nodefony 7.0.2 → 10.0.0-alpha.2

package/dist/node/kernel/commands/MenuCommand.js

@@ -0,0 +1,261 @@
+import { resolveColorEnabled } from "../../syslog/logColor.js";
+import Command from "../../command/Command.js";
+import { NPM_SCRIPT_PREFIX, buildInspectMenu, buildStartMenu, filterStartMenu, planMenuAction } from "../../cli/startMenu.js";
+import { readCliManifest } from "../../cli/completion.js";
+import { needsShell } from "../../cli/execPortable.js";
+import { INSPECT_SUBJECTS } from "../inspect/adminSubjects.js";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+//#region src/kernel/commands/MenuCommand.ts
+const options = {
+	helpGroup: "COMPRENDRE",
+	showBanner: false,
+	kernelEvent: "onStart"
+};
+/**
+* Menu interactif du CLI (`nodefony menu`, ou `nodefony` nu en TTY).
+*
+* La COMPOSITION (groupes, entrées, conseils, filtrage à la frappe) vit dans
+* `cli/startMenu.ts` — pure, testée sans TTY. Ici : le RENDU (couleurs gatées,
+* alignement à la largeur du terminal, aération des groupes), le prompt
+* `search` (taper filtre, façon palette), et l'exécution du choix. Ctrl+C est
+* un choix légitime : sortie 0, une ligne sobre — jamais une erreur.
+*/
+var Menu = class extends Command {
+	constructor(cli) {
+		super("menu", "menu interactif : les commandes utiles ici", cli, options);
+		this.forceInteractiveMode();
+	}
+	#color = false;
+	#dim(text) {
+		return this.#color ? `\x1b[2m${text}\x1b[22m` : text;
+	}
+	#bold(text) {
+		return this.#color ? `\x1b[1m${text}\x1b[22m` : text;
+	}
+	#cyan(text) {
+		return this.#color ? `\x1b[36m${text}\x1b[39m` : text;
+	}
+	/** Largeur utile du terminal (bornée : un résumé ne dépasse jamais). */
+	#columns() {
+		return Math.min(process.stdout.columns || 80, 110);
+	}
+	/**
+	* Traduit les items neutres en choices inquirer STYLÉS :
+	* - un titre de groupe = une ligne vide puis le titre en capitales discrètes
+	*   (l'aération est ce qui rend une liste de 20 entrées lisible) ;
+	* - un choix = label cyan aligné sur la colonne + résumé estompé, tronqué à
+	*   la largeur réelle du terminal (une ligne qui replie casse l'alignement).
+	*/
+	#render(items) {
+		const labels = items.filter((i) => i.kind === "choice");
+		const col = Math.max(...labels.map((c) => c.label.length), 10) + 2;
+		const width = this.#columns();
+		const out = [];
+		for (const item of items) {
+			if (item.kind === "separator") {
+				out.push(new this.prompts.Separator(" "));
+				out.push(new this.prompts.Separator(`  ${this.#bold(this.#dim(item.label.toUpperCase()))}`));
+				continue;
+			}
+			const room = width - col - 6;
+			const summary = item.summary.length > room && room > 8 ? `${item.summary.slice(0, room - 1)}…` : item.summary;
+			out.push({
+				name: `${this.#cyan(item.label.padEnd(col))}${this.#dim(summary)}`,
+				value: item.value,
+				short: item.label,
+				description: this.#dim(item.description)
+			});
+		}
+		return out;
+	}
+	/** Thème partagé des prompts du menu — sobre, aide clavier en français. */
+	#theme() {
+		return {
+			prefix: {
+				idle: this.#cyan("⬢"),
+				done: this.#cyan("⬢")
+			},
+			icon: { cursor: "❯" },
+			style: {
+				highlight: (text) => this.#bold(this.#cyan(text)),
+				description: (text) => `\n  ${text}`,
+				keysHelpTip: () => this.#dim("  ↑↓ naviguer · taper pour filtrer · ⏎ choisir · ctrl+c quitter")
+			}
+		};
+	}
+	/** Ctrl+C pendant un prompt = un choix, pas une panne : sortie 0, sobre. */
+	async #quit(e) {
+		if (e?.name === "ExitPromptError") {
+			process.stdout.write(`\n${this.#dim("À bientôt.")}\n`);
+			await this.cli?.terminate(0, true);
+		}
+		this.log(e.message, "ERROR");
+		this.terminate(1);
+		return new Promise(() => {});
+	}
+	/**
+	* Commandes de MODULE connues du manifest cache de complétion : celles que
+	* commander ne connaît pas encore à `onStart` (dispatch différé). Cache
+	* absent (jamais booté en dev) → liste vide, le groupe n'apparaît pas.
+	*/
+	moduleCommandsFromManifest() {
+		const manifest = readCliManifest(process.cwd());
+		if (!manifest) return [];
+		const builtins = this.cli.getBuiltinCommandNames();
+		return manifest.commands.filter((c) => !builtins.has(c.name)).map((c) => {
+			const entry = {
+				name: c.name,
+				description: c.description
+			};
+			if (c.group) entry.group = c.group;
+			return entry;
+		});
+	}
+	/**
+	* Les commandes INTÉGRÉES, telles que commander les connaît à `onStart`.
+	*
+	* Elles portent leur groupe d'intention et le nombre d'arguments qu'elles
+	* exigent : le menu s'en sert pour proposer tout ce qui existe, sans liste
+	* blanche à tenir.
+	*
+	* @returns le relevé, vide si commander n'est pas encore prêt.
+	*/
+	builtinCommands() {
+		return (this.cli?.commander?.commands ?? []).filter((c) => !c.name().startsWith("__") && c.name() !== "help").map((c) => {
+			const group = c.helpGroup?.();
+			const entry = {
+				name: c.name(),
+				description: c.description() || "",
+				requiredArgs: (c.registeredArguments ?? []).filter((a) => a.required).length
+			};
+			if (typeof group === "string" && group) entry.group = group;
+			return entry;
+		});
+	}
+	/**
+	* Noms des scripts du `package.json` du projet — le menu n'en proposera que
+	* ceux de son catalogue. Lecture fail-soft : pas de fichier, JSON invalide →
+	* liste vide, les groupes n'apparaissent pas.
+	*/
+	npmScriptsFromPackageJson() {
+		try {
+			const raw = readFileSync(path.join(process.cwd(), "package.json"), "utf8");
+			const scripts = JSON.parse(raw).scripts;
+			return scripts ? Object.keys(scripts) : [];
+		} catch {
+			return [];
+		}
+	}
+	async interaction() {
+		this.#color = resolveColorEnabled(Boolean(this.kernel?.isTTY));
+		const { message, items } = buildStartMenu({
+			inProject: Boolean(this.kernel?.trunk),
+			projectName: this.kernel?.projectName,
+			describe: (name) => {
+				const command = this.cli?.getCommand(name);
+				return command ? command.description() : null;
+			},
+			moduleCommands: this.moduleCommandsFromManifest(),
+			builtinCommands: this.builtinCommands(),
+			npmScripts: this.npmScriptsFromPackageJson()
+		});
+		const version = this.kernel?.version ? ` v${this.kernel.version}` : "";
+		process.stdout.write(`\n${this.#bold(this.kernel?.projectName ?? "nodefony")}${this.#dim(version)}\n`);
+		const pageSize = Math.max(8, Math.min(items.length + 8, (process.stdout.rows || 24) - 6));
+		const selected = await this.prompts.search({
+			message,
+			source: (term) => this.#render(filterStartMenu(items, term ?? "")),
+			pageSize,
+			theme: this.#theme()
+		}).catch((e) => this.#quit(e));
+		if (selected === "inspect") {
+			const sub = buildInspectMenu(INSPECT_SUBJECTS);
+			return `inspect ${await this.prompts.select({
+				message: sub.message,
+				choices: this.#render(sub.items),
+				pageSize: 12,
+				loop: false,
+				theme: this.#theme()
+			}).catch((e) => this.#quit(e))}`;
+		}
+		return selected;
+	}
+	/**
+	* Applique à la commande CHOISIE ce qu'elle déclare — aujourd'hui le boot
+	* silencieux, demain d'autres capacités.
+	*
+	* 🔴 `CliKernel.start()` pose déjà `quietBoot` d'après la commande DEMANDÉE
+	* sur la ligne — mais depuis le menu, la commande demandée est `menu` : celle
+	* que l'utilisateur choisit ensuite n'existe pas encore à cet instant. Sa
+	* déclaration était donc ignorée, et `check` choisie au menu rendait son
+	* verdict sous dix lignes de « MODULE ADD ». Le syslog est réinitialisé
+	* derrière, sinon le filtre resterait celui calculé au démarrage.
+	*
+	* PUBLIQUE pour être ÉPROUVÉE : ce câblage a échoué deux fois en silence (la
+	* capacité ignorée, puis le syslog empilé au lieu d'être remplacé), et un
+	* pseudo-terminal ne le prouve pas de façon fiable.
+	*
+	* @param name - nom de la commande choisie au menu
+	*/
+	applyCapabilities(name) {
+		const cli = this.cli;
+		const cmd = cli?.getCommand(name);
+		if (!cmd) return;
+		cmd.forceInteractiveMode();
+		if (cmd.quietBoot && cli) {
+			cli.quietBoot = true;
+			cli.initSyslog();
+		}
+	}
+	async generate(response) {
+		if (!this.cli) throw new Error(`cli not found`);
+		process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
+		process.stdout.write(`${this.#cyan("⬢")} ${this.#bold(this.kernel?.projectName ?? "nodefony")} ${this.#dim(`— ${response.replace(NPM_SCRIPT_PREFIX, "npm run ")}`)}\n\n`);
+		const plan = planMenuAction(response, (name) => Boolean(this.cli?.getCommand(name)));
+		if (plan.kind === "npm") {
+			const r = spawnSync("npm", ["run", plan.script], {
+				stdio: "inherit",
+				shell: needsShell("npm")
+			});
+			this.terminate(r.status ?? 1);
+			return this;
+		}
+		if (plan.kind === "respawn") {
+			const bin = process.argv[1];
+			const r = bin ? spawnSync(process.execPath, [
+				bin,
+				"--interactive",
+				...plan.argv
+			], { stdio: "inherit" }) : { status: 1 };
+			this.terminate(r.status ?? 1);
+			return this;
+		}
+		if (response.includes(" ")) {
+			const [name, ...args] = response.split(" ");
+			this.applyCapabilities(name);
+			await this.cli.runCommandAsync(name, args);
+			return this;
+		}
+		const command = this.cli.getCommand(response);
+		if (command && response) {
+			this.applyCapabilities(response);
+			if (this.kernel) {
+				this.cli.clearCommand();
+				if (response) process.argv.push(response);
+				this.cli.resolveCommand(command, this.kernel.commandArgs);
+				if (command.onKernelStart) await command.onKernelStart(...this.kernel.commandArgs);
+				if (command.isComplete() || command.kernelEvent === this.kernelEvent) {
+					await command.action(...this.kernel.commandArgs);
+					return this;
+				}
+			}
+		}
+		return await this.cli.runCommandAsync(response).then(() => {
+			return this;
+		});
+	}
+};
+//#endregion
+export { Menu as default };

