@nodefony/frontend 10.0.0-alpha.1

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

@@ -0,0 +1,75 @@
+import { FrontendPresetUnknownError } from "../errors/FrontendError.js";
+import react19Preset from "../presets/react19-vite.js";
+import vue3Preset from "../presets/vue3-vite.js";
+import angularPreset from "../presets/angular-vite.js";
+import vanillaPreset from "../presets/vanilla-vite.js";
+import svelte5Preset from "../presets/svelte5-vite.js";
+import path from "node:path";
+//#region nodefony/src/builders/ViteBuilder.ts
+/**
+* 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
+* démarrage est délégué au superviseur (child_process ou in-proc).
+*/
+var ViteBuilder = class {
+	presets = /* @__PURE__ */ new Map();
+	constructor() {
+		this.registerPreset(react19Preset);
+		this.registerPreset(vue3Preset);
+		this.registerPreset(angularPreset);
+		this.registerPreset(vanillaPreset);
+		this.registerPreset(svelte5Preset);
+	}
+	listPresets() {
+		return Array.from(this.presets.values());
+	}
+	getPreset(type) {
+		return this.presets.get(type);
+	}
+	registerPreset(preset) {
+		this.presets.set(preset.type, preset);
+	}
+	async buildViteConfig(entries, mode, assetBaseUrl = "") {
+		if (entries.length === 0) return { mode };
+		const usedPresets = /* @__PURE__ */ new Set();
+		for (const e of entries) usedPresets.add(e.type);
+		const plugins = [];
+		const optimizeInclude = [];
+		for (const type of usedPresets) {
+			const preset = this.presets.get(type);
+			if (!preset) throw new FrontendPresetUnknownError(type);
+			plugins.push(...await preset.buildPlugins());
+			optimizeInclude.push(...preset.optimizeDepsInclude);
+		}
+		const input = {};
+		for (const e of entries) input[e.entryName] = path.resolve(e.root, e.entryFile);
+		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");
+		return {
+			mode,
+			...base ? { base } : {},
+			root,
+			plugins,
+			...dedupe.length ? { resolve: { dedupe } } : {},
+			optimizeDeps: { include: optimizeInclude },
+			build: {
+				outDir,
+				manifest: true,
+				rollupOptions: { input },
+				emptyOutDir: true
+			},
+			server: {
+				strictPort: false,
+				cors: true
+			}
+		};
+	}
+};
+//#endregion
+export { ViteBuilder, ViteBuilder as default };

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

@@ -0,0 +1,50 @@
+//#region nodefony/src/errors/FrontendError.ts
+/**
+* Erreur de base pour @nodefony/frontend.
+*
+* - `code` : identifiant machine, consommé par Vision et l'audit-logger.
+* - `context` : payload structuré pour le PDU syslog.
+*/
+var FrontendError = class extends Error {
+	code;
+	context;
+	constructor(message, code, context) {
+		super(message);
+		this.code = code;
+		this.context = context;
+		this.name = "FrontendError";
+	}
+};
+/** Preset inconnu — module a déclaré `type: "foo"` non enregistré. */
+var FrontendPresetUnknownError = class extends FrontendError {
+	constructor(type) {
+		super(`Unknown frontend preset: "${type}"`, "PRESET_UNKNOWN", { type });
+		this.name = "FrontendPresetUnknownError";
+	}
+};
+/** Echec de démarrage de Vite (spawn raté, port occupé, config invalide). */
+var FrontendSupervisorStartError = class extends FrontendError {
+	constructor(reason, cause) {
+		super(`Vite supervisor failed to start: ${reason}`, "SUPERVISOR_START", { reason });
+		this.name = "FrontendSupervisorStartError";
+		if (cause instanceof Error) this.cause = cause;
+	}
+};
+/** Au moins un bundle a échoué au build production (Vite). */
+var FrontendBuildError = class extends FrontendError {
+	failures;
+	constructor(failures) {
+		super(`Frontend production build failed for ${failures.length} bundle(s): ${failures.map((f) => f.entryName).join(", ")}`, "BUILD_FAILED", { failures });
+		this.failures = failures;
+		this.name = "FrontendBuildError";
+	}
+};
+/** Aucune entrée front trouvée alors qu'on tente de démarrer le dev server. */
+var FrontendNoEntriesError = class extends FrontendError {
+	constructor() {
+		super(`No frontend entries declared. Add { frontend: { type, entry } } in your module config.`, "NO_ENTRIES");
+		this.name = "FrontendNoEntriesError";
+	}
+};
+//#endregion
+export { FrontendBuildError, FrontendError, FrontendNoEntriesError, FrontendPresetUnknownError, FrontendSupervisorStartError };

