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

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

@@ -1,4 +1,5 @@
 import { getRealtimeHub } from "./RealtimeHub.js";
+import { isRealtimePayload, realtimePayloadError } from "nodefony";
 // nodefony/src/server/ServerRealtimeSocket.ts
 /**
 * **L4 — façade serveur « la socket Nodefony ».** Un handle SERVEUR qui implémente
@@ -38,6 +39,7 @@ var ServerRealtimeSocket = class {
 	}
 	/** Émet sur un canal — fan-out aux abonnés via le hub (+ backplane si broadcast). */
 	publish(channel, payload) {
+		if (!isRealtimePayload(payload)) throw realtimePayloadError(channel, payload);
 		this.hub.publish(channel, payload);
 	}
 	/**

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

@@ -0,0 +1,176 @@
+// nodefony/src/server/admissionBudget.ts
+/**
+* Coupe-circuit des admissions (décision de l'auteur sur #622) : 50 délais
+* dépassés en 5 s suspendent les appels d'`allow` pendant 5 s. Constantes
+* internes : un exploitant règle le délai et les plafonds, pas la mécanique qui
+* protège sa base quand elle ne répond plus.
+*/
+const BREAKER_THRESHOLD = 50;
+const BREAKER_WINDOW_MS = 5e3;
+const BREAKER_OPEN_MS = 5e3;
+/** Un avertissement par cause et par fenêtre : sous une base bloquée, un journal par abonné serait un amplificateur. */
+const WARN_INTERVAL_MS = 1e4;
+/** Rendu par {@link AdmissionBudget.acquire} quand une place est réservée. */
+const ADMISSION_GRANTED = -1;
+/** Rendu par {@link AdmissionBudget.authenticateWithin} quand l'authentification n'a pas répondu à temps. */
+const AUTHENTICATE_TIMED_OUT = Symbol("authenticate-timed-out");
+/**
+* Budget des admissions d'UN exemplaire — appels d'`allow` en vol, coupe-circuit et compteurs de refus (ADR-0021 §S10 bis point 3, §S9).
+*
+* Partagé par toutes les connexions du hub ; chaque connexion garde sa propre
+* file ({@link ConnectionAdmission}). Aucune horloge n'est lue tant que le
+* coupe-circuit est fermé : une règle synchrone ne paie que deux incréments.
+*/
+var AdmissionBudget = class {
+	/** Délai de l'authentification à la poignée de main (ADR-0021 §S11). */
+	authenticateTimeoutMs = 1e4;
+	/** Délai d'un appel d'`allow`, compté depuis la réception du `subscribe`, file comprise. */
+	timeoutMs = 5e3;
+	/** Appels d'`allow` en vol par connexion ; au-delà, la demande attend son tour. */
+	maxPerConnection = 8;
+	#maxTotal = 512;
+	#pending = 0;
+	#timedOutTotal = 0;
+	#saturatedTotal = 0;
+	#authenticateTimedOutTotal = 0;
+	#windowStart = -1e400;
+	#windowTimeouts = 0;
+	#openUntil = 0;
+	#lastTimeoutWarn = -1e400;
+	#lastThrowWarn = -1e400;
+	#lastAuthenticateWarn = -1e400;
+	/** Applique les bornes de la configuration (boot, cold path). */
+	configure(limits) {
+		this.authenticateTimeoutMs = limits.authenticateTimeoutMs;
+		this.timeoutMs = limits.allowTimeoutMs;
+		this.maxPerConnection = limits.maxPendingAllowsPerConnection;
+		this.#maxTotal = limits.maxPendingAllowsTotal;
+	}
+	/**
+	* Réserve une place pour UN appel d'`allow`.
+	*
+	* @returns {@link ADMISSION_GRANTED} si la place est prise ; sinon la demande
+	*   est comptée dans `allowSaturatedTotal` et la valeur rendue est le délai à
+	*   annoncer au client (`retryAfterMs`, coupe-circuit ouvert), ou `0` quand il
+	*   n'est pas connu (plafond global atteint).
+	*/
+	acquire() {
+		if (this.#openUntil !== 0) {
+			const now = performance.now();
+			if (now < this.#openUntil) {
+				this.#saturatedTotal += 1;
+				return Math.ceil(this.#openUntil - now);
+			}
+			this.#openUntil = 0;
+		}
+		if (this.#pending >= this.#maxTotal) {
+			this.#saturatedTotal += 1;
+			return 0;
+		}
+		this.#pending += 1;
+		return -1;
+	}
+	/** Rend la place d'un appel terminé, dépassé ou abandonné à la fermeture. */
+	release() {
+		if (this.#pending > 0) this.#pending -= 1;
+	}
+	/** Un appel d'`allow` n'a pas répondu dans son délai : compté, et porté au coupe-circuit. */
+	recordTimeout(now) {
+		this.#timedOutTotal += 1;
+		if (now - this.#windowStart >= BREAKER_WINDOW_MS) {
+			this.#windowStart = now;
+			this.#windowTimeouts = 0;
+		}
+		this.#windowTimeouts += 1;
+		if (this.#windowTimeouts >= BREAKER_THRESHOLD) {
+			this.#openUntil = now + BREAKER_OPEN_MS;
+			this.#windowTimeouts = 0;
+		}
+	}
+	/** Une demande a épuisé son délai dans la file, sans appel d'`allow`. */
+	recordQueueExpired() {
+		this.#saturatedTotal += 1;
+	}
+	/** Délai restant du coupe-circuit à `now`, ou `undefined` s'il est fermé. */
+	retryAfter(now) {
+		return this.#openUntil > now ? Math.ceil(this.#openUntil - now) : void 0;
+	}
+	/** Faut-il journaliser cette cause maintenant ? Vrai au plus une fois par fenêtre et par cause. */
+	shouldWarn(kind, now) {
+		if (kind === "authenticate") {
+			if (now - this.#lastAuthenticateWarn < WARN_INTERVAL_MS) return false;
+			this.#lastAuthenticateWarn = now;
+			return true;
+		}
+		if (kind === "timeout") {
+			if (now - this.#lastTimeoutWarn < WARN_INTERVAL_MS) return false;
+			this.#lastTimeoutWarn = now;
+			return true;
+		}
+		if (now - this.#lastThrowWarn < WARN_INTERVAL_MS) return false;
+		this.#lastThrowWarn = now;
+		return true;
+	}
+	/**
+	* Borne l'authentification d'une poignée de main par `authenticateTimeoutMs` (ADR-0021 §S11).
+	*
+	* Une identité arrivée après le délai est IGNORÉE : la promesse rendue est
+	* déjà réglée sur {@link AUTHENTICATE_TIMED_OUT}, et un rejet tardif ne lève
+	* rien (la promesse d'origine garde son gestionnaire). Le minuteur est coupé
+	* dès la réponse et ne retient pas le processus à l'arrêt. Chaque dépassement
+	* compte une poignée de main dans `authenticateTimedOutTotal`.
+	*
+	* @param pending - la promesse rendue par `authenticate()`
+	* @returns le jeton, ou {@link AUTHENTICATE_TIMED_OUT} au dépassement
+	*/
+	authenticateWithin(pending) {
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.#authenticateTimedOutTotal++;
+				resolve(AUTHENTICATE_TIMED_OUT);
+			}, this.authenticateTimeoutMs);
+			timer.unref();
+			pending.then((value) => {
+				clearTimeout(timer);
+				resolve(value);
+			}, (error) => {
+				clearTimeout(timer);
+				reject(error instanceof Error ? error : new Error(String(error)));
+			});
+		});
+	}
+	/** Appels d'`allow` en vol sur l'exemplaire. */
+	get pending() {
+		return this.#pending;
+	}
+	/** Cumul `allowTimedOutTotal` — unité : un appel d'`allow`. */
+	get timedOutTotal() {
+		return this.#timedOutTotal;
+	}
+	/** Cumul `allowSaturatedTotal` — unité : une demande d'abonnement. */
+	get saturatedTotal() {
+		return this.#saturatedTotal;
+	}
+	/** Cumul `authenticateTimedOutTotal` — unité : une poignée de main. */
+	get authenticateTimedOutTotal() {
+		return this.#authenticateTimedOutTotal;
+	}
+	/** Remet compteurs, coupe-circuit et bornes à leurs défauts (hub vidé). */
+	reset() {
+		this.authenticateTimeoutMs = 1e4;
+		this.#authenticateTimedOutTotal = 0;
+		this.#lastAuthenticateWarn = -1e400;
+		this.timeoutMs = 5e3;
+		this.maxPerConnection = 8;
+		this.#maxTotal = 512;
+		this.#pending = 0;
+		this.#timedOutTotal = 0;
+		this.#saturatedTotal = 0;
+		this.#windowStart = -1e400;
+		this.#windowTimeouts = 0;
+		this.#openUntil = 0;
+		this.#lastTimeoutWarn = -1e400;
+		this.#lastThrowWarn = -1e400;
+	}
+};
+export { ADMISSION_GRANTED, AUTHENTICATE_TIMED_OUT, AdmissionBudget };

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

@@ -0,0 +1,95 @@
+import { declaresAction, getDeclaredChannelPolicies, isAdmissionClass, samePolicy } from "../../decorators/realtimeDecorators.js";
+import { samePresence } from "./channelPresence.js";
+import { BootConfigurationError, Injector } from "nodefony";
+// nodefony/src/server/channelPolicyRegistry.ts
+/**
+* Inscrit au hub les politiques déclarées par une classe de contrôleur — une fois par classe et par hub, et seulement si l'inscription entière réussit.
+*
+* Appelée pour chaque contrôleur connu au démarrage du noyau, puis à la
+* poignée de main pour une classe qui y aurait échappé : celle-ci ne paie alors
+* qu'un `has`. Une politique refusée ne marque PAS la classe — elle est refusée
+* de nouveau à la poignée de main suivante plutôt que de laisser le canal
+* ouvert.
+*
+* @param hub - le hub qui porte le registre.
+* @param ctor - constructeur du contrôleur.
+* @param resolveAdmission - résolution des classes d'admission ; `null` hors
+*   démarrage, et le hub refuse alors une politique qui en désigne une.
+* Chaque nom est déclaré au hub SORTE PAR SORTE (lecture, écriture), sans
+* héritage : le hub les fusionne avec les motifs de toutes les classes
+* (ADR-0022 §6, décision 1 quater). Deux classes qui déclarent la même sorte
+* différemment sous un même nom refusent le démarrage : la seconde effaçait la
+* première sans un mot.
+*
+* @throws BootConfigurationError Politique illisible ou contredite, `allow`
+*   posé sur une action ou sur une écriture distincte de la lecture, classe
+*   d'admission non résolue, ou deux classes en désaccord sur un nom.
+*/
+function registerControllerPolicies(hub, ctor, resolveAdmission) {
+	if (hub.hasPolicyOwner(ctor)) return;
+	const declared = getDeclaredChannelPolicies(ctor);
+	if (declared !== null) {
+		const owner = typeof ctor === "function" ? ctor.name : "(contrôleur)";
+		for (const [name, { read, write }] of Object.entries(declared.kinds)) {
+			if (write?.allow !== void 0 && read !== null && !samePolicy(read, write)) throw new BootConfigurationError(`${owner} : « allow » est posé sur l'écriture du canal « ${name} », qui déclare aussi une lecture différente — il ne s'applique qu'à la lecture (demandé au subscribe). Le poser sur @RealtimeChannel ; l'écriture se garde par authenticated, roles ou scopes.`);
+			const allow = (read ?? write)?.allow;
+			let admission;
+			if (allow !== void 0) {
+				if (declaresAction(ctor, name)) throw new BootConfigurationError(`${owner} : « allow » est posé sur l'action « ${name} » — il ne s'applique qu'aux canaux (demandé au subscribe). Une action se garde par authenticated, roles ou scopes.`);
+				if (isAdmissionClass(allow) && resolveAdmission !== null) admission = resolveAdmission(allow, name);
+			}
+			if (read !== null) claim(hub, name, "read", ctor, owner, read);
+			if (write !== null) claim(hub, name, "write", ctor, owner, write);
+			hub.declareChannelPolicy(name, read, write, admission);
+		}
+		for (const name of declared.actions) hub.declareActionDefault(name);
+	}
+	hub.addPolicyOwner(ctor);
+}
+/**
+* Revendique une sorte de politique d'un nom pour cette classe — refuse le démarrage si une AUTRE classe en a déclaré une différente : le registre est unique par nom, une seule s'appliquerait.
+*/
+function claim(hub, name, kind, ctor, owner, policy) {
+	const previous = hub.claimChannelPolicy(name, kind, ctor, policy);
+	if (previous === null || previous.owner === ctor || samePolicy(previous.policy, policy) && samePresence(previous.policy, policy)) return;
+	const which = kind === "read" ? "LECTURE" : "ÉCRITURE";
+	throw new BootConfigurationError(`canal temps réel « ${name} » : ${previous.ownerName} et ${owner} déclarent des politiques de ${which} différentes sous ce nom — le registre est unique par nom, une seule s'appliquerait. Les accorder, ou renommer l'un des canaux.`);
+}
+/**
+* Fabrique la résolution des classes d'admission du démarrage : portée singleton exigée, instance du conteneur réutilisée, sinon construite UNE fois par l'injecteur.
+*
+* @param get - l'instance déjà construite d'une classe : le démarrage la lit
+*   dans le conteneur du noyau par sa clé (`null` tant que la classe n'y a
+*   jamais été rangée), le harnais de test parmi les instances que le test lui
+*   donne. `undefined` → construite par l'injecteur.
+* @param log - journal du module (une ligne par canal résolu).
+* @returns le résolveur, qui mémorise l'instance de chaque classe.
+*/
+function createAdmissionResolver(get, log) {
+	const resolved = /* @__PURE__ */ new Map();
+	return (admissionClass, channel) => {
+		let admission = resolved.get(admissionClass);
+		if (admission === void 0) {
+			admission = resolveAdmissionInstance(admissionClass, channel, get);
+			resolved.set(admissionClass, admission);
+		}
+		log(`canal ${channel}, admission ${admissionClass.name}, résolue`);
+		return admission;
+	};
+}
+/** Résout l'instance d'une classe d'admission ou refuse le démarrage en nommant la classe ET le canal. */
+function resolveAdmissionInstance(admissionClass, channel, get) {
+	const where = `canal temps réel « ${channel} » : la classe d'admission ${admissionClass.name}`;
+	if (!Injector.isInjectable(admissionClass)) throw new BootConfigurationError(`${where} ne porte pas @injectable`);
+	const scope = Injector.scopeOf(admissionClass);
+	if (scope !== "singleton") throw new BootConfigurationError(`${where} est de portée « ${scope} » : une seule instance sert tous les abonnés en même temps, elle doit être un singleton (et ne garder aucun état par abonné).`);
+	let instance = get(Injector.containerKeyOf(admissionClass), admissionClass);
+	if (!(instance instanceof admissionClass)) try {
+		instance = Injector.instantiate(admissionClass);
+	} catch (error) {
+		throw new BootConfigurationError(`${where} ne se résout pas — ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+	}
+	if (!(instance instanceof admissionClass) || typeof instance.allow !== "function") throw new BootConfigurationError(`${where} n'a pas de méthode allow`);
+	return instance;
+}
+export { createAdmissionResolver, registerControllerPolicies };

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

@@ -0,0 +1,191 @@
+import { isAdmissionClass, samePolicy } from "../../decorators/realtimeDecorators.js";
+import { BootConfigurationError, USER_CHANNEL_PREFIX, isOwnUserChannel } from "nodefony";
+// nodefony/src/server/channelPolicyResolution.ts
+/**
+* Règle d'admission prête à appeler d'une politique, ou `null` sans `allow`.
+*
+* Une flèche se retient telle quelle. Une classe exige son instance — résolue au
+* démarrage, jamais ici : le hub n'a pas d'injecteur, et résoudre à la première
+* poignée de main laisserait sans politique un exemplaire qui n'émet que des
+* webhooks. La méthode est liée une fois, et la règle se construit une fois :
+* le `subscribe` n'alloue rien et n'appelle qu'une fonction.
+*
+* @throws BootConfigurationError La politique désigne une classe d'admission et
+*   aucune instance de CETTE classe n'est fournie.
+*/
+function admissionRuleOf(name, policy, admission) {
+	const allow = policy.allow;
+	if (allow === void 0) return null;
+	const anonymous = policy.anonymous === true;
+	if (!isAdmissionClass(allow)) return {
+		allow,
+		anonymous
+	};
+	if (!(admission instanceof allow)) throw new BootConfigurationError(`canal temps réel « ${name} » : la classe d'admission ${allow.name} n'a pas été résolue au démarrage du noyau. Son contrôleur doit être déclaré par @controllers dans un module : c'est là que le framework l'inscrit et résout ses dépendances.`);
+	return {
+		allow: admission.allow.bind(admission),
+		anonymous
+	};
+}
+/**
+* Construit une déclaration et sa vue seule : lecture déclarée, sinon l'écriture, sinon le défaut d'action ; écriture gardée seulement si elle exige autre chose que la lecture.
+*
+* @param name - nom exact ou motif (pour les messages).
+* @param read - lecture déclarée, ou `null`.
+* @param write - écriture déclarée, ou `null`.
+* @param fallback - défaut fermé d'une action, ou `null`.
+* @param admission - instance de la classe d'admission quand la politique qui
+*   sert de lecture en désigne une.
+*/
+function declarationOf(name, read, write, fallback, admission) {
+	const policy = read ?? write ?? fallback;
+	return {
+		read,
+		write,
+		fallback,
+		instance: admission,
+		self: policy === null ? null : {
+			policy,
+			write: read !== null && write !== null && !samePolicy(read, write) ? write : null,
+			admission: admissionRuleOf(name, policy, admission)
+		}
+	};
+}
+/**
+* Politique INTÉGRÉE du canal personnel `user:<id>` (ADR-0022 §6, D1) — connexion authentifiée, admise sur SON canal seulement.
+*
+* Constante de module : elle ne s'inscrit nulle part, donc aucun `clear()`,
+* aucun ordre de démarrage, aucun oubli ne peut la retirer. Elle sert de REPLI
+* de LECTURE aux noms `user:…` : seule une déclaration qui vise `user:`
+* (nom exact, ou motif dont le littéral commence par `user:`) la remplace — un
+* motif attrape-tout (`*`) ne retire pas la garde « son canal seulement ».
+*/
+const USER_CHANNEL_DECLARATION = Object.freeze({
+	read: Object.freeze({
+		authenticated: true,
+		allow: isOwnUserChannel
+	}),
+	write: null,
+	fallback: null,
+	instance: void 0,
+	self: Object.freeze({
+		policy: Object.freeze({
+			authenticated: true,
+			allow: isOwnUserChannel
+		}),
+		write: null,
+		admission: Object.freeze({
+			allow: isOwnUserChannel,
+			anonymous: false
+		})
+	})
+});
+/**
+* Résout les politiques d'un nom (ADR-0022 §6, décision 1 quater) : la LECTURE appartient à la déclaration la plus spécifique qui déclare quelque chose sur ce nom ; l'ÉCRITURE vient de la plus spécifique qui déclare une écriture.
+*
+* L'ordre de spécificité : le nom exact, puis les motifs du plus spécifique au
+* plus général. Pourquoi deux règles et non une :
+* - la LECTURE reste à la déclaration propriétaire du nom (déclarée, sinon
+*   héritée de sa propre écriture) : une commande `task:start` déclarée par
+*   `@RealtimeInbound` sous une famille `task:*` à `allow` ne devient pas un
+*   canal à membres, et une écriture exacte ne voit pas sa lecture s'ouvrir par
+*   un motif plus général ;
+* - l'ÉCRITURE descend jusqu'au motif qui en déclare une : elle s'ajoute à la
+*   lecture (une trame entrante exige les deux), elle ne peut que durcir — une
+*   écriture de famille (`mix:*` réservée) n'est plus perdue sur un nom exact
+*   qui ne déclare que sa lecture.
+*
+* Ensuite : un nom `user:…` sans déclaration qui le vise garde la politique
+* intégrée du canal personnel (un motif qui ne vise pas `user:` est ignoré) ;
+* une action sans politique (nom exact qui ne déclare rien) prend la lecture du
+* motif qui la couvre et le défaut fermé pour écriture — un motif de lecture
+* public ne l'ouvre donc pas.
+*
+* Rend la vue d'une déclaration quand une seule suffit (aucune allocation) ;
+* n'alloue que si l'écriture vient d'une autre déclaration que la lecture.
+*
+* @param name - nom résolu.
+* @param exact - déclaration exacte de ce nom, ou `undefined`.
+* @param patterns - motifs, triés du plus spécifique au plus général, ou `null`.
+* @returns les politiques, ou `null` si aucune ne couvre le nom.
+*/
+function resolveDeclaredPolicies(name, exact, patterns) {
+	const declares = (d) => d.read !== null || d.write !== null;
+	let owner = exact !== void 0 && declares(exact) ? exact : null;
+	let writeFrom = exact !== void 0 && exact.write !== null ? exact : null;
+	const isUser = name.startsWith(USER_CHANNEL_PREFIX);
+	if ((owner === null || writeFrom === null) && patterns !== null) for (const pattern of patterns) {
+		if (isUser && !pattern.source.startsWith(USER_CHANNEL_PREFIX)) continue;
+		if (!pattern.re.test(name)) continue;
+		if (owner === null && declares(pattern)) owner = pattern;
+		if (writeFrom === null && pattern.write !== null) writeFrom = pattern;
+		if (owner !== null && writeFrom !== null) break;
+	}
+	let write = writeFrom?.write ?? null;
+	if (write === null && exact !== void 0 && !declares(exact)) write = exact.fallback;
+	let own = owner?.self ?? null;
+	if (own === null) {
+		if (isUser) own = USER_CHANNEL_DECLARATION.self;
+		else return exact?.self ?? null;
+		if (own === null) return null;
+	}
+	const distinct = write === null || samePolicy(own.policy, write) ? null : write;
+	if (distinct === own.write) return own;
+	return {
+		policy: own.policy,
+		write: distinct,
+		admission: own.admission
+	};
+}
+/** Échantillon d'un motif : son littéral, chaque `*` vidé — un nom qu'il couvre toujours. */
+function sampleOf(pattern) {
+	return pattern.source.split("*").join("");
+}
+/**
+* Deux déclarations peuvent-elles s'appliquer au MÊME nom ? Exact : le même nom, ou couvert par le motif ; deux motifs : l'un couvre l'échantillon de l'autre.
+*
+* Prudente : elle répond « oui » dès qu'un nom commun est plausible — elle sert à
+* refuser un démarrage ambigu, jamais à ouvrir un accès.
+*/
+function couldOverlap(a, b) {
+	if (a.pattern === null && b.pattern === null) return a.name === b.name;
+	if (a.pattern === null) return b.pattern?.re.test(a.name) === true;
+	if (b.pattern === null) return a.pattern.re.test(b.name);
+	return a.pattern.re.test(sampleOf(b.pattern)) || b.pattern.re.test(sampleOf(a.pattern));
+}
+/**
+* Défaut de l'ensemble des déclarations qui refuse le démarrage, ou `null` : une ÉCRITURE à `allow` qui s'appliquerait sous une lecture différente (son `allow` ne serait évalué nulle part), ou — face à un verrou qui ne juge pas l'écriture — une écriture qui diffère d'une lecture qu'elle peut rencontrer.
+*
+* Cold path (inscription d'une politique, pose du verrou) : toutes les paires.
+*
+* @param exact - déclarations exactes, par nom.
+* @param patterns - déclarations par motif.
+* @param writeJudged - le verrou en place sait juger l'écriture (ou aucun verrou).
+* @returns le message du refus, ou `null`.
+*/
+function policyDeclarationsDefect(exact, patterns, writeJudged) {
+	const all = [];
+	if (exact !== null) for (const [name, decl] of exact) all.push({
+		name,
+		pattern: null,
+		decl
+	});
+	for (const pattern of patterns ?? []) all.push({
+		name: pattern.source,
+		pattern,
+		decl: pattern
+	});
+	for (const writer of all) {
+		const write = writer.decl.write;
+		if (write === null) continue;
+		for (const reader of all) {
+			const read = reader.decl.read;
+			if (read === null || samePolicy(read, write)) continue;
+			if (reader !== writer && !couldOverlap(writer, reader)) continue;
+			if (write.allow !== void 0) return `canal temps réel « ${writer.name} » : « allow » est posé sur l'écriture du canal « ${writer.name} », qui rencontre une lecture différente (« ${reader.name} ») — il ne s'applique qu'à la lecture (demandé au subscribe). Le poser sur @RealtimeChannel ; l'écriture se garde par authenticated, roles ou scopes.`;
+			if (!writeJudged) return `canal temps réel « ${writer.name} » : il déclare une politique d'ÉCRITURE distincte de sa lecture, et le verrou des trames posé sur le hub ne sait pas la juger (il ne déclare pas « judgesWrite ») — l'écriture resterait ouverte. Aligner @nodefony/security sur la version de @nodefony/realtime.`;
+		}
+	}
+	return null;
+}
+export { USER_CHANNEL_DECLARATION, admissionRuleOf, declarationOf, policyDeclarationsDefect, resolveDeclaredPolicies };