package/dist/node/kernel/commands/OutdatedCommand.js

@@ -0,0 +1,164 @@
+import "../../cli/sysexits.js";
+import Command from "../../command/Command.js";
+import { aggregateOutdated, formatDependents, formatHeadline, toTableRows } from "../../cli/outdated.js";
+import { promisify } from "node:util";
+import path from "node:path";
+import { access } from "node:fs/promises";
+import { execFile } from "node:child_process";
+//#region src/kernel/commands/OutdatedCommand.ts
+const run = promisify(execFile);
+/**
+* `kernelEvent: "onRegister"` — la commande n'interroge ni le plan d'administration
+* ni les serveurs : elle n'a besoin que de la racine du projet, connue dès la
+* construction du kernel. Aucun port n'est ouvert (profil console par défaut).
+*/
+const optionsCommand = {
+	helpGroup: "GÉNÉRER ET CONSTRUIRE",
+	quietBoot: true,
+	showBanner: false,
+	kernelEvent: "onRegister"
+};
+/** Sortie maximale acceptée de `npm outdated --json` (un gros dépôt en rend beaucoup). */
+const MAX_BUFFER = 33554432;
+/** Largeur de la colonne des dépendants — au-delà, le texte est replié. */
+const DEPENDENTS_COLUMN_WIDTH = 44;
+/**
+* Liste les dépendances en retard du projet — une ligne par paquet, pas une par dépendant.
+*
+* Une seule interrogation de `npm` est faite, à la racine du projet : les espaces de
+* travail y sont déjà couverts. Interroger chaque module séparément, comme le faisait
+* la version précédente, réaffichait le MÊME tableau complet à chaque tour, puisqu'un
+* `npm` lancé dans un sous-dossier d'espace de travail remonte à la racine.
+*
+* @example
+* ```bash
+* nodefony outdated
+* nodefony outdated --all           # nomme tous les dépendants au lieu de les compter
+* nodefony outdated --json | jq '.packages[] | select(.severity == "major")'
+* ```
+*/
+var Outdated = class extends Command {
+	constructor(cli) {
+		super("outdated", "les dépendances en retard, groupées par paquet", cli, optionsCommand);
+		this.addOption("-j, --json", "sortie JSON (scriptable)");
+		this.addOption("-a, --all", "nomme tous les dépendants au lieu de n'en donner le compte");
+	}
+	async generate(opts = {}) {
+		const root = this.kernel?.path ?? process.cwd();
+		if (!await this.isNpmProject(root)) {
+			this.log(`aucun « package-lock.json » à la racine (${root}) — cette commande lit le format de npm`, "ERROR");
+			await this.terminate(69);
+			return this;
+		}
+		let report;
+		try {
+			report = await this.readNpmReport(root);
+		} catch (error) {
+			this.log(`interrogation de npm impossible : ${error.message}`, "ERROR");
+			await this.terminate(70);
+			return this;
+		}
+		const summary = aggregateOutdated(report);
+		if (opts.json) process.stdout.write(`${JSON.stringify(summary, null, 2)}\n`);
+		else this.renderHuman(summary, opts.all === true);
+		await this.terminate(0);
+		return this;
+	}
+	/**
+	* Vérifie que la racine porte bien un projet géré par npm.
+	*
+	* @param root - racine du projet.
+	* @returns `true` si un `package-lock.json` s'y trouve.
+	*/
+	async isNpmProject(root) {
+		try {
+			await access(path.join(root, "package-lock.json"));
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Interroge `npm outdated --json` UNE fois, à la racine.
+	*
+	* @param root - racine du projet, passée en répertoire courant du process fils.
+	* @returns le document rendu par npm (objet vide si rien n'est en retard).
+	* @throws Si npm est introuvable, ou si sa sortie n'est pas du JSON.
+	*/
+	async readNpmReport(root) {
+		let stdout = "";
+		try {
+			({stdout} = await run("npm", [
+				"outdated",
+				"--json",
+				"--long"
+			], {
+				cwd: root,
+				maxBuffer: MAX_BUFFER
+			}));
+		} catch (error) {
+			const failure = error;
+			if (typeof failure.stdout !== "string" || !failure.stdout.trim()) throw error;
+			stdout = failure.stdout;
+		}
+		const trimmed = stdout.trim();
+		return trimmed ? JSON.parse(trimmed) : {};
+	}
+	/**
+	* Affiche le résumé sous forme de tableaux.
+	*
+	* @param summary - le résumé agrégé.
+	* @param all - `true` pour nommer tous les dépendants.
+	*/
+	renderHuman(summary, all) {
+		const say = (line) => {
+			process.stdout.write(`${line}\n`);
+		};
+		const syslog = null;
+		say(formatHeadline(summary));
+		if (summary.packages.length) this.cli?.displayTable(toTableRows(summary, all), {
+			head: [
+				"Paquet",
+				"Saut",
+				"Actuel",
+				"Souhaité",
+				"Dernier",
+				"Dépendants"
+			],
+			colWidths: [
+				null,
+				null,
+				null,
+				null,
+				null,
+				DEPENDENTS_COLUMN_WIDTH
+			],
+			wordWrap: true
+		}, syslog);
+		if (summary.ahead.length) {
+			say(`\n${summary.ahead.length} paquet${summary.ahead.length > 1 ? "s" : ""} en AVANCE sur le registre — un espace de travail local non publié n'est pas un retard :`);
+			this.cli?.displayTable(summary.ahead.map((p) => [
+				p.name,
+				p.current ?? "—",
+				p.latest,
+				formatDependents(p.dependents, all)
+			]), {
+				head: [
+					"Paquet",
+					"Installé ici",
+					"Publié au registre",
+					"Dépendants"
+				],
+				colWidths: [
+					null,
+					null,
+					null,
+					DEPENDENTS_COLUMN_WIDTH
+				],
+				wordWrap: true
+			}, syslog);
+		}
+	}
+};
+//#endregion
+export { Outdated as default };

package/dist/node/kernel/commands/ProdCommand.js

@@ -0,0 +1,60 @@
+import Command from "../../command/Command.js";
+import { loadClusterConfig, resolveTopology } from "../../service/cluster/topology.js";
+import { launchTopology } from "./runtimeLauncher.js";
+import cluster from "node:cluster";
+//#region src/kernel/commands/ProdCommand.ts
+const options = {
+	helpGroup: "LANCER",
+	showBanner: true,
+	kernelEvent: "onPostReady"
+};
+/**
+* Commande `nodefony production` — runtime PROD cloud-native, **foreground**.
+*
+* Modèle « 2 molettes » (2026-05-24) : front prod (dist, pas de Vite) × topologie
+* pilotée par la molette `workers` ({@link resolveTopology} : `--workers` >
+* `NF_WORKERS` > config `cluster.workers` > défaut 1). `workers:1` = mono-process
+* (1 process = 1 pod, scaling délégué à l'orchestrateur) ; `>= 2` = cluster (master +
+* workers), via le flow partagé {@link launchTopology} (même runtime que `cluster`).
+*
+* **Un seul Kernel par process** : la commande suit la recette `development` (kernelEvent
+* `onPostReady` + profil serveur via `setRunProfile` dans `onKernelStart`) — l'unique Kernel du CLI
+* démarre lui-même les serveurs. Le double-boot historique (kernel CLI + kernel runtime)
+* est supprimé.
+*
+* **Foreground par défaut** — pensé pour k8s / systemd / Docker. Plus aucune
+* daemonisation : 1 process Node = 1 pod/container, lifecycle (restart/health/logs)
+* délégué à l'orchestrateur. (PM2 retiré du framework — cf project_pm2_deprecation.)
+*/
+var Prod = class extends Command {
+	constructor(cli) {
+		super("production", "démarre en production, au premier plan", cli, options);
+		this.alias("prod");
+		this.alias("start");
+		this.addOption("-w, --workers <number>", "Number of worker processes (default: config cluster.workers / NF_WORKERS / 1)");
+		this.addOption("--detach", "spawn détaché + attente readiness (ports) + exit 0/69");
+		this.addOption("--wait <sec>", "plafond d'attente readiness (défaut 120)");
+		this.addOption("--health <path>", "GET de santé post-boot (best-effort)");
+		this.addOption("--log <file>", "log du runtime détaché (défaut tmp/)");
+	}
+	async onKernelStart(opts) {
+		this.cli.environment = "production";
+		process.env.NF_MODE_START = "production";
+		const cfgWorkers = await loadClusterConfig();
+		const topo = resolveTopology({
+			flag: opts?.workers,
+			config: cfgWorkers ?? void 0
+		});
+		await launchTopology({
+			cli: this.cli,
+			topo,
+			log: (msg, severity) => this.log(msg, severity)
+		});
+	}
+	async generate() {
+		process.title = cluster.isWorker ? `nodefony worker ${cluster.worker?.id ?? "?"} [cluster]` : "nodefony server";
+		return this.cli?.kernel;
+	}
+};
+//#endregion
+export { Prod as default };

package/dist/node/kernel/commands/StatusCommand.js

@@ -0,0 +1,30 @@
+import Command from "../../command/Command.js";
+import { runStatusReport } from "../../service/dev/devStatusReport.js";
+//#region src/kernel/commands/StatusCommand.ts
+const options = {
+	helpGroup: "LANCER",
+	showBanner: false,
+	kernelEvent: "onStart"
+};
+/**
+* Commande `nodefony status` — photo instantanée des process de développement
+* (superviseur / serveur / Vite + PID, parent, uptime, RSS, %CPU, ports).
+*
+* **Exécutée en « standalone » (zéro boot, hors trunk possible).** L'enregistrement
+* ici sert au help (`nodefony --help`) ; l'exécution réelle est interceptée par le
+* fast-path de {@link CliKernel.start} AVANT tout boot kernel — pur outillage de
+* process ({@link runStatusReport} : `ps` + sonde ports), lançable de n'importe où.
+* Le `generate()` ci-dessous n'est qu'un FILET (si une trunk a booté jusqu'ici).
+*/
+var Status = class extends Command {
+	constructor(cli) {
+		super("status", "dit quels processus de ce projet tournent, et où", cli, options);
+	}
+	async generate() {
+		await runStatusReport(process.cwd());
+		await this.terminate(0);
+		return this;
+	}
+};
+//#endregion
+export { Status as default };

package/dist/node/kernel/commands/StopCommand.js

@@ -0,0 +1,35 @@
+import Command from "../../command/Command.js";
+import { runStopReport } from "../../service/dev/devStop.js";
+//#region src/kernel/commands/StopCommand.ts
+const options = {
+	helpGroup: "LANCER",
+	showBanner: false,
+	kernelEvent: "onStart"
+};
+/**
+* Commande `nodefony stop` — arrêt PROPRE et COMPLET des process de dev (superviseur +
+* serveur + Vite). Remplace le `pkill -9` manuel ; idempotent.
+*
+* **Exécutée en « standalone » (zéro boot, hors trunk possible)** : l'enregistrement
+* ici sert au help ; l'exécution réelle est interceptée par le fast-path de
+* {@link CliKernel.start} AVANT tout boot ({@link runStopReport} : ps + group-kill +
+* attente ports). Donc lançable de n'importe où — utile pour tuer des zombies. Le
+* `generate()` n'est qu'un FILET (si une trunk a booté jusqu'ici).
+*/
+var Stop = class extends Command {
+	constructor(cli) {
+		super("stop", "arrête les processus Nodefony de ce projet", cli, options);
+		this.addArgument("[project]", "projet à arrêter (nom ou chemin) — défaut : le projet du répertoire courant");
+		this.addOption("--all", "stop Nodefony runtimes of ALL projects on this machine (default: current project only)");
+	}
+	async generate(project) {
+		const code = await runStopReport(process.cwd(), {
+			all: process.argv.includes("--all"),
+			target: project
+		});
+		await this.terminate(code);
+		return this;
+	}
+};
+//#endregion
+export { Stop as default };

package/dist/node/kernel/commands/SymbolsCommand.js

@@ -0,0 +1,45 @@
+import Command from "../../command/Command.js";
+import { runSymbolsCommand } from "../../cli/symbols.js";
+//#region src/kernel/commands/SymbolsCommand.ts
+const options = {
+	helpGroup: "COMPRENDRE",
+	quietBoot: true,
+	showBanner: false,
+	kernelEvent: "onRegister"
+};
+/**
+* Commande `nodefony symbols` — le graphe symbolique du framework, en O(1).
+*
+* Répond à « qu'est-ce que ce symbole, où est-il défini, qui l'étend » sans
+* ouvrir un `.d.ts` ni parcourir des sources — et donc sans que l'agent ait à
+* deviner.
+*
+* **Exécutée en « standalone » (zéro boot)**, comme `check`, `env` et `card` :
+* l'enregistrement ici sert au help. Le graphe est un FICHIER ; le faire lire
+* par une application démarrée aurait rendu la commande muette exactement quand
+* l'application ne démarre plus, et coûté un boot pour une lecture de JSON.
+*
+* @example
+* ```bash
+* nodefony symbols AbstractCrudService      # définition + TSDoc + parenté
+* nodefony symbols --module @nodefony/http  # la surface exportée d'un paquet
+* nodefony symbols                          # d'où vient le graphe, ce qu'il couvre
+* ```
+*/
+var Symbols = class extends Command {
+	constructor(cli) {
+		super("symbols", "où un symbole est défini, et de qui il hérite", cli, options);
+		this.addOption("-j, --json", "sortie JSON (scriptable)");
+		this.addOption("--cwd <path>", "Point de départ (la racine de l'app est résolue en remontant)");
+		this.addOption("-m, --module <nom>", "n'afficher qu'un paquet");
+	}
+	async generate(opts) {
+		const argv = ["symbols"];
+		if (opts?.json) argv.push("--json");
+		if (opts?.module) argv.push("--module", opts.module);
+		await this.terminate(runSymbolsCommand(argv));
+		return this;
+	}
+};
+//#endregion
+export { Symbols as default };