@nodefony/http 10.0.0-beta.6 → 10.0.0-beta.7

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

@@ -8,8 +8,8 @@ var Parser = class {
 	chunks;
 	received = 0;
 	aborted = false;
-	overflow = null;
-	onOverflow = null;
+	failure = null;
+	onFailure = null;
 	constructor(request) {
 		this.request = request;
 		this.chunks = [];
@@ -22,33 +22,51 @@ var Parser = class {
 		const max = this.request.maxBodySize;
 		this.received += buffer.length;
 		if (max > 0 && this.received > max) {
-			this.aborted = true;
-			this.chunks.length = 0;
-			this.overflow = new HttpError(`Request body exceeds maxBodySize (${max} bytes)`, 413, this.request.context);
-			this.request.request.pause?.();
-			if (this.onOverflow) this.onOverflow(this.overflow);
+			this.fail(new HttpError(`Request body exceeds maxBodySize (${max} bytes)`, 413, this.request.context));
 			return buffer;
 		}
 		this.chunks.push(buffer);
 		return buffer;
 	}
 	/**
+	* Interrompt la réception du corps : `parse()` rejette avec `error`, que
+	* l'interruption survienne avant ou pendant l'attente de la fin du flux.
+	*
+	* La RAM déjà bufferisée est libérée et la lecture du flux suspendue ; la
+	* réponse d'erreur peut encore partir. Sans effet si le corps est déjà
+	* entièrement reçu, ou déjà interrompu.
+	*
+	* @param error - la cause rendue au client (413 dépassement, 408 délai)
+	* @returns vrai si la réception a été interrompue
+	*/
+	fail(error) {
+		const req = this.request.request;
+		if (this.aborted || req.readableEnded === true || req.complete === true) return false;
+		this.aborted = true;
+		this.chunks.length = 0;
+		this.failure = error;
+		req.pause?.();
+		if (this.onFailure) this.onFailure(error);
+		return true;
+	}
+	/**
 	* Résout quand le flux requête est **entièrement reçu** (`end`). No-op si déjà
 	* terminé (corps vide / déjà drainé) → pas de hang d'un `once("end")` tardif.
 	* Indispensable avant de concaténer les chunks pour un corps à décoder
 	* (JSON…) : sinon on lit un buffer encore incomplet. (formidable drainait via
 	* son `await form.parse()` ; ses remplaçants doivent drainer explicitement.)
-	* Rejette en 413 si le corps dépasse `maxBodySize` (avant ou pendant l'attente).
+	* Rejette avec la cause de {@link Parser.fail} (413 dépassement de
+	* `maxBodySize`, 408 délai de réception), avant ou pendant l'attente.
 	*/
 	ended() {
-		if (this.overflow) return Promise.reject(this.overflow);
+		if (this.failure) return Promise.reject(this.failure);
 		const req = this.request.request;
 		return new Promise((resolve, reject) => {
 			if (req.readableEnded || req.complete) return resolve();
 			const cleanup = () => {
 				req.removeListener("end", onEnd);
 				req.removeListener("error", onError);
-				this.onOverflow = null;
+				this.onFailure = null;
 			};
 			const onEnd = () => {
 				cleanup();
@@ -58,7 +76,7 @@ var Parser = class {
 				cleanup();
 				reject(e instanceof Error ? e : new Error(String(e)));
 			};
-			this.onOverflow = (err) => {
+			this.onFailure = (err) => {
 				cleanup();
 				reject(err);
 			};

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

@@ -0,0 +1,56 @@
+import { HOP_BY_HOP } from "../../proxy/forward.js";
+import { Readable } from "node:stream";
+// nodefony/src/context/http/webResponse.ts
+/**
+* En-têtes qu'une réponse RELAYÉE (issue de `fetch`) ne garde pas. Son corps a
+* déjà été DÉCODÉ par `fetch` : `content-encoding` et `content-length`
+* décrivent encore les octets compressés de l'amont, et les recopier
+* annoncerait un corps qui n'est pas celui qu'on envoie. Ses cookies
+* appartiennent à l'amont : les relayer les poserait sous le domaine de
+* l'application.
+*/
+const UPSTREAM_ONLY = /* @__PURE__ */ new Set([
+	"content-encoding",
+	"content-length",
+	"set-cookie"
+]);
+/** Corps d'une `Response` sans corps (`new Response(null, { status: 204 })`). */
+const emptyBody = () => Readable.from([], { objectMode: false });
+/**
+* Traduit une `Response` Web standard en statut, en-têtes et corps pour le flux
+* d'octets — sans la lire : le corps reste un flux.
+*
+* Deux origines, deux règles, que `response.type` distingue :
+* - **construite par l'application** (`new Response(…)`, `Response.json(…)`,
+*   `Response.redirect(…)` — `type === "default"`) : ses en-têtes sont les
+*   siens, cookies compris (`getSetCookie()`), et partent tels quels ;
+* - **relayée** (issue de `fetch` — `"basic"`, `"cors"`…) : `content-encoding`,
+*   `content-length` et `set-cookie` de l'amont sont écartés (voir
+*   `UPSTREAM_ONLY`).
+*
+* Les en-têtes de connexion (RFC 9110 §7.6.1 — la liste du relais,
+* `HOP_BY_HOP`) ne partent jamais : ils décrivent un saut, et HTTP/2 les
+* refuse.
+*
+* @param response - une `Response` dont le corps n'a pas été consommé.
+* @returns statut, en-têtes filtrés et corps.
+*/
+function webResponseParts(response) {
+	const relayed = response.type !== "default";
+	const headers = {};
+	for (const [name, value] of response.headers) {
+		if (name === "set-cookie" || HOP_BY_HOP.has(name)) continue;
+		if (relayed && UPSTREAM_ONLY.has(name)) continue;
+		headers[name] = value;
+	}
+	if (!relayed) {
+		const cookies = response.headers.getSetCookie();
+		if (cookies.length > 0) headers["set-cookie"] = cookies;
+	}
+	return {
+		status: response.status,
+		headers,
+		source: response.body ?? emptyBody()
+	};
+}
+export { webResponseParts };

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

@@ -1,4 +1,5 @@
 import HttpResponse from "../http/Response.js";
+import { closeStreamAfterGrace } from "../../servers/http2StreamGrace.js";
 import { thenMaybe } from "nodefony";
 import http from "node:http";
 import http2 from "node:http2";
@@ -69,16 +70,13 @@ var Http2Response = class extends HttpResponse {
 					if (this.statusCode > 599) this.statusCode = 500;
 				}
 				this.statusMessage = this.getStatusMessage();
+				this.putCorrelationHeaders();
 				this.setLength();
 				this.ensureContentTypeHeader();
 				this.applyHeaderPolicy(this.contentTypeForPolicy());
 				this.headers = mergeResponseHeaders(this.statusMessage, this.response ?? emptyHeaders, headers, this.headerList());
 				this.headers[HTTP2_HEADER_STATUS] = this.statusCode;
-				const requestId = this.context.requestId;
-				if (requestId) this.headers["x-request-id"] = requestId;
-				const traceparent = this.context.traceparent;
-				if (traceparent) this.headers["traceparent"] = traceparent;
-				this.stream.respond(this.headers, { endStream: false });
+				this.stream.respond(this.headers, { endStream: this.headers["grpc-status"] !== void 0 });
 			} else this.log("Headers already sent !!", "WARNING");
 		} else return super.writeHead(statusCode, headers);
 	}
@@ -130,8 +128,9 @@ var Http2Response = class extends HttpResponse {
 		return super.end(chunk, encoding);
 	}
 	/**
-	* Termine la réponse de compatibilité d'un HEAD, dont Node a clos le flux de
-	* lui-même au `respond()`.
+	* Termine la réponse de compatibilité d'un HEAD, ou d'une réponse gRPC
+	* _Trailers-Only_ (statut gRPC dans les en-têtes), dont le flux s'est clos
+	* au `respond()`.
 	*
 	* Sans ce geste, `Http2ServerResponse` n'émet ni `finish` ni `close` : le
 	* démontage de la requête, branché sur ce `close` (ligne d'accès, profil,
@@ -142,7 +141,7 @@ var Http2Response = class extends HttpResponse {
 	*/
 	settleHeadResponse() {
 		const raw = this.response;
-		if (raw !== null && this.context.method === "HEAD" && this.stream?.destroyed === false && !raw.writableEnded) raw.end();
+		if (raw !== null && (this.context.method === "HEAD" || this.headers["grpc-status"] !== void 0) && this.stream?.destroyed === false && !raw.writableEnded) raw.end();
 	}
 	getStatusMessage(code) {
 		if (code) {
@@ -157,5 +156,45 @@ var Http2Response = class extends HttpResponse {
 			message: ""
 		};
 	}
+	/**
+	* Règle le sort d'un corps non lu quand la réponse part avant qu'il soit
+	* consommé (408 délai, 413 trop gros, refus précoce) : les octets en tampon
+	* sont jetés, puis — une fois la réponse écrite — le flux est fermé en
+	* `NO_ERROR` si le client ÉMET ENCORE.
+	*
+	* RFC 9113 §8.1 : après une réponse complète, le serveur PEUT demander au
+	* client d'arrêter d'émettre par un `RST_STREAM` `NO_ERROR`. `node:http2` ne
+	* le fait pas : le flux resterait ouvert tant que le client émet, et un
+	* client lent garderait sa place de flux sur la session. Attendre `finish`
+	* (fin d'écriture) garantit que la réponse elle-même n'est pas tronquée.
+	*
+	* « Émet encore » se décide après une GRÂCE d'un aller-retour
+	* ({@link closeStreamAfterGrace} : un `PING` par session pour tous les
+	* flux qui attendent, puis l'état du flux). Fini → le flux se ferme seul,
+	* sans `RST_STREAM` ; sinon — client qui émet encore, ou muet — fermé.
+	* Jamais de coupe avant la grâce : un `RST_STREAM` soumis pendant que la
+	* réponse attend dans la file de nghttp2 la fait jeter, et le client reçoit
+	* une fin de flux sans statut. grpc-go, Go `net/http2` et nginx coupent AUSSITÔT : Node, lui,
+	* répond avant de lire les trames DATA déjà en route, et la coupe
+	* immédiate frappait des clients qui finissaient d'émettre — le client
+	* HTTP/2 de Go la lit en erreur (ADR-0026 D13 point 1, constaté par la
+	* suite de conformité de Connect). `request.complete` ne dit rien ici : il
+	* ne passe à `true` qu'une fois le corps CONSOMMÉ.
+	*
+	* Chemin d'erreur seulement : un `PING` par aller-retour et par session,
+	* quel que soit le nombre de refus en attente.
+	*
+	* Sans effet si le corps est entièrement consommé, ou le flux déjà fermé.
+	* Peut s'appeler avant comme après l'écriture de la réponse.
+	*/
+	closeUnfinishedRequest() {
+		const stream = this.stream;
+		if (stream === null || stream.closed || stream.destroyed) return;
+		const request = this.context.request.request;
+		if (request.complete) return;
+		request.resume();
+		if (stream.writableFinished) closeStreamAfterGrace(stream);
+		else stream.once("finish", () => closeStreamAfterGrace(stream));
+	}
 };
 export { Http2Response as default, mergeResponseHeaders };

package/dist/nodefony/src/context/requestTrace.js

@@ -1,3 +1,4 @@
+import { rpcOutcomeOf } from "./rpcOutcome.js";
 import diagnosticsChannel from "node:diagnostics_channel";
 // nodefony/src/context/requestTrace.ts
 /**
@@ -46,7 +47,8 @@ function openRequestTrace(context, protocol) {
 		module: null,
 		statusCode: null,
 		durationMs: null,
-		error: null
+		error: null,
+		rpc: null
 	};
 	context.requestTrace = trace;
 	return trace;
@@ -82,8 +84,9 @@ function runTraced(trace, fn, thisArg, ...args) {
 * @param context - le contexte de la requête
 * @param statusCode - le statut rendu au client, `null` s'il n'y en a pas eu
 * @param error - l'exception attrapée par le pipeline, `null` ou `undefined` sinon
+* @param rpc - l'appel RPC de la requête, `null` hors RPC : copié, jamais publié tel quel
 */
-function closeRequestTrace(context, statusCode, error) {
+function closeRequestTrace(context, statusCode, error, rpc = null) {
 	const trace = context.requestTrace;
 	if (trace === null) return;
 	context.requestTrace = null;
@@ -93,6 +96,7 @@ function closeRequestTrace(context, statusCode, error) {
 	trace.routePath = path === void 0 ? null : path === "" ? "/" : path;
 	trace.module = context.logModule ?? route?.module?.name ?? null;
 	trace.statusCode = statusCode;
+	trace.rpc = rpcOutcomeOf(rpc);
 	trace.durationMs = context.stopClock();
 	if (error !== null && error !== void 0) {
 		trace.error = error;

package/dist/nodefony/src/context/rpcOutcome.js

@@ -0,0 +1,20 @@
+// nodefony/src/context/rpcOutcome.ts
+/**
+* Copie le résultat d'un appel RPC — les quatre champs, jamais la fiche
+* d'appel entière, qui porte le contrôleur et le contexte (ADR-0026 D10). La
+* forme est fixe : un objet par appel, alloué seulement par qui publie (audit
+* JSON, canal de traçage avec abonné).
+*
+* @param call - l'appel RPC de la requête, `null` hors RPC.
+* @returns sa copie, `null` hors RPC.
+*/
+function rpcOutcomeOf(call) {
+	if (call === null) return null;
+	return {
+		system: call.system,
+		method: call.method,
+		code: call.code,
+		codeName: call.codeName
+	};
+}
+export { rpcOutcomeOf };

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

@@ -194,13 +194,23 @@ var WebsocketResponse = class {
 	handshakeHeaders = null;
 	/**
 	* Retient un en-tête du handshake (cf {@link handshakeHeaders}) ; sans effet
-	* une fois la socket ouverte, où il n'y a plus de réponse HTTP.
+	* une fois la socket ouverte, où il n'y a plus de réponse HTTP — sauf
+	* `Retry-After` posé par une action invoquée par le pont `api.request` : il
+	* va au puits de CETTE invocation, et le pont le sert avec le refus. Le même
+	* code de contrôleur dit donc « réessaie dans N s » sur les deux transports.
+	* Seul cet en-tête passe : un `Set-Cookie` ou un `WWW-Authenticate` n'a
+	* aucun sens sur une trame, et rien d'autre ne doit fuir par là.
 	*
 	* @param name - nom de l'en-tête
 	* @param value - valeur
 	* @returns toujours `true`
 	*/
 	setHeader(name, value) {
+		const sink = RequestContext.get()?.renderSink;
+		if (sink) {
+			if (name.toLowerCase() === "retry-after" && typeof value !== "object") sink.retryAfter = String(value);
+			return true;
+		}
 		if (this.connection !== null) return true;
 		this.handshakeHeaders ??= {};
 		this.handshakeHeaders[name] = typeof value === "object" ? value.join(", ") : value;

package/dist/nodefony/src/context/websocket/WebsocketContext.js

@@ -107,7 +107,7 @@ function handshakeRefusalStatus(context, error) {
 * le gate court-circuite AVANT toute allocation/concat (0 surcoût hot path).
 */
 let wsContentLogging = null;
-var WebsocketContext = class extends Context {
+var WebsocketContext = class WebsocketContext extends Context {
 	request;
 	response = null;
 	acceptedProtocol;
@@ -297,7 +297,7 @@ var WebsocketContext = class extends Context {
 	}
 	async send(data, encoding) {
 		if (this.response) {
-			const payload = data ?? this.response.body;
+			const payload = data ?? WebsocketContext.takeRenderedBody(this.response);
 			const sink = RequestContext.get()?.renderSink;
 			if (sink) {
 				sink.body = payload;
@@ -310,9 +310,21 @@ var WebsocketContext = class extends Context {
 		}
 		throw new Error("No response found");
 	}
+	/**
+	* Rend le corps rendu (`setBody`) en le RETIRANT de la réponse : une trame
+	* envoyée n'a plus à vivre aussi longtemps que la connexion.
+	*
+	* @param response - la réponse de ce contexte
+	* @returns le corps rendu, ou `null` s'il n'y en a pas
+	*/
+	static takeRenderedBody(response) {
+		const body = response.body;
+		response.body = null;
+		return body;
+	}
 	broadcast(data, encoding) {
 		if (this.response) {
-			const payload = data ?? this.response.body;
+			const payload = data ?? WebsocketContext.takeRenderedBody(this.response);
 			if (payload) {
 				this.logMessageContent("BROADCAST", payload);
 				this.fire("onMessage", payload, this, "BROADCAST");
@@ -451,7 +463,6 @@ var WebsocketContext = class extends Context {
 		this.webSocketState = "message";
 		const message = isBinary ? data : data.toString();
 		this.logMessageContent("RECEIVE", message);
-		if (this.response) this.response.body = Buffer.isBuffer(data) ? data : Buffer.from(data);
 		try {
 			if (!this.resolver) this.resolver = this.router?.resolve(this) ?? null;
 			else this.resolver.match(this.resolver.route, this);

package/dist/nodefony/src/cookies/cookie.js

@@ -1,7 +1,7 @@
 import { extend } from "nodefony";
-import crypto from "node:crypto";
 import { parseCookie, stringifySetCookie } from "cookie";
 import MS from "ms";
+import crypto from "node:crypto";
 // nodefony/src/cookies/cookie.ts
 const encode = encodeURIComponent;
 /**
@@ -43,6 +43,7 @@ function cookiesParser(context) {
 			if (cookies) {
 				const obj = parseCookie(cookies, RAW_VALUES);
 				for (const cookie in obj) {
+					if (cookie === "") continue;
 					co = new Cookie(cookie, obj[cookie]);
 					context.addRequestCookie(co);
 				}
@@ -54,6 +55,7 @@ function cookiesParser(context) {
 			if (cookieHeader) {
 				const parsed = parseCookie(cookieHeader, RAW_VALUES);
 				for (const name in parsed) {
+					if (name === "") continue;
 					co = new Cookie(name, parsed[name]);
 					context.addRequestCookie(co);
 				}

package/dist/nodefony/src/errors/httpError.js

@@ -1,41 +1,51 @@
 import { clc, nodefonyError } from "nodefony";
 // nodefony/src/errors/httpError.ts
-const exclude = {
-	context: true,
-	resolver: true,
-	container: true,
-	secure: true,
-	request: true,
-	response: true
-};
+/** Références vivantes (circulaires) jamais sérialisées, quel que soit l'environnement. */
+const EXCLUDED_KEYS = /* @__PURE__ */ new Set([
+	"context",
+	"resolver",
+	"container",
+	"secure",
+	"request",
+	"response"
+]);
+/**
+* Sérialise les propriétés propres d'une erreur HTTP, sans jamais LIRE celles
+* qu'on écarte.
+*
+* Ne pas lire compte : `stack` est un accesseur paresseux de V8, et sa première
+* lecture FORMATE la pile (`prepareStackTrace`, plusieurs µs). Lire puis
+* supprimer, c'est payer ce formatage pour le jeter — ce que faisait le rendu
+* d'erreur en production, sur chaque 404.
+*
+* @param error - l'erreur à sérialiser (en pratique un `HttpError`).
+* @param omit - clés à écarter EN PLUS des références vivantes, ou `null`.
+* @returns un objet plat, prêt pour `JSON.stringify`.
+*/
+function serializeHttpError(error, omit = null) {
+	const alt = {};
+	for (const key of Object.getOwnPropertyNames(error)) {
+		if (EXCLUDED_KEYS.has(key) || omit?.has(key)) continue;
+		alt[key] = Reflect.get(error, key);
+	}
+	return alt;
+}
 const jsonHttpError = {
 	configurable: true,
 	writable: true,
 	value() {
-		const alt = {};
-		const storeKey = function(key) {
-			if (key in exclude) return;
-			alt[key] = this[key];
-		};
-		Object.getOwnPropertyNames(this).forEach(storeKey, this);
-		return alt;
+		return serializeHttpError(this);
 	}
 };
-var HttpError = class extends nodefonyError {
-	context;
-	response;
-	request;
+var HttpError = class HttpError extends nodefonyError {
 	url;
 	controller;
 	action;
 	jsonResponse;
 	constructor(message, code, context) {
 		super(message, code);
-		this.context = context;
 		const res = context?.response;
-		this.response = res ?? void 0;
-		this.request = context?.request ?? void 0;
-		this.url = this.context?.url;
+		this.url = context?.url;
 		if (res && code) res.statusCode = code;
 		if (!this.message && res) this.message = res.body?.toString() || res.statusMessage || res.getStatusMessage();
 		const resolver = context?.resolver;
@@ -43,8 +53,31 @@ var HttpError = class extends nodefonyError {
 		this.action = resolver?.actionName ?? void 0;
 		if (res) this.jsonResponse = `${res.statusCode} ${res.statusMessage}`.trim();
 	}
+	/**
+	* Construit un VERDICT de protocole (404, 405, 426…) sans capturer de pile.
+	*
+	* La pile d'un verdict pointe toujours au même endroit du noyau ou du routeur
+	* et ne dit rien de la requête ; la capturer coûte ~3,6 µs à profondeur
+	* réelle (`micro-error-path.mjs`), payés par chaque requête d'un scanner.
+	* Réservé à ce que le framework DÉCIDE — une panne garde sa pile. `stack` ne
+	* porte que l'en-tête (`HttpError: Not Found`).
+	*
+	* @param message - message du verdict.
+	* @param code - statut HTTP (ou code de fermeture WebSocket).
+	* @param context - contexte de la requête, comme pour le constructeur.
+	* @returns l'erreur, sans pile.
+	*/
+	static withoutStack(message, code, context) {
+		const limit = Error.stackTraceLimit;
+		Error.stackTraceLimit = 0;
+		try {
+			return new HttpError(message, code, context);
+		} finally {
+			Error.stackTraceLimit = limit;
+		}
+	}
 	toString() {
-		if (this.context) return `${clc.red(this.message)}
+		if (this.url !== void 0) return `${clc.red(this.message)}
     ${clc.blue("Name :")} ${this.name}
     ${clc.blue("Type :")} ${this.errorType}
     ${clc.green("Controller :")} ${this.controller}
@@ -65,4 +98,4 @@ var HttpError = class extends nodefonyError {
 	}
 };
 Object.defineProperty(HttpError.prototype, "toJSON", jsonHttpError);
-export { HttpError as default };
+export { HttpError as default, serializeHttpError };

package/dist/nodefony/src/grpc/cors.js

@@ -0,0 +1,59 @@
+import { hasGrpcRoutes } from "./refusal.js";
+// nodefony/src/grpc/cors.ts
+/**
+* Les listes de Connect (`cors` de `@connectrpc/connect`, `connect-cors.md`),
+* recopiées : `@nodefony/http` principal ne charge jamais Connect, pair
+* facultatif (ADR-0026 D12). La copie est COMPARÉE à l'original par un test
+* (`grpcCors.test.ts`) : une version de Connect qui change ses listes le fait
+* tomber.
+*/
+const GRPC_CORS = Object.freeze({
+	allowedMethods: Object.freeze(["POST", "GET"]),
+	allowedHeaders: Object.freeze([
+		"Content-Type",
+		"Connect-Protocol-Version",
+		"Connect-Timeout-Ms",
+		"Connect-Content-Encoding",
+		"Connect-Accept-Encoding",
+		"Content-Encoding",
+		"Accept-Encoding",
+		"Grpc-Message-Type",
+		"X-Grpc-Web",
+		"X-User-Agent",
+		"Grpc-Timeout"
+	]),
+	exposedHeaders: Object.freeze([
+		"Grpc-Status",
+		"Grpc-Message",
+		"Grpc-Status-Details-Bin",
+		"Content-Encoding",
+		"Connect-Content-Encoding"
+	])
+});
+/**
+* `Access-Control-Expose-Headers` d'une réponse RPC, composé une fois au
+* chargement.
+*/
+const RPC_EXPOSED_HEADERS = GRPC_CORS.exposedHeaders.join(", ");
+/**
+* Les listes CORS que demandent les protocoles RPC — dès qu'un service gRPC
+* est déclaré dans le processus, `null` sinon. Le pare-feu les ajoute à la
+* politique de l'application au démarrage (`onReady`) : le préflight ne
+* connaît pas la route, l'union est la seule voie (ADR-0026 D9 point 2).
+*
+* @returns les listes, ou `null` sans service gRPC déclaré.
+* @experimental Surface gRPC, ADR-0026 D11.
+*/
+function rpcCorsLists() {
+	return hasGrpcRoutes() ? GRPC_CORS : null;
+}
+/**
+* Les listes de Connect telles que recopiées, sans condition — réservé au test
+* qui les compare à l'original.
+*
+* @internal
+*/
+function grpcCorsCopy() {
+	return GRPC_CORS;
+}
+export { RPC_EXPOSED_HEADERS, grpcCorsCopy, rpcCorsLists };

package/dist/nodefony/src/grpc/limits.js

@@ -0,0 +1,16 @@
+// nodefony/src/grpc/limits.ts
+/**
+* Borne par défaut d'un message gRPC, reçu ou émis : 4 Mio (ADR-0026 D4,
+* points 1 et 2). C'est la borne de réception des implémentations de
+* référence (`grpc-js`, `grpc-go`) ; l'adaptateur Connect, lui, n'en pose
+* aucune (`limit-io.js` : `0xffffffff`). Seule source de cette valeur : le
+* schéma de la section `grpc` et le point d'entrée gRPC la lisent ici.
+*/
+const GRPC_DEFAULT_MAX_MESSAGE_BYTES = 4194304;
+/**
+* Plus grande borne qu'accepte l'adaptateur Connect pour `readMaxBytes` et
+* `writeMaxBytes` (`limit-io.js#validateReadWriteMaxBytes`) : la longueur
+* d'une enveloppe tient sur 32 bits.
+*/
+const GRPC_MAX_MESSAGE_BYTES = 4294967295;
+export { GRPC_DEFAULT_MAX_MESSAGE_BYTES, GRPC_MAX_MESSAGE_BYTES };