nodefony 7.0.2 → 10.0.0-alpha.2

package/dist/client/client/shim/events.js

@@ -0,0 +1,88 @@
+//#region src/client/shim/events.ts
+var EventEmitter = class {
+	_listeners = /* @__PURE__ */ new Map();
+	_maxListeners = 10;
+	on(event, fn) {
+		const arr = this._listeners.get(event) ?? [];
+		arr.push(fn);
+		this._listeners.set(event, arr);
+		return this;
+	}
+	addListener(event, fn) {
+		return this.on(event, fn);
+	}
+	once(event, fn) {
+		const wrapper = (...args) => {
+			this.off(event, wrapper);
+			fn(...args);
+		};
+		return this.on(event, wrapper);
+	}
+	off(event, fn) {
+		const arr = this._listeners.get(event);
+		if (!arr) return this;
+		const idx = arr.indexOf(fn);
+		if (idx !== -1) arr.splice(idx, 1);
+		if (arr.length === 0) this._listeners.delete(event);
+		return this;
+	}
+	removeListener(event, fn) {
+		return this.off(event, fn);
+	}
+	removeAllListeners(event) {
+		if (event === void 0) this._listeners.clear();
+		else this._listeners.delete(event);
+		return this;
+	}
+	emit(event, ...args) {
+		const arr = this._listeners.get(event);
+		if (!arr || arr.length === 0) return false;
+		for (const fn of arr.slice()) try {
+			fn(...args);
+		} catch (e) {
+			console.error("[EventEmitter] listener threw:", e);
+		}
+		return true;
+	}
+	listenerCount(event) {
+		return this._listeners.get(event)?.length ?? 0;
+	}
+	listeners(event) {
+		return (this._listeners.get(event) ?? []).slice();
+	}
+	eventNames() {
+		return Array.from(this._listeners.keys());
+	}
+	setMaxListeners(n) {
+		this._maxListeners = n;
+		return this;
+	}
+	getMaxListeners() {
+		return this._maxListeners;
+	}
+	/**
+	* Copie des listeners — ce shim ne wrappe pas distinctement les `once`, donc
+	* `rawListeners` ≡ {@link listeners}. Appelé par `Event.emitAsync` (hot path
+	* du bus async `fireAsync`) pour itérer les handlers sans muter la liste.
+	*/
+	rawListeners(event) {
+		return (this._listeners.get(event) ?? []).slice();
+	}
+	/** Comme {@link on} mais inséré en TÊTE de la liste des listeners. */
+	prependListener(event, fn) {
+		const arr = this._listeners.get(event) ?? [];
+		arr.unshift(fn);
+		this._listeners.set(event, arr);
+		return this;
+	}
+	/** Comme {@link once} mais inséré en TÊTE de la liste des listeners. */
+	prependOnceListener(event, fn) {
+		const wrapper = (...args) => {
+			this.off(event, wrapper);
+			fn(...args);
+		};
+		return this.prependListener(event, wrapper);
+	}
+};
+//#endregion
+export { EventEmitter, EventEmitter as default };

package/dist/client/client/shim/util.js

@@ -0,0 +1,20 @@
+//#region src/client/shim/util.ts
+/**
+* Shim browser de `node:util` — fournit `inspect` via JSON.stringify.
+* Suffisant pour la sortie Syslog côté browser (debug/log uniquement).
+*/
+const inspect = (obj, _opts) => {
+	try {
+		return JSON.stringify(obj, null, 2);
+	} catch {
+		return String(obj);
+	}
+};
+/**
+* Shim browser de `util.styleText` — identité (le navigateur n'a pas de TTY
+* ANSI). Consommé par la façade couleur `src/colors.ts` → jamais d'ANSI côté
+* client (parité ancien shim `cli-color` identity Proxy).
+*/
+const styleText = (_format, text, _opts) => String(text);
+//#endregion
+export { inspect, styleText };

package/dist/client/client/svelte/index.js

