@nodefony/realtime 10.0.0-alpha.9 → 10.0.0-beta.1

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

@@ -99,7 +99,8 @@ function openBackplaneEnvelope(raw, secret) {
 	if (!secret) return msg;
 	const provided = parsed[SEAL_FIELD];
 	if (typeof provided !== "string") return null;
-	const expected = seal(JSON.stringify(msg.originId), JSON.stringify(msg.channel), JSON.stringify(msg.payload) ?? "null", secret);
+	const payloadText = JSON.stringify(msg.payload);
+	const expected = seal(JSON.stringify(msg.originId), JSON.stringify(msg.channel), payloadText ?? "null", secret);
 	const a = Buffer.from(provided, "base64url");
 	const b = Buffer.from(expected, "base64url");
 	if (a.length !== b.length || !timingSafeEqual(a, b)) return null;

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

@@ -136,7 +136,7 @@ var ClusterProbeClient = class {
 	#report(buildOwn) {
 		const payload = buildOwn();
 		if (this.#richEnabled) {
-			if (this.#richProbe === null) this.#richProbe = new RichProcessProbe();
+			this.#richProbe ??= new RichProcessProbe();
 			payload.rich = this.#richProbe.read();
 		}
 		if (this.#ormRich !== null) payload.ormRich = this.#ormRich;

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

@@ -5,7 +5,7 @@ import { createSyslogUplinkHandler } from "./syslogUplink.js";
 import { WsConnectionTransport } from "../transport/WsConnectionTransport.js";
 import { welcomeEnv } from "./welcomeEnv.js";
 import { deniedDetail } from "./deniedDetail.js";
-import { JsonRpcPeer, PLATFORM_INBOUND, RequestContext, RpcEnvelope, RpcError, identityHint } from "nodefony";
+import { BootConfigurationError, JsonRpcPeer, PLATFORM_INBOUND, RequestContext, RpcEnvelope, RpcError, Scope, identityHint } from "nodefony";
 import { readBackpressureOptions } from "@nodefony/http";
 import { Controller } from "@nodefony/framework";
 //#region nodefony/src/server/RealtimeController.ts
@@ -77,6 +77,36 @@ let warnedUnenforcedPolicies = false;
 * d'action n'est payé que sur une requête `id`. C'est aussi le seam du backplane Redis.
 */
 var RealtimeController = class extends Controller {
+	/**
+	* Une instance PAR CONNEXION, par construction — le défaut `singleton` des
+	* contrôleurs ne s'applique pas ici. Le pair JSON-RPC de la connexion capture
+	* l'instance du handshake, et {@link notifyClient} / {@link requestClient}
+	* désignent « CETTE connexion » par l'instance : partagée, ils liraient
+	* l'ALS de celui qui ÉMET (un écouteur du hub, un minuteur), donc une autre
+	* connexion, ou aucune. Cf {@link assertScope}.
+	*/
+	static scope = "request";
+	/**
+	* Refuse qu'une sous-classe se déclare singleton — au démarrage
+	* (`Router.setController`), et au constructeur pour qui construit par `new`
+	* hors du routeur (harnais de test). Sans ce refus, la socket s'ouvrirait
+	* sans jamais émettre `realtime:welcome` : une panne indiscernable d'un
+	* incident réseau.
+	*
+	* @throws BootConfigurationError si la classe se déclare `@Scope("singleton")`.
+	*/
+	static assertScope() {
+		if (this.scope === "singleton") throw new BootConfigurationError(`Contrôleur temps réel « ${this.name} » déclaré @Scope("singleton") : un RealtimeController vit PAR CONNEXION — son pair JSON-RPC et notifyClient/requestClient désignent la connexion par l'instance. Retirer @Scope("singleton") : la portée d'un RealtimeController est request (une instance par connexion).`);
+	}
+	/**
+	* @param name - nom du service (celui de la classe, par convention).
+	* @param context - le contexte de la connexion.
+	* @throws BootConfigurationError si la classe se déclare singleton.
+	*/
+	constructor(name, context) {
+		new.target.assertScope();
+		super(name, context);
+	}
 	/**
 	* Map des factories de canaux EXACT, lue depuis les décorateurs `@RealtimeChannel`
 	* au handshake (cold-path) et mémoïsée par instance. `null` = pas de décorateur
@@ -161,7 +191,10 @@ var RealtimeController = class extends Controller {
 		const ctx = this.context;
 		if (!ctx) return;
 		if (message == null) {
-			this.onHandshake(ctx);
+			this.onHandshake(ctx).catch((e) => {
+				this.log(`WS realtime handshake failed: ${e instanceof Error ? e.message : String(e)}`, "ERROR");
+				ctx.connection?.close(1011, "internal error");
+			});
 			return;
 		}
 		ctx.__nfRealtime?.transport.feed(message.toString());
@@ -224,7 +257,7 @@ var RealtimeController = class extends Controller {
 		}
 		const authenticator = hub.resolveAuthenticator(handshake);
 		let token;
-		if (authenticator !== null && authenticator.supports(handshake)) try {
+		if (authenticator?.supports(handshake)) try {
 			token = await authenticator.authenticate(handshake);
 			authenticator.onSuccess?.(handshake, token);
 		} catch (e) {
@@ -301,13 +334,17 @@ var RealtimeController = class extends Controller {
 		this._decoratedChannels = getRealtimeChannels(this);
 		const channelPolicies = getRealtimeChannelPolicies(this);
 		if (channelPolicies) {
-			for (const name in channelPolicies) hub.registerChannelPolicy(name, channelPolicies[name]);
+			for (const [name, policy] of Object.entries(channelPolicies)) hub.registerChannelPolicy(name, policy);
 			if (hub.hasUnenforcedChannelPolicies() && !warnedUnenforcedPolicies) {
 				warnedUnenforcedPolicies = true;
 				this.log("Realtime channel policies declared but NO frame authorizer is wired — these policies are NOT enforced (a protected channel is currently open). Load @nodefony/security with a realtime zone to enforce them.", "WARNING");
 			}
 		}
-		hub.onPlatformNotice((message, severity) => this.log(message, severity));
+		const noticeSyslog = this.syslog;
+		const noticeName = this.name;
+		hub.onPlatformNotice((message, severity) => {
+			noticeSyslog?.log(message, severity, noticeName);
+		});
 		hub.registerConnection(transport);
 		let revocable = null;
 		if (typeof token.isValid === "function") {
@@ -318,7 +355,7 @@ var RealtimeController = class extends Controller {
 			hub.registerRevocable(revocable);
 		}
 		const broadcast = this.realtimeBroadcastChannels();
-		for (let i = 0; i < broadcast.length; i++) hub.markBroadcastChannel(broadcast[i]);
+		for (const channel of broadcast) hub.markBroadcastChannel(channel);
 		const decoratedInbound = getRealtimeInbound(this);
 		const overrideInbound = this.realtimeInbound();
 		const inboundMap = {
@@ -326,7 +363,7 @@ var RealtimeController = class extends Controller {
 			...overrideInbound
 		};
 		const clientLogs = hub.clientLogsLimits;
-		if (clientLogs !== null && inboundMap[PLATFORM_INBOUND.syslogUplink] === void 0) {
+		if (clientLogs !== null && !Object.hasOwn(inboundMap, PLATFORM_INBOUND.syslogUplink)) {
 			const syslog = this.syslog;
 			if (syslog) inboundMap[PLATFORM_INBOUND.syslogUplink] = createSyslogUplinkHandler({
 				syslog,
@@ -342,7 +379,7 @@ var RealtimeController = class extends Controller {
 			inbound
 		};
 		holder.__nfRealtime = state;
-		ctx.once?.("onFinish", () => {
+		ctx.once("onFinish", () => {
 			const liveHub = getRealtimeHub();
 			for (const [channel, sink] of state.channels) liveHub.unsubscribe(channel, sink);
 			state.channels.clear();
@@ -412,6 +449,7 @@ var RealtimeController = class extends Controller {
 			else state.peer.notify(channel, payload);
 		};
 		let servedByPattern = false;
+		const isServedByPattern = () => servedByPattern;
 		if (getRealtimeHub().subscribeClient(channel, sink, (ch, publish) => {
 			const decFactory = this._decoratedChannels?.[ch];
 			if (decFactory) return decFactory(ch, publish);
@@ -420,7 +458,7 @@ var RealtimeController = class extends Controller {
 			return dispose;
 		}, (payload) => JSON.stringify(JsonRpcPeer.buildNotification(channel, payload)))) {
 			state.channels.set(channel, sink);
-			if (servedByPattern) getRealtimeHub().noticeUnguardedDynamicChannel(channel);
+			if (isServedByPattern()) getRealtimeHub().noticeUnguardedDynamicChannel(channel);
 			this.log(`WS subscribe → ${channel}`, "DEBUG");
 			return;
 		}
@@ -505,6 +543,8 @@ var RealtimeController = class extends Controller {
 				user: token.getAttribute("user"),
 				userId: token.getUserIdentifier(),
 				context: ctx,
+				resolver,
+				scope: ctx.container instanceof Scope ? ctx.container : void 0,
 				body: p?.body,
 				idempotencyKey: typeof p?.idempotencyKey === "string" ? p.idempotencyKey : void 0,
 				renderSink,
@@ -542,7 +582,8 @@ var RealtimeController = class extends Controller {
 	stopChannel(ctx, channel) {
 		if (!channel) return;
 		const state = ctx.__nfRealtime;
-		const sink = state?.channels.get(channel);
+		if (!state) return;
+		const sink = state.channels.get(channel);
 		if (sink) {
 			getRealtimeHub().unsubscribe(channel, sink);
 			state.channels.delete(channel);
@@ -564,7 +605,7 @@ var RealtimeController = class extends Controller {
 function buildHandshakeFromContext(ctx) {
 	const headers = ctx.request?.headers ?? {};
 	const cookies = /* @__PURE__ */ new Map();
-	const rawCookies = ctx.cookies ?? {};
+	const rawCookies = ctx.cookies;
 	for (const name in rawCookies) {
 		const c = rawCookies[name];
 		if (c && typeof c.value === "string") cookies.set(name, c.value);

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

@@ -273,14 +273,15 @@ var RealtimeHub = class RealtimeHub {
 	* et retire le canal (libère timers/listeners). No-op si non abonné.
 	*/
 	unsubscribe(channel, sink) {
-		const st = this.#channels?.get(channel);
-		if (!st) return;
+		const channels = this.#channels;
+		const st = channels?.get(channel);
+		if (!channels || !st) return;
 		st.sinks.delete(sink);
 		if (st.sinks.size === 0) {
 			try {
 				st.dispose?.();
 			} catch {}
-			this.#channels.delete(channel);
+			channels.delete(channel);
 		}
 	}
 	/**
@@ -356,7 +357,7 @@ var RealtimeHub = class RealtimeHub {
 	#isBroadcast(channel) {
 		const prefixes = this.#broadcastPrefixes;
 		if (prefixes === null) return false;
-		for (let i = 0; i < prefixes.length; i++) if (channel.startsWith(prefixes[i])) return true;
+		for (const prefix of prefixes) if (channel.startsWith(prefix)) return true;
 		return false;
 	}
 	/**
@@ -372,7 +373,11 @@ var RealtimeHub = class RealtimeHub {
 	setBackplane(backplane) {
 		this.#backplane = backplane;
 		backplane.onMessage((msg) => this.#admitFromBackplane(msg));
-		backplane.start();
+		const started = backplane.start();
+		if (started instanceof Promise) started.catch((err) => {
+			if (this.#notice === null) throw err instanceof Error ? err : new Error(String(err));
+			this.#notifyOnce("backplane:start", `realtime: démarrage du backplane en échec — les autres pairs ne recevront rien (${err instanceof Error ? err.message : String(err)})`);
+		});
 		return backplane;
 	}
 	/**
@@ -433,7 +438,7 @@ var RealtimeHub = class RealtimeHub {
 			this.#revalidateTimer = setInterval(() => {
 				this.revalidateRevocable();
 			}, REVOCATION_REVALIDATE_MS);
-			this.#revalidateTimer.unref?.();
+			this.#revalidateTimer.unref();
 		}
 	}
 	/**
@@ -557,7 +562,7 @@ var RealtimeHub = class RealtimeHub {
 	useAuthenticator(matcher, authenticator) {
 		const list = this.#authenticators ??= [];
 		const compiled = compileMatcher(matcher);
-		for (let i = 0; i < list.length; i++) if (list[i].authenticator === authenticator) return;
+		for (const entry of list) if (entry.authenticator === authenticator) return;
 		list.push({
 			matcher: compiled,
 			authenticator
@@ -571,10 +576,7 @@ var RealtimeHub = class RealtimeHub {
 	resolveAuthenticator(handshake) {
 		const list = this.#authenticators;
 		if (list === null) return null;
-		for (let i = 0; i < list.length; i++) {
-			const entry = list[i];
-			if (entry.matcher.match(handshake)) return entry.authenticator;
-		}
+		for (const entry of list) if (entry.matcher.match(handshake)) return entry.authenticator;
 		return null;
 	}
 	/**
@@ -781,7 +783,7 @@ var RealtimeHub = class RealtimeHub {
 		if (exact !== void 0) return exact;
 		const patterns = this.#channelPolicyPatterns;
 		if (patterns === null) return null;
-		for (let i = 0; i < patterns.length; i++) if (patterns[i].re.test(name)) return patterns[i].policy;
+		for (const pattern of patterns) if (pattern.re.test(name)) return pattern.policy;
 		return null;
 	}
 	/** Des politiques de canal sont-elles déclarées (au moins une) ? */

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

@@ -57,17 +57,19 @@ var ServerRealtimeSocket = class {
 	/** Désabonne (ref-compté) : coupe le sink du hub au DERNIER consommateur. */
 	unsubscribe(channel) {
 		const c = channel;
-		const cur = this.#subs?.get(c);
-		if (!cur) return;
+		const subs = this.#subs;
+		const cur = subs?.get(c);
+		if (subs === null || cur === void 0 || cur === 0) return;
 		if (cur > 1) {
-			this.#subs.set(c, cur - 1);
+			subs.set(c, cur - 1);
 			return;
 		}
-		this.#subs.delete(c);
-		const sink = this.#sinks?.get(c);
-		if (sink) {
+		subs.delete(c);
+		const sinks = this.#sinks;
+		const sink = sinks?.get(c);
+		if (sinks && sink) {
 			this.hub.unsubscribe(c, sink);
-			this.#sinks.delete(c);
+			sinks.delete(c);
 		}
 	}
 	/** Branche un handler de réception sur un canal. Renvoie un `dispose`. */

package/dist/nodefony/src/service/RealtimeService.js

@@ -54,8 +54,9 @@ var RealtimeService = class extends Service {
 	* par la Module class). Aucun warn — c'est le cas commun.
 	*/
 	async init(_module) {
-		this.#config = this.module.config;
-		if (!this.#config) throw new Error(`${serviceName}: realtimeConfig absente (this.module.config vide) — la Module class doit la valider à onKernelRegister`);
+		const config = this.module.config;
+		if (!config) throw new Error(`${serviceName}: realtimeConfig absente (this.module.config vide) — la Module class doit la valider à onKernelRegister`);
+		this.#config = config;
 		if (!this.#config.enabled) {
 			this.log("realtime enabled:false → service inerte (hub non câblé)", "INFO");
 			return this;
@@ -227,10 +228,10 @@ var RealtimeService = class extends Service {
 *                                       `allowList` (pas de wildcard).
 */
 function buildOriginGuard(config) {
-	const c = config.csrf?.checkOrigin;
-	if (!c || c.enabled !== true) return null;
-	const allowSet = new Set(c.allowList ?? []);
-	const allowMissing = c.allowMissingOrigin === true;
+	const c = config.csrf.checkOrigin;
+	if (!c.enabled) return null;
+	const allowSet = new Set(c.allowList);
+	const allowMissing = c.allowMissingOrigin;
 	return (origin) => {
 		if (origin === void 0 || origin === "") return allowMissing;
 		return allowSet.has(origin);

package/dist/nodefony/testing/index.js

@@ -98,11 +98,13 @@ function createRealtimeHarness(create, options = {}) {
 			hub.onPlatformNotice((message) => {
 				notices.push(message);
 			});
-			if (!await waitFor(() => received.some((f) => f.method === "realtime:welcome"), 10)) {
+			await waitFor(() => received.some((f) => f.method === "realtime:welcome"), 10);
+			const welcome = received.find((f) => f.method === "realtime:welcome");
+			if (!welcome) {
 				const cause = closes.length > 0 ? `socket fermée (code ${String(closes[0]?.code)})` : "aucune frame émise";
 				throw new Error(`createRealtimeHarness: pas de realtime:welcome — ${cause}. Vérifier l'Origin (seam #4) et l'authenticator (seam #2).`);
 			}
-			return received.find((f) => f.method === "realtime:welcome");
+			return welcome;
 		},
 		async subscribe(channel) {
 			await feed(rpc({

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

@@ -44,6 +44,6 @@ export type IRealtimeConfigInput = z.input<typeof realtimeConfigSchema>;
 /** Config normalisée et gelée (sortie du builder, lue par `RealtimeService`). */
 export type IRealtimeConfig = IRealtimeSchemaConfig & {
     backplane: IRealtimeSchemaConfig["backplane"] & {
-        instance?: IBackplane;
+        instance?: IBackplane | undefined;
     };
 };

package/dist/types/nodefony/interfaces/IChannelPolicy.d.ts

@@ -19,10 +19,10 @@
  */
 export interface IChannelPolicy {
     /** Exige une connexion authentifiée (token non anonyme). */
-    readonly authenticated?: boolean;
+    readonly authenticated?: boolean | undefined;
     /** Un de ces rôles suffit (évalué AVEC la hiérarchie de rôles, côté security). */
-    readonly roles?: readonly string[];
+    readonly roles?: readonly string[] | undefined;
     /** Un de ces scopes suffit (axe API : JWT/clé API ; session BFF n'en porte pas). */
-    readonly scopes?: readonly string[];
+    readonly scopes?: readonly string[] | undefined;
 }
 export default IChannelPolicy;

package/dist/types/nodefony/interfaces/IRealtimeAuthenticatorMatcher.d.ts

@@ -40,7 +40,7 @@ export interface IRealtimeAuthenticatorMatcher {
  */
 export interface ICompiledRealtimeMatcher {
     readonly pattern: RegExp;
-    readonly host?: string;
+    readonly host?: string | undefined;
     /** Le matcher capture-t-il ce handshake ? */
     match(handshake: IRealtimeHandshake): boolean;
 }

package/dist/types/nodefony/interfaces/IRealtimeHandshake.d.ts

@@ -21,7 +21,7 @@ export interface IRealtimeHandshake {
     /** IP du client (déjà extraite — derrière proxy : voir `trust proxy`). */
     readonly remoteAddress: string;
     /** Origin RFC 6455 §10.2 — `undefined` si en-tête absent (clients non-browser). */
-    readonly origin?: string;
+    readonly origin?: string | undefined;
     /** Sous-protocoles annoncés (`Sec-WebSocket-Protocol`). `[]` si aucun. */
     readonly protocols: readonly string[];
 }

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

@@ -1,5 +1,7 @@
 import { type RpcActionHandler, type EventsMap, type ActionsMap, type DefaultEventsMap, type DefaultActionsMap, type EventNames, type EventPayload, type ActionNames, type ActionParams, type ActionResult } from "nodefony";
+import type { ContextType } from "@nodefony/http";
 import { Controller } from "@nodefony/framework";
+import type { ControllerScope } from "@nodefony/framework";
 import type { IRealtimeController, RealtimePublish, RealtimeInboundHandler } from "../../interfaces/IRealtimeController.js";
 /**
  * RealtimeController — base d'un endpoint WebSocket temps réel SERVEUR (JSON-RPC 2.0).
@@ -24,6 +26,31 @@ import type { IRealtimeController, RealtimePublish, RealtimeInboundHandler } fro
  * d'action n'est payé que sur une requête `id`. C'est aussi le seam du backplane Redis.
  */
 export declare abstract class RealtimeController<Emit extends EventsMap = DefaultEventsMap, Actions extends ActionsMap = DefaultActionsMap> extends Controller implements IRealtimeController {
+    /**
+     * Une instance PAR CONNEXION, par construction — le défaut `singleton` des
+     * contrôleurs ne s'applique pas ici. Le pair JSON-RPC de la connexion capture
+     * l'instance du handshake, et {@link notifyClient} / {@link requestClient}
+     * désignent « CETTE connexion » par l'instance : partagée, ils liraient
+     * l'ALS de celui qui ÉMET (un écouteur du hub, un minuteur), donc une autre
+     * connexion, ou aucune. Cf {@link assertScope}.
+     */
+    static scope: ControllerScope;
+    /**
+     * Refuse qu'une sous-classe se déclare singleton — au démarrage
+     * (`Router.setController`), et au constructeur pour qui construit par `new`
+     * hors du routeur (harnais de test). Sans ce refus, la socket s'ouvrirait
+     * sans jamais émettre `realtime:welcome` : une panne indiscernable d'un
+     * incident réseau.
+     *
+     * @throws BootConfigurationError si la classe se déclare `@Scope("singleton")`.
+     */
+    static assertScope(): void;
+    /**
+     * @param name - nom du service (celui de la classe, par convention).
+     * @param context - le contexte de la connexion.
+     * @throws BootConfigurationError si la classe se déclare singleton.
+     */
+    constructor(name: string, context: ContextType);
     /**
      * Map des factories de canaux EXACT, lue depuis les décorateurs `@RealtimeChannel`
      * au handshake (cold-path) et mémoïsée par instance. `null` = pas de décorateur

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

@@ -55,8 +55,8 @@ export interface IRealtimeFrame {
 }
 /** Fermeture demandée par le serveur (code RFC 6455 + raison). */
 export interface IHarnessClose {
-    readonly code?: number;
-    readonly reason?: string;
+    readonly code?: number | undefined;
+    readonly reason?: string | undefined;
 }
 /**
  * Refus d'abonnement notifié au client (`realtime:denied`) — le contrat de

package/docs/actions.md

@@ -136,8 +136,8 @@ l'instance du contrôleur au handshake, ce qui donne accès au noyau, aux servic
 connexion sans élargir le contrat.
 
 **L'endpoint s'annonce lui-même.** La liste des actions exposées voyage dans la frame d'accueil —
-`IRealtimeWelcome` (`RealtimeController.ts:8`) — et se lit côté client par
-`RealtimeClient.serverMethods` (`RealtimeClient.ts:591`). Une interface n'écrit donc jamais un nom d'action en dur : elle
+`IRealtimeWelcome` (`RealtimeController.ts:12`) — et se lit côté client par
+`RealtimeClient.serverMethods` (`RealtimeClient.ts:597`). Une interface n'écrit donc jamais un nom d'action en dur : elle
 n'active un bouton que si le serveur a déclaré savoir le servir.
 
 **Le compromis, dit franchement** : une action est **un aller-retour**, point. Elle ne diffuse pas,
@@ -277,7 +277,7 @@ Le trajet complet d'une requête, des étapes qu'elle traverse aux branches par
 | Voie                                                   | Quand la choisir                                            |
 | ------------------------------------------------------ | ----------------------------------------------------------- |
 | `@RealtimeAction("nom")` (`realtimeDecorators.ts:101`) | le cas courant — un nom fixe, une méthode, déclaratif       |
-| `realtimeActions()` (`RealtimeController.ts:186`)      | la table est **calculée** (noms dynamiques, boucle, config) |
+| `realtimeActions()` (`RealtimeController.ts:236`)      | la table est **calculée** (noms dynamiques, boucle, config) |
 
 Les deux sont fusionnées au handshake, et **l'override gagne** en cas de conflit de nom : une
 classe peut ainsi remplacer une action héritée sans toucher au parent
@@ -445,7 +445,7 @@ fois ? »**.
 
 Pour les mutations passant par le pont API, la clé n'est pas une convention : elle est **exigée
 par la signature** de `mutate()` (`RealtimeClient.ts:797`), et c'est la garde `@Idempotent`
-(`routerDecorators.ts:1142`) qui, côté serveur, reconnaît le rejeu et rend la réponse déjà calculée
+(`routerDecorators.ts:1171`) qui, côté serveur, reconnaît le rejeu et rend la réponse déjà calculée
 au lieu de refaire l'effet.
 
 ```ts ignore
@@ -510,8 +510,8 @@ il sera conçu avec son premier consommateur réel.
 Un cas particulier mérite d'être connu avant d'écrire une action : **elle existe peut-être déjà en
 HTTP**. Le pont API expose la méthode `api.request`, qui rejoue une route de contrôleur sur la
 socket, avec la même garde et le même résultat qu'en REST — `invokeApiRequest()`
-(`RealtimeController.ts:878`). Il est **désactivé par défaut** et s'active en surchargeant
-`realtimeApiRequest()` (`RealtimeController.ts:219`).
+(`RealtimeController.ts:949`). Il est **désactivé par défaut** et s'active en surchargeant
+`realtimeApiRequest()` (`RealtimeController.ts:276`).
 
 ```ts ignore
 const modules = await socket.request("/nodefony/kernel/api/modules");

package/docs/architecture.md

@@ -126,7 +126,7 @@ Nodefony étiquette avec **JSON-RPC 2.0**, une norme publique plutôt qu'un form
 Le point remarquable : le **même** moteur de protocole tourne des deux côtés du fil. La
 classe `JsonRpcPeer` (`JsonRpcPeer.ts:271`) est du code isomorphe du cœur — le navigateur
 l'exécute dans `RealtimeClient`, le serveur l'instancie une fois par connexion dans
-`RealtimeController.onHandshake()` (`RealtimeController.ts:328`). Le serveur peut donc
+`RealtimeController.onHandshake()` (`RealtimeController.ts:374`). Le serveur peut donc
 appeler le client, pas seulement l'inverse : c'est du vrai duplex, pas un aller-retour
 déguisé.
 
@@ -141,7 +141,7 @@ Trois partis pris distinguent cette pile d'un simple « serveur WebSocket ».
 et explicite : `ServerRealtimeSocket.request()` (`ServerRealtimeSocket.ts:131`) **rejette
 toujours** — un handle posé sur le hub n'a pas d'interlocuteur unique, puisque le hub est
 multi-clients. Pour un appel serveur→client ciblé, on passe par la connexion :
-`RealtimeController.requestClient()` (`RealtimeController.ts:279`).
+`RealtimeController.requestClient()` (`RealtimeController.ts:329`).
 
 **Un provider par canal, pas un par client.** Si mille onglets s'abonnent au même canal de
 santé, le calcul ne doit tourner qu'une fois. Le hub crée le producteur au **premier**
@@ -325,7 +325,7 @@ La pile se lit de haut en bas ; chaque étage ne connaît que son voisin du dess
 | Protocole  | `JsonRpcPeer` (`JsonRpcPeer.ts:271`)                    | étiqueter, corréler, refuser une frame  | par où passent les octets     |
 | Transport  | `WsConnectionTransport` (`WsConnectionTransport.ts:46`) | déplacer des octets, mesurer la file    | ce que veut dire un message   |
 | Hub        | `RealtimeHub` (`RealtimeHub.ts:213`)                    | table des abonnés locaux + fan-out      | qu'il existe d'autres process |
-| Backplane  | `IBackplane` (`IBackplane.ts:75`)                       | porter un message aux autres process    | ce qu'est un abonné           |
+| Backplane  | `IBackplane` (`IBackplane.ts:107`)                      | porter un message aux autres process    | ce qu'est un abonné           |
 
 > [!NOTE]
 > Une part de la documentation historique décrit cette pile en « 5 étages » en comptant
@@ -388,7 +388,7 @@ Le schéma ci-dessous rend ces étages vivants : active le temps réel et il res
 
 ## 🔌 Le cycle de vie d'une connexion
 
-Tout se joue dans `RealtimeController.onHandshake()` (`RealtimeController.ts:328`), appelé
+Tout se joue dans `RealtimeController.onHandshake()` (`RealtimeController.ts:374`), appelé
 une seule fois par connexion, en chemin froid.
 
 ```mermaid
@@ -419,19 +419,19 @@ sequenceDiagram
 
 Les étapes, dans l'ordre exact du code :
 
-1. **Contrôle de l'origine** — `RealtimeHub.checkOrigin()` (`RealtimeHub.ts:970`). Refus →
+1. **Contrôle de l'origine** — `RealtimeHub.checkOrigin()` (`RealtimeHub.ts:986`). Refus →
    fermeture `4003`. La politique vient de la configuration ; sans politique, tout passe.
 2. **Résolution de l'identité** — `RealtimeHub.resolveAuthenticator()`
-   (`RealtimeHub.ts:945`) parcourt les authentificateurs enregistrés : **le premier motif
+   (`RealtimeHub.ts:961`) parcourt les authentificateurs enregistrés : **le premier motif
    qui correspond capture**. Aucun ne correspond ? Le jeton anonyme gelé est posé
    (`ANONYMOUS_REALTIME_TOKEN`) — la lecture d'identité ne rend donc jamais `null`. Un
    échec d'authentification ferme en `4001`.
 3. **Création du peer et du transport**, puis association `peer → jeton`
-   (`RealtimeHub.setTokenForPeer()`, `RealtimeHub.ts:1002`), stockée dans une `WeakMap` : le
+   (`RealtimeHub.setTokenForPeer()`, `RealtimeHub.ts:1018`), stockée dans une `WeakMap` : le
    jeton disparaît avec le peer, sans fuite.
 4. **Enregistrement des actions** — celles des décorateurs `@RealtimeAction`, puis celles
    de la surcharge `realtimeActions()`, qui gagne en cas de conflit. Le pont API
-   `api.request` n'est ajouté que si `realtimeApiRequest()` (`RealtimeController.ts:219`)
+   `api.request` n'est ajouté que si `realtimeApiRequest()` (`RealtimeController.ts:276`)
    rend `true`.
 5. **Inscription aux registres** : sonde de connexion, révocation périodique si le jeton
    est révocable, préfixes de canaux broadcast, canaux entrants.
@@ -439,7 +439,7 @@ Les étapes, dans l'ordre exact du code :
    l'identité résolue (type, authentifié ou non, rôles, portées). Le client sait **qui il
    est** sans appeler la moindre route.
 
-À la fermeture, un unique `onFinish` (`RealtimeController.ts:578`) fait le ménage complet :
+À la fermeture, un unique `onFinish` (`RealtimeController.ts:715`) fait le ménage complet :
 désabonnement de chaque canal tenu, retrait des deux registres, `fireClose()` du transport,
 `dispose()` du peer. C'est ce qui garantit qu'aucun minuteur ni écouteur ne survit à une
 déconnexion.
@@ -459,13 +459,13 @@ déconnexion.
 La seconde mérite une explication. Le verrou de frame est synchrone et lit une identité
 figée au handshake : il ne peut donc pas voir une session qui meurt en cours de route (une
 déconnexion HTTP, par exemple). Un minuteur — démarré au premier inscrit, arrêté dès que le
-registre se vide (`RealtimeHub.registerRevocable()`, `RealtimeHub.ts:778`) — relit
+registre se vide (`RealtimeHub.registerRevocable()`, `RealtimeHub.ts:794`) — relit
 périodiquement ces identités et coupe les sockets orphelines. Seules les identités
 **révocables** y entrent : un visiteur anonyme ne coûte rien.
 
 ## Le hub — canaux partagés et fan-out
 
-Le hub est un singleton par process (`getRealtimeHub()`, `RealtimeHub.ts:1435`). Il ne
+Le hub est un singleton par process (`getRealtimeHub()`, `RealtimeHub.ts:1451`). Il ne
 dépend de rien : ce sont les fabriques fournies par les contrôleurs qui portent les
 dépendances.
 
@@ -478,7 +478,7 @@ dépendances.
    paquet du producteur atteigne bien ce premier abonné.
 3. La fabrique du contrôleur rend `null` (canal inconnu de lui) ? Dernier recours : le
    registre des **canaux système** (`RealtimeHub.registerSystemChannel()`,
-   `RealtimeHub.ts:1281`), qu'un module bas niveau alimente au démarrage. Toujours `null` →
+   `RealtimeHub.ts:1297`), qu'un module bas niveau alimente au démarrage. Toujours `null` →
    l'abonnement est refusé et rien n'est alloué.
 
 Au dernier désabonnement, `RealtimeHub.unsubscribe()` (`RealtimeHub.ts:576`) appelle le
@@ -547,12 +547,12 @@ coûte chaque abonné supplémentaire.
 
 ### Le contrat, en cinq méthodes
 
-`IBackplane` (`IBackplane.ts:75`) est délibérément minuscule : le backplane ne connaît ni
+`IBackplane` (`IBackplane.ts:107`) est délibérément minuscule : le backplane ne connaît ni
 les abonnés ni les canaux logiques. Tout l'état vit dans le hub.
 
 | Membre                                            | Rôle                                                            |
 | ------------------------------------------------- | --------------------------------------------------------------- |
-| `originId` (`IBackplane.ts:77`)                   | l'étiquette de CE process, lue par l'anti-écho                  |
+| `originId` (`IBackplane.ts:109`)                  | l'étiquette de CE process, lue par l'anti-écho                  |
 | `start()` (`IBackplane.ts:115`)                   | ouvrir le transport. Idempotent, synchrone ou asynchrone        |
 | `publish(channel, payload)` (`IBackplane.ts:121`) | propager aux **autres** pairs. Ne refait pas le fan-out local   |
 | `onMessage(handler)` (`IBackplane.ts:127`)        | recevoir des pairs. Un seul gestionnaire à la fois              |
@@ -743,19 +743,19 @@ Deux propriétés architecturales méritent d'être notées ici, parce qu'elles
 choix de conception visibles partout dans le module :
 
 **Coût nul quand la sécurité est absente.** Le verrou de frame n'est branché sur le peer que
-si une politique existe (`RealtimeHub.hasFrameAuthorizer()`, `RealtimeHub.ts:1042`, testé une
+si une politique existe (`RealtimeHub.hasFrameAuthorizer()`, `RealtimeHub.ts:1058`, testé une
 fois au handshake). Sans module de sécurité, `beforeDispatch` reste indéfini et le chemin
 chaud ne paie **rien** du tout.
 
 **Échec bruyant plutôt que faux sentiment de sécurité.** Si des canaux déclarent une
 politique sans qu'aucun décideur ne soit câblé, `hasUnenforcedChannelPolicies()`
-(`RealtimeHub.ts:1101`) le détecte et un avertissement est émis une fois par process
+(`RealtimeHub.ts:1117`) le détecte et un avertissement est émis une fois par process
 (`RealtimeController.ts:487`). Un canal qui **se croit** gardé alors qu'il est ouvert est
 bien plus dangereux qu'un canal ouvertement public.
 
 ## 📡 Observabilité — la sonde et Studio
 
-`RealtimeHub.probe()` (`RealtimeHub.ts:849`) rend un instantané en **lecture pure** : aucune
+`RealtimeHub.probe()` (`RealtimeHub.ts:865`) rend un instantané en **lecture pure** : aucune
 allocation sur le chemin chaud, jamais d'exception. Les compteurs sont des primitives
 incrémentées en O(1) ; ils sont **monotones**, ce qui laisse au lecteur le soin de dériver
 un débit.
@@ -808,7 +808,7 @@ révocables, authentificateurs, politiques de canal, association peer→jeton :
 `null`. Un process sans abonné n'alloue **rien** (`RealtimeHub.ts:141` et suivants).
 
 **Aucun minuteur au repos.** Le tick de révocation démarre au premier inscrit et s'arrête
-dès que le registre se vide — `RealtimeHub.unregisterRevocable()` (`RealtimeHub.ts:793`).
+dès que le registre se vide — `RealtimeHub.unregisterRevocable()` (`RealtimeHub.ts:809`).
 Les minuteurs sont détachés de la boucle d'événements : ils ne retiennent jamais l'arrêt du
 process.
 

package/docs/configuration.md

@@ -283,7 +283,7 @@ valeurs sont des constantes du code, pas des clés.
 
 Poser `false` charge le module sans rien activer. Concrètement : pas d'API d'administration
 enregistrée, pas de backplane câblé, pas de sonde de pod
-(`Realtime.onKernelBoot()`, `src/packages/@nodefony/realtime/index.ts:213`), et le service devient
+(`Realtime.onKernelBoot()`, `src/packages/@nodefony/realtime/index.ts:239`), et le service devient
 inerte (`RealtimeService.init()`, `RealtimeService.ts:77`).
 
 > [!WARNING]
@@ -344,7 +344,7 @@ canal exotique.
 Ne concerne, là aussi, que les transports **partagés**. Un bus pub/sub ne dit pas _qui_ a publié :
 sans secret, tout ce qui atterrit sur le canal — venu d'un pod ou d'un tiers qui sait écrire dans ce
 Redis — est traité comme un message légitime. Poser un secret fait porter à chaque message un sceau
-HMAC-SHA256, vérifié à l'arrivée (`openBackplaneEnvelope()`, `envelope.ts:96`) : un message non
+HMAC-SHA256, vérifié à l'arrivée (`openBackplaneEnvelope()`, `envelope.ts:112`) : un message non
 scellé, altéré ou repointé vers un autre canal est **ignoré**, sans exception possible.
 
 Le secret doit être **identique sur tous les pods** — c'est lui qui les reconnaît entre eux. En
@@ -378,7 +378,7 @@ d'éteindre une sonde sur un pod en incident sans redéployer une configuration.
 ### `slowConsumer.bytes` — un compteur, pas un frein
 
 Seuil de `bufferedAmount` — les octets en attente d'envoi sur une socket — au-delà duquel la sonde
-compte la connexion comme « lente » (`RealtimeHub.probe()`, `RealtimeHub.ts:849`).
+compte la connexion comme « lente » (`RealtimeHub.probe()`, `RealtimeHub.ts:865`).
 
 > [!IMPORTANT]
 > **Cette clé observe, elle n'agit pas.** Elle ne change que le compteur `slowConsumers` de la
@@ -434,7 +434,7 @@ des canaux d'état, où seul le dernier instantané compte.
 Chaque canal ouvert coûte un producteur côté hub, un minuteur le plus souvent, et une entrée de table
 côté connexion. Sans borne, **un seul** client peut s'abonner jusqu'à épuiser la mémoire du
 processus. Le plafond est vérifié à chaque abonnement (`RealtimeController.startChannel()`,
-`RealtimeController.ts:746`).
+`RealtimeController.ts:815`).
 
 Quatre propriétés qui décident du bon réglage :
 
@@ -457,7 +457,7 @@ les clients — un tableau de bord interne qui compose des dizaines de flux, par
 ### `csrf.checkOrigin` — qui a le droit d'ouvrir la socket
 
 Trois clés qui forment une seule politique, appliquée à l'ouverture de la connexion
-(`RealtimeHub.checkOrigin()`, `RealtimeHub.ts:970`). Une origine refusée ferme la socket avec le code
+(`RealtimeHub.checkOrigin()`, `RealtimeHub.ts:986`). Une origine refusée ferme la socket avec le code
 `4003`.
 
 Le défaut est **désactivé**. C'est le seul défaut du module qui n'est pas le réglage recommandé :
@@ -705,7 +705,7 @@ Deux fonctions publiques, utiles surtout aux tests et aux outils.
 
 `defineRealtimeConfig(config?, options?)` (`defineModuleConfig.ts:35`) analyse, applique la variable
 de driver et **gèle**. Le module l'appelle lui-même à l'enregistrement
-(`Realtime.onKernelRegister()`, `src/packages/@nodefony/realtime/index.ts:219`) : tu n'as pas à
+(`Realtime.onKernelRegister()`, `src/packages/@nodefony/realtime/index.ts:213`) : tu n'as pas à
 l'invoquer dans une application. En revanche, c'est l'outil qui permet de vérifier une configuration
 sans démarrer un serveur.
 

package/docs/cookbook-chat.md

@@ -134,7 +134,7 @@ le moment venu.
 
 ```bash
 # 1. Créer l'application (profil complet : http, framework, realtime, sécurité, frontend)
-npx nodefony create app mon-chat --complete
+npx nodefony create app mon-chat --preset complete
 cd mon-chat
 
 # 2. Créer le module qui portera le salon
@@ -1598,22 +1598,22 @@ Pour qui veut lire l'implémentation derrière chaque étape :
 | Ce que tu as utilisé | Où c'est écrit |
 | --- | --- |
 | Les trois décorateurs | `RealtimeAction()` (`realtimeDecorators.ts:101`), `RealtimeChannel()` (`realtimeDecorators.ts:192`), `RealtimeInbound()` (`realtimeDecorators.ts:231`) |
-| La porte WebSocket | `RealtimeController.handleRealtime()` (`RealtimeController.ts:249`) |
-| Le pont HTTP ⇄ WebSocket | `RealtimeController.realtimeApiRequest()` (`RealtimeController.ts:219`) |
-| L'abonnement et son cycle de vie | `RealtimeHub.subscribe()` (`RealtimeHub.ts:462`), `RealtimeController.startChannel()` (`RealtimeController.ts:746`) |
+| La porte WebSocket | `RealtimeController.handleRealtime()` (`RealtimeController.ts:299`) |
+| Le pont HTTP ⇄ WebSocket | `RealtimeController.realtimeApiRequest()` (`RealtimeController.ts:276`) |
+| L'abonnement et son cycle de vie | `RealtimeHub.subscribe()` (`RealtimeHub.ts:462`), `RealtimeController.startChannel()` (`RealtimeController.ts:815`) |
 | La publication et le fan-out | `RealtimeHub.publish()` (`RealtimeHub.ts:604`), réinjection locale `RealtimeHub.publishLocal()` (`RealtimeHub.ts:623`) |
 | Les canaux diffusables | `RealtimeBroadcast` (`realtimeDecorators.ts:342`), `RealtimeHub.markBroadcastChannel()` (`RealtimeHub.ts:668`) |
 | Le branchement du backplane | `RealtimeHub.setBackplane()` (`RealtimeHub.ts:714`), registre `registerBackplaneDriver()` (`backplaneRegistry.ts:55`), cloison `resolveBackplaneOriginId()` (`originId.ts:24`) |
-| Les politiques de canal | `IChannelPolicy` (`IChannelPolicy.ts:20`), `RealtimeHub.registerChannelPolicy()` (`RealtimeHub.ts:1127`), garde-fou `RealtimeHub.hasUnenforcedChannelPolicies()` (`RealtimeHub.ts:1127`) |
+| Les politiques de canal | `IChannelPolicy` (`IChannelPolicy.ts:20`), `RealtimeHub.registerChannelPolicy()` (`RealtimeHub.ts:1143`), garde-fou `RealtimeHub.hasUnenforcedChannelPolicies()` (`RealtimeHub.ts:1117`) |
 | Le branchement automatique du firewall | `Firewall.#wireRealtime()` (`firewall.ts:279`) |
-| Les refus | `IRealtimeDenied` (`RealtimeEventMap.ts:269`), erreur `unauthorized` (`JsonRpcPeer.ts:400`), fermetures `origin not allowed` (`RealtimeController.ts:327`) et `unauthorized` (`RealtimeController.ts:349`) |
-| La révocation en cours de session | `RealtimeHub.revalidateRevocable()` (`RealtimeHub.ts:810`) |
+| Les refus | `IRealtimeDenied` (`RealtimeEventMap.ts:269`), erreur `unauthorized` (`JsonRpcPeer.ts:417`), fermetures `origin not allowed` (`RealtimeController.ts:327`) et `unauthorized` (`RealtimeController.ts:397`) |
+| La révocation en cours de session | `RealtimeHub.revalidateRevocable()` (`RealtimeHub.ts:826`) |
 | Le consommateur lent | seuil `SLOW_CONSUMER_BYTES` (`RealtimeHub.ts:56`), fermeture `slow consumer` (`RealtimeHub.ts:63`) |
-| Le plafond de canaux | `RealtimeHub.maxChannelsPerConnection` (`RealtimeHub.ts:984`) |
+| Le plafond de canaux | `RealtimeHub.maxChannelsPerConnection` (`RealtimeHub.ts:1000`) |
 | L'accueil et l'identité | `IRealtimeWelcome` (`RealtimeEventMap.ts:231`) |
-| La sonde | `RealtimeHub.probe()` (`RealtimeHub.ts:849`), `IRealtimeProbe` (`IRealtimeProbe.ts:61`), `IRealtimeChannelStat` (`IRealtimeProbe.ts:47`) |
+| La sonde | `RealtimeHub.probe()` (`RealtimeHub.ts:865`), `IRealtimeProbe` (`IRealtimeProbe.ts:61`), `IRealtimeChannelStat` (`IRealtimeProbe.ts:47`) |
 | Le point de mesure d'administration | `createRealtimeAdminApi()` (`RealtimeAdminApi.ts:98`), `buildRealtimeHealth()` (`RealtimeAdminApi.ts:74`), `buildOwnHealth()` (`RealtimeAdminApi.ts:52`) |
 | Le service injectable | `RealtimeService.publish()` (`RealtimeService.ts:161`), `RealtimeService.probe()` (`RealtimeService.ts:213`), `RealtimeService.markBroadcastChannel()` (`RealtimeService.ts:222`) |
-| Les hooks React | `useNodefony()` (`client/react/index.ts:145`), `useNodefonyState()` (`client/react/index.ts:163`), `useNodefonyIdentity()` (`client/react/index.ts:182`), `useNodefonyChannel()` (`client/react/index.ts:198`), `useNodefonyChannelData()` (`client/react/index.ts:221`), `useNodefonyAdaptiveChannel()` (`client/react/index.ts:182`) |
+| Les hooks React | `useNodefony()` (`client/react/index.ts:145`), `useNodefonyState()` (`client/react/index.ts:163`), `useNodefonyIdentity()` (`client/react/index.ts:182`), `useNodefonyChannel()` (`client/react/index.ts:198`), `useNodefonyChannelData()` (`client/react/index.ts:221`), `useNodefonyAdaptiveChannel()` (`client/react/index.ts:255`) |
 | Le client navigateur | `RealtimeClient.connect()` (`RealtimeClient.ts:389`), `RealtimeClient.subscribe()` (`RealtimeClient.ts:530`), `RealtimeClient.request()` (`RealtimeClient.ts:729`), `RealtimeClient.onDenied()` (`RealtimeClient.ts:471`) |
-| L'upload | `UploadedFile` (`routerDecorators.ts:1253`), `IUploadedFile` (`IUpload.ts:49`), `queryFile` (`Request.ts:185`) |
+| L'upload | `UploadedFile` (`routerDecorators.ts:1286`), `IUploadedFile` (`IUpload.ts:49`), `queryFile` (`Request.ts:200`) |

package/docs/index.md

@@ -325,7 +325,7 @@ vue de tous les workers d'un pod.
 
 Le data plane admin expose `/nodefony/realtime/api/health` — canaux et abonnés, compteurs de
 diffusion, connexions, octets et frames, pression d'écriture. C'est la même donnée que celle rendue à
-l'écran, servie par la sonde du hub (`RealtimeHub.probe()`, `RealtimeHub.ts:849`).
+l'écran, servie par la sonde du hub (`RealtimeHub.probe()`, `RealtimeHub.ts:865`).
 
 ## 🧪 Tests & couverture
 
@@ -367,6 +367,3 @@ l'infrastructure sous la main.
 - 🏛️ **Transverse** : [vue d'ensemble du framework](../../../../../docs/architecture/vue-ensemble.md) ·
   [le pipeline d'une requête](../../../../../docs/architecture/pipeline-requete.md)
 - 📖 [Lexique général](../../../../../docs/lexique.md) du framework.
-</content>
-
-</invoke>

package/docs/observabilite.md

@@ -96,7 +96,7 @@ temps de réponse — elle mesure **ce qui n'est pas encore parti**.
 Trois partis pris, tous lisibles dans le code.
 
 **1. La sonde est une lecture pure, jamais un collecteur.** `RealtimeHub.probe()`
-(`RealtimeHub.ts:849`) ne fait qu'additionner des primitives déjà tenues à jour par le chemin chaud.
+(`RealtimeHub.ts:865`) ne fait qu'additionner des primitives déjà tenues à jour par le chemin chaud.
 Aucune entrée-sortie, aucune exception possible, aucun état de lecture conservé. Appeler la sonde
 mille fois par seconde ne changerait rien à ce que le hub fait par ailleurs.
 
@@ -265,7 +265,7 @@ Le contrat est `IRealtimeProbe` (`IRealtimeProbe.ts:61`). Quatre familles, un di
 | ---------------------- | ------------------------------------------------------------------------------------------------------------------ |
 | `publishTotal`         | Appels à `publish`. **Ce que le serveur a voulu envoyer.**                                                         |
 | `fanoutTotal`          | Livraisons effectives (`publish` × abonnés). **Ce que ça a réellement coûté.**                                     |
-| `inboundTotal`         | Frames poussées par les clients sur les canaux entrants, via `RealtimeHub.recordInbound()` (`RealtimeHub.ts:838`). |
+| `inboundTotal`         | Frames poussées par les clients sur les canaux entrants, via `RealtimeHub.recordInbound()` (`RealtimeHub.ts:854`). |
 | `ingressRejectedTotal` | Messages venus du **backplane** et jetés parce que leur canal n'est pas déclaré diffusable.                        |
 
 Le rapport `fanoutTotal / publishTotal` est la mesure la plus parlante de la page : c'est la **taille
@@ -588,6 +588,3 @@ npm run coverage   # rapport vitest — jamais de pourcentage figé dans cette p
 - [Sécurité](securite.md) — qui a le droit de s'abonner à un canal de santé, et pourquoi ça compte.
 - [Cookbook — un chat](cookbook-chat.md) — le patron appliqué de bout en bout sur une vraie fonctionnalité.
 - [Vocabulaire](vocabulaire.md) — les douze mots de la socket.
-</content>
-
-</invoke>

package/docs/protocole.md

@@ -246,7 +246,7 @@ Sur le fil, dans l'inspecteur réseau du navigateur, exactement cinq frames :
 ```jsonc
 // 1. serveur → client : l'accueil, aussitôt après le handshake
 {"jsonrpc":"2.0","method":"realtime:welcome","params":{
-  "ts":1770000000000,"protocol":"jsonrpc-2.0",
+  "ts":1770000000000,"protocol":"jsonrpc-2.0","env":"development",
   "channels":["chat:room-42"],"methods":["chat:history"],
   "identity":{"type":"anonymous","authenticated":false,
               "userIdentifier":"anonymous","roles":["ROLE_ANONYMOUS"],"scopes":[]}}}
@@ -264,9 +264,11 @@ Sur le fil, dans l'inspecteur réseau du navigateur, exactement cinq frames :
 {"jsonrpc":"2.0","method":"chat:room-42","params":{"text":"salut"}}
 ```
 
-L'accueil porte **cinq** champs : `ts`, `protocol`, `channels`, `methods`, `identity`
-(`IRealtimeWelcome`, `RealtimeEventMap.ts:231`), émis par le contrôleur au handshake
-(`RealtimeController.ts:8`). Il n'y a pas de champ `version`.
+L'accueil porte cinq champs — `ts`, `protocol`, `channels`, `methods`, `identity`
+(`IRealtimeWelcome`, `RealtimeEventMap.ts:231`) — plus un sixième, `env`, **uniquement hors
+production** (`welcomeEnv()`, `welcomeEnv.ts:19`) : c'est lui que porte l'exemple ci-dessus, capturé
+en développement. Émis par le contrôleur au handshake (`peer.notify("realtime:welcome")`,
+`RealtimeController.ts:708`). Il n'y a pas de champ `version`.
 
 ## 🔌 Anatomie d'une frame, champ par champ
 
@@ -335,19 +337,19 @@ ouvertes à l'application. Colonne `id` : présent = requête (réponse due), ab
 
 | Méthode            | Direction     | `id` ?  | Rôle                                                                  | Ancrage                     |
 | ------------------ | ------------- | :-----: | --------------------------------------------------------------------- | --------------------------- |
-| `subscribe`        | client→server |   non   | « pousse-moi ce canal » — `params.channel`                            | `RealtimeController.ts:459` |
-| `unsubscribe`      | client→server |   non   | « arrête » — dernier abonné, le producteur est libéré                 | `RealtimeController.ts:727` |
-| `ping`             | client→server |   non   | Battement de cœur — **no-op serveur**, aucun pong                     | `RealtimeClient.ts:740`     |
-| `<canal>`          | server→client |   non   | Push d'un message : le **nom du canal est la `method`**               | `RealtimeController.ts:901` |
+| `subscribe`        | client→server |   non   | « pousse-moi ce canal » — `params.channel`                            | `RealtimeController.ts:522` |
+| `unsubscribe`      | client→server |   non   | « arrête » — dernier abonné, le producteur est libéré                 | `RealtimeController.ts:775` |
+| `ping`             | client→server |   non   | Battement de cœur — **no-op serveur**, aucun pong                     | `RealtimeClient.ts:882`     |
+| `<canal>`          | server→client |   non   | Push d'un message : le **nom du canal est la `method`**               | `RealtimeController.ts:972` |
 | `<canal entrant>`  | client→server |   non   | Le client pousse sur un canal déclaré entrant                         | `RealtimeController.ts:736` |
 | `realtime:welcome` | server→client |   non   | L'accueil : 5 champs, dont l'identité résolue                         | `RealtimeController.ts:693` |
-| `realtime:denied`  | server→client |   non   | Rend OBSERVABLE le refus d'une notification                           | `RealtimeController.ts:433` |
-| `api.request`      | client→server | **oui** | Pont API — rejoue une route HTTP sur la socket (désactivé par défaut) | `RealtimeController.ts:534` |
+| `realtime:denied`  | server→client |   non   | Rend OBSERVABLE le refus d'une notification                           | `RealtimeController.ts:496` |
+| `api.request`      | client→server | **oui** | Pont API — rejoue une route HTTP sur la socket (désactivé par défaut) | `RealtimeController.ts:582` |
 | `<action>`         | client→server | **oui** | Toute action déclarée par `@RealtimeAction`                           | `realtimeDecorators.ts:101` |
 
 > [!TIP]
 > **L'accueil est ta carte du territoire.** `methods` et `channels` sont construits à partir de ce
-> que l'endpoint expose réellement (`RealtimeController.ts:641`) : un client peut activer ou griser
+> que l'endpoint expose réellement (`RealtimeController.ts:710`) : un client peut activer ou griser
 > ses commandes sans rien coder en dur. Côté navigateur, ils se lisent en `socket.serverMethods` et
 > `socket.serverChannels`.
 
@@ -357,12 +359,12 @@ Les quatre formes de frame circulent en permanence sous tes yeux — ce schéma
 > `nodefony:kernel:ping` et `nodefony:kernel:gc` (`StudioRealtimeController.ts:114`) sont des exemples d'actions,
 > **pas des méthodes du cœur temps réel** : elles sont déclarées par le contrôleur
 > d'administration de `@nodefony/studio`. Un endpoint applicatif ne les expose pas. Le helper
-> `RealtimeClient.ping()` (`RealtimeClient.ts:740`) mesure le RTT en les appelant — il suppose donc
+> `RealtimeClient.ping()` (`RealtimeClient.ts:878`) mesure le RTT en les appelant — il suppose donc
 > un endpoint qui les déclare, contrairement à la notification `ping` du battement de cœur, qui
 > n'attend jamais de réponse.
 
 `subscribe` et `unsubscribe` ne sont **pas** des actions enregistrées : elles sont traitées dans
-`onRealtimeNotification()` (`RealtimeController.ts:715`). Envoyées avec un `id`, elles seraient
+`onRealtimeNotification()` (`RealtimeController.ts:784`). Envoyées avec un `id`, elles seraient
 classées « requête », ne trouveraient aucun handler et récolteraient un `-32601`.
 
 ## Une conversation type, de bout en bout
@@ -400,7 +402,7 @@ de `RpcError`.
 | `-32603` | même méthode (`JsonRpcPeer.ts:528`)                        | le handler a levé une exception **ordinaire**       | `internal error` — générique, rien d'autre     |
 | `-32001` | le refus du verrou de frame (`JsonRpcPeer.ts:400`)         | `beforeDispatch` a dit non **sur une requête**      | `unauthorized`, sans jamais dire pourquoi      |
 | `-32000` | défaut du constructeur de `RpcError` (`JsonRpcPeer.ts:74`) | le handler expose volontairement son refus          | le message ET le `data` choisis par le handler |
-| `-32602` | le pont API, via `RpcError` (`RealtimeController.ts:718`)  | `api.request` appelé avec un `params.path` invalide | message explicite (l'appel est malformé)       |
+| `-32602` | le pont API, via `RpcError` (`RealtimeController.ts:787`)  | `api.request` appelé avec un `params.path` invalide | message explicite (l'appel est malformé)       |
 
 Et un échec qui n'est **pas** une frame : l'expiration. `startCall()` ne reçoit rien dans le délai
 imparti, supprime l'entrée en attente et rejette localement avec `RPC timeout: <méthode>`
@@ -431,12 +433,12 @@ radicalement :
 | La frame refusée est… | Ce qui part                                                     | Pourquoi                                             |
 | --------------------- | --------------------------------------------------------------- | ---------------------------------------------------- |
 | une **requête**       | `-32001 "unauthorized"` (`JsonRpcPeer.ts:413`)                  | Un `id` existe : il y a un canal de réponse          |
-| une **notification**  | la notification `realtime:denied` (`RealtimeController.ts:433`) | Aucun `id` : sans elle, le client se croirait abonné |
+| une **notification**  | la notification `realtime:denied` (`RealtimeController.ts:496`) | Aucun `id` : sans elle, le client se croirait abonné |
 
 `IRealtimeDenied` (`RealtimeEventMap.ts:269`) porte `channel` et `reason` — plus un `detail` optionnel, posé hors production seulement — et le motif
 est **générique**. Jamais « il te manque `ROLE_ADMIN` » : ce serait un oracle d'autorisation, un
 attaquant y lirait la carte des droits. Deux motifs circulent : `forbidden` (le verrou a dit non) et
-`limit` (le plafond de canaux de la connexion est atteint, `RealtimeController.ts:763`). Côté client,
+`limit` (le plafond de canaux de la connexion est atteint, `RealtimeController.ts:811`). Côté client,
 `onDenied()` (`RealtimeClient.ts:469`) branche un handler dessus.
 
 > [!CAUTION]
@@ -474,7 +476,7 @@ décrits dans [la page sécurité](./securite.md).
 | L'exception du serveur n'arrive jamais au client                 | Zero Trust : tout throw ordinaire devient `-32603` générique (`JsonRpcPeer.ts:528`)                             | Lever une `RpcError` pour exposer volontairement code et `data`                   |
 | Une notification refusée disparaît sans trace côté client        | Sans `id`, aucune réponse possible (`beforeDispatch`, `JsonRpcPeer.ts:151`)                                     | Écouter `realtime:denied` via `onDenied()` (`RealtimeClient.ts:471`)              |
 | `nodefony:kernel:ping` répond `-32601` sur mon endpoint          | L'action `nodefony:kernel:ping` est déclarée par `@nodefony/studio` (`StudioRealtimeController.ts:114`)         | Déclarer la sienne, ou lire `serverMethods` avant d'appeler                       |
-| Le battement de cœur ne renvoie aucun pong                       | La notification `ping` est un no-op serveur (`RealtimeController.ts:742`)                                       | Pour mesurer un RTT, utiliser une action RPC — `ping()` (`RealtimeClient.ts:740`) |
+| Le battement de cœur ne renvoie aucun pong                       | La notification `ping` est un no-op serveur (`RealtimeController.ts:791`)                                       | Pour mesurer un RTT, utiliser une action RPC — `ping()` (`RealtimeClient.ts:878`) |
 | Une réponse reçue est ignorée sans message                       | Corrélation sur `id` **numériques** seulement (`JsonRpcPeer.ts:537`)                                            | Ne pas fabriquer soi-même de réponse à `id` chaîne                                |
 | Les premières frames envoyées après `connect()` semblent perdues | Le transport n'est branché qu'une fois le handshake terminé                                                     | Attendre `realtime:welcome` — le client le fait déjà                              |
 

package/docs/securite.md

@@ -118,7 +118,7 @@ politiques.**
   `security/nodefony/config/config.ts:109`). L'opt-out est explicite ; un opt-in aurait été
   _fail-open_ (une zone qui oublie le flag laisserait le WS anonyme).
 - Le verrou de frame consulte la **même** fonction de match que le HTTP, `Firewall.matchPath()`
-  (`firewall.ts:712`), et la **même** hiérarchie de rôles, `Firewall.hasRole()`
+  (`firewall.ts:719`), et la **même** hiérarchie de rôles, `Firewall.hasRole()`
   (`firewall.ts:482`). Invariant par construction : `api.request {path}` n'accorde jamais plus que
   `GET {path}`.
 - L'identité du handshake est celle du firewall HTTP : `FirewallRealtimeAuthenticator`
@@ -261,13 +261,13 @@ Nodefony pose **deux barrières successives**, à deux étages différents.
 | Allowlist stricte    | `@nodefony/realtime` | **inactif** (`enabled: false`)      | configurable  | `close 4003` |
 
 **Barrière 1 — transport, active sans rien faire.** `HttpKernel.checkWebsocketOrigin()`
-(`http-kernel.ts:599`) exige que l'`Origin` du handshake corresponde au `Host` servi, avec tolérance
+(`http-kernel.ts:621`) exige que l'`Origin` du handshake corresponde au `Host` servi, avec tolérance
 loopback en développement et une allowlist optionnelle (`allowedOrigins`,
 `http/nodefony/config/config.ts:552`) acceptant le hostname exact ou un wildcard à un label. Une
 requête **sans** `Origin` est acceptée : un attaquant non-navigateur n'a pas besoin de CSWSH.
 
 **Barrière 2 — module realtime, opt-in et plus stricte.** `RealtimeHub.checkOrigin()`
-(`RealtimeHub.ts:970`) consulte une garde compilée une fois au boot par `buildOriginGuard()`
+(`RealtimeHub.ts:986`) consulte une garde compilée une fois au boot par `buildOriginGuard()`
 (`RealtimeService.ts:313`) depuis `checkOriginSchema` (`realtime/nodefony/config/config.ts:162`).
 Trois différences comptent :
 
@@ -292,18 +292,18 @@ n'est jamais traitée.
 
 ### Le pipeline exact
 
-`RealtimeController.onHandshake()` (`RealtimeController.ts:328`) exécute, une fois par connexion :
+`RealtimeController.onHandshake()` (`RealtimeController.ts:374`) exécute, une fois par connexion :
 
 1. Construction d'un DTO neutre `IRealtimeHandshake` par `buildHandshakeFromContext()`
-   (`RealtimeController.ts:1113`) — headers, cookies aplatis, url, origin, sous-protocoles. Aucune
+   (`RealtimeController.ts:1198`) — headers, cookies aplatis, url, origin, sous-protocoles. Aucune
    dépendance à `@nodefony/security` dans le contrat.
 2. Contrôle d'origine (verrou 1).
-3. Résolution de l'authenticator par `RealtimeHub.resolveAuthenticator()` (`RealtimeHub.ts:945`) :
+3. Résolution de l'authenticator par `RealtimeHub.resolveAuthenticator()` (`RealtimeHub.ts:961`) :
    les matchers sont testés dans l'ordre d'enregistrement, **le premier qui matche capture**.
 4. `authenticator.authenticate(handshake)` — **async autorisé** (on est en cold path, une fois par
    connexion : lire un store est acceptable ici, jamais par frame).
 5. Pose du token sur la WeakMap `peer → token` via `RealtimeHub.setTokenForPeer()`
-   (`RealtimeHub.ts:1002`), **avant** l'envoi du `welcome` : le lookup est garanti dès la première
+   (`RealtimeHub.ts:1018`), **avant** l'envoi du `welcome` : le lookup est garanti dès la première
    frame.
 
 Un `throw` de `authenticate()` ferme la socket en `4001` « unauthorized », après un log `WARNING`
@@ -312,8 +312,8 @@ d'audit défectueux ne peut pas empêcher la fermeture.
 
 ### Les matchers — quelle porte, quel vigile
 
-`RealtimeHub.useAuthenticator()` (`RealtimeHub.ts:927`) associe un sélecteur à une stratégie.
-`compileMatcher()` (`RealtimeHub.ts:1402`) le compile une fois :
+`RealtimeHub.useAuthenticator()` (`RealtimeHub.ts:943`) associe un sélecteur à une stratégie.
+`compileMatcher()` (`RealtimeHub.ts:1418`) le compile une fois :
 
 - `pattern` chaîne → RegExp **préfixe ancrée**, méta-caractères échappés par `RegExp.escape`.
   `"/admin/"` matche `/admin/` et `/admin/foo`, littéralement.
@@ -321,7 +321,7 @@ d'audit défectueux ne peut pas empêcher la fermeture.
 - `host` optionnel → comparaison **stricte** (insensible à la casse) sur l'en-tête `Host`, sans
   wildcard.
 - Le match porte sur le **path**, query comprise, jamais sur l'URL absolue : `handshakePath()`
-  (`RealtimeController.ts:1165`) extrait `pathname + search` du `WebsocketContext.url`, qui est
+  (`RealtimeController.ts:1250`) extrait `pathname + search` du `WebsocketContext.url`, qui est
   absolu. Sans cette extraction, un matcher `^/nodefony/…` ne se déclencherait jamais.
 
 `@nodefony/security` enregistre ces matchers automatiquement dans `Firewall.#wireRealtime()`
@@ -330,7 +330,7 @@ identité d'instance et une instance partagée n'enregistrerait que le premier m
 
 ### Zero Trust — il y a toujours un token
 
-`RealtimeHub.getTokenForPeer()` (`RealtimeHub.ts:1014`) ne renvoie **jamais** `null` : à défaut de
+`RealtimeHub.getTokenForPeer()` (`RealtimeHub.ts:1030`) ne renvoie **jamais** `null` : à défaut de
 token posé, c'est `ANONYMOUS_REALTIME_TOKEN` (`AnonymousRealtimeToken.ts:18`), singleton gelé,
 `isAuthenticated() === false`, `roles: ["ROLE_ANONYMOUS"]`. Le code consommateur (verrou, audit)
 n'a jamais à écrire « et s'il n'y a pas de token ? ».
@@ -451,7 +451,7 @@ peut **resserrer**, jamais desserrer.
 
 | Cible                                      | Politique par défaut                                           |
 | ------------------------------------------ | -------------------------------------------------------------- |
-| `nodefony:audit`                           | authentifié + `ROLE_NODEFONY_ADMIN` (`frameAuthorizer.ts:99`)  |
+| `nodefony:audit`                           | authentifié + `ROLE_NODEFONY_ADMIN` (`frameAuthorizer.ts:120`) |
 | tout le reste de `nodefony:`               | authentifié + `ROLE_NODEFONY_ADMIN` (`frameAuthorizer.ts:89`)  |
 | tout canal contenant `:health` ou `:stats` | authentifié + `ROLE_NODEFONY_ADMIN` (`frameAuthorizer.ts:253`) |
 | tout le reste                              | libre, sauf policy déclarée                                    |
@@ -472,7 +472,7 @@ Trois durcissements méritent d'être connus :
   donc re-cibler `nodefony:syslog` sur `ROLE_SECURITY_AUDITOR` ; on ne peut pas l'ouvrir à l'anonyme.
 
 Le canal du journal d'audit (`nodefony:audit`) est enregistré comme **canal système** sur le hub
-(`RealtimeHub.registerSystemChannel()`, `RealtimeHub.ts:1281`) : il devient servable par n'importe
+(`RealtimeHub.registerSystemChannel()`, `RealtimeHub.ts:1297`) : il devient servable par n'importe
 quel endpoint realtime, sans qu'aucun controller ne le connaisse — et il est gardé par sa règle
 dédiée. Son enregistrement est **couplé** à la pose du verrou (même condition), donc il n'existe
 jamais de canal d'audit non gardé.
@@ -536,15 +536,15 @@ C'est exactement le test de `Firewall.#wireRealtime()` (`firewall.ts:279`) : san
 évaluée — ni métier, ni système. `nodefony:syslog` redevient un canal ordinaire.
 
 Deuxième subtilité : `beforeDispatch` n'est branché sur une connexion que si le verrou est **déjà**
-posé au moment de son handshake (`RealtimeController.ts:429`, via
-`RealtimeHub.hasFrameAuthorizer()` — `RealtimeHub.ts:1042`). Choix de performance délibéré (un hub
+posé au moment de son handshake (`RealtimeController.ts:504`, via
+`RealtimeHub.hasFrameAuthorizer()` — `RealtimeHub.ts:1058`). Choix de performance délibéré (un hub
 non sécurisé garde un coût nul par frame), mais avec une conséquence : **une connexion ouverte avant
 la pose du verrou n'est jamais gardée**, et ce jusqu'à sa fermeture. En fonctionnement normal le
 firewall se construit au boot, avant tout trafic ; le cas ne se présente qu'en appelant
 `setFrameAuthorizer()` à chaud.
 
 **Le refus de dégrader en silence.** Quand des policies sont déclarées sans décideur câblé,
-`RealtimeHub.hasUnenforcedChannelPolicies()` (`RealtimeHub.ts:1101`) renvoie `true` et le controller
+`RealtimeHub.hasUnenforcedChannelPolicies()` (`RealtimeHub.ts:1117`) renvoie `true` et le controller
 émet un WARNING explicite, une seule fois par process (`RealtimeController.ts:558`) :
 
 ```text
@@ -600,16 +600,16 @@ Nodefony ferme l'écart par deux mécanismes de granularité différente.
 
 | Surface                     | Re-validation        | Fenêtre d'exposition | Où                                                                    |
 | --------------------------- | -------------------- | -------------------- | --------------------------------------------------------------------- |
-| `api.request` (data plane)  | **à chaque frame**   | nulle                | `RealtimeController.invokeApiRequest()` (`RealtimeController.ts:878`) |
-| `subscribe` / flux de canal | **périodique**, 30 s | ≤ 30 s               | `RealtimeHub.revalidateRevocable()` (`RealtimeHub.ts:810`)            |
+| `api.request` (data plane)  | **à chaque frame**   | nulle                | `RealtimeController.invokeApiRequest()` (`RealtimeController.ts:949`) |
+| `subscribe` / flux de canal | **périodique**, 30 s | ≤ 30 s               | `RealtimeHub.revalidateRevocable()` (`RealtimeHub.ts:826`)            |
 
 **Sur `api.request`**, `token.isValid()` est appelé avant l'exécution de l'action ; identité périmée
 ou changée → `-32000` avec `status: 401`, et le client bascule sur un `fetch` HTTP porteur du cookie
 courant. Une erreur de re-validation vaut refus (fail-closed).
 
 **Sur les canaux**, le hub n'inscrit au registre de révocation que les connexions dont le token porte
-`isValid` (`RealtimeController.ts:586`) — anonymes et JWT n'y entrent jamais, coût nul.
-`RealtimeHub.registerRevocable()` (`RealtimeHub.ts:778`) démarre un `setInterval` `unref` au premier
+`isValid` (`RealtimeController.ts:659`) — anonymes et JWT n'y entrent jamais, coût nul.
+`RealtimeHub.registerRevocable()` (`RealtimeHub.ts:794`) démarre un `setInterval` `unref` au premier
 inscrit et l'arrête dès que le registre se vide : zéro timer au repos. Période :
 `REVOCATION_REVALIDATE_MS` (`RealtimeHub.ts:111`), 30 s, alignée sur le heartbeat WS.
 
@@ -652,7 +652,7 @@ pas** borné.
 Chaque canal ouvert coûte un provider, un ticker et une entrée de Map. Sans borne, une connexion
 peut abonner jusqu'à l'OOM — un déni de service mémoire déclenché par **un seul** client.
 
-`RealtimeController.startChannel()` (`RealtimeController.ts:746`) refuse au-delà de
+`RealtimeController.startChannel()` (`RealtimeController.ts:815`) refuse au-delà de
 `limits.maxChannelsPerConnection` (`realtime/nodefony/config/config.ts:142`), défaut **256**,
 `null` pour illimité. Points prouvés par `realtimeChannelCap.attack.test.ts` :
 
@@ -693,7 +693,7 @@ au défaut de la librairie `ws`.
 | Limite de **fréquence** des frames entrantes | Un client authentifié peut inonder le peer ; seul le coût CPU le freine |
 | Limite de **connexions par IP ou par utilisateur** | Rien n'empêche N sockets par client au niveau du module |
 | Plafond **global** de canaux du process | Le plafond est par connexion ; M connexions × 256 canaux reste possible |
-| Seuils de back-pressure **configurables** | `slowConsumer.bytes` ne pilote que le **comptage** de la sonde, pas les seuils de drop/close (`WsConnectionTransport` est construit sans override, `RealtimeController.ts:373`) |
+| Seuils de back-pressure **configurables** | `slowConsumer.bytes` ne pilote que le **comptage** de la sonde, pas les seuils de drop/close (`WsConnectionTransport` est construit sans override, `RealtimeController.ts:421`) |
 
 ## ⚙️ Configuration de sécurité
 
@@ -773,7 +773,7 @@ n'est pas appliquée.
 ## 📡 Observabilité — Studio
 
 - **Santé de la socket** : `/nodefony/realtime/api/health`, alimenté par `RealtimeHub.probe()`
-  (`RealtimeHub.ts:849`) — canaux, abonnés, fan-out, connexions, back-pressure et carte d'identité
+  (`RealtimeHub.ts:865`) — canaux, abonnés, fan-out, connexions, back-pressure et carte d'identité
   du backplane. Un `drops` qui grimpe signale des clients en souffrance ; un `slowConsumers` non nul
   précède souvent une fermeture `1013`. Même snapshot en flux sur le canal `nodefony:socket`
   (namespace réservé : `ROLE_NODEFONY_ADMIN`).

package/docs/vocabulaire.md

@@ -127,7 +127,7 @@ vers un autre service — et le consommateur ne voit jamais la différence
 **`contrôleur` est le même mot qu'en HTTP.** Un endpoint temps réel est un contrôleur qui étend
 `RealtimeController` (`RealtimeController.ts:144`) et porte une route WebSocket : HTTP et WebSocket
 vivent dans le **même contexte de contrôleur**. C'est ce qui permet au pont `api.request`
-(`RealtimeController.realtimeApiRequest()`, `RealtimeController.ts:219`) de rejouer sur la socket
+(`RealtimeController.realtimeApiRequest()`, `RealtimeController.ts:276`) de rejouer sur la socket
 **la même action** que celle servie en REST.
 
 ## 🚀 Démarrage rapide — les mots en situation
@@ -270,7 +270,7 @@ Un handler qui lève une erreur rend un `-32603` **générique** ; seule une `Rp
 
 Un canal où le **client a le droit d'émettre** vers le serveur. Défaut sûr : **aucun**. Un canal
 n'accepte d'entrée que déclaré explicitement, par `@RealtimeInbound` (`realtimeDecorators.ts:231`) ou
-par l'override `realtimeInbound()` (`RealtimeController.ts:205`).
+par l'override `realtimeInbound()` (`RealtimeController.ts:262`).
 
 Le handler reçoit `(params, reply)` — `params` vient du réseau, donc **jamais fiable** :
 `RealtimeInboundHandler` (`IRealtimeController.ts:16`).
@@ -297,7 +297,7 @@ importable **sans** aucune dépendance serveur, ce qui est la condition de l'iso
 (`ServerRealtimeSocket.ts:223`) : un service métier tient un handle et publie **comme une page
 front**. Une différence assumée : `request()` n'y est pas supporté — au-dessus du hub il n'y a pas
 **un** pair mais N clients. Pour un appel serveur → un client précis, c'est `requestClient()`
-(`RealtimeController.ts:279`).
+(`RealtimeController.ts:329`).
 
 ### `accueil` (welcome) — la première frame
 
@@ -335,7 +335,7 @@ handshake, jamais renégociée par frame.
 ### `hub` — le broker du process
 
 Le **standard téléphonique** du pod : il tient la table « canal → abonnés locaux » et diffuse. Un
-process = un hub, obtenu par `getRealtimeHub()` (`RealtimeHub.ts:1435`). Il ne connaît **ni** les
+process = un hub, obtenu par `getRealtimeHub()` (`RealtimeHub.ts:1451`). Il ne connaît **ni** les
 contrôleurs, **ni** le métier : ce sont les providers qui portent les dépendances.
 
 `RealtimeHub` (`RealtimeHub.ts:213`). ⚠️ « hub » désigne **toujours** le serveur ; ce que tient le
@@ -395,7 +395,7 @@ Un canal dont la fabrique est déclarée par un module bas niveau (le journal d'
 qui devient servable par **n'importe quel** endpoint, présent ou futur, sans qu'aucun contrôleur ne
 le connaisse. Consulté seulement quand la fabrique du contrôleur a dit « inconnu ».
 
-`RealtimeHub.registerSystemChannel()` (`RealtimeHub.ts:1281`).
+`RealtimeHub.registerSystemChannel()` (`RealtimeHub.ts:1297`).
 
 ### `canal broadcast` — celui qui traverse le backplane
 
@@ -420,7 +420,7 @@ La classe de base d'un endpoint : elle porte tout le protocole (handshake, accue
 des frames, cycle de vie des canaux) et ne laisse au métier que ses canaux et ses actions.
 
 `RealtimeController` (`RealtimeController.ts:144`), point d'entrée `handleRealtime()`
-(`RealtimeController.ts:249`). C'est un **contrôleur** au sens habituel de Nodefony : la même classe
+(`RealtimeController.ts:299`). C'est un **contrôleur** au sens habituel de Nodefony : la même classe
 peut porter des routes HTTP.
 
 ### `service realtime` — la façade d'injection
@@ -437,8 +437,8 @@ L'option qui expose la méthode `api.request { path }` : la connexion rejoue **l
 contrôleur** que celle servie en REST, avec **la même garde**. Le pont n'atteint que les routes qui
 déclarent explicitement le transport WebSocket — aucun contournement possible.
 
-`realtimeApiRequest()` (`RealtimeController.ts:219`), mise en œuvre `invokeApiRequest()`
-(`RealtimeController.ts:878`). Désactivé par défaut.
+`realtimeApiRequest()` (`RealtimeController.ts:276`), mise en œuvre `invokeApiRequest()`
+(`RealtimeController.ts:949`). Désactivé par défaut.
 
 ## 🔌 Le protocole et le transport — ce qui passe sur le fil
 
@@ -630,7 +630,7 @@ l'authenticator tourne et que l'identité est figée. Tout ce qui coûte cher se
 frame.
 
 DTO neutre `IRealtimeHandshake` (`IRealtimeHandshake.ts:14`) — en-têtes, cookies, URL, origine,
-sous-protocoles. Traitement dans `onHandshake()` (`RealtimeController.ts:328`).
+sous-protocoles. Traitement dans `onHandshake()` (`RealtimeController.ts:374`).
 
 ### `authenticator` — du handshake à l'identité
 
@@ -639,7 +639,7 @@ La stratégie qui transforme une poignée de main en identité : `supports` (est
 HTTP — un seul modèle mental pour les deux transports.
 
 `IRealtimeAuthenticator` (`IRealtimeAuthenticator.ts:24`), enregistrement
-`RealtimeHub.useAuthenticator()` (`RealtimeHub.ts:927`).
+`RealtimeHub.useAuthenticator()` (`RealtimeHub.ts:943`).
 
 ### `matcher` — qui capture quoi
 
@@ -647,7 +647,7 @@ Le sélecteur (motif d'URL, hôte optionnel) qui décide **quel** authenticator
 **premier** qui capture gagne : on enregistre donc du plus spécifique au plus général.
 
 `IRealtimeAuthenticatorMatcher` (`IRealtimeAuthenticatorMatcher.ts:25`), résolution
-`resolveAuthenticator()` (`RealtimeHub.ts:945`).
+`resolveAuthenticator()` (`RealtimeHub.ts:961`).
 
 ### `jeton` (token) — l'identité figée
 
@@ -664,7 +664,7 @@ Les exigences déclarées d'un canal : authentifié, rôles, scopes. Elles s'att
 canal, pas à la méthode qui l'implémente — parce que c'est le nom que le pare-feu résout.
 
 `IChannelPolicy` (`IChannelPolicy.ts:20`), déclaration par `@RealtimeChannel`
-(`realtimeDecorators.ts:192`), résolution `resolveChannelPolicy()` (`RealtimeHub.ts:1212`).
+(`realtimeDecorators.ts:192`), résolution `resolveChannelPolicy()` (`RealtimeHub.ts:1228`).
 
 ### `verrou de frame` — la décision par frame
 
@@ -672,8 +672,8 @@ La fonction qui répond « cette frame passe-t-elle ? » à partir du jeton **d
 **Synchrone par doctrine** : attendre une réponse distante à chaque frame sérialiserait le flux d'une
 connexion. Un contrôle qui doit interroger le réseau se fait au handshake, pas ici.
 
-`FrameAuthorizer` (`RealtimeHub.ts:39`), pose `setFrameAuthorizer()` (`RealtimeHub.ts:1023`), appel
-`runAuthorizer()` (`RealtimeHub.ts:1312`).
+`FrameAuthorizer` (`RealtimeHub.ts:39`), pose `setFrameAuthorizer()` (`RealtimeHub.ts:1039`), appel
+`runAuthorizer()` (`RealtimeHub.ts:1328`).
 
 ### `contrôle d'origine` — la défense d'ouverture
 
@@ -689,7 +689,7 @@ Le problème que ce mot nomme : une connexion ouverte pourrait survivre à la se
 autorisée, puisque le verrou de frame ne relit rien. Un contrôle périodique referme l'écart en
 re-validant les identités révocables et en fermant celles qui ne valent plus.
 
-`registerRevocable()` (`RealtimeHub.ts:778`), `revalidateRevocable()` (`RealtimeHub.ts:810`), période
+`registerRevocable()` (`RealtimeHub.ts:794`), `revalidateRevocable()` (`RealtimeHub.ts:826`), période
 `REVOCATION_REVALIDATE_MS` (`RealtimeHub.ts:111`). Une re-validation en erreur **ferme** — jamais
 l'inverse.
 
@@ -728,7 +728,7 @@ ressources ; sans borne, une seule connexion peut les épuiser. Au-delà, l'abon
 client en est informé.
 
 `limits.maxChannelsPerConnection` (`config.ts:142`), pose `setMaxChannelsPerConnection()`
-(`RealtimeHub.ts:979`).
+(`RealtimeHub.ts:995`).
 
 ## 📡 L'observabilité — ce que la socket dit d'elle-même
 
@@ -747,7 +747,7 @@ L'oscilloscope du module : « voici mon état, maintenant ». Canaux et abonnés
 livraisons, connexions, octets, back-pressure, carte d'identité du backplane. Lecture **pure**, sans
 allocation sur le chemin chaud.
 
-`RealtimeHub.probe()` (`RealtimeHub.ts:849`) rend un `IRealtimeProbe` (`IRealtimeProbe.ts:61`).
+`RealtimeHub.probe()` (`RealtimeHub.ts:865`) rend un `IRealtimeProbe` (`IRealtimeProbe.ts:61`).
 
 > [!WARNING]
 > `IRealtimeProbe` est la **forme des données**, pas une interface à implémenter avec une méthode
@@ -807,7 +807,7 @@ elle-même par le même chemin que les autres modules.
 | Deux déploiements se mélangent sur un même serveur Redis           | pas de **cloison** — le numéro de base ne cloisonne pas le pub/sub                                                    | Poser `backplane.namespace` (`config.ts:59`)                                            |
 | Le fan-out disparaît entre conteneurs identiques                   | **origine** dérivée du seul identifiant de processus : deux conteneurs sont tous deux le n° 1, l'anti-écho avale tout | `resolveBackplaneOriginId()` (`originId.ts:24`) dérive du pod ou de l'hôte              |
 | Deux tickers pour le même tableau de bord                          | **cadence** différente = **canal** différent, jamais réconcilié                                                       | Fabriquer le nom via `rateChannel()` (`channelRate.ts:44`) des deux côtés               |
-| Un canal se croit protégé mais laisse tout passer                  | **politique** déclarée sans **verrou de frame** posé pour la faire respecter                                          | Le hub le détecte et avertit : `hasUnenforcedChannelPolicies()` (`RealtimeHub.ts:1101`) |
+| Un canal se croit protégé mais laisse tout passer                  | **politique** déclarée sans **verrou de frame** posé pour la faire respecter                                          | Le hub le détecte et avertit : `hasUnenforcedChannelPolicies()` (`RealtimeHub.ts:1117`) |
 | Une connexion garde ses flux après une déconnexion applicative     | le **verrou de frame** ne relit rien : par construction, il ne voit pas la session mourir                             | Inscrire l'identité au registre de **révocation** (`RealtimeHub.ts:433`)                |
 | « Le provider a planté après la fermeture d'un onglet »            | **provider** confondu avec **sink** : le provider est partagé, il survit à la connexion créatrice                     | N'y capturer que des dépendances à longue vie (`ChannelFactory`, `RealtimeHub.ts:170`)  |
 | « Notre store realtime est indisponible »                          | **store** employé pour **driver** : le backplane ne conserve rien, il fait passer                                     | Dire « le driver de backplane » — les données ont des stores, les flux ont des drivers  |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodefony/realtime",
-  "version": "10.0.0-alpha.9",
+  "version": "10.0.0-beta.1",
   "description": "Couche temps réel serveur de Nodefony : canaux, appels bidirectionnels JSON-RPC 2.0, contre-pression, et diffusion entre plusieurs instances (boucle locale, IPC de grappe, Redis)",
   "author": "Christophe CAMENSULI <ccamensuli@gmail.com>",
   "type": "module",
@@ -41,20 +41,20 @@
     "esm"
   ],
   "peerDependencies": {
-    "@nodefony/framework": "^10.0.0-alpha.9",
-    "@nodefony/http": "^10.0.0-alpha.9",
-    "nodefony": "^10.0.0-alpha.9",
+    "@nodefony/framework": "^10.0.0-beta.1",
+    "@nodefony/http": "^10.0.0-beta.1",
+    "nodefony": "^10.0.0-beta.1",
     "reflect-metadata": "0.2.2",
     "zod": "^4.6.5"
   },
   "devDependencies": {
-    "@nodefony/framework": "^10.0.0-alpha.9",
-    "@nodefony/http": "^10.0.0-alpha.9",
-    "@types/node": "26.6.2",
-    "@vitest/coverage-v8": "5.0.1",
-    "nodefony": "^10.0.0-alpha.9",
+    "@nodefony/framework": "^10.0.0-beta.1",
+    "@nodefony/http": "^10.0.0-beta.1",
+    "@types/node": "26.6.3",
+    "@vitest/coverage-v8": "5.0.2",
+    "nodefony": "^10.0.0-beta.1",
     "reflect-metadata": "0.2.2",
-    "vitest": "5.0.1"
+    "vitest": "5.0.2"
   },
   "private": false,
   "engines": {