@nodefony/realtime 10.0.0-alpha.1

package/dist/nodefony/decorators/realtimeDecorators.js

@@ -0,0 +1,240 @@
+import "reflect-metadata";
+//#region nodefony/decorators/realtimeDecorators.ts
+/** Clés de métadonnées posées sur le constructor de la classe controller. */
+const ACTIONS_KEY = "realtime:actions";
+const CHANNELS_KEY = "realtime:channels";
+const INBOUND_KEY = "realtime:inbound";
+const POLICIES_KEY = "realtime:policies";
+/** Enregistre (idempotent) une politique non vide sous son nom de canal/méthode. */
+function definePolicy(ctor, name, policy) {
+	if (!policy || policy.authenticated === void 0 && policy.roles === void 0 && policy.scopes === void 0) return;
+	const map = Reflect.getMetadata(POLICIES_KEY, ctor) ?? {};
+	map[name] = policy;
+	Reflect.defineMetadata(POLICIES_KEY, map, ctor);
+}
+/**
+* Politique appliquée à une action RPC dont l'auteur n'a rien déclaré :
+* **exiger une connexion authentifiée**. Une action est une méthode que le pair
+* APPELLE et qui AGIT — le défaut sûr est de la fermer, pas de l'ouvrir.
+* Pour une action délibérément publique, l'écrire : `{ authenticated: false }`.
+*/
+const DEFAULT_ACTION_POLICY = Object.freeze({ authenticated: true });
+/** Une politique est-elle DÉJÀ déclarée sous ce nom ? */
+function hasPolicy(ctor, name) {
+	const map = Reflect.getMetadata(POLICIES_KEY, ctor);
+	return map ? Object.prototype.hasOwnProperty.call(map, name) : false;
+}
+/**
+* Décorateur **méthode** — expose une **action RPC** request→response du
+* controller realtime sous le nom `method` (ex. `"nodefony:kernel:ping"`, `"chat:send"`).
+*
+* La méthode décorée devient le handler appelé sur une requête entrante AVEC `id` ;
+* sa valeur de retour est sérialisée comme `result`. Sync OU async (Promise) ;
+* un throw est mappé sur `-32603 internal error` (Zero Trust — message générique
+* au pair, détail loggé via `onError`).
+*
+* Le `this` est lié à l'instance de controller (`handler.bind(instance)` au
+* handshake). La méthode peut donc lire `this.context`, `this.kernel`, etc.
+*
+* **Autorisation — FERMÉE PAR DÉFAUT.** Une action sans `policy` exige une
+* connexion **authentifiée**. C'est délibéré : une action est une méthode que le
+* pair appelle et qui AGIT (`nodefony:kernel:gc`, `nodefony:scaffold:run`, `orders:quote`), et le
+* verrou de frame laisse passer tout ce qu'aucune politique ne couvre — sans ce
+* défaut, toute action applicative serait publique sans que rien ne le dise.
+* Pour une action délibérément ouverte, l'écrire : `{ authenticated: false }`.
+*
+* Si une politique est **déjà déclarée sous ce nom** (canal homonyme via
+* `@RealtimeChannel`/`@RealtimeInbound`), elle est conservée : le défaut ne
+* rétrograde jamais une politique existante, souvent plus stricte.
+*
+* ⚠️ Le NOM peut primer sur ta politique : le plancher système de
+* `@nodefony/security` réserve les préfixes plateforme (`kernel:`, `syslog:`…)
+* **et** tout nom contenant `:health` ou `:stats`. Une action ainsi nommée reste
+* réservée même déclarée `{ authenticated: false }`.
+*
+* @param method - nom RPC exposé au pair.
+* @param policy - politique d'autorisation ; par défaut `{ authenticated: true }`.
+*
+* @example
+*   class ChatController extends RealtimeController {
+*     @RealtimeAction("chat:ping")                       // authentifié requis
+*     ping(): { pong: true; ts: number } {
+*       return { pong: true, ts: Date.now() };
+*     }
+*
+*     @RealtimeAction("admin:purge", { roles: ["ROLE_ADMIN"] })
+*     purge(): void {}
+*
+*     @RealtimeAction("catalog:browse", { authenticated: false })  // ouvert, assumé
+*     browse(): string { return "ok"; }
+*   }
+*/
+function RealtimeAction(method, policy) {
+	return function(target, propertyKey) {
+		const ctor = target.constructor;
+		const map = Reflect.getMetadata(ACTIONS_KEY, ctor) ?? {};
+		map[method] = propertyKey;
+		Reflect.defineMetadata(ACTIONS_KEY, map, ctor);
+		if (policy) definePolicy(ctor, method, policy);
+		else if (!hasPolicy(ctor, method)) definePolicy(ctor, method, DEFAULT_ACTION_POLICY);
+	};
+}
+/**
+* Décorateur **méthode** — expose un **canal pub/sub** sous le nom `channel`
+* (match EXACT, sans préfixe `:<ms>` ni regex). La méthode décorée DOIT renvoyer
+* un `dispose: () => void` (la base le mémorise et l'appelle au dernier
+* désabonné, comme avec l'override classique).
+*
+* v1 — match EXACT uniquement. Les canaux à pattern (`/^nodefony:orm:rich@(\d+)/`) ou à
+* suffixe de granularité (`nodefony:dashboard:1000`) restent dans l'override
+* `createRealtimeChannel()` (la base donne PRIORITÉ aux décorateurs, puis tombe
+* sur l'override en fallback — coexistence sans casse). Un mode `pattern: RegExp`
+* arrivera plus tard sans rompre cette API.
+*
+* Le `this` est lié à l'instance ; le factory peut donc lire `this.kernel`, etc.
+* Mais ATTENTION : un provider est **partagé** entre toutes les connexions au
+* même canal (cf `RealtimeHub.subscribe`) — il survit à la connexion qui l'a
+* créé. Capturer des **valeurs long-lived** (broker, syslog) dans la closure,
+* jamais `this.context` (lié à la connexion créatrice qui peut fermer).
+*
+* @example
+*   class ChatController extends RealtimeController {
+*     @RealtimeChannel("chat:room42")
+*     room42(_channel: string, publish: RealtimePublish): () => void {
+*       const timer = setInterval(() => publish("chat:room42", { ts: Date.now() }), 1000);
+*       return () => clearInterval(timer);
+*     }
+*   }
+*/
+function RealtimeChannel(channel, policy) {
+	return function(target, propertyKey) {
+		const ctor = target.constructor;
+		const map = Reflect.getMetadata(CHANNELS_KEY, ctor) ?? {};
+		map[channel] = propertyKey;
+		Reflect.defineMetadata(CHANNELS_KEY, map, ctor);
+		definePolicy(ctor, channel, policy);
+	};
+}
+/**
+* Décorateur **méthode** — déclare un **canal FULL-DUPLEX entrant** (méthode WS
+* inverse : le client pousse via une notification `method: <name>`, params libres,
+* sans `id`). La méthode décorée reçoit `(params, reply)` :
+*  - `params` : NON FIABLE (entrée client) — valider AVANT d'agir.
+*  - `reply(payload)` : push serveur→client sur le MÊME canal, vers CETTE connexion.
+*
+* Équivalent décoratif de `realtimeInbound()` override. Sécurité : un canal n'est
+* inbound QUE s'il est explicitement déclaré (défaut sûr — un client ne peut rien
+* pousser tant qu'aucun handler n'est enregistré ici). Cf seam P13.8a
+* (`beforeDispatch`) pour la gate sécurité par voter P6.
+*
+* @example
+*   class ChatController extends RealtimeController {
+*     @RealtimeInbound("chat:send")
+*     onChatSend(params: unknown, reply: (payload: unknown) => void): void {
+*       const text = (params as { text?: unknown })?.text;
+*       if (typeof text !== "string") return;
+*       reply({ ok: true, echoed: text });
+*     }
+*   }
+*/
+function RealtimeInbound(method, policy) {
+	return function(target, propertyKey) {
+		const ctor = target.constructor;
+		const map = Reflect.getMetadata(INBOUND_KEY, ctor) ?? {};
+		map[method] = propertyKey;
+		Reflect.defineMetadata(INBOUND_KEY, map, ctor);
+		definePolicy(ctor, method, policy);
+	};
+}
+/** Lecture (lazy, au handshake) du registre des actions décorées. */
+function getRealtimeActions(instance) {
+	const map = Reflect.getMetadata(ACTIONS_KEY, instance.constructor);
+	if (!map) return null;
+	const out = {};
+	for (const [name, prop] of Object.entries(map)) {
+		const fn = instance[prop];
+		if (typeof fn === "function") out[name] = fn.bind(instance);
+	}
+	return out;
+}
+/** Lecture (lazy, au handshake) du registre des canaux décorés. */
+function getRealtimeChannels(instance) {
+	const map = Reflect.getMetadata(CHANNELS_KEY, instance.constructor);
+	if (!map) return null;
+	const out = {};
+	for (const [name, prop] of Object.entries(map)) {
+		const fn = instance[prop];
+		if (typeof fn === "function") out[name] = fn.bind(instance);
+	}
+	return out;
+}
+/** Lecture (lazy, au handshake) du registre des canaux inbound décorés. */
+function getRealtimeInbound(instance) {
+	const map = Reflect.getMetadata(INBOUND_KEY, instance.constructor);
+	if (!map) return null;
+	const out = {};
+	for (const [name, prop] of Object.entries(map)) {
+		const fn = instance[prop];
+		if (typeof fn === "function") out[name] = fn.bind(instance);
+	}
+	return out;
+}
+/**
+* Lecture (lazy, au handshake) des politiques d'autorisation déclarées
+* (`@RealtimeChannel`/`@RealtimeInbound` avec opts). `null` si aucune → le
+* controller n'enregistre rien au hub (0 alloc). Donnée pure (pas de `bind` :
+* une policy n'est pas une méthode), renvoyée telle quelle pour publication au
+* hub realtime, qui l'expose à `@nodefony/security`.
+*/
+function getRealtimeChannelPolicies(instance) {
+	return Reflect.getMetadata(POLICIES_KEY, instance.constructor) ?? null;
+}
+/**
+* Préfixes de canaux **broadcast** déclarés statiquement, tous controllers
+* confondus. Rempli à l'IMPORT des classes (le décorateur s'exécute au
+* chargement du module), donc connu **avant** tout trafic. `Set` : la
+* déclaration est idempotente et deux endpoints peuvent partager un préfixe.
+*/
+const declaredBroadcastPrefixes = /* @__PURE__ */ new Set();
+/**
+* Décorateur **classe** — déclare les préfixes de canaux **broadcast**
+* (cross-process) servis par cet endpoint : leurs publications traversent le
+* {@link IBackplane} au lieu de rester dans le processus.
+*
+* POURQUOI STATIQUE (trouvé sur un banc multi-pods) : la politique de forward
+* est une propriété du code, pas de l'instant. Déclarée seulement au handshake
+* — via l'override `realtimeBroadcastChannels()` — elle laissait un pod qui
+* publie **sans abonné local** (job planifié, webhook, worker) ne rien
+* propager : `publish` évaluait « pas broadcast », en silence. Ici la
+* déclaration existe dès l'import de la classe ; le service l'applique au hub
+* au boot, identiquement sur tous les pods.
+*
+* @example
+*   \@RealtimeBroadcast("chat:", "presence:")
+*   \@controller("/api/chat")
+*   class ChatController extends RealtimeController { … }
+*
+* @param prefixes - préfixes de canal (`"chat:"` couvre `chat:room1:1000`).
+*/
+function RealtimeBroadcast(...prefixes) {
+	return function() {
+		for (const prefix of prefixes) declaredBroadcastPrefixes.add(prefix);
+	};
+}
+/** Préfixes broadcast déclarés par décorateur (introspection / tests). */
+function getDeclaredBroadcastPrefixes() {
+	return [...declaredBroadcastPrefixes];
+}
+/**
+* Applique au hub les préfixes broadcast déclarés statiquement. Appelé au boot
+* par `RealtimeService` — avant tout trafic, donc la politique est en place que
+* le pod ait ou non reçu une connexion. Idempotent
+* ({@link RealtimeHub.markBroadcastChannel} l'est déjà).
+*
+* @param hub - hub à configurer (celui du processus).
+*/
+function applyDeclaredBroadcastPrefixes(hub) {
+	for (const prefix of declaredBroadcastPrefixes) hub.markBroadcastChannel(prefix);
+}
+//#endregion
+export { DEFAULT_ACTION_POLICY, RealtimeAction, RealtimeBroadcast, RealtimeChannel, RealtimeInbound, applyDeclaredBroadcastPrefixes, getDeclaredBroadcastPrefixes, getRealtimeActions, getRealtimeChannelPolicies, getRealtimeChannels, getRealtimeInbound };

