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

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

@@ -1,8 +1,11 @@
-import { isRealtimeConfig } from "../../config/defineModuleConfig.js";
 import { RESERVED_SYSTEM_PREFIXES, getRealtimeHub } from "../server/RealtimeHub.js";
+import { realtimeConnectSource } from "./publicOrigin.js";
 import { applyDeclaredBroadcastPrefixes } from "../../decorators/realtimeDecorators.js";
+import { isRealtimeConfig } from "../../config/defineModuleConfig.js";
 import { Service } from "nodefony";
 // nodefony/src/service/RealtimeService.ts
+/** Nom sous lequel ce module contribue à la politique de contenu. */
+const CSP_CONTRIBUTOR = "realtime";
 const serviceName = "realtimeService";
 /**
 * Façade DI publique de la **socket Nodefony** côté serveur.
@@ -70,7 +73,17 @@ var RealtimeService = class extends Service {
 		}
 		hub.setOriginGuard(buildOriginGuard(this.#config));
 		hub.setMaxChannelsPerConnection(this.#config.limits.maxChannelsPerConnection);
+		hub.setAdmissionLimits({
+			authenticateTimeoutMs: this.#config.authenticateTimeoutMs,
+			allowTimeoutMs: this.#config.allowTimeoutMs,
+			maxPendingAllowsPerConnection: this.#config.maxPendingAllowsPerConnection,
+			maxPendingAllowsTotal: this.#config.maxPendingAllowsTotal
+		});
 		hub.setSlowConsumerBytes(this.#config.slowConsumer.bytes);
+		if (this.#config.codec === "cbor") {
+			const { CBOR_FRAME_CODEC } = await import("nodefony/cbor");
+			hub.setFrameCodec(CBOR_FRAME_CODEC);
+		} else hub.setFrameCodec();
 		hub.setClientLogsLimits(this.#config.clientLogs.enabled ? {
 			maxEntriesPerBatch: this.#config.clientLogs.maxEntriesPerBatch,
 			maxEntriesPerWindow: this.#config.clientLogs.maxEntriesPerWindow,
@@ -78,8 +91,26 @@ var RealtimeService = class extends Service {
 			maxStringLength: this.#config.clientLogs.maxStringLength
 		} : null);
 		applyDeclaredBroadcastPrefixes(hub);
+		if (this.#config.publicOrigin !== void 0) this.#declareCspOrigin(this.#config.publicOrigin);
 		return this;
 	}
+	/**
+	* Déclare au pare-feu l'origine publique de la socket dans `connect-src`.
+	*
+	* Différé à `onReady` : au moment de `init`, le module de sécurité peut ne pas
+	* avoir encore enregistré son pare-feu (ordre des modules). Sans pare-feu
+	* (application sans `@nodefony/security`), aucune politique n'est posée :
+	* rien à déclarer.
+	*
+	* @param publicOrigin - origine nue validée par le schéma
+	*/
+	#declareCspOrigin(publicOrigin) {
+		const source = realtimeConnectSource(publicOrigin);
+		if (source === null) return;
+		this.kernel?.once("onReady", () => {
+			this.get("firewall")?.registerCspOrigins?.(CSP_CONTRIBUTOR, { "connect-src": [source] });
+		});
+	}
 	/** Configuration realtime gelée (lue par Studio / introspection). */
 	getConfig() {
 		if (!this.#config) throw new Error(`${serviceName}: not initialized`);
@@ -89,6 +120,14 @@ var RealtimeService = class extends Service {
 	getHub() {
 		return this.#hub ??= getRealtimeHub();
 	}
+	/**
+	* Le codec texte des connexions socket, lu PAR NOM par le REST du plan
+	* d'administration (`AdminApiController`, framework ne dépend pas de realtime) :
+	* les octets d'une réponse `GET` y prennent la même forme que sur la socket.
+	*/
+	get textFrameCodec() {
+		return this.getHub().textFrameCodec;
+	}
 	/** Backplane actuellement branché sur le hub (ou null = Loopback implicite). */
 	getBackplane() {
 		return this.getHub().backplane;
@@ -96,6 +135,8 @@ var RealtimeService = class extends Service {
 	/**
 	* Publie une charge sur un canal — fan-out local + propagation backplane si
 	* canal broadcast. Délégué à `RealtimeHub.publish`.
+	*
+	* @throws TypeError si la charge est un scalaire ou `null` (cf `isRealtimePayload`).
 	*/
 	publish(channel, payload) {
 		this.getHub().publish(channel, payload);
@@ -207,6 +248,15 @@ var RealtimeService = class extends Service {
 		return this.getHub().resolveChannelPolicy(channel);
 	}
 	/**
+	* **Seam #1b** — lecture ET écriture distincte d'un nom, en une résolution (ADR-0022 §6, décision 1 quater). Lu par `@nodefony/security` sur chaque trame jugée.
+	*
+	* @param channel - nom du canal, de la méthode entrante ou de l'action.
+	* @returns les deux politiques, ou `null` si aucune ne couvre ce nom.
+	*/
+	resolveChannelPolicies(channel) {
+		return this.getHub().resolveChannelPolicies(channel);
+	}
+	/**
 	* Renvoie le token associé à un peer (posé au handshake par le hub). Jamais
 	* `null` (Zero Trust : `ANONYMOUS_REALTIME_TOKEN` si aucun authenticator n'a
 	* capturé la connexion). Lookup O(1) via WeakMap interne. Branchement P6 :

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

@@ -0,0 +1,40 @@
+import { parseBareOrigin } from "nodefony";
+// nodefony/src/service/publicOrigin.ts
+/**
+* Schémas qu'accepte `realtime.publicOrigin` : celui de la socket (`ws:`,
+* `wss:`) ou celui de l'hôte qui la sert (`http:`, `https:`), ramené au
+* premier.
+*/
+const REALTIME_ORIGIN_PROTOCOLS = [
+	"ws:",
+	"wss:",
+	"http:",
+	"https:"
+];
+/** Le schéma de socket qui correspond à chaque schéma accepté. */
+const SOCKET_SCHEME = {
+	"ws:": "ws:",
+	"wss:": "wss:",
+	"http:": "ws:",
+	"https:": "wss:"
+};
+/**
+* Rend la source `connect-src` qui autorise la socket servie à `publicOrigin`,
+* toujours sous son schéma de socket.
+*
+* Une source `wss://hôte` couvre `wss:` ET `https:` du même hôte (CSP Level 3,
+* « scheme-part match ») ; une source `https://hôte` ne couvrirait PAS la
+* socket. D'où la conversion `https:` → `wss:`, `http:` → `ws:`.
+*
+* @param publicOrigin - origine nue où la socket est servie
+* @returns la source à déclarer (`wss://rt.example.com:8443`), ou `null` si la
+*   valeur n'est pas une origine nue d'un schéma accepté
+*/
+function realtimeConnectSource(publicOrigin) {
+	const url = parseBareOrigin(publicOrigin, REALTIME_ORIGIN_PROTOCOLS);
+	if (url === null) return null;
+	const scheme = SOCKET_SCHEME[url.protocol];
+	if (scheme === void 0) return null;
+	return `${scheme}//${url.host}`;
+}
+export { REALTIME_ORIGIN_PROTOCOLS, realtimeConnectSource };

package/dist/nodefony/src/transport/WsConnectionTransport.js

@@ -24,6 +24,16 @@ import { decideSend } from "@nodefony/http";
 * la fermeture est signalée par `fireClose()` (hook `onFinish` du Context). Le
 * `connect`/`onOpen` sont des no-op (la connexion est déjà ouverte au handshake).
 */
+/**
+* Vrai si les octets reposent sur un `ArrayBuffer` ordinaire — ce que le pair
+* et ses codecs reçoivent (`RealtimeFrameData`), jamais un `SharedArrayBuffer`.
+*
+* @param bytes - les octets reçus.
+* @returns `true` si la vue porte sur un `ArrayBuffer`.
+*/
+function isOwnedBytes(bytes) {
+	return bytes.buffer instanceof ArrayBuffer;
+}
 var WsConnectionTransport = class {
 	conn;
 	_onMessage = null;
@@ -78,7 +88,7 @@ var WsConnectionTransport = class {
 	* Compte une trame ENTRANTE écartée et rend le cumul de sa nature — `1` dit
 	* « première », le seul instant où l'appelant journalise.
 	*
-	* @param kind - `binary` (sans lecteur) ou `malformed` (texte non JSON).
+	* @param kind - `binary` (sans lecteur) ou `malformed` (illisible par le codec).
 	* @returns le cumul de cette nature, après incrément.
 	*/
 	discard(kind) {
@@ -88,7 +98,7 @@ var WsConnectionTransport = class {
 	get binaryDiscarded() {
 		return this._binaryDiscarded;
 	}
-	/** Cumul de trames TEXTE reçues et écartées parce que non JSON — monotone. */
+	/** Cumul de trames reçues et écartées parce qu'illisibles par le codec de la connexion — monotone. */
 	get malformedDiscarded() {
 		return this._malformedDiscarded;
 	}
@@ -122,9 +132,22 @@ var WsConnectionTransport = class {
 		this._onClose = cb;
 	}
 	onError() {}
-	/** Pump entrant : le pipeline framework pousse ici chaque message reçu. */
+	/**
+	* Pump entrant : le pipeline framework pousse ici chaque frame reçue — texte,
+	* ou octets d'une connexion qui a négocié un codec binaire (ADR-0022 §2).
+	*
+	* Une vue sur un `SharedArrayBuffer` n'est pas une trame : `ws` livre
+	* toujours un `Buffer` sur un `ArrayBuffer`, le type de Node l'admet
+	* seulement. Elle est comptée comme illisible, jamais transmise au pair.
+	*
+	* @param raw - la trame telle que reçue.
+	*/
 	feed(raw) {
-		this._onMessage?.(raw);
+		if (typeof raw === "string" || isOwnedBytes(raw)) {
+			this._onMessage?.(raw);
+			return;
+		}
+		this._malformedDiscarded += 1;
 	}
 	/** Fermeture : appelée par le owner sur `onFinish` (close WS). */
 	fireClose(code = 1e3, reason = "") {

package/dist/nodefony/testing/backplaneConformance.js

@@ -0,0 +1,347 @@
+import { RealtimeHub } from "../src/server/RealtimeHub.js";
+import { readControlOrder } from "../src/backplane/controlOrder.js";
+import "../src/backplane/publishQueue.js";
+import { presenceClient, presenceView } from "./presenceClient.js";
+import { PLATFORM_BUS_CHANNELS, PLATFORM_CHANNELS, ownField } from "nodefony";
+import { randomBytes, randomUUID } from "node:crypto";
+import assert from "node:assert/strict";
+// nodefony/testing/backplaneConformance.ts
+/**
+* Suite de conformité d'un **driver de backplane** — la définition exécutable du
+* contrat {@link IBackplane}, une seule pour tous les drivers (ADR-0022 §6,
+* décision 4).
+*
+* Un driver écrit par un tiers (journal partitionné, bus de messages…) compile et
+* démarre même mal réglé : un groupe de lecteurs partagé entre serveurs répartit
+* les messages au lieu de les diffuser, une lecture depuis le début du journal
+* rejoue des fins de partie sur des parties rouvertes. Rien ne lève, tout se perd
+* en silence. Cette suite rend ces défauts visibles : elle relie plusieurs pairs du
+* driver sur un même bus et vérifie ce que le hub tient pour acquis.
+*
+* ```ts
+* import { describe, it } from "vitest";
+* import { runBackplaneConformance } from "@nodefony/realtime/testing";
+*
+* runBackplaneConformance("mon-bus", (secret) => new MonBackplane({ url, secret }), { describe, it });
+* ```
+*
+* Le lanceur de tests est PASSÉ, jamais importé : le paquet publié ne dépend
+* d'aucun lanceur, et la suite tourne sous vitest, `node:test` ou `bun test`. Les
+* assertions passent par `node:assert`, qu'ils rapportent tous.
+*
+* @packageDocumentation
+*/
+/** Noms des cas — stables : un test négatif les désigne. */
+const BACKPLANE_CONFORMANCE_CASES = {
+	fanout: "diffusion : chaque pair reçoit TOUT, l'émetteur ne reçoit pas son écho",
+	order: "ordre par émetteur : les publications d'un pair arrivent dans l'ordre",
+	noReplay: "pas de rejeu : un pair démarré après une publication ne la reçoit pas",
+	seal: "sceau : un message non scellé ou mal scellé est refusé",
+	control: "ordres de contrôle : le canal de contrôle traverse intact",
+	controlUnderLoad: "ordre sous saturation : un ordre de contrôle n'est jamais jeté pour faire place aux publications",
+	aliveUnderLoad: "preuve de vie sous saturation : la preuve de vie de la présence n'est jamais jetée pour faire place aux publications",
+	reserved: "espace réservé : refusé et compté à l'entrée du hub, la diffusion passe sans revenir",
+	presence: "présence entre deux pods : chaque hub voit les présents de l'autre, l'arrêt propre les retire sans attendre l'oubli, sans doublon ni rejeu",
+	replaceHandler: "onMessage remplace le handler précédent",
+	stop: "stop coupe la réception, et se rappelle sans erreur"
+};
+const POLL_MS = 5;
+/** Charges de contrôle de fidélité : objet imbriqué, tableau, texte non ASCII. */
+function sample(seq) {
+	return {
+		seq,
+		text: "é — 😀",
+		list: [
+			seq,
+			"a",
+			null,
+			{ deep: true }
+		]
+	};
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function seqOf(payload) {
+	return typeof payload === "object" && payload !== null && "seq" in payload ? payload.seq : void 0;
+}
+function isFrom(payload, from) {
+	return typeof payload === "object" && payload !== null && "from" in payload && payload.from === from;
+}
+/** Attend qu'une condition tienne, ou échoue en nommant ce qui manquait (lu à l'échec). */
+async function until(done, timeoutMs, what) {
+	const deadline = Date.now() + timeoutMs;
+	while (!done()) {
+		if (Date.now() > deadline) assert.fail(`délai dépassé (${timeoutMs} ms) : ${what()}`);
+		await sleep(POLL_MS);
+	}
+}
+/**
+* Boîte de réception d'un pair, filtrée sur les canaux du cas courant. Posée
+* AVANT `start`, comme le hub le fait : un driver qui livrerait dès l'abonnement
+* (un rejeu, par exemple) est vu.
+*/
+var Inbox = class {
+	messages = [];
+	#prefix;
+	constructor(peer, prefix) {
+		this.#prefix = prefix;
+		peer.onMessage((msg) => {
+			if (msg.channel.startsWith(this.#prefix)) this.messages.push(msg);
+		});
+	}
+	payloads() {
+		return this.messages.map((m) => m.payload);
+	}
+};
+/**
+* Déclare la suite de conformité d'un driver de backplane auprès du lanceur de
+* tests de l'appelant.
+*
+* Vérifie, sur plusieurs pairs reliés au même bus : la diffusion à TOUS les pairs
+* sans écho, l'ordre par émetteur, l'absence de rejeu au démarrage, le sceau
+* (message non scellé ou mal scellé refusé), le transport des ordres de contrôle,
+* même quand une rafale de publications sature la file d'envoi, le refus de
+* l'espace réservé à l'entrée du hub, la présence répartie entre deux hubs
+* (ADR-0025), le remplacement du handler et l'arrêt.
+*
+* @param name - nom du driver, affiché dans le rapport.
+* @param makePeer - fabrique d'un pair relié au bus commun.
+* @param options - le lanceur (`describe`, `it`) et les réglages.
+*/
+function runBackplaneConformance(name, makePeer, options) {
+	const sealed = options.sealed ?? true;
+	const quietMs = options.quietMs ?? 100;
+	const timeoutMs = options.timeoutMs ?? 2e3;
+	const floodBytes = options.floodBytes ?? 16777216;
+	const secret = sealed ? randomBytes(32).toString("hex") : null;
+	const C = BACKPLANE_CONFORMANCE_CASES;
+	/**
+	* Cadre d'un cas : pairs ouverts puis tous arrêtés, et un préfixe de canal
+	* unique — un bus partagé entre cas ne mélange jamais leurs messages.
+	*/
+	const scenario = (body) => {
+		return async () => {
+			const peers = [];
+			const prefix = `conformance:${randomUUID()}:`;
+			const open = async (peerSecret = secret) => {
+				const peer = await makePeer(peerSecret);
+				peers.push(peer);
+				const inbox = new Inbox(peer, prefix);
+				await peer.start();
+				return {
+					peer,
+					inbox
+				};
+			};
+			try {
+				await body(open, prefix);
+			} finally {
+				await Promise.all(peers.map(async (p) => {
+					await p.stop();
+				}));
+			}
+		};
+	};
+	options.describe(`conformité du backplane « ${name} »`, () => {
+		options.it(C.fanout, scenario(async (open, prefix) => {
+			const a = await open();
+			const b = await open();
+			const c = await open();
+			const sent = Array.from({ length: 10 }, (_, i) => sample(i));
+			for (const p of sent) a.peer.publish(`${prefix}fanout`, p);
+			await until(() => b.inbox.messages.length >= sent.length && c.inbox.messages.length >= sent.length, timeoutMs, () => `B et C attendaient ${sent.length} messages, reçus ${b.inbox.messages.length} et ${c.inbox.messages.length} — le bus répartit-il les messages entre pairs ?`);
+			b.peer.publish(`${prefix}fanout`, { seq: -1 });
+			await until(() => a.inbox.messages.some((m) => m.originId === b.peer.originId), timeoutMs, () => "A n'a pas reçu la sentinelle de B");
+			await sleep(quietMs);
+			assert.deepEqual(b.inbox.payloads(), sent, "B : charges reçues fidèlement");
+			assert.deepEqual(c.inbox.messages.filter((m) => m.originId === a.peer.originId).map((m) => m.payload), sent, "C : charges reçues fidèlement");
+			for (const m of b.inbox.messages) assert.equal(m.originId, a.peer.originId);
+			assert.ok(a.inbox.messages.every((m) => m.originId === b.peer.originId), "l'émetteur a reçu son propre écho");
+		}));
+		options.it(C.order, scenario(async (open, prefix) => {
+			const a = await open();
+			const b = await open();
+			const count = 100;
+			for (let i = 0; i < count; i += 1) a.peer.publish(`${prefix}order`, { seq: i });
+			await until(() => b.inbox.messages.length >= count, timeoutMs, () => `B attendait ${count} messages, reçus ${b.inbox.messages.length}`);
+			assert.deepEqual(b.inbox.payloads().map(seqOf), Array.from({ length: count }, (_, i) => i), "ordre d'émission perdu — la clé de partition doit être l'émetteur, jamais le canal");
+		}));
+		options.it(C.noReplay, scenario(async (open, prefix) => {
+			const a = await open();
+			const witness = await open();
+			a.peer.publish(`${prefix}replay`, { seq: 0 });
+			await until(() => witness.inbox.messages.length === 1, timeoutMs, () => "le témoin n'a pas reçu la première publication");
+			const late = await open();
+			a.peer.publish(`${prefix}replay`, { seq: 1 });
+			await until(() => late.inbox.messages.some((m) => seqOf(m.payload) === 1), timeoutMs, () => "le pair démarré en retard n'a pas reçu la publication suivante");
+			await sleep(quietMs);
+			assert.deepEqual(late.inbox.payloads().map(seqOf), [1], "rejeu au démarrage — lire à partir du dernier message, jamais depuis le début");
+		}));
+		options.it(C.seal, scenario(async (open, prefix) => {
+			if (!sealed) {
+				const { peer } = await open(null);
+				assert.notEqual(peer.describe().crossPod, true, "un bus qui quitte la machine (crossPod) doit sceller : retirer `sealed: false`");
+				return;
+			}
+			const receiver = await open();
+			const bare = await open(null);
+			const forged = await open(randomBytes(32).toString("hex"));
+			const genuine = await open();
+			bare.peer.publish(`${prefix}seal`, { from: "non scellé" });
+			forged.peer.publish(`${prefix}seal`, { from: "autre secret" });
+			genuine.peer.publish(`${prefix}seal`, { from: "scellé" });
+			await until(() => receiver.inbox.messages.some((m) => isFrom(m.payload, "scellé")), timeoutMs, () => "le message scellé du bon secret n'est pas arrivé");
+			await sleep(quietMs);
+			assert.deepEqual(receiver.inbox.payloads(), [{ from: "scellé" }], "un message non scellé ou mal scellé a été accepté");
+		}));
+		options.it(C.control, scenario(async (open, prefix) => {
+			const a = await open();
+			const b = await open();
+			const got = [];
+			b.peer.onMessage((msg) => {
+				if (msg.channel !== PLATFORM_BUS_CHANNELS.control) return;
+				const order = readControlOrder(msg.payload);
+				if (order?.channel.startsWith(prefix) === true) got.push(order);
+			});
+			const orders = [{
+				op: "close",
+				channel: `${prefix}room`
+			}, {
+				op: "evictUser",
+				channel: `${prefix}chat`,
+				user: "u-42",
+				generation: 3
+			}];
+			for (const o of orders) a.peer.publish(PLATFORM_BUS_CHANNELS.control, o);
+			await until(() => got.length >= orders.length, timeoutMs, () => `ordres de contrôle reçus : ${got.length} sur ${orders.length}`);
+			assert.deepEqual(got, orders);
+		}));
+		/**
+		* Rafale qui sature la file d'envoi de A, puis UN message sur un canal
+		* prioritaire : il doit arriver chez B. `pick` reconnaît le message du cas.
+		*/
+		const underLoad = (channel, payload, pick, lost) => scenario(async (open, prefix) => {
+			const a = await open();
+			const b = await open();
+			const got = [];
+			b.peer.onMessage((msg) => {
+				if (msg.channel === channel && pick(msg.payload, prefix)) got.push(msg.payload);
+			});
+			const chunk = Math.min(65536, Math.ceil(floodBytes / 4));
+			const pad = "x".repeat(chunk);
+			const count = Math.ceil(floodBytes / chunk);
+			for (let i = 0; i < count; i += 1) a.peer.publish(`${prefix}flood`, {
+				seq: i,
+				pad
+			});
+			const sent = payload(prefix);
+			a.peer.publish(channel, sent);
+			const queue = a.peer.describe().queue;
+			if (queue !== void 0 && queue.maxBytes > 0) assert.ok(queue.droppedTotal > 0, `la rafale de ${floodBytes} octets n'a pas saturé la file (seuil ${queue.maxBytes}) : relever floodBytes, sinon ce cas ne prouve rien`);
+			await until(() => got.length > 0, timeoutMs, () => lost);
+			assert.deepEqual(got, [sent]);
+		});
+		options.it(C.controlUnderLoad, underLoad(PLATFORM_BUS_CHANNELS.control, (prefix) => ({
+			op: "evictUser",
+			channel: `${prefix}chat`,
+			user: "mallory"
+		}), (msg, prefix) => readControlOrder(msg)?.channel.startsWith(prefix) === true, "l'ordre d'éjection émis sous saturation n'est pas arrivé — la file l'a-t-elle jeté avec les publications ?"));
+		options.it(C.aliveUnderLoad, underLoad(PLATFORM_BUS_CHANNELS.presenceAlive, (prefix) => ({ probe: prefix }), (msg, prefix) => ownField(msg, "probe") === prefix, "la preuve de vie émise sous saturation n'est pas arrivée — la file l'a-t-elle jetée avec les publications ? Un pair oublierait ce pod vivant."));
+		options.it(C.reserved, scenario(async (open, prefix) => {
+			const a = await open();
+			const b = await open();
+			const hubA = new RealtimeHub();
+			const hubB = new RealtimeHub();
+			try {
+				hubA.setBackplane(a.peer);
+				hubB.setBackplane(b.peer);
+				hubA.markBroadcastChannel(prefix);
+				hubB.markBroadcastChannel(prefix);
+				const noop = () => () => {};
+				const channel = `${prefix}room`;
+				const gotA = [];
+				const gotB = [];
+				const audit = [];
+				hubA.subscribe(channel, (p) => gotA.push(p), noop);
+				hubB.subscribe(channel, (p) => gotB.push(p), noop);
+				hubB.subscribe(PLATFORM_CHANNELS.audit, (p) => audit.push(p), noop);
+				a.peer.publish(PLATFORM_CHANNELS.audit, { forged: "faux évènement d'audit" });
+				hubA.publish(channel, { ok: 1 });
+				await until(() => gotB.length > 0, timeoutMs, () => "la diffusion déclarée n'a pas atteint le hub B");
+				await sleep(quietMs);
+				assert.deepEqual(audit, [], "un canal réservé a atteint les abonnés locaux");
+				assert.equal(hubB.probe().ingressRejectedTotal, 1, "rejet non compté");
+				assert.deepEqual(gotB, [{ ok: 1 }]);
+				assert.deepEqual(gotA, [{ ok: 1 }], "message renvoyé sur le bus (boucle)");
+			} finally {
+				hubA.clear();
+				hubB.clear();
+			}
+		}));
+		options.it(C.presence, scenario(async (open, prefix) => {
+			const a = await open();
+			const b = await open();
+			const hubA = new RealtimeHub();
+			const hubB = new RealtimeHub();
+			try {
+				for (const hub of [hubA, hubB]) {
+					hub.declareChannelPolicy(`${prefix}*`, { presence: true }, null);
+					hub.markBroadcastChannel(prefix);
+				}
+				hubA.setBackplane(a.peer);
+				hubB.setBackplane(b.peer);
+				const channel = `${prefix}room`;
+				const same = (hub, want) => JSON.stringify(presenceView(hub, channel)) === JSON.stringify(want);
+				presenceClient(hubA, channel, "alice");
+				presenceClient(hubA, channel, null);
+				presenceClient(hubB, channel, "alice");
+				presenceClient(hubB, channel, "bob");
+				const both = {
+					alice: 2,
+					bob: 1
+				};
+				await until(() => same(hubB, both) && hubB.presence(channel)?.unnamed === 1 && hubB.presence(channel)?.partial === false && same(hubA, both), timeoutMs, () => `présence attendue ${JSON.stringify(both)} — A voit ${JSON.stringify(presenceView(hubA, channel))}, B voit ${JSON.stringify(presenceView(hubB, channel))} (lots, demandes ou réponses de présence perdus par le bus ?)`);
+				hubA.endPresence();
+				await until(() => same(hubB, {
+					alice: 1,
+					bob: 1
+				}) && hubB.presence(channel)?.unnamed === 0, timeoutMs, () => `après l'arrêt propre de A, B voit encore ${JSON.stringify(presenceView(hubB, channel))} — la preuve de vie finale a-t-elle traversé le bus ?`);
+				const probe = hubB.probe().presence;
+				assert.equal(probe?.endedTotal, 1, "arrêt propre non reçu");
+				assert.equal(probe.forgottenTotal, 0, "A oublié au lieu d'être retiré");
+				assert.equal(probe.presenceStaleDiscardedTotal, 0, "messages de présence reçus en double ou rejoués — le bus livre-t-il deux fois ?");
+				assert.equal(probe.presenceRejectedTotal, 0, "messages de présence refusés — la charge a-t-elle été altérée en route ?");
+			} finally {
+				hubA.clear();
+				hubB.clear();
+			}
+		}));
+		options.it(C.replaceHandler, scenario(async (open, prefix) => {
+			const a = await open();
+			const b = await open();
+			const second = [];
+			b.peer.onMessage((m) => {
+				if (m.channel.startsWith(prefix)) second.push(m.payload);
+			});
+			a.peer.publish(`${prefix}handler`, { seq: 0 });
+			await until(() => second.length > 0, timeoutMs, () => "le second handler n'a rien reçu");
+			await sleep(quietMs);
+			assert.equal(b.inbox.messages.length, 0, "l'ancien handler reçoit encore");
+			assert.deepEqual(second, [{ seq: 0 }]);
+		}));
+		options.it(C.stop, scenario(async (open, prefix) => {
+			const a = await open();
+			const b = await open();
+			const witness = await open();
+			await b.peer.stop();
+			await b.peer.stop();
+			const after = new Inbox(b.peer, prefix);
+			a.peer.publish(`${prefix}stop`, { seq: 0 });
+			await until(() => witness.inbox.messages.length > 0, timeoutMs, () => "le témoin n'a pas reçu la publication");
+			await sleep(quietMs);
+			assert.equal(after.messages.length, 0, "un pair arrêté reçoit encore");
+		}));
+	});
+}
+export { BACKPLANE_CONFORMANCE_CASES, runBackplaneConformance };

package/dist/nodefony/testing/index.js

@@ -1,6 +1,9 @@
+import "../src/server/RealtimeController.js";
 import { isRecord } from "../src/guards.js";
+import { createAdmissionResolver, registerControllerPolicies } from "../src/server/channelPolicyRegistry.js";
 import { getRealtimeHub } from "../src/server/RealtimeHub.js";
-import { RequestContext } from "nodefony";
+import { BACKPLANE_CONFORMANCE_CASES, runBackplaneConformance } from "./backplaneConformance.js";
+import { IDENTITY_DEAD_CLOSE_CODE, ORIGIN_REFUSED_CLOSE_CODE, RequestContext } from "nodefony";
 // nodefony/testing/index.ts
 /**
 * `@nodefony/realtime/testing` — **harnais de test d'un controller temps réel**.
@@ -61,7 +64,8 @@ async function waitFor(predicate, ticks) {
 const DENIED_REASONS = {
 	forbidden: true,
 	limit: true,
-	unknown: true
+	unknown: true,
+	unavailable: true
 };
 function isDeniedReason(reason) {
 	return Object.hasOwn(DENIED_REASONS, reason);
@@ -114,6 +118,8 @@ function readDenied(params) {
 	};
 	throw new Error(`createRealtimeHarness: realtime:denied malformé — ${JSON.stringify(params)}`);
 }
+/** Compteur des vhosts de harnais — un par harnais à identité, jamais réutilisé. */
+let harnessCount = 0;
 /**
 * Monte un controller temps réel sur une fausse connexion et rend de quoi le
 * piloter.
@@ -129,9 +135,18 @@ function readDenied(params) {
 function createRealtimeHarness(create, options = {}) {
 	const hub = getRealtimeHub();
 	if (options.resetHub !== false) hub.clear();
+	let headers = options.headers ?? {};
 	if (options.identity !== void 0) {
 		const token = options.identity;
-		hub.useAuthenticator({ pattern: /.*/u }, {
+		const host = headers["host"] ?? `harness-${++harnessCount}.invalid`;
+		headers = {
+			...headers,
+			host
+		};
+		hub.useAuthenticator({
+			pattern: /.*/u,
+			host
+		}, {
 			name: "harness",
 			supports: () => true,
 			authenticate: () => Promise.resolve(token)
@@ -159,12 +174,13 @@ function createRealtimeHarness(create, options = {}) {
 	};
 	const controller = create({
 		type: "websocket",
+		outboundTracer: () => null,
 		connection,
 		once: (event, fn) => {
 			if (event === "onFinish") onFinish = fn;
 		},
 		request: {
-			headers: options.headers ?? {},
+			headers,
 			url
 		},
 		cookies: options.cookies ?? {},
@@ -172,6 +188,8 @@ function createRealtimeHarness(create, options = {}) {
 		remoteAddress: "127.0.0.1",
 		origin: options.origin ?? ""
 	});
+	const admissions = options.admissions;
+	if (admissions !== void 0) registerControllerPolicies(hub, controller.constructor, createAdmissionResolver((_key, admissionClass) => admissions.find((admission) => admission instanceof admissionClass), () => {}));
 	const bridge = controller;
 	let nextId = 1;
 	const identity = options.identity;
@@ -197,15 +215,28 @@ function createRealtimeHarness(create, options = {}) {
 		closes,
 		notices,
 		async connect() {
-			await feed(null);
-			hub.onPlatformNotice((message) => {
-				notices.push(message);
-			});
-			await waitFor(() => received.some((f) => f.method === "realtime:welcome"), 10);
+			const failures = [];
+			const syslog = controller.syslog;
+			const onLog = (pdu) => {
+				const payload = pdu.payload;
+				if (pdu.severityName === "ERROR" && typeof payload === "string" && payload.startsWith("WS realtime handshake failed")) failures.push(payload);
+			};
+			syslog?.on("onLog", onLog);
+			try {
+				await feed(null);
+				hub.onPlatformNotice((message) => {
+					notices.push(message);
+				});
+				await waitFor(() => received.some((f) => f.method === "realtime:welcome") || failures.length > 0, 10);
+			} finally {
+				syslog?.removeListener("onLog", onLog);
+			}
 			const welcome = received.find((f) => f.method === "realtime:welcome");
 			if (!welcome) {
-				const cause = closes.length > 0 ? `socket fermée (code ${String(closes[0]?.code)})` : "aucune frame émise";
-				throw new Error(`createRealtimeHarness: pas de realtime:welcome — ${cause}. Vérifier l'Origin (seam #4) et l'authenticator (seam #2).`);
+				const code = closes[0]?.code;
+				const cause = closes.length > 0 ? `socket fermée (code ${String(code)})` : "aucune frame émise";
+				const hint = failures.length > 0 ? `le serveur a levé pendant la poignée de main : ${failures[0] ?? ""}` : code === ORIGIN_REFUSED_CLOSE_CODE ? "Origin refusée (option `origin` du harnais)" : code === IDENTITY_DEAD_CLOSE_CODE ? "identité refusée (option `identity` du harnais)" : "vérifier ce que le controller construit à la connexion (services, admissions, base)";
+				throw new Error(`createRealtimeHarness: pas de realtime:welcome — ${cause}. ${hint}.`);
 			}
 			return welcome;
 		},
@@ -275,4 +306,4 @@ function createRealtimeHarness(create, options = {}) {
 		}
 	};
 }
-export { createRealtimeHarness };
+export { BACKPLANE_CONFORMANCE_CASES, createRealtimeHarness, runBackplaneConformance };