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

package/dist/nodefony/decorators/realtimeDecorators.js

@@ -1,4 +1,6 @@
 import { isCallable, isRecord } from "../src/guards.js";
+import { presenceDefect, samePresence } from "../src/server/channelPresence.js";
+import { BootConfigurationError, Injector, channelPatternWeight, compileChannelPattern } from "nodefony";
 import "reflect-metadata";
 // nodefony/decorators/realtimeDecorators.ts
 /** Clés de métadonnées posées sur le constructor de la classe controller. */
@@ -6,6 +8,10 @@ const ACTIONS_KEY = "realtime:actions";
 const CHANNELS_KEY = "realtime:channels";
 const INBOUND_KEY = "realtime:inbound";
 const POLICIES_KEY = "realtime:policies";
+const WRITE_POLICIES_KEY = "realtime:write-policies";
+const OWN_READ_KEY = "realtime:policies:own-read";
+const OWN_WRITE_KEY = "realtime:policies:own-write";
+const CONFLICTS_KEY = "realtime:policies:conflicts";
 /**
 * Lit une métadonnée de classe posée par ces décorateurs : un objet nom → valeur,
 * ou `undefined` quand la classe n'en porte pas. Les valeurs restent `unknown` :
@@ -16,33 +22,138 @@ function readMetadataMap(key, ctor) {
 	const raw = Reflect.getMetadata(key, ctor);
 	return isRecord(raw) ? raw : void 0;
 }
+/** Comme {@link readMetadataMap}, sans remonter la chaîne de prototypes : ce que la classe a posé ELLE-MÊME. */
+function readOwnMetadataMap(key, ctor) {
+	const raw = Reflect.getOwnMetadata(key, ctor);
+	return isRecord(raw) ? raw : void 0;
+}
 /** Vrai si la valeur est un tableau de chaînes. */
 function isStringArray(value) {
 	return Array.isArray(value) && value.every((v) => typeof v === "string");
 }
-/** Vrai si la valeur a la forme d'une {@link IChannelPolicy}. */
+/**
+* Clés qu'une politique de canal peut porter — toute autre est refusée : une
+* faute de frappe (`role`, `alow`) dans une règle de sécurité ne s'ignore pas.
+*/
+const POLICY_KEYS = /* @__PURE__ */ new Set([
+	"authenticated",
+	"roles",
+	"scopes",
+	"allow",
+	"anonymous",
+	"presence"
+]);
+/**
+* `allow` désigne-t-il une classe d'admission (`@injectable`) plutôt qu'une flèche ?
+*
+* Tranché par la métadonnée `@injectable`, jamais par le texte de la fonction
+* (`class …`), qu'un minifieur réécrit (ADR-0021 §S10 bis).
+*
+* @param allow - valeur du membre `allow` d'une politique déjà validée.
+* @returns `true` pour une classe à résoudre par l'injecteur.
+*/
+function isAdmissionClass(allow) {
+	return Injector.isInjectable(allow);
+}
+/**
+* Défaut d'une politique de canal, ou `null` si elle est recevable — en clair, pour que le refus au démarrage dise QUOI corriger.
+*
+* @param value - valeur lue sous la métadonnée des politiques (`unknown` :
+*   `Reflect.defineMetadata` est public).
+* @returns la raison du refus, ou `null`.
+*/
+function channelPolicyDefect(value) {
+	if (!isRecord(value)) return "la politique n'est pas un objet";
+	for (const key of Object.keys(value)) if (!POLICY_KEYS.has(key)) return `clé inconnue « ${key} » (clés admises : ${[...POLICY_KEYS].join(", ")})`;
+	const { authenticated, roles, scopes, allow, anonymous, presence } = value;
+	const presenceIssue = presenceDefect(presence);
+	if (presenceIssue !== null) return presenceIssue;
+	if (authenticated !== void 0 && typeof authenticated !== "boolean") return "« authenticated » doit être un booléen";
+	if (roles !== void 0 && !isStringArray(roles)) return "« roles » doit être un tableau de chaînes";
+	if (scopes !== void 0 && !isStringArray(scopes)) return "« scopes » doit être un tableau de chaînes";
+	if (anonymous !== void 0 && typeof anonymous !== "boolean") return "« anonymous » doit être un booléen";
+	if (allow === void 0) return anonymous === void 0 ? null : "« anonymous » n'a de sens qu'avec « allow »";
+	if (typeof allow !== "function") return "« allow » doit être une fonction ou une classe @injectable";
+	if (anonymous === true && authenticated === true) return "« anonymous: true » contredit « authenticated: true »";
+	const proto = Reflect.get(allow, "prototype");
+	if (!Injector.isInjectable(allow) && isRecord(proto) && typeof proto.allow === "function") return `« allow » est une classe (${allow.name}) sans @injectable`;
+	return null;
+}
+/** Une valeur lue sous la métadonnée des politiques est-elle une politique recevable ? */
 function isChannelPolicy(value) {
-	if (!isRecord(value)) return false;
-	const { authenticated, roles, scopes } = value;
-	return (authenticated === void 0 || typeof authenticated === "boolean") && (roles === void 0 || isStringArray(roles)) && (scopes === void 0 || isStringArray(scopes));
+	return channelPolicyDefect(value) === null;
 }
