@nodefony/frontend 10.0.0-alpha.3 → 10.0.0-alpha.5

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

@@ -1,4 +1,4 @@
-//#region \0@oxc-project+runtime@0.148.0/helpers/esm/decorate.js
+//#region \0@oxc-project+runtime@0.149.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.148.0 → _@oxc-project_runtime@0.149.0}/helpers/esm/decorateMetadata.js

@@ -1,4 +1,4 @@
-//#region \0@oxc-project+runtime@0.148.0/helpers/esm/decorateMetadata.js
+//#region \0@oxc-project+runtime@0.149.0/helpers/esm/decorateMetadata.js
 function __decorateMetadata(k, v) {
 	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }

package/dist/index.js

@@ -10,8 +10,8 @@ import { ViteBuilder } from "./nodefony/src/builders/ViteBuilder.js";
 import { ViteConfigGenerator } from "./nodefony/service/ViteConfigGenerator.js";
 import { ViteProcessSupervisor } from "./nodefony/service/ViteProcessSupervisor.js";
 import { TemplateHelper } from "./nodefony/src/template/TemplateHelper.js";
-import __decorateMetadata from "./_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateMetadata.js";
-import __decorate from "./_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.js";
+import __decorateMetadata from "./_virtual/_@oxc-project_runtime@0.149.0/helpers/esm/decorateMetadata.js";
+import __decorate from "./_virtual/_@oxc-project_runtime@0.149.0/helpers/esm/decorate.js";
 import FrontendService_default from "./nodefony/service/FrontendService.js";
 import { buildFrontendStatus, createFrontendAdminApi } from "./nodefony/src/FrontendAdminApi.js";
 import FrontendBuild from "./nodefony/command/frontend-build.js";

package/dist/nodefony/config/config.js

