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

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

@@ -0,0 +1,541 @@
+import "../backplane/presenceMessage.js";
+import { classifyNumberedChange } from "nodefony";
+// nodefony/src/server/remotePresence.ts
+/** Ce qu'un pod annonce sur UN canal : identités nommées → onglets, et connexions non nommées. */
+var RemoteChannel = class {
+	members = /* @__PURE__ */ new Map();
+	unnamed = 0;
+};
+/**
+* Ce que CE pod sait d'un pair — une vie (`originId`, incarnation), ses numéros, son dernier signe de vie, ses tables par canal.
+*
+* Classe à forme fixe : un pair lu à chaque message, des champs jamais ajoutés
+* après coup.
+*/
+var RemotePod = class {
+	origin;
+	incarnation;
+	/** `seq` du dernier lot appliqué ; `null` = trou (vue à resynchroniser). */
+	reference = null;
+	/** Plus haut `seq` vu sur le canal des lots, demandes et réponses. */
+	messageSeq = 0;
+	/**
+	* Plus haut `seq` vu sur le canal de la preuve de vie — relevé À PART : la
+	* preuve de vie passe hors quota de la file d'envoi et peut doubler un lot
+	* encore en attente ; un relevé commun jetterait ce lot comme un rejeu.
+	*/
+	aliveSeq = 0;
+	/** Intervalle ANNONCÉ par le pair (ms). */
+	interval;
+	/** Dernier signe de vie, horloge monotone LOCALE (ms). */
+	lastSeen;
+	/** Instant de la dernière demande d'état pendant un trou ; `-Infinity` = à faire. */
+	requestedAt = Number.NEGATIVE_INFINITY;
+	/** Canaux nommés par la demande en cours — les réponses ne ferment le trou que si elles les couvrent. */
+	asked = null;
+	/**
+	* Canaux nommés pendant le trou par les réponses au même `last` — elles décrivent le même état, leurs couvertures s'additionnent ; `null` hors trou.
+	*/
+	covered = null;
+	/** `last` des réponses relevées dans {@link RemotePod.covered}. */
+	coveredLast = 0;
+	/** Pierre tombale : arrêt propre reçu, plus rien de cette vie ne s'applique. */
+	ended = false;
+	/** Tables par canal servi ; `null` tant que le pair n'a présenté personne ici. */
+	channels = null;
+	partSeq = 0;
+	partCount = 0;
+	partLast = 0;
+	parts = null;
+	constructor(origin, incarnation, interval, now) {
+		this.origin = origin;
+		this.incarnation = incarnation;
+		this.interval = interval;
+		this.lastSeen = now;
+	}
+};
+/** Entrées d'une table, retirées de l'agrégat quand le pod PART (grâce du canal pour les identités nommées). */
+function withdraw(table, aggregate, now) {
+	for (const [key, tabs] of table.members) aggregate.remoteLeave(key, tabs, now);
+	if (table.unnamed !== 0) aggregate.remoteUnnamed(-table.unnamed);
+}
+/**
+* Pose les paires à plat `[identité, onglets, …]` dans `table`, EN PLACE — une lecture par membre, l'agrégat n'est appelé que si le nombre d'onglets change.
+*/
+function upsertPairs(table, pairs, aggregate) {
+	const members = table.members;
+	for (let i = 0; i < pairs.length; i += 2) {
+		const key = pairs[i];
+		const tabs = pairs[i + 1];
+		if (typeof key !== "string" || typeof tabs !== "number") continue;
+		const old = members.get(key);
+		if (old === tabs) continue;
+		members.set(key, tabs);
+		aggregate.remoteTabs(key, old === void 0 ? tabs : tabs - old);
+	}
+}
+/**
+* Retire de `table` les identités qu'une réponse d'état ne nomme plus — chemin RARE : il ne tourne que si la table compte plus d'identités que la réponse n'en nomme.
+*
+* Un émetteur conforme ne nomme jamais deux fois la même identité ; un qui le
+* ferait (il détient alors le secret du bus) peut laisser une entrée jusqu'à
+* l'état suivant ou à l'oubli — rien de plus que ce qu'il peut déjà forger.
+*/
+function dropAbsentIn(table, channel, parts, aggregate) {
+	const named = /* @__PURE__ */ new Set();
+	for (const entries of parts) for (const entry of entries) {
+		if (entry.channel !== channel) continue;
+		const pairs = entry.members;
+		for (let i = 0; i < pairs.length; i += 2) {
+			const key = pairs[i];
+			if (typeof key === "string") named.add(key);
+		}
+	}
+	const members = table.members;
+	for (const [key, tabs] of members) {
+		if (named.has(key)) continue;
+		members.delete(key);
+		aggregate.remoteTabs(key, -tabs);
+	}
+}
+/**
+* Vue de la présence des PAIRS, rangée par pod puis par canal (ADR-0025 P2) — la règle répartie, sans horloge, sans minuteur, sans bus.
+*
+* Elle applique ce que le bus apporte — lots chaînés par `seq`/`prev`, réponses
+* d'état en parts appliquées d'un bloc, preuves de vie —, détecte les trous
+* (règle pure `classifyNumberedChange`, RFC 5263 §4.5), départage les vies d'un
+* même `originId` par l'incarnation, oublie un pair muet au bout de `factor`
+* intervalles ANNONCÉS, et ne transmet aux agrégats que des DELTAS. L'instant
+* (`now`, horloge monotone) est passé à chaque appel : la règle se prouve à
+* l'horloge simulée, au compte exact.
+*
+* Coût : un canal non servi ne stocke rien ; oublier un pod libère ses tables
+* d'un coup ; un message ne parcourt que ses propres entrées. Aucun parcours de
+* tous les pods hors de {@link RemotePresence.expire},
+* {@link RemotePresence.nextDeadline}, {@link RemotePresence.rearm} et
+* {@link RemotePresence.takeRequests}, appelés au tic.
+*/
+var RemotePresence = class {
+	#lookup;
+	#factor;
+	#interval;
+	#pods = /* @__PURE__ */ new Map();
+	#gaps = 0;
+	#rejectedTotal = 0;
+	#staleTotal = 0;
+	#forgottenTotal = 0;
+	#gapTotal = 0;
+	#endedTotal = 0;
+	#closer = Number.POSITIVE_INFINITY;
+	/**
+	* @throws RangeError si `factor` < 2 (Phoenix Tracker exige le même plancher :
+	*   sous deux intervalles, une seule preuve de vie retardée fait oublier un pair
+	*   vivant) ou si `interval` n'est pas un entier > 0.
+	*/
+	constructor(options) {
+		if (!Number.isSafeInteger(options.factor) || options.factor < 2) throw new RangeError(`présence : le délai d'oubli doit valoir au moins 2 intervalles (reçu ${String(options.factor)})`);
+		if (!Number.isSafeInteger(options.interval) || options.interval <= 0) throw new RangeError(`présence : l'intervalle doit être un entier de millisecondes > 0 (reçu ${String(options.interval)})`);
+		this.#lookup = options.lookup;
+		this.#factor = options.factor;
+		this.#interval = options.interval;
+	}
+	/** Pairs connus (pierres tombales comprises). */
+	get size() {
+		return this.#pods.size;
+	}
+	/** Pairs dont la vue est en trou — la présence servie est alors `partial`. */
+	get gaps() {
+		return this.#gaps;
+	}
+	/** Messages refusés : canal non déclaré à présence ici, plafond dépassé (`presenceRejectedTotal`). */
+	get rejectedTotal() {
+		return this.#rejectedTotal;
+	}
+	/** Messages déjà vus ou d'une vie plus ancienne (`presenceStaleDiscardedTotal`). */
+	get staleTotal() {
+		return this.#staleTotal;
+	}
+	/** Pairs oubliés faute de signe de vie. */
+	get forgottenTotal() {
+		return this.#forgottenTotal;
+	}
+	/** Arrêts propres reçus (preuve de vie `final`) — présents retirés sans attendre l'oubli. */
+	get endedTotal() {
+		return this.#endedTotal;
+	}
+	/** Trous ouverts depuis le début (lot perdu, pair inconnu, vie neuve). */
+	get gapTotal() {
+		return this.#gapTotal;
+	}
+	/**
+	* Compte un message de présence REFUSÉ par le lecteur à liste fermée (forme invalide) — même compteur que les refus de la vue.
+	*/
+	countRejected() {
+		this.#rejectedTotal += 1;
+	}
+	/**
+	* Applique un message du canal des lots, demandes et réponses.
+	*
+	* @param origin - `originId` de l'émetteur, lu dans l'enveloppe.
+	* @param message - message validé par `readPresenceMessage`.
+	* @param now - instant monotone local (ms).
+	* @returns la demande d'état si le message en est une, FRAÎCHE, à servir par
+	*   le répondeur ; `null` sinon.
+	*/
+	receive(origin, message, now) {
+		const pod = this.#podFor(origin, message.incarnation, message.op === "batch" && message.prev === 0, now);
+		if (pod === null) return null;
+		if (message.seq <= pod.messageSeq) {
+			this.#staleTotal += 1;
+			return null;
+		}
+		pod.messageSeq = message.seq;
+		pod.lastSeen = now;
+		if (message.op === "batch") this.#batch(pod, message);
+		else if (message.op === "state") this.#part(pod, message);
+		else return message;
+		return null;
+	}
+	/**
+	* Applique une preuve de vie.
+	*
+	* @param origin - `originId` de l'émetteur.
+	* @param alive - preuve de vie validée par `readPresenceAlive`.
+	* @param now - instant monotone local (ms).
+	*/
+	receiveAlive(origin, alive, now) {
+		const pod = this.#podFor(origin, alive.incarnation, alive.last === 0, now);
+		if (pod === null) return;
+		if (alive.seq <= pod.aliveSeq) {
+			this.#staleTotal += 1;
+			return;
+		}
+		pod.aliveSeq = alive.seq;
+		pod.lastSeen = now;
+		pod.interval = alive.interval;
+		this.#closerAt(now + this.#factor * alive.interval);
+		if (alive.final) {
+			this.#bury(pod, now);
+			return;
+		}
+		const reference = pod.reference;
+		if (reference === null) {
+			if (alive.last === 0) this.#close(pod, 0);
+		} else if (alive.last > reference) this.#openGap(pod);
+	}
+	/**
+	* Pairs à qui demander leur état MAINTENANT — en trou, et pas encore redemandés depuis un intervalle local ; ils sont marqués demandés.
+	*
+	* @param now - instant monotone local (ms).
+	* @param served - canaux à présence servis ici, nommés par la demande ; une
+	*   réponse ne ferme le trou que si elle les couvre tous.
+	* @returns les `originId` à viser (`to`), `null` s'il n'y en a pas.
+	*/
+	takeRequests(now, served) {
+		if (this.#gaps === 0) return null;
+		let out = null;
+		for (const pod of this.#pods.values()) {
+			if (pod.reference !== null || pod.ended) continue;
+			if (now - pod.requestedAt < this.#interval) continue;
+			pod.requestedAt = now;
+			pod.asked = served;
+			(out ??= []).push(pod.origin);
+		}
+		return out;
+	}
+	/**
+	* Oublie les pairs muets depuis `factor` intervalles ANNONCÉS, et retire les pierres tombales échues.
+	*
+	* @param now - instant monotone local (ms).
+	* @returns le nombre de pairs VIVANTS oubliés (hors pierres tombales).
+	*/
+	expire(now) {
+		let forgotten = 0;
+		for (const pod of this.#pods.values()) {
+			if (now - pod.lastSeen < this.#factor * pod.interval) continue;
+			if (!pod.ended) {
+				this.#withdrawPod(pod, now);
+				forgotten += 1;
+			}
+			this.#pods.delete(pod.origin);
+		}
+		this.#forgottenTotal += forgotten;
+		return forgotten;
+	}
+	/**
+	* Plus proche échéance d'oubli APPARUE depuis le dernier appel — celle d'une preuve de vie, dont l'intervalle annoncé peut être plus court que le local ; `Infinity` sinon. O(1), relevée à chaque réception pour que le porteur avance son tic sans attendre le suivant.
+	*
+	* Tout autre message recule l'échéance, et celle d'un pair neuf tombe au
+	* moins deux intervalles LOCAUX plus loin : le tic suivant la relève à temps.
+	* {@link RemotePresence.nextDeadline} reste la valeur exacte, recalculée au tic.
+	*/
+	takeCloserDeadline() {
+		const at = this.#closer;
+		this.#closer = Number.POSITIVE_INFINITY;
+		return at;
+	}
+	/** Prochaine échéance d'oubli (ms monotone), `Infinity` sans pair. */
+	nextDeadline() {
+		let next = Number.POSITIVE_INFINITY;
+		for (const pod of this.#pods.values()) {
+			const deadline = pod.lastSeen + this.#factor * pod.interval;
+			if (deadline < next) next = deadline;
+		}
+		return next;
+	}
+	/**
+	* Réarme le délai d'oubli de TOUS les pairs — après un tic en retard (récepteur gelé) ou au retour de l'écho (bus revenu).
+	*
+	* Sans lui, un pod bloqué 20 s oublierait d'un coup tous les pairs vivants
+	* dont les preuves de vie attendent encore dans son tampon : les minuteurs
+	* passent avant la lecture des sockets (Lifeguard).
+	*
+	* @param now - instant monotone local (ms).
+	*/
+	rearm(now) {
+		for (const pod of this.#pods.values()) pod.lastSeen = now;
+	}
+	/**
+	* Retire un canal de toutes les vues — il n'est plus servi ici (dernier abonné local parti). L'agrégat n'est pas notifié : il disparaît avec le canal.
+	*/
+	dropChannel(channel) {
+		for (const pod of this.#pods.values()) {
+			const channels = pod.channels;
+			if (channels === null) continue;
+			channels.delete(channel);
+			if (channels.size === 0) pod.channels = null;
+		}
+	}
+	/** Oublie tout, sans notifier les agrégats (arrêt, réinitialisation). */
+	clear() {
+		this.#pods.clear();
+		this.#gaps = 0;
+		this.#closer = Number.POSITIVE_INFINITY;
+	}
+	/**
+	* Le pair `origin` dans la vie `incarnation`, créé s'il est inconnu ; `null` si le message est d'une vie plus ancienne ou enterrée (compté).
+	*
+	* @param empty - le message prouve que le pair n'a jamais émis de lot (vue
+	*   vide connue sans demande).
+	*/
+	#podFor(origin, incarnation, empty, now) {
+		let pod = this.#pods.get(origin);
+		if (pod !== void 0) {
+			if (incarnation === pod.incarnation) {
+				if (!pod.ended) return pod;
+				this.#staleTotal += 1;
+				return null;
+			}
+			if (incarnation < pod.incarnation) {
+				this.#staleTotal += 1;
+				return null;
+			}
+			if (!pod.ended) this.#withdrawPod(pod, now);
+			this.#pods.delete(origin);
+		}
+		pod = new RemotePod(origin, incarnation, this.#interval, now);
+		this.#pods.set(origin, pod);
+		if (empty) pod.reference = 0;
+		else this.#enterGap(pod);
+		return pod;
+	}
+	/** Applique un lot : seulement au numéro attendu, sinon trou (le numéro est retenu). */
+	#batch(pod, batch) {
+		const reference = pod.reference;
+		if (reference === null) return;
+		if (classifyNumberedChange(reference, batch.seq, batch.prev) !== "applied") {
+			this.#openGap(pod);
+			return;
+		}
+		pod.reference = batch.seq;
+		let rejected = false;
+		for (const entry of batch.channels) {
+			const aggregate = this.#lookup(entry.channel);
+			if (aggregate === null) continue;
+			if (aggregate === false) {
+				rejected = true;
+				continue;
+			}
+			const channels = pod.channels ??= /* @__PURE__ */ new Map();
+			let table = channels.get(entry.channel);
+			const set = entry.set;
+			if (set !== null && (table?.members.size ?? 0) + set.length / 2 > 1e5) {
+				rejected = true;
+				continue;
+			}
+			if (table === void 0) {
+				table = new RemoteChannel();
+				channels.set(entry.channel, table);
+			}
+			const members = table.members;
+			if (set !== null) for (let i = 0; i < set.length; i += 2) {
+				const key = set[i];
+				const tabs = set[i + 1];
+				if (typeof key !== "string" || typeof tabs !== "number") continue;
+				const delta = tabs - (members.get(key) ?? 0);
+				members.set(key, tabs);
+				if (delta !== 0) aggregate.remoteTabs(key, delta);
+			}
+			const gone = entry.gone;
+			if (gone !== null) for (const key of gone) {
+				const tabs = members.get(key);
+				if (tabs === void 0) continue;
+				members.delete(key);
+				aggregate.remoteTabs(key, -tabs);
+			}
+			const unnamed = entry.unnamed - table.unnamed;
+			if (unnamed !== 0) {
+				table.unnamed = entry.unnamed;
+				aggregate.remoteUnnamed(unnamed);
+			}
+			if (members.size === 0 && table.unnamed === 0) {
+				channels.delete(entry.channel);
+				if (channels.size === 0) pod.channels = null;
+			}
+		}
+		if (rejected) this.#rejectedTotal += 1;
+	}
+	/** Range une part de réponse ; la réponse s'applique d'un bloc à sa dernière part. */
+	#part(pod, part) {
+		let parts = pod.parts;
+		if (part.i === 0) {
+			pod.partSeq = part.seq;
+			pod.partCount = part.n;
+			pod.partLast = part.last;
+			parts = pod.parts = [part.channels];
+		} else {
+			if (parts === null || part.i !== parts.length || part.seq !== pod.partSeq + part.i || part.n !== pod.partCount || part.last !== pod.partLast) {
+				pod.parts = null;
+				return;
+			}
+			parts.push(part.channels);
+		}
+		if (parts.length < pod.partCount) return;
+		pod.parts = null;
+		this.#applyState(pod, parts, pod.partLast);
+	}
+	/** Applique une réponse complète : remplace la vue de chaque canal servi qu'elle nomme, puis ferme le trou si elle couvre la demande. */
+	#applyState(pod, parts, last) {
+		const reference = pod.reference;
+		if (reference !== null && last < reference) return;
+		let pending = null;
+		let rejected = false;
+		for (const entries of parts) for (const entry of entries) {
+			let state = pending?.get(entry.channel);
+			if (state === void 0) {
+				const aggregate = this.#lookup(entry.channel);
+				if (aggregate === null) continue;
+				if (aggregate === false) {
+					rejected = true;
+					continue;
+				}
+				state = {
+					aggregate,
+					table: null,
+					count: 0,
+					unnamed: 0
+				};
+				(pending ??= /* @__PURE__ */ new Map()).set(entry.channel, state);
+			}
+			state.count += entry.members.length >> 1;
+			state.unnamed = entry.unnamed;
+		}
+		if (pending !== null) {
+			const channels = pod.channels ??= /* @__PURE__ */ new Map();
+			for (const [channel, state] of pending) {
+				if (state.count > 1e5) {
+					rejected = true;
+					continue;
+				}
+				let table = channels.get(channel);
+				if (table === void 0) {
+					table = new RemoteChannel();
+					channels.set(channel, table);
+				}
+				state.table = table;
+			}
+			for (const entries of parts) for (const entry of entries) {
+				const state = pending.get(entry.channel);
+				if (state?.table == null) continue;
+				upsertPairs(state.table, entry.members, state.aggregate);
+			}
+			for (const [channel, state] of pending) {
+				const table = state.table;
+				if (table === null) continue;
+				if (table.members.size > state.count) dropAbsentIn(table, channel, parts, state.aggregate);
+				const unnamed = state.unnamed - table.unnamed;
+				if (unnamed !== 0) {
+					table.unnamed = state.unnamed;
+					state.aggregate.remoteUnnamed(unnamed);
+				}
+				if (table.members.size === 0 && table.unnamed === 0) channels.delete(channel);
+			}
+			if (channels.size === 0) pod.channels = null;
+		}
+		if (rejected) this.#rejectedTotal += 1;
+		if (reference === null) {
+			if (covers(pod, parts, last)) this.#close(pod, last);
+		} else if (last > reference) this.#openGap(pod);
+	}
+	#enterGap(pod) {
+		pod.reference = null;
+		pod.requestedAt = Number.NEGATIVE_INFINITY;
+		pod.asked = null;
+		this.#gaps += 1;
+		this.#gapTotal += 1;
+	}
+	#openGap(pod) {
+		if (pod.reference !== null) this.#enterGap(pod);
+	}
+	#close(pod, last) {
+		pod.reference = last;
+		pod.asked = null;
+		pod.covered = null;
+		this.#gaps -= 1;
+	}
+	/** Une échéance d'oubli neuve : retenue si elle précède celles déjà annoncées au porteur. */
+	#closerAt(deadline) {
+		if (deadline < this.#closer) this.#closer = deadline;
+	}
+	/** Retire toutes les contributions d'un pod des agrégats. */
+	#withdrawPod(pod, now) {
+		if (pod.reference === null) this.#gaps -= 1;
+		const channels = pod.channels;
+		pod.channels = null;
+		pod.parts = null;
+		pod.covered = null;
+		if (channels === null) return;
+		for (const [channel, table] of channels) {
+			const aggregate = this.#lookup(channel);
+			if (aggregate !== null && aggregate !== false) withdraw(table, aggregate, now);
+		}
+	}
+	/** Arrêt propre : présents retirés aussitôt, vie enterrée jusqu'au délai d'oubli. */
+	#bury(pod, now) {
+		this.#withdrawPod(pod, now);
+		this.#endedTotal += 1;
+		pod.ended = true;
+		pod.reference = 0;
+	}
+};
+/**
+* Les réponses reçues pendant le trou au même `last` nomment-elles, ENSEMBLE, tous les canaux demandés — servis ou non depuis ? Chemin froid : seulement pendant un trou.
+*
+* Deux réponses au même `last` décrivent l'état du pair au même lot : leurs
+* canaux s'additionnent. Un `last` différent repart de zéro — des lots ont
+* changé l'état entre les deux, et ces lots, ignorés pendant le trou, auraient
+* pu toucher les canaux de la première.
+*/
+function covers(pod, parts, last) {
+	let named = pod.covered;
+	if (named === null || pod.coveredLast !== last) {
+		named = pod.covered = /* @__PURE__ */ new Set();
+		pod.coveredLast = last;
+	}
+	for (const entries of parts) for (const entry of entries) named.add(entry.channel);
+	const asked = pod.asked;
+	if (asked === null) return false;
+	for (const channel of asked) if (!named.has(channel)) return false;
+	return true;
+}
+export { RemotePresence };

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

