@nodefony/frontend 10.0.0-beta.1 → 10.0.0-beta.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (25) hide show
  1. package/README.md +56 -68
  2. package/dist/_virtual/{_@oxc-project_runtime@0.151.0 → _@oxc-project_runtime@0.153.0}/helpers/esm/decorate.js +1 -1
  3. package/dist/_virtual/{_@oxc-project_runtime@0.151.0 → _@oxc-project_runtime@0.153.0}/helpers/esm/decorateMetadata.js +1 -1
  4. package/dist/index.js +2 -2
  5. package/dist/nodefony/config/config.js +3 -8
  6. package/dist/nodefony/service/FrontendService.js +73 -295
  7. package/dist/nodefony/service/ViteConfigGenerator.js +11 -30
  8. package/dist/nodefony/service/ViteProcessSupervisor.js +17 -12
  9. package/dist/nodefony/service/bootSummary.js +44 -0
  10. package/dist/nodefony/src/isolationGroups.js +27 -32
  11. package/dist/nodefony/src/template/TemplateHelper.js +52 -19
  12. package/dist/types/nodefony/config/config.d.ts +0 -8
  13. package/dist/types/nodefony/interfaces/IFrontBuilder.d.ts +0 -9
  14. package/dist/types/nodefony/interfaces/IFrontendService.d.ts +6 -10
  15. package/dist/types/nodefony/interfaces/IViteSupervisor.d.ts +11 -5
  16. package/dist/types/nodefony/service/FrontendService.d.ts +24 -118
  17. package/dist/types/nodefony/service/ViteConfigGenerator.d.ts +13 -21
  18. package/dist/types/nodefony/service/ViteProcessSupervisor.d.ts +13 -16
  19. package/dist/types/nodefony/service/bootSummary.d.ts +23 -0
  20. package/dist/types/nodefony/src/isolationGroups.d.ts +24 -23
  21. package/dist/types/nodefony/src/template/TemplateHelper.d.ts +23 -7
  22. package/docs/index.md +173 -145
  23. package/package.json +12 -13
  24. package/dist/nodefony/src/remoteDev.js +0 -216
  25. package/dist/types/nodefony/src/remoteDev.d.ts +0 -152
@@ -0,0 +1,44 @@
1
+ //#region nodefony/service/bootSummary.ts
2
+ /**
3
+ * Résume les instances Vite pour le bilan de démarrage — fonction PURE (les
4
+ * statuts sont lus par l'appelant), éprouvable sans lancer Vite.
5
+ *
6
+ * @param statuses - l'état de chaque superviseur Vite, après démarrage.
7
+ * @returns lignes de détail, nombre d'instances prêtes, point d'attention.
8
+ */
9
+ function summarizeFrontendBoot(statuses) {
10
+ const lines = [];
11
+ const failed = [];
12
+ let ready = 0;
13
+ for (const st of statuses) {
14
+ const names = st.entries.map((e) => e.entryName).join(", ");
15
+ if (st.state === "ready") {
16
+ ready++;
17
+ lines.push(`${names} · Vite interne${st.port === null ? "" : ` :${st.port}`}`);
18
+ } else {
19
+ failed.push(names);
20
+ const state = st.state === "errored" || st.state === "crashed" ? "en échec" : `pas prêt (${st.state})`;
21
+ lines.push(`${names} · Vite ${state}${st.lastError ? ` — ${st.lastError}` : ""}`);
22
+ }
23
+ }
24
+ let notice = null;
25
+ if (statuses.length > 0 && ready === 0) notice = {
26
+ code: "FRONTEND_BUILD_FAILED",
27
+ level: "error",
28
+ message: "Aucune instance Vite n'est prête — aucun bundle n'est servi",
29
+ fix: "nodefony development --debug (journal Vite complet)"
30
+ };
31
+ else if (failed.length > 0) notice = {
32
+ code: "FRONTEND_PARTIAL",
33
+ level: "warning",
34
+ message: `Vite pas prêt pour ${failed.join(" · ")} — les autres bundles sont servis`,
35
+ fix: "nodefony development --debug (journal Vite complet)"
36
+ };
37
+ return {
38
+ ready,
39
+ lines,
40
+ notice
41
+ };
42
+ }
43
+ //#endregion
44
+ export { summarizeFrontendBoot };
@@ -45,6 +45,32 @@ function isolationGroup(type) {
45
45
  }
46
46
  }
