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

package/README.md

@@ -145,6 +145,10 @@ import { registerBackplaneDriver } from "@nodefony/realtime";
 registerBackplaneDriver("nats", (config) => new MyNatsBackplane(config));
 ```
 
+Un bus fourni par l'application (service `realtimeBackplane`) s'arrête à la charge de
+l'application : `await shutdownRealtime(getRealtimeHub(), bus)` dans son `onTerminate`, pour que
+la fin de la présence parte avant la sortie du processus.
+
 Détail des réglages : [`docs/configuration.md`](./docs/configuration.md).
 
 ## API
@@ -162,6 +166,7 @@ Détail des réglages : [`docs/configuration.md`](./docs/configuration.md).
 | `LoopbackBackplane` / `ClusterBackplane` / `RedisBackplane` | classes | Les 3 drivers natifs |
 | `registerBackplaneDriver` / `getBackplaneDriver` / `listBackplaneDrivers` | functions | Registre ouvert de drivers |
 | `IBackplane` | interface | Contrat d'un fond de panier |
+| `shutdownRealtime` / `BACKPLANE_STOP_TIMEOUT_MS` | fn / const | Arrêt propre : fin de la présence annoncée aux pairs, puis arrêt du bus en laissant partir ce qui est émis (borné). Appelé par le module pour le bus qu'il crée ; à appeler soi-même pour un bus fourni (`realtimeBackplane`) |
 | `ContractRealtimeController<C>` | classe | Base d'un contrôleur qui implémente un contrat (`realtimeActions()` complète si le contrat déclare des `serverMethods`, rien sinon) |
 | `getRealtimeHub<C>()` | fonction | Le hub lu par le contrat (`IContractRealtimeHub<C>`) : `publish` d'un service vérifié ; sans paramètre, le hub libre |
 | `ContractRealtimePublish<C>` | type | Le `publish` d'une fabrique de canal, typé par le contrat |

package/dist/_virtual/{_@oxc-project_runtime@0.157.0 → _@oxc-project_runtime@0.158.0}/helpers/esm/decorate.js

@@ -1,4 +1,4 @@
-// \0@oxc-project+runtime@0.157.0/helpers/esm/decorate.js
+// \0@oxc-project+runtime@0.158.0/helpers/esm/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);

package/dist/index.js

@@ -16,12 +16,16 @@ import { getBackplaneDriver, listBackplaneDrivers, registerBackplaneDriver } fro
 import { ClusterProbeClient, clusterProbeHealth, clusterProbeInstance, clusterProbeRequestEnrich, mergeClusterHealth, processProbeTransport, setClusterProbeClient } from "./nodefony/src/cluster/ClusterProbeClient.js";
 import { WsConnectionTransport } from "./nodefony/src/transport/WsConnectionTransport.js";
 import { buildOwnHealth, buildRealtimeHealth, createRealtimeAdminApi } from "./nodefony/src/server/RealtimeAdminApi.js";
-import __decorate from "./_virtual/_@oxc-project_runtime@0.157.0/helpers/esm/decorate.js";
+import { BACKPLANE_STOP_TIMEOUT_MS, shutdownRealtime } from "./nodefony/src/server/realtimeShutdown.js";
+import __decorate from "./_virtual/_@oxc-project_runtime@0.158.0/helpers/esm/decorate.js";
 import { ANONYMOUS_REALTIME_TOKEN, ANONYMOUS_SUBSCRIBER_IDENTITY } from "./nodefony/src/server/AnonymousRealtimeToken.js";
 import { RealtimeAction, RealtimeBroadcast, RealtimeChannel, RealtimeInbound, RealtimePolicy, getDeclaredBroadcastPrefixes } from "./nodefony/decorators/realtimeDecorators.js";
 import { ContractRealtimeController, ContractRealtimeControllerBase, ContractRealtimeControllerStrict } from "./nodefony/src/server/ContractRealtimeController.js";
 import { BROWSER_ORIGIN, MAX_CLIENT_SEVERITY, createSyslogUplinkHandler } from "./nodefony/src/server/syslogUplink.js";
-import { openBackplaneEnvelope, sealBackplaneEnvelope } from "./nodefony/src/backplane/envelope.js";
+import { DEFAULT_PRESENCE_MAX_NAMED, PRESENCE_WINDOW_MS } from "./nodefony/src/server/channelPresence.js";
+import { BackplaneEcho, openBackplaneEnvelope, sealBackplaneEnvelope } from "./nodefony/src/backplane/envelope.js";
+import { BackplanePublishQueue, DEFAULT_MAX_QUEUE_BYTES } from "./nodefony/src/backplane/publishQueue.js";
+import { BackplaneIngress } from "./nodefony/src/backplane/ingress.js";
 import { IDENTITY_CHANGED_EVENT, Module, services, withTimeout } from "nodefony";
 import { getRouteSchema, isFrameworkRouter } from "@nodefony/framework";
 // index.ts
@@ -80,6 +84,8 @@ let Realtime = class Realtime extends Module {
 	static critical = false;
 	/** Rôle topologique du process, capté à `onCluster` (défaut mono-process). */
 	#clusterRole = "MONO";
+	/** Bus créé PAR ce module (registre de pilotes) — à lui de l'arrêter ; `null` s'il est fourni par l'application ou absent. */
+	#ownedBackplane = null;
 	constructor(kernel) {
 		super("realtime", kernel, import.meta.url, config);
 		kernel.once("onCluster", (role) => {
@@ -128,6 +134,11 @@ let Realtime = class Realtime extends Module {
 			getRealtimeHub().refreshIdentity(event.identifier);
 		});
 		await this.#wireBackplane();
+		this.kernel?.once("onTerminate", async () => {
+			const stopped = await shutdownRealtime(getRealtimeHub(), this.#ownedBackplane);
+			this.#ownedBackplane = null;
+			if (!stopped) this.log(`realtime backplane : arrêt non terminé en ${BACKPLANE_STOP_TIMEOUT_MS} ms (bus injoignable ?) — la fin de la présence peut ne pas avoir atteint les autres serveurs, qui oublieront celui-ci au délai d'oubli`, "WARNING");
+		});
 		this.#wireClusterProbe(this.#clusterRole);
 		return this;
 	}