@@ -20,6 +20,9 @@ const SUBSCRIBED_FRAME_PREFIX = "{\"jsonrpc\":\"2.0\",\"method\":\"realtime:subs
 /**
 * Sérialise la notification `realtime:subscribed { channel }`.
 *
+* Connexion TEXTE seulement : sous codec binaire, l'accusé passe par
+* `peer.notify` (`RealtimeController.ts#RealtimeController.acknowledgeSubscription`).
+*
 * @param channel - le canal acquitté (entrée réseau : échappé par `JSON.stringify`).
 * @returns la trame JSON-RPC 2.0 prête à écrire sur le transport.
 */

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

@@ -248,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/testing/backplaneConformance.js

@@ -1,6 +1,8 @@
 import { RealtimeHub } from "../src/server/RealtimeHub.js";
 import { readControlOrder } from "../src/backplane/controlOrder.js";
-import { PLATFORM_BUS_CHANNELS, PLATFORM_CHANNELS } from "nodefony";
+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
@@ -36,7 +38,10 @@ const BACKPLANE_CONFORMANCE_CASES = {
 	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"
 };
@@ -96,8 +101,9 @@ var Inbox = class {
 * 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,
-* le refus de l'espace réservé à l'entrée du hub, le remplacement du handler et
-* l'arrêt.
+* 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.
@@ -107,6 +113,7 @@ 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;
 	/**
@@ -210,6 +217,37 @@ function runBackplaneConformance(name, makePeer, options) {
 			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();
@@ -241,6 +279,44 @@ function runBackplaneConformance(name, makePeer, options) {
 				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();