@@ -0,0 +1,319 @@
+import { isRateChannel, parseRate, rateChannel } from "../../realtime/channelRate.js";
+import { adaptiveRebindKey, connectShared, observeChannel, observeChannelStats, observeIdentity, observeNoticeLog, observeNotices, observeSnapshot, observeState, observeSyslog } from "../realtime/observe.js";
+import { createSubscriber } from "svelte/reactivity";
+//#region src/client/svelte/index.ts
+/**
+* `nodefony/svelte` — liaisons **Svelte 5** du client temps réel isomorphe.
+*
+* Adapte le {@link RealtimeClient} (agnostique : `on()`/`emit()`/`state`) au
+* système d'effets de Svelte, sans glue à recopier dans chaque application. Le
+* pendant exact de `nodefony/react`, `nodefony/vue` et `nodefony/angular` :
+* même surface, mêmes noms, mêmes garanties — seule la traduction change.
+*
+* **Ce fichier ne contient AUCUNE règle temps réel.** Souscrire, tenir un
+* dernier reçu, borner un anneau, décoder le format coalescé du journal, ne
+* jamais couper une socket partagée : tout cela vit dans le socle agnostique
+* `nodefony/client` (`observe*`, `connectShared`), que les quatre liaisons
+* consomment à l'identique. Ici ne reste que la traduction *rappel + libération
+* → réactivité Svelte* — la seule chose qu'une liaison a le droit de contenir.
+*
+* Quatre particularités de Svelte que les trois autres fronts ne montrent pas :
+*
+*  1. **AUCUNE rune n'est publiée ici, et c'est délibéré.** `$state` et
+*     `$effect` sont des constructions du COMPILATEUR : elles n'existent que
+*     dans un fichier `.svelte` ou `.svelte.ts`. Les publier imposerait au
+*     consommateur de compiler notre code — or le plugin Svelte ne compile pas
+*     `node_modules` par défaut : il faudrait une condition d'export `svelte`,
+*     une chaîne `svelte-package`, et le paquet deviendrait sensible aux
+*     versions du compilateur. Pour un front sur quatre. La liaison passe donc
+*     par {@link createSubscriber} (`svelte/reactivity`), l'API publique faite
+*     exactement pour ça : elle intègre un objet ORDINAIRE — écrit en
+*     TypeScript, bâti par le même bundler que les trois autres subpaths — au
+*     système d'effets, sans qu'aucune rune ne vive dans la bibliothèque.
+*  2. **Une valeur se lit `.current`**, jamais par appel : c'est le vocabulaire
+*     de Svelte 5 pour une source réactive externe (`MediaQuery.current`,
+*     `SvelteDate`…). Lu dans un template ou un `$effect`, il suit ; lu ailleurs,
+*     il rend l'instantané courant.
+*  3. **🔴 L'abonnement est PARESSEUX, et c'est le seul écart de comportement
+*     entre les quatre fronts.** React, Vue et Angular s'abonnent au montage ;
+*     ici, l'abonnement n'est pris **qu'au premier `.current` lu dans un effet**,
+*     et il est rendu **quand tous les effets qui le lisaient sont détruits**.
+*     Une valeur créée mais jamais affichée ne s'abonne donc jamais. C'est le
+*     comportement des primitives réactives de Svelte lui-même, et il est
+*     mesuré : un composant qui ne lit rien ne produit aucune trame
+*     `subscribe`. Quand un abonnement doit être pris QUOI QU'IL ARRIVE — une
+*     présence, un effet de bord serveur —, prendre {@link nodefonyChannel}
+*     dans un `$effect` : cette forme-là n'est pas paresseuse.
+*  4. **Un canal qui change ne laisse aucun trou** : le nouvel abonnement est
+*     pris AVANT que l'ancien soit rendu (`+b` puis `-a`), là où les liaisons à
+*     `watch`/`effect` des autres fronts libèrent d'abord. Rien à faire pour
+*     l'obtenir : c'est l'ordre du système d'effets de Svelte.
+*
+* `svelte` est une peerDep **optionnelle** : ce module n'est tiré que si on
+* importe `nodefony/svelte`.
+*
+* @example La page entière, en deux concepts :
+* ```ts
+* // main.ts
+* configureNodefony({ url: "/api/live/realtime" });
+* mount(App, { target: el });
+* ```
+* ```svelte
+* <script lang="ts">
+*   import { nodefonyState, nodefonyChannelData } from "nodefony/svelte";
+*   const etat = nodefonyState();
+*   const last = nodefonyChannelData<LiveEvent>("live:events");
+* <\/script>
+* <p>connexion : {etat.current}</p>
+* {#if last.current}<p>{last.current.text}</p>{/if}
+* ```
+*
+* @module nodefony/svelte
+*/
+/** La socket de la page, posée par {@link configureNodefony}. */
+let pageSocket = null;
+/**
+* Installe la politique temps réel de l'application — à appeler UNE fois, dans
+* le point d'entrée, avant `mount()`.
+*
+* Svelte n'a pas de contexte applicatif comparable à React : `setContext` ne se
+* pose qu'à l'initialisation d'un composant, et ne couvrirait donc pas les
+* liaisons appelées ailleurs. La politique s'écrit ici comme ce qu'elle est en
+* Svelte : une configuration de module.
+*
+* Elle ne coupe aucune connexion : la connexion appartient à la PAGE, pas à un
+* composant, et `disconnect()` tranche les requêtes en vol des autres
+* consommateurs de la même socket partagée.
+*
+* @throws si ni `url` ni `client` n'est fourni — l'adresse dépend de
+*   l'application, et le framework n'en devine aucune (règle du socle : une
+*   adresse devinée marche en développement et se trompe en production).
+*
+* @example
+* ```ts
+* configureNodefony({ url: "/api/live/realtime" });
+* ```
+*/
+function configureNodefony(options) {
+	const connection = connectShared(options);
+	pageSocket = connection.socket;
+	connection.start();
+}
+/**
+* `nodefony()` — la socket brute (canaux, journal, statistiques…). Tête de
+* gondole et échappatoire pour les cas avancés ; pour de l'état réactif, prendre
+* les liaisons dédiées ci-dessous.
+*
+* @throws si {@link configureNodefony} n'a pas été appelé. Le socle REFUSE de
+*   deviner une adresse : retomber ici sur une socket partagée fabriquée à la
+*   volée donnerait une page qui marche en développement et parle au mauvais
+*   hôte en production — mieux vaut une erreur au premier rendu.
+*/
+function nodefony() {
+	if (!pageSocket) throw new Error("nodefony() : configureNodefony() n'a pas été appelé — configureNodefony({ url: \"/api/live/realtime\" }) dans main.ts, avant mount().");
+	return pageSocket;
+}
+/** Lit une source, qu'elle soit constante ou fonction. */
+function read(source) {
+	return typeof source === "function" ? source() : source;
+}
+/**
+* Le motif commun à toutes les valeurs : brancher au premier lecteur, tenir la
+* dernière valeur reçue, libérer quand plus personne ne lit.
+*
+* `createSubscriber` porte tout le cycle : son `start` n'est appelé qu'au
+* premier `.current` lu dans un effet, une seule fois quels que soient le
+* nombre d'effets lecteurs, et la fonction qu'il rend est appelée quand le
+* dernier d'entre eux est détruit. C'est ce qui donne la libération sans une
+* ligne de `onDestroy` — et c'est aussi ce qui rend l'abonnement paresseux.
+*/
+function observedValue(initial, wire) {
+	let value = initial;
+	const subscribe = createSubscriber((update) => wire((v) => {
+		value = v;
+		update();
+	}));
+	return { get current() {
+		subscribe();
+		return value;
+	} };
+}
+/**
+* `nodefonyState()` — l'état de la connexion (`"connected"`, `"reconnecting"`,
+* …), tenu à jour. Branché sur la porte publique `onState`, jamais sur le nom
+* de l'événement local, qui n'a pas à sortir du client.
+*/
+function nodefonyState() {
+	const client = nodefony();
+	return observedValue(client.state, (emit) => observeState(client, emit));
+}
+/**
+* `nodefonyIdentity()` — l'**identité résolue** de la connexion, annoncée par le
+* serveur au `realtime:welcome` (`authenticated`, `roles`, `userIdentifier`,
+* `scopes`). `null` tant qu'aucun welcome n'est arrivé ; une fois reçu, un
+* visiteur anonyme a `authenticated: false`. Brique du gating front :
+* `authenticated: false` → écran de connexion, **sans** appeler `/auth/me`.
+*/
+function nodefonyIdentity() {
+	const client = nodefony();
+	return observedValue(client.identity, (emit) => observeIdentity(client, emit));
+}
+/**
+* `nodefonyChannel()` — s'abonne à un canal pub/sub : `onMessage` est appelé à
+* chaque message. Le socle apparie `subscribe`/`unsubscribe` côté serveur
+* (ref-comptés) et rejoue l'abonnement à chaque reconnexion.
+*
+* **C'est la forme NON paresseuse** : elle rend son propre teardown, ce que
+* `$effect` attend, et l'abonnement est donc pris que la valeur soit affichée
+* ou non.
+*
+* @example
+* ```svelte
+* $effect(() => nodefonyChannel("live:salon", (m) => messages.push(m)));
+* ```
+*/
+function nodefonyChannel(channel, onMessage) {
+	return observeChannel(nodefony(), read(channel), onMessage);
+}
+/**
+* `nodefonyChannelData()` — la **dernière valeur** reçue sur un canal (le cas le
+* plus courant : la dernière mesure d'un flux d'état). `null` tant que rien
+* n'est arrivé.
+*
+* Le canal accepte une fonction : donnée dans un `$derived`, elle fait suivre
+* l'abonnement — et le nouveau canal est pris AVANT que l'ancien soit rendu.
+*/
+function nodefonyChannelData(channel, initial = null) {
+	const client = nodefony();
+	return observedValue(initial, (emit) => observeChannel(client, read(channel), (payload) => emit(payload)));
+}
+/**
+* `nodefonyAdaptiveChannel()` — comme {@link nodefonyChannel}, mais en **cadence
+* adaptative** (AIMD piloté par le client) : la cadence recule sous famine puis
+* remonte quand c'est sain, sans rien changer au serveur.
+*
+* Réservé aux canaux d'ÉTAT (latest-wins) : décimer un canal d'événements perd
+* des messages.
+*
+* Comme {@link nodefonyChannel}, rend son teardown — forme non paresseuse, à
+* donner à `$effect`. La cadence effective est poussée par `onRate` ; pour
+* l'AFFICHER, prendre {@link nodefonyAdaptiveChannelData}, qui la rend réactive.
+*
+* Le ré-abonnement suit {@link adaptiveRebindKey} — la MÊME clé que les trois
+* autres liaisons, pour que les quatre rebranchent aux mêmes instants.
+*/
+function nodefonyAdaptiveChannel(base, onMessage, desiredMs, options = {}) {
+	const { onRate, ...rest } = options;
+	const binding = nodefony().adaptiveChannel(read(base), (...args) => onMessage(args[0]), {
+		...rest,
+		intervalMs: read(desiredMs),
+		enabled: rest.enabled !== false,
+		onRate
+	});
+	return () => binding.dispose();
+}
+/**
+* `nodefonyAdaptiveChannelData()` — comme {@link nodefonyChannelData}, mais en
+* cadence adaptative. Rend la dernière valeur **et** la cadence effective, les
+* deux réactives. Réservé aux canaux d'ÉTAT.
+*
+* La clé de ré-abonnement est {@link adaptiveRebindKey} : lue à chaque
+* branchement, elle fait suivre l'abonnement quand la base, la cadence désirée
+* ou l'activation changent — et pas quand autre chose bouge.
+*/
+function nodefonyAdaptiveChannelData(base, desiredMs, options = {}) {
+	const client = nodefony();
+	const enabled = options.enabled !== false;
+	let setCadence = null;
+	return {
+		data: observedValue(null, (emit) => {
+			adaptiveRebindKey(read(base), read(desiredMs), enabled);
+			const binding = client.adaptiveChannel(read(base), (...args) => emit(args[0]), {
+				...options,
+				intervalMs: read(desiredMs),
+				enabled,
+				onRate: (ms) => setCadence?.(ms)
+			});
+			return () => binding.dispose();
+		}),
+		intervalMs: observedValue(read(desiredMs), (emit) => {
+			setCadence = emit;
+			return () => {
+				setCadence = null;
+			};
+		})
+	};
+}
+/**
+* `nodefonyChannelStats()` — statistiques vivantes d'un canal (débit, série pour
+* un VU-mètre, total). La source est l'échantillonneur du client (1×/s) : aucune
+* horloge n'est posée ici, et aucune trame n'est émise pour mesurer.
+*/
+function nodefonyChannelStats(channel) {
+	const client = nodefony();
+	return observedValue(null, (emit) => observeChannelStats(client, read(channel), emit));
+}
+/**
+* `nodefonySnapshot()` — ce que la socket sait d'ELLE-MÊME : état, canaux tenus,
+* trames reçues, trames perdues, dernière trame. Rafraîchi par
+* l'échantillonneur déjà en place — aucune horloge de plus.
+*
+* La donnée est au socle, la **boîte qui l'affiche** reste à chaque front :
+* publier un composant obligerait à en écrire un par framework de vue, et ferait
+* entrer du DOM dans un module dont toute la valeur est de n'en avoir aucun.
+*/
+function nodefonySnapshot() {
+	const client = nodefony();
+	return observedValue(null, (emit) => observeSnapshot(client, emit));
+}
+/**
+* `nodefonySyslog()` — le flux du journal, prêt à afficher : anneau borné et
+* filtre de sévérité. Le format **coalescé** du canal (`{ logs, dropped }`),
+* l'entrée unique, la taille de l'anneau et le canal par défaut viennent du
+* socle ({@link observeSyslog}) : cette liaison n'en connaît aucun.
+*/
+function nodefonySyslog(options = {}) {
+	const client = nodefony();
+	return observedValue([], (emit) => {
+		const o = read(options);
+		const settings = {
+			max: o.max,
+			severities: o.severities,
+			channel: o.channel
+		};
+		return observeSyslog(client, emit, settings);
+	});
+}
+/**
+* `nodefonyNotifications()` — le flux des **notices normalisées** du client :
+* criticités qui cassent le temps réel (codes de fermeture RFC 6455
+* interprétés), erreurs poussées par le serveur, rétablissement de connexion.
+* `onNotice` est appelé pour CHAQUE notice → brancher un centre de
+* notifications.
+*
+* Forme non paresseuse (elle rend son teardown), à monter **une seule fois**
+* dans le shell de l'application : sans quoi la même notice s'affiche autant de
+* fois qu'il y a d'appels.
+*/
+function nodefonyNotifications(onNotice) {
+	return observeNotices(nodefony(), onNotice);
+}
+/**
+* `nodefonyNoticeLog()` — l'anneau borné des dernières notices, filtrable par
+* source : un historique léger des criticités, distinct des notifications
+* éphémères. La taille de l'anneau et le filtrage viennent du socle
+* ({@link observeNoticeLog}).
+*/
+function nodefonyNoticeLog(options = {}) {
+	const client = nodefony();
+	return observedValue([], (emit) => {
+		const o = read(options);
+		const settings = {
+			max: o.max,
+			sources: o.sources
+		};
+		return observeNoticeLog(client, emit, settings);
+	});
+}
+//#endregion
+export { configureNodefony, isRateChannel, nodefony, nodefonyAdaptiveChannel, nodefonyAdaptiveChannelData, nodefonyChannel, nodefonyChannelData, nodefonyChannelStats, nodefonyIdentity, nodefonyNoticeLog, nodefonyNotifications, nodefonySnapshot, nodefonyState, nodefonySyslog, parseRate, rateChannel };