@@ -229,6 +240,7 @@ let Realtime = class Realtime extends Module {
 			return;
 		}
 		hub.setBackplane(backplane);
+		this.#ownedBackplane = backplane;
 		const info = backplane.describe();
 		this.log(`realtime backplane  driver=${info.driver} kind=${info.kind} origin=${info.originId} cross-pod=${info.crossPod ? "yes" : "no"}` + (info.channel ? ` channel=${info.channel}` : ""), "INFO");
 		this.#logBroadcastPrefixes(hub);
@@ -287,4 +299,4 @@ let Realtime = class Realtime extends Module {
 };
 Realtime = __decorate([services([RealtimeService])], Realtime);
 var realtime_default = Realtime;
-export { ANONYMOUS_REALTIME_TOKEN, ANONYMOUS_SUBSCRIBER_IDENTITY, BROWSER_ORIGIN, ChannelFrame, ClusterBackplane, ClusterProbeClient, ContractRealtimeController, ContractRealtimeControllerBase, ContractRealtimeControllerStrict, LoopbackBackplane, MAX_CLIENT_SEVERITY, REDIS_RT_CHANNEL, RESERVED_SYSTEM_PREFIXES, Realtime, RealtimeAction, RealtimeBroadcast, RealtimeChannel, RealtimeController, RealtimeHub, RealtimeInbound, RealtimePolicy, RealtimeService, RedisBackplane, SLOW_CONSUMER_BYTES, ServerRealtimeSocket, WsConnectionTransport, buildOwnHealth, buildRealtimeHealth, clusterProbeHealth, clusterProbeInstance, clusterProbeRequestEnrich, createRealtimeAdminApi, createRedisServiceTransport, createSyslogUplinkHandler, realtime_default as default, defineRealtimeConfig, getBackplaneDriver, getDeclaredBroadcastPrefixes, getRealtimeHub, isReservedSystemChannel, listBackplaneDrivers, mergeClusterHealth, openBackplaneEnvelope, processIpcTransport, processProbeTransport, realtimeConfigJsonSchema, registerBackplaneDriver, resolveBackplaneOriginId, resolveRedisBytesChannel, resolveRedisChannel, sealBackplaneEnvelope, serverSocket, setClusterProbeClient };
+export { ANONYMOUS_REALTIME_TOKEN, ANONYMOUS_SUBSCRIBER_IDENTITY, BACKPLANE_STOP_TIMEOUT_MS, BROWSER_ORIGIN, BackplaneEcho, BackplaneIngress, BackplanePublishQueue, ChannelFrame, ClusterBackplane, ClusterProbeClient, ContractRealtimeController, ContractRealtimeControllerBase, ContractRealtimeControllerStrict, DEFAULT_MAX_QUEUE_BYTES, DEFAULT_PRESENCE_MAX_NAMED, LoopbackBackplane, MAX_CLIENT_SEVERITY, PRESENCE_WINDOW_MS, REDIS_RT_CHANNEL, RESERVED_SYSTEM_PREFIXES, Realtime, RealtimeAction, RealtimeBroadcast, RealtimeChannel, RealtimeController, RealtimeHub, RealtimeInbound, RealtimePolicy, RealtimeService, RedisBackplane, SLOW_CONSUMER_BYTES, ServerRealtimeSocket, WsConnectionTransport, buildOwnHealth, buildRealtimeHealth, clusterProbeHealth, clusterProbeInstance, clusterProbeRequestEnrich, createRealtimeAdminApi, createRedisServiceTransport, createSyslogUplinkHandler, realtime_default as default, defineRealtimeConfig, getBackplaneDriver, getDeclaredBroadcastPrefixes, getRealtimeHub, isReservedSystemChannel, listBackplaneDrivers, mergeClusterHealth, openBackplaneEnvelope, processIpcTransport, processProbeTransport, realtimeConfigJsonSchema, registerBackplaneDriver, resolveBackplaneOriginId, resolveRedisBytesChannel, resolveRedisChannel, sealBackplaneEnvelope, serverSocket, setClusterProbeClient, shutdownRealtime };

