@nodefony/http 10.0.0-alpha.1

package/dist/nodefony/src/session/storage/RevocationGuardStorage.js

@@ -0,0 +1,137 @@
+//#region nodefony/src/session/storage/RevocationGuardStorage.ts
+/**
+* Durée de vie (ms) d'une pierre tombale de révocation. Couvre la fenêtre
+* pendant laquelle une requête « en vol » — qui avait chargé la session AVANT
+* sa révocation — pourrait tenter un `write` tardif (autosave de fin de requête)
+* et la ressusciter. Une requête HTTP dure des secondes ; on prend large (5 min)
+* pour couvrir les requêtes longues (upload/SSE) sans risque : un id révoqué
+* n'est JAMAIS réémis (ids opaques CSPRNG), tombstoner ne bloque aucune session
+* légitime.
+*/
+const TOMBSTONE_TTL_MS = 3e5;
+/**
+* Garde-fou de révocation **décoré au-dessus** de n'importe quel
+* {@link ISessionStorage} (file, drizzle, redis, mongo…). Pose une « pierre
+* tombale » sur tout id détruit et REFUSE un `write` ultérieur de ce même id
+* pendant {@link TOMBSTONE_TTL_MS}.
+*
+* **Pourquoi ici, pas dans chaque store** : la résurrection est une propriété du
+* CYCLE DE VIE de session — révoquer une session puis l'autosave de fin de
+* requête (la requête la portait encore en mémoire, `dirty`) la ré-écrit — et
+* NON d'un backend particulier. Un seul garde-fou décoré sur le storage actif
+* couvre donc TOUS les backends, présents et futurs, **sans en modifier aucun**.
+*
+* Découvert en live le 2026-06-21 (« révoquer une session ne déconnecte pas ») ;
+* le store réel était `drizzle`, pas `files` — d'où la décoration générique.
+*
+* Couvre deux scénarios :
+*  - **self** : l'admin révoque SA PROPRE session ; l'autosave de la requête de
+*    révocation tente de la réécrire → refusé.
+*  - **race** : un autre client du user révoqué a une requête en vol dont
+*    l'autosave arrive après la révocation → refusé.
+*
+* **Perf** : décorateur **singleton** (1 par service). Délégation directe sur le
+* hot-path lecture (`read`/`start`/`listAll`) ; `write` ne paie qu'un test
+* `=== null` tant qu'aucune session n'a été révoquée (Map **lazy**, jamais de
+* `Date.now()` dans ce cas).
+*/
+var RevocationGuardStorage = class {
+	/** Storage réel décoré — exposé pour l'introspection admin (nom du driver). */
+	inner;
+	/** `id → epoch ms d'expiration`. **Lazy** : `null` tant qu'aucune révocation. */
+	#tombstones = null;
+	/**
+	* Énumération admin — (ré)assignée dans le constructeur **uniquement** si le
+	* backend décoré la supporte, pour que `SessionsService.supportsEnumeration`
+	* (`typeof storage.listAll === "function"`) reflète la vraie capacité du store.
+	*/
+	listAll;
+	/**
+	* Touch (prolongation d'idle) — (ré)assignée seulement si le backend décoré la
+	* supporte, pour que `Session.touchIfNeeded` (`typeof storage.touch`) reflète la
+	* vraie capacité. **Respecte la pierre tombale** : ne prolonge JAMAIS une session
+	* révoquée (cohérent avec `write` — une révocation ne doit pas être contournée
+	* par un touch tardif d'une requête en vol).
+	*/
+	touch;
+	/**
+	* Énumération admin **paginée** — (ré)assignée seulement si le backend décoré
+	* la supporte, même raison que {@link listAll} : `supportsEnumeration` teste la
+	* présence de la méthode, elle doit donc refléter la vraie capacité du store
+	* décoré et non celle du décorateur.
+	*/
+	listPage;
+	/** `COUNT` filtré — (ré)assigné seulement si le backend décoré le supporte. */
+	countSessions;
+	/**
+	* `COUNT(DISTINCT user)` — (ré)assigné seulement si le backend décoré le
+	* supporte, même raison que {@link countSessions} : une capacité perdue dans
+	* le décorateur ferait afficher « inconnu » là où la base sait répondre.
+	*/
+	countDistinctUsers;
+	/**
+	* Capacité de tri du backend décoré, relayée telle quelle.
+	*
+	* Une capacité qui se PERD dans un décorateur est pire qu'une capacité
+	* absente : elle est déclarée par le store réel, invisible au-dessus, et le
+	* data plane refuse alors (400) un tri que la base sait parfaitement faire.
+	* Comme ce décorateur est posé en production dès qu'une révocation est
+	* possible, l'oubli aurait désactivé le tri **partout**.
+	*/
+	sortableFields;
+	constructor(inner) {
+		this.inner = inner;
+		this.sortableFields = inner.sortableFields;
+		if (typeof inner.listAll === "function") this.listAll = (filter) => inner.listAll(filter);
+		if (typeof inner.listPage === "function") this.listPage = (query) => inner.listPage(query);
+		if (typeof inner.countSessions === "function") this.countSessions = (query) => inner.countSessions(query);
+		if (typeof inner.countDistinctUsers === "function") this.countDistinctUsers = (query) => inner.countDistinctUsers(query);
+		if (typeof inner.touch === "function") this.touch = (id, idleSeconds) => {
+			if (this.#isRevoked(id)) return Promise.resolve();
+			return inner.touch(id, idleSeconds);
+		};
+	}
+	read(id) {
+		return this.inner.read(id);
+	}
+	start(id) {
+		return this.inner.start(id);
+	}
+	open() {
+		return this.inner.open();
+	}
+	close() {
+		return this.inner.close();
+	}
+	gc(idleSeconds, absoluteSeconds) {
+		return this.inner.gc(idleSeconds, absoluteSeconds);
+	}
+	async destroy(id) {
+		this.#revoke(id);
+		return this.inner.destroy(id);
+	}
+	write(id, data) {
+		if (this.#isRevoked(id)) return Promise.resolve(data);
+		return this.inner.write(id, data);
+	}
+	#revoke(id) {
+		const now = Date.now();
+		this.#purgeExpired(now);
+		if (this.#tombstones === null) this.#tombstones = /* @__PURE__ */ new Map();
+		this.#tombstones.set(id, now + TOMBSTONE_TTL_MS);
+	}
+	#isRevoked(id) {
+		const t = this.#tombstones;
+		if (t === null) return false;
+		const expiry = t.get(id);
+		return expiry !== void 0 && expiry > Date.now();
+	}
+	#purgeExpired(now) {
+		const t = this.#tombstones;
+		if (t === null) return;
+		for (const [id, expiry] of t) if (expiry <= now) t.delete(id);
+		if (t.size === 0) this.#tombstones = null;
+	}
+};
+//#endregion
+export { RevocationGuardStorage as default };