package/dist/nodefony/src/isolationGroups.js

@@ -0,0 +1,116 @@
+//#region nodefony/src/isolationGroups.ts
+/**
+* Famille d'isolation Vite d'un type de preset frontend.
+*
+* Les presets d'une même famille **cohabitent dans une seule instance Vite** ;
+* les familles distinctes tournent dans des **process Vite séparés** (multi-
+* supervisor).
+*
+* **Le motif est toujours le même : un plugin qui transforme ce qui ne lui
+* appartient pas.** Deux familles le paient aujourd'hui.
+*
+* Angular : son plugin (`@analogjs/vite-plugin-angular`) transforme **tout**
+* fichier `.ts` du serveur de développement — y compris ceux des autres bundles
+* (ex. stores MobX à décorateurs). Mélangé aux autres, il throw sur des fichiers
+* hors de son tsconfig → erreurs de compilation + boucle de rechargement.
+*
+* Vue : le compilateur de composants monofichiers sert le bloc script sous un
+* identifiant qui se TERMINE par `.ts`
+* (`App.vue?vue&type=script&setup=true&lang.ts`). Le filtre de
+* `@vitejs/plugin-react` y mord — il est élargi aux identifiants portant une
+* query — et injecte son `$RefreshSig$()`, que rien ne définit sur une page sans
+* préambule React : la vitrine Vue ne se montait plus du tout
+* (`ReferenceError: $RefreshSig$ is not defined`).
+*
+* ⚠️ Il a longtemps été écrit ici que « React / Vue / vanilla ciblent des
+* extensions disjointes ». C'était faux, et c'est ce qui a fait chercher
+* ailleurs. Passer `exclude: [/\.vue/]` à `@vitejs/plugin-react` **ne suffit
+* pas** : mesuré sur Vite 8.2.2, l'injection persiste jusqu'à `exclude: [/./]`
+* inclus — l'option ne borne pas ce chemin. Seule l'isolation en process
+* distinct l'arrête.
+*
+* Svelte, lui, cohabite sans dommage (constaté) : son bloc script n'est pas
+* servi sous un identifiant qui finit par `.ts`.
+*
+* @param type - type de preset déclaré par le module (`react19`, `vue3`,
+*   `angular`, `vanilla`, …).
+* @returns la clé de famille d'isolation (`"default"` pour tout ce qui peut
+*   partager une instance, une clé dédiée pour ce qui doit être isolé).
+*/
+function isolationGroup(type) {
+	switch (type) {
+		case "angular": return "angular";
+		case "vue3": return "vue";
+		default: return "default";
+	}
+}
+/**
+* Famille servie sur le port de base (`devPort`). Les autres familles prennent
+* les blocs de ports suivants. Garder `default` ici garantit que l'instance
+* principale (React/Vue/Studio) reste sur le port habituel (5173).
+*/
+const PRIMARY_FAMILY = "default";
+/**
+* Ordonne les familles de façon déterministe : la famille primaire d'abord
+* (port de base), puis les autres triées alphabétiquement. L'ordre fixe le
+* port attribué à chaque famille — il doit être stable entre deux démarrages.
+*
+* @param families - familles présentes (clés de regroupement des entries).
+* @returns familles ordonnées, `PRIMARY_FAMILY` en tête s'il est présent.
+*/
+function orderFamilies(families) {
+	const others = families.filter((f) => f !== PRIMARY_FAMILY).sort();
+	return families.includes("default") ? [PRIMARY_FAMILY, ...others] : others;
+}
+/**
+* Plan d'allocation des ports : un **bloc disjoint** par famille. Chaque famille
+* réserve `portRetryAttempts + 1` ports consécutifs → le port-retry d'une
+* instance (sur EADDRINUSE) ne peut jamais empiéter sur le bloc d'une autre
+* famille. La famille primaire (index 0) garde `devPort` (le port habituel).
+*
+* @param devPort - port de base de la première famille (ex. 5173).
+* @param families - familles présentes ; réordonnées en interne via `orderFamilies`.
+* @param portRetryAttempts - tentatives de port-retry par instance (bloc = +1).
+* @returns map ordonnée `famille → port de base de son bloc`.
+*/
+function familyPortPlan(devPort, families, portRetryAttempts) {
+	const block = portRetryAttempts + 1;
+	const plan = /* @__PURE__ */ new Map();
+	orderFamilies(families).forEach((family, index) => {
+		plan.set(family, devPort + index * block);
+	});
+	return plan;
+}
+/**
+* Bloc de ports de chaque famille : tous les ports que SON instance Vite peut
+* prendre, port-retry compris.
+*
+* Le plan seul ne dit que le port ESPÉRÉ ; sur `EADDRINUSE` le superviseur
+* glisse dans son bloc. Un CSP construit sur le seul port espéré laisse la page
+* sans rechargement à chaud dès que le port de base est pris — et il l'est dès
+* qu'un second projet tourne sur la machine.
+*
+* Rendu par famille, et non à plat : le consommateur remplace le bloc d'une
+* famille par son port RÉEL dès qu'il est connu. Déclarer les douze ports d'un
+* poste à trois familles coûte un en-tête CSP de ~8 Ko sur chaque réponse
+* (mesuré) — la plage est le prix d'une incertitude, elle ne doit pas survivre
+* à sa levée.
+*
+* Dérivé du plan plutôt que recalculé depuis `devPort` : la règle des blocs
+* disjoints n'est écrite qu'à un endroit, `familyPortPlan`.
+*
+* @param plan - `famille → port de base`, tel que rendu par `familyPortPlan`.
+* @param portRetryAttempts - tentatives de port-retry par instance (bloc = +1).
+* @returns `famille → ports du bloc`, croissants.
+*/
+function familyPortBlocks(plan, portRetryAttempts) {
+	const blocks = /* @__PURE__ */ new Map();
+	for (const [family, base] of plan) {
+		const ports = [];
+		for (let i = 0; i <= portRetryAttempts; i++) ports.push(base + i);
+		blocks.set(family, ports);
+	}
+	return blocks;
+}
+//#endregion
+export { PRIMARY_FAMILY, familyPortBlocks, familyPortPlan, isolationGroup, orderFamilies };