package/dist/nodefony/decorators/realtimeDecorators.js

@@ -1,5 +1,6 @@
 import { isCallable, isRecord } from "../src/guards.js";
-import { BootConfigurationError, Injector } from "nodefony";
+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. */
@@ -7,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` :
@@ -17,6 +22,11 @@ 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");
@@ -30,7 +40,8 @@ const POLICY_KEYS = /* @__PURE__ */ new Set([
 	"roles",
 	"scopes",
 	"allow",
-	"anonymous"
+	"anonymous",
+	"presence"
 ]);
 /**
 * `allow` désigne-t-il une classe d'admission (`@injectable`) plutôt qu'une flèche ?
@@ -54,7 +65,9 @@ function isAdmissionClass(allow) {
 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 } = value;
+	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";
@@ -66,6 +79,34 @@ function channelPolicyDefect(value) {
 	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) {
+	return channelPolicyDefect(value) === null;
+}
+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.
 *
@@ -89,12 +130,30 @@ function hasDefinedKey(policy) {
 }
 /** 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) {
+/**
+* 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 map = { ...readMetadataMap(POLICIES_KEY, ctor) };
-	map[name] = policy;
-	Reflect.defineMetadata(POLICIES_KEY, map, ctor);
+	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é :
@@ -103,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"`).
@@ -127,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:`…)
@@ -159,8 +216,7 @@ 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);
 	};
 }
 /**
@@ -178,6 +234,10 @@ function RealtimeAction(method, policy) {
 *
 * 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
@@ -193,20 +253,25 @@ function RealtimeAction(method, policy) {
 */
 function RealtimePolicy(policies) {
 	return function(target) {
-		for (const [name, policy] of Object.entries(policies)) definePolicy(target, name, policy);
+		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
@@ -214,8 +279,20 @@ function RealtimePolicy(policies) {
 * 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);
@@ -229,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);
 	};
 }
 /**
@@ -244,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")
@@ -260,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);
 	};
 }
 /**
@@ -301,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);
@@ -323,19 +455,79 @@ function declaresAction(ctor, name) {
 	return map !== void 0 && Object.prototype.hasOwnProperty.call(map, name);
 }
 /**
-* Politiques d'autorisation déclarées sur une CLASSE de contrôleur (`@RealtimeChannel`/`@RealtimeInbound`/`@RealtimePolicy` avec politique), validées — lues au démarrage du noyau, jamais par trame.
+* 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, ou `null` si la classe n'en
-*   déclare aucune (0 allocation).
-* @throws BootConfigurationError Une politique est illisible : la classe, le
-*   canal et le défaut sont nommés.
+* @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) {
-	const map = readMetadataMap(POLICIES_KEY, ctor);
-	if (map === void 0) return null;
-	assertPolicyMap(typeof ctor === "function" ? ctor.name : "(contrôleur)", map);
-	return map;
+	return getDeclaredChannelPolicies(ctor)?.read ?? null;
 }
 /**
 * Politiques déclarées sur la classe d'une instance de contrôleur — même lecture que {@link getChannelPoliciesOf}.
@@ -393,4 +585,4 @@ function getDeclaredBroadcastPrefixes() {
 function applyDeclaredBroadcastPrefixes(hub) {
 	for (const prefix of declaredBroadcastPrefixes) hub.markBroadcastChannel(prefix);
 }
-export { DEFAULT_ACTION_POLICY, RealtimeAction, RealtimeBroadcast, RealtimeChannel, RealtimeInbound, RealtimePolicy, applyDeclaredBroadcastPrefixes, channelPolicyDefect, declaresAction, getChannelPoliciesOf, getDeclaredBroadcastPrefixes, getRealtimeActions, getRealtimeChannelPolicies, getRealtimeChannels, getRealtimeInbound, isAdmissionClass };
+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/src/backplane/RedisBackplane.js

@@ -1,6 +1,7 @@
 import resolveBackplaneOriginId from "./originId.js";
 import { isCallable, isRecord, isThenable } from "../guards.js";
-import { openBackplaneEnvelope, openBackplaneEnvelopeBytes, sealBackplaneEnvelope, sealBackplaneEnvelopeBytes } from "./envelope.js";
+import { sealBackplaneEnvelope, sealBackplaneEnvelopeBytes } from "./envelope.js";
+import { BackplaneIngress } from "./ingress.js";
 import { BackplanePublishQueue } from "./publishQueue.js";
 import { containsBytes } from "nodefony";
 // nodefony/src/backplane/RedisBackplane.ts
@@ -167,8 +168,8 @@ var RedisBackplane = class RedisBackplane {
 	/** Borne mémoire des publications en vol (cf {@link BackplanePublishQueue}). */
 	#queue;
 	#notice;
-	/** Messages reçus dont le sceau est refusé alors qu'un secret est posé (monotone). */
-	#sealRejectedTotal = 0;
+	/** Tri de l'entrée : écho, sceau, refus comptés (brique commune aux pilotes). */
+	#ingress;
 	#handler = null;
 	#started = false;
 	/**
@@ -183,6 +184,7 @@ var RedisBackplane = class RedisBackplane {
 		this.#secret = secret;
 		this.#notice = options.onNotice ?? null;
 		this.#queue = new BackplanePublishQueue(options.maxQueueBytes ?? 8388608, this.#notice);
+		this.#ingress = new BackplaneIngress(originId, secret, this.#notice);
 	}
 	/**
 	* Abonne au canal Redis dédié. Idempotent (le flag est posé avant l'`await` →
@@ -191,7 +193,7 @@ var RedisBackplane = class RedisBackplane {
 	async start() {
 		if (this.#started) return;
 		this.#started = true;
-		await Promise.all([this.#transport.subscribe(this.#redisChannel, (raw) => this.#ingress(raw)), this.#subscribeBytes()]);
+		await Promise.all([this.#transport.subscribe(this.#redisChannel, (raw) => this.#receive(raw)), this.#subscribeBytes()]);
 	}
 	/**
 	* Arme le sujet binaire (ADR-0021 S6) : les charges qui contiennent des octets
@@ -216,7 +218,7 @@ var RedisBackplane = class RedisBackplane {
 	async #subscribeBytes() {
 		const bytes = this.#bytes;
 		if (bytes === null) return;
-		await this.#transport.subscribeBytes?.(bytes.channel, (raw) => this.#ingressBytes(raw, bytes.codec));
+		await this.#transport.subscribeBytes?.(bytes.channel, (raw) => this.#receiveBytes(raw, bytes.codec));
 	}
 	/**
 	* Propage une publication locale aux autres pods via Redis. NE refait PAS le
@@ -225,7 +227,8 @@ var RedisBackplane = class RedisBackplane {
 	* 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).
+	* port ; le client realtime re-synchronise). Un ordre de contrôle, lui, part
+	* toujours (cf {@link BackplanePublishQueue.send}).
 	*/
 	publish(channel, payload) {
 		const env = {
@@ -236,55 +239,44 @@ var RedisBackplane = class RedisBackplane {
 		const bytes = this.#bytes;
 		if (bytes !== null && containsBytes(payload)) {
 			const bin = sealBackplaneEnvelopeBytes(env, bytes.codec, this.#secret);
-			this.#queue.send(bin.byteLength, () => this.#transport.publish(bytes.channel, bin));
+			this.#queue.send(channel, bin.byteLength, () => this.#transport.publish(bytes.channel, bin));
 			return;
 		}
 		const raw = sealBackplaneEnvelope(env, this.#secret);
-		this.#queue.send(Buffer.byteLength(raw), () => this.#transport.publish(this.#redisChannel, raw));
+		this.#queue.send(channel, 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.
-	* Sous un secret, chaque rejet est compté (`sealRejectedTotal`) et journalisé la
-	* première fois puis une fois sur cent (ADR-0021 S6) : une rotation du secret ou
-	* un producteur mal configuré ne perd plus de messages en silence.
+	* Remet au hub ce que le tri d'entrée admet ({@link BackplaneIngress}) : l'écho
+	* de ce pod (Redis renvoie à l'émetteur) est compté sans être décodé ; un message
+	* malformé ou au sceau refusé est **ignoré** — jamais réinjecté, jamais fatal —,
+	* compté et annoncé la première fois puis une fois sur cent (ADR-0021 S6).
 	*/
-	#ingress(raw) {
-		const msg = openBackplaneEnvelope(raw, this.#secret);
-		if (msg === null) {
-			if (this.#secret !== null) this.#sealRejected();
-			return;
-		}
-		if (msg.originId === this.originId) return;
-		this.#handler?.(msg);
-	}
-	/** Même tri que {@link #ingress}, sur le sujet binaire : décodage, sceau, anti-echo. */
-	#ingressBytes(raw, codec) {
-		const msg = openBackplaneEnvelopeBytes(raw, codec, this.#secret);
-		if (msg === null) {
-			if (this.#secret !== null) this.#sealRejected();
-			return;
-		}
-		if (msg.originId === this.originId) return;
-		this.#handler?.(msg);
+	#receive(raw) {
+		const msg = this.#ingress.text(raw);
+		if (msg !== null) this.#handler?.(msg);
 	}
-	/** Compte un sceau refusé ; annonce le premier, puis un sur cent (pas d'inondation du journal). */
-	#sealRejected() {
-		this.#sealRejectedTotal += 1;
-		const n = this.#sealRejectedTotal;
-		if (n !== 1 && n % 100 !== 0) return;
-		this.#notice?.(`backplane : ${n} message(s) reçu(s) au sceau refusé, JETÉS. Causes : rotation du secret en cours (des exemplaires n'ont pas le même NF_REALTIME_BACKPLANE_SECRET), producteur mal configuré, ou écriture tierce dans le bus. Compteur : sealRejectedTotal.`, "WARNING");
+	/** Même tri que {@link #receive}, sur le sujet binaire. */
+	#receiveBytes(raw, codec) {
+		const msg = this.#ingress.bytes(raw, codec);
+		if (msg !== null) this.#handler?.(msg);
 	}