package/dist/nodefony/src/session/storage/sessionFilters.js

@@ -0,0 +1,83 @@
+//#region nodefony/src/session/storage/sessionFilters.ts
+/**
+* **Le vocabulaire de filtre des sessions**, en noms PUBLICS — celui que la
+* console d'administration écrit dans l'URL (`?user=alice`).
+*
+* Frère de `SESSION_SORTABLE_FIELDS` (`sessionSort.ts`), posé au même endroit
+* pour la même raison : le vocabulaire appartient au module propriétaire du
+* contrat, la mécanique de lecture au cœur (`parseFilters`).
+*
+* `user` est un filtre **portable par construction** (égalité stricte) : il
+* s'exprime dans tous les backends — `WHERE` indexé en SQL et Mongo, prédicat en
+* mémoire, filtre de batch en Redis — donc aucun store n'a besoin de matérialiser
+* la collection pour l'honorer. C'est la propriété qui justifie qu'il soit au
+* contrat plutôt que dans une couche de filtrage applicative.
+*
+* `tenantId` n'y figure pas parce qu'il appartient au **contrat de page**
+* (`PAGE_QUERY_KEYS`, réserve multi-tenant) : le déclarer ici en ferait un
+* second lecteur du même paramètre.
+*/
+const SESSION_FILTERS = {
+	/** Sessions d'un utilisateur donné (égalité stricte sur l'identifiant). */
+	user: "string",
+	/**
+	* `true` = sessions rattachées à un utilisateur, `false` = anonymes, absent =
+	* les deux. Le contrat le définit comme « `user` non vide » — tous les stores
+	* l'honorent déjà (c'est ainsi que `sessions/stats` compte ses facettes).
+	*
+	* Il n'était pas exposé à l'URL, et la console ne pouvait donc pas MONTRER la
+	* population qu'elle affichait en carte : cliquer « Anonymes » demandait un
+	* paramètre que la liste refusait. Une facette n'existe que si le contrat de
+	* liste sait la filtrer — celle-ci le savait partout sauf sur le fil.
+	*
+	* ⚠️ Redondant avec `user` **par construction** (même donnée). Les combiner
+	* de façon contradictoire (`?user=alice&authenticated=false`) rend l'ENSEMBLE
+	* VIDE, jamais la page de l'un des deux — garde posée dans le banc de contrat
+	* partagé, donc rejouée sur les six backends.
+	*/
+	authenticated: "boolean"
+};
+/**
+* **Les facettes des sessions** — les questions fermées que la console pose à la
+* collection ENTIÈRE, pour ses cartes de tête.
+*
+* Distinct de `SESSION_FILTERS`, qui dit ce qu'un client a le droit d'écrire
+* dans l'URL : une facette n'est pas saisie, elle est posée par le serveur. Les
+* deux se recoupent par construction — une facette n'existe que si le contrat de
+* liste sait déjà la filtrer, sinon elle serait un compteur approximatif de plus.
+*
+* `authenticated` suffit à couvrir les deux populations : le contrat le définit
+* comme « `user` non vide », donc `false` rend exactement les sessions anonymes.
+* Aucune facette n'est déduite d'une soustraction (cf `countFacets`).
+*
+* Le décompte d'utilisateurs **distincts** n'est PAS ici : ce n'est pas un
+* `COUNT` filtré mais une agrégation, qu'un store en curseur ne peut pas rendre.
+* Il vit en capacité déclarée du backend (`ISessionStorage.countDistinctUsers`).
+*/
+const SESSION_FACETS = {
+	/** Toutes les sessions persistées, sans filtre. */
+	total: {},
+	/** Sessions rattachées à un utilisateur authentifié. */
+	authenticated: { authenticated: true },
+	/** Sessions anonymes (aucun utilisateur rattaché). */
+	anonymous: { authenticated: false }
+};
+/**
+* Ce que l'endpoint de COMPTEURS accepte de filtrer — {@link SESSION_FILTERS}
+* **moins** le champ que ses facettes décomposent (`authenticated`).
+*
+* Le demander ici rendrait une réponse qui se contredit : le total suivrait le
+* filtre pendant que chaque facette l'écraserait par le sien (« 5 sessions au
+* total, dont 40 anonymes »). `user` reste : il découpe une AUTRE dimension, et
+* « combien de sessions pour alice, dont combien d'anonymes ? » est une question
+* cohérente — qui rend d'ailleurs l'ensemble vide, la réponse honnête.
+*
+* Frère de `USER_STATS_FILTERS` / `TOKEN_STATS_FILTERS` / `WEBHOOK_STATS_FILTERS`.
+* Les sessions n'en avaient pas : `authenticated` n'était exposé nulle part, si
+* bien que le trou était fermé par accident plutôt que par décision. Ouvrir le
+* filtre sur la liste — pour que les cartes deviennent cliquables — l'aurait
+* rouvert du même geste.
+*/
+const SESSION_STATS_FILTERS = { user: "string" };
+//#endregion
+export { SESSION_FACETS, SESSION_FILTERS, SESSION_STATS_FILTERS };