47
47
  /**
48
+ * Espace d'URL réservé aux serveurs Vite de développement, sur l'origine de
49
+ * Nodefony. Chaque famille y a son sous-préfixe (cf {@link devBasePath}).
50
+ */
51
+ const DEV_BASE_ROOT = "/_vite/";
52
+ /**
53
+ * Chemin de base Vite d'une famille en développement (`/_vite/<famille>/`).
54
+ *
55
+ * Vite fabrique ses URLs d'assets RELATIVES AU DOCUMENT : une image importée
56
+ * devient `/<base>/src/logo.png`, que le navigateur résout contre l'origine de
57
+ * la page — servie par Nodefony, pas par Vite. Un préfixe réservé rend ces
58
+ * URLs reconnaissables : Nodefony les relaie (307) vers le serveur Vite, sans
59
+ * collision possible avec les routes de l'application. Un préfixe PAR famille,
60
+ * parce que chaque famille a son instance Vite, sur son port : le relais doit
61
+ * savoir vers laquelle renvoyer.
62
+ *
63
+ * `base` est l'option que Vite honore partout — dev classique, dev bundlé,
64
+ * socket HMR, `@vitejs/plugin-vue`, publicDir —, contrairement à
65
+ * `server.origin`, ignoré en mode bundlé.
66
+ *
67
+ * @param family - clé de famille ({@link isolationGroup})
68
+ * @returns le chemin, `/` en tête et en fin
69
+ */
70
+ function devBasePath(family) {
71
+ return `${DEV_BASE_ROOT}${family}/`;
72
+ }
73
+ /**
48
74
  * Famille servie sur le port de base (`devPort`). Les autres familles prennent
49
75
  * les blocs de ports suivants. Garder `default` ici garantit que l'instance
50
76
  * principale (React/Svelte/vanilla/Studio) reste sur le port habituel (5173).
@@ -81,36 +107,5 @@ function familyPortPlan(devPort, families, portRetryAttempts) {
81
107
  });
82
108
  return plan;
83
109
  }
84
- /**
85
- * Bloc de ports de chaque famille : tous les ports que SON instance Vite peut
86
- * prendre, port-retry compris.
87
- *
88
- * Le plan seul ne dit que le port ESPÉRÉ ; sur `EADDRINUSE` le superviseur
89
- * glisse dans son bloc. Un CSP construit sur le seul port espéré laisse la page
90
- * sans rechargement à chaud dès que le port de base est pris — et il l'est dès
91
- * qu'un second projet tourne sur la machine.
92
- *
93
- * Rendu par famille, et non à plat : le consommateur remplace le bloc d'une
94
- * famille par son port RÉEL dès qu'il est connu. Déclarer les douze ports d'un
95
- * poste à trois familles coûte un en-tête CSP de ~8 Ko sur chaque réponse
96
- * (mesuré) — la plage est le prix d'une incertitude, elle ne doit pas survivre
97
- * à sa levée.
98
- *
99
- * Dérivé du plan plutôt que recalculé depuis `devPort` : la règle des blocs
100
- * disjoints n'est écrite qu'à un endroit, `familyPortPlan`.
101
- *
102
- * @param plan - `famille → port de base`, tel que rendu par `familyPortPlan`.
103
- * @param portRetryAttempts - tentatives de port-retry par instance (bloc = +1).
104
- * @returns `famille → ports du bloc`, croissants.
105
- */
106
- function familyPortBlocks(plan, portRetryAttempts) {
107
- const blocks = /* @__PURE__ */ new Map();
108
- for (const [family, base] of plan) {
109
- const ports = [];
110
- for (let i = 0; i <= portRetryAttempts; i++) ports.push(base + i);
111
- blocks.set(family, ports);
112
- }
113
- return blocks;
114
- }
115
110
  //#endregion
116
- export { PRIMARY_FAMILY, familyPortBlocks, familyPortPlan, isolationGroup, orderFamilies };
111
+ export { DEV_BASE_ROOT, PRIMARY_FAMILY, devBasePath, familyPortPlan, isolationGroup, orderFamilies };
@@ -1,10 +1,19 @@
1
- import { isLoopbackHostname, originWithHostname } from "../remoteDev.js";
2
1
  import { createRequire } from "node:module";
3
- import { PLATFORM_EVENTS, escapeRegExp } from "nodefony";
2
+ import { Nodefony, PLATFORM_EVENTS, escapeRegExp } from "nodefony";
4
3
  import path from "node:path";
5
4
  import fs from "node:fs";
6
5
  //#region nodefony/src/template/TemplateHelper.ts
7
6
  /**
7
+ * Chemin de base de l'instance, sans `/` final : `/_vite/default` pour
8
+ * `/_vite/default/`, vide pour `/` (doubles de test sans `base`). C'est TOUT
9
+ * le préfixe des URLs émises vers Vite : elles sont relatives à la page, que
10
+ * Nodefony relaie (proxy inverse, #528).
11
+ */
12
+ function basePathOf(status) {
13
+ const base = status.base ?? "/";
14
+ return base.endsWith("/") ? base.slice(0, -1) : base;
15
+ }
16
+ /**
8
17
  * Chemin résolu (1×, caché) du build navigateur de la debug bar Nodefony
9
18
  * (`nodefony/debugbar`). `undefined` = pas encore tenté, `null` = irrésolu.
10
19
  */
@@ -46,18 +55,40 @@ var TemplateHelper = class {
46
55
  this.assetBaseUrl = assetBaseUrl;
47
56
  }