package/dist/client/client/syslog/context.js

@@ -0,0 +1,122 @@
+import Pdu from "../../syslog/Pdu.js";
+//#region src/client/syslog/context.ts
+/**
+* Identités de corrélation **côté navigateur** — ce que le pod pourra recouper quand
+* il recevra un journal venu d'un onglet.
+*
+* Le navigateur n'a pas d'`AsyncLocalStorage` : une erreur JavaScript ne survient dans
+* aucune bulle de requête. « Le `requestId` de la requête qui l'a précédée » n'existe
+* donc pas — deux `fetch` concurrents suffisent à attribuer l'erreur à la mauvaise, et
+* un journal qui ment sur la corrélation coûte plus cher qu'un journal sans corrélation.
+*
+* D'où deux identités séparées, chacune honnête sur ce qu'elle sait :
+*
+* - {@link getPageId} — **toujours** disponible, généré une fois par chargement de page.
+*   C'est lui qui relie entre elles toutes les lignes d'un même onglet. Sans lui, le pod
+*   reçoit des lignes orphelines qu'aucun écran ne peut regrouper.
+* - {@link withRequestId} — pose un `requestId` **seulement là où il est SU** : dans le
+*   code qui traite une réponse dont on a lu l'en-tête `x-request-id`. Hors de cette
+*   portée, aucun `requestId` n'est attaché. Rien n'est deviné.
+*
+* Coût quand personne ne s'en sert : une variable à `undefined` et un test de référence
+* par `Pdu` (le provider n'est même pas branché tant que {@link installRequestIdProvider}
+* n'a pas été appelé).
+*/
+/**
+* Identifiant de CE chargement de page. Alloué au premier appel seulement — une page
+* qui ne journalise jamais rien ne paie pas l'UUID.
+*/
+let _pageId = null;
+/** Requête dont on traite la réponse, `undefined` hors de {@link withRequestId}. */
+let _currentRequestId;
+/** Restaure le provider d'origine au retrait, ou `null` s'il n'y en avait pas. */
+let _previousProvider = null;
+let _installed = false;
+/**
+* Identifiant stable de ce chargement de page (UUID v4), généré à la demande.
+*
+* Il change à chaque rechargement — c'est voulu : il désigne une **session d'onglet**,
+* pas un utilisateur. Rien d'identifiant personnel ne doit y être mêlé.
+*
+* @returns l'identifiant de page, constant pour la durée du document.
+*/
+function getPageId() {
+	if (_pageId === null) _pageId = globalThis.crypto.randomUUID();
+	return _pageId;
+}
+/**
+* Exécute `fn` en déclarant que ce qu'elle journalise appartient à la requête `requestId`.
+*
+* La portée est le **tick synchrone** de `fn`, et rien de plus : après un `await`, la
+* bulle est refermée. C'est une limite assumée, pas un défaut — le navigateur n'offre
+* aucun moyen de propager un contexte à travers l'asynchrone, et l'alternative (« le
+* dernier `requestId` vu ») fabriquerait de fausses corrélations.
+*
+* @example
+* ```ts
+* const res = await fetch("/api/orders");
+* const rid = res.headers.get("x-request-id") ?? undefined;
+* withRequestId(rid, () => {
+*   syslog.log("commande refusée", "ERROR", "checkout");
+* });
+* ```
+*
+* @param requestId - la requête connue, ou `undefined` pour n'en attacher aucune.
+* @param fn - le travail à exécuter dans cette portée.
+* @returns ce que `fn` renvoie.
+*/
+function withRequestId(requestId, fn) {
+	const previous = _currentRequestId;
+	_currentRequestId = requestId;
+	try {
+		return fn();
+	} finally {
+		_currentRequestId = previous;
+	}
+}
+/**
+* `requestId` de la portée courante, `undefined` en dehors de {@link withRequestId}.
+*
+* @returns l'identifiant de requête su à cet instant, jamais deviné.
+*/
+function getCurrentRequestId() {
+	return _currentRequestId;
+}
+/**
+* Branche {@link getCurrentRequestId} sur `Pdu.requestIdProvider`, de sorte que tout
+* `Pdu` créé dans une portée {@link withRequestId} porte son `requestId` — le même champ
+* que côté serveur, donc la même clé de recoupement, sans qu'aucun appelant ait à le
+* répéter.
+*
+* Idempotent. Le provider d'origine (il n'y en a pas côté navigateur, mais un test peut
+* en poser un) est restauré au retrait.
+*
+* @returns la fonction de retrait — à appeler au démontage.
+*/
+function installRequestIdProvider() {
+	if (_installed) return () => {};
+	_installed = true;
+	_previousProvider = Pdu.requestIdProvider;
+	Pdu.requestIdProvider = getCurrentRequestId;
+	return () => {
+		if (!_installed) return;
+		_installed = false;
+		Pdu.requestIdProvider = _previousProvider;
+		_previousProvider = null;
+	};
+}
+/**
+* Remet le module à son état initial — réservé aux tests, qui doivent pouvoir repartir
+* d'une page « neuve » sans recharger un document.
+*/
+function resetClientLogContext() {
+	_pageId = null;
+	_currentRequestId = void 0;
+	if (_installed) {
+		Pdu.requestIdProvider = _previousProvider;
+		_previousProvider = null;
+		_installed = false;
+	}
+}
+//#endregion
+export { getCurrentRequestId, getPageId, installRequestIdProvider, resetClientLogContext, withRequestId };

