nodefony 7.0.2 → 10.0.0-alpha.2

package/dist/node/service/dev/devStop.js

@@ -0,0 +1,263 @@
+import { clearRuntimeState, clearSupervisorPidFile, defaultDevPorts, detectRuntimeMode, discoverDevProcessesDetailed, discoverFromRuntimeState, foreignPortOwners, formatForeignRuntimes, isNodefonyProjectDir, portOwnership, probePorts, processCwd, readRuntimeState, splitByProject, terminateDevProcesses } from "./devProcess.js";
+import { buildProjectTable, formatProjectTable, resolveProjectTarget } from "./devProjects.js";
+import { writeSync } from "node:fs";
+import path from "node:path";
+//#region src/service/dev/devStop.ts
+/**
+* Commande `nodefony stop` — arrêt PROPRE et COMPLET de tout runtime Nodefony (dev,
+* production mono, cluster) **du PROJET courant** ; remplace le `pkill -9` manuel.
+* Standalone : aucun boot kernel, aucune trunk requise → lançable de n'importe où
+* (cf le fast-path de `CliKernel.start`).
+*
+* MULTI-PROJET : plusieurs apps Nodefony peuvent tourner sur le même poste — le
+* balayage `ps` étant global, `stop` ne tue QUE les process dont le cwd est CE
+* projet (`splitByProject`) ; les autres sont LISTÉS avec leur dossier (le dev
+* sait où aller les arrêter). `--all` = comportement trans-projets explicite.
+*
+* Stratégie : vérité = `ps` (pas le seul pidfile). On tue les GROUPES « racines » (un
+* process dont le parent n'est pas dans la liste) — group-kill du superviseur/master
+* emporte déjà ses enfants (serveur + Vite, ou workers) ; un orphelin (pidfile périmé)
+* est sa propre racine et tombe aussi. SIGTERM (arrêt gracieux — déclenche le graceful
+* shutdown du ClusterManager pour un master) puis SIGKILL des récalcitrants un à un.
+*/
+/** Libellé du mode runtime pour les messages (`dev`/`production`/`cluster`). */
+function runtimeLabel(mode) {
+	if (mode === "prod") return "production";
+	if (mode === "cluster") return "cluster";
+	if (mode === "dev") return "dev";
+	return "runtime";
+}
+const ANSI = {
+	dim: "\x1B[90m",
+	green: "\x1B[32m",
+	red: "\x1B[31m",
+	yellow: "\x1B[33m",
+	bold: "\x1B[1m",
+	reset: "\x1B[0m"
+};
+/** Délai d'arrêt gracieux (SIGTERM) avant d'escalader en SIGKILL. */
+const TERM_WAIT_MS = 4e3;
+/** Délai max d'attente de libération des ports après le kill. */
+const PORTS_WAIT_MS = 4e3;
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/** Attend que tous les `ports` soient libres (poll), renvoie le dernier état sondé. */
+async function waitPortsFree(ports, timeoutMs, probe = probePorts) {
+	const deadline = Date.now() + timeoutMs;
+	for (;;) {
+		const states = await probe(ports);
+		if (states.every((s) => !s.listening)) return states;
+		if (Date.now() >= deadline) return states;
+		await delay(150);
+	}
+}
+/**
+* Ligne d'état des ports après (ou faute d') arrêt.
+*
+* `✗ encore occupé` est un VERDICT D'ÉCHEC : il dit « je n'ai pas réussi à libérer
+* ce port ». Il ne doit donc jamais tomber sur un port qui n'est pas le nôtre —
+* `stop` venait d'annoncer lui-même que ces runtimes appartenaient à un AUTRE projet,
+* puis marquait leurs ports en rouge : deux phrases qui se contredisent dans le même
+* rapport. Un propriétaire identifié ({@link foreignPortOwners}) est donc NOMMÉ, et
+* un port occupé sans propriétaire connu reste un échec quand on a tué quelque chose.
+*
+* @param states - ports sondés.
+* @param freeLabel - libellé (déjà coloré) d'un port que personne ne tient.
+* @param occupiedLabel - libellé d'un port tenu par un propriétaire INCONNU. C'est
+*   l'appelant qui sait s'il s'agit d'un échec : après avoir tué nos process, oui ;
+*   avant d'avoir tué quoi que ce soit, non.
+* @param owners - port → projet étranger qui le tient.
+*/
+const portsLine = (states, freeLabel, occupiedLabel, owners = {}) => states.map((p) => {
+	switch (portOwnership(p, owners)) {
+		case "free": return `${p.port} ${freeLabel}`;
+		case "foreign": return `${p.port} ${ANSI.yellow}occupé par ${owners[p.port]}${ANSI.reset}`;
+		default: return `${p.port} ${occupiedLabel}`;
+	}
+}).join("   ");
+/**
+* Filtre de `--all` : sans projet de référence, la SEULE preuve restante serait le
+* titre de process. C'est peu pour un `kill -9` trans-projets — un homonyme
+* suffirait. On exige donc une SECONDE preuve, indépendante du nom : le process
+* travaille bien dans un projet Nodefony (`package.json` qui dépend de `nodefony`,
+* ou `node_modules/nodefony`), lui-même ou un ancêtre (un Vite tourne dans le
+* SOUS-dossier de son bundle). Un cwd illisible — process d'un autre utilisateur,
+* `lsof` muet — ne prouve rien : on n'y touche pas.
+*
+* PURE (dépendances injectables) : `--all` tue sans garde-fou de projet, il ne
+* doit pas rester une branche non éprouvée.
+*
+* @param procs - runtimes découverts par `ps`.
+* @param getCwd - lecture du cwd d'un pid (défaut : `processCwd`).
+* @param isProject - test « ce dossier est un projet Nodefony » (défaut : `isNodefonyProjectDir`).
+* @returns `kept` = appartenance PROUVÉE (tuables) ; `rejected` = épargnés + le motif.
+*/
+function scopeAllToNodefonyProjects(procs, getCwd = processCwd, isProject = isNodefonyProjectDir) {
+	const kept = [];
+	const rejected = [];
+	for (const p of procs) {
+		const cwd = getCwd(p.pid);
+		if (cwd === null) {
+			rejected.push({
+				proc: p,
+				why: "cwd illisible"
+			});
+			continue;
+		}
+		let cur = path.resolve(cwd);
+		let belongs = false;
+		for (;;) {
+			if (isProject(cur)) {
+				belongs = true;
+				break;
+			}
+			const parent = path.dirname(cur);
+			if (parent === cur) break;
+			cur = parent;
+		}
+		if (belongs) kept.push(p);
+		else rejected.push({
+			proc: p,
+			why: `${cwd} n'est pas un projet Nodefony`
+		});
+	}
+	return {
+		kept,
+		rejected
+	};
+}
+/**
+* Racines des projets auxquels appartiennent `procs` — dédupliquées.
+*
+* Sert à `--all` pour savoir QUELS ports vérifier après un arrêt trans-projets :
+* un port qu'on ne sonde pas ne peut ni confirmer ni infirmer l'arrêt, et le
+* rapport concluait « ✓ arrêté proprement » sans avoir regardé les trois quarts
+* des ports qu'il venait de libérer.
+*
+* Fonction PURE (lecture du cwd injectable). Les rôles Vite sont ignorés : ils
+* travaillent parfois dans un sous-dossier, et leur parent porte déjà la racine.
+*
+* @param procs - runtimes sur le point d'être arrêtés.
+* @param getCwd - lecture du répertoire courant d'un pid.
+* @returns les racines distinctes, sans celles qu'on n'a pas pu lire.
+*/
+function hostProjects(procs, getCwd = processCwd) {
+	const roots = /* @__PURE__ */ new Set();
+	for (const p of procs) {
+		if (p.role === "vite") continue;
+		const cwd = getCwd(p.pid);
+		if (cwd) roots.add(path.resolve(cwd));
+	}
+	return [...roots];
+}
+/** Applique {@link scopeAllToNodefonyProjects} et ANNONCE les process épargnés. */
+function allRuntimesOfThisPoste(procs, write) {
+	const { kept, rejected } = scopeAllToNodefonyProjects(procs);
+	if (rejected.length > 0) write(`${ANSI.dim}[stop]${ANSI.reset} ${rejected.length} process au titre Nodefony NON confirmé(s), épargné(s) :\n` + rejected.map((r) => `  pid ${r.proc.pid} (${r.proc.label}) — ${r.why}`).join("\n") + "\n");
+	return kept;
+}
+/**
+* Découvre, tue (SIGTERM→SIGKILL) et nettoie ; écrit un rapport sur stdout.
+*
+* `opts.target` désigne un AUTRE projet par son nom ou son chemin — strictement
+* l'équivalent de `cd <projet> && nodefony stop`, obtenu en substituant la racine
+* visée au répertoire courant : une seule mécanique d'arrêt, jamais deux.
+*
+* @returns le code de sortie — `0` si l'arrêt a eu lieu (ou n'avait rien à faire),
+*   `1` si la cible n'a pas pu être DÉSIGNÉE sans ambiguïté. Un `stop` qui n'a rien
+*   arrêté parce qu'il n'a pas compris la cible ne doit pas se lire comme un succès
+*   dans un script.
+*/
+async function runStopReport(cwd, opts = {}) {
+	const tag = `${ANSI.dim}[stop]${ANSI.reset}`;
+	const write = opts.write ?? ((chunk) => writeSync(1, chunk));
+	const probe = opts.probe ?? probePorts;
+	const observed = (opts.discover ?? discoverDevProcessesDetailed)({});
+	const discovered = observed.procs;
+	let root = cwd;
+	if (opts.target !== void 0 && opts.target !== "") {
+		if (opts.all) {
+			write(`\n${tag} ${ANSI.yellow}\`--all\` et une cible sont contradictoires${ANSI.reset} — choisis l'un ou l'autre.\n\n`);
+			return 1;
+		}
+		const here = splitByProject(discovered, cwd, opts.getCwd);
+		const projects = buildProjectTable(cwd, here.mine, here.foreign, (await probe(defaultDevPorts(cwd))).filter((p) => p.listening).map((p) => p.port));
+		if (projects.length === 0 && discovered.length > 0 && here.foreign.every((p) => p.cwd === null)) {
+			write([
+				"",
+				`${tag} ${ANSI.yellow}impossible de rattacher les process à un projet ici${ANSI.reset}`,
+				`  ${ANSI.dim}${discovered.length} runtime(s) Nodefony tournent, mais leur répertoire de travail${ANSI.reset}`,
+				`  ${ANSI.dim}n'est pas lisible (\`lsof\` absent ? Windows ?) — une cible par NOM est${ANSI.reset}`,
+				`  ${ANSI.dim}donc indécidable, et rien ne sera arrêté au hasard.${ANSI.reset}`,
+				`  ${ANSI.dim}→ ${ANSI.reset}${ANSI.bold}cd <projet> && nodefony stop${ANSI.reset}${ANSI.dim}, ou ${ANSI.reset}${ANSI.bold}nodefony stop --all${ANSI.reset}`,
+				""
+			].join("\n") + "\n");
+			return 1;
+		}
+		const resolved = resolveProjectTarget(opts.target, projects);
+		if (!resolved.ok) {
+			write([
+				"",
+				resolved.reason === "inconnu" ? `${tag} ${ANSI.yellow}aucun projet Nodefony en cours ne s'appelle « ${opts.target} »${ANSI.reset}` : `${tag} ${ANSI.yellow}« ${opts.target} » désigne ${resolved.candidates.length} projets — donne le chemin complet${ANSI.reset}`,
+				...resolved.candidates.length > 0 ? formatProjectTable(resolved.candidates) : [`  ${ANSI.dim}(aucun runtime Nodefony observé sur ce poste)${ANSI.reset}`],
+				""
+			].join("\n") + "\n");
+			return 1;
+		}
+		root = resolved.project.root;
+		write(`${tag} cible : ${ANSI.bold}${resolved.project.name}${ANSI.reset} ${ANSI.dim}(${root})${ANSI.reset}\n`);
+	}
+	cwd = root;
+	const scoped = opts.all ? {
+		mine: allRuntimesOfThisPoste(discovered, write),
+		foreign: []
+	} : splitByProject(discovered, cwd, opts.getCwd);
+	const byState = observed.supported ? [] : discoverFromRuntimeState(cwd);
+	if (byState.length > 0) write(`${tag} observation des process indisponible ici — runtime retrouvé par son fichier d'état (pid ${byState[0].pid}).\n`);
+	const before = scoped.mine.length > 0 ? scoped.mine : byState;
+	if (scoped.foreign.length > 0) write(`${tag} ${scoped.foreign.length} runtime(s) d'un AUTRE projet non touché(s) :\n` + formatForeignRuntimes(scoped.foreign).join("\n") + "\n");
+	const owners = foreignPortOwners(scoped.foreign);
+	if (before.length === 0) {
+		clearSupervisorPidFile(cwd);
+		const ports = await probe(defaultDevPorts(cwd));
+		const occupied = ports.filter((p) => p.listening).map((p) => p.port);
+		const blind = !observed.supported && occupied.length > 0;
+		write([
+			"",
+			blind ? `${tag} ${ANSI.bold}Nodefony — process non observables ici, mais ${occupied.join(", ")} répond(ent) encore${ANSI.reset}` : `${tag} ${ANSI.bold}Nodefony — aucune instance de ce projet en cours (déjà arrêté)${ANSI.reset}`,
+			`  ${ANSI.dim}ports${ANSI.reset} : ${portsLine(ports, `${ANSI.green}libre${ANSI.reset}`, blind ? `${ANSI.yellow}occupé — un runtime répond encore${ANSI.reset}` : `${ANSI.yellow}occupé (pas par ce projet)${ANSI.reset}`, owners)}`,
+			...blind ? [`  ${ANSI.dim}un runtime tourne sans fichier d'état — l'arrêter par son PID (Get-Process node)${ANSI.reset}`] : [],
+			""
+		].join("\n") + "\n");
+		return 0;
+	}
+	const ourPorts = opts.all ? [.../* @__PURE__ */ new Set([...defaultDevPorts(cwd), ...hostProjects(before, opts.getCwd).flatMap((projectRoot) => readRuntimeState(projectRoot, { purgeStale: false })?.ports ?? [])])] : defaultDevPorts(cwd);
+	const mode = runtimeLabel(detectRuntimeMode(before));
+	const count = (role) => before.filter((p) => p.role === role).length;
+	const seg = [];
+	for (const [role, word] of [
+		["supervisor", "superviseur"],
+		["master", "master"],
+		["worker", "worker"],
+		["server", "serveur"],
+		["vite", "Vite"]
+	]) {
+		const n = count(role);
+		if (n) seg.push(`${n} ${word}`);
+	}
+	write(`\n${tag} ${ANSI.bold}arrêt de ${before.length} process ${mode}${ANSI.reset} (${seg.join(" · ")})…\n`);
+	const alive = await terminateDevProcesses(before, {
+		termWaitMs: TERM_WAIT_MS,
+		killWaitMs: 1500
+	});
+	clearSupervisorPidFile(cwd);
+	clearRuntimeState(cwd);
+	const ports = await waitPortsFree(ourPorts, PORTS_WAIT_MS, probe);
+	write([
+		`  ${alive.length === 0 ? `${ANSI.green}✓ arrêté proprement${ANSI.reset}` : `${ANSI.red}⚠ ${alive.length} process survivent (pid ${alive.join(", ")}) — relance \`nodefony stop\`${ANSI.reset}`}`,
+		`  ${ANSI.dim}ports${ANSI.reset} : ${portsLine(ports, `${ANSI.green}libéré${ANSI.reset}`, `${ANSI.red}✗ encore occupé${ANSI.reset}`, owners)}`,
+		""
+	].join("\n") + "\n");
+	return 0;
+}
+//#endregion
+export { hostProjects, runStopReport, scopeAllToNodefonyProjects };

package/dist/node/service/fetchService.js

@@ -0,0 +1,35 @@
+import Service from "../Service.js";
+//#region src/service/fetchService.ts
+/**
+* Service `Fetch` — façade DI au-dessus de l'API `fetch` **native** de Node.js.
+*
+* Depuis Node 21, `fetch`, `Response`, `Request` et `Headers` sont des globaux
+* stables (implémentation undici intégrée). Ce service les expose via le
+* conteneur d'injection (`@inject("Fetch")`) — la dépendance `node-fetch` n'est
+* donc plus nécessaire (un appel réseau de moins à bundler, perfs undici natives).
+*
+* `fetch` est lié à `globalThis` pour éviter le `TypeError: Illegal invocation`
+* quand il est appelé via `this.fetch(...)` (undici exige `globalThis` comme `this`).
+*
+* Posé au container par l'{@link Injector} à la construction du kernel : une
+* instance par kernel, partagée par tous ses consommateurs.
+*/
+var Fetch = class extends Service {
+	fetch;
+	Response;
+	Request;
+	Headers;
+	/**
+	* @param owner - porteur du service : le kernel (service core) ou un module.
+	*   Seul son `container` est utilisé — c'est ce dont un `Service` a besoin pour exister.
+	*/
+	constructor(owner) {
+		super("Fetch", owner.container);
+		this.fetch = globalThis.fetch.bind(globalThis);
+		this.Response = globalThis.Response;
+		this.Request = globalThis.Request;
+		this.Headers = globalThis.Headers;
+	}
+};
+//#endregion
+export { Fetch as default };

package/dist/node/service/gitService.js

@@ -0,0 +1,62 @@
+import fs from "node:fs";
+import path from "node:path";
+//#region src/service/gitService.ts
+let _cache;
+/** Branche depuis `.git/HEAD` (`ref: refs/heads/X` → `X`, sinon sha court). */
+function readBranch(gitDir) {
+	try {
+		const head = fs.readFileSync(path.join(gitDir, "HEAD"), "utf8").trim();
+		const m = head.match(/^ref:\s*refs\/heads\/(.+)$/);
+		return m ? m[1] : head.slice(0, 7);
+	} catch {
+		return "";
+	}
+}
+/** Commit HEAD court : suit `HEAD` → ref file, repli `packed-refs`. */
+function readCommit(gitDir) {
+	try {
+		const head = fs.readFileSync(path.join(gitDir, "HEAD"), "utf8").trim();
+		const m = head.match(/^ref:\s*(.+)$/);
+		if (!m) return head.slice(0, 7);
+		const ref = m[1];
+		let sha = "";
+		try {
+			sha = fs.readFileSync(path.join(gitDir, ref), "utf8").trim();
+		} catch {
+			const line = fs.readFileSync(path.join(gitDir, "packed-refs"), "utf8").split("\n").find((l) => l.endsWith(` ${ref}`));
+			sha = line ? line.split(" ")[0] : "";
+		}
+		return sha.slice(0, 7);
+	} catch {
+		return "";
+	}
+}
+/**
+* Introspection git du dépôt — **sans spawn `git` ni dépendance** (lecture directe
+* de `.git/`). Résultat caché pour la vie du process. Best-effort : champs `""`
+* hors d'un dépôt (ex. container sans `.git`). Consommé par le data plane kernel
+* (`/nodefony/kernel/api/info` → `git`) et la barre de debug (bloc `app`).
+*/
+var GitService = class GitService {
+	/**
+	* Lit branche + commit court (une fois, puis cache process).
+	*
+	* @param cwd - racine où chercher `.git` (défaut `process.cwd()`)
+	* @returns `{ branch, commit }` — champs `""` si indéterminés
+	*/
+	static read(cwd = process.cwd()) {
+		if (_cache) return _cache;
+		const gitDir = path.join(cwd, ".git");
+		_cache = {
+			branch: readBranch(gitDir),
+			commit: readCommit(gitDir)
+		};
+		return _cache;
+	}
+	/** Branche seule (raccourci). */
+	static branch(cwd) {
+		return GitService.read(cwd).branch;
+	}
+};
+//#endregion
+export { GitService as default };

package/dist/node/syslog/Pdu.js

@@ -0,0 +1,224 @@
+//#region src/syslog/Pdu.ts
+var SysLogSeverity = /* @__PURE__ */ function(SysLogSeverity) {
+	SysLogSeverity[SysLogSeverity["EMERGENCY"] = 0] = "EMERGENCY";
+	SysLogSeverity[SysLogSeverity["ALERT"] = 1] = "ALERT";
+	SysLogSeverity[SysLogSeverity["CRITIC"] = 2] = "CRITIC";
+	SysLogSeverity[SysLogSeverity["ERROR"] = 3] = "ERROR";
+	SysLogSeverity[SysLogSeverity["WARNING"] = 4] = "WARNING";
+	SysLogSeverity[SysLogSeverity["NOTICE"] = 5] = "NOTICE";
+	SysLogSeverity[SysLogSeverity["INFO"] = 6] = "INFO";
+	SysLogSeverity[SysLogSeverity["DEBUG"] = 7] = "DEBUG";
+	return SysLogSeverity;
+}(SysLogSeverity || {});
+const sysLogSeverity = [
+	0,
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7
+];
+/**
+* Les noms de sévérité RFC 5424, **dans l'ordre de l'enum** (l'index EST la
+* valeur : `SEVERITY_NAMES[3] === "ERROR"`). Les huit niveaux de la RFC, et
+* rien d'autre : une animation de terminal n'est pas un niveau de journal.
+*
+* Source **unique** du vocabulaire, côté serveur comme côté navigateur (le
+* bundle client la réexporte). Elle existe parce qu'elle était écrite trois
+* fois — deux copies dans la console d'administration, dans deux ORDRES
+* différents, et aucune côté data plane, si bien qu'un `?severity=CRITICAL`
+* n'était refusé nulle part : il rendait le journal entier.
+*
+* Pour un sélecteur qui va du moins au plus grave, lire `[...SEVERITY_NAMES]
+* .reverse()` — l'ordre d'affichage se dérive, il ne se redéclare pas.
+*/
+const SEVERITY_NAMES = [
+	"EMERGENCY",
+	"ALERT",
+	"CRITIC",
+	"ERROR",
+	"WARNING",
+	"NOTICE",
+	"INFO",
+	"DEBUG"
+];
+/**
+* `moduleName` porté par une entrée de journal venue d'un NAVIGATEUR.
+*
+* Valeur de confiance : le pod l'impose lui-même en recevant un lot sur le canal
+* montant, sans jamais reprendre ce que la page prétend être. Une ligne qui la porte
+* a donc traversé ce canal, et rien d'autre ne peut la produire.
+*
+* Elle vit ICI, dans le cœur isomorphe, pour la même raison que
+* {@link SEVERITY_NAMES} : le serveur l'écrit, le navigateur la lit pour distinguer
+* ces lignes à l'écran. Une copie côté console d'administration dériverait le jour
+* où le mot change — et un écran qui ne reconnaît plus l'origine ne se plaint pas,
+* il affiche simplement une ligne de plus au milieu des autres.
+*/
+const BROWSER_ORIGIN = "browser";
+const translateSeverity = function(severity = "INFO") {
+	if (typeof severity === "number") {
+		if (sysLogSeverity[severity] !== void 0) return sysLogSeverity[severity];
+		else throw new Error(`Not a valid nodefony syslog severity: ${severity}`);
+	} else if (SysLogSeverity[severity] !== void 0) return SysLogSeverity[severity];
+	else throw new Error(`Not a valid nodefony syslog severity: ${severity}`);
+};
+const sysLogSeverityObj = Object.entries(SysLogSeverity).reduce((acc, [key, value]) => {
+	acc[key] = value;
+	return acc;
+}, {});
+const severityNameMap = new Map(Object.entries(SysLogSeverity).filter(([, v]) => typeof v === "number").map(([k, v]) => [v, k]));
+const _gBuffer = globalThis.Buffer;
+const PID = globalThis.process?.pid ?? 0;
+const fastTypeOf = (value) => {
+	if (value === null) return null;
+	const t = typeof value;
+	if (t !== "object") return t;
+	if (Array.isArray(value)) return "array";
+	if (value instanceof Date) return "date";
+	if (value instanceof RegExp) return "RegExp";
+	if (value instanceof Error) return "Error";
+	if (_gBuffer?.isBuffer(value)) return "buffer";
+	return "object";
+};
+/**
+* Process Data Unit — entrée de log unitaire conforme RFC 5424.
+*
+* Une instance représente un événement de log dans le pipeline Syslog.
+* Stockée dans le `CircularBuffer` (O(1)) et diffusée aux transports
+* via l'event `onLog` du {@link Syslog}.
+*
+* @example
+* ```ts
+* const pdu = new Pdu("user logged in", "INFO", "AUTH", "USER_LOGIN", "user@example.com");
+* pdu.severity;      // 6
+* pdu.severityName;  // "INFO"
+* pdu.payload;       // "user logged in"
+* ```
+*
+* @remarks `pdu.severity` est numérique (RFC 5424) pour comparaisons rapides.
+*   `pdu.severityName` est la string (`"INFO"`, `"CRITIC"` — pas `"CRITICAL"`).
+*/
+let guid = 0;
+var Pdu = class Pdu {
+	payload;
+	uid;
+	severity;
+	timeStamp;
+	severityName;
+	typePayload;
+	moduleName;
+	msgid;
+	msg;
+	status;
+	/** PID du process émetteur (= procid RFC 5424). Constant, capturé au chargement du module. */
+	pid;
+	/**
+	* Identifiant de la requête en cours (corrélation log↔requête).
+	*
+	* Présent UNIQUEMENT si le Pdu est créé dans une bulle `RequestContext` active
+	* (ALS Node) ET que {@link Pdu.requestIdProvider} a été branché côté Node — voir
+	* `src/index.ts` (barrel Node uniquement, isomorphisme préservé : le bundle
+	* client/browser ne branche pas, le provider reste `null` → 0 alloc, 0 lecture).
+	*
+	* Combiné à `pid` (procid RFC 5424), permet la corrélation **complète** :
+	* `pid` = quel worker, `requestId` = quelle requête. Voyage dans ring buffer +
+	* `nodefony:syslog` + transports JSON (champ public sérialisé naturellement).
+	*/
+	requestId;
+	/**
+	* Provider injectable du `requestId` courant (ALS). Branché par le barrel
+	* Node (`src/index.ts`) sur `RequestContext.getRequestId`. Reste `null` côté
+	* browser/debugbar (le bundle client n'importe pas `node:async_hooks`) et
+	* pendant les phases boot pré-Kernel (cohérent : pas de requête en cours).
+	*
+	* Coût : 1 test de référence par Pdu (~5 ns) quand `null` ; ~50-100 ns quand
+	* branché (lecture ALS + accès propriété). Pas d'alloc supplémentaire si
+	* `requestId` est `undefined` (le champ reste non-défini sur l'instance).
+	*/
+	static requestIdProvider = null;
+	/**
+	* Construit un Pdu prêt à être publié dans le pipeline Syslog.
+	*
+	* @param pci - payload (string, Error, objet — typé `unknown`, narrower côté lecteur).
+	* @param severity - niveau RFC 5424 (string `"INFO"` ou numérique `6`). Défaut `"INFO"`.
+	* @param moduleName - nom du module/service qui a produit le log. Défaut `"nodefony"`.
+	* @param msgid - catégorie de message (`"AUTH"`, `"ROUTER"`, etc.). Défaut `""`.
+	* @param msg - détail libre optionnel. Défaut `""`.
+	* @param date - timestamp (number, Date, ou string parsable). Défaut `Date.now()`.
+	* @throws Si `severity` n'est pas une valeur valide de {@link SysLogSeverity}.
+	*/
+	constructor(pci, severity, moduleName = "nodefony", msgid = "", msg = "", date) {
+		if (date === void 0) this.timeStamp = Date.now();
+		else if (typeof date === "number") this.timeStamp = date;
+		else if (date instanceof Date) this.timeStamp = date.getTime();
+		else this.timeStamp = new Date(date).getTime();
+		this.uid = ++guid;
+		this.severity = translateSeverity(severity);
+		const sName = severityNameMap.get(this.severity);
+		if (sName === void 0) throw new Error(`Invalid severity value: ${this.severity}`);
+		this.severityName = sName;
+		this.typePayload = fastTypeOf(pci);
+		this.payload = pci;
+		this.moduleName = moduleName;
+		this.msgid = msgid;
+		this.msg = msg;
+		this.status = "NOTDEFINED";
+		this.pid = PID;
+		this.requestId = Pdu.requestIdProvider !== null ? Pdu.requestIdProvider() : void 0;
+	}
+	/**
+	* Map bidirectionnelle des sévérités RFC 5424 (`{ INFO: 6, 6: "INFO", ... }`).
+	*
+	* @returns dictionnaire `{ severityName: severityValue }` plus enum reverse.
+	*/
+	static sysLogSeverity() {
+		return sysLogSeverityObj;
+	}
+	/**
+	* Convertit une sévérité numérique ou string en son nom canonique.
+	*
+	* @param severity - valeur numérique (`6`) ou string (`"INFO"` ou `"6"`).
+	* @returns nom canonique (`"INFO"`) ou `undefined` si invalide.
+	*/
+	static severityToString(severity) {
+		const numericSeverity = typeof severity === "string" ? parseInt(severity, 10) : severity;
+		if (!isNaN(numericSeverity) && SysLogSeverity[numericSeverity] !== void 0) return SysLogSeverity[numericSeverity];
+		const severityKey = Pdu.severityToString(SysLogSeverity[severity]);
+		return severityKey !== void 0 ? severityKey : void 0;
+	}
+	/**
+	* Retourne le timestamp formaté `HH:MM:SS GMT±HHMM (TZ Name)`.
+	*
+	* @returns time string lisible par humain.
+	*/
+	getDate() {
+		return new Date(this.timeStamp).toTimeString();
+	}
+	/**
+	* Sérialise le Pdu en string mono-ligne pour transport console/file.
+	*
+	* @returns ligne formatée `TimeStamp:... Log:... ModuleName:... SeverityName:... MessageID:... UID:... Message:...`.
+	*/
+	toString() {
+		return `TimeStamp:${this.getDate()}  Log:${this.payload}  ModuleName:${this.moduleName}  SeverityName:${this.severityName}  MessageID:${this.msgid}  UID:${this.uid}  Message:${this.msg}`;
+	}
+	/**
+	* Réhydrate un Pdu existant à partir d'une string JSON — mute uniquement les
+	* clés déjà présentes sur l'instance (filtre `key in this`).
+	*
+	* @param str - JSON sérialisé d'un Pdu.
+	* @returns objet parsé (ou `null` si JSON vide). Mute l'instance courante au passage.
+	*/
+	parseJson(str) {
+		const json = JSON.parse(str);
+		Object.entries(json).forEach(([key, value]) => {
+			if (key in this) this[key] = value;
+		});
+		return json;
+	}
+};
+//#endregion
+export { BROWSER_ORIGIN, SEVERITY_NAMES, Pdu as default };