package/dist/nodefony/interfaces/IBackplane.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/IChannelPolicy.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/IClientLogsLimits.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/IRealtimeAuthenticator.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/IRealtimeAuthenticatorMatcher.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/IRealtimeController.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/IRealtimeHandshake.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/IRealtimeProbe.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/IRealtimeToken.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/interfaces/index.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,105 @@
+import resolveBackplaneOriginId from "./originId.js";
+import { CLUSTER_RT_KIND } from "nodefony";
+//#region nodefony/src/backplane/ClusterBackplane.ts
+/**
+* Transport de production : `process.send` (émission) + `process.on("message")`
+* (réception). Standalone — utilisable tel quel. En vrai câblage cluster (Phase 3c),
+* un transport branché sur l'event kernel `onMessage` (déjà alimenté par
+* `Kernel.initCluster`) est préféré pour éviter un 2ᵉ listener + le log par message.
+*/
+const processIpcTransport = {
+	send(env) {
+		process.send?.(env);
+	},
+	onReceive(cb) {
+		process.on("message", (msg) => cb(msg));
+	}
+};
+/**
+* Type-guard d'enveloppe realtime — narrowing sûr d'un message IPC `unknown`.
+* Filtre tout ce qui n'est pas une publication realtime (autres messages de contrôle).
+*/
+function isEnvelope(m) {
+	if (typeof m !== "object" || m === null) return false;
+	const e = m;
+	return e.kind === CLUSTER_RT_KIND && typeof e.channel === "string" && typeof e.originId === "string";
+}
+/**
+* Backplane **IPC cross-process** (Phase 3) — implémentation worker-side du port
+* {@link IBackplane} dans un cluster Node natif, où les workers ne se parlent qu'à
+* travers le **master-gateway** (un worker ne peut envoyer qu'au master via IPC).
+*
+* Flux d'une publication cross-process :
+*  - {@link publish} → emballe `{kind,channel,payload,originId}` → `transport.send`
+*    (worker → master) ; le master rebroadcast aux **autres** workers (cf `ClusterRelay`,
+*    Phase 3b) ; le fan-out **local** a déjà été fait par le hub avant cet appel ;
+*  - réception (master → worker) → {@link onMessage} handler → le hub réinjecte en
+*    fan-out **local uniquement** (`publishLocal`), jamais re-publié (anti-boucle).
+*
+* Anti-echo (2ᵉ barrière du contrat) : à la réception, on **filtre son propre
+* `originId`** — même si le master renvoyait à la source, le worker l'ignore.
+*
+* Perf : hors mono-process (où le hub garde `#backplane === null` → ce code ne tourne
+* jamais). En cluster, `publish` alloue 1 enveloppe + 1 sérialisation IPC (coût dominé
+* par l'IPC, pas par l'alloc) — sur le chemin realtime broadcast (tickers/fan-out),
+* PAS sur le hot path du request HTTP. SERVEUR uniquement (`process`).
+*/
+var ClusterBackplane = class ClusterBackplane {
+	/** Nom du driver — source unique du littéral (registre + config). */
+	static driver = "cluster";
+	originId;
+	#transport;
+	#handler = null;
+	#started = false;
+	constructor(transport = processIpcTransport, originId = resolveBackplaneOriginId()) {
+		this.#transport = transport;
+		this.originId = originId;
+	}
+	/** Branche la réception IPC. Idempotent. */
+	start() {
+		if (this.#started) return;
+		this.#started = true;
+		this.#transport.onReceive((msg) => this.#ingress(msg));
+	}
+	/**
+	* Propage une publication locale aux autres pairs via le master. NE refait PAS le
+	* fan-out local (déjà fait par le hub). Sérialisé par le transport IPC.
+	*/
+	publish(channel, payload) {
+		this.#transport.send({
+			kind: CLUSTER_RT_KIND,
+			channel,
+			payload,
+			originId: this.originId
+		});
+	}
+	/** Un seul handler d'ingress ; un appel ultérieur remplace le précédent. */
+	onMessage(handler) {
+		this.#handler = handler;
+	}
+	/** Tri + anti-echo + délégation au handler. Robuste : ignore tout message non-realtime. */
+	#ingress(msg) {
+		if (!isEnvelope(msg)) return;
+		if (msg.originId === this.originId) return;
+		this.#handler?.({
+			channel: msg.channel,
+			payload: msg.payload,
+			originId: msg.originId
+		});
+	}
+	/** Détache le handler. Le listener du transport prod (`process`) survit au process. */
+	stop() {
+		this.#handler = null;
+		this.#started = false;
+	}
+	describe() {
+		return {
+			driver: ClusterBackplane.driver,
+			kind: "ipc",
+			originId: this.originId,
+			crossPod: false
+		};
+	}
+};
+//#endregion
+export { ClusterBackplane, ClusterBackplane as default, processIpcTransport };

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

