@nodefony/realtime 10.0.0-beta.5 → 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,10 +20,22 @@ 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.
 */
 function subscribedAckFrame(channel) {
 	return SUBSCRIBED_FRAME_PREFIX + JSON.stringify(channel) + "}}";
 }
-export { subscribedAckFrame };
+/**
+* Sérialise `realtime:subscribed { channel, imposed: true }` — l'acquittement d'un abonnement imposé par le serveur.
+*
+* @param channel - le canal imposé (échappé par `JSON.stringify`).
+* @returns la trame JSON-RPC 2.0 prête à écrire sur le transport.
+*/
+function imposedSubscribedAckFrame(channel) {
+	return SUBSCRIBED_FRAME_PREFIX + JSON.stringify(channel) + ",\"imposed\":true}}";
+}
+export { imposedSubscribedAckFrame, subscribedAckFrame };

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

@@ -75,11 +75,10 @@ function createSyslogUplinkHandler(opts) {
 	let windowStart = 0;
 	let windowCount = 0;
 	return function onSyslogUplink(params) {
-		if (params === null || typeof params !== "object") return;
-		const batch = params;
-		const entries = batch.entries;
+		if (!isRecord(params)) return;
+		const entries = params.entries;
 		if (!Array.isArray(entries) || entries.length === 0) return;
-		const pageId = safeRequestId(batch.pageId, maxRequestIdLength);
+		const pageId = safeRequestId(params.pageId, maxRequestIdLength);
 		if (pageId === void 0) return;
 		const now = Date.now();
 		if (now - windowStart > windowMs) {

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

@@ -0,0 +1,37 @@
+// nodefony/src/server/welcomeIdentity.ts
+/**
+* Vue PUBLIQUE de l'identité d'une connexion, annoncée au client par `realtime:welcome` — tirée de l'identité d'admission quand le jeton en produit une.
+*
+* Un objet NEUF, champ par champ, et jamais l'identité d'admission elle-même :
+* celle-ci porte `issuer` et `account`, qui restent au serveur — la sérialiser
+* telle quelle les enverrait au client (ADR-0021 §S10 point 1). Les tableaux
+* de rôles et de scopes, eux, sont repris par RÉFÉRENCE : gelés une fois à la
+* construction de l'identité, ils ne se recopient pas.
+*
+* Un jeton sans `getIdentity` (authentificateur tiers) annonce `id: null` : son
+* identifiant stable n'est pas connu, et le déduire du login serait le défaut
+* même que `id` corrige.
+*
+* @param token - jeton figé à la poignée de main.
+* @returns l'identité à placer dans le `welcome`.
+*/
+function welcomeIdentityOf(token) {
+	const who = token.getIdentity?.();
+	if (who !== void 0) return {
+		type: who.type,
+		authenticated: who.authenticated,
+		id: who.id,
+		userIdentifier: who.userIdentifier,
+		roles: who.roles,
+		scopes: who.scopes
+	};
+	return {
+		type: token.type,
+		authenticated: token.isAuthenticated(),
+		id: null,
+		userIdentifier: token.getUserIdentifier(),
+		roles: token.getRoles(),
+		scopes: token.getScopes()
+	};
+}
+export { welcomeIdentityOf };