-	/** Désabonne du canal Redis et détache le handler. Idempotent. */
+	/**
+	* Laisse partir les publications déjà émises (acquittées ou refusées par Redis), puis désabonne du canal et détache le handler. Idempotent.
+	*
+	* Sans l'attente, un arrêt suivi de la sortie du processus perdait ce qui
+	* était encore dans la file — la preuve de vie FINALE de la présence comprise,
+	* et les pairs gardaient alors ce pod jusqu'au délai d'oubli. Un Redis qui ne
+	* répond plus fait attendre : l'appelant borne (l'arrêt du module le fait).
+	*/
 	async stop() {
 		this.#handler = null;
 		if (!this.#started) return;
 		this.#started = false;
+		await this.#queue.settled();
 		await Promise.all([this.#transport.unsubscribe(this.#redisChannel), this.#bytes !== null ? this.#transport.unsubscribe(this.#bytes.channel) : void 0]);
 	}
 	describe() {
@@ -295,7 +287,8 @@ var RedisBackplane = class RedisBackplane {
 			crossPod: true,
 			channel: this.#redisChannel,
 			sealed: this.#secret !== null,
-			...this.#secret !== null && { sealRejectedTotal: this.#sealRejectedTotal },
+			...this.#secret !== null && { sealRejectedTotal: this.#ingress.sealRejectedTotal },
+			echoTotal: this.#ingress.echoTotal,
 			queue: this.#queue.describe(),
 			...this.#bytes !== null && { bytes: true }
 		};