package/dist/nodefony/src/session/storage/sessionSort.js

@@ -0,0 +1,53 @@
+import { renameOrderFields } from "nodefony";
+//#region nodefony/src/session/storage/sessionSort.ts
+/**
+* **Le vocabulaire de tri des sessions**, en noms PUBLICS — ceux qu'un client
+* écrit dans l'URL (`?order=updatedAt:DESC`), jamais des noms de colonne.
+*
+* Il vit ici, chez le propriétaire du contrat (`@nodefony/http`), et non dans
+* chaque backend : c'est ce qui garantit qu'une console offre le même tri que
+* l'application tourne sur mémoire, SQLite, PostgreSQL ou Mongo. Un store qui
+* nomme ses colonnes autrement (SQL stocke l'identifiant en `session_id`)
+* **traduit chez lui** — cf {@link SESSION_COLUMN_ALIASES}.
+*
+* - `updatedAt` — dernière activité (l'axe naturel d'une console de sessions).
+* - `createdAt` — ouverture de la session (« qui s'est connecté en premier »).
+* - `user` — porteur, pour regrouper les sessions d'un même compte à l'œil.
+* - `id` — identifiant de session, utile surtout en départage.
+*
+* Ce que la liste n'inclut PAS, et pourquoi : `ip` et `ua` ne sont **pas des
+* champs** mais des entrées du sac de métadonnées (`metaBag`, sérialisé en
+* JSON). Aucun backend ne peut les ordonner sans matérialiser la collection —
+* la console les affiche donc en colonnes non triables, au lieu d'offrir un
+* tri qui serait refusé (SQL) ou coûteux (mémoire).
+*/
+const SESSION_SORTABLE_FIELDS = [
+	"updatedAt",
+	"createdAt",
+	"user",
+	"id"
+];
+/**
+* Ordre contractuel appliqué quand le client n'en demande aucun : activité la
+* plus récente d'abord, départagée par identifiant pour rester **déterministe**
+* à horodatage égal (sans quoi une pagination peut sauter ou répéter une ligne
+* entre deux pages).
+*/
+const SESSION_DEFAULT_ORDER = [["updatedAt", "DESC"], ["id", "ASC"]];
+/**
+* Table d'alias des backends dont le schéma nomme l'identifiant de session
+* `session_id` (SQL comme Mongo) — à passer à `renameOrderFields` (core).
+*
+* C'est une **donnée** du schéma, pas du code : la règle « réécrire les noms »
+* vit au core en un exemplaire, et chaque backend n'apporte que sa table. Sans
+* cette traduction, `?order=id:ASC` partirait vers une colonne `id` inexistante
+* — l'erreur ne se verrait qu'à l'exécution, sur le backend concerné seulement.
+*/
+const SESSION_COLUMN_ALIASES = { id: "session_id" };
+/**
+* Ordre par défaut des backends dont le schéma nomme l'identifiant
+* `session_id` — {@link SESSION_DEFAULT_ORDER} déjà traduit.
+*/
+const SESSION_DEFAULT_ORDER_SQL = renameOrderFields(SESSION_DEFAULT_ORDER, SESSION_COLUMN_ALIASES);
+//#endregion
+export { SESSION_COLUMN_ALIASES, SESSION_DEFAULT_ORDER, SESSION_DEFAULT_ORDER_SQL, SESSION_SORTABLE_FIELDS };