@@ -0,0 +1,40 @@
+import resolveBackplaneOriginId from "./originId.js";
+//#region nodefony/src/backplane/LoopbackBackplane.ts
+/**
+* Backplane **mono-process no-op** — implémentation de RÉFÉRENCE du port
+* {@link IBackplane} quand il n'existe **aucun pair** (1 process = 1 pod).
+*
+* `publish` ne sort rien (pas de pair à qui propager), `onMessage` ne fire jamais
+* (rien n'arrive de l'extérieur) → 0 fan-out cross-process, le hub se comporte
+* exactement comme en local pur.
+*
+* Rôle : (1) matérialiser le contrat pour les tests (cible de vérification du câblage
+* du hub) ; (2) câblage explicite « backplane présent mais inactif ». NB perf : en
+* mono-process le {@link RealtimeHub} garde `#backplane === null` (0 overhead réel,
+* style lazy du fichier) — ce Loopback n'est donc PAS sur le hot path par défaut, il
+* sert à prouver que brancher un backplane ne change rien tant qu'il n'y a pas de pair.
+*
+* SERVEUR uniquement (`process.pid`) — pas isomorphe.
+*/
+var LoopbackBackplane = class LoopbackBackplane {
+	/** Nom du driver — source unique du littéral (registre + config). */
+	static driver = "loopback";
+	originId;
+	constructor(originId = resolveBackplaneOriginId()) {
+		this.originId = originId;
+	}
+	start() {}
+	publish(_channel, _payload) {}
+	onMessage(_handler) {}
+	stop() {}
+	describe() {
+		return {
+			driver: LoopbackBackplane.driver,
+			kind: "local",
+			originId: this.originId,
+			crossPod: false
+		};
+	}
+};
+//#endregion
+export { LoopbackBackplane, LoopbackBackplane as default };

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

