nodefony 7.0.2 → 10.0.0-alpha.2

package/dist/client/client/debugbar/format.js

@@ -0,0 +1,103 @@
+//#region src/client/debugbar/format.ts
+/**
+* Helpers de formatage PURS de la debug bar — aucune dépendance DOM/réseau,
+* donc unit-testables côté Node (suite mocha du core).
+*/
+const UNITS = [
+	"B",
+	"KB",
+	"MB",
+	"GB",
+	"TB"
+];
+/**
+* Formatte un nombre d'octets en unité lisible (1 décimale, base 1024).
+*
+* @param bytes - taille en octets (négatif/NaN → "0 B")
+* @returns ex. `"1.5 MB"`, `"0 B"`
+*/
+function formatBytes(bytes) {
+	if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
+	let i = 0;
+	let n = bytes;
+	while (n >= 1024 && i < UNITS.length - 1) {
+		n /= 1024;
+		i++;
+	}
+	return `${i === 0 ? n : n.toFixed(1)} ${UNITS[i]}`;
+}
+/**
+* Formatte une durée (secondes) en chaîne compacte (`1h 02m`, `3m 12s`, `45s`).
+*
+* @param seconds - uptime en secondes
+*/
+function formatUptime(seconds) {
+	if (!Number.isFinite(seconds) || seconds < 0) return "0s";
+	const s = Math.floor(seconds);
+	const h = Math.floor(s / 3600);
+	const m = Math.floor(s % 3600 / 60);
+	const sec = s % 60;
+	if (h > 0) return `${h}h ${String(m).padStart(2, "0")}m`;
+	if (m > 0) return `${m}m ${String(sec).padStart(2, "0")}s`;
+	return `${sec}s`;
+}
+/**
+* Classe une valeur 0-100 en palier vert/orange/rouge.
+*
+* @param percent - valeur de la jauge
+* @param warn - seuil orange (défaut 70)
+* @param crit - seuil rouge (défaut 90)
+*/
+function gauge(percent, warn = 70, crit = 90) {
+	if (!Number.isFinite(percent)) return "ok";
+	if (percent >= crit) return "crit";
+	if (percent >= warn) return "warn";
+	return "ok";
+}
+const ANSI_RE = /\[[0-9;]*m/g;
+/** Retire les séquences d'échappement ANSI (couleurs terminal) d'une chaîne. */
+function stripAnsi(input) {
+	return input.replace(ANSI_RE, "");
+}
+/**
+* Calcule l'attribut `points` d'un `<polyline>` SVG (sparkline) à partir d'une
+* série de valeurs. Pur → testable. Mise à l'échelle sur `[0, max]`.
+*
+* @param values - série temporelle (gauche = ancien, droite = récent)
+* @param width - largeur du viewBox
+* @param height - hauteur du viewBox
+* @param max - plafond de l'axe Y (défaut = max de la série, plancher 1)
+* @returns ex. `"0,14 10,7 20,2"` (vide si < 2 points)
+*/
+function sparklinePoints(values, width, height, max) {
+	const n = values.length;
+	if (n < 2) return "";
+	const top = max ?? Math.max(...values, 1);
+	const ceil = top > 0 ? top : 1;
+	const step = width / (n - 1);
+	let out = "";
+	for (let i = 0; i < n; i++) {
+		const v = Number.isFinite(values[i]) ? values[i] : 0;
+		const ratio = Math.min(1, Math.max(0, v / ceil));
+		const x = Math.round(i * step * 100) / 100;
+		const y = Math.round((height - ratio * height) * 100) / 100;
+		out += i === 0 ? `${x},${y}` : ` ${x},${y}`;
+	}
+	return out;
+}
+/**
+* Heure locale d'un horodatage, à la milliseconde — `14:03:27.482`.
+*
+* La date n'y figure pas : une barre de débogage montre ce qui vient de se
+* passer, et une date répétée sur chaque ligne coûte de la place sans rien
+* apprendre. Le détail d'une entrée, lui, rend l'horodatage complet.
+*/
+function fmtClock(ts) {
+	const d = new Date(ts);
+	const p2 = (n) => n < 10 ? `0${n}` : String(n);
+	const ms = d.getMilliseconds();
+	const p3 = ms < 10 ? `00${ms}` : ms < 100 ? `0${ms}` : String(ms);
+	return `${p2(d.getHours())}:${p2(d.getMinutes())}:${p2(d.getSeconds())}.${p3}`;
+}
+//#endregion
+export { fmtClock, formatBytes, formatUptime, gauge, sparklinePoints, stripAnsi };

package/dist/client/client/debugbar/hmr.js

@@ -0,0 +1,37 @@
+import { PLATFORM_EVENTS } from "../../realtime/platformChannels.js";
+//#region src/client/debugbar/hmr.ts
+/**
+* Observation des hot-updates Vite **sans ouvrir de WebSocket**.
+*
+* Historique : cette sonde ouvrait jadis un **2ᵉ client** WebSocket `vite-hmr`
+* sur le serveur HMR de Vite. Ce client passif (il ne renvoyait jamais le
+* heartbeat attendu) se faisait fermer par Vite, puis se reconnectait en
+* boucle → une cascade de connexions `wss://…:5173` qui s'ouvrent et se ferment
+* sans fin dans la console. C'était aussi un WebSocket de trop (philosophie
+* Nodefony : une seule connexion temps réel côté navigateur).
+*
+* Désormais : aucun socket. On écoute un `CustomEvent` `nodefony:hmr` émis sur
+* `window` par un pont injecté côté page (TemplateHelper, `@nodefony/frontend`),
+* lequel se branche sur le client HMR **déjà chargé** par Vite via
+* `createHotContext` — zéro connexion ajoutée.
+*/
+/** Nom de l'événement DOM émis par le pont HMR côté page. */
+const HMR_EVENT = PLATFORM_EVENTS.hmr;
+/**
+* Observe les hot-updates Vite via l'événement `window` `nodefony:hmr`.
+* Aucune connexion réseau ouverte. No-op hors navigateur.
+*
+* @param onEvent - appelé à chaque hot-update relayé par le pont.
+* @returns dispose() — retire le listener (OBLIGATOIRE au démontage).
+*/
+function observeViteHmr(onEvent) {
+	if (typeof window === "undefined") return () => {};
+	const handler = (ev) => {
+		const detail = ev.detail;
+		if (detail && typeof detail.kind === "string") onEvent(detail);
+	};
+	window.addEventListener(HMR_EVENT, handler);
+	return () => window.removeEventListener(HMR_EVENT, handler);
+}
+//#endregion
+export { HMR_EVENT, observeViteHmr };

package/dist/client/client/debugbar/index.js

@@ -0,0 +1,29 @@
+import { NetworkModel, computeWaterfall, isError, phaseTier } from "./profile.js";
+import { DebugBar } from "./DebugBar.js";
+//#region src/client/debugbar/index.ts
+/**
+* Subpath `nodefony/debugbar` — point d'entrée de la debug bar Nodefony.
+*
+* Entry Rollup SÉPARÉE (tree-shakée, 0 octet si non importée) : ce fichier ne
+* doit JAMAIS être réexporté depuis `client/index.ts` (sinon le barrel `nodefony`
+* navigateur tire toute la barre). Cf décision `project_client_lib_subpaths_decision`.
+*
+* Usage :
+* ```ts
+* import { mountDebugBar } from "nodefony/debugbar";
+* mountDebugBar(); // dev only
+* ```
+*/
+/**
+* Monte la debug bar sur la page courante. Idempotent (un seul widget par page).
+* No-op hors navigateur (SSR). Branche un {@link RealtimeClient} sur le WS
+* realtime et rend l'overlay live.
+*
+* @param opts - URL du WS, client partagé, position, ouverture initiale
+* @returns l'instance {@link DebugBar} (appeler `.unmount()` pour retirer)
+*/
+function mountDebugBar(opts = {}) {
+	return new DebugBar(opts).mount();
+}
+//#endregion
+export { DebugBar, NetworkModel, computeWaterfall, mountDebugBar as default, mountDebugBar, isError as isNetworkError, phaseTier };

package/dist/client/client/debugbar/model.js

@@ -0,0 +1,133 @@
+import Pdu from "../../syslog/Pdu.js";
+import { stripAnsi } from "./format.js";
+//#region src/client/debugbar/model.ts
+/** Sévérité RFC 5424 : ≤ 3 = erreur, 4 = warning. */
+const SEVERITY_ERROR_MAX = 3;
+const SEVERITY_WARNING = 4;
+/** Points conservés dans les séries de sparkline (~1 min à 1 tick/s). */
+const SERIES_POINTS = 60;
+function pushCapped(arr, v, cap) {
+	arr.push(v);
+	if (arr.length > cap) arr.shift();
+}
+function logText(pci) {
+	if (pci == null) return "";
+	if (typeof pci === "string") return stripAnsi(pci);
+	if (typeof pci === "number" || typeof pci === "boolean") return String(pci);
+	try {
+		return stripAnsi(JSON.stringify(pci));
+	} catch {
+		return String(pci);
+	}
+}
+var DebugBarModel = class {
+	_state = "disconnected";
+	_stats = null;
+	_cpuPeak = 0;
+	_heapPeak = 0;
+	_loopPeak = 0;
+	_cpuSeries = [];
+	_heapSeries = [];
+	_loopSeries = [];
+	_logTotal = 0;
+	_errorCount = 0;
+	_warnCount = 0;
+	_dropped = 0;
+	_feed = [];
+	setState(state) {
+		this._state = state;
+	}
+	/** Mémorise le dernier tick stats + alimente les séries/peaks. */
+	ingestStats(payload) {
+		this._stats = payload;
+		const cpu = payload.cpuPercent ?? 0;
+		const loop = payload.eventLoopMs ?? 0;
+		const heapUsed = payload.memory?.heapUsed ?? 0;
+		const heapLimit = payload.memory?.heapLimit ?? 0;
+		const heapPct = heapLimit > 0 ? Math.round(heapUsed / heapLimit * 100) : 0;
+		pushCapped(this._cpuSeries, cpu, SERIES_POINTS);
+		pushCapped(this._heapSeries, heapPct, SERIES_POINTS);
+		pushCapped(this._loopSeries, loop, SERIES_POINTS);
+		if (cpu > this._cpuPeak) this._cpuPeak = cpu;
+		if (heapPct > this._heapPeak) this._heapPeak = heapPct;
+		if (loop > this._loopPeak) this._loopPeak = loop;
+	}
+	/**
+	* Comptabilise un batch de logs coalescés (compteurs cumulés + feed). Chaque
+	* entrée est **réhydratée en {@link Pdu}** — la MÊME classe Core que côté
+	* serveur (severityName/payload canoniques, pas de devinette de champ).
+	*/
+	ingestSyslog(payload) {
+		const logs = payload.logs;
+		if (logs) {
+			for (let i = 0; i < logs.length; i++) {
+				const entry = logs[i];
+				if (typeof entry?.severity !== "number") continue;
+				let pdu;
+				try {
+					pdu = new Pdu(entry.payload, entry.severity, entry.moduleName ?? "nodefony", entry.msgid ?? "", entry.msg ?? "");
+				} catch {
+					continue;
+				}
+				const sev = pdu.severity;
+				this._logTotal++;
+				if (sev <= SEVERITY_ERROR_MAX) this._errorCount++;
+				else if (sev === SEVERITY_WARNING) this._warnCount++;
+				this._feed.push({
+					severity: sev,
+					name: pdu.severityName,
+					text: logText(pdu.payload),
+					module: pdu.moduleName,
+					ts: typeof entry.timeStamp === "number" ? entry.timeStamp : Date.now(),
+					uid: typeof entry.uid === "number" ? entry.uid : 0,
+					msgid: typeof entry.msgid === "string" ? entry.msgid : "",
+					pid: typeof entry.pid === "number" ? entry.pid : 0,
+					requestId: typeof entry.requestId === "string" ? entry.requestId : void 0
+				});
+			}
+			if (this._feed.length > 40) this._feed.splice(0, this._feed.length - 40);
+		}
+		if (typeof payload.dropped === "number") this._dropped += payload.dropped;
+	}
+	get view() {
+		const s = this._stats;
+		const mem = s?.memory;
+		const app = s?.app;
+		const heapUsed = mem?.heapUsed ?? 0;
+		const heapLimit = mem?.heapLimit ?? 0;
+		return {
+			state: this._state,
+			appName: app?.name ?? "",
+			appVersion: app?.version ?? "",
+			env: app?.env ?? "",
+			debug: app?.debug ?? false,
+			branch: app?.branch ?? "",
+			cpuPercent: s?.cpuPercent ?? 0,
+			cpuPeak: this._cpuPeak,
+			cpuCount: s?.cpuCount ?? 0,
+			eventLoopMs: s?.eventLoopMs ?? 0,
+			eventLoopPeak: this._loopPeak,
+			uptime: s?.uptime ?? 0,
+			pid: s?.pid ?? 0,
+			instanceId: s?.instanceId ?? "—",
+			loadavg: s?.loadavg ?? [],
+			rss: mem?.rss ?? 0,
+			heapUsed,
+			heapTotal: mem?.heapTotal ?? 0,
+			heapLimit,
+			external: mem?.external ?? 0,
+			heapPercent: heapLimit > 0 ? Math.round(heapUsed / heapLimit * 100) : 0,
+			heapPeak: this._heapPeak,
+			cpuSeries: this._cpuSeries,
+			heapSeries: this._heapSeries,
+			loopSeries: this._loopSeries,
+			logTotal: this._logTotal,
+			errorCount: this._errorCount,
+			warnCount: this._warnCount,
+			dropped: this._dropped,
+			feed: this._feed
+		};
+	}
+};
+//#endregion
+export { DebugBarModel };

package/dist/client/client/debugbar/network.js

@@ -0,0 +1,173 @@
+//#region src/client/debugbar/network.ts
+/**
+* Intercepteur réseau **dev-only** de la debug bar — capture les appels AJAX
+* (`fetch` + `XMLHttpRequest`) de la page pour le panneau Network, et lit le
+* header `X-Request-Id` de chaque réponse → corrélation avec le profil serveur
+* (`/nodefony/profiler/api/{requestId}`).
+*
+* ⚠️ Monkey-patch des globals = intrusif. Donc 6 garde-fous (cf décision design) :
+*  1. **dev-only** : n'est installé que par la debug bar, jamais en prod.
+*  2. **défensif** : toute la collecte est en try/catch — un bug ici ne casse
+*     JAMAIS la requête de l'app (on relaie toujours l'appel original).
+*  3. **header-only** : on ne touche jamais au body (pas de `.clone()`, pas de
+*     lecture du stream) → 0 risque de consommer/altérer la réponse.
+*  4. **réversible** : `uninstall()` restaure les implémentations d'origine.
+*  5. **chain-safe** : on wrappe le `fetch`/XHR COURANT (déjà potentiellement
+*     patché par une autre lib), on ne clobber pas — l'uninstall ne restaure que
+*     si personne n'a re-patché par-dessus.
+*  6. **opt-out** : `mountDebugBar({ network:false })` n'installe rien.
+*
+* Coût : 2 `performance.now()` + lecture d'1 header + 1 push capé par appel.
+* Négligeable vs la latence réseau.
+*/
+/**
+* En-têtes de corrélation posés par le framework sur chaque réponse :
+*  - `x-request-id` = **clé de lookup** du profiler serveur (concept requestId) ;
+*  - `traceparent`  = W3C Trace Context (RFC-propre), affiché pour la corrélation
+*    distribuée — pas la clé du profiler (qui est keyé par requestId).
+*/
+const REQUEST_ID_HEADER = "x-request-id";
+const TRACEPARENT_HEADER = "traceparent";
+/** Extrait le path d'une URL (absolue ou relative), tolérant. */
+function toPath(url) {
+	try {
+		return new URL(url, location.href).pathname;
+	} catch {
+		return url;
+	}
+}
+/** Normalise l'`input` polymorphe de `fetch` en URL string. */
+function fetchUrl(input) {
+	if (typeof input === "string") return input;
+	if (input && typeof input === "object") {
+		const u = input.url;
+		if (typeof u === "string") return u;
+	}
+	return String(input);
+}
+/**
+* Installe l'intercepteur fetch + XHR. No-op hors navigateur.
+*
+* @returns `uninstall()` — restaure les globals (OBLIGATOIRE à l'unmount).
+*/
+function installNetworkInterceptor(opts) {
+	if (typeof window === "undefined") return () => {};
+	const ignore = opts.ignore ?? (() => false);
+	let seq = 0;
+	const origFetch = window.fetch;
+	const patchedFetch = typeof origFetch === "function" ? function(...args) {
+		let url = "";
+		let method = "GET";
+		try {
+			url = fetchUrl(args[0]);
+			method = (args[1]?.method ?? args[0]?.method ?? "GET").toString().toUpperCase();
+		} catch {}
+		if (!url || ignore(url)) return origFetch.apply(this, args);
+		const entry = {
+			id: ++seq,
+			method,
+			url,
+			path: toPath(url),
+			status: null,
+			ok: false,
+			durationMs: null,
+			startedAt: performance.now(),
+			requestId: null,
+			traceparent: null,
+			pending: true,
+			error: null
+		};
+		safeEmit(opts, entry);
+		return origFetch.apply(this, args).then((res) => {
+			try {
+				entry.status = res.status;
+				entry.ok = res.ok;
+				entry.requestId = res.headers.get(REQUEST_ID_HEADER);
+				entry.traceparent = res.headers.get(TRACEPARENT_HEADER);
+				entry.durationMs = round(performance.now() - entry.startedAt);
+				entry.pending = false;
+				safeEmit(opts, entry);
+			} catch {}
+			return res;
+		}, (err) => {
+			try {
+				entry.error = err instanceof Error ? err.message : "network error";
+				entry.durationMs = round(performance.now() - entry.startedAt);
+				entry.pending = false;
+				safeEmit(opts, entry);
+			} catch {}
+			throw err;
+		});
+	} : null;
+	if (patchedFetch) window.fetch = patchedFetch;
+	const XHR = window.XMLHttpRequest;
+	const origOpen = XHR?.prototype.open;
+	const origSend = XHR?.prototype.send;
+	const state = /* @__PURE__ */ new WeakMap();
+	if (XHR && origOpen && origSend) {
+		XHR.prototype.open = function(method, url, ...rest) {
+			try {
+				const u = url.toString();
+				if (u && !ignore(u)) state.set(this, {
+					id: ++seq,
+					method: (method ?? "GET").toUpperCase(),
+					url: u,
+					path: toPath(u),
+					status: null,
+					ok: false,
+					durationMs: null,
+					startedAt: 0,
+					requestId: null,
+					traceparent: null,
+					pending: true,
+					error: null
+				});
+			} catch {}
+			return origOpen.apply(this, [
+				method,
+				url,
+				...rest
+			]);
+		};
+		XHR.prototype.send = function(...args) {
+			const entry = state.get(this);
+			if (entry) {
+				entry.startedAt = performance.now();
+				safeEmit(opts, entry);
+				const finalize = (error) => {
+					try {
+						entry.status = this.status || null;
+						entry.ok = this.status >= 200 && this.status < 400;
+						entry.requestId = this.getResponseHeader(REQUEST_ID_HEADER) || null;
+						entry.traceparent = this.getResponseHeader(TRACEPARENT_HEADER) || null;
+						entry.durationMs = round(performance.now() - entry.startedAt);
+						entry.error = error;
+						entry.pending = false;
+						safeEmit(opts, entry);
+					} catch {}
+				};
+				this.addEventListener("load", () => finalize(null));
+				this.addEventListener("error", () => finalize("network error"));
+				this.addEventListener("abort", () => finalize("aborted"));
+				this.addEventListener("timeout", () => finalize("timeout"));
+			}
+			return origSend.apply(this, args);
+		};
+	}
+	return () => {
+		if (patchedFetch && window.fetch === patchedFetch) window.fetch = origFetch;
+		if (XHR && origOpen && XHR.prototype.open !== origOpen) XHR.prototype.open = origOpen;
+		if (XHR && origSend && XHR.prototype.send !== origSend) XHR.prototype.send = origSend;
+	};
+}
+function round(ms) {
+	return Math.round(ms * 10) / 10;
+}
+/** Émission protégée — un onChange qui throw ne doit pas casser la requête. */
+function safeEmit(opts, entry) {
+	try {
+		opts.onChange(entry);
+	} catch {}
+}
+//#endregion
+export { installNetworkInterceptor };

package/dist/client/client/debugbar/profile.js

@@ -0,0 +1,114 @@
+//#region src/client/debugbar/profile.ts
+/** Couleur stable par nom de phase canonique. */
+const PHASE_TIER = {
+	parse: "parse",
+	resolve: "resolve",
+	firewall: "firewall",
+	identity: "identity",
+	initialize: "init",
+	action: "action",
+	render: "render",
+	send: "send"
+};
+/** Mappe un nom de phase vers sa classe de couleur (défaut neutre). */
+function phaseTier(name) {
+	return PHASE_TIER[name] ?? "other";
+}
+/** Logs/appels conservés dans le panneau Network. */
+const NET_MAX = 80;
+var NetworkModel = class {
+	_byId = /* @__PURE__ */ new Map();
+	_profiles = /* @__PURE__ */ new Map();
+	_total = 0;
+	_errors = 0;
+	/** Upsert d'une entrée (pending puis résolue partagent le même `id`). */
+	ingest(entry) {
+		if (!this._byId.has(entry.id)) this._total++;
+		const prev = this._byId.get(entry.id);
+		const wasErr = prev ? isError(prev) : false;
+		const isErr = isError(entry);
+		if (isErr && !wasErr) this._errors++;
+		else if (!isErr && wasErr) this._errors--;
+		this._byId.set(entry.id, entry);
+		if (this._byId.size > NET_MAX) {
+			const oldest = this._byId.keys().next().value;
+			if (oldest !== void 0) {
+				const ev = this._byId.get(oldest);
+				if (ev && isError(ev)) this._errors--;
+				this._byId.delete(oldest);
+			}
+		}
+	}
+	/** Entrées récentes (récent → ancien) pour le rendu. */
+	entries() {
+		return [...this._byId.values()].reverse();
+	}
+	get total() {
+		return this._total;
+	}
+	get errors() {
+		return this._errors;
+	}
+	get pending() {
+		let n = 0;
+		for (const e of this._byId.values()) if (e.pending) n++;
+		return n;
+	}
+	profileState(requestId) {
+		return this._profiles.get(requestId);
+	}
+	setProfileState(requestId, state) {
+		this._profiles.set(requestId, state);
+	}
+	clear() {
+		this._byId.clear();
+		this._profiles.clear();
+		this._total = 0;
+		this._errors = 0;
+	}
+};
+/** Vrai si une entrée est en erreur réseau ou status ≥ 400. */
+function isError(e) {
+	if (e.error) return true;
+	return e.status !== null && e.status >= 400;
+}
+/**
+* Calcule le layout proportionnel des phases serveur (waterfall). Pur.
+*
+* Chaque barre est positionnée sur le span `[min start, max end]` en %. Une
+* phase de durée nulle reçoit une largeur plancher (visibilité). Span nul →
+* barres vides (évite la division par zéro).
+*
+* @param phases - phases du profil serveur (startMs relatif + durationMs)
+* @returns barres prêtes à rendre (gauche/largeur en %)
+*/
+function computeWaterfall(phases) {
+	if (phases.length === 0) return [];
+	let min = Infinity;
+	let max = -Infinity;
+	for (const p of phases) {
+		if (p.startMs < min) min = p.startMs;
+		const end = p.startMs + (p.durationMs ?? 0);
+		if (end > max) max = end;
+	}
+	const span = max - min;
+	return phases.map((p) => {
+		const dur = p.durationMs ?? 0;
+		const leftPct = span > 0 ? (p.startMs - min) / span * 100 : 0;
+		const widthRaw = span > 0 ? dur / span * 100 : 0;
+		return {
+			name: p.name,
+			leftPct: clampPct(leftPct),
+			widthPct: clampPct(Math.max(widthRaw, dur > 0 || span === 0 ? 1.5 : .6)),
+			durationMs: Math.round(dur * 100) / 100,
+			tier: phaseTier(p.name)
+		};
+	});
+}
+function clampPct(v) {
+	if (!Number.isFinite(v) || v < 0) return 0;
+	if (v > 100) return 100;
+	return Math.round(v * 100) / 100;
+}
+//#endregion
+export { NetworkModel, computeWaterfall, isError, phaseTier };

package/dist/client/client/index.js

@@ -0,0 +1,34 @@
+import { extend, isArray, isContainer, isEmptyObject, isFunction, isPlainObject, isPromise, isRegExp, isSubclassOf, isUndefined, typeOf } from "../Tools.js";
+import Container from "../Container.js";
+import Pdu, { BROWSER_ORIGIN, SEVERITY_NAMES } from "../syslog/Pdu.js";
+import Syslog from "../syslog/Syslog.js";
+import Service from "../Service.js";
+import { closeCodeToNotice } from "./realtime/notice.js";
+import { JsonRpcPeer, RpcError } from "../realtime/JsonRpcPeer.js";
+import { LOCAL_EVENTS, isLocalEvent } from "./realtime/localEvents.js";
+import { TransportState } from "../realtime/IRealtimeTransport.js";
+import { BrowserWsTransport } from "./realtime/BrowserWsTransport.js";
+import { isRateChannel, parseRate, rateChannel } from "../realtime/channelRate.js";
+import { AdaptiveRate, bindAdaptiveChannel } from "./realtime/AdaptiveRate.js";
+import { NODEFONY_CHANNEL_NAMESPACE, PLATFORM_CHANNELS, PLATFORM_EVENTS, PLATFORM_INBOUND, PLATFORM_METHODS, isPlatformChannel } from "../realtime/platformChannels.js";
+import { RealtimeClient } from "./realtime/RealtimeClient.js";
+import { pduProtocol } from "../syslog/drivers/pduProtocol.js";
+import { FLOW_STEPS, pduFlowStep } from "../syslog/drivers/pduFlow.js";
+import { ClientKernel, createClientKernel } from "./ClientKernel.js";
+import { getCurrentRequestId, getPageId, installRequestIdProvider, resetClientLogContext, withRequestId } from "./syslog/context.js";
+import { UPLINK_MSGID, installSyslogUplink } from "./syslog/uplink.js";
+import { BROWSER_ERROR_MSGID, BROWSER_REJECTION_MSGID, installErrorCapture } from "./syslog/errors.js";
+import { adaptiveRebindKey, connectShared, observeAdaptiveChannel, observeChannel, observeChannelData, observeChannelStats, observeIdentity, observeNoticeLog, observeNotices, observeReconnect, observeSnapshot, observeState, observeSyslog, socketSnapshot } from "./realtime/observe.js";
+//#region src/client/index.ts
+/**
+* Génère un identifiant unique (UUID v4) côté client.
+*
+* Named export plat — remplace l'ancienne façade singleton `Nodefony` du barrel
+* client (supprimée par l'ADR-0007 D4 : named exports only, symétrie avec le
+* barrel node où le singleton exporté a déjà été supprimé).
+*/
+function generateId() {
+	return globalThis.crypto.randomUUID();
+}
+//#endregion
+export { AdaptiveRate, BROWSER_ERROR_MSGID, BROWSER_ORIGIN, BROWSER_REJECTION_MSGID, BrowserWsTransport, ClientKernel, Container, FLOW_STEPS, JsonRpcPeer, LOCAL_EVENTS, NODEFONY_CHANNEL_NAMESPACE, PLATFORM_CHANNELS, PLATFORM_EVENTS, PLATFORM_INBOUND, PLATFORM_METHODS, Pdu, RealtimeClient, RpcError, SEVERITY_NAMES, Service, Syslog, TransportState, UPLINK_MSGID, adaptiveRebindKey, bindAdaptiveChannel, closeCodeToNotice, connectShared, createClientKernel, extend, generateId, getCurrentRequestId, getPageId, installErrorCapture, installRequestIdProvider, installSyslogUplink, isArray, isContainer, isEmptyObject, isFunction, isLocalEvent, isPlainObject, isPlatformChannel, isPromise, isRateChannel, isRegExp, isSubclassOf, isUndefined, observeAdaptiveChannel, observeChannel, observeChannelData, observeChannelStats, observeIdentity, observeNoticeLog, observeNotices, observeReconnect, observeSnapshot, observeState, observeSyslog, parseRate, pduFlowStep, pduProtocol, rateChannel, resetClientLogContext, socketSnapshot, typeOf, withRequestId };