@kekonic/diagrams-cli 1.0.0-rc.4

package/dist/cli.mjs

@@ -0,0 +1,1273 @@
+#!/usr/bin/env node
+import { t as runLanguageServer } from "./lsp-server-uxE48S7X.mjs";
+import { createRequire } from "node:module";
+import { createReadStream, existsSync, mkdirSync, readFileSync, statSync, watch, writeFileSync } from "node:fs";
+import { basename, dirname, extname, isAbsolute, join, parse, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { analyzeDiagramQuality, compileSource, getCapabilities, parseSource, registerTheme, renderPipeline } from "@kekonic/diagrams";
+import { KDiagramLanguageService } from "@kekonic/diagrams-language-service";
+import { globSync, isDynamicPattern } from "tinyglobby";
+import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+import { loadIconSubset } from "@kekonic/diagrams-icons";
+import { STUDIO_PROTOCOL_VERSION, createStudioPreviewCoordinator, parseStudioClientMessage, studioMessageJson } from "@kekonic/diagrams-studio";
+//#region src/command-model.ts
+var CliUsageError = class extends Error {
+	constructor(..._args) {
+		super(..._args);
+		this.exitCode = 2;
+	}
+};
+const COMMANDS$1 = /* @__PURE__ */ new Set([
+	"render",
+	"check",
+	"analyze",
+	"capabilities",
+	"ast",
+	"graph",
+	"format",
+	"studio",
+	"lsp",
+	"doctor",
+	"completions"
+]);
+const VALUE_OPTIONS = /* @__PURE__ */ new Map([
+	["-o", "output"],
+	["--output", "output"],
+	["--out-dir", "outDir"],
+	["--output-template", "outputTemplate"],
+	["--theme", "theme"],
+	["--exclude", "exclude"],
+	["--ignore-file", "ignoreFile"],
+	["--stdin-filename", "stdinFilename"],
+	["--files-from", "filesFrom"],
+	["--color", "color"],
+	["--config", "config"],
+	["--profile", "profile"],
+	["--theme-file", "themeFile"],
+	["--background", "background"],
+	["--port", "port"]
+]);
+const BOOLEAN_OPTIONS = /* @__PURE__ */ new Map([
+	["--snapshot", "snapshot"],
+	["--live-theme", "liveTheme"],
+	["--json", "json"],
+	["--pretty", "pretty"],
+	["--write", "write"],
+	["--check", "check"],
+	["--quiet", "quiet"],
+	["--verbose", "verbose"],
+	["--debug", "debug"],
+	["--embed-fonts", "embedFonts"],
+	["--print-safe", "printSafe"],
+	["--open", "open"],
+	["--no-open", "noOpen"],
+	["--allow-write", "allowWrite"],
+	["--stdio", "stdio"]
+]);
+const DISCOVERY = [
+	"exclude",
+	"ignoreFile",
+	"stdinFilename",
+	"filesFrom"
+];
+const PRESENTATION = [
+	"color",
+	"quiet",
+	"verbose",
+	"debug"
+];
+const ALLOWED_OPTIONS = {
+	render: /* @__PURE__ */ new Set([
+		"output",
+		"outDir",
+		"outputTemplate",
+		"theme",
+		"snapshot",
+		"liveTheme",
+		"config",
+		"profile",
+		"themeFile",
+		"background",
+		"embedFonts",
+		"printSafe",
+		...DISCOVERY,
+		...PRESENTATION
+	]),
+	check: /* @__PURE__ */ new Set([
+		"json",
+		...DISCOVERY,
+		...PRESENTATION
+	]),
+	analyze: /* @__PURE__ */ new Set([
+		"json",
+		"pretty",
+		...DISCOVERY,
+		...PRESENTATION
+	]),
+	capabilities: /* @__PURE__ */ new Set(["pretty"]),
+	ast: /* @__PURE__ */ new Set([
+		"pretty",
+		"json",
+		...DISCOVERY,
+		...PRESENTATION
+	]),
+	graph: /* @__PURE__ */ new Set([
+		"pretty",
+		"json",
+		...DISCOVERY,
+		...PRESENTATION
+	]),
+	format: /* @__PURE__ */ new Set([
+		"output",
+		"write",
+		"check",
+		...DISCOVERY,
+		...PRESENTATION
+	]),
+	studio: /* @__PURE__ */ new Set([
+		"open",
+		"noOpen",
+		"allowWrite",
+		"port",
+		...DISCOVERY,
+		...PRESENTATION
+	]),
+	lsp: /* @__PURE__ */ new Set(["stdio"]),
+	doctor: /* @__PURE__ */ new Set(["json", ...PRESENTATION]),
+	completions: /* @__PURE__ */ new Set([])
+};
+function defaults() {
+	return {
+		snapshot: false,
+		liveTheme: false,
+		color: "auto",
+		quiet: false,
+		verbose: false,
+		debug: false,
+		embedFonts: false,
+		printSafe: false,
+		open: false,
+		noOpen: false,
+		allowWrite: false,
+		stdio: false,
+		json: false,
+		pretty: false,
+		write: false,
+		check: false,
+		excludes: []
+	};
+}
+function optionParts(raw) {
+	if (!raw.startsWith("--")) return { flag: raw };
+	const equals = raw.indexOf("=");
+	return equals < 0 ? { flag: raw } : {
+		flag: raw.slice(0, equals),
+		inlineValue: raw.slice(equals + 1)
+	};
+}
+function parseCommand(argv) {
+	const name = argv[0];
+	if (!COMMANDS$1.has(name)) {
+		const suggestion = name ? nearest(name, [...COMMANDS$1]) : void 0;
+		throw new CliUsageError(name ? `Unknown command: ${name}${suggestion ? `. Did you mean ${suggestion}?` : ""}` : "Missing command");
+	}
+	const command = name;
+	const inputs = [];
+	const options = defaults();
+	let positionalOnly = false;
+	for (let index = 1; index < argv.length; index++) {
+		const raw = argv[index];
+		if (raw === "--" && !positionalOnly) {
+			positionalOnly = true;
+			continue;
+		}
+		if (raw === "-" || positionalOnly || !raw.startsWith("-")) {
+			inputs.push(raw);
+			continue;
+		}
+		const { flag, inlineValue } = optionParts(raw);
+		const valueKey = VALUE_OPTIONS.get(flag);
+		const booleanKey = BOOLEAN_OPTIONS.get(flag);
+		const allowed = ALLOWED_OPTIONS[command];
+		if (valueKey) {
+			if (!allowed.has(valueKey)) throw new CliUsageError(`Unknown option for ${command}: ${flag}`);
+			const value = inlineValue ?? argv[++index];
+			if (!value || inlineValue == null && value.startsWith("-") && value !== "-") throw new CliUsageError(`Missing value for ${flag}`);
+			if (valueKey === "exclude") options.excludes.push(value);
+			else if (valueKey === "color") {
+				if (value !== "auto" && value !== "always" && value !== "never") throw new CliUsageError(`Invalid --color value: ${value} (expected auto, always, or never)`);
+				options.color = value;
+			} else if (valueKey === "background") {
+				if (value !== "transparent" && value !== "theme") throw new CliUsageError(`Invalid --background value: ${value} (expected transparent or theme)`);
+				options.background = value;
+			} else if (valueKey === "theme") options.theme = value;
+			else options[valueKey] = value;
+			continue;
+		}
+		if (booleanKey) {
+			if (inlineValue != null) throw new CliUsageError(`${flag} does not accept a value`);
+			if (!allowed.has(booleanKey)) throw new CliUsageError(`Unknown option for ${command}: ${flag}`);
+			options[booleanKey] = true;
+			continue;
+		}
+		const suggestion = nearest(flag, [
+			...VALUE_OPTIONS.keys(),
+			...BOOLEAN_OPTIONS.keys(),
+			"--help",
+			"--version"
+		]);
+		throw new CliUsageError(`Unknown option: ${flag}${suggestion ? `. Did you mean ${suggestion}?` : ""}`);
+	}
+	validateOptions(command, options);
+	return {
+		name: command,
+		inputs,
+		options
+	};
+}
+function nearest(value, candidates) {
+	let best;
+	for (const candidate of candidates) {
+		const distance = editDistance(value, candidate);
+		if (!best || distance < best.distance) best = {
+			value: candidate,
+			distance
+		};
+	}
+	return best && best.distance <= Math.max(2, Math.floor(value.length / 3)) ? best.value : void 0;
+}
+function editDistance(left, right) {
+	const previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+	for (let i = 1; i <= left.length; i++) {
+		const current = [i];
+		for (let j = 1; j <= right.length; j++) current[j] = Math.min(current[j - 1] + 1, previous[j] + 1, previous[j - 1] + (left[i - 1] === right[j - 1] ? 0 : 1));
+		previous.splice(0, previous.length, ...current);
+	}
+	return previous[right.length];
+}
+function validateOptions(command, options) {
+	if (command === "render") {
+		const destinations = [
+			options.output,
+			options.outDir,
+			options.outputTemplate
+		].filter(Boolean);
+		if (options.output && destinations.length > 1) throw new CliUsageError("--output cannot be combined with --out-dir or --output-template");
+		if (options.snapshot && options.liveTheme) throw new CliUsageError("--snapshot and --live-theme cannot be combined");
+	}
+	if (command === "format") {
+		if (options.write && options.check) throw new CliUsageError("--write and --check cannot be combined");
+		if (options.output && (options.write || options.check)) throw new CliUsageError("--output cannot be combined with --write or --check");
+	}
+	if (command === "studio") {
+		if (options.open && options.noOpen) throw new CliUsageError("--open and --no-open cannot be combined");
+		if (options.port != null && (!/^\d+$/.test(options.port) || Number(options.port) > 65535)) throw new CliUsageError("--port must be an integer from 0 to 65535");
+	}
+	if (command === "lsp" && !options.stdio) throw new CliUsageError("lsp requires --stdio");
+	if (options.quiet && options.verbose) throw new CliUsageError("--quiet and --verbose cannot be combined");
+	if (command === "completions" && options.excludes.length > 0) throw new CliUsageError("completions does not accept discovery options");
+}
+//#endregion
+//#region src/completions.ts
+const COMMANDS = "render check analyze capabilities format studio lsp ast graph doctor completions";
+const OPTIONS = "--help --version --color --quiet --verbose --debug --exclude --ignore-file --stdin-filename --files-from --output --out-dir --output-template --theme --theme-file --config --profile --live-theme --snapshot --background --embed-fonts --print-safe --json --pretty --check --write --open --no-open --allow-write --port --stdio";
+function shellCompletions(shell) {
+	switch (shell) {
+		case "bash": return `# Kekonic Diagrams completion\n_kdiagrams() {\n  local cur="\${COMP_WORDS[COMP_CWORD]}"\n  COMPREPLY=( $(compgen -W "${COMMANDS} ${OPTIONS}" -- "$cur") )\n}\ncomplete -F _kdiagrams kdiagrams\n`;
+		case "zsh": return `#compdef kdiagrams\n_arguments '1:command:(${COMMANDS})' '*:option:(${OPTIONS})'\n`;
+		case "fish": return `${COMMANDS.split(" ").map((command) => `complete -c kdiagrams -f -n '__fish_use_subcommand' -a '${command}'`).join("\n")}\n`;
+		default: throw new CliUsageError("completions requires one shell: bash, zsh, or fish");
+	}
+}
+//#endregion
+//#region src/project-config.ts
+const DEFAULT_CONFIG = "kekonic-diagrams.config.json";
+function resolveRenderSettings(command, cwd = process.cwd()) {
+	const loaded = loadProjectConfig(command.options.config, cwd);
+	const config = loaded?.config;
+	const configDir = loaded ? dirname(loaded.path) : cwd;
+	for (const [name, tokens] of Object.entries(config?.themes ?? {})) {
+		validateTokens(tokens, `themes.${name}`);
+		registerTheme(name, tokens);
+	}
+	if (command.options.themeFile) {
+		const themePath = resolve(configDir, command.options.themeFile);
+		const parsed = readJson(themePath);
+		const name = command.options.theme ?? "custom";
+		const tokens = isRecord(parsed) && isRecord(parsed.tokens) ? parsed.tokens : parsed;
+		validateTokens(tokens, themePath);
+		registerTheme(name, tokens);
+	}
+	const profileName = command.options.profile ?? config?.defaultProfile;
+	const profile = profileName ? config?.profiles?.[profileName] : void 0;
+	if (profileName && !profile) throw new CliUsageError(`Unknown export profile: ${profileName}`);
+	if (profile?.format && profile.format !== "svg") throw new CliUsageError(`Export profile ${profileName} requests ${profile.format}; this CLI build supports SVG output`);
+	const printSafe = command.options.printSafe || profile?.printSafe === true;
+	const snapshotTheme = command.options.liveTheme ? false : command.options.snapshot || profile?.snapshotTheme !== false;
+	const settings = {
+		theme: command.options.theme ?? profile?.theme ?? (printSafe ? "light" : "dark"),
+		snapshotTheme,
+		background: command.options.background ?? profile?.background ?? (printSafe ? "theme" : "transparent"),
+		embedFonts: command.options.embedFonts || profile?.embedFonts === true,
+		printSafe,
+		presentation: profile?.presentation,
+		configPath: loaded?.path,
+		profileName,
+		warnings: []
+	};
+	if (!snapshotTheme) settings.warnings.push("live-theme SVG retains unresolved CSS custom properties and requires KDiagram theme tokens from its host");
+	return settings;
+}
+function findProjectConfig(cwd) {
+	let current = resolve(cwd);
+	const root = parse(current).root;
+	while (true) {
+		const candidate = join(current, DEFAULT_CONFIG);
+		if (existsSync(candidate)) return candidate;
+		if (current === root) return void 0;
+		current = dirname(current);
+	}
+}
+function loadProjectConfig(explicitPath, cwd) {
+	const path = explicitPath ? isAbsolute(explicitPath) ? explicitPath : resolve(cwd, explicitPath) : findProjectConfig(cwd);
+	if (!path) return void 0;
+	if (!existsSync(path)) throw new CliUsageError(`Config file does not exist: ${path}`);
+	const parsed = readJson(path);
+	if (!isRecord(parsed) || parsed.version !== 1) throw new CliUsageError(`${path}: expected { "version": 1, ... }`);
+	validateConfigKeys(parsed, path);
+	return {
+		path,
+		config: parsed
+	};
+}
+function validateConfigKeys(value, path) {
+	const allowed = /* @__PURE__ */ new Set([
+		"version",
+		"defaultProfile",
+		"themes",
+		"profiles",
+		"$schema"
+	]);
+	for (const key of Object.keys(value)) if (!allowed.has(key)) throw new CliUsageError(`${path}: unknown config property ${key}`);
+	if (value.profiles != null && !isRecord(value.profiles)) throw new CliUsageError(`${path}: profiles must be an object`);
+	for (const [name, profile] of Object.entries(value.profiles ?? {})) {
+		if (!isRecord(profile)) throw new CliUsageError(`${path}: profile ${name} must be an object`);
+		const profileKeys = /* @__PURE__ */ new Set([
+			"theme",
+			"snapshotTheme",
+			"background",
+			"embedFonts",
+			"printSafe",
+			"presentation",
+			"format"
+		]);
+		for (const key of Object.keys(profile)) if (!profileKeys.has(key)) throw new CliUsageError(`${path}: unknown profiles.${name}.${key}`);
+	}
+}
+function readJson(path) {
+	try {
+		return JSON.parse(readFileSync(path, "utf8"));
+	} catch (error) {
+		throw new CliUsageError(`${path}: ${error instanceof Error ? error.message : "could not read JSON"}`);
+	}
+}
+function validateTokens(value, label) {
+	if (!isRecord(value)) throw new CliUsageError(`${label}: theme tokens must be an object`);
+	for (const [key, token] of Object.entries(value)) {
+		if (!/^--[a-zA-Z0-9_-]+$/.test(key) || typeof token !== "string") throw new CliUsageError(`${label}: theme tokens must map --custom-properties to strings`);
+		if (/[;{}<>@]/.test(token) || /url\s*\(/i.test(token)) throw new CliUsageError(`${label}.${key}: theme token contains unsupported CSS syntax`);
+	}
+}
+function isRecord(value) {
+	return value != null && typeof value === "object" && !Array.isArray(value);
+}
+//#endregion
+//#region src/doctor.ts
+const require$2 = createRequire(import.meta.url);
+function runDoctor(cwd = process.cwd()) {
+	const nodeMajor = Number(process.versions.node.split(".")[0]);
+	const config = findProjectConfig(cwd);
+	let font = "unavailable";
+	try {
+		const path = require$2.resolve("@fontsource/inter/files/inter-latin-500-normal.woff");
+		if (existsSync(path)) font = path;
+	} catch {}
+	return [
+		{
+			name: "runtime",
+			status: nodeMajor >= 22 ? "pass" : "fail",
+			detail: `Node ${process.versions.node} (requires >=22.18.0)`
+		},
+		{
+			name: "font",
+			status: font === "unavailable" ? "fail" : "pass",
+			detail: font === "unavailable" ? "Bundled Inter measurement font not found" : "Bundled Inter font available"
+		},
+		{
+			name: "config",
+			status: config ? "pass" : "warn",
+			detail: config ?? "No kekonic-diagrams.config.json discovered; built-in export defaults apply"
+		},
+		{
+			name: "renderer",
+			status: "pass",
+			detail: "SVG renderer available; portable snapshot export is the default"
+		}
+	];
+}
+//#endregion
+//#region src/input-resolver.ts
+const SOURCE_EXTENSION = ".kdiagram";
+const DEFAULT_IGNORE_FILE = ".kdiagramignore";
+const CRAWL_IGNORES = ["**/.git/**", "**/node_modules/**"];
+const createIgnore = createRequire(import.meta.url)("ignore");
+function resolveCommandInputs(command, options = {}) {
+	const cwd = resolve(options.cwd ?? process.cwd());
+	const readStdin = options.readStdin ?? (() => readFileSync(0, "utf-8"));
+	const requested = [...command.inputs];
+	if (command.options.filesFrom) {
+		const listSource = command.options.filesFrom;
+		let pathList;
+		if (listSource === "-") {
+			if (requested.includes("-")) throw new CliUsageError("stdin cannot contain both diagram source and --files-from paths");
+			pathList = readStdin();
+		} else pathList = readFileSync(resolve(cwd, listSource), "utf-8");
+		requested.push(...parsePathList(pathList));
+	}
+	if (requested.length === 0) {
+		if (command.options.filesFrom) throw new CliUsageError("--files-from did not provide any input paths");
+		if (options.stdinIsTTY ?? process.stdin.isTTY) throw new CliUsageError("Missing input (pass a path, '-' or pipe diagram source on stdin)");
+		requested.push("-");
+	}
+	const files = [];
+	let stdinInput;
+	for (const input of requested) {
+		if (input === "-") {
+			if (stdinInput) throw new CliUsageError("stdin source may be supplied only once");
+			const filename = command.options.stdinFilename;
+			const absolutePath = filename ? resolve(cwd, filename) : void 0;
+			stdinInput = {
+				kind: "stdin",
+				absolutePath,
+				displayPath: filename ?? "<stdin>",
+				relativePath: filename ? portableRelativePath(cwd, absolutePath) : "stdin.kdiagram",
+				source: readStdin()
+			};
+			continue;
+		}
+		files.push(...expandInput(input, cwd));
+	}
+	const filtered = filterIgnoredFiles(files, cwd, command.options.ignoreFile, command.options.excludes);
+	const unique = /* @__PURE__ */ new Map();
+	for (const candidate of filtered) unique.set(resolve(candidate.absolutePath), candidate);
+	const resolvedFiles = [...unique.values()].sort((left, right) => comparePaths(left.absolutePath, right.absolutePath)).map(({ absolutePath, relativePath }) => ({
+		kind: "file",
+		absolutePath,
+		displayPath: absolutePath,
+		relativePath
+	}));
+	const result = stdinInput ? [...resolvedFiles, stdinInput] : resolvedFiles;
+	if (result.length === 0) throw new CliUsageError("No .kdiagram input files matched");
+	return result;
+}
+function readResolvedInput(input) {
+	if (input.kind === "stdin") return input.source ?? "";
+	return readFileSync(input.absolutePath, "utf-8");
+}
+function expandInput(input, cwd) {
+	const absolute = resolve(cwd, input);
+	if (existsSync(absolute)) {
+		const stats = statSync(absolute);
+		if (stats.isDirectory()) {
+			const matches = globSync("**/*.kdiagram", {
+				cwd: absolute,
+				absolute: true,
+				dot: true,
+				followSymbolicLinks: false,
+				ignore: CRAWL_IGNORES
+			});
+			const insideCwd = isWithin(cwd, absolute);
+			return matches.map((file) => ({
+				absolutePath: file,
+				relativePath: insideCwd ? portableRelativePath(cwd, file) : toPosix(relative(absolute, file))
+			}));
+		}
+		if (!stats.isFile()) throw new CliUsageError(`Input is not a file or directory: ${input}`);
+		if (extname(absolute).toLowerCase() !== SOURCE_EXTENSION) throw new CliUsageError(`Input file must end in ${SOURCE_EXTENSION}: ${input}`);
+		return [{
+			absolutePath: absolute,
+			relativePath: portableRelativePath(cwd, absolute)
+		}];
+	}
+	if (!isDynamicPattern(input)) throw new CliUsageError(`Input path does not exist: ${input}`);
+	return globSync(input, {
+		cwd,
+		absolute: true,
+		dot: true,
+		followSymbolicLinks: false,
+		onlyFiles: true,
+		ignore: CRAWL_IGNORES
+	}).filter((file) => extname(file).toLowerCase() === SOURCE_EXTENSION).map((file) => ({
+		absolutePath: file,
+		relativePath: portableRelativePath(cwd, file)
+	}));
+}
+function filterIgnoredFiles(files, cwd, ignoreFileOption, excludes) {
+	const ignoreFile = resolve(cwd, ignoreFileOption ?? DEFAULT_IGNORE_FILE);
+	const ignoreRoot = dirname(ignoreFile);
+	const ignoreMatcher = existsSync(ignoreFile) ? createIgnore().add(readFileSync(ignoreFile, "utf-8")) : void 0;
+	const excludeMatcher = excludes.length > 0 ? createIgnore().add(excludes) : void 0;
+	if (!ignoreMatcher && !excludeMatcher) return [...files];
+	return files.filter((candidate) => {
+		if (ignoreMatcher && isWithin(ignoreRoot, candidate.absolutePath)) {
+			const ignoredPath = toPosix(relative(ignoreRoot, candidate.absolutePath));
+			if (ignoreMatcher.ignores(ignoredPath)) return false;
+		}
+		return !excludeMatcher?.ignores(candidate.relativePath);
+	});
+}
+function isWithin(parent, child) {
+	const rel = relative(parent, child);
+	return !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+function parsePathList(contents) {
+	return contents.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+}
+function portableRelativePath(cwd, absolutePath) {
+	const rel = relative(cwd, absolutePath);
+	if (!rel || rel.startsWith(`..${sep}`) || isAbsolute(rel)) return basename(absolutePath);
+	return toPosix(rel);
+}
+function toPosix(path) {
+	return path.split(sep).join("/");
+}
+function comparePaths(left, right) {
+	const a = toPosix(left);
+	const b = toPosix(right);
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+function createOutputContext(options, stderr = process.stderr, env = process.env) {
+	return {
+		color: shouldUseColor(options.color, stderr.isTTY === true, env),
+		quiet: options.quiet,
+		verbose: options.verbose,
+		debug: options.debug,
+		stderr
+	};
+}
+function shouldUseColor(mode, isTTY, env) {
+	if (mode === "always") return true;
+	if (mode === "never") return false;
+	if (env.NO_COLOR != null || env.FORCE_COLOR === "0") return false;
+	if (env.FORCE_COLOR != null) return true;
+	return isTTY;
+}
+function printDiagnostic(context, diagnostic, source, path) {
+	const { start, end } = diagnostic.range;
+	const severity = colorizeSeverity(context, diagnostic.severity);
+	context.stderr.write(`${bold(context, `${path}:${start.line}:${start.column}`)} ${severity}[${diagnostic.code}] ${diagnostic.message}\n`);
+	const line = source.split(/\r?\n/)[start.line - 1] ?? "";
+	const lineNumber = String(start.line);
+	const gutter = " ".repeat(lineNumber.length);
+	const startColumn = Math.max(1, start.column);
+	const endColumn = end.line === start.line ? Math.max(startColumn + 1, end.column) : line.length + 1;
+	const markerLength = Math.max(1, Math.min(endColumn - startColumn, line.length - startColumn + 2));
+	context.stderr.write(`${dim(context, `${gutter} |`)}\n`);
+	context.stderr.write(`${dim(context, `${lineNumber} |`)} ${line}\n`);
+	context.stderr.write(`${dim(context, `${gutter} |`)} ${" ".repeat(startColumn - 1)}${severityColor(context, diagnostic.severity, "^".repeat(markerLength))}\n`);
+	if (diagnostic.hint) context.stderr.write(`${dim(context, `${gutter} =`)} ${cyan(context, "hint:")} ${diagnostic.hint}\n`);
+}
+function printSummary(context, message) {
+	if (!context.quiet) context.stderr.write(`${message}\n`);
+}
+function printProgress(context, message) {
+	if (!context.quiet && context.verbose) context.stderr.write(`${dim(context, message)}\n`);
+}
+function machineEnvelope(command, payload) {
+	return {
+		version: 1,
+		command,
+		payload
+	};
+}
+function installPipeErrorHandlers() {
+	for (const stream of [process.stdout, process.stderr]) stream.on("error", (error) => {
+		if (error.code === "EPIPE") process.exit(0);
+		throw error;
+	});
+}
+function printCode(code) {
+	return `\u001b[${code}m`;
+}
+function styled(context, code, text) {
+	return context.color ? `${printCode(code)}${text}${printCode(0)}` : text;
+}
+function bold(context, text) {
+	return styled(context, 1, text);
+}
+function dim(context, text) {
+	return styled(context, 2, text);
+}
+function cyan(context, text) {
+	return styled(context, 36, text);
+}
+function severityColor(context, severity, text) {
+	return styled(context, severity === "error" ? 31 : severity === "warning" ? 33 : 36, text);
+}
+function colorizeSeverity(context, severity) {
+	return severityColor(context, severity, severity);
+}
+//#endregion
+//#region src/output-paths.ts
+function renderOutputPaths(command, inputs, cwd = process.cwd()) {
+	const { output, outDir, outputTemplate } = command.options;
+	if (inputs.length > 1 && output) throw new CliUsageError("--output accepts only one resolved input");
+	if (inputs.length > 1 && !outDir && !outputTemplate) throw new CliUsageError("Multiple render inputs require --out-dir or --output-template; SVG documents are never concatenated");
+	const paths = inputs.map((input) => {
+		if (output) return resolve(cwd, output);
+		if (!outDir && !outputTemplate) return void 0;
+		const rendered = applyTemplate(outputTemplate ?? "{path}.svg", input.relativePath);
+		return outDir ? resolve(cwd, outDir, rendered) : resolve(cwd, rendered);
+	});
+	rejectCollisions(paths);
+	return paths;
+}
+function applyTemplate(template, relativeInput) {
+	const extension = extname(relativeInput);
+	const pathWithoutExtension = extension ? relativeInput.slice(0, relativeInput.length - extension.length) : relativeInput;
+	const directory = dirname(pathWithoutExtension) === "." ? "" : dirname(pathWithoutExtension);
+	const name = basename(pathWithoutExtension);
+	const rendered = template.replaceAll("{path}", pathWithoutExtension).replaceAll("{dir}", directory).replaceAll("{name}", name).replaceAll("{ext}", "svg");
+	if (!rendered || rendered.endsWith("/")) throw new CliUsageError(`Invalid --output-template result for ${relativeInput}: ${rendered}`);
+	return rendered;
+}
+function rejectCollisions(paths) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const path of paths) {
+		if (!path) continue;
+		if (seen.has(path)) throw new CliUsageError(`Multiple inputs resolve to the same output: ${path}`);
+		seen.add(path);
+	}
+}
+//#endregion
+//#region src/portable-svg.ts
+const require$1 = createRequire(import.meta.url);
+function finalizePortableSvg(svg, settings) {
+	let output = svg;
+	if (settings.embedFonts) output = embedInter(output);
+	if (settings.background === "theme") output = output.replace(/(<desc\b[^>]*>[^<]*<\/desc>)/, `$1\n<rect class="kdiagram-export-background" width="100%" height="100%" fill="var(--kd-bg)"/>`);
+	return output;
+}
+function embedInter(svg) {
+	const css = `@font-face{font-family:"Inter";src:url(data:font/woff;base64,${readFileSync(require$1.resolve("@fontsource/inter/files/inter-latin-500-normal.woff")).toString("base64")}) format("woff");font-style:normal;font-weight:100 900;font-display:block;}`;
+	const styleIndex = svg.indexOf("<style>");
+	if (styleIndex >= 0) return svg.slice(0, styleIndex + 7) + css + svg.slice(styleIndex + 7);
+	return svg.replace(/(<svg\b[^>]*>)/, `$1\n<style>${css}</style>`);
+}
+//#endregion
+//#region src/studio-server.ts
+const require = createRequire(import.meta.url);
+const ICON_NAME = /^[a-z0-9][a-z0-9-]*$/;
+const MAX_ICONS_PER_REQUEST = 64;
+async function startStudioServer(options) {
+	const files = [...new Set(options.files.map((file) => resolve(file)))].sort();
+	if (files.length === 0) throw new Error("Studio requires at least one .kdiagram file");
+	for (const file of files) if (!existsSync(file) || !statSync(file).isFile()) throw new Error(`Studio input is not a file: ${file}`);
+	const roots = minimalRoots(files.map(dirname));
+	const documents = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		const id = relative(commonRoot(files), file).split(sep).join("/") || basename(file);
+		documents.set(id, {
+			id,
+			path: file,
+			label: id,
+			revision: 0,
+			source: readFileSync(file, "utf8")
+		});
+	}
+	let activeDocumentId = documents.keys().next().value;
+	let presentation = {
+		theme: "dark",
+		options: { theme: "dark" }
+	};
+	const token = randomBytes(32).toString("base64url");
+	const sessionId = randomBytes(16).toString("hex");
+	const browserRoot = resolve(options.browserRoot ?? dirname(require.resolve("@kekonic/diagrams-studio/browser")));
+	const clients = /* @__PURE__ */ new Set();
+	const renders = /* @__PURE__ */ new Map();
+	const coordinator = createStudioPreviewCoordinator((source, renderOptions) => renderPipeline(source, {
+		...renderOptions,
+		snapshotTheme: true,
+		shadows: false
+	}));
+	const broadcast = (message) => {
+		const line = `data: ${studioMessageJson(message)}\n\n`;
+		for (const client of clients) client.write(line);
+	};
+	const renderDocument = async (document) => {
+		const result = await coordinator.render(document.id, document.revision, document.source, presentation.options);
+		if (result) {
+			renders.set(document.id, result);
+			broadcast({
+				version: STUDIO_PROTOCOL_VERSION,
+				type: "render",
+				...result
+			});
+		}
+	};
+	const server = createServer(async (request, response) => {
+		try {
+			const url = new URL(request.url ?? "/", "http://127.0.0.1");
+			const cookieToken = request.headers.cookie?.split(";").map((item) => item.trim()).find((item) => item.startsWith("kdiagram_studio="))?.slice(16);
+			if (url.searchParams.get("token") !== token && cookieToken !== token) return respond(response, 403, "Forbidden");
+			if (request.method === "GET" && url.pathname === "/events") {
+				response.writeHead(200, {
+					"Content-Type": "text/event-stream",
+					"Cache-Control": "no-cache, no-transform",
+					Connection: "keep-alive",
+					"X-Content-Type-Options": "nosniff"
+				});
+				clients.add(response);
+				response.write(`data: ${studioMessageJson({
+					version: 1,
+					type: "ready",
+					sessionId,
+					documents: [...documents.values()],
+					activeDocumentId,
+					capabilities: {
+						write: options.allowWrite === true,
+						export: true
+					},
+					presentation
+				})}\n\n`);
+				request.on("close", () => clients.delete(response));
+				renderDocument(documents.get(activeDocumentId));
+				return;
+			}
+			if (request.method === "POST" && url.pathname === "/message") {
+				const message = parseStudioClientMessage(JSON.parse(await readBody(request)));
+				const document = "documentId" in message ? documents.get(message.documentId) : void 0;
+				if ("documentId" in message && !document) return respond(response, 404, "Unknown document");
+				switch (message.type) {
+					case "open":
+						activeDocumentId = message.documentId;
+						broadcast({
+							version: 1,
+							type: "document",
+							reason: "open",
+							...document
+						});
+						renderDocument(document);
+						break;
+					case "source":
+						if (message.revision <= document.revision) return respond(response, 409, "Stale revision");
+						document.revision = message.revision;
+						document.source = message.source;
+						renderDocument(document);
+						break;
+					case "save":
+						if (!options.allowWrite) return respond(response, 403, "Studio writes are not authorized");
+						assertWithinRoots(document.path, roots);
+						if (message.revision < document.revision) return respond(response, 409, "Stale revision");
+						writeFileSync(document.path, message.source.endsWith("\n") ? message.source : `${message.source}\n`, "utf8");
+						document.source = readFileSync(document.path, "utf8");
+						document.revision = message.revision;
+						broadcast({
+							version: 1,
+							type: "saved",
+							documentId: document.id,
+							revision: document.revision
+						});
+						break;
+					case "selection":
+						if (message.selection.graphElement && !message.selection.range) {
+							const graph = renders.get(message.selection.documentId)?.graph;
+							const element = (message.selection.graphElement.type === "node" ? graph?.nodes : graph?.edges)?.find((item) => item.id === message.selection.graphElement?.id);
+							if (element?.sourceRange) message.selection.range = element.sourceRange;
+						}
+						broadcast({
+							version: 1,
+							type: "selection",
+							selection: message.selection
+						});
+						break;
+					case "viewport":
+						broadcast({
+							version: 1,
+							type: "viewport",
+							viewport: message.viewport
+						});
+						break;
+					case "presentation":
+						presentation = message.presentation;
+						broadcast({
+							version: 1,
+							type: "presentation",
+							presentation
+						});
+						renderDocument(documents.get(activeDocumentId));
+						break;
+				}
+				return respond(response, 204, "");
+			}
+			if (request.method === "GET" && url.pathname.startsWith("/__kdiagram/icons/")) return serveIconSubset(url, response);
+			if (request.method !== "GET") return respond(response, 405, "Method not allowed");
+			const requestedPath = url.pathname === "/" ? "index.html" : decodeURIComponent(url.pathname.slice(1));
+			const assetPath = resolve(browserRoot, requestedPath);
+			assertWithinRoots(assetPath, [browserRoot]);
+			if (!existsSync(assetPath) || !statSync(assetPath).isFile()) return respond(response, 404, "Not found");
+			response.writeHead(200, {
+				"Content-Type": contentType(assetPath),
+				"Cache-Control": requestedPath === "index.html" ? "no-store" : "public, max-age=31536000, immutable",
+				"Content-Security-Policy": "default-src 'self'; script-src 'self' 'wasm-unsafe-eval'; style-src 'self' 'unsafe-inline'; font-src 'self'; img-src 'self' data:; connect-src 'self'; object-src 'none'; base-uri 'none'; frame-ancestors 'none'",
+				"X-Content-Type-Options": "nosniff",
+				"Referrer-Policy": "no-referrer",
+				...requestedPath === "index.html" ? { "Set-Cookie": `kdiagram_studio=${token}; HttpOnly; SameSite=Strict; Path=/` } : {}
+			});
+			createReadStream(assetPath).pipe(response);
+		} catch (error) {
+			respond(response, 400, error instanceof Error ? error.message : String(error));
+		}
+	});
+	const watchers = files.map((file) => watch(file, { persistent: false }, () => {
+		const document = [...documents.values()].find((item) => item.path === file);
+		if (!document) return;
+		const source = readFileSync(file, "utf8");
+		if (source === document.source) return;
+		document.source = source;
+		document.revision += 1;
+		broadcast({
+			version: 1,
+			type: "document",
+			reason: "external",
+			...document
+		});
+		renderDocument(document);
+	}));
+	const heartbeat = setInterval(() => {
+		for (const client of clients) client.write(": heartbeat\n\n");
+	}, 15e3);
+	heartbeat.unref();
+	await new Promise((resolveListen, reject) => {
+		server.once("error", reject);
+		server.listen(options.port ?? 0, "127.0.0.1", resolveListen);
+	});
+	const address = server.address();
+	if (!address || typeof address === "string") throw new Error("Studio server did not bind a TCP port");
+	let resolveClosed;
+	const closed = new Promise((resolvePromise) => resolveClosed = resolvePromise);
+	server.once("close", resolveClosed);
+	const close = async () => {
+		clearInterval(heartbeat);
+		for (const watcher of watchers) watcher.close();
+		for (const client of clients) client.end();
+		await new Promise((resolveClose, reject) => server.close((error) => error ? reject(error) : resolveClose()));
+	};
+	return {
+		url: `http://127.0.0.1:${address.port}/?token=${encodeURIComponent(token)}`,
+		port: address.port,
+		token,
+		closed,
+		close
+	};
+}
+async function openStudioBrowser(url) {
+	const command = process.platform === "darwin" ? {
+		executable: "open",
+		args: [url]
+	} : process.platform === "win32" ? {
+		executable: "cmd",
+		args: [
+			"/c",
+			"start",
+			"",
+			url
+		]
+	} : {
+		executable: "xdg-open",
+		args: [url]
+	};
+	const child = spawn(command.executable, command.args, {
+		detached: true,
+		stdio: "ignore"
+	});
+	child.unref();
+	await new Promise((resolveSpawn, reject) => {
+		child.once("spawn", resolveSpawn);
+		child.once("error", reject);
+	});
+}
+function respond(response, status, body) {
+	response.writeHead(status, {
+		"Content-Type": "text/plain; charset=utf-8",
+		"X-Content-Type-Options": "nosniff"
+	});
+	response.end(body);
+}
+async function serveIconSubset(url, response) {
+	const match = /^\/__kdiagram\/icons\/([a-z0-9-]+)\.json$/.exec(url.pathname);
+	const names = parseIconNames(url.searchParams.get("icons"));
+	if (!match || !names) return respondJson(response, 400, { error: "Invalid icon request" });
+	const subset = await loadIconSubset(match[1], names);
+	if (!subset) return respondJson(response, 404, { error: "Unknown icon collection" });
+	return respondJson(response, 200, subset);
+}
+function parseIconNames(value) {
+	if (!value) return null;
+	const names = [...new Set(value.split(","))];
+	if (names.length === 0 || names.length > MAX_ICONS_PER_REQUEST || names.some((name) => !ICON_NAME.test(name))) return null;
+	return names;
+}
+function respondJson(response, status, body) {
+	response.writeHead(status, {
+		"Content-Type": "application/json; charset=utf-8",
+		"Cache-Control": "public, max-age=86400",
+		"X-Content-Type-Options": "nosniff"
+	});
+	response.end(JSON.stringify(body));
+}
+async function readBody(request) {
+	const chunks = [];
+	let bytes = 0;
+	for await (const chunk of request) {
+		const buffer = Buffer.from(chunk);
+		bytes += buffer.byteLength;
+		if (bytes > 2e6) throw new Error("Studio message exceeds 2 MB");
+		chunks.push(buffer);
+	}
+	return Buffer.concat(chunks).toString("utf8");
+}
+function assertWithinRoots(path, roots) {
+	const absolute = resolve(path);
+	if (!roots.some((root) => absolute === root || absolute.startsWith(`${resolve(root)}${sep}`))) throw new Error("Path is outside the studio session roots");
+}
+function minimalRoots(directories) {
+	const sorted = [...new Set(directories.map((directory) => resolve(directory)))].sort();
+	return sorted.filter((directory, index) => !sorted.some((other, otherIndex) => otherIndex !== index && directory.startsWith(`${other}${sep}`)));
+}
+function commonRoot(files) {
+	let root = dirname(files[0]);
+	while (!files.every((file) => file === root || file.startsWith(`${root}${sep}`))) root = dirname(root);
+	return root;
+}
+function contentType(path) {
+	switch (extname(path)) {
+		case ".html": return "text/html; charset=utf-8";
+		case ".js": return "text/javascript; charset=utf-8";
+		case ".css": return "text/css; charset=utf-8";
+		case ".ttf": return "font/ttf";
+		case ".map": return "application/json";
+		default: return "application/octet-stream";
+	}
+}
+//#endregion
+//#region src/cli.ts
+const argv = process.argv.slice(2);
+const languageService = new KDiagramLanguageService();
+let activeCommand;
+installPipeErrorHandlers();
+function usage(stream = process.stdout) {
+	stream.write(`kdiagrams — deterministic text-to-diagram tooling
+
+Common jobs:
+  kdiagrams check .
+  kdiagrams format diagrams/ --check
+  kdiagrams render diagrams/ --out-dir public/diagrams
+  kdiagrams render architecture.kdiagram -o architecture.svg --print-safe
+
+Commands:
+  render [inputs...]       Render portable SVG
+  check [inputs...]        Validate source and semantics
+  analyze [inputs...]      Analyze rendered layout quality as JSON
+  capabilities            Describe the active language and renderer as JSON
+  format [inputs...]       Format or check source
+  studio [inputs...]       Launch the local browser authoring studio
+  lsp --stdio              Run the Language Server Protocol over stdio
+  ast [input]              Emit a versioned AST envelope
+  graph [input]            Emit a versioned semantic-model envelope
+  doctor                   Inspect runtime, font, config, and renderer health
+  completions <shell>      Print Bash, Zsh, or Fish completion source
+
+Studio:
+  --no-open                Start without opening the browser (opens by default)
+  --allow-write            Authorize saving resolved input files
+  --port number            Loopback port (default: random available port)
+
+Input discovery:
+  --exclude pattern        Git-ignore-style exclusion (repeatable)
+  --ignore-file file       Rules file (default: .kdiagramignore)
+  --stdin-filename file    Logical filename for piped diagram source
+  --files-from file|-      Read additional input paths, one per line
+
+Portable render output:
+  -o, --output file        Single output file
+  --out-dir dir            Batch output directory; preserves relative paths
+  --output-template text   Template using {path}, {dir}, {name}, and {ext}
+  --theme name             Built-in or configured theme
+  --config file            Project config (default: discovered kekonic-diagrams.config.json)
+  --profile name           Named export profile from config
+  --theme-file file        JSON custom-property token map
+  --live-theme             Retain host-resolved CSS variables (snapshot is default)
+  --background mode        transparent or theme
+  --embed-fonts            Embed bundled Inter in SVG
+  --print-safe             Light snapshot with explicit theme background
+
+Human and machine output:
+  --json                   Versioned JSON envelope (check/doctor)
+  --pretty                 Pretty versioned JSON (ast/graph)
+  --color mode             auto, always, or never
+  --quiet                  Suppress summaries and progress
+  --verbose                Include progress details
+  --debug                  Include stack traces for operational failures
+  -v, --version            Print installed version
+  -h, --help               Show help
+
+Exit status: 0 success, 1 source/check failure, 2 usage error, 3 operational failure.
+`);
+}
+function version() {
+	const manifestPath = fileURLToPath(new URL("../package.json", import.meta.url));
+	return JSON.parse(readFileSync(manifestPath, "utf-8")).version ?? "unknown";
+}
+function printDiagnostics(context, diagnostics, source, path) {
+	for (const diagnostic of diagnostics) printDiagnostic(context, diagnostic, source, path);
+}
+async function cmdRender(command, inputs, context) {
+	const outputPaths = renderOutputPaths(command, inputs);
+	const settings = resolveRenderSettings(command);
+	for (const warning of settings.warnings) if (!context.quiet) context.stderr.write(`warning[FMCLI101] ${warning}\n`);
+	if (settings.configPath) printProgress(context, `Using config ${settings.configPath}`);
+	if (settings.profileName) printProgress(context, `Using export profile ${settings.profileName}`);
+	let failed = false;
+	for (let index = 0; index < inputs.length; index++) {
+		const input = inputs[index];
+		const source = readResolvedInput(input);
+		printProgress(context, `Rendering ${input.displayPath}`);
+		const result = await renderPipeline(source, {
+			theme: settings.theme,
+			snapshotTheme: settings.snapshotTheme,
+			presentation: settings.presentation,
+			shadows: false
+		});
+		printDiagnostics(context, result.diagnostics, source, input.displayPath);
+		if (!result.ok || !result.svg) {
+			failed = true;
+			continue;
+		}
+		const svg = finalizePortableSvg(result.svg, settings);
+		const outputPath = outputPaths[index];
+		if (!outputPath) {
+			process.stdout.write(svg);
+			continue;
+		}
+		mkdirSync(dirname(outputPath), { recursive: true });
+		writeFileSync(outputPath, svg, "utf-8");
+		printSummary(context, `Wrote ${outputPath}`);
+	}
+	return failed ? 1 : 0;
+}
+async function cmdAnalyze(command, inputs) {
+	const files = [];
+	let errorCount = 0;
+	let warningCount = 0;
+	for (const input of inputs) {
+		const result = await renderPipeline(readResolvedInput(input), { shadows: false });
+		const diagnostics = result.diagnostics;
+		errorCount += diagnostics.filter((item) => item.severity === "error").length;
+		warningCount += diagnostics.filter((item) => item.severity === "warning").length;
+		files.push({
+			path: input.displayPath,
+			diagnostics,
+			artifact: result.layout && result.graph && result.routing ? {
+				...analyzeDiagramQuality(result.graph, result.layout, result.routing.edges).metrics,
+				nodes: result.stats.nodeCount,
+				edges: result.stats.edgeCount,
+				layoutAlgorithm: result.stats.layoutAlgorithm,
+				routerAlgorithm: result.stats.routerAlgorithm
+			} : void 0
+		});
+	}
+	process.stdout.write(`${JSON.stringify(machineEnvelope("analyze", {
+		files,
+		summary: {
+			files: inputs.length,
+			errors: errorCount,
+			warnings: warningCount
+		}
+	}), null, command.options.pretty ? 2 : void 0)}\n`);
+	return errorCount > 0 ? 1 : 0;
+}
+function cmdCheck(command, inputs, context) {
+	const files = [];
+	let errorCount = 0;
+	let warningCount = 0;
+	for (const input of inputs) {
+		const source = readResolvedInput(input);
+		const diagnostics = languageService.updateDocument(inputUri(input), source, 1).diagnostics;
+		files.push({
+			path: input.displayPath,
+			diagnostics
+		});
+		errorCount += diagnostics.filter((diagnostic) => diagnostic.severity === "error").length;
+		warningCount += diagnostics.filter((diagnostic) => diagnostic.severity === "warning").length;
+		if (!command.options.json) printDiagnostics(context, diagnostics, source, input.displayPath);
+	}
+	if (command.options.json) process.stdout.write(`${JSON.stringify(machineEnvelope("check", {
+		files,
+		summary: {
+			files: inputs.length,
+			errors: errorCount,
+			warnings: warningCount
+		}
+	}))}\n`);
+	else printSummary(context, `${inputs.length} file(s): ${errorCount} error(s), ${warningCount} warning(s)`);
+	return errorCount > 0 ? 1 : 0;
+}
+function cmdInspect(command, inputs, context) {
+	requireSingleInput(command.name, inputs);
+	const input = inputs[0];
+	const source = readResolvedInput(input);
+	if (command.name === "ast") {
+		const result = parseSource(source);
+		printDiagnostics(context, result.diagnostics, source, input.displayPath);
+		writeInspectionEnvelope(command, input, result.ast, result.diagnostics);
+		return result.diagnostics.some((diagnostic) => diagnostic.severity === "error") ? 1 : 0;
+	}
+	const result = compileSource(source);
+	printDiagnostics(context, result.diagnostics, source, input.displayPath);
+	writeInspectionEnvelope(command, input, result.graph, result.diagnostics);
+	return result.diagnostics.some((diagnostic) => diagnostic.severity === "error") ? 1 : 0;
+}
+function writeInspectionEnvelope(command, input, data, diagnostics) {
+	process.stdout.write(`${JSON.stringify(machineEnvelope(command.name, {
+		path: input.displayPath,
+		data,
+		diagnostics
+	}), null, command.options.pretty ? 2 : void 0)}\n`);
+}
+function cmdFormat(command, inputs, context) {
+	if (command.options.output) requireSingleInput(command.name, inputs);
+	if (!command.options.write && !command.options.check && !command.options.output) requireSingleInput(command.name, inputs);
+	if (command.options.write && inputs.some((input) => input.kind === "stdin")) throw new CliUsageError("--write cannot be used with stdin");
+	let changed = false;
+	for (const input of inputs) {
+		const source = readResolvedInput(input);
+		const uri = inputUri(input);
+		languageService.updateDocument(uri, source, 1);
+		const formatted = languageService.format(uri)[0]?.newText ?? source;
+		if (command.options.check) {
+			if (source !== formatted) {
+				changed = true;
+				context.stderr.write(`${input.displayPath}: not formatted\n`);
+			}
+			continue;
+		}
+		const target = command.options.output ? resolve(command.options.output) : command.options.write ? input.absolutePath : void 0;
+		if (target) {
+			mkdirSync(dirname(target), { recursive: true });
+			writeFileSync(target, formatted, "utf-8");
+			printSummary(context, `Wrote ${target}`);
+		} else process.stdout.write(formatted);
+	}
+	return changed ? 1 : 0;
+}
+function cmdDoctor(command, context) {
+	const checks = runDoctor();
+	if (command.options.json) process.stdout.write(`${JSON.stringify(machineEnvelope("doctor", { checks }))}\n`);
+	else for (const check of checks) context.stderr.write(`${check.status.toUpperCase().padEnd(4)} ${check.name}: ${check.detail}\n`);
+	return checks.some((check) => check.status === "fail") ? 3 : 0;
+}
+function requireSingleInput(command, inputs) {
+	if (inputs.length !== 1) throw new CliUsageError(`${command} requires exactly one resolved input; received ${inputs.length}`);
+}
+async function main() {
+	if (argv.includes("-v") || argv.includes("--version")) {
+		process.stdout.write(`${version()}\n`);
+		return 0;
+	}
+	if (argv.includes("-h") || argv.includes("--help")) {
+		usage();
+		return 0;
+	}
+	if (argv.length === 0) {
+		usage(process.stderr);
+		return 2;
+	}
+	const command = parseCommand(argv);
+	activeCommand = command;
+	const context = createOutputContext(command.options);
+	if (command.name === "completions") {
+		if (command.inputs.length !== 1) throw new CliUsageError("completions requires one shell");
+		process.stdout.write(shellCompletions(command.inputs[0]));
+		return 0;
+	}
+	if (command.name === "doctor") {
+		if (command.inputs.length > 0) throw new CliUsageError("doctor does not accept inputs");
+		return cmdDoctor(command, context);
+	}
+	if (command.name === "capabilities") {
+		if (command.inputs.length > 0) throw new CliUsageError("capabilities does not accept inputs");
+		process.stdout.write(`${JSON.stringify(machineEnvelope("capabilities", getCapabilities()), null, command.options.pretty ? 2 : void 0)}\n`);
+		return 0;
+	}
+	if (command.name === "lsp") {
+		if (command.inputs.length !== 0) throw new CliUsageError("lsp does not accept inputs");
+		return runLanguageServer();
+	}
+	if (command.name === "studio") {
+		const studioInputs = resolveCommandInputs(command.inputs.length === 0 ? {
+			...command,
+			inputs: ["."]
+		} : command);
+		if (studioInputs.some((input) => input.kind === "stdin" || !input.absolutePath)) throw new CliUsageError("studio accepts files, directories, and globs, not stdin");
+		const server = await startStudioServer({
+			files: studioInputs.map((input) => input.absolutePath),
+			allowWrite: command.options.allowWrite,
+			port: Number(command.options.port ?? 0)
+		});
+		context.stderr.write(`Kekonic Diagrams Studio: ${server.url}\n`);
+		if (!command.options.noOpen) await openStudioBrowser(server.url);
+		await server.closed;
+		return 0;
+	}
+	const inputs = resolveCommandInputs(command);
+	switch (command.name) {
+		case "render": return cmdRender(command, inputs, context);
+		case "check": return cmdCheck(command, inputs, context);
+		case "analyze": return cmdAnalyze(command, inputs);
+		case "ast":
+		case "graph": return cmdInspect(command, inputs, context);
+		case "format": return cmdFormat(command, inputs, context);
+	}
+}
+main().then((exitCode) => {
+	process.exitCode = exitCode;
+}).catch((error) => {
+	if (error instanceof CliUsageError) {
+		process.stderr.write(`${error.message}\n`);
+		process.exitCode = 2;
+		return;
+	}
+	const message = operationalMessage(error);
+	process.stderr.write(`Operational error: ${message}\n`);
+	if (activeCommand?.options.debug && error instanceof Error && error.stack) process.stderr.write(`${error.stack}\n`);
+	process.exitCode = 3;
+});
+function operationalMessage(error) {
+	if (error instanceof Error) {
+		const code = error.code;
+		if (code === "ENOENT") return `File not found: ${error.path ?? error.message}`;
+		if (code === "EACCES") return `Permission denied: ${error.path ?? error.message}`;
+		return error.message;
+	}
+	return String(error);
+}
+function inputUri(input) {
+	return input.absolutePath ? `file://${input.absolutePath}` : `stdin://${input.displayPath}`;
+}
+//#endregion
+export {};
+
+//# sourceMappingURL=cli.mjs.map