package/dist/types/index.d.ts

@@ -0,0 +1,83 @@
+import { Kernel, Module } from "nodefony";
+import type { IHttpConfig, IHttpConfigInput } from "./nodefony/interfaces/IHttpConfig.js";
+import { Profiler } from "./nodefony/src/profiler/Profiler.js";
+import HttpKernel from "./nodefony/service/http-kernel.js";
+import SessionsService from "./nodefony/service/sessions/sessions-service.js";
+import Context from "./nodefony/src/context/Context.js";
+import Session from "./nodefony/src/session/session.js";
+import HttpError from "./nodefony/src/errors/httpError.js";
+import Response from "./nodefony/src/context/http/Response.js";
+import Http2Response from "./nodefony/src/context/http2/Response.js";
+import wsResponse from "./nodefony/src/context/websocket/Response.js";
+import Cookie from "./nodefony/src/cookies/cookie.js";
+import DefaultErrorRenderer from "./nodefony/service/error-renderer.js";
+import DefaultRequestLogger from "./nodefony/service/request-logger.js";
+import JsonAuditLogger from "./nodefony/service/audit-logger.js";
+import PrettyRequestLogger from "./nodefony/service/pretty-request-logger.js";
+import HttpContext from "./nodefony/src/context/http/HttpContext.js";
+import WebsocketContext from "./nodefony/src/context/websocket/WebsocketContext.js";
+import HttpRequest from "./nodefony/src/context/http/Request.js";
+import Http2Request from "./nodefony/src/context/http2/Request.js";
+declare module "nodefony" {
+    interface NodefonyModuleConfig {
+        "@nodefony/http": IHttpConfigInput;
+    }
+}
+declare class Http extends Module<IHttpConfig> {
+    constructor(kernel: Kernel);
+    /**
+     * Expose le JSON Schema de la config http (dérivé du schéma Zod, flags `meta()`
+     * inclus) au data plane admin → Studio rend la config en réglages documentés
+     * (type, défaut, état, valeur effective) au lieu d'un dump brut. Override du
+     * seam {@link Module.configSchema}.
+     */
+    configSchema(): unknown;
+    /**
+     * Phase `onRegister` : valide la config (défauts + override `module-http` +
+     * défauts kernel) via `defineHttpConfig`, puis la ré-assigne à `this.options`
+     * AVANT l'instanciation des `@services` (phase `onBoot`). Plante propre avec
+     * messages clairs si la config est invalide (convention Zod figée 2026-05-28).
+     *
+     * Config NON gelée : les services mutent `module.options` (upload `uploadDir`,
+     * certificats `serialNumber`) — cf `defineHttpConfig`.
+     */
+    onKernelRegister(): Promise<this>;
+    /**
+     * Phase `onBoot` : s'enregistre comme producteur admin (`/nodefony/http/api/*`)
+     * auprès du broker, AVANT que framework ne monte le data plane à `onReady`.
+     *
+     * Importe seulement `IAdminRegistry` (core) — jamais `@nodefony/framework`
+     * (dépendance circulaire). Le broker est résolu du container partagé.
+     */
+    onKernelBoot(): Promise<this>;
+    onKernelReady(): Promise<this>;
+}
+export default Http;
+export { defineHttpConfig, httpConfigJsonSchema, } from "./nodefony/config/defineModuleConfig.js";
+export { httpConfigSchema, type HttpConfig, type HttpConfigInput, } from "./nodefony/config/config.js";
+export type { IHttpConfig, IHttpConfigInput, } from "./nodefony/interfaces/IHttpConfig.js";
+export { decideSend, readBackpressureOptions, type WsBackpressurePolicy, type WsSendDecision, type IWsBackpressureOptions, type IBackpressureSocket, type IBackpressureTarget, } from "./nodefony/src/context/websocket/wsBackpressure.js";
+export { compileDomainPattern, compileDomainPatterns, compileTrustedHosts, isDomainAllowed, } from "./nodefony/src/context/domainMatcher.js";
+export type { DomainPattern, TrustedHostsConfig, } from "./nodefony/src/context/domainMatcher.js";
+export { MemoryRateLimitStore } from "./nodefony/src/rateLimit/MemoryRateLimitStore.js";
+export type { IRateLimitStore, IRateLimitOptions, RateLimitVerdict, } from "./nodefony/src/rateLimit/IRateLimitStore.js";
+export { Context, Session, SessionsService, HttpError, HttpKernel, Response, Http2Response, Response as HttpResponse, wsResponse, wsResponse as WebsocketResponse, Cookie, HttpContext, WebsocketContext, HttpRequest, Http2Request, DefaultErrorRenderer, DefaultRequestLogger, JsonAuditLogger, PrettyRequestLogger, Profiler, };
+export { schemaMismatchOf, type SchemaMismatchConfidence, } from "./nodefony/service/error-renderer.js";
+export type { ProfileEntry, ProfileSummary, ProfilePhase, ProfileQuery, ProfileSecurity, } from "./nodefony/src/profiler/Profiler.js";
+export { FrameProfile } from "./nodefony/src/profiler/FrameProfile.js";
+export type { FrameProfileInit, ProfiledArea, ProfiledResolver, } from "./nodefony/src/profiler/FrameProfile.js";
+export { resolveUiDelivery, PrebuiltUi, } from "./nodefony/src/assets/prebuiltUi.js";
+export type { UiDeliveryMode, UiDeliveryResolved, IUiDeliveryResolution, IUiDeliveryOptions, IPrebuiltUiOptions, } from "./nodefony/src/assets/prebuiltUi.js";
+export type { IContext, IHttpContext, IWebsocketContext, ServerType, SchemeType, WebSocketStateType, CookiesMap, ISecurityTrace, SecurityOutcome, } from "./nodefony/interfaces/IContext.js";
+export type { ICookie, ICookieOptions, IWsCookie, SameSiteType, PriorityType, } from "./nodefony/interfaces/ICookie.js";
+export type { ISession, ISessionStorage, ISerializedSession, ISessionSummary, ISessionRecord, ISessionListFilter, ISessionListQuery, SessionIntent, SessionStatusType, SessionStrategyType, FlashBagType, MetaBagType, } from "./nodefony/interfaces/ISession.js";
+export { SESSION_SORTABLE_FIELDS, SESSION_DEFAULT_ORDER, SESSION_DEFAULT_ORDER_SQL, SESSION_COLUMN_ALIASES, } from "./nodefony/src/session/storage/sessionSort.js";
+export type { IHttpRequest, IHttp2Request, IWsRequest, HTTPMethodType, } from "./nodefony/interfaces/IRequest.js";
+export type { IHttpResponse, IWebsocketResponse, } from "./nodefony/interfaces/IResponse.js";
+export type { IHttpKernel } from "./nodefony/interfaces/IHttpKernel.js";
+export type { IUploadedFile, IUploadService, IParsedUploadFile, IUploadOptions, } from "./nodefony/interfaces/IUpload.js";
+export type { IErrorRenderer, IErrorHttpResult, IErrorWebsocketResult, } from "./nodefony/interfaces/IErrorRenderer.js";
+export type { IRequestLogger, IRequestLogEntry, } from "./nodefony/interfaces/IRequestLogger.js";
+export type { AuditLogEntry, AuditErrorEntry, JsonAuditLoggerOptions, } from "./nodefony/service/audit-logger.js";
+export type { ContextType, httpRequest, httpResponse, ProtocolType, } from "./nodefony/service/http-kernel.js";
+export type { contextRequest, contextResponse, HTTPMethod, WebSocketState, Cookies, } from "./nodefony/src/context/Context.js";

