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

package/dist/nodefony/src/backplane/RedisBackplane.js

@@ -1,7 +1,8 @@
-import { isCallable, isRecord, isThenable } from "../guards.js";
 import resolveBackplaneOriginId from "./originId.js";
-import { openBackplaneEnvelope, sealBackplaneEnvelope } from "./envelope.js";
+import { isCallable, isRecord, isThenable } from "../guards.js";
+import { openBackplaneEnvelope, openBackplaneEnvelopeBytes, sealBackplaneEnvelope, sealBackplaneEnvelopeBytes } from "./envelope.js";
 import { BackplanePublishQueue } from "./publishQueue.js";
+import { containsBytes } from "nodefony";
 // nodefony/src/backplane/RedisBackplane.ts
 /**
 * BASE du canal Redis **dédié** transportant les enveloppes realtime entre pods.
@@ -28,22 +29,18 @@ function resolveRedisChannel(namespace) {
 	return namespace ? `${REDIS_RT_CHANNEL}:${namespace}` : REDIS_RT_CHANNEL;
 }
 /**
-* Adapte deux clients Redis (publisher + subscriber dédié) au seam
-* {@link IRedisBackplaneTransport}. SEUL point de contact avec la lib `redis` —
-* et même ici le couplage est **structurel** (aucun import). Le consommateur
-* branche typiquement les connexions du module `@nodefony/redis` :
-*
-* ```ts
-* const redis = kernel.get("redis"); // RedisService
-* const bp = new RedisBackplane(
-*   createRedisServiceTransport(redis.getClient("publish")!, redis.getClient("subscribe")!),
-* );
-* defineRealtimeConfig({ backplane: { driver: "redis" } }, { backplane: bp });
-* ```
+* Construit le **sujet binaire** du bus (ADR-0021 S6) : le canal texte suffixé du
+* protocole du codec. Un second sujet, versionné par son nom, que les exemplaires
+* plus anciens n'écoutent pas — le message texte n'est pas touché, et un codec
+* binaire d'un autre format aurait son propre sujet.
 *
-* Le listener Redis est conservé pour un `unsubscribe(channel, listener)` ciblé
-* (n'arrache pas d'éventuels autres abonnés du même client).
+* @param redisChannel - le canal texte effectif ({@link resolveRedisChannel}).
+* @param codec - le codec binaire du serveur.
+* @returns le nom du canal Redis qui porte les enveloppes binaires.
 */
+function resolveRedisBytesChannel(redisChannel, codec) {
+	return `${redisChannel}:${codec.protocol}`;
+}
 /**
 * Vrai si la valeur expose la surface d'un client Redis publisher — vérifié au
 * démarrage, sur le client que rend le service `redis`.
@@ -55,27 +52,77 @@ function isRedisPublisher(value) {
 function isRedisSubscriber(value) {
 	return isRecord(value) && isCallable(value.subscribe) && isCallable(value.unsubscribe);
 }
+/**
+* Vrai si la valeur expose la surface d'un client abonné capable du mode octets.
+*
+* La forme ne dit pas si le troisième argument est compris : ce garde vaut pour
+* le client que rend le service `redis` (node-redis, qui l'accepte). Un client qui
+* l'ignorerait livrerait du texte au sujet binaire — illisible pour le codec,
+* donc jeté, compté sous un secret (`sealRejectedTotal`), jamais réinjecté.
+*/
+function isRedisBytesSubscriber(value) {
+	return isRedisSubscriber(value);
+}
 /** Ramène l'acquittement d'une commande Redis au contrat du transport. */
 function settled(ack) {
 	return isThenable(ack) ? ack.then(() => void 0) : void 0;
 }