48
57
  /**
58
+ * Origine LOCALE du serveur Vite — la cible du proxy inverse que Nodefony
59
+ * monte sur `/_vite/<famille>/` (#528). Jamais annoncée au navigateur : la
60
+ * page ne connaît que sa propre origine, Vite reste sur la boucle locale.
61
+ *
62
+ * 🔴 Seul un Vite qui SERT (`ready`, `compiling`) est une cible. Un port
63
+ * retenu par une instance tombée ou en redémarrage peut avoir été repris
64
+ * par le Vite d'une AUTRE application de la machine (même préfixe
65
+ * `/_vite/<famille>/`) : relayer vers lui servirait les sources de l'autre
66
+ * application à cette page. Le superviseur quitte `ready` dès l'`exit` de
67
+ * son processus — avant qu'un autre ne puisse reprendre le port.
68
+ *
69
+ * @returns l'origine (`http://127.0.0.1:5173`), ou `undefined` sans
70
+ * superviseur, tant que Vite n'a pas résolu son port, ou quand il ne sert
71
+ * pas (amont pas prêt : le relais répond `503`, avant tout `101` pour la
72
+ * socket — le client Vite ne recharge la page qu'une fois Vite revenu)
73
+ */
74
+ devTarget() {
75
+ if (!this.supervisor) return void 0;
76
+ const status = this.supervisor.status();
77
+ if (status.port === null) return void 0;
78
+ if (status.state !== "ready" && status.state !== "compiling") return;
79
+ return status.origin ?? `${status.https ? "https" : "http"}://${status.host}:${status.port}`;
80
+ }
81
+ /**
49
82
  * Tags à injecter dans `<head>` (ou avant `</body>`) pour une entrée donnée.
83
+ * En développement, toutes les URLs vers Vite sont relatives à la page
84
+ * (`/_vite/<famille>/…`) : Nodefony les relaie, la page n'a qu'une origine.
85
+ *
50
86
  * @param entryName nom logique de l'entrée (matche `entryName` dans IResolvedFrontendEntry)
51
87
  * @param nonce nonce CSP de la requête (`Context.cspNonce`) — posé sur les `<script>`
52
88
  * pour satisfaire `script-src 'nonce-…'` (preamble inline dev + entrée prod).
53
- * @param requestHost nom d'hôte par lequel le client a demandé la PAGE
54
- * (`Context.domain`, sans port). Dev : l'origine des assets est réécrite
55
- * sur ce nom (scheme et port restent ceux de Vite) → poste et conteneur
56
- * servis par la même instance. Prod : **ignoré** — les URLs du manifest
57
- * sont relatives au document, elles suivent déjà l'hôte de la page.
58
89
  */
