nodefony 7.0.2 → 10.0.0-alpha.2

package/dist/node/service/dev/devProcess.js

@@ -0,0 +1,1137 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import net from "node:net";
+//#region src/service/dev/devProcess.ts
+/**
+* Helpers d'INTROSPECTION des process de développement Nodefony — source de vérité
+* PARTAGÉE entre le superviseur (`DevSupervisor`, écrivain du pidfile) et les
+* commandes de diagnostic (`nodefony status`, `nodefony stop`, lecteurs).
+*
+* 100 % OBSERVATION EXTERNE : pidfile + `ps` + sonde TCP, AUCUN IPC superviseur↔enfant
+* (choix d'architecture). Toute valeur dont la divergence écrivain/lecteur serait un
+* bug (chemin du pidfile, ports surveillés) vit ICI et n'est dupliquée nulle part.
+*/
+/** Titre de process du superviseur de dev (posé par {@link DevSupervisor.start}). */
+const DEV_SUPERVISOR_TITLE = "nodefony-dev-supervisor";
+/** Titre de process du serveur enfant supervisé (posé par `DevCommand` à `onReady`). */
+const DEV_SERVER_TITLE = "nodefony-dev-server";
+/** Préfixe de titre des process Vite (`ViteProcessSupervisor`, via `argv0`). */
+const DEV_VITE_PREFIX = "nodefony-vite";
+/**
+* Titre du serveur prod **mono-process** (`production` ou `cluster` avec `workers:1`,
+* posé par `Prod`/`ClusterCommand.generate`). Espace (≠ tiret de `nodefony-dev-server`)
+* → aucune collision de `String.includes` entre les deux.
+*/
+const PROD_SERVER_TITLE = "nodefony server";
+/** Préfixe du titre du master cluster (posé par `startClusterMaster`, ex. `nodefony master [cluster 6w]`). */
+const CLUSTER_MASTER_PREFIX = "nodefony master";
+/** Préfixe du titre d'un worker cluster (posé par `Prod`/`ClusterCommand.generate`, ex. `nodefony worker 3 [cluster]`). */
+const CLUSTER_WORKER_PREFIX = "nodefony worker";
+/** Rôles « principaux » (tiennent les ports ou supervisent) — Vite exclu (enfant jetable). */
+const PRIMARY_ROLES = /* @__PURE__ */ new Set([
+	"supervisor",
+	"server",
+	"master",
+	"worker"
+]);
+/**
+* Chemin du pidfile single-instance du superviseur dev — **source UNIQUE** lue par
+* `status`/`stop` et écrite par le superviseur (divergence = bug : le lecteur ne
+* verrait jamais l'instance). Sous `node_modules/.cache` (déjà gitignoré).
+*/
+function devSupervisorPidFile(cwd) {
+	return path.join(cwd, "node_modules", ".cache", "nodefony", "dev-supervisor.pid");
+}
+/** Ports Nodefony historiques — le point de départ, pas une vérité. */
+const FALLBACK_DEV_PORTS = [5151, 5152];
+/**
+* Chemin du **state file runtime** — le canal par lequel le serveur DIT sur quels
+* ports il écoute VRAIMENT.
+*
+* Il existe parce que le port n'est plus une convention : avec
+* `servers.portPolicy: "auto"`, un port occupé fait glisser l'écoute (5151 → 5153).
+* `status`, `stop` et la readiness `--detach` sondaient `[5151, 5152]` **en dur** —
+* ils deviendraient aveugles à la première app décalée. Le serveur écrit donc ses
+* ports effectifs ici, et les lecteurs les prennent à la source.
+*
+* À côté du pidfile, même dossier déjà gitignoré.
+*/
+function runtimeStateFile(cwd) {
+	return path.join(cwd, "node_modules", ".cache", "nodefony", "runtime.json");
+}
+/**
+* Chemin du **canal de disponibilité** — par lequel le serveur DIT *qui* retient
+* sa mise en service, et pourquoi.
+*
+* ## Pourquoi un fichier, et pas la sonde HTTP
+*
+* Le serveur publie déjà ce détail sur `/nodefony/kernel/api/livez`, mais
+* **réservé à un appelant authentifié** : les noms décrivent l'architecture
+* interne, et cette route est publique en production. La gradation est
+* délibérée — l'anonyme reçoit un compte, jamais des noms — et l'ouvrir pour le
+* confort d'un outil local serait payer en surface publique un service rendu sur
+* une seule machine.
+*
+* Le système de fichiers **est** la frontière « local », et une bien meilleure
+* que l'adresse d'appel : un conteneur voisin ou un mandataire présentent la
+* boucle locale sans être l'exploitant. Ici, lire le fichier suppose déjà un
+* accès au dossier du projet.
+*
+* Et il répond quand la sonde ne répond plus — pipeline saturé, boucle
+* d'événements bloquée. C'est précisément le moment où l'on tape `status`.
+*
+* À côté du pidfile et du state file runtime, même dossier déjà gitignoré.
+*/
+function readinessStateFile(cwd) {
+	return path.join(cwd, "node_modules", ".cache", "nodefony", "readiness.json");
+}
+/**
+* Publie qui retient la mise en service — **best-effort, jamais bloquant**.
+*
+* Écrit seulement quand l'état a changé (l'appelant en décide) : en régime
+* établi, ce fichier ne coûte rien. Un système de fichiers en lecture seule, un
+* dossier absent, un disque plein : on n'écrit pas, et le diagnostic retombe sur
+* le compte que la sonde donne déjà. Publier son état ne doit jamais mettre en
+* péril le processus qui sert.
+*
+* @param cwd - racine du projet.
+* @param contributors - l'état de chaque contributeur, tel que le registre le rend.
+*/
+function writeReadinessState(cwd, contributors) {
+	try {
+		const file = readinessStateFile(cwd);
+		mkdirSync(path.dirname(file), { recursive: true });
+		writeFileSync(file, JSON.stringify({
+			pid: process.pid,
+			contributors,
+			ts: Date.now()
+		}), "utf8");
+	} catch {}
+}
+/**
+* Efface le canal de disponibilité — geste d'un processus qui s'arrête.
+*
+* @param cwd - racine du projet.
+*/
+function clearReadinessState(cwd) {
+	try {
+		rmSync(readinessStateFile(cwd), { force: true });
+	} catch {}
+}
+/**
+* Lit qui retient la mise en service, ou `null`.
+*
+* **Un fichier dont le process est MORT est ignoré** : sinon `status` nommerait
+* le contributeur d'un serveur d'hier, ce qui est pire que de ne rien nommer —
+* on chercherait une cause déjà disparue.
+*
+* @param cwd - racine du projet à interroger.
+* @returns les contributeurs publiés, ou `null` si rien d'exploitable.
+*/
+function readReadinessState(cwd) {
+	try {
+		const raw = JSON.parse(readFileSync(readinessStateFile(cwd), "utf8"));
+		if (!Array.isArray(raw.contributors)) return null;
+		const pid = typeof raw.pid === "number" ? raw.pid : 0;
+		if (pid > 0 && !isPidAlive(pid)) return null;
+		const out = [];
+		for (const c of raw.contributors) {
+			if (typeof c?.name !== "string" || typeof c?.ready !== "boolean") continue;
+			out.push(typeof c.reason === "string" ? {
+				name: c.name,
+				ready: c.ready,
+				reason: c.reason
+			} : {
+				name: c.name,
+				ready: c.ready
+			});
+		}
+		return out;
+	} catch {
+		return null;
+	}
+}
+/**
+* Publie les ports EFFECTIFS du runtime. Best-effort : un échec d'écriture ne doit
+* jamais faire tomber un serveur qui, lui, écoute très bien (les lecteurs
+* retomberont sur les ports par défaut).
+*/
+function writeRuntimeState(cwd, state) {
+	try {
+		const file = runtimeStateFile(cwd);
+		mkdirSync(path.dirname(file), { recursive: true });
+		writeFileSync(file, JSON.stringify({
+			...state,
+			ts: Date.now()
+		}), "utf8");
+	} catch {}
+}
+/**
+* Lit les ports publiés par le runtime, ou `null`.
+*
+* **Un state file dont le process est MORT est ignoré** (et purgé) : sinon un
+* `status` lirait les ports d'un serveur d'hier et sonderait dans le vide.
+*
+* @param cwd - racine du projet à interroger.
+* @param opts.purgeStale - retirer le fichier d'un process mort (défaut `true`).
+*   À passer `false` pour lire l'état d'un projet ÉTRANGER : on interroge son canal
+*   pour savoir à qui appartient un port, on ne fait pas son ménage. Purger le décor
+*   d'un autre projet depuis une commande scopée à celui-ci serait un effet de bord
+*   hors périmètre — et le voisin perdrait la trace de ses propres ports.
+*/
+/**
+* Ports lus d'un FICHIER, ramenés à ce qu'un port peut être.
+*
+* Le fichier d'état est écrit par un process du projet, pas par un tiers — mais
+* il reste une entrée sur disque qui alimente ensuite une sonde réseau (l'hôte,
+* lui, est écrit en dur en boucle locale). Une valeur hors bornes n'ouvre donc
+* aucune porte vers l'extérieur ; elle enverrait la sonde frapper un service
+* local au hasard, et un fichier tronqué suffit à la produire.
+*
+* @param value - la valeur brute lue dans le fichier, de forme inconnue.
+* @returns les entiers retenus dans `1..65535` ; tableau vide si rien n'est valide.
+*/
+function sanitizePorts(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((n) => Number.isInteger(n) && n > 0 && n <= 65535);
+}
+function readRuntimeState(cwd, opts = {}) {
+	try {
+		const file = runtimeStateFile(cwd);
+		const raw = JSON.parse(readFileSync(file, "utf8"));
+		const pid = typeof raw.pid === "number" ? raw.pid : 0;
+		const ports = sanitizePorts(raw.ports);
+		if (ports.length === 0) return null;
+		if (pid > 0 && !isPidAlive(pid)) {
+			if (opts.purgeStale !== false) clearRuntimeState(cwd);
+			return null;
+		}
+		return {
+			pid,
+			ports,
+			desiredPorts: Array.isArray(raw.desiredPorts) ? sanitizePorts(raw.desiredPorts) : void 0,
+			ts: typeof raw.ts === "number" ? raw.ts : 0
+		};
+	} catch {
+		return null;
+	}
+}
+/** Retire le state file (arrêt propre, ou reliquat d'un process mort). */
+/**
+* Retrouve le runtime de CE projet par son fichier d'état, sans observer les process.
+*
+* Repli employé là où l'observation externe n'existe pas ({@link isProcessDiscoverySupported}).
+* Le fichier vit sous le `cwd` du projet et porte le PID de qui écoute : l'appartenance au
+* projet est donc acquise par construction, là où `ps` exigeait de lire le répertoire
+* courant d'un process tiers. {@link readRuntimeState} a déjà vérifié que le PID est
+* vivant et purgé le fichier sinon — un reliquat ne peut pas faire tuer un PID recyclé.
+*
+* Rend la TOPOLOGIE, pas un process isolé : le superviseur (pidfile) EN TÊTE, puis le
+* serveur qui écoute (fichier d'état). L'ordre porte une conséquence — un superviseur
+* relance son enfant dès qu'il le voit mourir, donc arrêter le serveur seul ne fait que
+* provoquer un rechargement. Les instances Vite, elles, restent hors de portée : rien ne
+* les publie, et elles meurent avec le superviseur qui les a lancées.
+*
+* Ce que le repli NE donne pas, faute de les observer : mémoire résidente, part CPU,
+* durée de vie du superviseur. Ces colonnes valent zéro et le rapport le dit.
+*
+* @param cwd - racine du projet.
+* @returns les process du projet, du superviseur au serveur ; vide si rien d'exploitable.
+*/
+function discoverFromRuntimeState(cwd) {
+	const supervisor = readSupervisorPid(cwd);
+	const supervisorAlive = supervisor !== null && isPidAlive(supervisor);
+	const state = readRuntimeState(cwd);
+	const found = [];
+	if (supervisorAlive) found.push({
+		pid: supervisor,
+		ppid: 0,
+		mode: "dev",
+		role: "supervisor",
+		label: "supervisor",
+		rssKb: 0,
+		cpu: 0,
+		uptimeSec: 0
+	});
+	if (state && state.pid > 0) found.push({
+		pid: state.pid,
+		ppid: supervisorAlive ? supervisor : 0,
+		mode: supervisorAlive ? "dev" : "prod",
+		role: "server",
+		label: "server",
+		rssKb: 0,
+		cpu: 0,
+		uptimeSec: Math.max(0, Math.round((Date.now() - state.ts) / 1e3))
+	});
+	return found;
+}
+function clearRuntimeState(cwd) {
+	try {
+		rmSync(runtimeStateFile(cwd), { force: true });
+	} catch {}
+}
+/**
+* Chemin du **verrou de suspension du superviseur dev** — le canal par lequel le serveur
+* dit à son parent : « je suis en train d'écrire dans les sources, ne me redémarre pas
+* maintenant ».
+*
+* Il existe parce que le watcher regarde `nodefony/`, `index.ts`, `src/` — et que
+* certaines opérations du serveur écrivent PRÉCISÉMENT là : générer un module depuis
+* Studio, appliquer une migration, installer un module tiers. Sans verrou, le
+* rechargement part au milieu de l'opération et tue le `npm install` en cours (le process
+* npm est un enfant du serveur), laissant un `node_modules` à moitié écrit.
+*
+* Un fichier, et pas un IPC, parce que parent et enfant n'en ont pas (`stdio: [ignore,
+* pipe, pipe]`) — et parce que c'est déjà le patron du pidfile et du state file, au même
+* endroit, déjà gitignoré.
+*/
+function supervisorLockFile(cwd) {
+	return path.join(cwd, "node_modules", ".cache", "nodefony", "supervisor.lock");
+}
+/**
+* Au-delà de cette durée, un verrou est tenu pour périmé quoi qu'il arrive.
+*
+* Deuxième filet après la vérification du PID : une opération très longue (`npm install`)
+* reste couverte, mais aucun verrou ne peut museler le watcher indéfiniment.
+*/
+const SUPERVISOR_LOCK_TTL_MS = 9e5;
+/**
+* Suspend le rechargement automatique le temps d'une opération qui écrit dans les
+* sources.
+*
+* À utiliser par TOUTE opération serveur qui touche aux fichiers surveillés — génération
+* de code, migration, installation d'un module. Best-effort : un échec d'écriture ne doit
+* jamais faire échouer l'opération elle-même (au pire, le superviseur redémarre).
+*
+* @param cwd - racine du projet.
+* @param reason - raison affichée à l'utilisateur (« génération de code »…).
+* @param detail - précision optionnelle (id de job…).
+*/
+function suspendSupervisor(cwd, reason, detail) {
+	try {
+		const file = supervisorLockFile(cwd);
+		mkdirSync(path.dirname(file), { recursive: true });
+		const lock = {
+			pid: process.pid,
+			reason,
+			detail,
+			ts: Date.now()
+		};
+		writeFileSync(file, JSON.stringify(lock), "utf8");
+	} catch {}
+}
+/** Rend la main au superviseur (fin de l'opération, quelle qu'en soit l'issue). */
+function resumeSupervisor(cwd) {
+	try {
+		rmSync(supervisorLockFile(cwd), { force: true });
+	} catch {}
+}
+/**
+* Le rechargement est-il suspendu, et pourquoi ?
+*
+* **Fail-safe par construction** : dans le doute, on répond `null` (le watcher fait son
+* travail). Un verrou muselle le rechargement automatique — le laisser traîner serait
+* pire que le mal : on éditerait ses fichiers sans que plus rien ne se recharge, sans la
+* moindre explication. Un verrou n'est donc retenu que s'il est VIVANT :
+*
+*  - son process existe encore (`kill(pid, 0)`) — un serveur tué en pleine opération
+*    laisse son fichier derrière lui ; on ne le croit pas sur parole ;
+*  - il a moins de {@link SUPERVISOR_LOCK_TTL_MS} — filet si un PID est recyclé par l'OS.
+*
+* Un verrou mort est SUPPRIMÉ au passage, pour ne pas se reposer la question.
+*
+* @param cwd - racine du projet.
+* @returns le verrou vivant (avec sa raison, à afficher), ou `null`.
+*/
+function readSupervisorSuspension(cwd) {
+	let raw;
+	try {
+		raw = readFileSync(supervisorLockFile(cwd), "utf8");
+	} catch {
+		return null;
+	}
+	let lock;
+	try {
+		lock = JSON.parse(raw);
+	} catch {
+		resumeSupervisor(cwd);
+		return null;
+	}
+	if (!lock?.pid || Date.now() - (lock.ts ?? 0) > SUPERVISOR_LOCK_TTL_MS) {
+		resumeSupervisor(cwd);
+		return null;
+	}
+	try {
+		process.kill(lock.pid, 0);
+	} catch {
+		resumeSupervisor(cwd);
+		return null;
+	}
+	return lock;
+}
+/**
+* Ports serveur à SONDER (`status`, `stop`, readiness, attente de libération).
+*
+* Ordre de vérité, du plus fiable au moins fiable :
+*  1. `NF_DEV_PORTS` — override explicite de l'opérateur, il gagne toujours ;
+*  2. le **state file runtime** — ce que le serveur écoute VRAIMENT (seule source
+*     exacte quand `portPolicy: "auto"` a décalé l'écoute) ;
+*  3. `NF_PORT` / `NF_PORT_HTTPS` — ce que l'application DÉCLARE. L'alias
+*     plateforme `PORT` (Cloud Run, Heroku) n'est PAS lu ici : il appartient au
+*     gabarit d'application, qui choisit de l'accepter, pas au framework — le
+*     lire depuis le cœur ferait précisément la collision que le préfixe `NF_`
+*     existe pour empêcher (un `PORT` posé pour un autre outil détournerait la
+*     sonde). Sans cette marche, une application qui tourne ailleurs que sur la
+*     convention était jugée sur les ports d'un projet VOISIN : `check` rendait
+*     « port déjà tenu » sur du code parfait dès qu'un autre serveur tournait
+*     sur le poste, et le verdict devenait dépendant de la machine ;
+*  4. `[5151, 5152]` — la convention historique, quand rien n'est déclaré ni ne
+*     tourne (cas du tout premier boot : personne n'a pu publier quoi que ce soit).
+*
+* @param cwd - racine du projet (le state file est par projet).
+*/
+function defaultDevPorts(cwd = process.cwd()) {
+	const env = process.env.NF_DEV_PORTS;
+	if (env) {
+		const parsed = env.split(",").map((s) => Number.parseInt(s.trim(), 10)).filter((n) => Number.isInteger(n) && n > 0);
+		if (parsed.length > 0) return parsed;
+	}
+	const state = readRuntimeState(cwd);
+	if (state && state.ports.length > 0) return [...state.ports];
+	const declares = [process.env.NF_PORT, process.env.NF_PORT_HTTPS].map((v) => Number.parseInt(String(v ?? ""), 10)).filter((n) => Number.isInteger(n) && n > 0);
+	if (declares.length > 0) return declares;
+	return [...FALLBACK_DEV_PORTS];
+}
+/** Lit le PID du superviseur depuis le pidfile, ou `null` si absent / illisible. */
+function readSupervisorPid(cwd) {
+	const file = devSupervisorPidFile(cwd);
+	try {
+		if (!existsSync(file)) return null;
+		const pid = Number.parseInt(readFileSync(file, "utf8").trim(), 10);
+		return Number.isInteger(pid) && pid > 0 ? pid : null;
+	} catch {
+		return null;
+	}
+}
+/** `true` si le process `pid` est vivant (signal 0 — ne le tue pas). */
+function isPidAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Nom d'image d'une ligne `tasklist /NH /FO CSV` — fonction PURE.
+*
+* `tasklist` sort `"node.exe","4212","Console","1","52 480 K"`, mais aussi, quand le
+* PID n'existe plus, une phrase en clair (`INFO: No tasks are running…`) avec un code
+* de sortie NUL. Ne rendre un nom que sur la forme CSV attendue est donc ce qui
+* distingue « je l'ai vu » de « je n'ai rien vu ».
+*
+* @param out - sortie brute de `tasklist`.
+* @returns le nom d'image, ou `null` si la sortie ne décrit aucun process.
+*/
+function parseTasklistImage(out) {
+	for (const raw of out.split("\n")) {
+		const line = raw.trim();
+		if (!line.startsWith("\"")) continue;
+		const m = /^"([^"]+)","(\d+)"/.exec(line);
+		if (m) return m[1];
+	}
+	return null;
+}
+/**
+* Identifie un process vivant par OBSERVATION EXTERNE, sur toutes les plateformes.
+*
+* POSIX lit la ligne de commande (`ps -o command=`) — la preuve la plus forte, elle
+* contient le titre de process Nodefony. Windows n'a pas d'équivalent bon marché :
+* `tasklist` ne rend que le nom d'IMAGE (`node.exe`), preuve plus faible, qui suffit
+* néanmoins à écarter un PID recyclé par un process tiers. C'est à l'appelant de
+* corroborer (le pidfile qui nomme ce PID vit dans SON projet).
+*
+* @param pid - process à identifier (supposé vivant).
+* @returns le verdict d'observation, cf {@link ProcessIdentity}.
+*/
+function identifyProcess(pid) {
+	const cmd = process.platform === "win32" ? {
+		file: "tasklist",
+		args: [
+			"/FI",
+			`PID eq ${pid}`,
+			"/NH",
+			"/FO",
+			"CSV"
+		]
+	} : {
+		file: "ps",
+		args: [
+			"-p",
+			String(pid),
+			"-o",
+			"command="
+		]
+	};
+	try {
+		const res = spawnSync(cmd.file, cmd.args, {
+			encoding: "utf8",
+			env: {
+				...process.env,
+				LC_ALL: "C",
+				LANG: "C"
+			}
+		});
+		if (res.error || typeof res.stdout !== "string") return {
+			observed: false,
+			command: null
+		};
+		if (process.platform === "win32") {
+			const image = parseTasklistImage(res.stdout);
+			return image === null ? {
+				observed: res.status === 0,
+				command: null
+			} : {
+				observed: true,
+				command: image
+			};
+		}
+		if (res.status !== 0) return {
+			observed: true,
+			command: null
+		};
+		const out = res.stdout.trim();
+		return {
+			observed: true,
+			command: out.length > 0 ? out : null
+		};
+	} catch {
+		return {
+			observed: false,
+			command: null
+		};
+	}
+}
+/**
+* Comment atteindre l'ARBRE de `pid` sur `platform` — fonction PURE, sans effet.
+*
+* POSIX répond par un signal au groupe (`-pid`), qui n'a pas d'équivalent Windows :
+* là-bas la seule voie est un programme externe, `taskkill /T`, qui descend la
+* FILIATION (parent → enfants → petits-enfants) au lieu du groupe. C'est pourquoi
+* l'enfant serveur y est spawné `detached:false` : rattaché, il est atteignable.
+*
+* `/F` (forcé) est là par nécessité, pas par choix : `taskkill` sans `/F` poste un
+* `WM_CLOSE` aux FENÊTRES du process, ce qu'un process console n'a pas — la demande
+* gracieuse n'arriverait donc nulle part. **Windows n'offre aucun arrêt gracieux
+* d'arbre**, et ce fait s'ÉNONCE ({@link TreeSignalOutcome}) plutôt qu'il ne se
+* masque derrière un `SIGTERM` qui n'en a que le nom.
+*
+* @param pid - racine de l'arbre à emporter.
+* @param platform - `process.platform` (injecté : c'est ce qui rend la règle testable
+*   depuis n'importe quel système).
+* @returns le programme à lancer, ou `null` quand la plateforme passe par les signaux.
+*/
+function killTreeCommand(pid, platform) {
+	if (platform !== "win32") return null;
+	return {
+		file: "taskkill",
+		args: [
+			"/PID",
+			String(pid),
+			"/T",
+			"/F"
+		]
+	};
+}
+/** Lance `taskkill` et CONSTATE le résultat (code 128 = process déjà parti : succès). */
+function defaultRunTreeKill(cmd) {
+	try {
+		const res = spawnSync(cmd.file, cmd.args, { encoding: "utf8" });
+		if (res.error) return false;
+		return res.status === 0 || res.status === 128;
+	} catch {
+		return false;
+	}
+}
+/**
+* Envoie `signal` à l'ARBRE de `pid` — enfant serveur ET ses Vite — et dit ce qu'il a
+* pu atteindre. No-op silencieux si le process n'existe plus.
+*
+* POSIX : signal au groupe (`-pid`) puis au pid en repli. Windows : `taskkill /T /F`
+* (cf {@link killTreeCommand}) puis, si le programme manque, `process.kill(pid)` —
+* qui n'emporte QUE l'enfant direct, d'où le verdict `single` à annoncer.
+*
+* @returns ce qui a été atteint, cf {@link TreeSignalOutcome}.
+*/
+function signalProcessGroup(pid, signal, deps = {}) {
+	const platform = deps.platform ?? process.platform;
+	const killPid = deps.killPid ?? ((p, s) => {
+		process.kill(p, s);
+	});
+	const tree = killTreeCommand(pid, platform);
+	if (tree) {
+		if ((deps.runTreeKill ?? defaultRunTreeKill)(tree)) return "forced-tree";
+		try {
+			killPid(pid, signal);
+		} catch {
+			return "gone";
+		}
+		return "single";
+	}
+	const killGroup = deps.killGroup ?? ((p, s) => {
+		process.kill(-p, s);
+	});
+	let group = true;
+	try {
+		killGroup(pid, signal);
+	} catch {
+		group = false;
+	}
+	let self = true;
+	try {
+		killPid(pid, signal);
+	} catch {
+		self = false;
+	}
+	if (group) return "group";
+	return self ? "single" : "gone";
+}
+/** Supprime le pidfile du superviseur (best-effort, idempotent). */
+function clearSupervisorPidFile(cwd) {
+	try {
+		const f = devSupervisorPidFile(cwd);
+		if (existsSync(f)) rmSync(f, { force: true });
+	} catch {}
+}
+/** Petite pause (poll/backoff des boucles d'attente). */
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+* Racines d'un ensemble de process : ceux dont le parent n'est PAS lui-même dans
+* l'ensemble. Tuer le GROUPE d'une racine suffit à emporter ses descendants présents
+* (le superviseur emporte enfant serveur + Vite ; un orphelin est sa propre racine).
+*/
+function rootProcesses(procs) {
+	const pids = new Set(procs.map((p) => p.pid));
+	return procs.filter((p) => !pids.has(p.ppid));
+}
+/** Attend que tous les `pids` soient morts (poll), renvoie ceux encore vivants à l'échéance. */
+async function waitAllDead(pids, timeoutMs) {
+	const deadline = Date.now() + timeoutMs;
+	for (;;) {
+		const alive = pids.filter((pid) => isPidAlive(pid));
+		if (alive.length === 0) return [];
+		if (Date.now() >= deadline) return alive;
+		await delay(120);
+	}
+}
+/**
+* Arrête un ensemble de process dev par GROUPE — SIGTERM (arrêt gracieux) sur les
+* racines puis SIGKILL des récalcitrants (groupes racines + PID restants un à un).
+* Renvoie les PID encore vivants à la fin (vide = arrêt complet).
+*
+* OBSERVATION EXTERNE pure (signaux POSIX, aucun IPC). Logique PARTAGÉE entre
+* `nodefony stop` (rapport user, cf {@link DevProcessInfo}) et le verrou single-instance
+* du superviseur (nettoyage des résiduels au démarrage) → une seule définition de « tuer
+* proprement un arbre de process dev » (divergence = bug).
+*/
+async function terminateDevProcesses(procs, opts = {}) {
+	if (procs.length === 0) return [];
+	const termWaitMs = opts.termWaitMs ?? 4e3;
+	const killWaitMs = opts.killWaitMs ?? 1500;
+	const roots = rootProcesses(procs);
+	for (const r of roots) signalProcessGroup(r.pid, "SIGTERM");
+	let alive = await waitAllDead(procs.map((p) => p.pid), termWaitMs);
+	if (alive.length > 0) {
+		for (const r of roots) signalProcessGroup(r.pid, "SIGKILL");
+		for (const pid of alive) try {
+			process.kill(pid, "SIGKILL");
+		} catch {}
+		alive = await waitAllDead(alive, killWaitMs);
+	}
+	return alive;
+}
+/**
+* Répertoire de travail d'un process — `/proc/<pid>/cwd` (Linux) ou `lsof -d cwd`
+* (macOS/BSD). `null` si irrésolu (process mort, permissions, outil absent).
+*
+* Sert au SCOPING PAR PROJET du multi-app : plusieurs apps Nodefony peuvent
+* tourner en dev sur le même poste — un balayage `ps` global sans notion de
+* projet faisait tuer le runtime d'un AUTRE dossier (destructeur, vécu en
+* design review). Le cwd est le seul identifiant de projet observable de
+* l'extérieur (aucun IPC — choix d'architecture de ce module).
+*/
+function processCwd(pid) {
+	if (process.platform === "linux") try {
+		return readlinkSync(`/proc/${pid}/cwd`);
+	} catch {
+		return null;
+	}
+	try {
+		const res = spawnSync("lsof", [
+			"-a",
+			"-p",
+			String(pid),
+			"-d",
+			"cwd",
+			"-Fn"
+		], {
+			encoding: "utf8",
+			env: {
+				...process.env,
+				LC_ALL: "C"
+			}
+		});
+		if (typeof res.stdout !== "string") return null;
+		for (const line of res.stdout.split("\n")) if (line.startsWith("n")) return line.slice(1);
+	} catch {}
+	return null;
+}
+/**
+* Scinde des process découverts entre CE projet (`mine` — tuables par les gardes
+* single-instance / `nodefony stop`) et les AUTRES (`foreign` — JAMAIS touchés).
+*
+* Règles de rattachement :
+* - rôles racine (supervisor/master/server/worker) : cwd EXACTEMENT le projet —
+*   ils sont toujours spawnés à la racine ;
+* - `vite` : projet OU sous-dossier (le builder peut travailler dans `frontend/`) ;
+* - cwd IRRÉSOLU → `foreign` : on préfère laisser vivre un orphelin (bénin, la
+*   collision de ports est refusée plus loin) plutôt que tuer la session d'un
+*   autre projet (destructeur).
+*
+* Limite assumée : deux projets IMBRIQUÉS (une app dans un sous-dossier du repo)
+* partagent le préfixe → le Vite de l'app peut être adopté par le parent.
+*/
+function splitByProject(procs, projectCwd, getCwd = processCwd) {
+	const root = path.resolve(projectCwd);
+	const mine = [];
+	const foreign = [];
+	for (const p of procs) {
+		const cwd = getCwd(p.pid);
+		const resolved = cwd === null ? null : path.resolve(cwd);
+		if (resolved !== null && (resolved === root || p.role === "vite" && resolved.startsWith(root + path.sep))) mine.push(p);
+		else foreign.push({
+			...p,
+			cwd: resolved
+		});
+	}
+	return {
+		mine,
+		foreign
+	};
+}
+/**
+* `true` si `cwd` ressemble à un projet Nodefony : `package.json` déclarant la
+* dépendance `nodefony`, OU `node_modules/nodefony` présent (app installée sans
+* la déclarer). MÊME heuristique que `Kernel.resolveAppEntry` (détection d'app),
+* mais STANDALONE (fs seul, aucun kernel) — pour que `nodefony status`/`stop`
+* lancés hors projet le DISENT au lieu de suggérer un `nodefony dev` voué à
+* l'échec.
+*
+* @param cwd - dossier à tester.
+*/
+function isNodefonyProjectDir(cwd) {
+	try {
+		const pkg = JSON.parse(readFileSync(path.resolve(cwd, "package.json"), "utf8"));
+		if (pkg.dependencies?.nodefony ?? pkg.devDependencies?.nodefony ?? pkg.peerDependencies?.nodefony) return true;
+	} catch {}
+	return existsSync(path.resolve(cwd, "node_modules", "nodefony"));
+}
+/**
+* Racines de projet des runtimes ÉTRANGERS = cwd des rôles racine
+* (supervisor/master/server/worker), toujours spawnés à la racine de leur projet.
+* Un Vite, lui, peut travailler dans un sous-dossier : il se rattache par préfixe.
+*
+* Fonction PURE, partagée par le groupement d'affichage
+* ({@link formatForeignRuntimes}) et l'attribution des ports
+* ({@link foreignPortOwners}) — deux lectures du même découpage, une seule règle.
+*/
+function foreignProjectRoots(foreign) {
+	return [...new Set(foreign.filter((p) => p.role !== "vite" && p.cwd).map((p) => p.cwd))];
+}
+/**
+* À QUI appartient chaque port occupé, quand ce n'est pas à nous.
+*
+* Un port tenu par le voisin n'est pas un arrêt qui a échoué : `stop` marquait
+* `✗ encore occupé` les ports 5151/5152 juste après avoir annoncé lui-même que ces
+* runtimes appartenaient à un AUTRE projet — la croix suggérait un échec là où il
+* n'y avait rien à arrêter. Et `status`, faute de cette distinction, annonçait
+* « 2/2 ports UP » à une application qui ne tournait pas.
+*
+* On interroge le canal que chaque projet publie sur lui-même
+* ({@link readRuntimeState}) : c'est la seule source qui dise les ports EFFECTIFS
+* quand `portPolicy: "auto"` les a décalés. Lecture SANS purge — le ménage d'un
+* projet étranger ne nous appartient pas.
+*
+* @param foreign - runtimes d'autres projets (sortie `splitByProject().foreign`).
+* @param readState - lecture d'un état de projet (injectable pour les tests).
+* @returns port → racine du projet qui le tient (objet nu : sérialisable JSON,
+*   donc transportable tel quel par le data plane, là où une `Map` se perdrait).
+*/
+function foreignPortOwners(foreign, readState = (cwd) => readRuntimeState(cwd, { purgeStale: false })) {
+	const owners = {};
+	for (const root of foreignProjectRoots(foreign)) {
+		const state = readState(root);
+		if (!state) continue;
+		for (const port of state.ports) if (owners[port] === void 0) owners[port] = root;
+	}
+	return owners;
+}
+/**
+* Qualifie un port sondé à partir des propriétaires connus
+* ({@link foreignPortOwners}). Fonction PURE : c'est LA règle « pas à moi ≠ pas
+* mort », et elle vit à un seul endroit pour que `status` et `stop` la lisent pareil.
+*/
+function portOwnership(state, owners = {}) {
+	if (!state.listening) return "free";
+	return owners[state.port] === void 0 ? "occupied" : "foreign";
+}
+/**
+* Met en forme les runtimes ÉTRANGERS (autre projet) en bloc multi-lignes AÉRÉ :
+* groupés par racine de projet (un Vite au cwd sous-dossier est rattaché à la
+* racine qui le préfixe, affiché en relatif), un process par ligne (pid + rôle),
+* puis les commandes EXACTES à copier-coller pour les arrêter. Partagé par le
+* refus de boot (`DevSupervisor`), `nodefony dev --detach`, `nodefony stop` et
+* `nodefony status` — même pédagogie partout (vécu : un pavé mono-ligne de 4 pids,
+* dev bloqué sans savoir QUOI taper).
+*
+* @param foreign - runtimes d'autres projets (sortie `splitByProject().foreign`).
+* @returns lignes prêtes à afficher (sans couleur ; l'appelant préfixe/colore).
+*/
+function formatForeignRuntimes(foreign) {
+	const roots = foreignProjectRoots(foreign);
+	const projectOf = (p) => {
+		if (!p.cwd) return "(dossier inconnu)";
+		return roots.find((r) => p.cwd === r || p.cwd.startsWith(r + path.sep)) ?? p.cwd;
+	};
+	const byProject = /* @__PURE__ */ new Map();
+	for (const p of foreign) {
+		const key = projectOf(p);
+		const list = byProject.get(key);
+		if (list) list.push(p);
+		else byProject.set(key, [p]);
+	}
+	const lines = [""];
+	for (const [project, procs] of byProject) {
+		lines.push(`  projet ${project}`);
+		for (const p of procs) {
+			const sub = p.cwd && p.cwd !== project ? `  (${path.relative(project, p.cwd)})` : "";
+			lines.push(`    · pid ${p.pid}  ${p.label}${sub}`);
+		}
+	}
+	lines.push("", "  pour les arrêter :");
+	for (const project of byProject.keys()) if (!project.startsWith("(")) {
+		lines.push(`    nodefony stop ${path.basename(project)}`);
+		lines.push(`    cd ${project} && nodefony stop`);
+	}
+	lines.push("    nodefony stop --all        (tout Nodefony, tous projets)", "");
+	return lines;
+}
+/**
+* `true` si un service écoute sur `port` en loopback (connexion acceptée). Inverse de
+* la sonde « port libre » du superviseur : ici on confirme qu'un serveur RÉPOND.
+*/
+function isPortListening(port, host = "127.0.0.1", timeoutMs = 400) {
+	return new Promise((resolve) => {
+		const socket = net.connect({
+			host,
+			port
+		});
+		const settle = (listening) => {
+			socket.removeAllListeners();
+			socket.destroy();
+			resolve(listening);
+		};
+		socket.once("connect", () => settle(true));
+		socket.once("error", () => settle(false));
+		socket.setTimeout(timeoutMs, () => settle(false));
+	});
+}
+/** Sonde TCP de plusieurs ports en parallèle. */
+async function probePorts(ports) {
+	return Promise.all(ports.map(async (port) => ({
+		port,
+		listening: await isPortListening(port)
+	})));
+}
+/** Convertit le champ `etime` de `ps` (`[[DD-]HH:]MM:SS`) en secondes. */
+function parseEtime(etime) {
+	let rest = etime.trim();
+	let days = 0;
+	const dash = rest.indexOf("-");
+	if (dash >= 0) {
+		days = Number.parseInt(rest.slice(0, dash), 10) || 0;
+		rest = rest.slice(dash + 1);
+	}
+	const parts = rest.split(":").map((n) => Number.parseInt(n, 10) || 0);
+	let h = 0;
+	let m = 0;
+	let s = 0;
+	if (parts.length === 3) [h, m, s] = parts;
+	else if (parts.length === 2) [m, s] = parts;
+	else if (parts.length === 1) [s] = parts;
+	return days * 86400 + h * 3600 + m * 60 + s;
+}
+/** Formate une durée (s) en libellé court (`45s`, `2m14s`, `1h03m`, `2d 05h`). */
+function formatUptime(sec) {
+	if (sec < 60) return `${sec}s`;
+	const d = Math.floor(sec / 86400);
+	const h = Math.floor(sec % 86400 / 3600);
+	const m = Math.floor(sec % 3600 / 60);
+	const s = sec % 60;
+	if (d > 0) return `${d}d ${String(h).padStart(2, "0")}h`;
+	if (h > 0) return `${h}h${String(m).padStart(2, "0")}m`;
+	return `${m}m${String(s).padStart(2, "0")}s`;
+}
+/** Extrait le détail d'un titre Vite (`nodefony-vite[studio]` → `studio`). */
+function viteEntries(command) {
+	const m = command.match(/nodefony-vite\[([^\]]*)\]/);
+	return m ? m[1] : "";
+}
+/** Regex d'une ligne `ps -o pid=,ppid=,rss=,pcpu=,etime=,command=`. */
+const PS_ROW_RE = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+([\d.,]+)\s+(\S+)\s+(.*)$/;
+/**
+* Parse UNE ligne `ps` (pid ppid rss pcpu etime command) en {@link DevProcessInfo},
+* ou `null` si la ligne ne matche pas ou n'est pas un process dev connu. `%CPU` toléré
+* avec point OU virgule décimale (robustesse locale — la virgule FR a déjà fait passer
+* la détection à zéro). Fonction PURE (testable sans `ps`).
+*/
+function parsePsRow(line) {
+	const m = line.match(PS_ROW_RE);
+	if (!m) return null;
+	const c = classify(m[6]);
+	if (!c) return null;
+	return {
+		pid: Number.parseInt(m[1], 10),
+		ppid: Number.parseInt(m[2], 10),
+		mode: c.mode,
+		role: c.role,
+		label: c.label,
+		detail: c.detail,
+		rssKb: Number.parseInt(m[3], 10),
+		cpu: Number.parseFloat(m[4].replace(",", ".")),
+		uptimeSec: parseEtime(m[5])
+	};
+}
+/**
+* Classe une ligne de commande `ps` en (mode, rôle) runtime Nodefony, ou `null` si hors
+* périmètre. Ordre du matching : titres dev (les plus spécifiques) d'abord, puis cluster
+* (master/worker), puis le serveur prod mono générique en dernier — `nodefony-dev-server`
+* (tiret) ne contient jamais `nodefony server` (espace), donc aucune ambiguïté.
+*
+* **Le titre est ANCRÉ EN TÊTE, jamais cherché dans la ligne.** Poser un
+* `process.title` REMPLACE l'argv entier : `ps` rend alors le titre seul (au
+* padding d'espaces près). Un process qui porte le motif AILLEURS ne fait que le
+* mentionner — `tail -f /dev/null nodefony server`, `vim nodefony master.ts`,
+* `grep -r nodefony-dev-server` — et il ne doit jamais devenir une cible :
+* `nodefony stop --all` ne filtre par aucun projet, la reconnaissance du titre y
+* est le SEUL rempart. Corollaire assumé : la fenêtre PRÉ-titre d'un boot
+* (`npm exec nodefony development`, avant que la commande pose son titre) n'est
+* pas détectée — mieux vaut manquer un process de 200 ms que tuer celui d'autrui.
+*/
+function classify(command) {
+	const cmd = command.trim();
+	if (cmd.startsWith("nodefony-dev-supervisor")) return {
+		mode: "dev",
+		role: "supervisor",
+		label: "supervisor"
+	};
+	if (cmd.startsWith("nodefony-dev-server")) return {
+		mode: "dev",
+		role: "server",
+		label: "server"
+	};
+	if (cmd.startsWith("nodefony-vite")) return {
+		mode: "dev",
+		role: "vite",
+		label: "vite",
+		detail: viteEntries(cmd) || void 0
+	};
+	if (cmd.startsWith("nodefony master")) {
+		const w = cmd.match(/\[cluster\s+(\d+)w\]/);
+		return {
+			mode: "cluster",
+			role: "master",
+			label: "master",
+			detail: w ? `${w[1]} workers` : void 0
+		};
+	}
+	if (cmd.startsWith("nodefony worker")) {
+		const id = cmd.match(/^nodefony worker (\d+)/);
+		return {
+			mode: "cluster",
+			role: "worker",
+			label: "worker",
+			detail: id ? `#${id[1]}` : void 0
+		};
+	}
+	if (cmd.startsWith("nodefony server")) return {
+		mode: "prod",
+		role: "server",
+		label: "server"
+	};
+	return null;
+}
+/**
+* Découvre les process dev Nodefony vivants par OBSERVATION EXTERNE (`ps`), et DIT si
+* l'observation a eu lieu.
+*
+* Ne retient que les process dont la commande porte un titre dev connu (superviseur /
+* serveur / Vite) et en extrait PID/PPID/RSS/CPU/uptime. S'auto-exclut par défaut (le
+* process appelant) sauf `opts.includeSelf`. Tri : superviseur, puis serveur, puis Vite.
+*
+* @remarks La disponibilité de `ps` ne se DÉDUIT pas de la plateforme, elle se CONSTATE.
+*   La supposer d'après `process.platform` revenait à parier que tout ce qui n'est pas
+*   Windows embarque `ps` — faux là où ça compte le plus : `procps` n'est pas installé
+*   dans les images Node minces (`node:*-slim`, distroless, Alpine nu) qui SONT le
+*   modèle de déploiement de Nodefony, et les BSD n'acceptent pas forcément cette
+*   syntaxe. Le pari donnait alors « aucun process » sans repli et sans un mot. On rend
+*   donc `supported:false` sur tout ce qui empêche de conclure : plateforme sans `ps`,
+*   binaire absent (`ENOENT`), code de sortie non nul, sortie illisible.
+*/
+function discoverDevProcessesDetailed(opts = {}) {
+	if (process.platform === "win32") return {
+		supported: false,
+		procs: []
+	};
+	let out;
+	try {
+		const res = spawnSync("ps", [
+			"-A",
+			"-o",
+			"pid=,ppid=,rss=,pcpu=,etime=,command="
+		], {
+			encoding: "utf8",
+			maxBuffer: 4194304,
+			env: {
+				...process.env,
+				LC_ALL: "C",
+				LANG: "C"
+			}
+		});
+		if (res.error || res.status !== 0 || typeof res.stdout !== "string") return {
+			supported: false,
+			procs: []
+		};
+		out = res.stdout;
+	} catch {
+		return {
+			supported: false,
+			procs: []
+		};
+	}
+	const procs = [];
+	for (const raw of out.split("\n")) {
+		const info = parsePsRow(raw);
+		if (!info) continue;
+		if (!opts.includeSelf && info.pid === process.pid) continue;
+		procs.push(info);
+	}
+	const order = {
+		supervisor: 0,
+		master: 0,
+		server: 1,
+		worker: 1,
+		vite: 2
+	};
+	procs.sort((a, b) => order[a.role] - order[b.role] || a.pid - b.pid);
+	return {
+		supported: true,
+		procs
+	};
+}
+/**
+* Liste seule des process observés — commodité pour les appelants qui n'ont rien à
+* décider du « je n'ai pas pu regarder » (le rendu d'un tableau, un décompte).
+* Quiconque doit choisir un REPLI prend {@link discoverDevProcessesDetailed}, sans quoi
+* une liste vide se lit « rien ne tourne » alors qu'elle peut signifier l'inverse.
+*/
+function discoverDevProcesses(opts = {}) {
+	return discoverDevProcessesDetailed(opts).procs;
+}
+/**
+* Modes runtime présents parmi les process PRINCIPAUX (Vite exclu — un Vite ne « tient »
+* pas les ports serveur). Set vide = aucun runtime principal vivant. Fonction PURE.
+*/
+function runtimeModes(procs) {
+	const modes = /* @__PURE__ */ new Set();
+	for (const p of procs) if (PRIMARY_ROLES.has(p.role)) modes.add(p.mode);
+	return modes;
+}
+/**
+* Mode runtime dominant observé, ou `null` si aucun process principal. Priorité
+* dev > cluster > prod en cas de cohabitation anormale (le conflit est signalé par
+* ailleurs en warning / refus). Fonction PURE.
+*/
+function detectRuntimeMode(procs) {
+	const modes = runtimeModes(procs);
+	if (modes.has("dev")) return "dev";
+	if (modes.has("cluster")) return "cluster";
+	if (modes.has("prod")) return "prod";
+	return null;
+}
+/**
+* Process PRINCIPAUX appartenant à un runtime d'un mode DIFFÉRENT de `intended` — un
+* conflit de cohabitation (ex. un `prod`/`cluster` occupe les ports quand on veut
+* démarrer en `dev`, ou l'inverse). Vite exclu (enfant). Sert aux gardes anti-collision :
+* fail-loud (refus + message), JAMAIS de kill cross-mode automatique (un prod est
+* intentionnel). Fonction PURE.
+*/
+function findRuntimeConflict(procs, intended) {
+	return procs.filter((p) => PRIMARY_ROLES.has(p.role) && p.mode !== intended);
+}
+/** Résout les globs `workspaces` (`a/b`, `a/*`) en chemins de dossiers absolus. */
+function resolveWorkspaceDirs(cwd, globs) {
+	const out = [];
+	for (const g of globs) if (g.endsWith("/*")) {
+		const base = path.join(cwd, g.slice(0, -2));
+		try {
+			for (const e of readdirSync(base, { withFileTypes: true })) if (e.isDirectory()) out.push(path.join(base, e.name));
+		} catch {}
+	} else out.push(path.join(cwd, g));
+	return out;
+}
+/**
+* Liste les workspaces qui DEVRAIENT produire un dist (présence d'un `rolldown.config.ts`)
+* mais dont le dossier `dist/` est absent ou vide — renvoie leurs **noms de package**
+* (pour `turbo --filter`). On cible l'ABSENCE de build, pas l'entrée exacte (le core
+* sort `dist/node/…`, d'autres `dist/index.js`) → vérifier « dist non vide » est le
+* critère robuste et uniforme.
+*
+* POST-CONDITION du build du superviseur : `turbo run build` peut renvoyer 0 en « cache
+* hit » SANS restaurer un dist supprimé (gitignored, `clean` partiel, checkout de
+* branche) → le module manquant tombe en fail-soft au boot et cascade en silence
+* (« vert mais cassé »). On vérifie le terrain (la confiance n'exclut pas le contrôle).
+* Pur filesystem, aucun boot. Un workspace sans config de bundler (WIP non câblé) est
+* ignoré : aucun dist n'est attendu de lui.
+*/
+function missingWorkspaceDists(cwd) {
+	let globs;
+	try {
+		globs = JSON.parse(readFileSync(path.join(cwd, "package.json"), "utf8")).workspaces ?? [];
+	} catch {
+		return [];
+	}
+	const missing = [];
+	for (const dir of resolveWorkspaceDirs(cwd, globs)) {
+		if (!existsSync(path.join(dir, "rolldown.config.ts"))) continue;
+		if (distIsBuilt(dir)) continue;
+		let name = path.basename(dir);
+		try {
+			const pj = JSON.parse(readFileSync(path.join(dir, "package.json"), "utf8"));
+			if (pj.name) name = pj.name;
+		} catch {}
+		missing.push(name);
+	}
+	return missing;
+}
+/** `true` si le dossier `dist/` du workspace existe et contient au moins un fichier. */
+function distIsBuilt(dir) {
+	try {
+		return readdirSync(path.join(dir, "dist")).length > 0;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { CLUSTER_MASTER_PREFIX, CLUSTER_WORKER_PREFIX, DEV_SERVER_TITLE, DEV_SUPERVISOR_TITLE, DEV_VITE_PREFIX, FALLBACK_DEV_PORTS, PROD_SERVER_TITLE, clearReadinessState, clearRuntimeState, clearSupervisorPidFile, defaultDevPorts, detectRuntimeMode, devSupervisorPidFile, discoverDevProcesses, discoverDevProcessesDetailed, discoverFromRuntimeState, findRuntimeConflict, foreignPortOwners, foreignProjectRoots, formatForeignRuntimes, formatUptime, identifyProcess, isNodefonyProjectDir, isPidAlive, isPortListening, killTreeCommand, missingWorkspaceDists, parsePsRow, parseTasklistImage, portOwnership, probePorts, processCwd, readReadinessState, readRuntimeState, readSupervisorPid, readSupervisorSuspension, readinessStateFile, resumeSupervisor, rootProcesses, runtimeModes, runtimeStateFile, signalProcessGroup, splitByProject, supervisorLockFile, suspendSupervisor, terminateDevProcesses, waitAllDead, writeReadinessState, writeRuntimeState };