@@ -42,7 +42,7 @@ const resilienceSchema = z.strictObject({
 const frontendConfigSchema = z.strictObject({
 	devHost: z.string().default("127.0.0.1").describe("Host d'écoute du dev server Vite — utilisé tel quel dans les `<script>` injectés (doit être joignable depuis le navigateur). Prod : N/A (Vite ne tourne pas en prod, le manifest pilote)."),
 	devPort: z.number().int().positive().default(5173).describe("Port d'écoute du dev server Vite (5173 par défaut) — port de BASE : chaque famille de frontends prend le bloc suivant. Si occupé, c'est le SUPERVISEUR qui relance sur le port suivant (`resilience.portRetryAttempts` essais) et publie le port réel dans son `status()` — Vite, lui, ne se décale jamais seul : le fichier généré porte `strictPort` pour que l'origine annoncée au navigateur soit toujours celle qui sert."),
-	publicOrigin: z.string().default("").refine((v) => v === "" || /^https?:\/\/[^/\s]+$/.test(v), { message: "publicOrigin doit être une origine (`scheme://host[:port]`), sans chemin" }).describe("Origine PUBLIQUE du dev server Vite — celle que le NAVIGATEUR utilise, quand elle diffère de l'adresse d'écoute (`devHost`). ÉPINGLE le rendu sur une origine unique : à réserver aux cas où un frontal la réécrit (tunnel, proxy, port remappé). Utilisée telle quelle (port inclus SEULEMENT si écrit) dans les `<script>` injectés, le `base` Vite et le WebSocket HMR (`hmr.host`/`clientPort`, dérivés). Vide (défaut, RECOMMANDÉ) = chaque page annonce l'origine par laquelle le client est arrivé (`Host` de la requête, scheme et port de Vite) : un poste et un navigateur en conteneur sont servis EN MÊME TEMPS par la même instance, sans configuration — et Codespaces/Gitpod restent détectés automatiquement. L'hôte d'une origine épinglée est automatiquement autorisé par Vite (`server.allowedHosts`) ; les hôtes suivis par la dérivation sont ceux de `trustedHosts` de @nodefony/http (une seule liste à maintenir : elle ouvre la barrière 421, Vite, le CSP et le rendu)."),
+	publicOrigin: z.string().default("").refine((v) => v === "" || /^https?:\/\/[^/\s]+$/.test(v), { message: "publicOrigin doit être une origine (`scheme://host[:port]`), sans chemin" }).describe("Origine PUBLIQUE du dev server Vite — celle que le NAVIGATEUR utilise, quand elle diffère de l'adresse d'écoute (`devHost`). ÉPINGLE le rendu sur une origine unique : à réserver aux cas où un frontal la réécrit (tunnel, proxy, port remappé). Utilisée telle quelle (port inclus SEULEMENT si écrit) dans les `<script>` injectés, le `base` Vite et le WebSocket HMR (`hmr.host`/`clientPort`, dérivés). Vide (défaut, RECOMMANDÉ) = chaque page annonce l'origine par laquelle le client est arrivé (`Host` de la requête, scheme et port de Vite) : un poste et un navigateur en conteneur sont servis EN MÊME TEMPS par la même instance, sans configuration. Codespaces/Gitpod sont détectés automatiquement et fournissent alors l'origine par défaut — MAIS un client arrivé par la boucle locale (tunnel de port : VS Code Desktop le fait par défaut) reste servi en local, parce que l'origine publique d'une plateforme exige sa session, qu'une intégration continue ou une sonde n'a pas. Une origine écrite ICI, en revanche, gagne sur tout — c'est un réglage, pas une déduction. L'hôte d'une origine épinglée est automatiquement autorisé par Vite (`server.allowedHosts`) ; les hôtes suivis par la dérivation sont ceux de `trustedHosts` de @nodefony/http (une seule liste à maintenir : elle ouvre la barrière 421, Vite, le CSP et le rendu)."),
 	autoStartInDevelopment: z.boolean().default(true).describe("Démarre automatiquement le superviseur Vite quand le kernel passe en `development`. Ignoré en `production`/`staging`. Reco : true en dev, sinon les helpers template injecteront une URL morte."),
 	defaultOutDir: z.string().default("./public/dist").describe("Dossier de sortie par défaut pour le build prod, relatif à la racine du module consommateur. Réécrit par la prop `outDir` de la déclaration d'entrée."),
 	defaultRoot: z.string().default("./frontend").describe("Racine front par défaut (contient `index.html`) côté module."),

package/dist/nodefony/service/FrontendService.js

@@ -1,12 +1,12 @@
 import config from "../config/config.js";
 import { FrontendNoEntriesError, FrontendSupervisorStartError } from "../src/errors/FrontendError.js";
 import { ViteBuilder } from "../src/builders/ViteBuilder.js";
-import { allowedHostPatternForTemplate, detectRemoteDev, isValidOriginTemplate, viteAllowedHostFromPattern } from "../src/remoteDev.js";
+import { allowedHostPatternForTemplate, detectRemoteDev, isLoopbackHostname, isValidOriginTemplate, viteAllowedHostFromPattern } from "../src/remoteDev.js";
 import { ViteProcessSupervisor } from "./ViteProcessSupervisor.js";
 import { TemplateHelper } from "../src/template/TemplateHelper.js";
 import { familyPortBlocks, familyPortPlan, isolationGroup } from "../src/isolationGroups.js";
-import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateMetadata.js";
-import __decorate from "../../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.js";
+import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.149.0/helpers/esm/decorateMetadata.js";
+import __decorate from "../../_virtual/_@oxc-project_runtime@0.149.0/helpers/esm/decorate.js";
 import { Module, Service, extend, injectable, stripTrailingSlashes } from "nodefony";
 import path from "node:path";
 import fs from "node:fs";
@@ -47,12 +47,23 @@ let FrontendService = class FrontendService extends Service {
 	/** Helper prod unique (lit les manifests) — `null` tant qu'on n'est pas en prod. */
 	prodHelper = null;
 	/**
-	* L'origine publique est-elle ÉPINGLÉE par une décision explicite
-	* (`frontend.publicOrigin` en config, ou plateforme de dev déporté détectée) ?
-	* `true` → la dérivation par `Host` est désactivée : un réglage voulu gagne
-	* toujours sur une déduction (cf ordre de priorité, README du module).
+	* QUI a épinglé l'origine publique — la question n'est pas « est-elle
+	* épinglée » mais « par quoi », car les deux sources n'ont pas la même
+	* autorité :
+	*
+	*  - `"config"` — `frontend.publicOrigin` : une décision ÉCRITE par l'auteur.
+	*    Elle gagne sur tout, y compris sur le `Host` reçu : c'est le sens même
+	*    d'un réglage explicite, et le seul moyen de servir derrière un frontal
+	*    qui réécrit l'origine.
+	*  - `"platform"` — Codespaces/Gitpod déduits de l'environnement : une
+	*    DÉDUCTION, faite une fois au démarrage, sur une machine qui reçoit
+	*    simultanément des clients arrivés par des chemins différents. Elle ne
+	*    peut donc pas prévaloir sur un fait constaté à la requête — un client
+	*    venu de la boucle locale se sert en local (cf `derivableHost`).
+	*  - `null` — rien d'épinglé : chaque page annonce l'origine par laquelle son
+	*    client est arrivé.
 	*/
-	originPinned = false;
+	originPinnedBy = null;
 	/**
 	* Ports que l'instance Vite de chaque famille PEUT prendre pour ce démarrage
 	* (bloc de la famille, port-retry compris) — `null` tant que `startDev` n'a
@@ -195,8 +206,9 @@ let FrontendService = class FrontendService extends Service {
 		if (this.supervisors.size > 0 && [...this.supervisors.values()].some((s) => s.status().state === "ready")) return;
 		const backendOrigin = `${this.cfg.backendProtocol}://${this.cfg.backendHost}:${this.resolveBackendPort()}`;
 		const https = this.resolveHttps();
-		const publicOriginTemplate = this.resolvePublicOriginTemplate();
-		this.originPinned = publicOriginTemplate !== void 0;
+		const pinned = this.resolvePublicOrigin();
+		const publicOriginTemplate = pinned?.template;
+		this.originPinnedBy = pinned?.source ?? null;
 		const allowedHosts = this.viteAllowedHosts(publicOriginTemplate);
 		const nodeEnv = this.kernel?.environment;
 		const extraEnv = this.cfg.viteEnv ?? {};
@@ -279,28 +291,43 @@ let FrontendService = class FrontendService extends Service {
 		};
 	}
 	/**
-	* Template d'origine publique Vite (P14.17). Priorité : `frontend.publicOrigin`
-	* (config, validée — invalide = ERROR + ignorée, jamais un boot cassé) puis
-	* détection de plateforme (Codespaces/Gitpod — variables documentées de la
-	* plateforme, qu'on lit sans les posséder). `undefined` = dérivation locale.
+	* Template d'origine publique Vite (P14.17), AVEC sa provenance. Priorité :
+	* `frontend.publicOrigin` (config, validée — invalide = ERROR + ignorée,
+	* jamais un boot cassé) puis détection de plateforme (Codespaces/Gitpod —
+	* variables documentées de la plateforme, qu'on lit sans les posséder).
+	* `null` = dérivation locale.
+	*
+	* La provenance est rendue avec le template parce qu'elle CHANGE la suite :
+	* une config écrite est un ordre, une plateforme déduite est une supposition
+	* qui cède devant le `Host` reçu quand celui-ci désigne la boucle locale
+	* (cf `originPinnedBy`). Les confondre servait l'origine publique à un client
+	* venu d'un tunnel local, qui n'a pas la session de la plateforme.
+	*
 	* Chaque adaptation est JOURNALISÉE : on doit pouvoir lire dans le boot
 	* pourquoi les `<script>` pointent où ils pointent.
 	*/
-	resolvePublicOriginTemplate() {
+	resolvePublicOrigin() {
 		const cfgOrigin = this.cfg.publicOrigin;
 		if (cfgOrigin) {
 			if (!isValidOriginTemplate(cfgOrigin)) {
 				this.log(`frontend.publicOrigin invalide (« ${cfgOrigin} ») — attendu scheme://host[:port|:{port}] sans chemin ; origine locale utilisée`, "ERROR");
-				return;
+				return null;
 			}
 			this.log(`origine publique Vite (config) : ${cfgOrigin}`, "INFO");
-			return cfgOrigin;
+			return {
+				template: cfgOrigin,
+				source: "config"
+			};
 		}
 		const detected = detectRemoteDev(process.env);
 		if (detected) {
-			this.log(`dev déporté détecté (${detected.provider}) — origine publique Vite : ` + detected.originTemplate, "INFO");
-			return detected.originTemplate;
+			this.log(`dev déporté détecté (${detected.provider}) — origine publique Vite : ${detected.originTemplate} (un client arrivé par la boucle locale reste servi en local)`, "INFO");
+			return {
+				template: detected.originTemplate,
+				source: "platform"
+			};
 		}
+		return null;
 	}
 	/**
 	* `server.allowedHosts` pour Vite. Vite accepte d'office IP et `localhost` ;
@@ -581,7 +608,9 @@ let FrontendService = class FrontendService extends Service {
 	*   résolue au démarrage (comportement d'avant la dérivation).
 	*/
 	derivableHost(requestHost) {
-		if (!requestHost || this.originPinned) return void 0;
+		if (!requestHost) return void 0;
+		if (this.originPinnedBy === "config") return void 0;
+		if (this.originPinnedBy === "platform" && !isLoopbackHostname(requestHost)) return;
 		const httpKernel = this.container?.get?.("HttpKernel");
 		if (!httpKernel || httpKernel.trustedHosts === true) return void 0;
 		return httpKernel.isTrustedHostname?.(requestHost) === true ? requestHost : void 0;

package/dist/nodefony/service/ViteConfigGenerator.js

@@ -89,17 +89,16 @@ ${fsAllowLines}
     },
 `;
 		const allowedHostsLine = opts.allowedHosts === true ? `    allowedHosts: true,\n` : opts.allowedHosts && opts.allowedHosts.length > 0 ? `    allowedHosts: ${JSON.stringify(opts.allowedHosts)},\n` : "";
-		const hmrLine = opts.hmr ? `    hmr: { host: ${JSON.stringify(opts.hmr.host)}, clientPort: ${opts.hmr.clientPort}, protocol: ${JSON.stringify(opts.hmr.protocol)} },\n` : "";
 		const serverBlock = proxyPaths.size > 0 ? `  server: {
     strictPort: ${strictPort},
     cors: true,
-${allowedHostsLine}${hmrLine}${httpsLines}${fsBlock}    proxy: {
+${allowedHostsLine}${httpsLines}${fsBlock}    proxy: {
 ${proxyLines}
     },
   },` : `  server: {
     strictPort: ${strictPort},
     cors: true,
-${allowedHostsLine}${hmrLine}${httpsLines}${fsBlock}  },`;
+${allowedHostsLine}${httpsLines}${fsBlock}  },`;
 		const baseLine = useViteOrigin ? `  base: ${JSON.stringify(opts.viteOrigin + "/")},\n` : "";
 		const dedupe = [];
 		if (usedTypes.has("react19")) dedupe.push("react", "react-dom");

package/dist/nodefony/service/ViteProcessSupervisor.js

@@ -240,8 +240,7 @@ var ViteProcessSupervisor = class {
 			backendOrigin: this.opts.backendOrigin,
 			viteOrigin,
 			https: this.opts.https,
-			allowedHosts: this.opts.allowedHosts,
-			hmr: resolved?.hmr
+			allowedHosts: this.opts.allowedHosts
 		});
 		writeFileSync(this.configFilePath, content, "utf8");
 		this.opts.logger.debug?.(`vite config written: ${this.configFilePath}`);

package/dist/nodefony/src/builders/ViteBuilder.js

@@ -7,6 +7,50 @@ import svelte5Preset from "../presets/svelte5-vite.js";
 import path from "node:path";
 //#region nodefony/src/builders/ViteBuilder.ts
 /**
+* Les paquets à dédupliquer pour un lot de préréglages — la règle, isolée.
+*
+* Pure et exportée pour DEUX raisons. Elle ne dépend que des préréglages
+* utilisés : la faire passer par `buildViteConfig` obligeait son test à charger
+* réellement les plugins Vite depuis le disque, et sous la contention d'une
+* passe complète ce chargement a dépassé le budget de temps par défaut — un
+* rouge qui ne disait rien du produit. Et c'est la règle même qui avait divergé
+* de son jumeau du développement : elle mérite d'être nommée.
+*
+* MÊME règle que le fichier dev généré (ViteConfigGenerator) : dans une app
+* liée (`--link`), un import `react` émis par la façade `nodefony/react`
+* (réelpathée HORS de l'app, dans le checkout) se résout dans le
+* node_modules du framework pendant qu'`App.tsx` résout celui de l'app →
+* DEUX runtimes React dans le bundle prod, hooks au dispatcher null
+* (« Cannot read properties of null (reading 'useContext') » au mount —
+* vécu ; le dev ne le voyait pas : le prébundle unifie). `resolve.dedupe`
+* force une seule résolution, celle du root Vite.
+*
+* Ce que chaque préréglage doit VRAIMENT à cette liste, mesuré dans les
+* plugins installés — parce que la moitié d'entre eux le font déjà :
+*   • react   : `@vitejs/plugin-react` ne pose AUCUN dedupe → notre ligne
+*     est la seule protection, et c'est bien celle dont l'absence a été
+*     vécue en production ;
+*   • angular : `@analogjs/vite-plugin-angular` non plus ;
+*   • vue     : `@vitejs/plugin-vue` pose `resolve: { dedupe: ["vue"] }` ;
+*   • svelte  : `@sveltejs/vite-plugin-svelte` pose `SVELTE_DEDUPED_IMPORTS`,
+*     qui couvre `svelte` ET ses sous-chemins.
+* Les deux derniers sont donc une DÉFENSE EN PROFONDEUR, pas un correctif :
+* ils gardent cette liste symétrique de celle du développement, et nous
+* rendent indépendants d'un détail d'implémentation de plugin tiers qui
+* peut disparaître à une majeure sans que personne ne le remarque.
+*
+* @param usedPresets - les préréglages effectivement présents dans les entrées
+* @returns les spécificateurs à passer à `resolve.dedupe`, dans l'ordre
+*/
+function resolveDedupe(usedPresets) {
+	const dedupe = [];
+	if (usedPresets.has("react19")) dedupe.push("react", "react-dom");
+	if (usedPresets.has("vue3")) dedupe.push("vue");
+	if (usedPresets.has("svelte5")) dedupe.push("svelte");
+	if (usedPresets.has("angular")) dedupe.push("@angular/core", "@angular/common", "@angular/platform-browser");
+	return dedupe;
+}
+/**
 * Construit la config Vite finale à partir des entrées résolues et des presets.
 *
 * Le builder ne lance JAMAIS Vite — il fournit uniquement la config. Le
@@ -47,10 +91,7 @@ var ViteBuilder = class {
 		const root = entries[0].root;
 		const outDir = entries[0].outDir;
 		const base = mode === "production" ? assetBaseUrl + entries[0].publicPath : void 0;
-		const dedupe = [];
-		if (usedPresets.has("react19")) dedupe.push("react", "react-dom");
-		if (usedPresets.has("vue3")) dedupe.push("vue");
-		if (usedPresets.has("angular")) dedupe.push("@angular/core", "@angular/common", "@angular/platform-browser");
+		const dedupe = resolveDedupe(usedPresets);
 		return {
 			mode,
 			...base ? { base } : {},
@@ -72,4 +113,4 @@ var ViteBuilder = class {
 	}
 };
 //#endregion
-export { ViteBuilder, ViteBuilder as default };
+export { ViteBuilder, ViteBuilder as default, resolveDedupe };

package/dist/nodefony/src/remoteDev.js

@@ -6,7 +6,7 @@
 * NAVIGATEUR utilise peut être toute autre chose — un forwarder TLS (Codespaces,
 * Gitpod), une passerelle de conteneur (`host.docker.internal`), un port remappé.
 * Ce module dissocie les deux : il produit l'origine publique (assets, `base`
-* Vite, WebSocket HMR) à partir d'un TEMPLATE (`{port}` substitué au port réel
+* Vite) à partir d'un TEMPLATE (`{port}` substitué au port réel
 * du spawn) — explicite (`frontend.publicOrigin`) ou détecté depuis
 * l'environnement de la plateforme.
 *
@@ -15,7 +15,7 @@
 *
 * Formats VÉRIFIÉS (docs officielles + source Vite 8) :
 *  - Codespaces : `https://${CODESPACE_NAME}-${port}.${GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN}`
-*    (TLS terminé par le forwarder → WS HMR en `wss` sur 443).
+*    (TLS terminé par le forwarder ; le socket HMR s'en déduit côté client).
 *  - Gitpod classic : `https://${port}-<hôte de GITPOD_WORKSPACE_URL>`.
 *  - Vite `server.allowedHosts` : IP et `localhost`/`*.localhost` TOUJOURS
 *    acceptés ; un préfixe `.` = le domaine ET tous ses sous-domaines.
@@ -25,6 +25,12 @@
 /** Placeholder substitué par le port réel du spawn dans un template d'origine. */
 const PORT_PLACEHOLDER = "{port}";
 /**
+* `127.0.0.0/8` avec des octets BORNÉS (0-255). Pas de quantificateur imbriqué
+* ni d'alternance qui se chevauche : linéaire sur toute entrée, y compris
+* forgée (le `Host` est une donnée cliente).
+*/
+const LOOPBACK_V4_RE = /^127\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/;
+/**
 * Template d'origine publique : `scheme://hostTemplate[:portTemplate]`, sans
 * chemin. `{port}` peut apparaître dans l'hôte (Codespaces/Gitpod : port encodé
 * dans le sous-domaine) OU en position de port (`host:{port}`).
@@ -41,6 +47,34 @@ const ORIGIN_TEMPLATE_RE = /^(https?):\/\/([^/:\s]+)(?::(\d+|\{port\}))?$/;
 function browserReachableHost(listenHost) {
 	return listenHost === "0.0.0.0" || listenHost === "::" || listenHost === "[::]" || listenHost === "" ? "127.0.0.1" : listenHost;
 }
+/**
+* Le client est-il arrivé par la BOUCLE LOCALE de la machine qui sert ?
+*
+* Ce n'est pas une commodité : c'est un fait vérifiable qui prime sur toute
+* déduction faite au démarrage. Une plateforme de dev déporté se détecte par
+* une variable d'environnement — donc UNE FOIS, au lancement du serveur — alors
+* qu'un même serveur reçoit simultanément des clients arrivés par des chemins
+* différents : l'origine publique de la plateforme, et un tunnel local (VS Code
+* Desktop redirige les ports d'un Codespace sur `localhost`, c'est sa
+* configuration par défaut).
+*
+* Servir l'origine publique à un client venu du tunnel a un coût réel : cette
+* origine exige la session de la plateforme. Un navigateur humain la porte et
+* ne voit rien ; une intégration continue, une sonde ou un agent ne l'ont pas,
+* se font refuser, et obtiennent une page blanche que rien n'explique.
+*
+* La liste est FERMÉE, et c'est ce qui la rend sûre : le `Host` est une donnée
+* cliente, et seuls ces noms désignent la machine locale de façon non
+* ambiguë. `0.0.0.0`/`::` en sont exclus — ce sont des adresses d'écoute, pas
+* des destinations (cf `browserReachableHost`).
+*
+* @param hostname - nom d'hôte NU, sans port (`[::1]` pour l'IPv6 canonique).
+* @returns `true` si ce nom désigne la boucle locale.
+*/
+function isLoopbackHostname(hostname) {
+	if (hostname === "localhost" || hostname === "::1" || hostname === "[::1]") return true;
+	return LOOPBACK_V4_RE.test(hostname);
+}
 /** Un template d'origine est-il syntaxiquement valide ? (autorité unique) */
 function isValidOriginTemplate(template) {
 	return ORIGIN_TEMPLATE_RE.test(template);
@@ -79,9 +113,10 @@ function originWithHostname(origin, hostname) {
 /**
 * Résout un template d'origine contre le port RÉEL du spawn. Pure.
 *
-* @returns origine + config HMR cliente, ou `null` si le template est invalide
+* @returns l'origine publique, ou `null` si le template est invalide
 *   (l'appelant retombe sur la dérivation locale en l'ANNONÇANT — jamais en
-*   silence).
+*   silence). Aucune config HMR n'est rendue : le socket suit l'origine par
+*   laquelle le client Vite a été chargé, il n'a rien à recevoir.
 */
 function resolveOriginTemplate(template, port) {
 	const m = ORIGIN_TEMPLATE_RE.exec(template);
@@ -89,15 +124,7 @@ function resolveOriginTemplate(template, port) {
 	const [, scheme, hostTemplate, portTemplate] = m;
 	const host = hostTemplate.replaceAll(PORT_PLACEHOLDER, String(port));
 	const explicitPort = portTemplate ? parseInt(portTemplate.replaceAll(PORT_PLACEHOLDER, String(port)), 10) : void 0;
-	const secure = scheme === "https";
-	return {
-		origin: `${scheme}://${host}${explicitPort !== void 0 ? `:${explicitPort}` : ""}`,
-		hmr: {
-			host,
-			clientPort: explicitPort ?? (secure ? 443 : 80),
-			protocol: secure ? "wss" : "ws"
-		}
-	};
+	return { origin: `${scheme}://${host}${explicitPort !== void 0 ? `:${explicitPort}` : ""}` };
 }
 /**
 * Motif `server.allowedHosts` couvrant TOUTES les origines qu'un template peut
@@ -154,4 +181,4 @@ function detectRemoteDev(env) {
 	return null;
 }
 //#endregion
-export { PORT_PLACEHOLDER, allowedHostPatternForTemplate, browserReachableHost, detectRemoteDev, isValidOriginTemplate, originWithHostname, resolveOriginTemplate, viteAllowedHostFromPattern };
+export { PORT_PLACEHOLDER, allowedHostPatternForTemplate, browserReachableHost, detectRemoteDev, isLoopbackHostname, isValidOriginTemplate, originWithHostname, resolveOriginTemplate, viteAllowedHostFromPattern };

package/dist/nodefony/src/template/TemplateHelper.js

@@ -1,4 +1,4 @@
-import { originWithHostname } from "../remoteDev.js";
+import { isLoopbackHostname, originWithHostname } from "../remoteDev.js";
 import { createRequire } from "node:module";
 import { PLATFORM_EVENTS, escapeRegExp } from "nodefony";
 import path from "node:path";
@@ -120,7 +120,7 @@ ${tags}
 		const entry = status.entries.find((e) => e.entryName === entryName);
 		if (!entry) return `<!-- @nodefony/frontend: unknown entry "${entryName}" -->`;
 		const resolvedOrigin = status.origin ?? `${status.https ? "https" : "http"}://${status.host}:${status.port}`;
-		const baseUrl = requestHost ? originWithHostname(resolvedOrigin, requestHost) ?? resolvedOrigin : resolvedOrigin;
+		const baseUrl = !requestHost ? resolvedOrigin : isLoopbackHostname(requestHost) ? `${status.https ? "https" : "http"}://${requestHost}:${status.port}` : originWithHostname(resolvedOrigin, requestHost) ?? resolvedOrigin;
 		const absEntryPath = path.resolve(entry.root, entry.entryFile).replace(/\\/g, "/");
 		const entryUrl = `${baseUrl}${absEntryPath.startsWith("/") ? `/@fs${absEntryPath}` : `/@fs/${absEntryPath}`}`;
 		const tags = [];

package/dist/types/index.d.ts

@@ -1,13 +1,13 @@
 import { Kernel, Module } from "nodefony";
 import { type IFrontendConfigInput } from "./nodefony/config/defineModuleConfig.js";
-import type { FrontendConfig } from "./nodefony/config/config.js";
+import type { IFrontendConfig } from "./nodefony/config/config.js";
 import FrontendService from "./nodefony/service/FrontendService.js";
 declare module "nodefony" {
     interface NodefonyModuleConfig {
         "@nodefony/frontend": IFrontendConfigInput;
     }
 }
-declare class Frontend extends Module<FrontendConfig> {
+declare class Frontend extends Module<IFrontendConfig> {
     constructor(kernel: Kernel);
     /** JSON Schema de la config frontend → data plane admin (config riche Studio). */
     configSchema(): unknown;
@@ -48,4 +48,4 @@ export type { IFrontBuilder, IFrontendModuleDeclaration, IResolvedFrontendEntry,
 export type { IViteSupervisor, IViteSupervisorStatus, ViteSupervisorState, } from "./nodefony/interfaces/IViteSupervisor.js";
 export type { IFrontendService } from "./nodefony/interfaces/IFrontendService.js";
 export { defineFrontendConfig, frontendConfigJsonSchema, type IFrontendConfigInput, } from "./nodefony/config/defineModuleConfig.js";
-export { frontendConfigSchema, type FrontendConfig, } from "./nodefony/config/config.js";
+export { frontendConfigSchema, type IFrontendConfig, } from "./nodefony/config/config.js";

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

@@ -29,10 +29,10 @@ export declare const frontendConfigSchema: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 /** Type de sortie (config normalisée + défauts appliqués). */
-export type FrontendConfig = z.infer<typeof frontendConfigSchema>;
+export type IFrontendConfig = z.infer<typeof frontendConfigSchema>;
 /**
  * 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: FrontendConfig;
+declare const config: IFrontendConfig;
 export default config;

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { frontendConfigSchema, type FrontendConfig } from "./config.js";
+import { frontendConfigSchema, type IFrontendConfig } from "./config.js";
 /**
  * Builder type-safe de la configuration de `@nodefony/frontend`.
  *
@@ -18,7 +18,7 @@ import { frontendConfigSchema, type FrontendConfig } from "./config.js";
  * @returns config gelée prête pour `FrontendService`.
  * @throws ZodError si invalide.
  */
-export declare function defineFrontendConfig(config?: IFrontendConfigInput): FrontendConfig;
+export declare function defineFrontendConfig(config?: IFrontendConfigInput): IFrontendConfig;
 /**
  * JSON Schema introspectable de la config frontend — destiné au panneau de config
  * Studio (`/nodefony/config`).
@@ -26,4 +26,3 @@ export declare function defineFrontendConfig(config?: IFrontendConfigInput): Fro
 export declare function frontendConfigJsonSchema(): unknown;
 /** Entrée du builder (champs avec défaut optionnels). */
 export type IFrontendConfigInput = z.input<typeof frontendConfigSchema>;
-export type { FrontendConfig };

package/dist/types/nodefony/service/FrontendService.d.ts

@@ -29,12 +29,23 @@ declare class FrontendService extends Service implements IFrontendService {
     /** Helper prod unique (lit les manifests) — `null` tant qu'on n'est pas en prod. */
     private prodHelper;
     /**
-     * L'origine publique est-elle ÉPINGLÉE par une décision explicite
-     * (`frontend.publicOrigin` en config, ou plateforme de dev déporté détectée) ?
-     * `true` → la dérivation par `Host` est désactivée : un réglage voulu gagne
-     * toujours sur une déduction (cf ordre de priorité, README du module).
-     */
-    private originPinned;
+     * QUI a épinglé l'origine publique — la question n'est pas « est-elle
+     * épinglée » mais « par quoi », car les deux sources n'ont pas la même
+     * autorité :
+     *
+     *  - `"config"` — `frontend.publicOrigin` : une décision ÉCRITE par l'auteur.
+     *    Elle gagne sur tout, y compris sur le `Host` reçu : c'est le sens même
+     *    d'un réglage explicite, et le seul moyen de servir derrière un frontal
+     *    qui réécrit l'origine.
+     *  - `"platform"` — Codespaces/Gitpod déduits de l'environnement : une
+     *    DÉDUCTION, faite une fois au démarrage, sur une machine qui reçoit
+     *    simultanément des clients arrivés par des chemins différents. Elle ne
+     *    peut donc pas prévaloir sur un fait constaté à la requête — un client
+     *    venu de la boucle locale se sert en local (cf `derivableHost`).
+     *  - `null` — rien d'épinglé : chaque page annonce l'origine par laquelle son
+     *    client est arrivé.
+     */
+    private originPinnedBy;
     /**
      * Ports que l'instance Vite de chaque famille PEUT prendre pour ce démarrage
      * (bloc de la famille, port-retry compris) — `null` tant que `startDev` n'a
@@ -100,14 +111,22 @@ declare class FrontendService extends Service implements IFrontendService {
      */
     private resolveHttps;
     /**
-     * Template d'origine publique Vite (P14.17). Priorité : `frontend.publicOrigin`
-     * (config, validée — invalide = ERROR + ignorée, jamais un boot cassé) puis
-     * détection de plateforme (Codespaces/Gitpod — variables documentées de la
-     * plateforme, qu'on lit sans les posséder). `undefined` = dérivation locale.
+     * Template d'origine publique Vite (P14.17), AVEC sa provenance. Priorité :
+     * `frontend.publicOrigin` (config, validée — invalide = ERROR + ignorée,
+     * jamais un boot cassé) puis détection de plateforme (Codespaces/Gitpod —
+     * variables documentées de la plateforme, qu'on lit sans les posséder).
+     * `null` = dérivation locale.
+     *
+     * La provenance est rendue avec le template parce qu'elle CHANGE la suite :
+     * une config écrite est un ordre, une plateforme déduite est une supposition
+     * qui cède devant le `Host` reçu quand celui-ci désigne la boucle locale
+     * (cf `originPinnedBy`). Les confondre servait l'origine publique à un client
+     * venu d'un tunnel local, qui n'a pas la session de la plateforme.
+     *
      * Chaque adaptation est JOURNALISÉE : on doit pouvoir lire dans le boot
      * pourquoi les `<script>` pointent où ils pointent.
      */
-    private resolvePublicOriginTemplate;
+    private resolvePublicOrigin;
     /**
      * `server.allowedHosts` pour Vite. Vite accepte d'office IP et `localhost` ;
      * cette liste ne porte que les NOMS. Source des noms légitimes = la MÊME que

package/dist/types/nodefony/service/ViteConfigGenerator.d.ts

@@ -39,17 +39,6 @@ export interface ViteConfigGeneratorOptions {
      * sert que les NOMS (vhosts, `host.docker.internal`, forwarders).
      */
     readonly allowedHosts?: true | ReadonlyArray<string>;
-    /**
-     * Config `server.hmr` CLIENTE — où le navigateur ouvre le WebSocket HMR
-     * quand un intermédiaire (forwarder TLS, passerelle conteneur) sépare
-     * l'origine publique de l'adresse d'écoute. Absent = fallback client Vite
-     * (`location.hostname` + port d'écoute), correct en local.
-     */
-    readonly hmr?: {
-        readonly host: string;
-        readonly clientPort: number;
-        readonly protocol: "ws" | "wss";
-    };
 }
 export declare class ViteConfigGenerator {
     /**

package/dist/types/nodefony/src/builders/ViteBuilder.d.ts

@@ -1,5 +1,42 @@
 import type { IFrontBuilder, IResolvedFrontendEntry } from "../../interfaces/IFrontBuilder.js";
 import type { IFrontPreset } from "../../interfaces/IFrontPreset.js";
+/**
+ * Les paquets à dédupliquer pour un lot de préréglages — la règle, isolée.
+ *
+ * Pure et exportée pour DEUX raisons. Elle ne dépend que des préréglages
+ * utilisés : la faire passer par `buildViteConfig` obligeait son test à charger
+ * réellement les plugins Vite depuis le disque, et sous la contention d'une
+ * passe complète ce chargement a dépassé le budget de temps par défaut — un
+ * rouge qui ne disait rien du produit. Et c'est la règle même qui avait divergé
+ * de son jumeau du développement : elle mérite d'être nommée.
+ *
+ * MÊME règle que le fichier dev généré (ViteConfigGenerator) : dans une app
+ * liée (`--link`), un import `react` émis par la façade `nodefony/react`
+ * (réelpathée HORS de l'app, dans le checkout) se résout dans le
+ * node_modules du framework pendant qu'`App.tsx` résout celui de l'app →
+ * DEUX runtimes React dans le bundle prod, hooks au dispatcher null
+ * (« Cannot read properties of null (reading 'useContext') » au mount —
+ * vécu ; le dev ne le voyait pas : le prébundle unifie). `resolve.dedupe`
+ * force une seule résolution, celle du root Vite.
+ *
+ * Ce que chaque préréglage doit VRAIMENT à cette liste, mesuré dans les
+ * plugins installés — parce que la moitié d'entre eux le font déjà :
+ *   • react   : `@vitejs/plugin-react` ne pose AUCUN dedupe → notre ligne
+ *     est la seule protection, et c'est bien celle dont l'absence a été
+ *     vécue en production ;
+ *   • angular : `@analogjs/vite-plugin-angular` non plus ;
+ *   • vue     : `@vitejs/plugin-vue` pose `resolve: { dedupe: ["vue"] }` ;
+ *   • svelte  : `@sveltejs/vite-plugin-svelte` pose `SVELTE_DEDUPED_IMPORTS`,
+ *     qui couvre `svelte` ET ses sous-chemins.
+ * Les deux derniers sont donc une DÉFENSE EN PROFONDEUR, pas un correctif :
+ * ils gardent cette liste symétrique de celle du développement, et nous
+ * rendent indépendants d'un détail d'implémentation de plugin tiers qui
+ * peut disparaître à une majeure sans que personne ne le remarque.
+ *
+ * @param usedPresets - les préréglages effectivement présents dans les entrées
+ * @returns les spécificateurs à passer à `resolve.dedupe`, dans l'ordre
+ */
+export declare function resolveDedupe(usedPresets: ReadonlySet<IFrontPreset["type"]>): string[];
 /**
  * Construit la config Vite finale à partir des entrées résolues et des presets.
  *