-function createRedisServiceTransport(publisher, subscriber) {
-	let listener = null;
-	return {
+/**
+* Adapte deux clients Redis (publisher + subscriber dédié) au seam
+* {@link IRedisBackplaneTransport}. SEUL point de contact avec la lib `redis` —
+* et même ici le couplage est **structurel** (aucun import). Le consommateur
+* branche typiquement les connexions du module `@nodefony/redis` :
+*
+* ```ts
+* const redis = kernel.get("redis"); // RedisService
+* const bp = new RedisBackplane(
+*   createRedisServiceTransport(redis.getClient("publish")!, redis.getClient("subscribe")!),
+* );
+* defineRealtimeConfig({ backplane: { driver: "redis" } }, { backplane: bp });
+* ```
+*
+* Chaque listener Redis est conservé, par canal, pour un `unsubscribe(channel,
+* listener)` ciblé (n'arrache pas d'éventuels autres abonnés du même client).
+*
+* @param publisher - connexion de publication.
+* @param subscriber - connexion d'abonnement dédiée.
+* @param bytesSubscriber - la MÊME connexion d'abonnement, vue en mode octets
+*   ({@link IRedisBytesSubscriber}) ; absente, le transport n'offre pas de sujet
+*   binaire et les octets restent sur le serveur qui les publie.
+* @returns le transport du {@link RedisBackplane}.
+*/
+function createRedisServiceTransport(publisher, subscriber, bytesSubscriber) {
+	const listeners = /* @__PURE__ */ new Map();
+	const transport = {
 		publish(channel, message) {
-			const ack = publisher.publish(channel, message);
+			const ack = publisher.publish(channel, typeof message === "string" ? message : Buffer.from(message.buffer, message.byteOffset, message.byteLength));
 			return isThenable(ack) ? ack : void 0;
 		},
 		subscribe(channel, onMessage) {
-			listener = (message) => onMessage(message);
-			return settled(subscriber.subscribe(channel, listener));
+			const fn = (message) => onMessage(message);
+			listeners.set(channel, {
+				bytes: false,
+				fn
+			});
+			return settled(subscriber.subscribe(channel, fn));
 		},
 		unsubscribe(channel) {
-			const current = listener;
-			listener = null;
-			return settled(current ? subscriber.unsubscribe(channel, current) : subscriber.unsubscribe(channel));
+			const current = listeners.get(channel);
+			listeners.delete(channel);
+			if (current === void 0) return settled(subscriber.unsubscribe(channel));
+			if (!current.bytes) return settled(subscriber.unsubscribe(channel, current.fn));
+			return settled(bytesSubscriber?.unsubscribe(channel, current.fn, true));
 		}
 	};
+	if (bytesSubscriber !== void 0) transport.subscribeBytes = (channel, onMessage) => {
+		const fn = (message) => onMessage(message);
+		listeners.set(channel, {
+			bytes: true,
+			fn
+		});
+		return settled(bytesSubscriber.subscribe(channel, fn, true));
+	};
+	return transport;
 }
 /**
 * Backplane **Redis pub/sub** (P13.5) — implémentation du port {@link IBackplane}
@@ -119,14 +166,23 @@ var RedisBackplane = class RedisBackplane {
 	#secret;
 	/** Borne mémoire des publications en vol (cf {@link BackplanePublishQueue}). */
 	#queue;
+	#notice;
+	/** Messages reçus dont le sceau est refusé alors qu'un secret est posé (monotone). */
+	#sealRejectedTotal = 0;
 	#handler = null;
 	#started = false;
+	/**
+	* Sujet binaire : son codec et son canal Redis ({@link resolveRedisBytesChannel}) ;
+	* `null` tant que {@link enableBytes} n'a pas armé les octets.
+	*/
+	#bytes = null;
 	constructor(transport, originId = resolveBackplaneOriginId(), redisChannel = REDIS_RT_CHANNEL, secret = null, options = {}) {
 		this.#transport = transport;
 		this.originId = originId;
 		this.#redisChannel = redisChannel;
 		this.#secret = secret;
-		this.#queue = new BackplanePublishQueue(options.maxQueueBytes ?? 8388608, options.onNotice ?? null);
+		this.#notice = options.onNotice ?? null;
+		this.#queue = new BackplanePublishQueue(options.maxQueueBytes ?? 8388608, this.#notice);
 	}
 	/**
 	* Abonne au canal Redis dédié. Idempotent (le flag est posé avant l'`await` →
@@ -135,7 +191,32 @@ var RedisBackplane = class RedisBackplane {
 	async start() {
 		if (this.#started) return;
 		this.#started = true;
-		await this.#transport.subscribe(this.#redisChannel, (raw) => this.#ingress(raw));
+		await Promise.all([this.#transport.subscribe(this.#redisChannel, (raw) => this.#ingress(raw)), this.#subscribeBytes()]);
+	}
+	/**
+	* Arme le sujet binaire (ADR-0021 S6) : les charges qui contiennent des octets
+	* partent en enveloppe encodée par `codec` sur un second canal Redis, et ce
+	* canal est écouté. Les charges sans octets gardent le sujet texte, intact pour
+	* les exemplaires plus anciens. Idempotent.
+	*
+	* @param codec - le codec binaire du serveur.
+	* @returns `false` si le transport ne sait pas s'abonner en octets.
+	*/
+	enableBytes(codec) {
+		if (this.#transport.subscribeBytes === void 0) return false;
+		if (this.#bytes !== null) return true;
+		this.#bytes = {
+			codec,
+			channel: resolveRedisBytesChannel(this.#redisChannel, codec)
+		};
+		if (this.#started) this.#subscribeBytes().catch((err) => this.#notice?.(`backplane : abonnement au sujet binaire en échec — les octets des autres exemplaires ne seront pas reçus (${err instanceof Error ? err.message : String(err)})`, "WARNING"));
+		return true;
+	}
+	/** Abonne le sujet binaire s'il est armé ; sinon rien. */
+	async #subscribeBytes() {
+		const bytes = this.#bytes;
+		if (bytes === null) return;
+		await this.#transport.subscribeBytes?.(bytes.channel, (raw) => this.#ingressBytes(raw, bytes.codec));
 	}
 	/**
 	* Propage une publication locale aux autres pods via Redis. NE refait PAS le
@@ -152,6 +233,12 @@ var RedisBackplane = class RedisBackplane {
 			payload,
 			originId: this.originId
 		};
+		const bytes = this.#bytes;
+		if (bytes !== null && containsBytes(payload)) {
+			const bin = sealBackplaneEnvelopeBytes(env, bytes.codec, this.#secret);
+			this.#queue.send(bin.byteLength, () => this.#transport.publish(bytes.channel, bin));
+			return;
+		}
 		const raw = sealBackplaneEnvelope(env, this.#secret);
 		this.#queue.send(Buffer.byteLength(raw), () => this.#transport.publish(this.#redisChannel, raw));
 	}
@@ -163,19 +250,42 @@ var RedisBackplane = class RedisBackplane {
 	* Ouverture d'enveloppe (parse + vérification du sceau) + anti-echo + délégation.
 	* Robuste par construction : un message malformé, non scellé alors qu'un secret
 	* est exigé, ou au sceau invalide, est **ignoré** — jamais réinjecté, jamais fatal.
+	* Sous un secret, chaque rejet est compté (`sealRejectedTotal`) et journalisé la
+	* première fois puis une fois sur cent (ADR-0021 S6) : une rotation du secret ou
+	* un producteur mal configuré ne perd plus de messages en silence.
 	*/
 	#ingress(raw) {
 		const msg = openBackplaneEnvelope(raw, this.#secret);
-		if (msg === null) return;
+		if (msg === null) {
+			if (this.#secret !== null) this.#sealRejected();
+			return;
+		}
+		if (msg.originId === this.originId) return;
+		this.#handler?.(msg);
+	}
+	/** Même tri que {@link #ingress}, sur le sujet binaire : décodage, sceau, anti-echo. */
+	#ingressBytes(raw, codec) {
+		const msg = openBackplaneEnvelopeBytes(raw, codec, this.#secret);
+		if (msg === null) {
+			if (this.#secret !== null) this.#sealRejected();
+			return;
+		}
 		if (msg.originId === this.originId) return;
 		this.#handler?.(msg);
 	}
+	/** Compte un sceau refusé ; annonce le premier, puis un sur cent (pas d'inondation du journal). */
+	#sealRejected() {
+		this.#sealRejectedTotal += 1;
+		const n = this.#sealRejectedTotal;
+		if (n !== 1 && n % 100 !== 0) return;
+		this.#notice?.(`backplane : ${n} message(s) reçu(s) au sceau refusé, JETÉS. Causes : rotation du secret en cours (des exemplaires n'ont pas le même NF_REALTIME_BACKPLANE_SECRET), producteur mal configuré, ou écriture tierce dans le bus. Compteur : sealRejectedTotal.`, "WARNING");
+	}
 	/** Désabonne du canal Redis et détache le handler. Idempotent. */
 	async stop() {
 		this.#handler = null;
 		if (!this.#started) return;
 		this.#started = false;
-		await this.#transport.unsubscribe(this.#redisChannel);
+		await Promise.all([this.#transport.unsubscribe(this.#redisChannel), this.#bytes !== null ? this.#transport.unsubscribe(this.#bytes.channel) : void 0]);
 	}
 	describe() {
 		return {
@@ -185,8 +295,10 @@ var RedisBackplane = class RedisBackplane {
 			crossPod: true,
 			channel: this.#redisChannel,
 			sealed: this.#secret !== null,
-			queue: this.#queue.describe()
+			...this.#secret !== null && { sealRejectedTotal: this.#sealRejectedTotal },
+			queue: this.#queue.describe(),
+			...this.#bytes !== null && { bytes: true }
 		};
 	}
 };
-export { REDIS_RT_CHANNEL, RedisBackplane, RedisBackplane as default, createRedisServiceTransport, isRedisPublisher, isRedisSubscriber, resolveRedisChannel };
+export { REDIS_RT_CHANNEL, RedisBackplane, RedisBackplane as default, createRedisServiceTransport, isRedisBytesSubscriber, isRedisPublisher, isRedisSubscriber, resolveRedisBytesChannel, resolveRedisChannel };

package/dist/nodefony/src/backplane/controlOrder.js

@@ -0,0 +1,57 @@
+import { ownField } from "nodefony";
+// nodefony/src/backplane/controlOrder.ts
+/**
+* Ordres de contrôle entre serveurs — la LISTE FERMÉE de ce qui circule sur le
+* canal `PLATFORM_BUS_CHANNELS.control` (ADR-0022 §6 décision 4).
+*
+* Un ordre ne fait qu'ENLEVER : terminer un canal, éjecter un compte d'un
+* canal. Aucun n'admet — seul `allow` fait entrer. Il voyage dans la charge
+* d'un message ordinaire du bus, donc sous le sceau de l'enveloppe
+* (`envelope.ts#sealBackplaneEnvelope`), sans champ neuf dans l'enveloppe ni
+* méthode neuve dans `IBackplane` : un driver tiers le transporte sans le savoir.
+*/
+/** Longueur maximale d'un champ texte d'un ordre (nom de canal, identifiant de compte). */
+const MAX_CONTROL_FIELD_LENGTH = 1024;
+function isBoundedText(value) {
+	return typeof value === "string" && value.length > 0 && value.length <= 1024;
+}
+/**
+* Lit un ordre de contrôle dans une charge venue du bus — `null` si la forme n'est pas celle d'un ordre connu.
+*
+* Une seule garde pour les deux bords : l'émetteur la passe avant de publier
+* (il n'émet jamais ce que ses pairs refuseraient), le récepteur avant
+* d'appliquer. Lecture par champs PROPRES (`ownField`) : une charge dont le
+* prototype porterait `op` ne passe pas. Un champ inconnu est toléré — c'est
+* ce qui laisse une version suivante ajouter un champ sans faire refuser ses
+* ordres pendant un déploiement progressif ; un champ CONNU de forme fausse
+* fait refuser l'ordre entier.
+*
+* @param payload - la charge du message reçu (forme inconnue).
+* @returns l'ordre, ou `null`.
+*/
+function readControlOrder(payload) {
+	const channel = ownField(payload, "channel");
+	if (!isBoundedText(channel)) return null;
+	const op = ownField(payload, "op");
+	if (op === "close") return {
+		op,
+		channel
+	};
+	if (op !== "evictUser") return null;
+	const user = ownField(payload, "user");
+	if (!isBoundedText(user)) return null;
+	const generation = ownField(payload, "generation");
+	if (generation === void 0) return {
+		op,
+		channel,
+		user
+	};
+	if (typeof generation !== "number" || !Number.isSafeInteger(generation) || generation < 0) return null;
+	return {
+		op,
+		channel,
+		user,
+		generation
+	};
+}
+export { MAX_CONTROL_FIELD_LENGTH, readControlOrder };

package/dist/nodefony/src/backplane/envelope.js

@@ -1,3 +1,4 @@
+import { ownField } from "nodefony";
 import { createHmac, timingSafeEqual } from "node:crypto";
 // nodefony/src/backplane/envelope.ts
 /**
@@ -25,10 +26,19 @@ import { createHmac, timingSafeEqual } from "node:crypto";
 * canal (`chat:` → `nodefony:audit`), ni substitution de charge.
 *
 * Hors portée (assumé, cf sémantique at-most-once du port) : le **rejeu**. Un
-* tiers qui lit le bus peut re-publier un message scellé intact ; l'effet se
-* limite à re-diffuser une charge déjà diffusée sur un canal déjà broadcast, que
-* le client realtime re-synchronise. Un anti-rejeu (horodatage + fenêtre) exigerait
-* des horloges alignées entre pods pour un gain nul face à ce modèle de menace.
+* tiers qui lit le bus peut re-publier un message scellé intact. Pour une
+* publication, l'effet se limite à re-diffuser une charge déjà diffusée sur un
+* canal déjà broadcast. Pour un **ordre** (fermer, éjecter), le rejeu RECOUPE —
+* l'effet reste soustractif, jamais une admission (ADR-0022 §6 d4). Une fin vise
+* un canal qui porte son instance (`room:42:<partie>`) : rejouée, elle ne désigne
+* plus rien de vivant. Une éjection vise `(canal, compte)` : rejouée sur un canal
+* DURABLE, elle recoupe le compte à chaque réadmission — risque accepté en 10.0,
+* borné (écrire sur le bus est requis ; changer le secret rend caducs les ordres
+* captés), parade réservée par le champ optionnel `generation` de l'ordre. Un
+* anti-rejeu par horodatage exigerait des horloges alignées entre pods.
+*
+* La forme signée est la re-sérialisation de la charge par le récepteur ; elle
+* n'est PAS promise comme contrat à un producteur écrit dans un autre langage.
 */
 /** Nom du champ portant le sceau dans l'enveloppe sérialisée. */
 const SEAL_FIELD = "sig";
@@ -66,9 +76,7 @@ function sealBackplaneEnvelope(msg, secret) {
 }
 /** Type-guard d'enveloppe — narrowing sûr d'un message brut venu du bus. */
 function isEnvelope(m) {
-	if (typeof m !== "object" || m === null) return false;
-	const e = m;
-	return typeof e.channel === "string" && typeof e.originId === "string";
+	return typeof ownField(m, "channel") === "string" && typeof ownField(m, "originId") === "string";
 }
 /**
 * Parse et **vérifie** une enveloppe reçue du bus partagé.
@@ -93,17 +101,110 @@ function openBackplaneEnvelope(raw, secret) {
 	if (!isEnvelope(parsed)) return null;
 	const msg = {
 		channel: parsed.channel,
-		payload: parsed.payload,
+		payload: parsed.payload === null ? void 0 : parsed.payload,
 		originId: parsed.originId
 	};
 	if (!secret) return msg;
 	const provided = parsed[SEAL_FIELD];
 	if (typeof provided !== "string") return null;
 	const payloadText = JSON.stringify(msg.payload);
-	const expected = seal(JSON.stringify(msg.originId), JSON.stringify(msg.channel), payloadText ?? "null", secret);
+	return sameSeal(provided, seal(JSON.stringify(msg.originId), JSON.stringify(msg.channel), payloadText ?? "null", secret)) ? msg : null;
+}
+/**
+* Compare deux sceaux base64url à temps constant.
+*
+* Longueurs différentes → `timingSafeEqual` lève ; on tranche avant (la longueur
+* du sceau n'est pas un secret : c'est celle de SHA-256).
+*/
+function sameSeal(provided, expected) {
 	const a = Buffer.from(provided, "base64url");
 	const b = Buffer.from(expected, "base64url");
-	if (a.length !== b.length || !timingSafeEqual(a, b)) return null;
-	return msg;
+	return a.length === b.length && timingSafeEqual(a, b);
+}
+/**
+* Sceau d'une enveloppe BINAIRE : la même chaîne canonique que le texte, où le
+* troisième fragment est la charge ENCODÉE par le codec au lieu de son JSON.
+* Les deux premiers fragments restent des chaînes JSON échappées : aucun
+* décalage de frontière n'est possible, et la charge, en dernier, n'a pas de
+* frontière à garder.
+*/
+function sealBytes(originId, channel, payloadBytes, secret) {
+	return createHmac("sha256", secret).update(`${JSON.stringify(originId)}\n${JSON.stringify(channel)}\n`).update(payloadBytes).digest("base64url");
+}
+/** Encode par le codec, et refuse un codec texte : le sujet binaire porte des octets. */
+function encodeBytes(codec, value) {
+	const out = codec.encode(value);
+	if (typeof out === "string") throw new TypeError(`backplane : le codec « ${codec.protocol} » rend du texte — le sujet binaire du bus exige un codec binaire`);
+	return out;
+}
+/**
+* Encode un message backplane pour le **sujet binaire** du bus (ADR-0021 S6) :
+* la MÊME enveloppe `{ channel, payload, originId }`, encodée par le codec
+* binaire du serveur, octets natifs dans `payload`, scellée si un secret est
+* fourni.
+*
+* Scellée, la charge est encodée deux fois — une pour le sceau, une dans
+* l'enveloppe : le codec générique ne permet pas d'assembler l'enveloppe à
+* partir de fragments déjà encodés, comme le fait la voie texte.
+*
+* @param msg - message à transporter (canal, charge, origine).
+* @param codec - le codec binaire du serveur (`CBOR_FRAME_CODEC` de `nodefony/cbor`).
+* @param secret - secret partagé entre pods ; `null`/`undefined` → enveloppe nue.
+* @returns les octets à publier sur le sujet binaire.
+* @throws TypeError si le codec rend du texte.
+*/
+function sealBackplaneEnvelopeBytes(msg, codec, secret) {
+	const payload = msg.payload ?? null;
+	if (!secret) return encodeBytes(codec, {
+		channel: msg.channel,
+		payload,
+		originId: msg.originId
+	});
+	const sig = sealBytes(msg.originId, msg.channel, encodeBytes(codec, payload), secret);
+	return encodeBytes(codec, {
+		channel: msg.channel,
+		payload,
+		originId: msg.originId,
+		[SEAL_FIELD]: sig
+	});
+}
+/**
+* Décode et **vérifie** une enveloppe reçue sur le sujet binaire du bus — même
+* règle que {@link openBackplaneEnvelope} : fail-closed strict sous un secret,
+* aucun downgrade en retirant `sig`.
+*
+* Le sceau se recalcule sur le RÉ-ENCODAGE de la charge décodée, comme la voie
+* texte le fait sur sa re-sérialisation : le codec CBOR du cœur rend la forme la
+* plus courte de chaque valeur, donc émetteur et récepteur signent les mêmes
+* octets.
+*
+* @param raw - octets lus sur le sujet binaire.
+* @param codec - le codec binaire du serveur.
+* @param secret - secret partagé attendu, ou `null`/`undefined` si aucun.
+* @returns le message vérifié, ou `null` s'il doit être ignoré.
+*/
+function openBackplaneEnvelopeBytes(raw, codec, secret) {
+	let parsed;
+	try {
+		parsed = codec.decode(raw);
+	} catch {
+		return null;
+	}
+	if (!isEnvelope(parsed)) return null;
+	const msg = {
+		channel: parsed.channel,
+		payload: parsed.payload === null ? void 0 : parsed.payload,
+		originId: parsed.originId
+	};
+	if (!secret) return msg;
+	const provided = parsed[SEAL_FIELD];
+	if (typeof provided !== "string") return null;
+	let payloadBytes;
+	try {
+		payloadBytes = encodeBytes(codec, parsed.payload ?? null);
+	} catch {
+		return null;
+	}
+	return sameSeal(provided, sealBytes(msg.originId, msg.channel, payloadBytes, secret)) ? msg : null;
 }
-export { openBackplaneEnvelope, sealBackplaneEnvelope };
+export { openBackplaneEnvelope, openBackplaneEnvelopeBytes, sealBackplaneEnvelope, sealBackplaneEnvelopeBytes };

package/dist/nodefony/src/cluster/ClusterProbeClient.js

@@ -34,6 +34,7 @@ function mergeClusterHealth(instances, ts = Date.now()) {
 		fanoutTotal: 0,
 		inboundTotal: 0,
 		ingressRejectedTotal: 0,
+		localOnlyTotal: 0,
 		connectionCount: 0,
 		bytesSentTotal: 0,
 		messagesSentTotal: 0,
@@ -52,6 +53,7 @@ function mergeClusterHealth(instances, ts = Date.now()) {
 		totals.fanoutTotal += h.fanoutTotal;
 		totals.inboundTotal += h.inboundTotal;
 		totals.ingressRejectedTotal += h.ingressRejectedTotal;
+		totals.localOnlyTotal += h.localOnlyTotal;
 		totals.connectionCount += h.connectionCount;
 		totals.bytesSentTotal += h.bytesSentTotal;
 		totals.messagesSentTotal += h.messagesSentTotal;

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

@@ -1,5 +1,23 @@
 // nodefony/src/server/AnonymousRealtimeToken.ts
 /**
+* Identité d'admission de l'ANONYME — gelée et partagée par toutes les connexions non authentifiées (0 allocation par connexion).
+*
+* Porte l'invariant de l'ADR-0021 §S10 : anonyme ⇔ `authenticated === false`,
+* `id === null` et `issuer === null`. Un canal qui déclare `allow` refuse
+* cette identité d'office, sauf option explicite `anonymous: true` — ce qui
+* garantit que `user:${who.id}` ne vaut jamais `"user:null"`.
+*/
+const ANONYMOUS_SUBSCRIBER_IDENTITY = Object.freeze({
+	type: "anonymous",
+	authenticated: false,
+	id: null,
+	userIdentifier: "anonymous",
+	roles: Object.freeze(["ROLE_ANONYMOUS"]),
+	scopes: Object.freeze([]),
+	issuer: null,
+	account: false
+});
+/**
 * Token realtime ANONYME — fallback Zero Trust quand aucun matcher
 * `IRealtimeAuthenticatorMatcher` ne capture le handshake.
 *
@@ -26,6 +44,9 @@ const ANONYMOUS_REALTIME_TOKEN = Object.freeze({
 	getScopes() {
 		return [];
 	},
-	getAttribute(_key) {}
+	getAttribute(_key) {},
+	getIdentity() {
+		return ANONYMOUS_SUBSCRIBER_IDENTITY;
+	}
 });
-export { ANONYMOUS_REALTIME_TOKEN, ANONYMOUS_REALTIME_TOKEN as default };
+export { ANONYMOUS_REALTIME_TOKEN, ANONYMOUS_REALTIME_TOKEN as default, ANONYMOUS_SUBSCRIBER_IDENTITY };

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

@@ -0,0 +1,75 @@
+import { RealtimeController } from "./RealtimeController.js";
+// nodefony/src/server/ContractRealtimeController.ts
+/**
+* Socle commun des deux formes de {@link ContractRealtimeController} : l'étiquette
+* de contrat et les canaux annoncés. Les actions y gardent le défaut de la base
+* (`{}`) — un contrat SANS `serverMethods` n'a rien à écrire.
+*
+* Ne s'étend pas directement : on étend {@link ContractRealtimeController}, qui
+* choisit cette forme ou la forme stricte selon le contrat.
+*
+* @typeParam C - le contrat de l'application.
+*/
+var ContractRealtimeControllerBase = class extends RealtimeController {
+	/** Canaux annoncés au handshake, contraints aux noms de `serverToClient`. */
+	realtimeChannels() {
+		return [];
+	}
+};
+/**
+* Forme stricte de {@link ContractRealtimeController}, retenue quand le contrat
+* déclare des `serverMethods` : `realtimeActions()` y devient ABSTRAITE et typée
+* par le contrat — la seule construction qui fait d'une méthode OUBLIÉE une
+* erreur de compilation (un décorateur ne voit jamais la classe entière).
+*
+* Ne s'étend pas directement : on étend {@link ContractRealtimeController}.
+*
+* @typeParam C - le contrat de l'application.
+*/
+var ContractRealtimeControllerStrict = class extends ContractRealtimeControllerBase {};
+/**
+* Base d'un contrôleur qui IMPLÉMENTE un contrat temps réel — la porte du
+* serveur. Le contrat s'écrit UNE fois, sur `extends` ; la direction du serveur
+* en est dérivée (il émet `serverToClient`, écoute `clientToServer`, appelle
+* `clientMethods`) et il DOIT servir chaque méthode de `serverMethods`.
+*
+* Quand le contrat déclare des `serverMethods`, `realtimeActions()` est
+* abstraite et typée par lui : une méthode OUBLIÉE ne compile pas. Un contrat
+* SANS `serverMethods` (tableau de bord, chat qui ne fait que diffuser) n'a rien
+* à écrire. Les entrées client (`realtimeInbound()`) restent facultatives canal
+* par canal : accepter une entrée est une permission, pas une promesse. Les
+* politiques d'accès se posent sur la classe par `@RealtimePolicy`, qui lit le
+* contrat sur cette classe.
+*
+* Le fichier du contrat, fait de types seuls, est partagé avec le navigateur, qui
+* entre par `NodefonySocket.fromContract<C>()`.
+*
+* Un contrat qui déclare des `serverRoutes` (routes du pont, typées côté client
+* par le schéma que la route valide) se double d'une table statique de VALEURS,
+* `static readonly serverRoutes = { … } satisfies ContractRouteSchemas<C>` : le
+* compilateur y exige chaque route du contrat avec son schéma, et le démarrage
+* vérifie que chacune est montée, servie par la socket et valide LE MÊME schéma
+* (`BootConfigurationError` sinon). Sans cette table, aucun contrôle.
+*
+* @typeParam C - le contrat de l'application.
+*
+* @example
+* ```ts
+* @RealtimePolicy({ "chat:send": { roles: ["ROLE_USER"] } })
+* class ChatRt extends ContractRealtimeController<ChatContract> {
+*   protected realtimeActions() {
+*     return { "chat:send": (p: { text: string }) => ({ id: this.store(p.text) }) };
+*   }
+* }
+*
+* class DashRt extends ContractRealtimeController<DashContract> {} // sans serverMethods
+*
+* class ChatRoutesRt extends ContractRealtimeController<ChatContract> {
+*   static readonly serverRoutes = {
+*     "POST /chat/send": { body: SendBody }, // le schéma de la route, pas une copie
+*   } satisfies ContractRouteSchemas<ChatContract>;
+* }
+* ```
+*/
+const ContractRealtimeController = ContractRealtimeControllerStrict;
+export { ContractRealtimeController, ContractRealtimeControllerBase, ContractRealtimeControllerStrict };