package/dist/client/client/syslog/errors.js

@@ -0,0 +1,49 @@
+//#region src/client/syslog/errors.ts
+/** Catégorie par défaut d'une exception non rattrapée. */
+const BROWSER_ERROR_MSGID = "BROWSER_ERROR";
+/** Catégorie d'une promesse rejetée sans `catch`. */
+const BROWSER_REJECTION_MSGID = "BROWSER_REJECTION";
+/**
+* Installe la capture des erreurs globales du navigateur.
+*
+* No-op hors navigateur (rendu serveur, test Node sans DOM) : le contrat isomorphe veut
+* qu'un code client puisse être chargé des deux côtés sans garde chez l'appelant.
+*
+* @param opts - journal cible et bornes.
+* @returns la fonction de retrait — retire les deux écouteurs.
+*/
+function installErrorCapture(opts) {
+	if (typeof window === "undefined") return () => {};
+	const { syslog, msgid = BROWSER_ERROR_MSGID, dedupeMs = 1e3 } = opts;
+	let lastKey = null;
+	let lastAt = 0;
+	/** Vrai si cette erreur répète la précédente dans la fenêtre — donc à taire. */
+	const isRepeat = (key) => {
+		if (dedupeMs <= 0) return false;
+		const now = Date.now();
+		if (key === lastKey && now - lastAt < dedupeMs) return true;
+		lastKey = key;
+		lastAt = now;
+		return false;
+	};
+	const onError = (event) => {
+		const source = event.filename !== void 0 && event.filename !== "" ? `${event.filename}:${event.lineno}:${event.colno}` : void 0;
+		const key = `error|${event.message}|${source ?? ""}`;
+		if (isRepeat(key)) return;
+		syslog.log(event.error ?? event.message, "ERROR", msgid, source ?? "");
+	};
+	const onRejection = (event) => {
+		const reason = event.reason;
+		const key = `rejection|${reason instanceof Error ? reason.message : String(reason)}`;
+		if (isRepeat(key)) return;
+		syslog.log(reason, "ERROR", BROWSER_REJECTION_MSGID, "");
+	};
+	window.addEventListener("error", onError);
+	window.addEventListener("unhandledrejection", onRejection);
+	return () => {
+		window.removeEventListener("error", onError);
+		window.removeEventListener("unhandledrejection", onRejection);
+	};
+}
+//#endregion
+export { BROWSER_ERROR_MSGID, BROWSER_REJECTION_MSGID, installErrorCapture };