@nodefony/http 10.0.0-beta.2 → 10.0.0-beta.4

package/dist/nodefony/src/context/http/Request.js

@@ -1,8 +1,9 @@
 import HttpError from "../../errors/httpError.js";
 import { hasForwardingHeaders, resolveForwarded } from "../forwarded.js";
-import { Parser, ParserJson, ParserQs, ParserXml, acceptParser } from "./parser.js";
+import { hostnameOf } from "../domainMatcher.js";
+import { Parser, ParserJson, ParserQs, ParserRaw, ParserXml, acceptParser } from "./parser.js";
 import { isCanonicalAuthority, splitTarget } from "./urlFastPath.js";
-import { RequestContext, extend, useConfig } from "nodefony";
+import { RequestContext, useConfig } from "nodefony";
 import { createHash, randomUUID } from "node:crypto";
 import { URL } from "node:url";
 import fs from "node:fs";
@@ -11,7 +12,7 @@ import os from "node:os";
 import path from "node:path";
 import QS from "qs";
 import { Busboy } from "@fastify/busboy";
-//#region nodefony/src/context/http/Request.ts
+// nodefony/src/context/http/Request.ts
 const reg = /(.*)[[][\]]$/u;
 /**
 * Supprime un fichier temporaire d'upload sans jamais faire échouer le nettoyage :
@@ -33,6 +34,7 @@ const CHARSET_ALIASES = {
 	"utf-16le": "utf16le"
 };
 const QUOTE_TRIM = /^["']|["']$/gu;
+const NO_FILES = Object.freeze([]);
 const parse = {
 	POST: true,
 	PUT: true,
@@ -52,15 +54,6 @@ function perfMark(field) {
 	const p = globalThis.__nfPerfProbe;
 	if (p && p.t0 !== 0n) p[field] += Number(process.hrtime.bigint() - p.t0);
 }
-/**
-* Nom d'hôte d'une autorité brute (`host[:port]`) : tout ce qui précède le
-* premier `:`. Même résultat que `host.split(":")[0]`, sans tableau (#508).
-*/
-function hostnameOf(host) {
-	if (!host) return "";
-	const colon = host.indexOf(":");
-	return colon === -1 ? host : host.slice(0, colon);
-}
 var HttpRequest = class {
 	context;
 	request;
@@ -112,7 +105,7 @@ var HttpRequest = class {
 		let u = this.#url;
 		if (u === null) {
 			u = this.getUrl(this.sUrl);
-			u.query = this.queryGet;
+			u.query = this.query;
 			this.#url = u;
 		}
 		return u;
@@ -121,24 +114,28 @@ var HttpRequest = class {
 		this.#url = u;
 	}
 	parser = null;
-	queryPost = {};
-	queryGet = {};
-	queryFile = [];
-	query = {};
 	/**
-	* Le CORPS de la requête, parsé — nom universel de l'écosystème (Express,
-	* Fastify, NestJS), alias de {@link queryPost}.
-	*
-	* Ne pas confondre avec {@link query}, qui FUSIONNE la query string et le
-	* corps : `body` ne rend jamais un paramètre d'URL. Le data plane admin
-	* expose déjà cette sémantique (`IAdminRequest.body`) ; ce getter la rend
-	* disponible partout.
+	* Le CORPS de la requête, parsé (JSON, urlencoded, XML, champs multipart) —
+	* nom universel de l'écosystème (Express, Fastify, NestJS) et celui
+	* d'`IAdminRequest.body`. Jamais un paramètre d'URL : ceux-là sont dans
+	* {@link query}, et les deux ne fusionnent pas.
+	*/
+	body = {};
+	/** Fichiers reçus, alloués au PREMIER fichier seulement (cf {@link files}). */
+	#uploads = null;
+	/**
+	* Les fichiers reçus dans un corps multipart, déjà écrits dans le répertoire
+	* temporaire — lus par `@UploadedFile()` / `@UploadedFiles()`. Les champs
+	* texte du même corps sont dans {@link body}.
 	*
-	* Getter (aucune allocation) : `queryPost` reste la source unique.
+	* Lecture seule : une requête sans upload rend un vide partagé et gelé,
+	* aucune allocation.
 	*/
-	get body() {
-		return this.queryPost;
+	get files() {
+		return this.#uploads ?? NO_FILES;
 	}
+	/** Les paramètres d'URL, seuls — jamais un champ du corps ({@link body}). */
+	query = {};
 	queryStringOptions;
 	charset = "utf8";
 	uploadOption = {};
@@ -193,7 +190,6 @@ var HttpRequest = class {
 		if (this.search) query = QS.parse(this.search.slice(1), this.queryStringOptions ?? {});
 		else query = {};
 		if (this.#url !== null) this.#url.query = query;
-		this.queryGet = query;
 		this.query = query;
 		if (PERF_PROBE_SUB) perfMark("reqQueryNs");
 		this.contentType = this.getContentType(this.request);
@@ -209,11 +205,11 @@ var HttpRequest = class {
 	* remplace le `once("onRequestEnd")` du ctor qui allouait 1 onceWrapper +
 	* 1 closure à CHAQUE requête.
 	*
-	* Il porte le CORPS (`queryPost`), pas la fusion `query` : un seul sens de
+	* Il porte le CORPS (`body`), jamais les paramètres d'URL : un seul sens de
 	* `body` dans tout le framework, celui de l'écosystème et d'`IAdminRequest`.
 	*/
 	fireRequestEnd() {
-		this.request.body = this.queryPost;
+		this.request.body = this.body;
 		if (this.context.listenerCount("onRequestEnd") === 0) return false;
 		return this.context.fireAsync("onRequestEnd", this);
 	}
@@ -323,7 +319,7 @@ var HttpRequest = class {
 					await this.fireRequestEnd();
 					return BODY_DONE;
 				}
-				this.parser = new Parser(this);
+				this.parser = new ParserRaw(this);
 				return this.parser;
 		}
 	}
@@ -370,8 +366,7 @@ var HttpRequest = class {
 			return this.parser;
 		}
 		const { fields, files } = await this.streamMultipart(bb);
-		this.queryPost = fields;
-		this.query = extend({}, this.query, this.queryPost);
+		this.body = fields;
 		for (const pf of files) await this.createFileUpload(pf.field, pf.file);
 		this.context.requestEnded = true;
 		await this.fireRequestEnd();
@@ -486,7 +481,7 @@ var HttpRequest = class {
 	}
 	accepts(Type) {
 		let parts = [];
-		let subtype = "*";
+		let subtype;
 		let type = "*";
 		if (Type) parts = Type.split("/");
 		switch (parts.length) {
@@ -504,7 +499,7 @@ var HttpRequest = class {
 	}
 	async createFileUpload(name, file) {
 		const fileUpload = await this.context.uploadService?.createUploadFile(file, name);
-		if (fileUpload) this.queryFile.push(fileUpload);
+		if (fileUpload) (this.#uploads ??= []).push(fileUpload);
 		return fileUpload;
 	}
 	getMethod() {
@@ -569,7 +564,9 @@ var HttpRequest = class {
 	/**
 	* Scheme effectif côté client : `Forwarded`/`X-Forwarded-*` résolu de façon
 	* canonique (this.forwarded, gated proxy de confiance) ; sinon le transport
-	* réel. HTTP/2 remplace la lecture du socket par le pseudo-header `:scheme`.
+	* réel. Vaut pour HTTP/2 aussi : le pseudo-en-tête `:scheme` vient du client
+	* (RFC 9113 §8.3.1) et n'est jamais cru — sur h2c, `:scheme: https` ferait
+	* passer une connexion claire pour chiffrée.
 	*/
 	resolveScheme(request) {
 		if (this.forwarded?.proto) return this.forwarded.proto;
@@ -597,9 +594,8 @@ var HttpRequest = class {
 		return new URL(sUrl, baseUrl);
 	}
 	log(pci, severity, msgid, msg) {
-		if (!msgid) msgid = `${this.context.type} REQUEST `;
+		if (!msgid) msgid = `${this.context.serverType} REQUEST `;
 		return this.context.log(pci, severity, msgid, msg);
 	}
 };
-//#endregion
 export { HttpRequest as default };

package/dist/nodefony/src/context/http/Response.js

@@ -2,7 +2,7 @@ import Cookie from "../../cookies/cookie.js";
 import { thenMaybe, typeOf } from "nodefony";
 import http from "node:http";
 import mime from "mime-types";
-//#region nodefony/src/context/http/Response.ts
+// nodefony/src/context/http/Response.ts
 const ANSI_REGEX = new RegExp(["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)", "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))"].join("|"), "g");
 const stripAnsi = function(val) {
 	return typeof val === "string" ? val.replace(ANSI_REGEX, "") : val;
@@ -55,16 +55,32 @@ var HttpResponse = class {
 	constructor(response, context) {
 		this.context = context;
 		this.response = response;
-		this.timeout = this.context.httpKernel?.responseTimeout[this.context.type];
+		const responseTimeout = this.context.httpKernel?.responseTimeout;
+		this.timeout = this.context.serverType === "https" ? responseTimeout?.https : responseTimeout?.http;
 	}
 	/**
 	* Filet posé juste avant l'émission des en-têtes : si aucun `Content-Type`
 	* n'a été choisi (ni négociation, ni `render`, ni controller), émet le défaut
 	* `this.contentType` (application/octet-stream) — comportement identique à
 	* l'ancienne pose au constructeur, sans le ping-pong set/remove/re-set.
+	*
+	* Une réponse SANS corps n'annonce aucun type : `Content-Type` décrit le
+	* contenu (RFC 9110 §8.3), et il n'y en a pas.
 	*/
 	ensureContentTypeHeader() {
-		if (this.response && !this.response.hasHeader("content-type")) this.response.setHeader("content-type", this.contentType);
+		if (this.response && !this.response.hasHeader("content-type") && !this.#isBodyless()) this.response.setHeader("content-type", this.contentType);
+	}
+	/**
+	* Vrai quand la réponse n'a pas de corps : 204 et 304 n'en ont jamais
+	* (RFC 9110 §15.3.5, §15.4.5) ; ailleurs, un corps posé et VIDE. Un corps
+	* jamais posé ne dit rien — un flux peut suivre l'en-tête — et `HEAD` rend
+	* les en-têtes du `GET` (§9.3.2) : tous deux gardent le défaut.
+	*/
+	#isBodyless() {
+		if (NO_CONTENT_LENGTH_STATUS.has(this.statusCode)) return true;
+		if (this.context.method === "HEAD") return false;
+		if (this.#text !== null) return this.#text === "" && !this.flushing;
+		return this.#buffer?.length === 0 && !this.flushing;
 	}
 	/**
 	* Corps de la réponse en octets. Un corps posé en texte n'est encodé qu'à la
@@ -138,16 +154,33 @@ var HttpResponse = class {
 		const serialized = [];
 		for (const cookie of cookies) {
 			const s = cookie.serialize();
-			this.log(`ADD COOKIE ==> ${s}`, "DEBUG");
+			this.logCookie(cookie, s);
 			serialized.push(s);
 		}
 		return this.setHeader("Set-Cookie", serialized);
 	}
 	setCookie(cookie) {
 		const serialize = cookie.serialize();
-		this.log(`ADD COOKIE ==> ${serialize}`, "DEBUG");
+		this.logCookie(cookie, serialize);
 		return this.setHeader("Set-Cookie", serialize);
 	}
+	/**
+	* Journalise en DEBUG un cookie posé, sa VALEUR MASQUÉE : nom et attributs
+	* seulement. Le journal de développement se lit par le plan d'administration
+	* — un identifiant de session y entrerait chez quiconque le consulte.
+	* La ligne n'est construite que si DEBUG passe le gate du syslog pour ce
+	* `msgid` (debug ciblé compris) : rien n'est alloué en production.
+	*
+	* @param cookie - le cookie posé.
+	* @param serialized - sa forme `Set-Cookie`, déjà calculée pour l'en-tête.
+	*/
+	logCookie(cookie, serialized) {
+		const msgid = `${this.context.serverType} RESPONSE `;
+		const syslog = this.context.syslog;
+		if (syslog && !syslog.severityEnabled("DEBUG", msgid)) return;
+		const attrs = serialized.indexOf("; ", cookie.name.length + 1);
+		this.log(`ADD COOKIE ==> ${cookie.name}=<masqué>${attrs === -1 ? "" : serialized.slice(attrs)}`, "DEBUG", msgid);
+	}
 	setHeader(name, value) {
 		if (this.response) {
 			if (this.flushing) {
@@ -444,9 +477,8 @@ var HttpResponse = class {
 		return this;
 	}
 	log(pci, severity, msgid, msg) {
-		if (!msgid) msgid = `${this.context.type} RESPONSE `;
+		if (!msgid) msgid = `${this.context.serverType} RESPONSE `;
 		return this.context.log(pci, severity, msgid, msg);
 	}
 };
-//#endregion
 export { HttpResponse as default };

package/dist/nodefony/src/context/http/SseStream.js

@@ -0,0 +1,349 @@
+import HttpError from "../../errors/httpError.js";
+import Http2Response from "../http2/Response.js";
+import { RequestContext } from "nodefony";
+import http from "node:http";
+import { AsyncResource } from "node:async_hooks";
+// nodefony/src/context/http/SseStream.ts
+/** Battement de cœur par défaut, en ms (§9.2.7 : « every 15 seconds or so »). */
+const SSE_HEARTBEAT_MS = 15e3;
+/** Délai de blocage d'écriture par défaut, en ms. */
+const SSE_STALL_TIMEOUT_MS = 3e4;
+/** Taille maximale d'un événement par défaut, en octets (1 Mio). */
+const SSE_MAX_EVENT_BYTES = 1048576;
+/**
+* Plus long délai qu'un minuteur sait tenir (2^31-1 ms). Au-delà, Node le
+* ramène à 1 ms : un `retry` qui le dépasse ferait reconnecter le client en
+* rafale, un battement qui le dépasse battrait mille fois par seconde.
+*/
+const MAX_TIMER_MS = 2147483647;
+/** Commentaire de battement de cœur — ignoré par tout client conforme. */
+const HEARTBEAT = ":\n\n";
+/** Fin de ligne : CRLF, CR ou LF (§9.2.5). */
+const LINE_BREAK = /\r\n|\r|\n/;
+/**
+* Refuse un champ d'une seule ligne qui contiendrait une fin de ligne.
+*
+* Laisser passer un CR ou un LF dans `event` ou `id` permettrait à une valeur
+* venue d'un utilisateur de clore l'événement et d'en FORGER un autre dans le
+* flux — l'équivalent SSE d'une injection d'en-tête.
+*
+* @throws TypeError quand la valeur contient CR, LF ou NUL.
+*/
+function singleLine(name, value) {
+	if (/[\r\n\0]/.test(value)) throw new TypeError(`Champ SSE « ${name} » : fin de ligne ou NUL interdits`);
+	return value;
+}
+/**
+* Texte d'un événement : la chaîne telle quelle, sinon son JSON.
+*
+* `JSON.stringify` rend `undefined` pour `undefined`, une fonction ou un
+* symbole, et son type `string` le tait : on l'élargit avant de le lire.
+*/
+function serialize(data) {
+	if (typeof data === "string") return data;
+	const json = JSON.stringify(data);
+	return typeof json === "string" ? json : "";
+}
+/**
+* Refuse une option de délai hors de ce qu'un minuteur sait tenir.
+*
+* @throws RangeError quand la valeur n'est ni `false` ni un entier entre 1 et 2^31-1.
+*/
+function checkTimer(name, value) {
+	if (value === void 0 || value === false) return;
+	if (!Number.isInteger(value) || value < 1 || value > MAX_TIMER_MS) throw new RangeError(`SSE : ${name} entier entre 1 et ${MAX_TIMER_MS} ms, ou false, attendu`);
+}
+/** Préfixe chaque ligne d'un texte par `prefix` — `data: ` ou `: `. */
+function lines(prefix, text) {
+	let out = "";
+	for (const line of text.split(LINE_BREAK)) out += `${prefix}${line}\n`;
+	return out;
+}
+/**
+* Un flux `text/event-stream` ouvert sur une réponse.
+*
+* Il s'obtient par {@link openSseStream} (ou `this.renderSse()` dans un
+* contrôleur), jamais par `new` : l'ouverture écrit les en-têtes, et un flux
+* sans en-têtes ne se rattrape pas.
+*/
+var SseStream = class {
+	#context;
+	#target;
+	/** La réponse dont on écoute la fermeture — en HTTP/2, l'objet de compatibilité. */
+	#response;
+	#stallTimeout;
+	#maxEventBytes;
+	#revalidate;
+	/**
+	* Identifiant de connexion de l'identité qui a ouvert le flux (`null` pour
+	* un anonyme) — le registre de révocation ferme par lui les flux d'une
+	* identité dont les droits ont changé.
+	*
+	* @internal
+	*/
+	identifier;
+	#closed = false;
+	#heartbeat = null;
+	/** Coupure d'un client qui ne lit plus — armée seulement sous pression. */
+	#stall = null;
+	/** Fin de vie du flux — armée seulement si `maxDuration` est posé. */
+	#lifetime = null;
+	/** Écouteurs de fermeture — `null` tant que personne n'en pose (lazy). */
+	#onClose = null;
+	/** Attente de `drain` en cours, partagée par tous les `send()` sous pression. */
+	#drain = null;
+	#releaseDrain = null;
+	#onResponseClose = () => this.#finish();
+	#onDrain = () => this.#settleDrain();
+	/**
+	* Le client ne lit plus depuis `stallTimeout` : on coupe la connexion, comme
+	* s'il était parti — la fermeture de la réponse termine le flux.
+	*/
+	#onStall = () => {
+		this.#stall = null;
+		this.#target.destroy();
+	};
+	/** @internal — passer par {@link openSseStream}. */
+	constructor(context, target, response, settings) {
+		this.#context = context;
+		this.#target = target;
+		this.#response = response;
+		this.#stallTimeout = settings.stallTimeout;
+		this.#maxEventBytes = settings.maxEventBytes;
+		this.#revalidate = settings.revalidate;
+		this.identifier = settings.identifier;
+		response.on("close", this.#onResponseClose);
+		const heartbeat = settings.heartbeat;
+		if (settings.maxDuration !== false) {
+			this.#lifetime = setTimeout(() => void this.close(), settings.maxDuration);
+			this.#lifetime.unref();
+		}
+		if (heartbeat !== false && heartbeat > 0) {
+			this.#heartbeat = setInterval(() => {
+				if (this.#drain === null) this.#target.write(HEARTBEAT);
+			}, heartbeat);
+			this.#heartbeat.unref();
+		}
+	}
+	/** Le flux est-il fermé — par le serveur (`close()`) ou par le client parti ? */
+	get closed() {
+		return this.#closed;
+	}
+	/**
+	* L'identité qui a ouvert le flux est-elle toujours valable ? Lu par le
+	* registre de révocation du noyau HTTP.
+	*
+	* @internal
+	*/
+	revalidate() {
+		return this.#revalidate === null ? Promise.resolve(true) : this.#revalidate();
+	}
+	/**
+	* Envoie un événement.
+	*
+	* @param data - texte envoyé tel quel, ou valeur sérialisée en JSON ; un
+	*   texte de plusieurs lignes part en autant de champs `data:`.
+	* @param options - type (`event`) et identifiant (`id`) de l'événement.
+	* @returns rien quand l'écriture est acceptée ; une promesse réglée au
+	*   `drain` quand le client lit moins vite qu'on écrit — l'attendre borne la
+	*   mémoire du serveur. Sans effet une fois le flux fermé.
+	* @throws TypeError quand `event` ou `id` contient une fin de ligne.
+	* @throws RangeError quand l'événement dépasse `maxEventBytes`.
+	*/
+	send(data, options) {
+		let frame = "";
+		if (options?.event !== void 0) frame += `event: ${singleLine("event", options.event)}\n`;
+		if (options?.id !== void 0) frame += `id: ${singleLine("id", options.id)}\n`;
+		frame += `${lines("data: ", serialize(data))}\n`;
+		return this.#write(frame);
+	}
+	/**
+	* Envoie un commentaire — ignoré par le client, utile pour garder une
+	* connexion vivante ou marquer le flux à la lecture.
+	*
+	* @returns comme {@link send}.
+	*/
+	comment(text = "") {
+		return this.#write(`${lines(": ", text)}\n`);
+	}
+	/**
+	* Impose au client un délai de reconnexion (champ `retry:`).
+	*
+	* @param ms - délai en millisecondes, entier positif.
+	* @returns comme {@link send}.
+	* @throws RangeError quand `ms` n'est pas un entier entre 0 et 2^31-1.
+	*/
+	retry(ms) {
+		if (!Number.isInteger(ms) || ms < 0 || ms > MAX_TIMER_MS) throw new RangeError(`retry : entier entre 0 et ${MAX_TIMER_MS} ms attendu`);
+		return this.#write(`retry: ${ms}\n\n`);
+	}
+	/**
+	* Appelle `listener` à la fermeture du flux, quelle qu'en soit la cause.
+	*
+	* L'écouteur est lié au contexte asynchrone de la requête au moment de
+	* l'enregistrement : la fermeture par le client part de la SOCKET, hors de
+	* la bulle de la requête, et un `RequestContext.get()` y rendrait `undefined`.
+	* Un flux déjà fermé appelle l'écouteur au tour suivant.
+	*/
+	onClose(listener) {
+		const bound = AsyncResource.bind(listener);
+		if (this.#closed) {
+			queueMicrotask(bound);
+			return;
+		}
+		this.#onClose ??= [];
+		this.#onClose.push(bound);
+	}
+	/**
+	* Ferme le flux et termine la requête. Idempotent.
+	*
+	* @returns la fin de la requête (hooks `onClose` du contexte compris).
+	*/
+	close() {
+		if (this.#closed) return void 0;
+		this.#finish();
+		const done = this.#context.close();
+		return done instanceof Promise ? done.then(() => void 0) : void 0;
+	}
+	/** Écrit une trame ; une promesse seulement sous contre-pression. */
+	#write(frame) {
+		if (this.#closed) return void 0;
+		const max = this.#maxEventBytes;
+		if (frame.length * 3 > max && Buffer.byteLength(frame) > max) throw new RangeError(`SSE : événement de plus de ${max} octets refusé`);
+		if (this.#target.write(frame)) return void 0;
+		if (this.#drain === null) {
+			this.#drain = new Promise((resolve) => {
+				this.#releaseDrain = resolve;
+			});
+			this.#target.once("drain", this.#onDrain);
+			if (this.#stallTimeout !== false) {
+				this.#stall = setTimeout(this.#onStall, this.#stallTimeout);
+				this.#stall.unref();
+			}
+		}
+		return this.#drain;
+	}
+	#settleDrain() {
+		if (this.#stall !== null) {
+			clearTimeout(this.#stall);
+			this.#stall = null;
+		}
+		const release = this.#releaseDrain;
+		this.#drain = null;
+		this.#releaseDrain = null;
+		release?.();
+	}
+	/** Fin du flux : minuteur, écouteurs et attentes libérés, une seule fois. */
+	#finish() {
+		if (this.#closed) return;
+		this.#closed = true;
+		this.#response.removeListener("close", this.#onResponseClose);
+		this.#target.removeListener("drain", this.#onDrain);
+		if (this.#heartbeat !== null) {
+			clearInterval(this.#heartbeat);
+			this.#heartbeat = null;
+		}
+		if (this.#lifetime !== null) {
+			clearTimeout(this.#lifetime);
+			this.#lifetime = null;
+		}
+		if (this.#revalidate !== null) this.#context.httpKernel?.unwatchStream(this);
+		this.#settleDrain();
+		const listeners = this.#onClose;
+		this.#onClose = null;
+		if (listeners !== null) for (const listener of listeners) listener();
+	}
+};
+/**
+* Le client accepte-t-il un flux d'événements ? Lit l'en-tête `Accept`.
+*
+* Un même `POST` répond en JSON ou en flux selon ce que demande le client
+* (porte MCP) : c'est cette fonction qui tranche, et elle seule. Une plage
+* `q=0` est un REFUS explicite (RFC 9110 §12.4.2) ; `*\/*` ne suffit pas — un
+* client qui ne nomme pas le flux ne sait pas le lire.
+*
+* @param accept - valeur de l'en-tête `Accept`, absente ou multiple.
+* @returns `true` quand `text/event-stream` est nommé avec un poids non nul.
+*/
+function acceptsEventStream(accept) {
+	if (accept === void 0) return false;
+	const value = Array.isArray(accept) ? accept.join(",") : accept;
+	for (const range of value.split(",")) {
+		const [type, ...params] = range.split(";");
+		if (type?.trim().toLowerCase() !== "text/event-stream") continue;
+		const q = params.map((p) => p.trim().toLowerCase()).find((p) => p.startsWith("q="));
+		if (q === void 0 || Number.parseFloat(q.slice(2)) > 0) return true;
+	}
+	return false;
+}
+/**
+* Ouvre un flux d'événements sur la réponse d'un contexte HTTP.
+*
+* Sauve la session d'abord — ses cookies partent avec les en-têtes, qu'on ne
+* pourra plus toucher —, puis écrit les en-têtes du flux et désarme le délai
+* d'inactivité de la requête.
+*
+* @param context - le contexte de la requête, pas encore répondu.
+* @param options - battement de cœur, délai `retry:` initial.
+* @returns le flux ouvert, ou sa promesse quand une session est à sauver.
+* @throws HttpError 500 quand la réponse est déjà partie.
+* @throws HttpError 429 quand l'IP du client a déjà tous ses flux et sockets
+*   (`wsMaxConnectionsPerIp`) — refusé AVANT d'écrire quoi que ce soit.
+* @throws RangeError quand un délai n'est ni `false` ni un entier entre 1 et
+*   2^31-1, ou que `maxEventBytes` n'est pas un entier positif.
+*/
+function openSseStream(context, options = {}) {
+	checkTimer("heartbeat", options.heartbeat);
+	checkTimer("stallTimeout", options.stallTimeout);
+	checkTimer("maxDuration", options.maxDuration);
+	const maxEventBytes = options.maxEventBytes ?? 1048576;
+	if (!Number.isInteger(maxEventBytes) || maxEventBytes < 1) throw new RangeError("SSE : maxEventBytes entier positif attendu");
+	if (context.sended || context.finished || context.response.isHeaderSent()) throw new HttpError("SSE : la réponse est déjà partie", 500, context);
+	const kernel = context.httpKernel;
+	const nodeResponse = context.response.response;
+	if (kernel !== null && nodeResponse !== null && !kernel.acquireConnectionSlot(context.request.request, nodeResponse)) throw new HttpError("SSE : trop de connexions ouvertes depuis cette adresse", 429, context);
+	const revalidate = kernel?.firewall?.currentRevalidator?.() ?? null;
+	const identifier = revalidate === null ? null : RequestContext.getAuthenticatedUser()?.identifier ?? null;
+	const settings = {
+		heartbeat: options.heartbeat ?? 15e3,
+		stallTimeout: options.stallTimeout ?? 3e4,
+		maxEventBytes,
+		maxDuration: options.maxDuration ?? false,
+		revalidate,
+		identifier
+	};
+	context.sended = true;
+	if (context.session != null) return context.saveSession().catch((e) => {
+		context.log(e, "ERROR", "SESSION-STORE");
+		return null;
+	}).then(() => startSseStream(context, options, settings));
+	return startSseStream(context, options, settings);
+}
+/** En-têtes, désarmement du délai, puis le flux. */
+function startSseStream(context, options, settings) {
+	const response = context.response;
+	const nodeResponse = response.response;
+	if (nodeResponse === null) throw new HttpError("SSE : réponse introuvable", 500, context);
+	const stream = response instanceof Http2Response ? response.stream : null;
+	const h1 = nodeResponse instanceof http.ServerResponse ? nodeResponse : null;
+	let target;
+	if (stream !== null) target = stream;
+	else if (h1 !== null) target = h1;
+	else throw new HttpError("SSE : transport de réponse inconnu", 500, context);
+	response.setHeaders({
+		"Content-Type": "text/event-stream; charset=utf-8",
+		"Cache-Control": "no-cache, no-transform",
+		"X-Accel-Buffering": "no"
+	});
+	context.writeHead(200);
+	if (stream !== null) stream.setTimeout(0);
+	else if (h1 !== null) {
+		h1.flushHeaders();
+		h1.socket?.setTimeout(0);
+	}
+	const sse = new SseStream(context, target, nodeResponse, settings);
+	if (settings.revalidate !== null) context.httpKernel?.watchStream(sse);
+	if (options.retry !== void 0) sse.retry(options.retry);
+	return sse;
+}
+export { SSE_HEARTBEAT_MS, SSE_MAX_EVENT_BYTES, SSE_STALL_TIMEOUT_MS, SseStream, acceptsEventStream, openSseStream };