@@ -0,0 +1,176 @@
+import resolveBackplaneOriginId from "./originId.js";
+import { openBackplaneEnvelope, sealBackplaneEnvelope } from "./envelope.js";
+import { BackplanePublishQueue } from "./publishQueue.js";
+//#region nodefony/src/backplane/RedisBackplane.ts
+/**
+* BASE du canal Redis **dédié** transportant les enveloppes realtime entre pods.
+* Un seul canal pub/sub par app (les canaux logiques voyagent DANS l'enveloppe,
+* comme le `channel` IPC du {@link ClusterBackplane}) → 1 `SUBSCRIBE` au boot, pas
+* de (dés)abonnement Redis dynamique par canal applicatif.
+*
+* ⚠️ Le `database` Redis ne cloisonne PAS le pub/sub (global au serveur) → sur un
+* Redis mutualisé, deux apps sur le même canal se parlent (cross-talk). Le canal
+* effectif est donc suffixé par un namespace via {@link resolveRedisChannel}
+* (config `backplane.namespace`, sinon dérivé de `kernel.projectName` au wiring).
+*/
+const REDIS_RT_CHANNEL = "nodefony:realtime";
+/**
+* Construit le canal pub/sub effectif : `nodefony:realtime:<namespace>`, ou la
+* base seule si aucun namespace n'est résolu (compat mono-app). Deux déploiements
+* de la MÊME app sur un Redis partagé (staging + prod) ont le même nom dérivé →
+* y poser un `backplane.namespace` EXPLICITE distinct.
+*
+* @param namespace - cloison logique (config `backplane.namespace` ou nom d'app).
+* @returns le nom du canal Redis à `SUBSCRIBE`/`PUBLISH`.
+*/
+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 });
+* ```
+*
+* Le listener Redis est conservé pour un `unsubscribe(channel, listener)` ciblé
+* (n'arrache pas d'éventuels autres abonnés du même client).
+*/
+function createRedisServiceTransport(publisher, subscriber) {
+	let listener = null;
+	return {
+		publish(channel, message) {
+			return publisher.publish(channel, message);
+		},
+		subscribe(channel, onMessage) {
+			listener = (message) => onMessage(message);
+			return subscriber.subscribe(channel, listener);
+		},
+		unsubscribe(channel) {
+			const current = listener;
+			listener = null;
+			return current ? subscriber.unsubscribe(channel, current) : subscriber.unsubscribe(channel);
+		}
+	};
+}
+/**
+* Backplane **Redis pub/sub** (P13.5) — implémentation du port {@link IBackplane}
+* pour le fan-out realtime **cross-pod** (multi-host), là où le {@link ClusterBackplane}
+* ne couvrait que les workers d'un même pod (IPC). **Drop-in** : le hub ne change pas,
+* seul le driver branché change.
+*
+* Flux d'une publication cross-pod :
+*  - {@link publish} → emballe `{channel,payload,originId}` → `PUBLISH nodefony:realtime`
+*    (le fan-out **local** a déjà été fait par le hub avant cet appel) ;
+*  - réception (`SUBSCRIBE`) → {@link onMessage} handler → le hub réinjecte en
+*    fan-out **local uniquement** (`publishLocal`), jamais re-publié (anti-boucle).
+*
+* Anti-echo (2ᵉ barrière du contrat) : Redis renvoie au pod émetteur ce qu'il
+* publie (publisher + subscriber sont 2 connexions du même pod) → on **filtre son
+* propre `originId`** à la réception, sinon double fan-out local.
+*
+* Authenticité (F83) : Redis pub/sub n'authentifie PAS l'émetteur d'un message —
+* quiconque écrit dans ce Redis (autre app d'un Redis mutualisé, credential fuité,
+* SSRF vers le port) publierait sur les canaux de tous les pods. Avec un `secret`
+* partagé, l'enveloppe est **scellée** (HMAC, cf `envelope.ts`) et l'ingress devient
+* fail-closed strict : non scellé ou mal scellé = ignoré, sans downgrade possible.
+* Sans secret le transport reste ouvert (compat) — le wiring alerte alors au boot.
+*
+* Livraison : **best-effort / at-most-once** — pub/sub Redis ne persiste ni ne
+* rejoue ; un pod déconnecté rate les messages émis pendant sa coupure (le client
+* realtime re-synchronise). Ne pas sur-concevoir une fiabilité que le backing
+* n'offre pas (cf contrat {@link IBackplane}).
+*
+* Perf : hors mono-process (où le hub garde `#backplane === null`). `publish`
+* alloue 1 enveloppe + 1 `JSON.stringify` — sur le chemin broadcast realtime
+* (tickers/fan-out), PAS sur le hot path HTTP. SERVEUR uniquement (`process.pid`).
+*/
+var RedisBackplane = class RedisBackplane {
+	/** Nom du driver — source unique du littéral (registre + config). */
+	static driver = "redis";
+	originId;
+	#transport;
+	#redisChannel;
+	/** Secret de scellement partagé entre pods ; `null` = bus non authentifié. */
+	#secret;
+	/** Borne mémoire des publications en vol (cf {@link BackplanePublishQueue}). */
+	#queue;
+	#handler = null;
+	#started = false;
+	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);
+	}
+	/**
+	* Abonne au canal Redis dédié. Idempotent (le flag est posé avant l'`await` →
+	* un 2ᵉ appel concurrent ne ré-abonne pas).
+	*/
+	async start() {
+		if (this.#started) return;
+		this.#started = true;
+		await this.#transport.subscribe(this.#redisChannel, (raw) => this.#ingress(raw));
+	}
+	/**
+	* Propage une publication locale aux autres pods via Redis. NE refait PAS le
+	* fan-out local (déjà fait par le hub). Sérialisé une fois ici.
+	*
+	* L'envoi passe par la **file bornée** : si le bus n'acquitte plus, les
+	* publications suivantes sont jetées et comptées plutôt que d'empiler des
+	* mégaoctets dans le client Redis (sémantique at-most-once déjà assumée par le
+	* port ; le client realtime re-synchronise).
+	*/
+	publish(channel, payload) {
+		const env = {
+			channel,
+			payload,
+			originId: this.originId
+		};
+		const raw = sealBackplaneEnvelope(env, this.#secret);
+		this.#queue.send(Buffer.byteLength(raw), () => this.#transport.publish(this.#redisChannel, raw));
+	}
+	/** Un seul handler d'ingress ; un appel ultérieur remplace le précédent. */
+	onMessage(handler) {
+		this.#handler = handler;
+	}
+	/**
+	* 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.
+	*/
+	#ingress(raw) {
+		const msg = openBackplaneEnvelope(raw, this.#secret);
+		if (msg === null) return;
+		if (msg.originId === this.originId) return;
+		this.#handler?.(msg);
+	}
+	/** 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);
+	}
+	describe() {
+		return {
+			driver: RedisBackplane.driver,
+			kind: "redis-pubsub",
+			originId: this.originId,
+			crossPod: true,
+			channel: this.#redisChannel,
+			sealed: this.#secret !== null,
+			queue: this.#queue.describe()
+		};
+	}
+};
+//#endregion
+export { REDIS_RT_CHANNEL, RedisBackplane, RedisBackplane as default, createRedisServiceTransport, resolveRedisChannel };

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

@@ -0,0 +1,20 @@
+//#region nodefony/src/backplane/backplaneRegistry.ts
+const drivers = /* @__PURE__ */ new Map();
+/**
+* Enregistre (ou remplace) la fabrique d'un driver backplane. Appelé par les
+* drivers natifs au chargement du module, et par l'utilisateur pour ses drivers
+* custom (NATS, Pulsar, RabbitMQ…).
+*/
+function registerBackplaneDriver(name, factory) {
+	drivers.set(name, factory);
+}
+/** Fabrique d'un driver par nom, ou `undefined` si inconnu. */
+function getBackplaneDriver(name) {
+	return drivers.get(name);
+}
+/** Noms des drivers enregistrés (introspection / Studio / tests). */
+function listBackplaneDrivers() {
+	return [...drivers.keys()];
+}
+//#endregion
+export { getBackplaneDriver, listBackplaneDrivers, registerBackplaneDriver };