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

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

@@ -1,6 +1,15 @@
+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 { DEFAULT_ACTION_POLICY } from "../../decorators/realtimeDecorators.js";
+import { USER_CHANNEL_DECLARATION, declarationOf, policyDeclarationsDefect, resolveDeclaredPolicies } from "./channelPolicyResolution.js";
 import { LoopbackBackplane } from "../backplane/LoopbackBackplane.js";
+import { isUnknownControlOrder, readControlOrder } from "../backplane/controlOrder.js";
 import { ANONYMOUS_REALTIME_TOKEN } from "./AnonymousRealtimeToken.js";
-import { IDENTITY_REFRESH_CLOSE_CODE, NODEFONY_CHANNEL_NAMESPACE, REVOCATION_REVALIDATE_MS, RevocationWatch, isPlatformChannel } 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
 /**
 * Seuil d'alerte slow-consumer (octets de `bufferedAmount`). Au-delà, la connexion
@@ -64,6 +73,110 @@ function channelFamily(channel) {
 	return i === -1 ? "*" : `${channel.slice(0, i + 1)}*`;
 }
 /**
+* Frame d'UNE publication diffusée à plusieurs abonnés, encodée **au plus une fois
+* par codec** (ADR-0022 §2) : un canal suivi par des connexions texte et CBOR paie
+* deux encodages, jamais un par connexion. L'encodage est paresseux — un codec
+* qu'aucun abonné n'utilise ne coûte rien.
+*
+* Deux places suffisent : un hub sert au plus son codec texte et son codec
+* binaire. Un troisième codec reste servi, sans mise en cache.
+*/
+var ChannelFrame = class {
+	message;
+	codecA;
+	dataA;
+	codecB;
+	dataB;
+	claimedA;
+	claimedB;
+	/** @param message - la frame protocolaire, telle que rendue par le {@link ChannelFrameBuilder}. */
+	constructor(message) {
+		this.message = message;
+		this.codecA = null;
+		this.dataA = void 0;
+		this.codecB = null;
+		this.dataB = void 0;
+		this.claimedA = false;
+		this.claimedB = false;
+	}
+	/**
+	* Rend la frame encodée pour un codec, en l'encodant à la première demande.
+	*
+	* @param codec - le codec de la connexion qui va l'écrire.
+	* @returns la trame à écrire telle quelle, ou `undefined` si la frame n'est pas
+	*   encodable : l'abonné qui en {@link ChannelFrame.claimFailure | réclame}
+	*   l'échec reprend son chemin habituel, qui porte le filet (journal).
+	*/
+	encodeFor(codec) {
+		if (codec === this.codecA) return this.dataA;
+		if (codec === this.codecB) return this.dataB;
+		let data;
+		try {
+			data = codec.encode(this.message);
+		} catch {
+			data = void 0;
+		}
+		if (this.codecA === null) {
+			this.codecA = codec;
+			this.dataA = data;
+		} else if (this.codecB === null) {
+			this.codecB = codec;
+			this.dataB = data;
+		}
+		return data;
+	}
+	/**
+	* Réclame l'échec d'encodage de cette frame pour un codec : `true` au PREMIER
+	* abonné qui le demande, `false` ensuite.
+	*
+	* Un seul abonné reprend alors son chemin habituel, dont le filet journalise
+	* l'échec ; les autres sautent la trame, qu'ils ne pourraient pas encoder non
+	* plus. Sans cela, une charge non encodable — un `$bytes` forgé par un client,
+	* une valeur cyclique — coûtait un encodage et une ligne de journal PAR abonné.
+	* Un codec hors des deux places réclame à chaque fois : il n'est pas retenu.
+	*
+	* @param codec - le codec dont {@link ChannelFrame.encodeFor} a rendu `undefined`.
+	* @returns `true` si l'appelant doit dire l'échec.
+	*/
+	claimFailure(codec) {
+		if (codec === this.codecA) {
+			if (this.claimedA) return false;
+			this.claimedA = true;
+			return true;
+		}
+		if (codec === this.codecB) {
+			if (this.claimedB) return false;
+			this.claimedB = true;
+			return true;
+		}
+		return true;
+	}
+};
+/**
+* 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).
 *
 * Élève le realtime serveur du modèle **per-connexion** (chaque connexion son propre
@@ -92,17 +205,49 @@ function channelFamily(channel) {
 */
 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;
+	#closedMessagesSent = 0;
+	#closedDropped = 0;
+	#closedBinaryDiscarded = 0;
+	#closedMalformedDiscarded = 0;
 	#inboundTotal = 0;
 	#ingressRejectedTotal = 0;
+	#ingressUnknownDiscardedTotal = 0;
+	#localOnlyTotal = 0;
 	#systemFloorDeniedTotal = 0;
 	#notice = null;
 	#noticed = null;
 	#connections = null;
 	#revocation = new RevocationWatch({
 		isValid: (entry) => entry.token.isValid?.(),