-/** Vrai si chaque entrée du registre est une {@link IChannelPolicy}. */
-function isPolicyMap(map) {
-	for (const name in map) if (!isChannelPolicy(map[name])) return false;
+const NO_NAMES = [];
+/** Deux listes de rôles ou de scopes désignent-elles le même ENSEMBLE — ordre et doublons indifférents, absente = vide ? */
+function sameNames(a, b) {
+	const x = a ?? NO_NAMES;
+	const y = b ?? NO_NAMES;
+	for (const name of x) if (!y.includes(name)) return false;
+	for (const name of y) if (!x.includes(name)) return false;
 	return true;
 }
+/**
+* Deux politiques exigent-elles exactement la même chose ? Structurel : deux littéraux identiques écrits dans deux classes le sont ; `allow` se compare par référence.
+*
+* Sert à refuser deux déclarations CONTRADICTOIRES d'un même nom (une seule
+* s'appliquerait) sans refuser deux déclarations ÉQUIVALENTES, et à ne juger
+* l'écriture que si elle diffère de la lecture. Démarrage seulement.
+*
+* @param a - une politique recevable.
+* @param b - une politique recevable.
+* @returns `true` si aucun pair ne peut satisfaire l'une sans l'autre.
+*/
+function samePolicy(a, b) {
+	if (a === b) return true;
+	return a.authenticated === true === (b.authenticated === true) && sameNames(a.roles, b.roles) && sameNames(a.scopes, b.scopes) && a.allow === b.allow && a.anonymous === true === (b.anonymous === true);
+}
+/**
+* Exige que chaque entrée du registre soit une politique recevable — sinon le démarrage s'arrête en nommant la classe, le canal et le défaut.
+*
+* Une politique illisible ne se laisse jamais tomber : sans elle, le canal
+* s'ouvrirait à qui la politique fermait (fail-closed).
+*/
+function assertPolicyMap(owner, map) {
+	for (const name in map) {
+		const defect = channelPolicyDefect(map[name]);
+		if (defect !== null) throw new BootConfigurationError(`${owner} : politique du canal temps réel « ${name} » refusée — ${defect}`);
+	}
+}
 /** Méthode de l'instance que désigne une entrée de registre, ou `undefined`. */
 function methodOf(instance, prop) {
 	return typeof prop === "string" || typeof prop === "symbol" ? Reflect.get(instance, prop) : void 0;
 }
+/** La politique porte-t-elle au moins une clé propre non `undefined` ? */
+function hasDefinedKey(policy) {
+	for (const key of Object.keys(policy)) if (Reflect.get(policy, key) !== void 0) return true;
+	return false;
+}
 /** Libération d'un canal dont la fabrique décorée n'en a rendu aucune. */
 const NO_DISPOSE = () => {};
-/** 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 = { ...readMetadataMap(POLICIES_KEY, ctor) };
-	map[name] = policy;
-	Reflect.defineMetadata(POLICIES_KEY, map, ctor);
+/**
+* Déclare une politique non vide d'une sorte sous son nom — sans jamais écraser une déclaration contradictoire de la même classe : celle-ci est retenue pour refuser le démarrage.
+*/
+function declarePolicy(ctor, name, kind, policy) {
+	if (!policy || !hasDefinedKey(policy)) return;
+	const key = kind === "read" ? POLICIES_KEY : WRITE_POLICIES_KEY;
+	const ownKey = kind === "read" ? OWN_READ_KEY : OWN_WRITE_KEY;
+	const own = readOwnMetadataMap(ownKey, ctor);
+	const current = readMetadataMap(key, ctor)?.[name];
+	if (own?.[name] === true && current !== void 0 && !(isChannelPolicy(current) && isChannelPolicy(policy) && samePolicy(current, policy) && samePresence(current, policy))) {
+		Reflect.defineMetadata(CONFLICTS_KEY, {
+			...readOwnMetadataMap(CONFLICTS_KEY, ctor),
+			[name]: kind
+		}, ctor);
+		return;
+	}
+	Reflect.defineMetadata(key, {
+		...readMetadataMap(key, ctor),
+		[name]: policy
+	}, ctor);
+	Reflect.defineMetadata(ownKey, {
+		...own,
+		[name]: true
+	}, ctor);
 }
 /**
 * Politique appliquée à une action RPC dont l'auteur n'a rien déclaré :
@@ -51,11 +162,6 @@ function definePolicy(ctor, name, policy) {
 * 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 = readMetadataMap(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"`).
@@ -75,9 +181,12 @@ function hasPolicy(ctor, name) {
 * 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.
+* Une politique d'action est une politique d'**écriture** : l'appel exige aussi
+* la lecture déclarée sous le même nom. Sans politique, l'action **hérite** de la
+* lecture d'un canal homonyme (`@RealtimeChannel`) si elle existe — le défaut ne
+* rétrograde jamais une politique déclarée —, et sinon du défaut fermé, quel que
+* soit l'ordre des méthodes. Deux politiques explicites différentes sur le même
+* nom (action et `@RealtimeInbound`) refusent le démarrage.
 *
 * ⚠️ Le NOM peut primer sur ta politique : le plancher système de
 * `@nodefony/security` réserve les préfixes plateforme (`kernel:`, `syslog:`…)
@@ -107,21 +216,62 @@ function RealtimeAction(method, policy) {
 		const map = { ...readMetadataMap(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);
+		declarePolicy(ctor, method, "write", policy);
+	};
+}
+/**
+* Décorateur de **classe** — pose les politiques d'accès d'actions ou de canaux
+* par leur NOM, sans déclarer de handler.
+*
+* C'est la voie des actions servies par la table de `realtimeActions()` : cette
+* table ne sait pas porter de politique, et un `@RealtimeAction` ajouté pour la
+* seule politique ferait fabriquer, à chaque connexion, un handler aussitôt
+* écrasé par la table (et contournerait l'injection de ses paramètres décorés).
+* Ici, rien par connexion : les politiques sont écrites UNE fois, à la
+* définition de la classe, dans le même registre que celles des décorateurs de
+* méthode. Une action de la table sans politique garde le défaut FERMÉ
+* (connexion authentifiée).
+*
+* Un nom qui porte `*` est un motif (famille de canaux), comme partout ailleurs.
+*
+* La politique vaut pour la LECTURE et l'ÉCRITURE du nom (le même objet, jugé
+* une fois). Elle prime sur le défaut fermé d'une action ; contredire une
+* politique explicite d'un décorateur de méthode refuse le démarrage.
+*
+* **Sur un contrôleur de contrat** (`extends ContractRealtimeController<C>`), le
+* décorateur lit le contrat sur la classe qu'il décore : chaque nom doit être
+* une méthode ou un canal de `C`, sinon la classe ne compile pas, et l'erreur
+* nomme le fautif (`notInContract`). Le contrat ne se répète pas. Sur un
+* contrôleur sans contrat, tout nom est accepté. Vérification à la compilation
+* seulement : coût d'exécution nul.
+*
+* @param policies - nom d'action ou de canal → politique.
+*
+* @example
+*   @RealtimePolicy({ "orders:quote": { roles: ["ROLE_SALES"] } })
+*   class OrdersRt extends ContractRealtimeController<OrdersContract> { … }
+*/
+function RealtimePolicy(policies) {
+	return function(target) {
+		for (const [name, policy] of Object.entries(policies)) {
+			declarePolicy(target, name, "read", policy);
+			declarePolicy(target, name, "write", 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écorateur **méthode** — expose un **canal pub/sub** sous le nom `channel`, ou
+* une FAMILLE de canaux sous un motif (`chat:room:*`). 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.
+* Un motif (`*` = toute suite de caractères, la grammaire des politiques) sert
+* chaque nom qu'il couvre : `@RealtimeChannel("chat:room:*", { allow })` déclare
+* la règle ET la fabrique de tous les salons, et la méthode reçoit le nom réel
+* (`chat:room:42`) en premier argument. Ordre de résolution au `subscribe` : le
+* nom exact décoré, puis l'override `createRealtimeChannel()` (canaux à suffixe
+* de granularité, regex — un contrôleur qui en a un garde son comportement),
+* puis les motifs décorés, du plus spécifique au plus général.
 *
 * 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
@@ -129,8 +279,20 @@ function RealtimeAction(method, policy) {
 * créé. Capturer des **valeurs long-lived** (broker, syslog) dans la closure,
 * jamais `this.context` (lié à la connexion créatrice qui peut fermer).
 *
+* La `policy` est celle de **LECTURE** : exigée au `subscribe`, et en plus de
+* l'écriture sur toute trame entrante du même nom. Absente, la lecture hérite de
+* l'écriture (`@RealtimeInbound`) si elle est déclarée — une application qui ne
+* garde que l'écriture reste protégée en lecture. Pour un canal que tout le
+* monde lit et que seuls certains écrivent, l'écrire : `{ authenticated: false }`.
+*
 * @example
 *   class ChatController extends RealtimeController {
+*     // Tous les salons : la règle et la fabrique, une seule fois.
+*     @RealtimeChannel("chat:room:*", { allow: RoomAdmission })
+*     room(_channel: string): () => void {
+*       return () => {};
+*     }
+*
 *     @RealtimeChannel("chat:room42")
 *     room42(_channel: string, publish: RealtimePublish): () => void {
 *       const timer = setInterval(() => publish("chat:room42", { ts: Date.now() }), 1000);
@@ -144,7 +306,7 @@ function RealtimeChannel(channel, policy) {
 		const map = { ...readMetadataMap(CHANNELS_KEY, ctor) };
 		map[channel] = propertyKey;
 		Reflect.defineMetadata(CHANNELS_KEY, map, ctor);
-		definePolicy(ctor, channel, policy);
+		declarePolicy(ctor, channel, "read", policy);
 	};
 }
 /**
@@ -159,6 +321,20 @@ function RealtimeChannel(channel, policy) {
 * pousser tant qu'aucun handler n'est enregistré ici). Cf seam P13.8a
 * (`beforeDispatch`) pour la gate sécurité par voter P6.
 *
+* La `policy` est celle d'**ÉCRITURE** : une trame entrante exige la LECTURE du
+* même nom (`@RealtimeChannel`) ET elle — l'écriture n'est jamais moins stricte
+* que la lecture. Sans lecture déclarée, la lecture en hérite.
+*
+* @example
+*   class ChatController extends RealtimeController {
+*     @RealtimeChannel("chat:typing", { authenticated: false }) // tout le monde lit
+*     typing(_channel: string, _publish: RealtimePublish): () => void {
+*       return () => {};
+*     }
+*     @RealtimeInbound("chat:typing", { authenticated: true }) // seuls les connectés écrivent
+*     onTyping(): void {}
+*   }
+*
 * @example
 *   class ChatController extends RealtimeController {
 *     @RealtimeInbound("chat:send")
@@ -175,7 +351,7 @@ function RealtimeInbound(method, policy) {
 		const map = { ...readMetadataMap(INBOUND_KEY, ctor) };
 		map[method] = propertyKey;
 		Reflect.defineMetadata(INBOUND_KEY, map, ctor);
-		definePolicy(ctor, method, policy);
+		declarePolicy(ctor, method, "write", policy);
 	};
 }
 /**
@@ -216,6 +392,47 @@ function getRealtimeChannels(instance) {
 	}
 	return out;
 }
+/**
+* Motifs décorés de chaque classe, compilés au premier besoin : du plus
+* spécifique au plus général. Par CLASSE et non par instance — un contrôleur
+* temps réel est instancié par connexion, ses motifs ne changent pas.
+*/
+const decoratedPatterns = /* @__PURE__ */ new WeakMap();
+/**
+* La fabrique décorée sous un MOTIF qui couvre `channel` — `@RealtimeChannel("chat:room:*")` sert `chat:room:42` —, ou `null` si aucun motif ne le couvre.
+*
+* Même grammaire que les politiques (`compileChannelPattern`) et même
+* départage (`channelPatternWeight`, le plus spécifique d'abord) : un nom
+* reçoit la fabrique du motif dont il reçoit la règle. Un motif refusé par la
+* grammaire (trop d'étoiles) ne sert rien — le hub le dit déjà au démarrage.
+* Cold path : appelé au premier abonné d'un canal qu'aucun nom exact ni
+* `createRealtimeChannel` ne produit.
+*
+* @param instance - le contrôleur ; ses motifs se lisent sur sa classe.
+* @param channels - le registre rendu par {@link getRealtimeChannels}.
+* @param channel - le nom demandé.
+*/
+function patternChannelFactory(instance, channels, channel) {
+	if (channels === null) return null;
+	let patterns = decoratedPatterns.get(instance.constructor);
+	if (patterns === void 0) {
+		const compiled = [];
+		for (const source of Object.keys(channels)) {
+			if (!source.includes("*")) continue;
+			const re = compileChannelPattern(source);
+			if (re !== null) compiled.push({
+				source,
+				re,
+				weight: channelPatternWeight(source)
+			});
+		}
+		compiled.sort((a, b) => b.weight - a.weight);
+		patterns = compiled;
+		decoratedPatterns.set(instance.constructor, patterns);
+	}
+	for (const pattern of patterns) if (pattern.re.test(channel)) return channels[pattern.source] ?? null;
+	return null;
+}
 /** Lecture (lazy, au handshake) du registre des canaux inbound décorés. */
 function getRealtimeInbound(instance) {
 	const map = readMetadataMap(INBOUND_KEY, instance.constructor);
@@ -228,17 +445,98 @@ function getRealtimeInbound(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`.
+* La classe déclare-t-elle une ACTION (`@RealtimeAction`) sous ce nom ? Sert à refuser un `allow` posé sur une action, que rien n'appliquerait.
+*
+* @param ctor - constructeur du contrôleur.
+* @param name - nom d'action ou de canal.
+*/
+function declaresAction(ctor, name) {
+	const map = readMetadataMap(ACTIONS_KEY, ctor);
+	return map !== void 0 && Object.prototype.hasOwnProperty.call(map, name);
+}
+/**
+* Politiques déclarées sur une CLASSE de contrôleur, validées et résolues par sorte — lues au démarrage du noyau, jamais par trame.
+*
+* Résolution indépendante de l'ordre des méthodes :
+* - l'écriture d'un nom est celle déclarée (`@RealtimeInbound`, `@RealtimeAction`
+*   avec politique, `@RealtimePolicy`) ; pour une action SANS politique, le
+*   défaut fermé, sauf si une lecture est déclarée — l'action en hérite alors ;
+* - la lecture est celle déclarée (`@RealtimeChannel`, `@RealtimePolicy`),
+*   sinon l'écriture : une application qui ne garde que l'écriture reste
+*   protégée en lecture ;
+* - `kinds` garde ce que la classe déclare, SANS héritage : le hub le fusionne
+*   avec les motifs de toutes les classes, sorte par sorte.
+*
+* @param ctor - constructeur du contrôleur.
+* @returns les deux tables, ou `null` si la classe ne déclare aucune politique.
+* @throws BootConfigurationError Une politique est illisible, ou deux
+*   déclarations d'une même sorte se contredisent : la classe, le canal et le
+*   défaut sont nommés.
+*/
+function getDeclaredChannelPolicies(ctor) {
+	const readMap = readMetadataMap(POLICIES_KEY, ctor);
+	const writeMap = readMetadataMap(WRITE_POLICIES_KEY, ctor);
+	const actions = readMetadataMap(ACTIONS_KEY, ctor);
+	if (readMap === void 0 && writeMap === void 0 && actions === void 0) return null;
+	const owner = typeof ctor === "function" ? ctor.name : "(contrôleur)";
+	const conflicts = readMetadataMap(CONFLICTS_KEY, ctor);
+	if (conflicts !== void 0) for (const [name, kind] of Object.entries(conflicts)) throw new BootConfigurationError(`${owner} : le canal temps réel « ${name} » déclare deux politiques de ${kind === "read" ? "LECTURE" : "ÉCRITURE"} différentes — une seule s'appliquerait, l'autre disparaîtrait sans un mot. Garder une seule déclaration ; pour garder la lecture et l'écriture séparément : @RealtimeChannel(nom, lecture) et @RealtimeInbound(nom, écriture).`);
+	if (readMap !== void 0) assertPolicyMap(owner, readMap);
+	if (writeMap !== void 0) assertPolicyMap(owner, writeMap);
+	const read = {};
+	const kinds = {};
+	let any = false;
+	if (readMap !== void 0) for (const [name, policy] of Object.entries(readMap)) {
+		read[name] = policy;
+		kinds[name] = {
+			read: policy,
+			write: null
+		};
+		any = true;
+	}
+	if (writeMap !== void 0) for (const [name, policy] of Object.entries(writeMap)) {
+		kinds[name] = {
+			read: kinds[name]?.read ?? null,
+			write: policy
+		};
+		read[name] ??= policy;
+		any = true;
+	}
+	const actionNames = actions === void 0 ? [] : Object.keys(actions);
+	for (const name of actionNames) {
+		if (Object.hasOwn(read, name)) continue;
+		read[name] = DEFAULT_ACTION_POLICY;
+		any = true;
+	}
+	return any ? {
+		read,
+		kinds,
+		actions: actionNames
+	} : null;
+}
+/**
+* Politiques de LECTURE déclarées sur une CLASSE de contrôleur (`@RealtimeChannel`/`@RealtimeInbound`/`@RealtimeAction`/`@RealtimePolicy`), validées — lues au démarrage du noyau, jamais par trame.
+*
+* La lecture d'un nom est celle exigée au `subscribe` ; une écriture distincte
+* se lit par {@link getDeclaredChannelPolicies}.
+*
+* @param ctor - constructeur du contrôleur.
+* @returns nom de canal ou de méthode → politique de lecture, ou `null` si la
+*   classe n'en déclare aucune.
+* @throws BootConfigurationError Une politique est illisible ou contredite :
+*   la classe, le canal et le défaut sont nommés.
+*/
+function getChannelPoliciesOf(ctor) {
+	return getDeclaredChannelPolicies(ctor)?.read ?? null;
+}
+/**
+* Politiques déclarées sur la classe d'une instance de contrôleur — même lecture que {@link getChannelPoliciesOf}.
+*
+* @param instance - contrôleur instancié.
+* @returns nom → politique, ou `null` si aucune.
 */
 function getRealtimeChannelPolicies(instance) {
-	const map = readMetadataMap(POLICIES_KEY, instance.constructor);
-	if (map === void 0) return null;
-	if (!isPolicyMap(map)) throw new TypeError(`${instance.constructor.name} : politique de canal temps réel illisible`);
-	return map;
+	return getChannelPoliciesOf(instance.constructor);
 }
 /**
 * Préfixes de canaux **broadcast** déclarés statiquement, tous controllers
@@ -287,4 +585,4 @@ function getDeclaredBroadcastPrefixes() {
 function applyDeclaredBroadcastPrefixes(hub) {
 	for (const prefix of declaredBroadcastPrefixes) hub.markBroadcastChannel(prefix);
 }
-export { DEFAULT_ACTION_POLICY, RealtimeAction, RealtimeBroadcast, RealtimeChannel, RealtimeInbound, applyDeclaredBroadcastPrefixes, getDeclaredBroadcastPrefixes, getRealtimeActions, getRealtimeChannelPolicies, getRealtimeChannels, getRealtimeInbound };
+export { DEFAULT_ACTION_POLICY, RealtimeAction, RealtimeBroadcast, RealtimeChannel, RealtimeInbound, RealtimePolicy, applyDeclaredBroadcastPrefixes, channelPolicyDefect, declaresAction, getChannelPoliciesOf, getDeclaredBroadcastPrefixes, getDeclaredChannelPolicies, getRealtimeActions, getRealtimeChannelPolicies, getRealtimeChannels, getRealtimeInbound, isAdmissionClass, patternChannelFactory, samePolicy };

package/dist/nodefony/interfaces/IRealtimeConnection.js

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

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

@@ -1,5 +1,5 @@
 import resolveBackplaneOriginId from "./originId.js";
-import { CLUSTER_RT_KIND } from "nodefony";
+import { CLUSTER_IPC_ADVANCED, CLUSTER_IPC_SERIALIZATION_ENV, CLUSTER_RT_KIND } from "nodefony";
 // nodefony/src/backplane/ClusterBackplane.ts
 /**
 * Transport de production : `process.send` (émission) + `process.on("message")`
@@ -13,6 +13,9 @@ const processIpcTransport = {
 	},
 	onReceive(cb) {
 		process.on("message", (msg) => cb(msg));
+	},
+	carriesBytes() {
+		return process.channel !== void 0 && process.env[CLUSTER_IPC_SERIALIZATION_ENV] === CLUSTER_IPC_ADVANCED;
 	}
 };
 /**
@@ -51,14 +54,24 @@ var ClusterBackplane = class ClusterBackplane {
 	#transport;
 	#handler = null;
 	#started = false;
+	/**
+	* Récepteur posé sur le transport — une fois pour la vie de l'instance : le
+	* transport de production (`process.on("message")`) ne sait pas le retirer, et
+	* le reposer à chaque redémarrage doublerait chaque message reçu.
+	*/
+	#listening = false;
+	/** Vrai une fois {@link enableBytes} constaté que le canal porte les octets. */
+	#bytes = false;
 	constructor(transport = processIpcTransport, originId = resolveBackplaneOriginId()) {
 		this.#transport = transport;
 		this.originId = originId;
 	}
-	/** Branche la réception IPC. Idempotent. */
+	/** Branche la réception IPC. Idempotent, et redémarrable après {@link stop}. */
 	start() {
 		if (this.#started) return;
 		this.#started = true;
+		if (this.#listening) return;
+		this.#listening = true;
 		this.#transport.onReceive((msg) => this.#ingress(msg));
 	}
 	/**
@@ -77,8 +90,19 @@ var ClusterBackplane = class ClusterBackplane {
 	onMessage(handler) {
 		this.#handler = handler;
 	}
+	/**
+	* Les octets traversent l'IPC tels quels quand le canal est en clonage
+	* structuré : aucun codec n'est appliqué, l'argument est ignoré.
+	*
+	* @returns `true` si le transport constate un canal `advanced`.
+	*/
+	enableBytes() {
+		this.#bytes = this.#transport.carriesBytes?.() === true;
+		return this.#bytes;
+	}
 	/** Tri + anti-echo + délégation au handler. Robuste : ignore tout message non-realtime. */
 	#ingress(msg) {
+		if (!this.#started) return;
 		if (!isEnvelope(msg)) return;
 		if (msg.originId === this.originId) return;
 		this.#handler?.({
@@ -87,7 +111,10 @@ var ClusterBackplane = class ClusterBackplane {
 			originId: msg.originId
 		});
 	}
-	/** Détache le handler. Le listener du transport prod (`process`) survit au process. */
+	/**
+	* Coupe la réception et détache le handler. Le récepteur du transport survit
+	* (`process` ne le retire pas) mais ne livre plus rien jusqu'au prochain {@link start}.
+	*/
 	stop() {
 		this.#handler = null;
 		this.#started = false;
@@ -97,7 +124,8 @@ var ClusterBackplane = class ClusterBackplane {
 			driver: ClusterBackplane.driver,
 			kind: "ipc",
 			originId: this.originId,
-			crossPod: false
+			crossPod: false,
+			...this.#bytes && { bytes: true }
 		};
 	}
 };