package/dist/types/nodefony/command/assetsPublishCommand.d.ts

@@ -0,0 +1,23 @@
+import { CliKernel, Command } from "nodefony";
+/**
+ * Commande CLI `assets:publish` — assemble TOUS les assets statiques servables
+ * (publics de module montés sous `/<module>/` + bundles `@nodefony/frontend`
+ * sous `/_assets/<name>/`) dans UN arbre `dist-assets/` miroir des préfixes
+ * d'URL, plus un `manifest.json`.
+ *
+ * Provider-agnostic — Nodefony ASSEMBLE, l'orchestrateur PUBLIE (cloud-native) :
+ * `aws s3 sync dist-assets s3://bucket`, `rsync`, upload CI… Pas de dépendance
+ * cloud embarquée dans le framework. Combine avec `frontend.assetBaseUrl` pour
+ * que les URLs émises pointent le CDN qui sert cet arbre.
+ */
+declare class AssetsPublish extends Command {
+    constructor(cli: CliKernel);
+    generate(opts: {
+        out?: string;
+        clean?: boolean;
+        json?: boolean;
+    }): Promise<this>;
+    /** Sources = mounts natifs (`server-static`) + bundles `@nodefony/frontend`. */
+    private collectSources;
+}
+export default AssetsPublish;