-		revoke: (entry) => entry.close(4001, "session revoked"),
+		status: (entry) => entry.token.status?.(),
+		revoke: (entry, status) => status === "expired" ? entry.close(TOKEN_EXPIRED_CLOSE_CODE, "token expired") : entry.close(IDENTITY_DEAD_CLOSE_CODE, "session revoked"),
 		identityOf: (entry) => entry.token.getUserIdentifier(),
 		refresh: (entry) => entry.close(IDENTITY_REFRESH_CLOSE_CODE, "identity changed")
 	});
@@ -111,7 +256,16 @@ var RealtimeHub = class RealtimeHub {
 	#peerTokens = null;
 	#frameAuthorizer = null;
 	#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.
@@ -133,6 +287,14 @@ var RealtimeHub = class RealtimeHub {
 	#originGuard = null;
 	#maxChannelsPerConnection = 256;
 	#slowConsumerBytes = SLOW_CONSUMER_BYTES;
+	#frameCodecs = frameCodecSet();
+	#busBytes = false;
+	/**
+	* Budget des admissions de l'exemplaire (appels d'`allow` en vol, coupe-circuit,
+	* `allowTimedOutTotal`/`allowSaturatedTotal`) — partagé par les files de toutes
+	* les connexions. Bornes posées par {@link setAdmissionLimits} au boot.
+	*/
+	admissionBudget = new AdmissionBudget();
 	#broadcastPrefixes = null;
 	/**
 	* Abonnement demandé par une **connexion cliente** — même chose que
@@ -148,9 +310,11 @@ var RealtimeHub = class RealtimeHub {
 	* sécurité en pose un, c'est lui qui décide (avec les rôles, ce que le hub ne
 	* sait pas faire) et le plancher s'efface.
 	*
+	* @param member - la connexion qui s'abonne : inscrite au registre du canal,
+	*   elle devient un membre identifiable ({@link channelMembers}).
 	* @returns `true` si abonné, `false` si canal inconnu ou fermé par le plancher.
 	*/
-	subscribeClient(channel, sink, factory, serialize) {
+	subscribeClient(channel, sink, factory, buildFrame, member) {
 		if (channel.includes("*")) {
 			this.#notifyOnce("wildcard-channel", `abonnement REFUSÉ au canal "${channel}" : le caractère « * » est réservé aux MOTIFS de politique et n'a pas de sens dans un nom de canal servi. Un motif garde une famille, il ne se souscrit pas.`);
 			return false;
@@ -160,7 +324,117 @@ var RealtimeHub = class RealtimeHub {
 			this.#notifyOnce("system-floor", `canal de plateforme "${channel}" REFUSÉ : aucun module de sécurité n'est chargé, donc aucune identité ne peut être vérifiée. Les namespaces réservés (${RESERVED_SYSTEM_PREFIXES.join(" ")}) sont fermés à toutes les connexions. Deux causes possibles : la sécurité n'est pas installée (charger @nodefony/security et déclarer une zone protégée), ou ce canal applicatif porte par erreur un préfixe réservé — dans ce cas, le renommer suffit.`);
 			return false;
 		}
-		return this.subscribe(channel, sink, factory, serialize);
+		if (!this.subscribe(channel, sink, factory, buildFrame)) return false;
+		if (member !== void 0) {
+			const st = this.#channels?.get(channel);
+			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
@@ -175,13 +449,13 @@ var RealtimeHub = class RealtimeHub {
 	*
 	* @returns `true` si abonné, `false` si canal inconnu (`factory` a renvoyé `null`).
 	*/
-	subscribe(channel, sink, factory, serialize) {
+	subscribe(channel, sink, factory, buildFrame) {
 		const channels = this.#channels ??= /* @__PURE__ */ new Map();
 		let st = channels.get(channel);
 		if (st) {
 			if (st.owned) {
 				st.sinks.add(sink);
-				if (st.serialize === null && serialize !== void 0) st.serialize = serialize;
+				if (st.buildFrame === null && buildFrame !== void 0) st.buildFrame = buildFrame;
 				return true;
 			}
 			st.sinks.add(sink);
@@ -192,14 +466,16 @@ var RealtimeHub = class RealtimeHub {
 			}
 			st.dispose = dispose;
 			st.owned = true;
-			if (serialize !== void 0) st.serialize = serialize;
+			if (buildFrame !== void 0) st.buildFrame = buildFrame;
 			return true;
 		}
 		st = {
 			dispose: null,
 			owned: false,
-			sinks: /* @__PURE__ */ new Set([sink]),
-			serialize: serialize ?? null,
+			sinks: singleSink(sink),
+			members: null,
+			presence: null,
+			buildFrame: buildFrame ?? null,
 			messages: 0,
 			forward: this.#isBroadcast(channel)
 		};
@@ -237,8 +513,10 @@ var RealtimeHub = class RealtimeHub {
 		channels.set(channel, {
 			dispose: null,
 			owned: false,
-			sinks: /* @__PURE__ */ new Set([sink]),
-			serialize: null,
+			sinks: singleSink(sink),
+			members: null,
+			presence: null,
+			buildFrame: null,
 			messages: 0,
 			forward: this.#isBroadcast(channel)
 		});
@@ -255,11 +533,12 @@ 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);
-		return sys ? sys(channel, publishFn) : null;
+		if (sys) return sys(channel, publishFn);
+		return channel.startsWith(USER_CHANNEL_PREFIX) ? USER_CHANNEL_DISPOSE : null;
 	}
 	/**
 	* Désabonne une connexion d'un canal. Au **dernier** abonné, `dispose()` le provider
@@ -270,14 +549,356 @@ 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
+	* des membres. Chemin froid : une copie à chaque appel.
+	*
+	* @param channel - nom exact du canal.
+	* @returns les membres de ce pod, vide si le canal n'en a aucun ici.
+	*/
+	channelMembers(channel) {
+		const members = this.#channels?.get(channel)?.members;
+		return members == null ? [] : Array.from(members.values());
+	}
+	/**
+	* Abonne d'office une connexion à un canal — **local à ce pod** : seule une connexion acceptée par ce processus peut l'être.
+	*
+	* Même porte qu'un `subscribe` du client (ADR-0022 §6 décision 2) : la
+	* politique fixe du canal (rôles, scopes, plancher de plateforme), puis sa
+	* règle `allow` s'il en déclare une. Un refus n'abonne pas, et seul
+	* l'appelant l'apprend ; jamais un abonnement qui contourne `allow` — le
+	* client rejoue ses abonnements à chaque reconnexion, et ce rejeu passe par
+	* `allow` : l'application écrit donc l'appartenance là où `allow` la lit.
+	*
+	* Le client est notifié par `realtime:subscribed { channel, imposed: true }`
+	* et inscrit le canal dans ses abonnements ; il peut le quitter.
+	*
+	* Plusieurs exemplaires : la requête qui décide doit atteindre le processus
+	* qui tient la socket — la passer par la socket elle-même (`@RealtimeInbound`,
+	* qui reçoit la connexion), ou faire autoriser l'entrée par `allow` (registre
+	* partagé) et laisser le navigateur s'abonner.
+	*
+	* @param channel - nom exact du canal.
+	* @param connection - la connexion à abonner (reçue par un gestionnaire `@RealtimeInbound`, ou lue dans {@link channelMembers}).
+	* @returns `true` une fois l'abonnement acquitté ; `false` si refusé, si la
+	*   connexion est fermée ou inconnue de ce processus, ou si le client s'en
+	*   désabonne avant le verdict.
+	*/
+	subscribeConnection(channel, connection) {
+		if (!(connection instanceof RealtimeConnection)) return Promise.resolve(false);
+		return connection.impose(channel);
+	}
+	/**
+	* Retire une connexion d'un canal — **local à ce pod** ; elle reçoit `realtime:closed { reason: "evicted" }`.
+	*
+	* ⚠️ **Éjecter coupe la connexion du canal, seul `allow` exclut**
+	* (ADR-0022 §6 décision 3). Le client ne rejoue pas un canal dont il a été
+	* éjecté, mais c'est une politesse : une page rechargée refait `subscribe`.
+	* Sur un canal à `allow`, l'éjecté revient si l'application n'a pas retiré
+	* l'appartenance là où `allow` la lit ; sur un canal sans `allow`, sa
+	* politique fixe le laisse rentrer.
+	*
+	* @param channel - nom exact du canal.
+	* @param connection - la connexion à retirer.
+	* @returns `false` si la connexion n'est pas membre du canal, est fermée, ou
+	*   inconnue de ce processus — jamais un geste muet.
+	*/
+	evictConnection(channel, connection) {
+		return connection instanceof RealtimeConnection && connection.end(channel, "evicted");
+	}
+	/**
+	* Termine un canal pour tous ses membres, **sur tous les serveurs** : chacun reçoit `realtime:closed { reason: "ended" }`, et le producteur est libéré.
+	*
+	* **Traverse les pods** : avec un backplane branché, l'ordre part sur le bus
+	* (`PLATFORM_BUS_CHANNELS.control`, scellé comme toute publication) et chaque
+	* serveur l'applique à SES membres. Livraison « au plus une fois » du bus :
+	* un pod qui manque l'ordre, ou qui démarre après, est rattrapé par la
+	* fabrique, qui rend `null` pour une instance terminée. Un canal de la
+	* plateforme (`nodefony:`) reste local — il décrit un pod, pas une partie.
+	*
+	* Les écouteurs du serveur (`listen`) restent inscrits, sur un canal redevenu
+	* PASSIF : le prochain `subscribe` d'un client rejoue la fabrique, et c'est
+	* elle qui tranche. **Seule la fabrique clôt un canal** (ADR-0021 S4) — le
+	* hub ne garde aucune marque « fermé » : une fabrique qui rend encore un
+	* producteur pour ce nom le rouvre. D'où la règle d'écriture d'un canal à
+	* durée de vie : son nom porte l'identifiant de l'instance
+	* (`room:42:<partie>`), et la fabrique rend `null` pour une instance terminée.
+	*
+	* @param channel - nom exact du canal.
+	* @returns le nombre de membres de CE pod à qui la fin a été notifiée — les
+	*   autres serveurs l'appliquent sans compte rendu.
+	*/
+	closeChannel(channel) {
+		this.#sendControl({
+			op: "close",
+			channel
+		});
+		return this.#closeLocal(channel);
+	}
+	/**
+	* Éjecte un compte d'un canal, **sur tous les serveurs** : chacune de ses connexions membres reçoit `realtime:closed { reason: "evicted" }`.
+	*
+	* Tous les onglets du compte sont visés, où qu'ils soient servis ; l'ordre
+	* traverse les pods comme {@link closeChannel}. ⚠️ **Éjecter coupe, seul
+	* `allow` exclut** (ADR-0022 §6 décision 3) : pour que le compte ne revienne
+	* pas, l'application retire l'appartenance là où `allow` la lit.
+	*
+	* ⚠️ Sur un bus PARTAGÉ, un tiers qui y écrit peut rejouer un ordre capté :
+	* sur un canal durable, il recouperait le compte à chaque réadmission (risque
+	* accepté et borné, ADR-0022 §6 d4) — bus privé exigé ; changer le secret du
+	* bus rend caducs les ordres déjà captés.
+	*
+	* @param channel - nom exact du canal.
+	* @param user - identifiant du compte (`IRealtimeConnection.userId`).
+	* @returns le nombre de connexions de CE pod éjectées. Un nom vide ou de plus
+	*   de 1 024 caractères n'éjecte rien et ne part pas sur le bus.
+	*/
+	evictUser(channel, user) {
+		if (!this.#sendControl({
+			op: "evictUser",
+			channel,
+			user
+		})) return 0;
+		return this.#evictUserLocal(channel, user);
+	}
+	/**
+	* Publie un ordre de contrôle aux autres serveurs — s'il y a un bus et que l'ordre a une forme que ses pairs acceptent.
+	*
+	* @returns `false` si l'ordre est mal formé (rien n'est appliqué nulle part).
+	*/
+	#sendControl(order) {
+		if (readControlOrder(order) === null) return false;
+		if (this.#backplane !== null && !isReservedSystemChannel(order.channel)) this.#backplane.publish(PLATFORM_BUS_CHANNELS.control, order);
+		return true;
+	}
+	/** 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) {
+			if (isUnknownControlOrder(payload)) this.#discardUnknownFromBus("order");
+			else this.#ingressRejectedTotal += 1;
+			return;
+		}
+		if (isReservedSystemChannel(order.channel)) {
+			this.#ingressRejectedTotal += 1;
+			return;
+		}
+		if (order.op === "close") this.#closeLocal(order.channel);
+		else this.#evictUserLocal(order.channel, order.user);
+	}
+	/** Éjecte de `channel` les connexions de CE pod dont le compte est `user`. */
+	#evictUserLocal(channel, user) {
+		const members = this.#channels?.get(channel)?.members;
+		if (members == null) return 0;
+		let evicted = 0;
+		for (const member of members.values()) if (member.userId === user && member.end(channel, "evicted")) evicted += 1;
+		return evicted;
+	}
+	/** Termine `channel` pour les membres de CE pod et libère son producteur. */
+	#closeLocal(channel) {
+		const st = this.#channels?.get(channel);
+		if (st === void 0) return 0;
+		let ended = 0;
+		const members = st.members;
+		if (members !== null) {
+			for (const member of members.values()) if (member.end(channel, "ended")) ended += 1;
+		}
+		const rest = this.#channels?.get(channel);
+		if (rest?.owned === true) {
+			try {
+				rest.dispose?.();
+			} catch {}
+			rest.dispose = null;
+			rest.owned = false;
+		}
+		return ended;
+	}
+	/**
 	* Publie une charge sur un canal : **fan-out local** **+** propagation conditionnelle
 	* au {@link IBackplane} (autres workers/pods). C'est le point d'entrée des providers
 	* locaux (tickers, listeners) ET de tout code serveur.
@@ -290,12 +911,65 @@ var RealtimeHub = class RealtimeHub {
 	*
 	* Anti-boucle : un message **reçu** du backplane ne repasse PAS par ici (il appelle
 	* `publishLocal` directement) → aucune ré-émission cross-process, pas de tempête.
+	*
+	* @param payload - objet, tableau ou octets ; omise = signal sans charge.
+	* @throws TypeError si la charge est un scalaire ou `null` ({@link isRealtimePayload},
+	*   ADR-0021 S1) — un scalaire se publie dans un objet (`{ value }`).
 	*/
 	publish(channel, payload) {
+		if (!isRealtimePayload(payload)) throw realtimePayloadError(channel, payload);
 		const st = this.#channels?.get(channel);
 		if (st !== void 0) this.#fanout(st, payload);
 		if (this.#backplane === null) return;
-		if (st !== void 0 ? st.forward : this.#isBroadcast(channel)) this.#backplane.publish(channel, payload);
+		if (!(st !== void 0 ? st.forward : this.#isBroadcast(channel))) {
+			this.#localOnlyTotal += 1;
+			return;
+		}
+		if (this.#busRefuses(payload)) {
+			this.#notifyOnce("backplane:binary", this.#busBytes ? `realtime: le canal « ${channel} » publie des octets hors \`Uint8Array\` — le bus entre serveurs ne porte que des \`Uint8Array\` : seuls les abonnés de ce serveur les reçoivent` : `realtime: le canal « ${channel} » publie des octets — sans codec binaire côté serveur (\`codec: "cbor"\`) ou sans backplane qui les porte, ils ne traversent pas le bus entre serveurs (ils y seraient déformés) : seuls les abonnés de ce serveur les reçoivent`);
+			return;
+		}
+		this.#backplane.publish(channel, payload);
+	}
+	/**
+	* Le bus refuse-t-il cette charge ? Un `Uint8Array` voyage quand le bus porte
+	* les octets ({@link #busBytes}) ; toute autre vue binaire, jamais.
+	*
+	* Sans bus binaire, le parcours en profondeur n'est payé que si un codec
+	* binaire est posé — seul cas où une charge à octets est légitime ; sans codec,
+	* seule la charge de premier niveau est examinée, comme avant le codec.
+	*/
+	#busRefuses(payload) {
+		const topLevel = ArrayBuffer.isView(payload) || payload instanceof ArrayBuffer;
+		if (this.#busBytes) return topLevel && !(payload instanceof Uint8Array);
+		if (this.#frameCodecs.binary !== null) return topLevel || containsBytes(payload);
+		return topLevel;
+	}
+	/** Arme les octets sur le bus quand codec binaire ET backplane sont posés, dans n'importe quel ordre. */
+	#armBusBytes() {
+		const codec = this.#frameCodecs.binary;
+		this.#busBytes = codec !== null && this.#backplane !== null && this.#backplane.enableBytes?.(codec) === true;
+	}
+	/**
+	* Livre une charge à UNE identité — tous ses onglets, tous les serveurs, et personne d'autre (ADR-0022 §6, D1).
+	*
+	* Publie sur son canal personnel `user:<userId>` : seuls les onglets de cette
+	* identité ont pu s'y abonner (politique intégrée, admission par égalité de
+	* chaîne), et le préfixe traverse le bus dès qu'un bus est branché. Rien à
+	* déclarer côté application. Personne n'écoute ? La charge est perdue, sans
+	* erreur : c'est une diffusion, pas une boîte aux lettres.
+	*
+	* @param userId - l'`id` STABLE du compte (`RealtimeIdentity.id`), jamais le
+	*   login.
+	* @param payload - objet, tableau ou octets ; omise = signal sans charge.
+	* @throws TypeError si la charge est un scalaire ou `null` (cf {@link publish}).
+	*/
+	publishToUser(userId, payload) {
+		this.publish(userChannel(userId), payload);
+	}
+	/** Préfixes déclarés diffusables entre serveurs, dans l'ordre de déclaration — lu par la ligne de démarrage. */
+	broadcastPrefixes() {
+		return this.#broadcastPrefixes ?? [];
 	}
 	/**
 	* Fan-out d'une charge aux **seuls abonnés locaux** d'un canal (process courant).
@@ -313,14 +987,14 @@ var RealtimeHub = class RealtimeHub {
 		this.#publishTotal += 1;
 		st.messages += 1;
 		this.#fanoutTotal += st.sinks.size;
-		let raw;
-		if (st.serialize !== null && st.sinks.size > 1) try {
-			raw = st.serialize(payload);
+		let frame;
+		if (st.buildFrame !== null && st.sinks.size > 1) try {
+			frame = new ChannelFrame(st.buildFrame(payload));
 		} catch {
-			raw = void 0;
+			frame = void 0;
 		}
 		for (const sink of st.sinks) try {
-			sink(payload, raw);
+			sink(payload, frame);
 		} catch {}
 	}
 	/**
@@ -343,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;
 	}
 	/**
@@ -365,7 +1048,12 @@ 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();
 		const started = backplane.start();
 		if (started instanceof Promise) started.catch((err) => {
 			if (this.#notice === null) throw err instanceof Error ? err : new Error(String(err));
@@ -390,14 +1078,54 @@ var RealtimeHub = class RealtimeHub {
 	* nominale : un pair légitime n'émet que des canaux broadcast (`publish` filtre à
 	* la source), et un canal ne peut avoir d'abonné local que si l'endpoint qui le
 	* sert a été handshaké — donc ses préfixes déjà déclarés.
+	*
+	* 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;
@@ -414,9 +1142,18 @@ var RealtimeHub = class RealtimeHub {
 	registerConnection(conn) {
 		(this.#connections ??= /* @__PURE__ */ new Set()).add(conn);
 	}
-	/** Retire une connexion du registre de la sonde (au close). No-op si absente. */
+	/**
+	* Retire une connexion du registre de la sonde (au close) et verse ses cumuls à
+	* ceux des connexions fermées : les totaux de {@link probe} restent monotones.
+	* No-op si absente — une double sortie ne compte pas deux fois.
+	*/
 	unregisterConnection(conn) {
-		this.#connections?.delete(conn);
+		if (this.#connections?.delete(conn) !== true) return;
+		this.#closedBytesSent += conn.bytesSent;
+		this.#closedMessagesSent += conn.messagesSent;
+		this.#closedDropped += conn.dropped;
+		this.#closedBinaryDiscarded += conn.binaryDiscarded ?? 0;
+		this.#closedMalformedDiscarded += conn.malformedDiscarded ?? 0;
 	}
 	/**
 	* Inscrit une connexion à identité RÉVOCABLE au registre de
@@ -479,22 +1216,32 @@ var RealtimeHub = class RealtimeHub {
 			messages: st.messages
 		});
 		let connectionCount = 0;
-		let bytesSentTotal = 0;
-		let messagesSentTotal = 0;
+		let bytesSentTotal = this.#closedBytesSent;
+		let messagesSentTotal = this.#closedMessagesSent;
 		let maxBufferedAmount = 0;
 		let totalBufferedAmount = 0;
 		let slowConsumers = 0;
-		let drops = 0;
+		let drops = this.#closedDropped;
+		let binaryDiscardedTotal = this.#closedBinaryDiscarded;
+		let malformedDiscardedTotal = this.#closedMalformedDiscarded;
 		if (this.#connections) for (const c of this.#connections) {
 			connectionCount += 1;
 			bytesSentTotal += c.bytesSent;
 			messagesSentTotal += c.messagesSent;
 			drops += c.dropped;
+			binaryDiscardedTotal += c.binaryDiscarded ?? 0;
+			malformedDiscardedTotal += c.malformedDiscarded ?? 0;
 			const buf = c.bufferedAmount;
 			if (buf > maxBufferedAmount) maxBufferedAmount = buf;
 			totalBufferedAmount += buf;
 			if (buf >= this.#slowConsumerBytes) slowConsumers += 1;
 		}
+		const backplane = this.#backplane?.describe() ?? {
+			driver: LoopbackBackplane.driver,
+			kind: "local",
+			originId: String(process.pid),
+			crossPod: false
+		};
 		return {
 			ts: Date.now(),
 			channels,
@@ -503,7 +1250,16 @@ 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,
+			frameRateRejectedTotal: frameRateRejectedTotal(),
+			allowTimedOutTotal: this.admissionBudget.timedOutTotal,
+			allowSaturatedTotal: this.admissionBudget.saturatedTotal,
+			authenticateTimedOutTotal: this.admissionBudget.authenticateTimedOutTotal,
+			binaryDiscardedTotal,
+			malformedDiscardedTotal,
 			connectionCount,
 			bytesSentTotal,
 			messagesSentTotal,
@@ -513,12 +1269,38 @@ var RealtimeHub = class RealtimeHub {
 				slowConsumers,
 				drops
 			},
-			backplane: this.#backplane?.describe() ?? {
-				driver: LoopbackBackplane.driver,
-				kind: "local",
-				originId: String(process.pid),
-				crossPod: false
-			}
+			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. */
@@ -593,6 +1375,39 @@ var RealtimeHub = class RealtimeHub {
 		this.#slowConsumerBytes = bytes;
 	}
 	/**
+	* Les codecs de frame du serveur (ADR-0022 §2) : le texte, et le codec binaire
+	* accordé aux clients qui l'offrent — `null` tant que la configuration n'en
+	* active aucun. Lu une fois par connexion, au handshake, jamais par trame.
+	*/
+	get frameCodecs() {
+		return this.#frameCodecs;
+	}
+	/**
+	* Pose le codec binaire du serveur — 1× au boot par `RealtimeService.init()`,
+	* depuis la clé `codec` de la configuration. Sans argument : texte seul.
+	*
+	* @param codec - le codec activé (`CBOR_FRAME_CODEC` de `nodefony/cbor`).
+	*/
+	setFrameCodec(codec) {
+		this.#frameCodecs = frameCodecSet(codec);
+		this.#armBusBytes();
+	}
+	/**
+	* Le codec des connexions texte — celui qu'emprunte aussi le REST du plan
+	* d'administration, pour qu'une valeur lue par `GET` soit celle que la socket
+	* livre (#618 D9). Avec un codec binaire activé, c'est le JSON à convention
+	* d'octets ; sinon le JSON natif.
+	*/
+	get textFrameCodec() {
+		return this.#frameCodecs.text;
+	}
+	/**
+	* Pose les bornes des admissions (`authenticateTimeoutMs`, `allowTimeoutMs`, `maxPendingAllowsPerConnection`, `maxPendingAllowsTotal`) — 1× au boot par `RealtimeService.init()`.
+	*/
+	setAdmissionLimits(limits) {
+		this.admissionBudget.configure(limits);
+	}
+	/**
 	* Associe un token au peer (posé par `RealtimeController.onHandshake()` après
 	* succès `authenticator.authenticate()` ou fallback anonyme). Lazy alloc de
 	* la `WeakMap` au 1ᵉʳ appel (0 coût si aucun authenticator enregistré).
@@ -612,9 +1427,18 @@ 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;
 	}
 	/**
@@ -678,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 :
 	*
@@ -691,21 +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 `*`.
-	* @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.
+	* @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, 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}.
 	*/
-	registerChannelPolicy(name, policy) {
+	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}`);
+		};
+		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, policy);
+		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, policy);
+		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.
@@ -717,52 +1641,90 @@ var RealtimeHub = class RealtimeHub {
 	* de déclaration, et on le DIT plutôt que d'exposer un chemin coûteux à ce
 	* qu'un client peut nommer.
 	*/
-	static MAX_PATTERN_WILDCARDS = 3;
+	static MAX_PATTERN_WILDCARDS = MAX_CHANNEL_PATTERN_WILDCARDS;
 	/**
-	* Compile un motif et l'insère à son rang de spécificité.
+	* 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.
+	*/
+	resolveChannelPolicy(name) {
+		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.
 	*
-	* 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.
+	* @param name - nom du canal, de la méthode entrante ou de l'action.
 	*/
-	#registerChannelPolicyPattern(source, policy) {
-		const etoiles = source.split("*").length - 1;
-		if (etoiles > RealtimeHub.MAX_PATTERN_WILDCARDS) {
-			this.#notifyOnce(`pattern-too-broad:${source}`, `le motif de politique "${source}" porte ${etoiles} 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 echappe = source.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-		const re = new RegExp(`^${echappe.split("\\*").join(".*")}$`, "u");
-		const weight = source.split("*").join("").length;
-		const policies = this.#channelPolicyPatterns ??= [];
-		const existing = policies.findIndex((p) => p.source === source);
-		const policyEntry = {
-			source,
-			re,
-			weight,
+	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
-		};
-		if (existing >= 0) {
-			policies[existing] = policyEntry;
-			return;
-		}
-		const rang = policies.findIndex((p) => p.weight < weight);
-		if (rang < 0) policies.push(policyEntry);
-		else policies.splice(rang, 0, policyEntry);
+		});
+		return null;
 	}
 	/**
-	* 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.
+	* 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
+	* plus spécifique) : la règle suit TOUJOURS la politique qui s'applique.
 	*/
-	resolveChannelPolicy(name) {
-		const exact = this.#channelPolicies?.get(name);
-		if (exact !== void 0) return exact;
+	resolveChannelAdmission(name) {
+		return this.#resolvePolicyEntry(name)?.admission ?? null;
+	}
+	/**
+	* Les politiques de cette classe de contrôleur sont-elles déjà inscrites ? Une poignée de main n'en paie que ce `has`.
+	*
+	* @param owner - le constructeur du contrôleur.
+	*/
+	hasPolicyOwner(owner) {
+		return this.#policyOwners?.has(owner) === true;
+	}
+	/**
+	* Marque les politiques de cette classe comme inscrites — APRÈS l'inscription réussie, jamais avant : une politique refusée doit l'être de nouveau à la poignée de main suivante, pas laisser le canal ouvert.
+	*
+	* @param owner - le constructeur du contrôleur.
+	*/
+	addPolicyOwner(owner) {
+		(this.#policyOwners ??= /* @__PURE__ */ new WeakSet()).add(owner);
+	}
+	/**
+	* 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 merged = this.#channelPolicies?.get(name);
+		if (merged !== void 0) return merged;
 		const patterns = this.#channelPolicyPatterns;
-		if (patterns === null) return null;
-		for (const pattern of patterns) if (pattern.re.test(name)) return pattern.policy;
-		return null;
+		if (patterns === null) return name.startsWith(USER_CHANNEL_PREFIX) ? USER_CHANNEL_DECLARATION.self : null;
+		return resolveDeclaredPolicies(name, void 0, patterns);
+	}
+	/**
+	* Ce nom EXACT porte-t-il une déclaration — motifs ignorés ?
+	*
+	* @param name - nom d'action ou de canal.
+	*/
+	hasExactChannelPolicy(name) {
+		return this.#policyDeclarations?.has(name) === true;
 	}
 	/** Des politiques de canal sont-elles déclarées (au moins une) ? */
 	hasChannelPolicies() {
@@ -773,14 +1735,14 @@ var RealtimeHub = class RealtimeHub {
 	* DYNAMIQUE n'est couvert par aucune politique déclarée, alors que d'autres
 	* canaux du module en portent une.
 	*
-	* Le registre des politiques est indexé par nom **EXACT** : `@RealtimeChannel`
-	* déclare `"chat:room"`, mais un canal dérivé (`chat:room:1000` — cadence,
-	* forage, suffixe) est servi par la fabrique dynamique et **ne matche pas**.
-	* L'auteur croit alors son canal gardé ; il ne l'est pas, et rien ne le lui
-	* dit. C'est ce silence qu'on ferme ici — et depuis qu'une politique peut se
-	* déclarer par MOTIF (`chat:room:*`), cet avertissement ne parle plus que des
-	* canaux qu'aucun motif ne couvre : il désigne un vrai trou, pas une limite
-	* de l'outil.
+	* Le registre des politiques lit le nom **EXACT**, puis les **MOTIFS**
+	* déclarés ({@link resolveChannelPolicy}) : `@RealtimeChannel` déclare
+	* `"chat:room"`, mais un canal dérivé (`chat:room:1000` — cadence, forage,
+	* suffixe) servi par la fabrique dynamique ne matche ce nom que si un motif
+	* (`chat:room:*`) le couvre. Sans motif, l'auteur croit son canal gardé ; il
+	* ne l'est pas, et rien ne le lui dit. C'est ce silence qu'on ferme ici :
+	* l'avertissement ne parle que des canaux qu'aucun motif ne couvre — un vrai
+	* trou, pas une limite de l'outil.
 	*
 	* Appelé par le contrôleur, seul à savoir par quelle voie le canal a été
 	* servi. Muet si aucune politique n'est déclarée (module aux canaux libres :
@@ -810,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.
@@ -831,9 +1783,72 @@ 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) {
-		if (this.#frameAuthorizer === null) return true;
-		return this.#frameAuthorizer(frame, this.getTokenForPeer(peer));
+		const authorizer = this.#frameAuthorizer;
+		if (authorizer === null) return true;
+		try {
+			return authorizer(frame, this.getTokenForPeer(peer)) === true;
+		} catch (e) {
+			this.#notifyOnce("frame-authorizer-threw", "le verrou des trames a levé une exception — trame refusée : " + (e instanceof Error ? e.message : String(e)));
+			return false;
+		}
+	}
+	/**
+	* Inscrit une connexion qui vient de retenir son premier « oui » du verrou.
+	*
+	* Appelé par `gateFrame`, jamais par trame chaude ; à équilibrer par
+	* {@link untrackRetainedVerdicts} à la fermeture.
+	*
+	* @param state - état de la connexion.
+	*/
+	trackRetainedVerdicts(state) {
+		(this.#retainers ??= /* @__PURE__ */ new Set()).add(state);
+	}
+	/**
+	* Retire une connexion fermée du registre des verdicts retenus.
+	*
+	* @param state - état de la connexion.
+	*/
+	untrackRetainedVerdicts(state) {
+		this.#retainers?.delete(state);
+	}
+	#dropRetainedVerdicts() {
+		const retainers = this.#retainers;
+		if (retainers === null) return;
+		for (const state of retainers) dropRetainedVerdicts(state);
+		this.#retainers = null;
 	}
 	/**
 	* Ce peer pourrait-il s'abonner à ce canal ? — même décision que `subscribe`,
@@ -849,11 +1864,17 @@ var RealtimeHub = class RealtimeHub {
 	* @returns `true` si un `subscribe` sur ce canal serait accepté.
 	*/
 	probeChannel(channel, peer) {
-		if (this.#channelProbe === null) return true;
-		return this.#channelProbe({
-			method: "subscribe",
-			params: { channel }
-		}, this.getTokenForPeer(peer));
+		const probe = this.#channelProbe;
+		if (probe === null) return true;
+		try {
+			return probe({
+				method: "subscribe",
+				params: { channel }
+			}, this.getTokenForPeer(peer));
+		} catch (e) {
+			this.#notifyOnce("channel-probe-threw", "la sonde des canaux annoncés a levé une exception — canal annoncé : " + (e instanceof Error ? e.message : String(e)));
+			return true;
+		}
 	}
 	/** Authenticators enregistrés (debug / tests). Lecture seule. */
 	get registeredAuthenticators() {
@@ -862,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?.();
@@ -875,16 +1908,31 @@ var RealtimeHub = class RealtimeHub {
 		this.#authenticators = null;
 		this.#peerTokens = null;
 		this.#frameAuthorizer = null;
+		this.#channelProbe = null;
+		this.#dropRetainedVerdicts();
 		this.#channelPolicies?.clear();
 		this.#channelPolicies = null;
 		this.#channelPolicyPatterns = null;
+		this.#policyOwners = null;
+		this.#policyClaims = null;
+		this.#policyDeclarations = null;
 		this.#originGuard = null;
 		this.#backplane = null;
+		this.#busBytes = false;
 		this.#publishTotal = 0;
 		this.#fanoutTotal = 0;
+		this.#closedBytesSent = 0;
+		this.#closedMessagesSent = 0;
+		this.#closedDropped = 0;
+		this.#closedBinaryDiscarded = 0;
+		this.#closedMalformedDiscarded = 0;
 		this.#inboundTotal = 0;
 		this.#ingressRejectedTotal = 0;
+		this.#ingressUnknownDiscardedTotal = 0;
+		this.#localOnlyTotal = 0;
 		this.#systemFloorDeniedTotal = 0;
+		this.admissionBudget.reset();
+		this.#frameCodecs = frameCodecSet();
 		this.#noticed = null;
 		this.#notice = null;
 	}
@@ -918,8 +1966,7 @@ function compileMatcher(m) {
 	};
 }
 let _hub = null;
-/** Renvoie le hub realtime du process (singleton lazy). */
 function getRealtimeHub() {
 	return _hub ??= new RealtimeHub();
 }
-export { RESERVED_SYSTEM_PREFIXES, REVOCATION_REVALIDATE_MS, RealtimeHub, RealtimeHub as default, SLOW_CONSUMER_BYTES, channelFamily, getRealtimeHub, isReservedSystemChannel };
+export { ChannelFrame, RESERVED_SYSTEM_PREFIXES, REVOCATION_REVALIDATE_MS, RealtimeHub, RealtimeHub as default, SLOW_CONSUMER_BYTES, channelFamily, getRealtimeHub, isReservedSystemChannel };