@nodefony/http 10.0.0-alpha.1

package/dist/nodefony/service/sessions/sessions-service.js

@@ -0,0 +1,580 @@
+import { SESSION_FACETS } from "../../src/session/storage/sessionFilters.js";
+import __decorateMetadata from "../../../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateMetadata.js";
+import __decorate from "../../../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.js";
+import http_kernel_default from "../http-kernel.js";
+import __decorateParam from "../../../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateParam.js";
+import Session from "../../src/session/session.js";
+import MemorySessionStorage from "../../src/session/storage/MemorySessionStorage.js";
+import RevocationGuardStorage from "../../src/session/storage/RevocationGuardStorage.js";
+import { AUTO_STORE, EMPTY_INFRA, GcScheduler, Module, Nodefony, RequestContext, Service, countFacets, extend, inject, injectable, readStoreLocation, resolveAutoStore } from "nodefony";
+import { createHash, createHmac } from "node:crypto";
+//#region nodefony/service/sessions/sessions-service.ts
+var _SessionsService;
+/**
+* Convertit un timestamp de session (`Date` en mémoire, **string ISO** après
+* `JSON.parse` côté File/Redis, ou `number`) en epoch ms — `null` si absent ou
+* invalide. JSON-safe pour le DTO admin.
+*/
+function toEpoch(value) {
+	if (value === void 0 || value === null) return null;
+	const t = new Date(value).getTime();
+	return Number.isNaN(t) ? null : t;
+}
+/**
+* Taille des pages lues par les parcours d'administration (révocation par
+* référence, « déconnecter partout »). C'est **la borne mémoire** de ces
+* opérations : quel que soit le parc — 10 ou 10 millions de sessions — le service
+* ne détient jamais plus de `SCAN_PAGE` records à la fois. Assez grand pour que
+* les allers-retours au store restent rares, assez petit pour rester négligeable
+* en RAM.
+*/
+const SCAN_PAGE = 200;
+/**
+* Nombre maximal de pages lues par un parcours d'administration (garde-fou :
+* `SCAN_PAGE × MAX_ADMIN_PAGES` sessions visitées au plus). Protège d'une boucle
+* infinie si un store au curseur ne convergeait jamais vers la fin. Un parcours
+* interrompu est **journalisé** — partiel signalé, jamais silencieux.
+*/
+const MAX_ADMIN_PAGES = 5e3;
+/**
+* Nombre maximal de passages complets d'un « déconnecter partout ». Le premier
+* détruit l'essentiel, le second confirme qu'il ne reste rien ; les suivants ne
+* servent que si un store à curseur faible a sauté des éléments sous la
+* suppression. Au-delà, on journalise plutôt que de boucler — une révocation
+* incomplète doit être VISIBLE, pas silencieuse.
+*/
+const MAX_LOGOUT_PASSES = 10;
+/**
+* Dérive le pseudonyme public d'une session — `HMAC-SHA256(secret, id)` tronqué,
+* préfixé `sess_`. **Non réversible** : exposer ce `ref` ne révèle pas l'id de
+* session (= le jeton du cookie). Fonction **pure** (testable sans instancier le
+* service ni démarrer de serveur).
+*/
+function computeSessionRef(secret, id) {
+	return `sess_${createHmac("sha256", secret).update(id).digest("hex").slice(0, 24)}`;
+}
+/**
+* Projette une entrée brute {@link ISessionRecord} en {@link ISessionSummary}
+* **redacté par construction** (allowlist) : jamais `Attributes`, jamais
+* `flashBag`, jamais l'id brut — seulement le `ref` + des champs sûrs
+* (`user`/`ip`/`ua`/dates). Fonction **pure** (cœur de la garantie anti-fuite,
+* testée isolément).
+*/
+function toSessionSummary(rec, ref, currentRef = null) {
+	const data = rec.data;
+	const user = typeof data.user === "string" ? data.user : "";
+	const meta = data.metaBag ?? {};
+	return {
+		ref,
+		user,
+		authenticated: user.length > 0,
+		ip: typeof meta.ip === "string" ? meta.ip : null,
+		ua: typeof meta.ua === "string" ? meta.ua : null,
+		createdAt: toEpoch(data.createdAt),
+		updatedAt: toEpoch(data.updatedAt),
+		tenantId: typeof meta.tenantId === "string" ? meta.tenantId : null,
+		current: currentRef !== null && ref === currentRef
+	};
+}
+let SessionsService = class SessionsService extends Service {
+	static {
+		_SessionsService = this;
+	}
+	httpKernel;
+	/**
+	* Registre des storages de session — inversion de contrôle.
+	*
+	* Chaque module qui fournit un storage l'enregistre à son chargement
+	* (`SessionsService.registerStorage("drizzle", DrizzleStorage)`). Ainsi
+	* `@nodefony/http` **ne dépend d'aucun ORM** : pas d'import croisé, pas de
+	* cycle, et ajouter un driver ne touche plus ce fichier. Le handler de la
+	* config (`session.store`) sélectionne le storage par son nom.
+	*/
+	static storages = /* @__PURE__ */ new Map();
+	/**
+	* Enregistre un storage de session sous un nom de store (insensible à la
+	* casse) et émet l'événement kernel `onRegisterSessionStorage` (observabilité
+	* Studio / extension). Le kernel peut être absent au tout premier chargement
+	* (registration statique) → fire gardé.
+	*/
+	static registerStorage(name, ctor) {
+		const key = name.toLowerCase();
+		_SessionsService.storages.set(key, ctor);
+		const kernel = Nodefony.getKernel();
+		kernel?.fire("onRegisterSessionStorage", key, ctor);
+		kernel?.log(`SESSION STORAGE registered : ${key}`, "DEBUG", "SESSION");
+	}
+	/** Storage enregistré pour un store, ou `undefined`. */
+	static getStorage(name) {
+		return _SessionsService.storages.get(String(name ?? "").toLowerCase());
+	}
+	/** Noms des handlers de session enregistrés. */
+	static storageHandlers() {
+		return [..._SessionsService.storages.keys()];
+	}
+	sessionStrategy = "migrate";
+	storage = null;
+	module;
+	defaultSessionName = "nodefony";
+	secret;
+	iv;
+	certificates;
+	gcScheduler = null;
+	constructor(module, httpKernel) {
+		super("sessions", module.container, module.notificationsCenter, module.options.session);
+		this.httpKernel = httpKernel;
+		this.module = module;
+		this.certificates = this.get("certificates");
+		this.defaultSessionName = this.options.name;
+		this.once("onTerminate", () => {
+			this.gcScheduler?.stop();
+			if (this.storage) this.storage.close();
+		});
+	}
+	async init() {
+		this.secret = this.createSecret();
+		this.iv = this.createIv();
+		this.initializeStorage();
+		return this;
+	}
+	initializeStorage() {
+		let storeName = this.options.store;
+		const configured = storeName;
+		let reason = `store explicitement configuré ("${configured}")`;
+		if (storeName === AUTO_STORE) {
+			const auto = resolveAutoStore("session", this.kernel?.infra ?? EMPTY_INFRA, _SessionsService.storageHandlers(), "memory");
+			storeName = auto.store;
+			reason = auto.reason;
+			this.log(`session.store "auto" → "${storeName}" (${auto.reason})`, "INFO");
+		}
+		let Storage = _SessionsService.getStorage(storeName);
+		if (!Storage) {
+			const known = _SessionsService.storageHandlers().join(", ") || "aucun";
+			const msg = `session store "${storeName}" inconnu (enregistrés : ${known})`;
+			if (this.kernel?.environment === "production") throw new Error(`${msg} — sessions indisponibles : boot avorté.`);
+			this.log(`${msg} — repli "memory"`, "WARNING");
+			storeName = "memory";
+			reason = `repli "memory" (store "${configured}" introuvable)`;
+			Storage = _SessionsService.getStorage(storeName);
+			if (!Storage) throw new Error(`session store de repli "memory" introuvable — sessions indisponibles.`);
+		}
+		const innerStorage = new Storage(this);
+		const storage = new RevocationGuardStorage(innerStorage);
+		this.storage = storage;
+		this.log(`SESSION STORAGE active : ${storeName}`, "INFO");
+		this.fire("onSessionStorageReady", storeName, this.storage);
+		this.kernel?.fire("onSessionStorageReady", storeName, this.storage);
+		this.kernel?.on("onReady", async () => {
+			this.kernel?.registerStoreResolution({
+				brick: "session",
+				nature: "session",
+				configured,
+				resolved: storeName,
+				available: _SessionsService.storageHandlers(),
+				reason,
+				configPath: "http.session.store",
+				location: readStoreLocation(innerStorage)
+			});
+			await storage.open();
+			this.gcScheduler = new GcScheduler({
+				intervalS: Number(this.options.gcIntervalS ?? 600),
+				jitter: this.options.gcJitter !== false,
+				run: () => this.runGc(),
+				onError: (e) => this.log(e, "WARNING", "SESSION-GC")
+			});
+			this.gcScheduler.start();
+		});
+		return this.storage;
+	}
+	createSecret() {
+		const secret = createHash("sha512").update(this.certificates?.key).digest();
+		return Buffer.from(secret.buffer.slice(0, 32));
+	}
+	createIv() {
+		const iv = createHash("sha512").update(this.certificates?.publicKeyPem).digest();
+		return Buffer.from(iv.buffer.slice(0, 16));
+	}
+	async start(context, readOnly) {
+		return new Promise((resolve, reject) => {
+			if (context.sessionStarting) {
+				if (context.session) {
+					resolve(context.session);
+					return;
+				}
+				context.once("onSessionStart", (session, error) => {
+					if (session) return resolve(session);
+					return reject(error || /* @__PURE__ */ new Error("Bad Session"));
+				});
+				return;
+			}
+			if (context.session) {
+				if (context.session.status === "active") {
+					this.log(`SESSION ALLREADY STARTED ==> ${context.session.name} : ${context.session.id}`, "DEBUG");
+					return resolve(context.session);
+				}
+			}
+			let inst = null;
+			try {
+				context.sessionStarting = true;
+				inst = this.createSession(this.defaultSessionName);
+				inst.readOnly = readOnly === true;
+			} catch (e) {
+				context.fire("onSessionStart", null, e);
+				return reject(e);
+			}
+			inst.start(context).then((session) => {
+				try {
+					context.session = session;
+					const method = context.method;
+					const request = context.request;
+					if (method !== "WEBSOCKET" && request && request.request) request.request.session = session;
+					context.sessionStarting = false;
+					if (context.cleaned) return reject(/* @__PURE__ */ new Error("context already cleaned"));
+					context.fire("onSessionStart", session, null);
+					return resolve(session);
+				} catch (e) {
+					if (context.cleaned) return reject(e);
+					context.fire("onSessionStart", null, e);
+					return reject(e);
+				}
+			}).catch((err) => {
+				if (context.cleaned) return reject(err);
+				context.fire("onSessionStart", null, err);
+				return reject(err);
+			});
+		});
+	}
+	async saveSession(context) {
+		const session = context.session;
+		if (!session) return null;
+		if (session.dirty && !session.readOnly) return session.save(context.user ? context.user : void 0);
+		await session.touchIfNeeded();
+		return session;
+	}
+	createSession(name, options) {
+		options = extend({}, this.options, options);
+		return new Session(name, options, this);
+	}
+	setSessionStrategy(strategy) {
+		this.sessionStrategy = strategy;
+	}
+	/**
+	* Une passe de purge du store (`storage.gc(idle, absolute)`) — point d'entrée
+	* public d'un ordonnanceur : le {@link GcScheduler} l'appelle, mais un futur
+	* worker cron (`session:gc` / k8s CronJob) peut l'appeler à sa place (poser
+	* alors `gcIntervalS:0`). L'anti-empilement et la capture d'erreur vivent dans
+	* le GcScheduler (via `onError`) — ici, la passe métier nue.
+	*/
+	async runGc() {
+		if (!this.storage) return;
+		await this.storage.gc(this.options.idleTimeoutS, this.options.absoluteTimeoutS);
+	}
+	/**
+	* `true` si le backend de session courant sait s'énumérer **par pages**
+	* (`listPage`). Un store KV/edge sans scan retourne `false` → l'endpoint admin
+	* répond **501** (refus honnête, jamais une liste vide trompeuse).
+	*
+	* C'est bien `listPage` — et non `listAll` — qui fait foi : toute la surface
+	* d'administration (listing, révocation par référence, « déconnecter partout »)
+	* est bâtie sur la pagination, pour que son coût mémoire soit **indépendant du
+	* nombre de sessions**. Un store qui ne saurait que tout charger serait une
+	* régression déguisée en capacité.
+	*/
+	supportsEnumeration() {
+		const storage = this.storage;
+		return !!storage && typeof storage.listPage === "function";
+	}
+	/**
+	* Champs de tri que le backend de session **actuellement configuré** sait
+	* honorer, en vocabulaire public.
+	*
+	* La capacité se CONSTATE au runtime : la même application rend `["updatedAt",
+	* "id"]` sur SQLite et `[]` sur Redis (`SCAN` ne donne aucun ordre global).
+	* Le data plane transmet cette liste à `parsePageQuery`, qui **refuse** (400)
+	* un `order` qu'aucun store ne pourrait honorer — au lieu de rendre une page
+	* non triée en laissant croire le contraire.
+	*
+	* @returns les champs triables, liste vide si le backend ne trie pas.
+	*/
+	sortableFields() {
+		return this.storage?.sortableFields ?? [];
+	}
+	/**
+	* Dérive le pseudonyme public d'une session — `HMAC-SHA256(secret, id)` tronqué,
+	* préfixé `sess_`. **Non réversible** : exposer ce `ref` ne révèle pas l'id de
+	* session (= le jeton du cookie). Le secret HMAC = celui de la couche session
+	* (`this.secret`, dérivé de la clé du certificat au boot), jamais sérialisé.
+	*
+	* @throws Error si le secret n'est pas initialisé (service pas démarré) — capté
+	*   en 503 côté endpoint plutôt que d'émettre un `ref` faible.
+	*/
+	sessionRef(id) {
+		if (!this.secret) throw new Error("sessions: HMAC secret unavailable (service not initialized)");
+		return computeSessionRef(this.secret, id);
+	}
+	/**
+	* Énumère les sessions persistées en {@link ISessionSummary} **redactés** (jamais
+	* d'id brut ni d'`Attributes`), des plus récentes aux plus anciennes. Le filtre
+	* `user` est poussé au store (WHERE SQL) PUIS ré-appliqué ici (défense si un
+	* store l'ignore). Pré-condition : {@link supportsEnumeration} (sinon throw).
+	*/
+	/**
+	* Référence publique de la session qui porte la **requête en cours**, lue dans
+	* le contexte de l'ALS — ou `null` quand la requête n'en porte aucune (CLI,
+	* appel interne, session jamais démarrée).
+	*
+	* Point UNIQUE de cette dérivation : marquer « cet appareil » se fait ici, et
+	* les deux énumérations (admin et self-service) s'en servent — sans quoi
+	* chaque appelant recalculerait la règle et l'une des copies dériverait.
+	* Un HMAC par page d'administration, jamais sur le chemin nominal.
+	*/
+	currentSessionRef() {
+		if (!this.secret) return null;
+		const id = RequestContext.getContext()?.session?.id;
+		return typeof id === "string" && id.length > 0 ? computeSessionRef(this.secret, id) : null;
+	}
+	async listSessionsPage(query) {
+		const page = await this.enumerable().listPage(query);
+		const wantUser = query.user;
+		const currentRef = this.currentSessionRef();
+		const items = [];
+		for (const rec of page.items) {
+			const user = typeof rec.data.user === "string" ? rec.data.user : "";
+			if (wantUser !== void 0 && user !== wantUser) continue;
+			items.push(toSessionSummary(rec, this.sessionRef(rec.id), currentRef));
+		}
+		return {
+			...page,
+			items
+		};
+	}
+	/**
+	* Compte les sessions sans les énumérer (KPI de la console). Renvoie **`-1`**
+	* si le backend ne sait pas compter à coût raisonnable (Redis) — l'appelant
+	* affiche alors l'inconnu plutôt qu'un chiffre inventé.
+	*/
+	async countSessions(query) {
+		const storage = this.enumerable();
+		if (typeof storage.countSessions !== "function") return -1;
+		return storage.countSessions(query);
+	}
+	/**
+	* Compte les utilisateurs **distincts** ayant une session — le second nombre
+	* de la console, celui que `countSessions` ne dit pas (« 400 sessions » n'est
+	* pas « 400 personnes »).
+	*
+	* @returns le nombre d'utilisateurs distincts, ou **`-1`** si le backend ne
+	*   sait pas agréger (Redis).
+	*/
+	async countDistinctUsers(query) {
+		const storage = this.enumerable();
+		if (typeof storage.countDistinctUsers !== "function") return -1;
+		return storage.countDistinctUsers(query);
+	}
+	/**
+	* Les compteurs de tête de la console — posés sur la collection ENTIÈRE, pas
+	* sur la page affichée.
+	*
+	* C'est la correction d'un mensonge d'affichage : les cartes étaient calculées
+	* dans le navigateur à partir des sessions chargées, donc bornées par la
+	* fenêtre du tableau. Elles décrivaient l'échantillon visible en ayant l'air
+	* de décrire le parc.
+	*
+	* Chaque compteur vaut `null` quand le backend ne sait pas répondre — la
+	* console affiche alors l'inconnu (« — ») plutôt qu'un zéro qui se lirait
+	* comme une absence.
+	*
+	* @param query - filtres à appliquer avant comptage (sans fenêtre).
+	*/
+	async countSessionFacets(query) {
+		const [facets, users] = await Promise.all([countFacets(SESSION_FACETS, (facet) => this.countSessions({
+			...query,
+			...facet
+		})), this.countDistinctUsers(query)]);
+		return {
+			...facets,
+			users: users >= 0 ? users : null
+		};
+	}
+	/**
+	* Storage courant, garanti énumérable — factorise la pré-condition de toute la
+	* surface admin (une seule formulation de l'erreur, un seul point à faire
+	* évoluer).
+	*
+	* @throws Error si le storage est absent ou n'implémente pas `listPage`.
+	*/
+	enumerable() {
+		const storage = this.storage;
+		if (!storage || typeof storage.listPage !== "function") throw new Error("sessions: enumeration not supported by current storage");
+		return storage;
+	}
+	/**
+	* Parcourt les sessions **page par page**, en ne gardant JAMAIS plus d'une page
+	* en mémoire — le cœur de la gouvernance bornée : retrouver une session par sa
+	* référence publique impose de recalculer un HMAC sur chaque id, mais pas de
+	* charger le parc entier pour le faire.
+	*
+	* Gère les deux modes du contrat de façon transparente pour l'appelant :
+	* curseur (`nextCursor` du store) ou offset (avance de `SCAN_PAGE`). Le visiteur
+	* renvoie `true` pour **arrêter** le parcours (court-circuit dès le match).
+	*
+	* @param filter - restriction poussée au store (ex. `user`).
+	* @param visit - appelé pour chaque record ; `true` = stop.
+	* @returns `true` si le parcours a été arrêté par le visiteur.
+	*/
+	async eachSessionRecord(filter, visit) {
+		const storage = this.enumerable();
+		let cursor;
+		let offset = 0;
+		for (let guard = 0; guard < MAX_ADMIN_PAGES; guard += 1) {
+			const page = await storage.listPage({
+				...filter,
+				limit: SCAN_PAGE,
+				withTotal: false,
+				...cursor !== void 0 ? { cursor } : { offset }
+			});
+			for (const rec of page.items) if (await visit(rec)) return true;
+			if (!page.hasNext) return false;
+			if (page.nextCursor) cursor = page.nextCursor;
+			else offset += SCAN_PAGE;
+		}
+		this.log(`sessions: parcours admin interrompu après ${MAX_ADMIN_PAGES} pages (résultat potentiellement partiel)`, "WARNING");
+		return false;
+	}
+	/**
+	* Révoque une session par son `ref` public : re-scanne, recalcule le HMAC de
+	* chaque id pour retrouver l'id réel (l'id brut ne quitte jamais le process),
+	* puis `destroy()`. `ref` étant public (pas un secret), la comparaison directe
+	* est sûre. Idempotent — `false` si aucun `ref` ne correspond.
+	*/
+	async destroyByRef(ref, actor) {
+		const storage = this.enumerable();
+		let destroyed = false;
+		await this.eachSessionRecord(void 0, async (rec) => {
+			if (this.sessionRef(rec.id) !== ref) return false;
+			const subject = typeof rec.data.user === "string" ? rec.data.user : null;
+			destroyed = await storage.destroy(rec.id);
+			if (destroyed) {
+				this.log(`session revoked by admin — ref=${ref} actor=${actor ?? "admin"}`, "INFO");
+				this.emitAudit({
+					category: "session",
+					action: "session.revoked",
+					outcome: "success",
+					actor: actor ?? null,
+					resource: ref,
+					metadata: {
+						subject,
+						viaAdmin: true
+					}
+				});
+			}
+			return true;
+		});
+		return destroyed;
+	}
+	/**
+	* « Déconnexion partout » : détruit TOUTES les sessions d'un utilisateur (scan
+	* O(N) — pas d'index inverse, acceptable en admin). Renvoie le nombre détruit.
+	*/
+	async destroyByUser(identifier, actor) {
+		const storage = this.enumerable();
+		let destroyed = 0;
+		for (let pass = 0; pass < MAX_LOGOUT_PASSES; pass += 1) {
+			let destroyedThisPass = 0;
+			await this.eachSessionRecord({ user: identifier }, async (rec) => {
+				if (rec.data.user !== identifier) return false;
+				if (await storage.destroy(rec.id)) destroyedThisPass += 1;
+				return false;
+			});
+			destroyed += destroyedThisPass;
+			if (destroyedThisPass === 0) break;
+			if (pass === 9) this.log(`sessions: logout-all interrompu après ${MAX_LOGOUT_PASSES} passages — user=${identifier} (révocation potentiellement incomplète)`, "WARNING");
+		}
+		if (destroyed > 0) {
+			this.log(`sessions revoked by admin (logout-all) — user=${identifier} count=${destroyed} actor=${actor ?? "admin"}`, "INFO");
+			this.emitAudit({
+				category: "session",
+				action: "session.revoked",
+				outcome: "success",
+				actor: actor ?? null,
+				resource: identifier,
+				reason: "logout_all",
+				metadata: {
+					count: destroyed,
+					viaAdmin: true
+				}
+			});
+		}
+		return destroyed;
+	}
+	/**
+	* Énumère **une page** des sessions APPARTENANT à `identifier`
+	* ({@link ISessionSummary} redactés). Délègue à {@link listSessionsPage} avec le
+	* filtre `user` (poussé au store PUIS ré-appliqué — défense en profondeur). Un
+	* `identifier` vide renvoie une page vide (jamais les sessions anonymes
+	* `user===""`, qui appartiennent à tout le monde et donc à personne).
+	*/
+	async listOwnSessionsPage(identifier, query) {
+		if (!identifier) return {
+			items: [],
+			total: 0,
+			limit: query.limit,
+			offset: query.offset ?? 0,
+			hasNext: false
+		};
+		return this.listSessionsPage({
+			...query,
+			user: identifier
+		});
+	}
+	/**
+	* Révoque UNE session **possédée par `identifier`**, désignée par son `ref`
+	* public. Contrairement à {@link destroyByRef} (admin, scan GLOBAL), le scan est
+	* RESTREINT aux sessions de `identifier` (+ re-check d'appartenance) : un `ref`
+	* qui ne lui appartient pas est introuvable → `false`, ce qui ferme l'IDOR.
+	* Idempotent. Audité (`self: true`, acteur = le propriétaire).
+	*/
+	async destroyOwnByRef(identifier, ref, actor) {
+		if (!identifier) return false;
+		const storage = this.enumerable();
+		let destroyed = false;
+		await this.eachSessionRecord({ user: identifier }, async (rec) => {
+			if (rec.data.user !== identifier) return false;
+			if (this.sessionRef(rec.id) !== ref) return false;
+			destroyed = await storage.destroy(rec.id);
+			if (destroyed) {
+				this.log(`session revoked by owner — ref=${ref} user=${identifier}`, "INFO");
+				this.emitAudit({
+					category: "session",
+					action: "session.revoked",
+					outcome: "success",
+					actor: actor ?? identifier,
+					resource: ref,
+					metadata: {
+						subject: identifier,
+						self: true
+					}
+				});
+			}
+			return true;
+		});
+		return destroyed;
+	}
+	/**
+	* Émet un événement dans le journal d'audit de `@nodefony/security` s'il est
+	* monté (résolu par nom au runtime) — **no-op** si security est absent/désactivé.
+	* L'action de révocation reste tracée par `this.log()` dans tous les cas.
+	*/
+	emitAudit(event) {
+		this.get("auditService")?.record(event);
+	}
+};
+SessionsService = _SessionsService = __decorate([
+	injectable(),
+	__decorateParam(1, inject("HttpKernel")),
+	__decorateMetadata("design:paramtypes", [typeof Module === "undefined" ? Object : Module, typeof http_kernel_default === "undefined" ? Object : http_kernel_default])
+], SessionsService);
+SessionsService.registerStorage("memory", MemorySessionStorage);
+var sessions_service_default = SessionsService;
+//#endregion
+export { computeSessionRef, sessions_service_default as default, toSessionSummary };