package/dist/types/nodefony/command/certificatesCommand.d.ts

@@ -0,0 +1,17 @@
+import { CliKernel, Command } from "nodefony";
+/**
+ * Commande CLI `certificates` — (re)génère et inspecte le certificat TLS de
+ * DÉVELOPPEMENT. La génération reste un confort de dev : en production, fournir
+ * un vrai certificat (`certificates.strategy: "explicit"`).
+ *
+ * Réutilise le service `certificates` du module `@nodefony/http` (source unique)
+ * → la commande, le boot auto et un futur endpoint Studio appellent le même code.
+ */
+declare class Certificates extends Command {
+    constructor(cli: CliKernel);
+    generate(opts: {
+        force?: boolean;
+        json?: boolean;
+    }): Promise<this>;
+}
+export default Certificates;

package/dist/types/nodefony/command/networkCommand.d.ts

@@ -0,0 +1,8 @@
+import { CliKernel, Command } from "nodefony";
+declare class Network extends Command {
+    constructor(cli: CliKernel);
+    generate(arg: string, opts: {
+        json: boolean;
+    }): Promise<this>;
+}
+export default Network;

package/dist/types/nodefony/command/proxyGenerateCommand.d.ts

@@ -0,0 +1,19 @@
+import { CliKernel, Command } from "nodefony";
+/**
+ * Commande CLI `proxy:generate <nginx|haproxy>` — génère une configuration
+ * reverse-proxy DÉRIVÉE de l'introspection Nodefony (domaines de confiance,
+ * dossiers statiques servis, ports). Évite d'écrire la conf à la main et de la
+ * laisser diverger ; résout le « trou statiques multi-modules » côté nginx.
+ */
+declare class ProxyGenerate extends Command {
+    constructor(cli: CliKernel);
+    generate(target: string, opts: {
+        out?: string;
+        backend?: string;
+        listen?: string;
+        reencrypt?: boolean;
+    }): Promise<this>;
+    /** Construit le modèle d'introspection depuis le kernel + le service statique. */
+    private buildIntrospection;
+}
+export default ProxyGenerate;

package/dist/types/nodefony/config/config.d.ts

