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

package/dist/_virtual/{_@oxc-project_runtime@0.157.0 → _@oxc-project_runtime@0.158.0}/helpers/esm/decorate.js

@@ -1,4 +1,4 @@
-// \0@oxc-project+runtime@0.157.0/helpers/esm/decorate.js
+// \0@oxc-project+runtime@0.158.0/helpers/esm/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);

package/dist/_virtual/{_@oxc-project_runtime@0.157.0 → _@oxc-project_runtime@0.158.0}/helpers/esm/decorateParam.js

@@ -1,4 +1,4 @@
-// \0@oxc-project+runtime@0.157.0/helpers/esm/decorateParam.js
+// \0@oxc-project+runtime@0.158.0/helpers/esm/decorateParam.js
 function __decorateParam(paramIndex, decorator) {
 	return function(target, key) {
 		decorator(target, key, paramIndex);

package/dist/index.js

@@ -5,7 +5,7 @@ import { RedisIdempotencyStore } from "./nodefony/src/RedisIdempotencyStore.js";
 import { scheduleIdempotencyGc } from "./nodefony/src/idempotencyGc.js";
 import router_default, { FRAMEWORK_ROUTER, isFrameworkRouter } from "./nodefony/service/router.js";
 import Route from "./nodefony/src/Route.js";
-import Controller, { configureFileServing } from "./nodefony/src/Controller.js";
+import Controller, { configureFileServing, contentDisposition } from "./nodefony/src/Controller.js";
 import ResourceController from "./nodefony/src/ResourceController.js";
 import Resolver from "./nodefony/src/Resolver.js";
 import AdminBroker_default from "./nodefony/service/AdminBroker.js";
@@ -28,7 +28,7 @@ import { buildPlaygroundSnapshot } from "./nodefony/src/PlaygroundAdminApi.js";
 import { createSyslogAdminApi } from "./nodefony/src/SyslogAdminApi.js";
 import Eta from "./nodefony/service/Eta.js";
 import { All, Anonymous, Body, BypassFirewall, Cookie, Csp, CsrfExempt, CsrfProtect, CurrentUser, Delete, Domain, Get, Head, Header, Headers, HttpCode, Idempotent, IsGranted, Options, Param, Patch, Post, Put, Query, Redirect, Req, RequireAuthentication, RequireScope, Res, Scope, Session, UploadedFile, UploadedFiles, UseSession, buildContextParamArgs, controller, controllers, getParamArgsMeta, getRouteSchema, route, routeExpectsBodyStream } from "./nodefony/decorators/routerDecorators.js";
-import __decorate from "./_virtual/_@oxc-project_runtime@0.157.0/helpers/esm/decorate.js";
+import __decorate from "./_virtual/_@oxc-project_runtime@0.158.0/helpers/esm/decorate.js";
 import { validateRouteInput } from "./nodefony/src/routeSchema.js";
 import path from "node:path";
 import { AUTO_STORE, EMPTY_INFRA, Module, durableStoreRemedy, readStoreConnector, readStoreLocation, resolveAutoStore, services, storeConnectivity } from "nodefony";
@@ -208,4 +208,4 @@ Framework = __decorate([services([
 	IdempotencyStore_default
 ])], Framework);
 var framework_default = Framework;
-export { AdminApiController, AdminBroker_default as AdminBroker, All, Anonymous, ApiKeyController, BenchController, Body, BypassFirewall, Controller, Cookie, Csp, CspReportController, CsrfExempt, CsrfProtect, CurrentUser, Delete, Domain, Eta, FRAMEWORK_ROUTER, Get, Head, Header, Headers, HttpCode, Idempotent, IsGranted, IssuerMetadataController, LoginPageController, IdempotencyStore_default as MemoryIdempotencyStore, OAuth2Controller, Options, Param, Patch, Post, ProtectedResourceMetadataController, Put, Query, Redirect, Req, RequireAuthentication, RequireScope, Res, Resolver, ResourceController, Route, router_default as Router, Scope, Session, SessionAuthController, TokenAuthController, TotpController, UploadedFile, UploadedFiles, UseSession, WebAuthnController, buildContextParamArgs, buildPlaygroundSnapshot, collectProtectedResources, controller, controllers, createFrameworkAdminApi, createKernelAdminApi, createSyslogAdminApi, framework_default as default, defineFrameworkConfig, frameworkConfigJsonSchema, frameworkConfigSchema, getIdempotencyStoreFactory, getParamArgsMeta, getRouteSchema, isFrameworkRouter, listIdempotencyStores, mountApiKeyRoutes, mountBenchRoutes, mountCspReportRoute, mountIssuerMetadataRoutes, mountLoginPage, mountOAuth2Routes, mountProtectedResourceRoutes, mountSessionAuthRoutes, mountTokenAuthRoutes, mountTotpRoutes, mountWebAuthnRoutes, protectedResourceRoutePaths, registerIdempotencyStore, route, routeExpectsBodyStream, validateRouteInput };
+export { AdminApiController, AdminBroker_default as AdminBroker, All, Anonymous, ApiKeyController, BenchController, Body, BypassFirewall, Controller, Cookie, Csp, CspReportController, CsrfExempt, CsrfProtect, CurrentUser, Delete, Domain, Eta, FRAMEWORK_ROUTER, Get, Head, Header, Headers, HttpCode, Idempotent, IsGranted, IssuerMetadataController, LoginPageController, IdempotencyStore_default as MemoryIdempotencyStore, OAuth2Controller, Options, Param, Patch, Post, ProtectedResourceMetadataController, Put, Query, Redirect, Req, RequireAuthentication, RequireScope, Res, Resolver, ResourceController, Route, router_default as Router, Scope, Session, SessionAuthController, TokenAuthController, TotpController, UploadedFile, UploadedFiles, UseSession, WebAuthnController, buildContextParamArgs, buildPlaygroundSnapshot, collectProtectedResources, contentDisposition, controller, controllers, createFrameworkAdminApi, createKernelAdminApi, createSyslogAdminApi, framework_default as default, defineFrameworkConfig, frameworkConfigJsonSchema, frameworkConfigSchema, getIdempotencyStoreFactory, getParamArgsMeta, getRouteSchema, isFrameworkRouter, listIdempotencyStores, mountApiKeyRoutes, mountBenchRoutes, mountCspReportRoute, mountIssuerMetadataRoutes, mountLoginPage, mountOAuth2Routes, mountProtectedResourceRoutes, mountSessionAuthRoutes, mountTokenAuthRoutes, mountTotpRoutes, mountWebAuthnRoutes, protectedResourceRoutePaths, registerIdempotencyStore, route, routeExpectsBodyStream, validateRouteInput };

package/dist/nodefony/controller/CspReportController.js

@@ -1,8 +1,8 @@
 import router_default from "../service/router.js";
 import Controller from "../src/Controller.js";
 import { Body, CsrfExempt } from "../decorators/routerDecorators.js";
-import __decorateParam from "../../_virtual/_@oxc-project_runtime@0.157.0/helpers/esm/decorateParam.js";
-import __decorate from "../../_virtual/_@oxc-project_runtime@0.157.0/helpers/esm/decorate.js";
+import __decorateParam from "../../_virtual/_@oxc-project_runtime@0.158.0/helpers/esm/decorateParam.js";
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.158.0/helpers/esm/decorate.js";
 import { CSP_REPORT_MAX_BYTES, CSP_REPORT_PATH } from "nodefony";
 import { HttpError } from "@nodefony/http";
 // nodefony/controller/CspReportController.ts

package/dist/nodefony/controller/IssuerMetadataController.js

@@ -92,7 +92,7 @@ var IssuerMetadataController = class extends Controller {
 		try {
 			document = buildAuthorizationServerMetadata({ issuer });
 		} catch (error) {
-			this.log(`métadonnées d'émetteur impubliables : ${error.message}`, "CRITIC");
+			this.log(`métadonnées d'émetteur impubliables : ${error instanceof Error ? error.message : String(error)}`, "CRITIC");
 			return this.renderJson({ error: "server_error" }, 500);
 		}
 		return this.renderJson(document, 200, { "Cache-Control": "public, max-age=3600" });
@@ -110,7 +110,7 @@ var IssuerMetadataController = class extends Controller {
 		try {
 			keys = await publisher.getPublicJWKS();
 		} catch (error) {
-			this.log(`JWKS illisible : ${error.message}`, "CRITIC");
+			this.log(`JWKS illisible : ${error instanceof Error ? error.message : String(error)}`, "CRITIC");
 			return this.renderJson({ error: "server_error" }, 500);
 		}
 		return this.renderJson(keys, 200, { "Cache-Control": "public, max-age=300" });

package/dist/nodefony/controller/ProtectedResourceMetadataController.js

@@ -66,9 +66,10 @@ var ProtectedResourceMetadataController = class extends Controller {
 	/** Chemin bien connu demandé, tel que le Router l'a matché. */
 	#askedPath() {
 		const req = this.request;
-		const p = req?.pathname;
+		if (typeof req !== "object" || req === null) return null;
+		const p = "pathname" in req ? req.pathname : void 0;
 		if (typeof p === "string") return p;
-		const url = req?.url;
+		const url = "url" in req ? req.url : void 0;
 		if (url instanceof URL) return url.pathname;
 		if (typeof url === "string") try {
 			return new URL(url, "http://localhost").pathname;
@@ -112,7 +113,7 @@ var ProtectedResourceMetadataController = class extends Controller {
 		try {
 			document = buildProtectedResourceMetadata(match);
 		} catch (error) {
-			this.log(`métadonnées de ressource protégée impubliables : ${error.message}`, "CRITIC");
+			this.log(`métadonnées de ressource protégée impubliables : ${error instanceof Error ? error.message : String(error)}`, "CRITIC");
 			return this.renderJson({ error: "server_error" }, 500);
 		}
 		return this.renderJson(document, 200, { "Cache-Control": "public, max-age=3600" });
@@ -140,23 +141,87 @@ var ProtectedResourceMetadataController = class extends Controller {
 * interface à implémenter formellement — le même couplage que `tokenService` ou
 * `adminBroker`.
 *
+* Deux sources peuvent déclarer la MÊME ressource — une zone du pare-feu et la
+* porte MCP qu'elle couvre, typiquement — : elles sont fusionnées
+* ({@link mergeProtectedResources}), jamais départagées par leur ordre.
+*
 * @param container - conteneur de services de l'application
-* @returns les ressources déclarées, dans l'ordre des services
+* @returns les ressources déclarées, une entrée par ressource, dans l'ordre des
+*          services
 */
 function collectProtectedResources(container) {
 	const collected = [];
 	for (const name of container.keys()) {
 		const service = container.get(name);
-		if (typeof service?.publishedProtectedResources !== "function") continue;
+		if (typeof service !== "object" || service === null || !("publishedProtectedResources" in service) || typeof service.publishedProtectedResources !== "function") continue;
 		let declared;
 		try {
-			declared = service.publishedProtectedResources();
+			declared = Reflect.apply(service.publishedProtectedResources, service, []);
+		} catch {
+			continue;
+		}
+		if (!Array.isArray(declared)) continue;
+		for (const entry of declared) if (isProtectedResourceInput(entry)) collected.push(entry);
+	}
+	return mergeProtectedResources(collected);
+}
+/** Une liste de chaînes, ou rien. */
+function isStringList(value) {
+	return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+/**
+* Une déclaration a-t-elle la forme d'une ressource publiable ? Le contrat est
+* structurel ({@link IProtectedResourcePublisher}) : ce qu'un service rend se
+* VÉRIFIE, il ne se suppose pas.
+*/
+function isProtectedResourceInput(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if (!("resource" in value) || typeof value.resource !== "string") return false;
+	if (!("authorizationServers" in value) || !isStringList(value.authorizationServers)) return false;
+	return !("scopesSupported" in value) || value.scopesSupported === void 0 || isStringList(value.scopesSupported);
+}
+/** L'union de deux listes, dans l'ordre d'apparition. */
+function union(first, second) {
+	return [.../* @__PURE__ */ new Set([...first, ...second])];
+}
+/**
+* Une ressource, UN document : fusionne les déclarations d'une même ressource
+* (même URI canonique) — l'union de leurs serveurs d'autorisation et de leurs
+* scopes ; le premier nom et la première documentation déclarés.
+*
+* Pourquoi fusionner plutôt que garder la première : une zone du pare-feu
+* publie sa ressource avec les émetteurs de confiance, et la porte MCP qu'elle
+* couvre publie la MÊME ressource avec les scopes de ses outils. Garder la
+* première jetait les scopes sans un mot — et un agent qui suit le document
+* demandait alors un jeton sans eux, qui n'ouvrait pas l'outil.
+*
+* @param entries - déclarations, dans l'ordre des services
+* @returns une entrée par ressource, à la place de la première déclaration
+*/
+function mergeProtectedResources(entries) {
+	const merged = [];
+	const byResource = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		let key;
+		try {
+			key = canonicalResourceUri(entry.resource);
 		} catch {
+			merged.push(entry);
+			continue;
+		}
+		const seen = byResource.get(key);
+		if (seen === void 0) {
+			const first = { ...entry };
+			byResource.set(key, first);
+			merged.push(first);
 			continue;
 		}
-		for (const entry of declared) collected.push(entry);
+		seen.authorizationServers = union(seen.authorizationServers, entry.authorizationServers);
+		if (entry.scopesSupported !== void 0) seen.scopesSupported = union(seen.scopesSupported ?? [], entry.scopesSupported);
+		if (seen.resourceName === void 0 && entry.resourceName !== void 0) seen.resourceName = entry.resourceName;
+		if (seen.resourceDocumentation === void 0 && entry.resourceDocumentation !== void 0) seen.resourceDocumentation = entry.resourceDocumentation;
 	}
-	return collected;
+	return merged;
 }
 /**
 * Chemins bien connus à monter pour un jeu de ressources déclarées.
@@ -217,4 +282,4 @@ function mountProtectedResourceRoutes(frameworkModule, resources) {
 	mounted = true;
 	return paths.length;
 }
-export { collectProtectedResources, ProtectedResourceMetadataController as default, mountProtectedResourceRoutes, protectedResourceRoutePaths };
+export { collectProtectedResources, ProtectedResourceMetadataController as default, mergeProtectedResources, mountProtectedResourceRoutes, protectedResourceRoutePaths };

package/dist/nodefony/controller/SessionAuthController.js

@@ -1,7 +1,7 @@
 import { CsrfProtect } from "../decorators/routerDecorators.js";
 import router_default from "../service/router.js";
 import SecurityApiController from "../src/SecurityApiController.js";
-import __decorate from "../../_virtual/_@oxc-project_runtime@0.157.0/helpers/esm/decorate.js";
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.158.0/helpers/esm/decorate.js";
 import { AUTH_API_BASE } from "nodefony";
 // nodefony/controller/SessionAuthController.ts
 let mounted = false;

package/dist/nodefony/decorators/routerDecorators.js

@@ -97,6 +97,36 @@ function controllers(targets) {
 	};
 }
 /**
+* Applique à une route en cours de montage ce que la classe et la méthode
+* déclarent par décorateur : `@Domain` (hôte) et `@BypassFirewall`. Seule
+* implémentation de ces précédences — `@controller` et `@GrpcService` montent
+* leurs routes par elle.
+*
+* Précédences : `@route({ host })` > `@Domain` méthode > `@Domain` classe ;
+* option `bypassFirewall: true` > `@BypassFirewall` méthode > classe. Lecture
+* au montage, fail-closed : un oubli laisse la route gardée.
+*
+* @param ctor - la classe contrôleur.
+* @param options - les options de la route, complétées EN PLACE.
+* @param method - la méthode dont les décorateurs s'appliquent (celle du
+*   contrat pour une route gRPC, pas l'action de base).
+*
+* @internal
+*/
+function applyDeclaredRouteOptions(ctor, options, method) {
+	if (options.host === void 0) {
+		const methodDomain = method === void 0 ? void 0 : Reflect.getMetadata(DOMAIN_METHOD_METADATA, ctor, method);
+		const classDomain = Reflect.getMetadata(DOMAIN_CLASS_METADATA, ctor);
+		const domain = methodDomain ?? classDomain;
+		if (domain) options.host = domain;
+	}
+	if (options.bypassFirewall !== true) {
+		const methodBypass = method === void 0 ? void 0 : Reflect.getMetadata(BYPASS_FIREWALL_METHOD_METADATA, ctor, method);
+		const classBypass = Reflect.getMetadata(BYPASS_FIREWALL_CLASS_METADATA, ctor);
+		if (methodBypass === true || classBypass === true) options.bypassFirewall = true;
+	}
+}
+/**
 * Declaration Controller
 *
 * @param prefix - prefixage du router du controller.
@@ -124,17 +154,7 @@ function controller(prefix) {
 			let hasMagic = false;
 			for (const [name, options] of Object.entries(metadata)) {
 				options.prefix = prefix;
-				if (options.host === void 0) {
-					const methodDomain = options.classMethod === void 0 ? void 0 : Reflect.getMetadata(DOMAIN_METHOD_METADATA, mycontroller, options.classMethod);
-					const classDomain = Reflect.getMetadata(DOMAIN_CLASS_METADATA, mycontroller);
-					const domain = methodDomain ?? classDomain;
-					if (domain) options.host = domain;
-				}
-				if (options.bypassFirewall !== true) {
-					const methodBypass = options.classMethod === void 0 ? void 0 : Reflect.getMetadata(BYPASS_FIREWALL_METHOD_METADATA, mycontroller, options.classMethod);
-					const classBypass = Reflect.getMetadata(BYPASS_FIREWALL_CLASS_METADATA, mycontroller);
-					if (methodBypass === true || classBypass === true) options.bypassFirewall = true;
-				}
+				applyDeclaredRouteOptions(mycontroller, options, options.classMethod);
 				if (options.path === "*") {
 					hasMagic = {
 						options,
@@ -153,6 +173,72 @@ function controller(prefix) {
 function route(name, options) {
 	return defineRoute(name, options);
 }
+/** Plus long délai qu'un minuteur Node honore : au-delà, il tombe à 1 ms. */
+const MAX_TIMER_MS = 2147483647;
+/**
+* Valide l'option de route `responseTimeout` À LA DÉCLARATION : un entier de
+* 0 à 2³¹−1. Hors bornes, Node ramènerait le minuteur à 1 ms — chaque requête
+* de la route expirerait aussitôt, sans que rien ne dise pourquoi.
+*
+* @param value - l'option telle que déclarée (absente = celle du serveur).
+* @param className - classe du contrôleur, nommée dans l'erreur.
+* @param method - action, nommée dans l'erreur.
+* @returns la valeur validée, ou `undefined` si l'option est absente.
+* @throws BootConfigurationError qui nomme l'action et la borne.
+*/
+function checkedResponseTimeout(value, className, method) {
+	if (value === void 0) return void 0;
+	if (!Number.isInteger(value) || value < 0 || value > MAX_TIMER_MS) throw new BootConfigurationError(`${className}.${method} : « responseTimeout » entier entre 0 et ${MAX_TIMER_MS} ms attendu (reçu ${String(value)}).`);
+	return value;
+}
+/** Les bornes d'envoi chiffrées qu'une route peut régler pour elle-même. */
+const UPLOAD_LIMIT_KEYS = /* @__PURE__ */ new Set([
+	"maxFileSize",
+	"maxTotalFileSize",
+	"maxFiles",
+	"maxFields",
+	"maxFieldsSize"
+]);
+function isUploadLimitKey(key) {
+	return UPLOAD_LIMIT_KEYS.has(key);
+}
+/** Les empreintes que le flux d'envoi sait calculer. */
+function isUploadHash(value) {
+	return value === false || value === "sha1" || value === "md5" || value === "sha256";
+}
+/**
+* Valide l'option de route `upload` À LA DÉCLARATION : des entiers ≥ 1 pour
+* les bornes, une empreinte connue, aucune clé inconnue. Une faute de frappe
+* (`maxFilesize`) laisserait sinon la route sur la borne de l'application —
+* 500 Mo par défaut — sans que rien ne le dise.
+*
+* @param value - l'option telle que déclarée (absente = celles de la config).
+* @param bodyStream - la route laisse son corps en flux : ses bornes ne
+*   s'appliqueraient jamais, la déclaration est contradictoire.
+* @param className - classe du contrôleur, nommée dans l'erreur.
+* @param method - action, nommée dans l'erreur.
+* @returns les bornes validées, figées, sans clé `undefined` (la fusion sur
+*   la configuration ne doit rien écraser par du vide), ou `undefined`.
+* @throws BootConfigurationError qui nomme l'action et la clé fautive.
+*/
+function checkedUpload(value, bodyStream, className, method) {
+	if (value === void 0) return void 0;
+	const where = `${className}.${method} : « upload »`;
+	if (bodyStream) throw new BootConfigurationError(`${where} et « bodyStream: true » s'excluent — un corps laissé en flux n'est jamais lu par le pipeline, ses bornes ne s'appliqueraient pas.`);
+	const checked = {};
+	for (const [key, entry] of Object.entries(value)) {
+		if (entry === void 0) continue;
+		if (key === "hashAlgorithm") {
+			if (!isUploadHash(entry)) throw new BootConfigurationError(`${where} : « hashAlgorithm » vaut false, "sha1", "md5" ou "sha256" (reçu ${String(entry)}).`);
+			checked.hashAlgorithm = entry;
+			continue;
+		}
+		if (!isUploadLimitKey(key)) throw new BootConfigurationError(`${where} : clé inconnue « ${key} » — une route règle ${[...UPLOAD_LIMIT_KEYS].join(", ")} et hashAlgorithm ; le dossier et l'encodage restent ceux de la configuration.`);
+		if (typeof entry !== "number" || !Number.isSafeInteger(entry) || entry < 1) throw new BootConfigurationError(`${where} : « ${key} » entier ≥ 1 attendu (reçu ${String(entry)}).`);
+		checked[key] = entry;
+	}
+	return Object.freeze(checked);
+}
 /** L'implémentation de {@link route}, sans les surcharges de typage. */
 function defineRoute(name, options) {
 	return function(target, propertyKey, descriptor) {
@@ -190,7 +276,9 @@ function defineRoute(name, options) {
 			defaults: options.defaults,
 			requirements: options.requirements,
 			bypassFirewall: options.bypassFirewall,
-			fallback: options.fallback
+			fallback: options.fallback,
+			responseTimeout: checkedResponseTimeout(options.responseTimeout, className, propertyKey),
+			upload: checkedUpload(options.upload, options.bodyStream === true, className, propertyKey)
 		};
 		Reflect.defineMetadata(metadataKey, metadata, target.constructor);
 		return descriptor;
@@ -1176,4 +1264,4 @@ function computeAuthenticationRequirement(ctor, method) {
 		amr: Object.freeze([.../* @__PURE__ */ new Set([...onClass.amr, ...onMethod.amr])])
 	});
 }
-export { All, Anonymous, BYPASS_FIREWALL_CLASS_METADATA, BYPASS_FIREWALL_METHOD_METADATA, Body, BypassFirewall, Cookie, Csp, CsrfExempt, CsrfProtect, CurrentUser, DOMAIN_CLASS_METADATA, DOMAIN_METHOD_METADATA, Delete, Domain, Get, HEADERS_METADATA, HTTP_CODE_METADATA, Head, Header, Headers, HttpCode, Idempotent, IsGranted, Options, PARAM_ARGS_METADATA, Param, Patch, Post, Put, Query, REDIRECT_METADATA, Redirect, Req, RequireAuthentication, RequireScope, Res, Scope, Session, USE_SESSION_CLASS_METADATA, USE_SESSION_METHOD_METADATA, UploadedFile, UploadedFiles, UseSession, assertRouteSchemaDeclaration, buildContextParamArgs, buildParamArgs, computeActionMeta, controller, controllers, extractActionScopes, getParamArgsMeta, getRouteSchema, readInvocationBody, readRouteInput, resolveActionMeta, resolveParamArg, resolveSessionIntent, route, routeExpectsBodyStream };
+export { All, Anonymous, BYPASS_FIREWALL_CLASS_METADATA, BYPASS_FIREWALL_METHOD_METADATA, Body, BypassFirewall, Cookie, Csp, CsrfExempt, CsrfProtect, CurrentUser, DOMAIN_CLASS_METADATA, DOMAIN_METHOD_METADATA, Delete, Domain, Get, HEADERS_METADATA, HTTP_CODE_METADATA, Head, Header, Headers, HttpCode, Idempotent, IsGranted, Options, PARAM_ARGS_METADATA, Param, Patch, Post, Put, Query, REDIRECT_METADATA, Redirect, Req, RequireAuthentication, RequireScope, Res, Scope, Session, USE_SESSION_CLASS_METADATA, USE_SESSION_METHOD_METADATA, UploadedFile, UploadedFiles, UseSession, applyDeclaredRouteOptions, assertRouteSchemaDeclaration, buildContextParamArgs, buildParamArgs, computeActionMeta, controller, controllers, extractActionScopes, getParamArgsMeta, getReservedActionNames, getRouteSchema, readInvocationBody, readRouteInput, resolveActionMeta, resolveParamArg, resolveSessionIntent, route, routeExpectsBodyStream };

package/dist/nodefony/grpc/GrpcController.js

@@ -0,0 +1,138 @@
+import Controller from "../src/Controller.js";
+import { computeActionMeta, getReservedActionNames } from "../decorators/routerDecorators.js";
+import { grpcDeclarationOf } from "./declarations.js";
+import { BootConfigurationError } from "nodefony";
+import { HttpContext } from "@nodefony/http";
+import { GrpcEndpoint, markGrpcRoute } from "@nodefony/http/grpc";
+// nodefony/grpc/GrpcController.ts
+/**
+* Nom de l'action de base, celle que toute route gRPC exécute : elle remet la
+* requête à l'adaptateur. Les gardes, elles, se lisent sur la méthode du
+* contrat.
+*
+* @internal
+*/
+const GRPC_ACTION = "serveGrpc";
+/**
+* Ce que chaque décorateur sans effet en gRPC laisse dans la méta d'action —
+* un refus au démarrage le nomme (ADR-0026 D1, point 5 ; S-grpc-18).
+*/
+function inertDecorators(meta) {
+	const found = [];
+	if (meta.paramsMeta !== null) found.push("@Body/@Param/@Query… (paramètres)");
+	if (meta.schema !== null) found.push("schéma de route");
+	if (meta.sessionIntent !== null) found.push("@UseSession");
+	if (meta.cspDirectives !== null) found.push("@Csp");
+	if (meta.idempotent !== null) found.push("@Idempotent");
+	if (meta.httpCode !== null) found.push("@HttpCode");
+	if (meta.headerEntries !== null) found.push("@Header");
+	if (meta.redirectMeta !== null) found.push("@Redirect");
+	return found;
+}
+/**
+* Classe de base d'un point d'entrée gRPC (ADR-0026 D1), jumelle de
+* `RealtimeController` : marquée par `@GrpcService(Contrat)`, déclarée par
+* `@controllers([...])`. Chaque méthode du contrat est une méthode de la
+* classe, appelée par l'adaptateur Connect avec `(request, HandlerContext)` ;
+* la logique métier vit dans un service injecté.
+*
+* Singleton par défaut : aucune instance par appel, l'adaptateur lie les
+* méthodes une fois. `@Scope("request")` donne une instance par appel.
+*
+* Ce que le framework décide pour chaque méthode, sans code de ta part :
+* - les gardes (`@IsGranted`, `@RequireAuthentication`…) posées sur la
+*   méthode ou la classe s'appliquent ; un refus part en 16
+*   `UNAUTHENTICATED` sans identité, en 7 `PERMISSION_DENIED` sinon ;
+* - `this.user`, l'ALS et la portée `request` valent pendant tout l'appel,
+*   flux compris ;
+* - une `ConnectError` part telle quelle ; une `HttpError` est traduite par
+*   la table de `google/rpc/code.proto` ; toute autre exception devient 13
+*   `INTERNAL`. Dans un flux, la traduction ne vaut qu'avant le premier
+*   message ;
+* - un flux est interrompu en 14 `UNAVAILABLE` à l'arrêt du serveur et en 16
+*   à la révocation de son identité : passer `ctx.signal` à ses sources ;
+* - messages bornés à 4 Mio (section `grpc` de la configuration http).
+*
+* Un décorateur sans effet en gRPC (`@Body`, `@UseSession`, `@Csp`,
+* `@Idempotent`…) sur une méthode du contrat interrompt le démarrage.
+* Guide complet : `docs/grpc.md` du paquet.
+*
+* @example
+* \@GrpcService(GreetService)
+* export class GreetController extends GrpcController {
+*   constructor(context: ContextType) {
+*     super("GreetController", context);
+*   }
+*   greet(request: GreetRequest) {
+*     return { greeting: `Bonjour, ${request.name} !` };
+*   }
+* }
+*
+* @experimental Surface gRPC, ADR-0026 D11.
+*/
+var GrpcController = class extends Controller {
+	/**
+	* Vérifie la déclaration gRPC de la classe et fige ses routes — au
+	* démarrage (`Router.setController`), jamais à la première requête.
+	*
+	* Refuse : une classe sans `@GrpcService` ; une méthode du contrat absente
+	* de la classe ou dont le nom est réservé par le framework ; un décorateur
+	* sans effet en gRPC sur une méthode du contrat (ou sur la classe) — le
+	* refus nomme la méthode et le décorateur.
+	*
+	* Fige ensuite, sur chaque route, la méta d'action lue sur la MÉTHODE DU
+	* CONTRAT (l'action exécutée reste celle de la base) et le corps laissé en
+	* flux : les gardes valent quel que soit l'ordre des décorateurs de classe.
+	*
+	* @throws BootConfigurationError sur une déclaration refusée.
+	*/
+	static assertScope() {
+		const declaration = grpcDeclarationOf(this);
+		if (declaration === void 0) throw new BootConfigurationError(`Contrôleur gRPC « ${this.name} » sans @GrpcService(Contrat) : rien ne dit quel service il sert. Poser @GrpcService sur la classe.`);
+		const typeName = declaration.service.typeName;
+		const reserved = getReservedActionNames();
+		const metas = /* @__PURE__ */ new Map();
+		for (const method of declaration.service.methods) {
+			const name = method.localName;
+			const where = `Service gRPC ${typeName} (« ${this.name} »), méthode « ${name} »`;
+			const owner = name === "serveGrpc" || name === "grpcEndpoint" ? "GrpcController" : reserved.get(name);
+			if (owner !== void 0) throw new BootConfigurationError(`${where} : ce nom est réservé par ${owner}, dont tout contrôleur hérite. Renommer la méthode dans le contrat.`);
+			if (typeof Reflect.get(this.prototype, name) !== "function") throw new BootConfigurationError(`${where} : absente de la classe. Chaque méthode du contrat s'implémente sur son contrôleur.`);
+			const meta = computeActionMeta(this, name);
+			const inert = inertDecorators(meta);
+			if (inert.length !== 0) throw new BootConfigurationError(`${where} : ${inert.join(", ")} sans effet sur un appel gRPC (posé sur la méthode ou sur la classe). Les retirer.`);
+			metas.set(name, meta);
+		}
+		for (const { route, method } of declaration.routes) {
+			const meta = metas.get(method.localName);
+			if (meta === void 0) continue;
+			route.actionMeta = {
+				...meta,
+				bodyStream: true
+			};
+			route.bodyStream = true;
+			markGrpcRoute(route);
+		}
+		Object.defineProperty(this.prototype, "grpcEndpoint", {
+			value: new GrpcEndpoint(declaration.service, { perCall: this.scope !== "singleton" }),
+			configurable: true
+		});
+	}
+	/**
+	* L'action de base de toute route gRPC : remet la requête et la réponse
+	* brutes à l'adaptateur, qui appelle la méthode du contrat et écrit la
+	* réponse. Synchrone, sauf pour un flux dont la session est à sauver : la
+	* promesse de la remise est alors rendue au résolveur, qui en lit l'échec.
+	*
+	* @throws Error quand la classe n'a pas été enregistrée par le routeur, ou
+	*   hors d'une requête HTTP.
+	*/
+	serveGrpc() {
+		const endpoint = this.grpcEndpoint;
+		if (endpoint === void 0) throw new Error(`Contrôleur gRPC « ${this.constructor.name} » non enregistré : le déclarer par @controllers([...]).`);
+		const context = this.context;
+		if (!(context instanceof HttpContext)) throw new Error("Un appel gRPC n'est servi que sur une requête HTTP.");
+		return endpoint.serve(context, this);
+	}
+};
+export { GRPC_ACTION, GrpcController };

package/dist/nodefony/grpc/GrpcService.js

@@ -0,0 +1,75 @@
+import router_default from "../service/router.js";
+import { applyDeclaredRouteOptions } from "../decorators/routerDecorators.js";
+import { GRPC_ACTION } from "./GrpcController.js";
+import { claimGrpcService, declareGrpcService } from "./declarations.js";
+import { BootConfigurationError } from "nodefony";
+import { MethodOptions_IdempotencyLevel } from "@bufbuild/protobuf/wkt";
+// nodefony/grpc/GrpcService.ts
+/**
+* Déclare un contrôleur comme le point d'entrée du service gRPC `service`
+* (le descripteur généré par `buf`, ex. `EchoService` de `echo_pb.ts`).
+*
+* Monte une route littérale du Router par méthode du contrat,
+* `POST /<paquet.Service>/<Méthode>`, plus `GET` pour une méthode déclarée
+* `option idempotency_level = NO_SIDE_EFFECTS` (le GET de Connect). Ces
+* routes passent par tout le pipeline — pare-feu, `@IsGranted`, hôtes
+* virtuels, profileur, liste des routes —, et leurs gardes se lisent sur la
+* méthode du contrat. La classe se déclare ensuite par `@controllers([...])`,
+* comme tout point d'entrée d'un module.
+*
+* Les décorateurs de classe `@Domain` et `@BypassFirewall` se placent SOUS
+* `@GrpcService` (lus au montage des routes, comme sous `@controller`).
+*
+* Le descripteur vient du code généré, jamais écrit à la main : contrat dans
+* `proto/<paquet>/v1/*.proto`, `npx buf generate` vers `nodefony/gen/`, code
+* commité. Les routes répondent sur 5152 (gRPC, gRPC-Web, Connect), 5151
+* (gRPC-Web, Connect : HTTP/1.1, jamais le gRPC natif) et 5153 si h2c est
+* activé. Guide complet : `docs/grpc.md` du paquet.
+*
+* @param service - le descripteur du service.
+* @returns le décorateur de classe.
+* @throws BootConfigurationError quand une autre classe sert déjà ce contrat.
+*
+* @example
+* \@GrpcService(EchoService)
+* export class EchoController extends GrpcController {
+*   constructor(context: ContextType) {
+*     super("EchoController", context);
+*   }
+*   \@IsGranted("ROLE_ECHO")
+*   say(request: SayRequest) {
+*     return { sentence: request.sentence };
+*   }
+* }
+*
+* @experimental Surface gRPC, ADR-0026 D11.
+*/
+function GrpcService(service) {
+	return function(ctor) {
+		const owner = claimGrpcService(service.typeName, ctor.name);
+		if (owner !== null) throw new BootConfigurationError(`@GrpcService(${service.typeName}) sur « ${ctor.name} » : ce service est déjà servi par « ${owner} ». Un contrat n'a qu'un point d'entrée.`);
+		const routes = [];
+		for (const method of service.methods) {
+			const options = {
+				prefix: `/${service.typeName}`,
+				path: `/${method.name}`,
+				constructor: ctor,
+				className: ctor.name,
+				classMethod: GRPC_ACTION,
+				method: method.idempotency === MethodOptions_IdempotencyLevel.NO_SIDE_EFFECTS ? ["POST", "GET"] : "POST"
+			};
+			applyDeclaredRouteOptions(ctor, options, method.localName);
+			const route = router_default.createRoute(`${ctor.name}::${method.localName}`, options);
+			routes.push({
+				route,
+				method
+			});
+		}
+		declareGrpcService(ctor, {
+			service,
+			routes
+		});
+		return ctor;
+	};
+}
+export { GrpcService };

package/dist/nodefony/grpc/declarations.js

@@ -0,0 +1,33 @@
+// nodefony/grpc/declarations.ts
+/**
+* Déclarations par classe contrôleur. Écrite à l'import (`@GrpcService`), lue
+* une fois au démarrage (`GrpcController.assertScope`) : jamais sur le chemin
+* d'un appel.
+*/
+const declarations = /* @__PURE__ */ new WeakMap();
+/**
+* Contrat déjà servi, par nom complet : deux classes qui serviraient le même
+* service monteraient deux fois les mêmes chemins.
+*/
+const servedBy = /* @__PURE__ */ new Map();
+/** @internal */
+function declareGrpcService(ctor, declaration) {
+	declarations.set(ctor, declaration);
+}
+/** @internal */
+function grpcDeclarationOf(ctor) {
+	return declarations.get(ctor);
+}
+/**
+* Retient quelle classe sert un contrat.
+*
+* @returns le nom de la classe qui le servait déjà, ou `null`.
+* @internal
+*/
+function claimGrpcService(typeName, className) {
+	const owner = servedBy.get(typeName);
+	if (owner !== void 0) return owner;
+	servedBy.set(typeName, className);
+	return null;
+}
+export { claimGrpcService, declareGrpcService, grpcDeclarationOf };

package/dist/nodefony/grpc/index.js

@@ -0,0 +1,3 @@
+import { GrpcController } from "./GrpcController.js";
+import { GrpcService } from "./GrpcService.js";
+export { GrpcController, GrpcService };

package/dist/nodefony/service/AdminBroker.js

@@ -1,6 +1,6 @@
 import router_default from "./router.js";
 import AdminApiController from "../controller/AdminApiController.js";
-import __decorate from "../../_virtual/_@oxc-project_runtime@0.157.0/helpers/esm/decorate.js";
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.158.0/helpers/esm/decorate.js";
 import { ADMIN_DEFAULT_ROLE, Service, injectable, resolveAdminRole } from "nodefony";
 // nodefony/service/AdminBroker.ts
 const serviceName = "adminBroker";

package/dist/nodefony/service/IdempotencyStore.js

@@ -1,4 +1,4 @@
-import __decorate from "../../_virtual/_@oxc-project_runtime@0.157.0/helpers/esm/decorate.js";
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.158.0/helpers/esm/decorate.js";
 import { Service, assertPageQuery, injectable } from "nodefony";
 // nodefony/service/IdempotencyStore.ts
 const serviceName = "idempotencyStore";