package/dist/nodefony/src/presets/angular-vite.js

@@ -0,0 +1,27 @@
+//#region nodefony/src/presets/angular-vite.ts
+/**
+* Preset Angular (17+ standalone) + Vite via `@analogjs/vite-plugin-angular`.
+*
+* Charge le plugin paresseusement : aucune dépendance Angular tant qu'aucune
+* entrée `angular` n'est déclarée. Comme React/Vue, aucun preamble HTML n'est
+* requis — `bootstrapApplication(AppComponent)` dans le point d'entrée suffit.
+*
+* ⚠️ Contrairement à `.vue`/`.tsx`, le plugin Angular transforme les `.ts`
+* (extension non dédiée). Le scoping se fait via le `tsconfig` de l'app Angular
+* (passé par `ViteConfigGenerator`) dont le `include` ne couvre que le frontend
+* Angular — les `main.ts` des autres bundles (Vue) restent hors programme.
+*/
+const angularPreset = {
+	type: "angular",
+	extensions: [".ts", ".html"],
+	optimizeDepsInclude: [
+		"@angular/core",
+		"@angular/common",
+		"@angular/platform-browser"
+	],
+	async buildPlugins() {
+		return [(await import("@analogjs/vite-plugin-angular")).default()];
+	}
+};
+//#endregion
+export { angularPreset as default };