59
- renderTags(entryName, nonce, requestHost) {
60
- if (this.mode === "development") return this.renderDevTags(entryName, nonce, requestHost);
90
+ renderTags(entryName, nonce) {
91
+ if (this.mode === "development") return this.renderDevTags(entryName, nonce);
61
92
  return this.renderProdTags(entryName, nonce);
62
93
  }
63
94
  /**
@@ -69,8 +100,8 @@ var TemplateHelper = class {
69
100
  *
70
101
  * @param entryName nom logique de l'entrée
71
102
  */
72
- renderDocument(entryName, nonce, requestHost) {
73
- const tags = this.renderTags(entryName, nonce, requestHost);
103
+ renderDocument(entryName, nonce) {
104
+ const tags = this.renderTags(entryName, nonce);
74
105
  const entry = this.entries.find((e) => e.entryName === entryName) ?? this.supervisor?.status().entries.find((e) => e.entryName === entryName);
75
106
  const html = entry ? this.loadIndexHtml(entry.root) : null;
76
107
  if (!entry || !html) return `<!DOCTYPE html>
@@ -113,14 +144,13 @@ ${tags}
113
144
  if (this.mode === "production") this.indexCache.set(root, html);
114
145
  return html;
115
146
  }
116
- renderDevTags(entryName, nonce, requestHost) {
147
+ renderDevTags(entryName, nonce) {
117
148
  if (!this.supervisor) return `<!-- @nodefony/frontend: no vite supervisor (dev) -->`;
118
149
  const status = this.supervisor.status();
119
150
  if (status.state !== "ready") return `<!-- @nodefony/frontend: vite supervisor state=${status.state} -->`;
120
151
  const entry = status.entries.find((e) => e.entryName === entryName);
121
152
  if (!entry) return `<!-- @nodefony/frontend: unknown entry "${entryName}" -->`;
122
- const resolvedOrigin = status.origin ?? `${status.https ? "https" : "http"}://${status.host}:${status.port}`;
123
- const baseUrl = !requestHost ? resolvedOrigin : isLoopbackHostname(requestHost) ? `${status.https ? "https" : "http"}://${requestHost}:${status.port}` : originWithHostname(resolvedOrigin, requestHost) ?? resolvedOrigin;
153
+ const baseUrl = basePathOf(status);
124
154
  const absEntryPath = path.resolve(entry.root, entry.entryFile).replace(/\\/g, "/");
125
155
  const entryUrl = `${baseUrl}${absEntryPath.startsWith("/") ? `/@fs${absEntryPath}` : `/@fs/${absEntryPath}`}`;
126
156
  const tags = [];
@@ -180,11 +210,14 @@ try {
180
210
  if (!debugbarFile) return `<!-- @nodefony/frontend: debugbar unresolved -->`;
181
211
  const norm = debugbarFile.replace(/\\/g, "/");
182
212
  const fsUrl = `${baseUrl}${norm.startsWith("/") ? `/@fs${norm}` : `/@fs/${norm}`}`;
183
- const opts = JSON.stringify({ frontend: {
184
- framework,
185
- name: entryName,
186
- viteOrigin: baseUrl
187
- } });
213
+ const opts = JSON.stringify({
214
+ frontend: {
215
+ framework,
216
+ name: entryName,
217
+ viteOrigin: baseUrl
218
+ },
219
+ env: Nodefony.getKernel()?.environment ?? ""
220
+ });
188
221
  return `<script type="module"${nonceAttr}>
189
222
  import { mountDebugBar } from ${JSON.stringify(fsUrl)};
190
223
  mountDebugBar(${opts});
@@ -2,20 +2,12 @@ import { z } from "zod";
2
2
  export declare const frontendConfigSchema: z.ZodObject<{
3
3
  devHost: z.ZodDefault<z.ZodString>;
4
4
  devPort: z.ZodDefault<z.ZodNumber>;
5
- publicOrigin: z.ZodDefault<z.ZodString>;
6
5
  autoStartInDevelopment: z.ZodDefault<z.ZodBoolean>;
7
6
  defaultOutDir: z.ZodDefault<z.ZodString>;
8
7
  defaultRoot: z.ZodDefault<z.ZodString>;
9
8
  assetBaseUrl: z.ZodDefault<z.ZodString>;
10
9
  startupTimeoutMs: z.ZodDefault<z.ZodNumber>;
11
10
  pipeViteLogs: z.ZodDefault<z.ZodBoolean>;
12
- backendHost: z.ZodDefault<z.ZodString>;
13
- backendPort: z.ZodDefault<z.ZodNumber>;
14
- backendProtocol: z.ZodDefault<z.ZodEnum<{
15
- http: "http";
16
- https: "https";
17
- }>>;
18
- https: z.ZodDefault<z.ZodBoolean>;
19
11
  viteEnv: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
20
12
  resilience: z.ZodDefault<z.ZodObject<{
21
13
  autoRestart: z.ZodDefault<z.ZodBoolean>;
@@ -24,13 +24,6 @@ export interface IFrontendModuleDeclaration {
24
24
  * au build ET de mount prefix au serveur statique → les deux restent alignés.
25
25
  */
26
26
  readonly publicPath?: string;
27
- /**
28
- * Préfixes de paths à proxifier depuis Vite vers Nodefony (dev only).
29
- * Sans ça, un `fetch("/poc/api/data")` depuis l'app React servie par Vite
30
- * tape Vite (qui retourne son index.html SPA-fallback) au lieu du backend.
31
- * Exemple : `["/poc/api", "/nodefony"]`.
32
- */
33
- readonly apiProxyPaths?: ReadonlyArray<string>;
34
27
  }
35
28
  /**
36
29
  * Description résolue d'une entrée front, prête à être passée au superviseur Vite.
@@ -47,8 +40,6 @@ export interface IResolvedFrontendEntry {
47
40
  * — `base` Vite en prod + mount prefix du serveur statique.
48
41
  */
49
42
  readonly publicPath: string;
50
- /** Préfixes à proxifier vers Nodefony (résolus depuis la déclaration). */
51
- readonly apiProxyPaths: ReadonlyArray<string>;
52
43
  }
53
44
  /**
54
45
  * Builder responsable de construire la config Vite finale à partir
@@ -51,23 +51,19 @@ export interface IFrontendService {
51
51
  /**
52
52
  * Helper template — retourne les balises `<script>` à injecter dans une page.
53
53
  *
54
+ * En développement, les URLs vers Vite sont RELATIVES à la page
55
+ * (`/_vite/<famille>/…`, relayées par Nodefony) : elles suivent d'elles-mêmes
56
+ * l'hôte par lequel le client est arrivé.
57
+ *
54
58
  * @param nonce nonce CSP de la requête (`Context.cspNonce`).
55
- * @param requestHost nom d'hôte par lequel le client a demandé la page
56
- * (`Context.domain`, sans port). En développement, l'origine des assets
57
- * Vite est dérivée de ce nom — le scheme et le port restent ceux de Vite —
58
- * de sorte qu'un poste et un conteneur soient servis en même temps sans
59
- * configuration. Ignoré si `frontend.publicOrigin` est configurée, si
60
- * l'hôte ne franchit pas `trustedHosts`, et en production.
61
59
  */
62
- renderTags(entryName: string, nonce?: string, requestHost?: string): string;
60
+ renderTags(entryName: string, nonce?: string): string;
63
61
  /**
64
62
  * Document HTML complet : `index.html` du module + tags injectés. Pour les
65
63
  * controllers qui veulent déléguer toute la coquille (le dev contrôle le
66
64
  * `<head>` via son `index.html`).
67
- *
68
- * @param requestHost cf {@link IFrontendService.renderTags}.
69
65
  */
70
- renderDocument(entryName: string, nonce?: string, requestHost?: string): string;
66
+ renderDocument(entryName: string, nonce?: string): string;
71
67
  /**
72
68
  * Résout l'URL publique d'un asset : préfixe `p` par `assetBaseUrl` (CDN) si
73
69
  * configuré, sinon chemin relatif inchangé. URLs absolues renvoyées telles
@@ -12,13 +12,19 @@ export interface IViteSupervisorStatus {
12
12
  readonly host: string;
13
13
  readonly port: number | null;
14
14
  /**
15
- * Origine PUBLIQUE effective du dev server — celle que le navigateur doit
16
- * utiliser (`publicOrigin` config si posée, sinon dérivée de `host:port`).
17
- * Source unique des URLs émises (TemplateHelper, boot line, CSP, admin API) :
18
- * un `scheme://host:port` recomposé ailleurs finirait par diverger.
19
- * `null` tant qu'aucun spawn n'a résolu de port.
15
+ * Origine LOCALE du dev server (`http://127.0.0.1:<port réel>`) : la cible
16
+ * du proxy inverse de Nodefony. Le navigateur ne la voit jamais — il passe
17
+ * par `/_vite/<famille>/` sur l'origine de la page. Source unique de cette
18
+ * cible (TemplateHelper, boot line, admin API). `null` tant qu'aucun spawn
19
+ * n'a résolu de port.
20
20
  */
21
21
  readonly origin: string | null;
22
+ /**
23
+ * Chemin de base Vite de cette instance (`/_vite/<famille>/`, `/` en tête et
24
+ * en fin). Toute URL émise vers Vite le porte : c'est lui que Nodefony relaie.
25
+ * Absent quand le superviseur n'en a pas reçu (doubles de test) → `/`.
26
+ */
27
+ readonly base?: string;
22
28
  readonly pid: number | null;
23
29
  readonly lastError: string | null;
24
30
  readonly entries: ReadonlyArray<IResolvedFrontendEntry>;
@@ -28,33 +28,6 @@ declare class FrontendService extends Service implements IFrontendService {
28
28
  private readonly entryFamily;
29
29
  /** Helper prod unique (lit les manifests) — `null` tant qu'on n'est pas en prod. */
30
30
  private prodHelper;
31
- /**
32
- * QUI a épinglé l'origine publique — la question n'est pas « est-elle
33
- * épinglée » mais « par quoi », car les deux sources n'ont pas la même
34
- * autorité :
35
- *
36
- * - `"config"` — `frontend.publicOrigin` : une décision ÉCRITE par l'auteur.
37
- * Elle gagne sur tout, y compris sur le `Host` reçu : c'est le sens même
38
- * d'un réglage explicite, et le seul moyen de servir derrière un frontal
39
- * qui réécrit l'origine.
40
- * - `"platform"` — Codespaces/Gitpod déduits de l'environnement : une
41
- * DÉDUCTION, faite une fois au démarrage, sur une machine qui reçoit
42
- * simultanément des clients arrivés par des chemins différents. Elle ne
43
- * peut donc pas prévaloir sur un fait constaté à la requête — un client
44
- * venu de la boucle locale se sert en local (cf `derivableHost`).
45
- * - `null` — rien d'épinglé : chaque page annonce l'origine par laquelle son
46
- * client est arrivé.
47
- */
48
- private originPinnedBy;
49
- /**
50
- * Ports que l'instance Vite de chaque famille PEUT prendre pour ce démarrage
51
- * (bloc de la famille, port-retry compris) — `null` tant que `startDev` n'a
52
- * pas établi le plan, et remis à `null` par `stopDev`.
53
- *
54
- * Alloué une fois par démarrage de développement, jamais en production
55
- * (`startDev` n'y tourne pas) : aucun coût par requête.
56
- */
57
- private plannedPortBlocks;
58
31
  constructor(module: Module);
59
32
  /** Base CDN normalisée (sans slash final). `""` = origine Nodefony. */
60
33
  private get assetBase();
@@ -90,53 +63,6 @@ declare class FrontendService extends Service implements IFrontendService {
90
63
  * famille n'a pu démarrer.
91
64
  */
92
65
  startDev(): Promise<void>;
93
- /**
94
- * Port backend que Vite doit proxifier — le port RÉELLEMENT écouté, pas celui
95
- * qu'on espérait.
96
- *
97
- * `config.backendPort` (5151) n'est qu'une intention : avec
98
- * `servers.portPolicy: "auto"`, un port occupé fait glisser l'écoute du backend
99
- * (5151 → 5153). Un proxy figé sur 5151 enverrait alors les appels API du front
100
- * vers le serveur d'une AUTRE app — au mieux des 404, au pire les données du
101
- * voisin. On lit donc le port sur le serveur lui-même.
102
- *
103
- * Résolution par NOM (`server-http`), jamais par import : `@nodefony/frontend`
104
- * ne dépend pas de `@nodefony/http` (cycle via la config d'app).
105
- */
106
- private resolveBackendPort;
107
- /**
108
- * Résout les certificats HTTPS partagés (service `certificates` de
109
- * @nodefony/http) si `https: true`. Pas de duplication — mêmes PEM que
110
- * `server-https` (5152). Retombe sur HTTP avec un warning si indisponible.
111
- */
112
- private resolveHttps;
113
- /**
114
- * Template d'origine publique Vite (P14.17), AVEC sa provenance. Priorité :
115
- * `frontend.publicOrigin` (config, validée — invalide = ERROR + ignorée,
116
- * jamais un boot cassé) puis détection de plateforme (Codespaces/Gitpod —
117
- * variables documentées de la plateforme, qu'on lit sans les posséder).
118
- * `null` = dérivation locale.
119
- *
120
- * La provenance est rendue avec le template parce qu'elle CHANGE la suite :
121
- * une config écrite est un ordre, une plateforme déduite est une supposition
122
- * qui cède devant le `Host` reçu quand celui-ci désigne la boucle locale
123
- * (cf `originPinnedBy`). Les confondre servait l'origine publique à un client
124
- * venu d'un tunnel local, qui n'a pas la session de la plateforme.
125
- *
126
- * Chaque adaptation est JOURNALISÉE : on doit pouvoir lire dans le boot
127
- * pourquoi les `<script>` pointent où ils pointent.
128
- */
129
- private resolvePublicOrigin;
130
- /**
131
- * `server.allowedHosts` pour Vite. Vite accepte d'office IP et `localhost` ;
132
- * cette liste ne porte que les NOMS. Source des noms légitimes = la MÊME que
133
- * la barrière Host de Nodefony (`kernel.domain` + `trustedHosts` http) — une
134
- * seule liste à maintenir : autoriser un hôte dans `trustedHosts` ouvre à la
135
- * fois la barrière 421 ET Vite. S'y ajoute l'hôte du template d'origine
136
- * publique. `trustedHosts: true` (barrière déléguée au reverse-proxy) →
137
- * `true` (même délégation). Un pattern non exprimable chez Vite est ANNONCÉ.
138
- */
139
- private viteAllowedHosts;
140
66
  /** Regroupe les entries par famille d'isolation + remplit l'index inverse. */
141
67
  private groupEntriesByFamily;
142
68
  /**
@@ -145,6 +71,28 @@ declare class FrontendService extends Service implements IFrontendService {
145
71
  * observable même si le démarrage échoue → rendu propre, pas d'exception).
146
72
  */
147
73
  private startFamily;
74
+ /**
75
+ * Monte `/_vite/<famille>/` sur le proxy inverse de `@nodefony/http` (#528).
76
+ *
77
+ * Tout ce que la page demande à Vite — modules, images importées, `url()`
78
+ * CSS, socket du rechargement à chaud — porte ce préfixe (`base` Vite) et
79
+ * reste donc sur l'ORIGINE DE LA PAGE : un certificat, aucun contenu mixte,
80
+ * et les API réservées aux contextes sécurisés (caméra, Service Workers,
81
+ * WebAuthn) disponibles depuis un téléphone, une IP de réseau local ou un
82
+ * navigateur en conteneur. Vite, lui, reste sur la boucle locale.
83
+ *
84
+ * GET/HEAD seulement (Vite ne sert que des lectures) ; `cookie` et
85
+ * `authorization` ne lui parviennent pas — un serveur de sources n'a pas à
86
+ * voir la session. Posé avant `start()` : tant que Vite n'est pas prêt, la
87
+ * cible est inconnue et le relais répond `503` — à la socket de sonde du
88
+ * client Vite comprise, AVANT tout `101` : la page ne recharge qu'une fois
89
+ * Vite revenu, jamais sur une page blanche (#577). No-op sans proxy
90
+ * (application sans serveur HTTP).
91
+ *
92
+ * @param devBase - chemin de base de la famille (`devBasePath`)
93
+ * @param helper - helper de la famille, qui connaît son superviseur
94
+ */
95
+ private mountDevProxy;
148
96
  /**
149
97
  * Câblage prod (idempotent) : monte chaque `outDir` sur son `publicPath`
150
98
  * auprès du serveur statique `server-static` (résolu par nom — pas d'import
@@ -201,49 +149,7 @@ declare class FrontendService extends Service implements IFrontendService {
201
149
  * Le controller renvoie : `this.render(svc.renderDocument("x", this.context.cspNonce))`.
202
150
  * @param nonce nonce CSP de la requête (`Context.cspNonce`) — propagé aux `<script>`.
203
151
  */
204
- renderDocument(entryName: string, nonce?: string, requestHost?: string): string;
205
- renderTags(entryName: string, nonce?: string, requestHost?: string): string;
206
- /**
207
- * Le `Host` de la requête peut-il servir à dériver l'origine des assets ?
208
- *
209
- * Trois conditions, dans cet ordre — chacune protège un cas RÉEL :
210
- * 1. **origine non épinglée** : un `frontend.publicOrigin` explicite (ou une
211
- * plateforme de dev déporté détectée) est une décision de l'auteur, elle
212
- * gagne toujours sur une déduction ;
213
- * 2. **barrière `trustedHosts` franchie** : le `Host` est une donnée
214
- * CLIENTE. Sans ce filtre, un `Host` forgé ferait émettre des
215
- * `<script src="https://attaquant:5173/…">` dans une page de dev ;
216
- * 3. **barrière non déléguée** (`trustedHosts !== true`) : le bypass total
217
- * ne dit plus rien de la légitimité d'un nom, et surtout le CSP émis par
218
- * le firewall (`#viteCspFragment`) ne couvre alors QUE loopback +
219
- * domaine canonique — dériver ailleurs produirait une page dont les
220
- * scripts sont bloqués. Les deux listes doivent rester la même liste.
221
- *
222
- * @returns le nom d'hôte à employer, ou `undefined` pour garder l'origine
223
- * résolue au démarrage (comportement d'avant la dérivation).
224
- */
225
- private derivableHost;
226
- /**
227
- * Ports Vite à déclarer au CSP, famille par famille : le BLOC entier tant que
228
- * l'instance ne sert pas, son port RÉEL dès qu'elle sert.
229
- *
230
- * Pourquoi le bloc avant : le CSP part AVEC la page et ne se renégocie jamais.
231
- * Une page servie avant que Vite ait résolu son port doit déjà porter le port
232
- * qu'il prendra, sinon son socket de rechargement à chaud est refusé pour
233
- * toute la durée de la page.
234
- *
235
- * Pourquoi le port seul après : la plage est le prix d'une incertitude, elle
236
- * ne doit pas lui survivre. Mesuré sur ce dépôt (3 familles × 4 hôtes de
237
- * confiance), garder les blocs porte l'en-tête CSP à ~7,9 Ko sur CHAQUE
238
- * réponse, contre ~2,3 Ko une fois les ports connus — au bord des 8 Ko que
239
- * refusent beaucoup de relais.
240
- *
241
- * Développement seulement : `startDev` ne tourne pas en production. La
242
- * garantie reste une liste d'origines nommées — jamais un `ws:` sans hôte,
243
- * qui la supprimerait au lieu de corriger le symptôme.
244
- *
245
- * @returns ports en chaîne, dédupliqués ; repli `devPort` si rien n'est connu.
246
- */
247
- private cspPorts;
152
+ renderDocument(entryName: string, nonce?: string): string;
153
+ renderTags(entryName: string, nonce?: string): string;
248
154
  }
249
155
  export default FrontendService;
@@ -10,17 +10,18 @@ import type { IResolvedFrontendEntry } from "../interfaces/IFrontBuilder.js";
10
10
  */
11
11
  export interface ViteConfigGeneratorOptions {
12
12
  /**
13
- * Origine du serveur Nodefony pour le proxy Vite (`server.proxy`).
14
- * Exemple : `"http://127.0.0.1:5151"`. En dev uniquement — ignoré en prod.
13
+ * Chemin de base Vite en développement — `/_vite/<famille>/`
14
+ * (`devBasePath`). Émis comme `base` : Vite préfixe alors TOUTES ses URLs
15
+ * (modules, assets, `url()` CSS, socket HMR), et Nodefony relaie ce préfixe
16
+ * vers le serveur Vite.
15
17
  */
16
- readonly backendOrigin?: string | undefined;
18
+ readonly devBase?: string | undefined;
17
19
  /**
18
- * Origine publique du dev server Vite — ex `"http://127.0.0.1:5173"`.
19
- * Définie comme `base` dans Vite, ce qui force les imports internes du
20
- * source transformé (ex `/src/App.tsx`) à devenir absolus
21
- * (`http://host:port/src/App.tsx`). Sans ça, une page rendue par
22
- * Nodefony (5151) qui charge `/src/main.tsx` voit ses imports résolus
23
- * contre 5151 → 404. Active aussi `strictPort` pour garantir l'origine.
20
+ * @deprecated Utiliser {@link ViteConfigGeneratorOptions.devBase}. Vite
21
+ * réduit un `base` absolu à son seul chemin en développement
22
+ * (`resolveBaseUrl`) : cette origine n'a jamais rendu aucune URL absolue.
23
+ * Sans effet : `strictPort`, qu'elle activait, est désormais toujours posé
24
+ * en développement.
24
25
  */
25
26
  readonly viteOrigin?: string | undefined;
26
27
  /**
@@ -32,23 +33,14 @@ export interface ViteConfigGeneratorOptions {
32
33
  readonly keyPath: string;
33
34
  readonly certPath: string;
34
35
  } | undefined;
35
- /**
36
- * Hôtes acceptés dans le header `Host` (`server.allowedHosts`, Vite ≥6).
37
- * `true` = tous. Un motif `.suffixe` couvre le domaine et ses sous-domaines.
38
- * Les IP et `localhost` sont toujours acceptés par Vite — cette liste ne
39
- * sert que les NOMS (vhosts, `host.docker.internal`, forwarders).
40
- */
41
- readonly allowedHosts?: true | ReadonlyArray<string> | undefined;
42
36
  }
43
37
  export declare class ViteConfigGenerator {
44
38
  /**
45
39
  * Construit le content `.mjs` à écrire à côté de `index.html` du module.
46
40
  *
47
- * Si `opts.backendOrigin` est fourni en mode `development`, agrège les
48
- * `apiProxyPaths` de toutes les entries et génère un `server.proxy` qui
49
- * forward chaque préfixe vers le backend Nodefony. Sans ça, les fetch
50
- * relatifs depuis l'app servie par Vite atterrissent sur Vite et reçoivent
51
- * un SPA-fallback HTML (cause classique de `Unexpected token '<'`).
41
+ * Aucun `server.proxy` : la page est rendue par Nodefony et ses appels d'API
42
+ * partent sur sa propre origine ; Vite ne reçoit que ce que le relais
43
+ * `/_vite/<famille>/` lui transmet (#528).
52
44
  */
53
45
  toMjs(entries: ReadonlyArray<IResolvedFrontendEntry>, mode: "development" | "production", opts?: ViteConfigGeneratorOptions): string;
54
46
  }
@@ -1,5 +1,15 @@
1
1
  import type { IViteSupervisor, IViteSupervisorStatus } from "../interfaces/IViteSupervisor.js";
2
2
  import type { IResolvedFrontendEntry } from "../interfaces/IFrontBuilder.js";
3
+ /**
4
+ * Hôte JOIGNABLE pour une adresse d'écoute : `0.0.0.0`/`::` désignent toutes
5
+ * les interfaces, pas une destination — s'y connecter échoue sous Windows. Le
6
+ * superviseur, sa sonde et le proxy inverse joignent Vite depuis la machine
7
+ * qui le lance : la boucle locale est alors toujours juste.
8
+ *
9
+ * @param listenHost - adresse d'écoute (`devHost`)
10
+ * @returns l'hôte à joindre
11
+ */
12
+ export declare function browserReachableHost(listenHost: string): string;
3
13
  /**
4
14
  * Logger minimal — injecté par FrontendService pour piper les logs Vite
5
15
  * dans le syslog Nodefony sans dépendance dure sur Service.
@@ -13,27 +23,14 @@ export interface ViteSupervisorOptions {
13
23
  readonly devHost: string;
14
24
  readonly devPort: number;
15
25
  /**
16
- * Template d'origine PUBLIQUE du dev server (P14.17) — `{port}` substitué au
17
- * port RÉEL de chaque spawn (suit les retries de port). Vide/absent = dérivé
18
- * de `devHost:port`. Dissocie ce que Vite ÉCOUTE de ce que le navigateur
19
- * APPELLE (forwarder Codespaces/Gitpod, `host.docker.internal`, remap).
26
+ * Chemin de base Vite de l'instance (`devBasePath(famille)`) — émis comme
27
+ * `base` dans la config générée, rendu par `status().base`.
20
28
  */
21
- readonly publicOriginTemplate?: string | undefined;
22
- /**
23
- * Hôtes que Vite doit accepter dans le header `Host` (`server.allowedHosts`).
24
- * `true` = tous. Dérivé par FrontendService de la liste `trustedHosts` http —
25
- * jamais maintenu ici (1 règle = 1 implémentation).
26
- */
27
- readonly allowedHosts?: true | ReadonlyArray<string> | undefined;
29
+ readonly devBase?: string | undefined;
28
30
  readonly startupTimeoutMs: number;
29
31
  readonly pipeLogs: boolean;
30
32
  readonly cwd: string;
31
33
  readonly logger: IViteSupervisorLogger;
32
- /**
33
- * Origine du serveur Nodefony pour `server.proxy` côté Vite — ex `"http://127.0.0.1:5151"`.
34
- * Quand fourni, les paths `apiProxyPaths` des entries sont proxifiés vers ce backend.
35
- */
36
- readonly backendOrigin?: string;
37
34
  /**
38
35
  * Certificats à utiliser si Vite doit servir en HTTPS. Paths absolus vers les
39
36
  * fichiers PEM — les mêmes que Nodefony utilise pour son `server-https` (5152).
@@ -0,0 +1,23 @@
1
+ import type { IBootNotice } from "nodefony";
2
+ import type { IViteSupervisorStatus } from "../interfaces/IViteSupervisor.js";
3
+ /** Ce que le frontend dit au bilan de démarrage. */
4
+ export interface IFrontendBootSummary {
5
+ /** Instances Vite réellement prêtes. */
6
+ ready: number;
7
+ /**
8
+ * Une ligne par instance : les bundles qu'elle sert et son port INTERNE
9
+ * (`react, studio · Vite interne :5173`) — jamais présenté comme une adresse
10
+ * à ouvrir : Vite passe derrière Nodefony, on ouvre l'application.
11
+ */
12
+ lines: string[];
13
+ /** Le point d'attention à déclarer, ou `null` si tout est servi. */
14
+ notice: IBootNotice | null;
15
+ }
16
+ /**
17
+ * Résume les instances Vite pour le bilan de démarrage — fonction PURE (les
18
+ * statuts sont lus par l'appelant), éprouvable sans lancer Vite.
19
+ *
20
+ * @param statuses - l'état de chaque superviseur Vite, après démarrage.
21
+ * @returns lignes de détail, nombre d'instances prêtes, point d'attention.
22
+ */
23
+ export declare function summarizeFrontendBoot(statuses: readonly IViteSupervisorStatus[]): IFrontendBootSummary;