@@ -0,0 +1,197 @@
+import { z } from "zod";
+export declare const httpConfigSchema: z.ZodObject<{
+    headerServer: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    trustProxy: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString, z.ZodArray<z.ZodString>]>>;
+    trustedHosts: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString, z.ZodArray<z.ZodString>]>>;
+    securityHeaders: z.ZodDefault<z.ZodObject<{
+        contentTypeOptions: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        frameOptions: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        strictTransportSecurity: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            maxAge: z.ZodDefault<z.ZodNumber>;
+            includeSubDomains: z.ZodDefault<z.ZodBoolean>;
+            preload: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    maxBodySize: z.ZodDefault<z.ZodNumber>;
+    upload: z.ZodDefault<z.ZodObject<{
+        uploadDir: z.ZodDefault<z.ZodString>;
+        maxFileSize: z.ZodDefault<z.ZodNumber>;
+        maxTotalFileSize: z.ZodDefault<z.ZodNumber>;
+        maxFiles: z.ZodDefault<z.ZodNumber>;
+        maxFields: z.ZodDefault<z.ZodNumber>;
+        maxFieldsSize: z.ZodDefault<z.ZodNumber>;
+        hashAlgorithm: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodEnum<{
+            md5: "md5";
+            sha1: "sha1";
+            sha256: "sha256";
+        }>]>>;
+        encoding: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>>;
+    queryString: z.ZodDefault<z.ZodObject<{
+        parameterLimit: z.ZodDefault<z.ZodNumber>;
+        delimiter: z.ZodDefault<z.ZodString>;
+        ignoreQueryPrefix: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$loose>>;
+    http: z.ZodDefault<z.ZodObject<{
+        maxHeadersCount: z.ZodDefault<z.ZodNumber>;
+        keepAliveTimeout: z.ZodDefault<z.ZodNumber>;
+        timeout: z.ZodDefault<z.ZodNumber>;
+        requestTimeout: z.ZodDefault<z.ZodNumber>;
+        responseTimeout: z.ZodDefault<z.ZodNumber>;
+        shutdownTimeout: z.ZodDefault<z.ZodNumber>;
+        headers: z.ZodDefault<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    }, z.core.$loose>>;
+    https: z.ZodDefault<z.ZodObject<{
+        maxHeadersCount: z.ZodDefault<z.ZodNumber>;
+        keepAliveTimeout: z.ZodDefault<z.ZodNumber>;
+        timeout: z.ZodDefault<z.ZodNumber>;
+        requestTimeout: z.ZodDefault<z.ZodNumber>;
+        responseTimeout: z.ZodDefault<z.ZodNumber>;
+        shutdownTimeout: z.ZodDefault<z.ZodNumber>;
+        headers: z.ZodDefault<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
+        rejectUnauthorized: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$loose>>;
+    http2: z.ZodDefault<z.ZodObject<{
+        maxConcurrentStreams: z.ZodDefault<z.ZodNumber>;
+        maxSessionMemory: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$loose>>;
+    http3: z.ZodDefault<z.ZodObject<{}, z.core.$loose>>;
+    certificates: z.ZodDefault<z.ZodObject<{
+        strategy: z.ZodDefault<z.ZodEnum<{
+            auto: "auto";
+            explicit: "explicit";
+            mkcert: "mkcert";
+            selfsigned: "selfsigned";
+        }>>;
+        ca: z.ZodDefault<z.ZodString>;
+        key: z.ZodDefault<z.ZodString>;
+        cert: z.ZodDefault<z.ZodString>;
+        privateKeyMode: z.ZodDefault<z.ZodNumber>;
+        san: z.ZodDefault<z.ZodObject<{
+            dns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            ip: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        dev: z.ZodDefault<z.ZodObject<{
+            useMkcert: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        openssl: z.ZodDefault<z.ZodObject<{
+            size: z.ZodDefault<z.ZodNumber>;
+            hash: z.ZodDefault<z.ZodEnum<{
+                sha256: "sha256";
+                sha384: "sha384";
+                sha512: "sha512";
+            }>>;
+            validityDays: z.ZodDefault<z.ZodNumber>;
+            backdateMinutes: z.ZodDefault<z.ZodNumber>;
+            attrs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                value: z.ZodOptional<z.ZodString>;
+                shortName: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    websocket: z.ZodDefault<z.ZodObject<{
+        keepaliveInterval: z.ZodDefault<z.ZodNumber>;
+        keepaliveGracePeriod: z.ZodDefault<z.ZodNumber>;
+        closeTimeout: z.ZodDefault<z.ZodNumber>;
+        maxPayload: z.ZodDefault<z.ZodNumber>;
+        allowedOrigins: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString, z.ZodArray<z.ZodString>]>>;
+        perMessageDeflate: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            serverNoContextTakeover: z.ZodOptional<z.ZodBoolean>;
+            clientNoContextTakeover: z.ZodOptional<z.ZodBoolean>;
+            serverMaxWindowBits: z.ZodOptional<z.ZodNumber>;
+            clientMaxWindowBits: z.ZodOptional<z.ZodNumber>;
+            threshold: z.ZodOptional<z.ZodNumber>;
+            concurrencyLimit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>]>>;
+        skipUTF8Validation: z.ZodDefault<z.ZodBoolean>;
+        autoPong: z.ZodDefault<z.ZodBoolean>;
+        allowSynchronousEvents: z.ZodDefault<z.ZodBoolean>;
+        maxBackpressure: z.ZodDefault<z.ZodNumber>;
+        backpressureCloseAfterDrops: z.ZodDefault<z.ZodNumber>;
+        backpressurePolicy: z.ZodDefault<z.ZodEnum<{
+            close: "close";
+            drop: "drop";
+        }>>;
+    }, z.core.$loose>>;
+    websocketSecure: z.ZodDefault<z.ZodObject<{
+        keepaliveInterval: z.ZodDefault<z.ZodNumber>;
+        keepaliveGracePeriod: z.ZodDefault<z.ZodNumber>;
+        closeTimeout: z.ZodDefault<z.ZodNumber>;
+        maxPayload: z.ZodDefault<z.ZodNumber>;
+        allowedOrigins: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString, z.ZodArray<z.ZodString>]>>;
+        perMessageDeflate: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+            serverNoContextTakeover: z.ZodOptional<z.ZodBoolean>;
+            clientNoContextTakeover: z.ZodOptional<z.ZodBoolean>;
+            serverMaxWindowBits: z.ZodOptional<z.ZodNumber>;
+            clientMaxWindowBits: z.ZodOptional<z.ZodNumber>;
+            threshold: z.ZodOptional<z.ZodNumber>;
+            concurrencyLimit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>]>>;
+        skipUTF8Validation: z.ZodDefault<z.ZodBoolean>;
+        autoPong: z.ZodDefault<z.ZodBoolean>;
+        allowSynchronousEvents: z.ZodDefault<z.ZodBoolean>;
+        maxBackpressure: z.ZodDefault<z.ZodNumber>;
+        backpressureCloseAfterDrops: z.ZodDefault<z.ZodNumber>;
+        backpressurePolicy: z.ZodDefault<z.ZodEnum<{
+            close: "close";
+            drop: "drop";
+        }>>;
+    }, z.core.$loose>>;
+    statics: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        defaultOptions: z.ZodDefault<z.ZodObject<{
+            cacheControl: z.ZodOptional<z.ZodBoolean>;
+            maxAge: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+        web: z.ZodDefault<z.ZodObject<{
+            path: z.ZodString;
+            options: z.ZodOptional<z.ZodObject<{
+                cacheControl: z.ZodOptional<z.ZodBoolean>;
+                maxAge: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+    session: z.ZodDefault<z.ZodObject<{
+        strictMode: z.ZodDefault<z.ZodBoolean>;
+        name: z.ZodDefault<z.ZodString>;
+        store: z.ZodDefault<z.ZodString>;
+        gcIntervalS: z.ZodDefault<z.ZodNumber>;
+        gcJitter: z.ZodDefault<z.ZodBoolean>;
+        idleTimeoutS: z.ZodDefault<z.ZodNumber>;
+        absoluteTimeoutS: z.ZodDefault<z.ZodNumber>;
+        refererCheck: z.ZodDefault<z.ZodBoolean>;
+        cookie: z.ZodDefault<z.ZodObject<{
+            maxAge: z.ZodDefault<z.ZodNumber>;
+            httpOnly: z.ZodDefault<z.ZodBoolean>;
+            secure: z.ZodDefault<z.ZodBoolean>;
+            signed: z.ZodDefault<z.ZodBoolean>;
+            hostPrefix: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    rateLimit: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        windowS: z.ZodDefault<z.ZodNumber>;
+        max: z.ZodDefault<z.ZodNumber>;
+        maxTracked: z.ZodDefault<z.ZodNumber>;
+        gcIntervalS: z.ZodDefault<z.ZodNumber>;
+        gcJitter: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    health: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        livenessPath: z.ZodDefault<z.ZodString>;
+        readinessPath: z.ZodDefault<z.ZodString>;
+        shutdownDelay: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$loose>>;
+    wsMaxConnectionsPerIp: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strict>;
+/** Type de sortie (config normalisée + défauts appliqués). */
+export type HttpConfig = z.infer<typeof httpConfigSchema>;
+/** Type d'entrée (toutes sections omissibles — défauts du schéma). */
+export type HttpConfigInput = z.input<typeof httpConfigSchema>;
+/**
+ * Défauts du module, matérialisés depuis le schéma (source unique). Toujours
+ * valides par construction ; passés au `super(..., config)` du Module class.
+ */
+declare const config: HttpConfig;
+export default config;