package/dist/nodefony/src/presets/react19-vite.js

@@ -0,0 +1,26 @@
+//#region nodefony/src/presets/react19-vite.ts
+/**
+* Preset React 19 + Vite.
+*
+* Charge `@vitejs/plugin-react` paresseusement : aucune dépendance
+* sur le module si aucune entrée React n'est déclarée.
+*/
+const react19Preset = {
+	type: "react19",
+	extensions: [
+		".jsx",
+		".tsx",
+		".js",
+		".ts"
+	],
+	optimizeDepsInclude: [
+		"react",
+		"react-dom",
+		"react-dom/client"
+	],
+	async buildPlugins() {
+		return [(await import("@vitejs/plugin-react")).default({ jsxRuntime: "automatic" })];
+	}
+};
+//#endregion
+export { react19Preset as default };

package/dist/nodefony/src/presets/svelte5-vite.js

@@ -0,0 +1,37 @@
+//#region nodefony/src/presets/svelte5-vite.ts
+/**
+* Preset Svelte 5 + Vite.
+*
+* Charge `@sveltejs/vite-plugin-svelte` paresseusement : aucune dépendance sur
+* le module tant qu'aucune entrée Svelte n'est déclarée — c'est l'application
+* qui porte `svelte` et le plugin en devDependencies. Comme Vue, Svelte n'exige
+* aucun preamble HMR injecté côté serveur (`mount(App, { target })` suffit) ;
+* il cohabite donc dans la famille d'isolation `default` (extensions `.svelte`
+* disjointes de `.tsx`/`.vue`).
+*/
+const svelte5Preset = {
+	type: "svelte5",
+	extensions: [
+		".svelte",
+		".ts",
+		".js"
+	],
+	optimizeDepsInclude: ["svelte"],
+	async buildPlugins() {
+		const pkg = "@sveltejs/vite-plugin-svelte";
+		let mod;
+		try {
+			mod = await import(pkg);
+		} catch {
+			const [{ createRequire }, { pathToFileURL }, path] = await Promise.all([
+				import("node:module"),
+				import("node:url"),
+				import("node:path")
+			]);
+			mod = await import(pathToFileURL(createRequire(path.join(process.cwd(), "package.json")).resolve(pkg)).href);
+		}
+		return [mod.svelte()];
+	}
+};
+//#endregion
+export { svelte5Preset as default };

package/dist/nodefony/src/presets/vanilla-vite.js

@@ -0,0 +1,17 @@
+//#region nodefony/src/presets/vanilla-vite.ts
+/**
+* Preset vanilla — TS/JS sans framework.
+*
+* Aucun plugin Vite, utile pour les modules qui n'ont besoin
+* que de bundling ESM + HMR de base.
+*/
+const vanillaPreset = {
+	type: "vanilla",
+	extensions: [".ts", ".js"],
+	optimizeDepsInclude: [],
+	async buildPlugins() {
+		return [];
+	}
+};
+//#endregion
+export { vanillaPreset as default };

package/dist/nodefony/src/presets/vue3-vite.js