package/dist/nodefony/service/trace.js

@@ -0,0 +1,72 @@
+import { randomFillSync } from "node:crypto";
+//#region nodefony/service/trace.ts
+/**
+* W3C Trace Context — parse + generate `traceparent` headers (P2.7).
+*
+* Spec: https://www.w3.org/TR/trace-context/
+* Format: `<version>-<traceId>-<parentId>-<flags>`
+*   - version: 2 hex chars (currently always `00`; `ff` is reserved/invalid)
+*   - traceId: 32 hex chars (16 bytes), non-zero
+*   - parentId / spanId: 16 hex chars (8 bytes), non-zero
+*   - flags: 2 hex chars (`01` = sampled)
+*
+* Behaviour at the request boundary:
+*   - Valid incoming traceparent → keep `version`/`traceId`/`flags`, generate
+*     a fresh `parentId` (we are a child span in the existing trace).
+*   - Missing or invalid → mint a brand-new traceparent (version `00`,
+*     `flags=01` sampled by default).
+*
+* The result is propagated through {@link RequestContext} and echoed on the
+* HTTP response so downstream services and clients can stitch the trace.
+*/
+const TRACEPARENT_RE = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/;
+/**
+* Parse a `traceparent` header value. Returns `null` when the header is
+* missing, malformed, or carries an all-zero traceId/spanId (per W3C the
+* recipient MUST NOT propagate such values).
+*/
+function parseTraceparent(header) {
+	if (typeof header !== "string") return null;
+	const m = TRACEPARENT_RE.exec(header.trim().toLowerCase());
+	if (!m) return null;
+	const [, version, traceId, parentId, flags] = m;
+	if (version === "ff") return null;
+	if (/^0+$/.test(traceId)) return null;
+	if (/^0+$/.test(parentId)) return null;
+	return {
+		version,
+		traceId,
+		parentId,
+		flags
+	};
+}
+const ENTROPY_POOL_BYTES = 4096;
+const entropyPool = Buffer.allocUnsafe(ENTROPY_POOL_BYTES);
+let entropyOffset = ENTROPY_POOL_BYTES;
+/** `size` octets aléatoires en hex, puisés dans le pool amorti (refill si épuisé). */
+function randomHex(size) {
+	if (entropyOffset + size > ENTROPY_POOL_BYTES) {
+		randomFillSync(entropyPool);
+		entropyOffset = 0;
+	}
+	const hex = entropyPool.toString("hex", entropyOffset, entropyOffset + size);
+	entropyOffset += size;
+	return hex;
+}
+/**
+* Resolve the traceparent to attach to a new request. Honors an incoming
+* valid header, generates a fresh one otherwise.
+*
+* @param header - raw value read from `request.headers.traceparent`
+* @returns the traceparent string to propagate (always well-formed)
+*/
+function resolveTraceparent(header) {
+	const parsed = parseTraceparent(header);
+	if (parsed) {
+		const newSpanId = randomHex(8);
+		return `${parsed.version}-${parsed.traceId}-${newSpanId}-${parsed.flags}`;
+	}
+	return `00-${randomHex(16)}-${randomHex(8)}-01`;
+}
+//#endregion
+export { parseTraceparent, resolveTraceparent };