@@ -0,0 +1,23 @@
+//#region nodefony/src/presets/vue3-vite.ts
+/**
+* Preset Vue 3 + Vite.
+*
+* Charge `@vitejs/plugin-vue` paresseusement : aucune dépendance
+* sur le module tant qu'aucune entrée Vue n'est déclarée. Contrairement
+* à React, Vue ne nécessite aucun preamble HMR injecté côté serveur —
+* `createApp(App).mount(...)` dans le point d'entrée suffit.
+*/
+const vue3Preset = {
+	type: "vue3",
+	extensions: [
+		".vue",
+		".ts",
+		".js"
+	],
+	optimizeDepsInclude: ["vue"],
+	async buildPlugins() {
+		return [(await import("@vitejs/plugin-vue")).default()];
+	}
+};
+//#endregion
+export { vue3Preset as default };

package/dist/nodefony/src/remoteDev.js

@@ -0,0 +1,157 @@
+//#region nodefony/src/remoteDev.ts
+/**
+* Dev déporté (P14.17) — calculs PURS d'origine publique du dev server Vite.
+*
+* Le problème résolu : `devHost` est une adresse d'ÉCOUTE ; l'origine que le
+* 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
+* du spawn) — explicite (`frontend.publicOrigin`) ou détecté depuis
+* l'environnement de la plateforme.
+*
+* Tout est pur et injectable (env en paramètre) : testable sans process, sans
+* réseau, sur les trois plateformes.
+*
+* 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).
+*  - 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.
+*  - VS Code Remote / dev containers / WSL2 : forwarding sur `localhost` →
+*    les défauts locaux suffisent, aucune détection requise.
+*/
+/** Placeholder substitué par le port réel du spawn dans un template d'origine. */
+const PORT_PLACEHOLDER = "{port}";
+/**
+* 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}`).
+* Regex plutôt que `new URL()` : le parseur WHATWG refuse `{`/`}` dans un hôte.
+*/
+const ORIGIN_TEMPLATE_RE = /^(https?):\/\/([^/:\s]+)(?::(\d+|\{port\}))?$/;
+/**
+* Hôte utilisable par un NAVIGATEUR pour une adresse d'écoute donnée.
+* `0.0.0.0`/`::` sont des adresses d'ÉCOUTE (toutes interfaces), pas des
+* destinations : dérivées telles quelles dans une URL, elles donnent des
+* `<script src="http://0.0.0.0:5173/…">` que les navigateurs refusent — et
+* sous Windows, une CONNEXION vers `0.0.0.0` échoue aussi (health check).
+*/
+function browserReachableHost(listenHost) {
+	return listenHost === "0.0.0.0" || listenHost === "::" || listenHost === "[::]" || listenHost === "" ? "127.0.0.1" : listenHost;
+}
+/** Un template d'origine est-il syntaxiquement valide ? (autorité unique) */
+function isValidOriginTemplate(template) {
+	return ORIGIN_TEMPLATE_RE.test(template);
+}
+/**
+* Origine RÉSOLUE (scheme + hôte + port), telle qu'elle sort du superviseur :
+* `https://127.0.0.1:5173`, `https://x.app.github.dev` (port implicite),
+* `http://[::1]:5173`. Pas de `{port}` ici — le template est déjà substitué.
+*/
+const RESOLVED_ORIGIN_RE = /^(https?:\/\/)(\[[^\]/]+\]|[^/:\s]+)(:\d+)?$/;
+/**
+* Rejoue une origine résolue sur un AUTRE nom d'hôte, en conservant le scheme
+* et le port. Pure.
+*
+* C'est le cœur de la dérivation par requête : le scheme et le port sont ceux
+* du serveur Vite (il écoute où il écoute), seul le NOM change — celui par
+* lequel le client est arrivé. Une page servie sur `http://poste:5151` charge
+* donc `https://poste:5173` si Vite est en TLS : le scheme ne se déduit JAMAIS
+* de la page.
+*
+* `new URL()` est volontairement évité (une allocation par page rendue, pour
+* une chaîne dont nous produisons nous-mêmes la grammaire).
+*
+* @param origin - origine résolue (`scheme://hôte[:port]`).
+* @param hostname - nom d'hôte de remplacement, SANS port (`Context.domain`) ;
+*   une IPv6 est acceptée sous sa forme canonique entre crochets (`[::1]`).
+* @returns l'origine réécrite, ou `null` si l'un des deux est inexploitable
+*   (l'appelant garde alors l'origine d'origine — jamais d'URL bancale émise).
+*/
+function originWithHostname(origin, hostname) {
+	const m = RESOLVED_ORIGIN_RE.exec(origin);
+	if (!m) return null;
+	if (!/^(\[[^\]/]+\]|[A-Za-z0-9._-]+)$/.test(hostname)) return null;
+	return `${m[1]}${hostname}${m[3] ?? ""}`;
+}
+/**
+* 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
+*   (l'appelant retombe sur la dérivation locale en l'ANNONÇANT — jamais en
+*   silence).
+*/
+function resolveOriginTemplate(template, port) {
+	const m = ORIGIN_TEMPLATE_RE.exec(template);
+	if (!m) return null;
+	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"
+		}
+	};
+}
+/**
+* Motif `server.allowedHosts` couvrant TOUTES les origines qu'un template peut
+* produire. `{port}` dans l'hôte → le sous-domaine varie avec le port : motif
+* `.suffixe` (wildcard Vite = domaine + sous-domaines). Hôte fixe → verbatim.
+*
+* @returns le motif, ou `null` si template invalide ou hôte non exprimable
+*   (un `{port}` dans le DERNIER label n'a pas de suffixe à wildcarder).
+*/
+function allowedHostPatternForTemplate(template) {
+	const m = ORIGIN_TEMPLATE_RE.exec(template);
+	if (!m) return null;
+	const hostTemplate = m[2];
+	if (!hostTemplate.includes("{port}")) return hostTemplate;
+	const dot = hostTemplate.indexOf(".");
+	if (dot === -1 || hostTemplate.slice(dot + 1).includes("{port}")) return null;
+	return hostTemplate.slice(dot);
+}
+/**
+* Motif Vite `allowedHosts` équivalent d'un pattern `trustedHosts` http.
+* `*.suffixe` (wildcard un-label de la barrière Host) → `.suffixe` (wildcard
+* Vite). Un `*` ailleurs n'est pas exprimable chez Vite → `null` (l'hôte reste
+* couvert par la barrière Nodefony ; Vite le refusera — motif à écrire en
+* clair dans `trustedHosts` si le cas se présente).
+*/
+function viteAllowedHostFromPattern(pattern) {
+	if (!pattern.includes("*")) return pattern;
+	if (pattern.startsWith("*.") && !pattern.slice(2).includes("*")) return pattern.slice(1);
+	return null;
+}
+/**
+* Détecte un environnement de dev déporté depuis les variables de plateforme
+* (variables qu'on ne possède pas — elles se lisent, ne se renomment pas).
+* Ordre : Codespaces puis Gitpod (jamais les deux posées en pratique).
+* Env local/VS Code Remote/WSL2 → `null` (les défauts locaux suffisent).
+*/
+function detectRemoteDev(env) {
+	const csName = env.CODESPACE_NAME;
+	const csDomain = env.GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN;
+	if (csName && csDomain) return {
+		provider: "codespaces",
+		originTemplate: `https://${csName}-${PORT_PLACEHOLDER}.${csDomain}`
+	};
+	const gpUrl = env.GITPOD_WORKSPACE_URL;
+	if (gpUrl) try {
+		const host = new URL(gpUrl).hostname;
+		return {
+			provider: "gitpod",
+			originTemplate: `https://${PORT_PLACEHOLDER}-${host}`
+		};
+	} catch {
+		return null;
+	}
+	return null;
+}
+//#endregion
+export { PORT_PLACEHOLDER, allowedHostPatternForTemplate, browserReachableHost, detectRemoteDev, isValidOriginTemplate, originWithHostname, resolveOriginTemplate, viteAllowedHostFromPattern };