glimmervoid 0.0.0-stage → 0.30.0

package/dist/chunks/visions-setup-CvVnOe1r.js

@@ -0,0 +1,1753 @@
+import { a as packageRoot, i as extensionDir, n as cliPath, o as relayPath, t as bundled } from "./runtime-paths-Ci_ksSkj.js";
+import { i as execSync, n as execFileAsync } from "./child-process-safe-DRGsp0TE.js";
+import { r as resolvePathCommandMatches } from "./spawn-command-Cc40FiZI.js";
+import { d as scrubText, n as SOURCE_DEFAULTS } from "./ingest-core-DWI1Mbu4.js";
+import { stripTypeScriptTypes } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import crypto from "node:crypto";
+var KIND = "file-change";
+var DEFAULT_BATCH_MS = SOURCE_DEFAULTS.fs.batchMs;
+var MAX_FILES_PER_BATCH = SOURCE_DEFAULTS.fs.digestQuota;
+var UNTRACKED_KEY_CHARS = 16;
+var MAX_ROOT_ENTRIES = 32;
+var MAX_SAMPLE_FILES = 5;
+var MAX_REL_PATH_CHARS = 200;
+var IGNORED_DIR_NAMES = Object.freeze([
+	".git",
+	"node_modules",
+	".glimmervoid",
+	".cache",
+	".parcel-cache",
+	".turbo",
+	".next",
+	".nuxt",
+	".svelte-kit",
+	".gradle",
+	".tox",
+	".venv",
+	".pytest_cache",
+	".mypy_cache",
+	".ruff_cache",
+	".idea",
+	"__pycache__",
+	"dist",
+	"build",
+	"target",
+	"coverage"
+]);
+var IGNORED_FILE_SUFFIXES = Object.freeze([
+	"~",
+	".swp",
+	".swx",
+	".swo",
+	".tmp",
+	".temp",
+	".lock"
+]);
+var IGNORED_FILE_NAMES = Object.freeze([
+	".DS_Store",
+	"Thumbs.db",
+	"desktop.ini",
+	"4913"
+]);
+var DAEMON_CONFIG_SIBLINGS = Object.freeze([
+	"usage-lanes.json",
+	"usage-warehouse.json",
+	"usage-budget-state.json",
+	"pr-review-state.json",
+	"team-review-state.json",
+	"pairings.json",
+	"pairings-seen.json",
+	"litellm-pricing.json",
+	"update-check.json",
+	"recordings",
+	"uploads",
+	"memory"
+]);
+var ACTIVE_SESSION_STATES = Object.freeze([
+	"INITIALIZING",
+	"STARTING",
+	"RUNNING",
+	"WAITING",
+	"IDLE",
+	"COMPLETE"
+]);
+var CHANGE_KINDS = Object.freeze([
+	"create",
+	"update",
+	"delete"
+]);
+var CHANGE_VERBS = Object.freeze({
+	create: "created",
+	update: "updated",
+	delete: "deleted"
+});
+function toPosix(value) {
+	return String(value == null ? "" : value).split("\\").join("/");
+}
+function nonEmptyString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function buildIgnorePatterns(extraDirNames = []) {
+	const names = [];
+	for (const raw of [...IGNORED_DIR_NAMES, ...Array.isArray(extraDirNames) ? extraDirNames : []]) {
+		const name = nonEmptyString(raw);
+		if (!name || names.includes(name)) continue;
+		names.push(name);
+	}
+	const patterns = [];
+	for (const name of names) patterns.push(name, `**/${name}`, `**/${name}/**`);
+	for (const suffix of IGNORED_FILE_SUFFIXES) patterns.push(`**/*${suffix}`);
+	for (const name of IGNORED_FILE_NAMES) patterns.push(`**/${name}`);
+	return patterns;
+}
+function hasIgnoredSegment(relPath) {
+	for (const segment of toPosix(relPath).split("/")) {
+		if (!segment) continue;
+		if (IGNORED_DIR_NAMES.includes(segment)) return true;
+	}
+	return false;
+}
+function isIgnoredFileName(base) {
+	if (IGNORED_FILE_NAMES.includes(base)) return true;
+	return IGNORED_FILE_SUFFIXES.some((suffix) => base.endsWith(suffix));
+}
+function daemonWriteRules(configPath) {
+	const resolvedPath = nonEmptyString(configPath);
+	if (!resolvedPath) return null;
+	const configFile = path.resolve(resolvedPath);
+	const dir = path.dirname(configFile);
+	return {
+		paths: [configFile, ...DAEMON_CONFIG_SIBLINGS.map((name) => path.join(dir, name))],
+		dir,
+		prefix: `${path.basename(configFile)}.`
+	};
+}
+function isDaemonDerivedSibling(rules, absolutePath) {
+	const resolved = path.resolve(absolutePath);
+	if (foldCase(path.dirname(resolved)) !== foldCase(rules.dir)) return false;
+	return foldCase(path.basename(resolved)).startsWith(foldCase(rules.prefix));
+}
+function foldCase(value) {
+	return process.platform === "win32" ? String(value).toLowerCase() : String(value);
+}
+function isPathInside(parent, child) {
+	const from = nonEmptyString(parent);
+	const to = nonEmptyString(child);
+	if (!from || !to) return false;
+	const resolvedParent = path.resolve(from);
+	const resolvedChild = path.resolve(to);
+	if (foldCase(resolvedParent) === foldCase(resolvedChild)) return true;
+	const relative = path.relative(resolvedParent, resolvedChild);
+	if (!relative || path.isAbsolute(relative)) return false;
+	return !toPosix(relative).startsWith("../");
+}
+function relativeWithin(root, absolutePath) {
+	const from = nonEmptyString(root);
+	const to = nonEmptyString(absolutePath);
+	if (!from || !to) return null;
+	const relative = path.relative(path.resolve(from), path.resolve(to));
+	if (!relative || path.isAbsolute(relative)) return null;
+	const posix = toPosix(relative);
+	if (posix.startsWith("../")) return null;
+	return posix;
+}
+function isIgnoredChange({ relPath, absolutePath = null, daemonRules = null } = {}) {
+	const relative = nonEmptyString(relPath);
+	if (!relative) return true;
+	if (hasIgnoredSegment(relative)) return true;
+	const base = toPosix(relative).split("/").pop();
+	if (base && isIgnoredFileName(base)) return true;
+	const absolute = nonEmptyString(absolutePath);
+	if (!absolute || !daemonRules) return false;
+	if (daemonRules.paths.some((daemonPath) => isPathInside(daemonPath, absolute))) return true;
+	return isDaemonDerivedSibling(daemonRules, absolute);
+}
+function normalizeRoots(raw) {
+	if (!Array.isArray(raw)) return [];
+	const roots = [];
+	for (const entry of raw) {
+		const value = nonEmptyString(entry);
+		if (!value || roots.includes(value)) continue;
+		roots.push(value);
+		if (roots.length >= MAX_ROOT_ENTRIES) break;
+	}
+	return roots;
+}
+function dedupeRoots(roots) {
+	const named = [];
+	for (const entry of Array.isArray(roots) ? roots : []) {
+		const value = nonEmptyString(entry);
+		if (!value) continue;
+		if (named.some((kept) => foldCase(path.resolve(kept)) === foldCase(path.resolve(value)))) continue;
+		named.push(value);
+	}
+	named.sort((left, right) => left.length - right.length || left.localeCompare(right));
+	const kept = [];
+	for (const root of named) {
+		if (kept.some((outer) => isPathInside(outer, root))) continue;
+		kept.push(root);
+	}
+	return kept;
+}
+function deriveSessionRoots(session) {
+	const dirs = [];
+	for (const dir of [session?.path, session?.worktreeDir]) {
+		const value = nonEmptyString(dir);
+		if (!value || dirs.includes(value)) continue;
+		dirs.push(value);
+	}
+	return dirs;
+}
+function isActiveSessionState(state) {
+	return ACTIVE_SESSION_STATES.includes(nonEmptyString(state) || "");
+}
+function createBatch() {
+	return {
+		files: /* @__PURE__ */ new Map(),
+		untracked: /* @__PURE__ */ new Set(),
+		floored: false
+	};
+}
+function untrackedKey(relPath) {
+	return crypto.createHash("sha1").update(relPath, "utf8").digest("hex").slice(0, UNTRACKED_KEY_CHARS);
+}
+function truncatePath(relPath) {
+	if (relPath.length <= MAX_REL_PATH_CHARS) return relPath;
+	const scrubbed = scrubText(relPath);
+	if (scrubbed.length <= MAX_REL_PATH_CHARS) return scrubbed;
+	return `${scrubbed.slice(0, MAX_REL_PATH_CHARS)}...`;
+}
+function normalizeChangeKind(type) {
+	const kind = nonEmptyString(type);
+	if (!kind || !CHANGE_KINDS.includes(kind)) return null;
+	return kind;
+}
+function mergeChange(previous, next) {
+	if (!previous) return next;
+	if (previous === "create" && next === "delete") return null;
+	if (next === "delete") return "delete";
+	if (previous === "create") return "create";
+	return "update";
+}
+function recordChange(batch, relPath, type) {
+	const kind = normalizeChangeKind(type);
+	const relative = nonEmptyString(relPath);
+	if (!kind || !relative) return false;
+	const key = truncatePath(relative);
+	if (batch.files.has(key)) {
+		const merged = mergeChange(batch.files.get(key), kind);
+		if (merged === null) batch.files.delete(key);
+		if (merged !== null) batch.files.set(key, merged);
+		return true;
+	}
+	if (batch.files.size >= 2e3) {
+		const digest = untrackedKey(key);
+		if (batch.untracked.has(digest)) return true;
+		if (batch.untracked.size >= 1e4) {
+			batch.floored = true;
+			return true;
+		}
+		batch.untracked.add(digest);
+		return true;
+	}
+	batch.files.set(key, kind);
+	return true;
+}
+function batchSize(batch) {
+	return batch.files.size + batch.untracked.size;
+}
+function fileChangeEvent({ root, relPath, change, now }) {
+	return {
+		source: "fs",
+		kind: KIND,
+		ts: now,
+		scope: {
+			root,
+			sessionId: null
+		},
+		summary: `${CHANGE_VERBS[change]} ${relPath}`,
+		detail: {
+			path: relPath,
+			change
+		}
+	};
+}
+function countByKind(batch) {
+	const counts = {
+		create: 0,
+		update: 0,
+		delete: 0
+	};
+	for (const change of batch.files.values()) counts[change] += 1;
+	return counts;
+}
+function burstSummary(batch) {
+	const counts = countByKind(batch);
+	const parts = [];
+	if (counts.create) parts.push(`${counts.create} created`);
+	if (counts.update) parts.push(`${counts.update} updated`);
+	if (counts.delete) parts.push(`${counts.delete} deleted`);
+	const total = batchSize(batch);
+	const tail = parts.length > 0 ? `: ${parts.join(", ")}` : "";
+	return {
+		summary: `${batch.floored ? `at least ${total}` : `${total}`} files changed${tail}`,
+		counts,
+		total
+	};
+}
+function sampleOf(batch) {
+	return [...batch.files.keys()].slice(0, MAX_SAMPLE_FILES).join(", ");
+}
+function decideFsEvents(batch, { root = null, now = 0 } = {}) {
+	const total = batchSize(batch);
+	if (total === 0) return [];
+	if (total <= MAX_FILES_PER_BATCH && batch.untracked.size === 0) {
+		const events = [];
+		for (const [relPath, change] of batch.files) events.push(fileChangeEvent({
+			root,
+			relPath,
+			change,
+			now
+		}));
+		return events;
+	}
+	const { summary, counts } = burstSummary(batch);
+	return [{
+		source: "fs",
+		kind: KIND,
+		ts: now,
+		scope: {
+			root,
+			sessionId: null
+		},
+		summary,
+		detail: {
+			files: total,
+			atLeast: batch.floored,
+			created: counts.create,
+			updated: counts.update,
+			deleted: counts.delete,
+			sample: sampleOf(batch)
+		}
+	}];
+}
+//#endregion
+//#region server/lane-log.ts
+var MAX_ONCE_KEYS = 256;
+function renderFieldValue(value) {
+	if (typeof value !== "string") return String(value);
+	if (value !== "" && !/[ ="\u0000-\u001f\u007f]/.test(value)) return value;
+	return JSON.stringify(value);
+}
+function renderLine(prefix, message, fields) {
+	const renderedFields = Object.entries(fields ?? {}).flatMap(([key, value]) => {
+		if (value === null || value === void 0) return [];
+		return `${key}=${renderFieldValue(value)}`;
+	});
+	if (renderedFields.length === 0) return `${prefix} ${message}`;
+	return `${prefix} ${message} ${renderedFields.join(" ")}`;
+}
+function createLaneLog({ prefix = "", logger = console, debugFlag = false } = {}) {
+	const onceKeys = /* @__PURE__ */ new Set();
+	function note(message, fields) {
+		if (!logger || typeof logger.log !== "function") return;
+		logger.log(renderLine(prefix, message, fields));
+	}
+	function warn(message, fields) {
+		if (!logger || typeof logger.warn !== "function") return;
+		logger.warn(renderLine(prefix, message, fields));
+	}
+	function warnOnce(key, message, fields) {
+		if (onceKeys.has(key)) return;
+		onceKeys.add(key);
+		const [oldestKey] = onceKeys;
+		if (onceKeys.size > MAX_ONCE_KEYS && oldestKey !== void 0) onceKeys.delete(oldestKey);
+		warn(message, fields);
+	}
+	function isDebug() {
+		if (typeof debugFlag !== "function") return debugFlag === true;
+		try {
+			return debugFlag() === true;
+		} catch {
+			return false;
+		}
+	}
+	function debugNote(buildMessage, buildFields) {
+		if (!isDebug()) return;
+		note(buildMessage(), buildFields?.());
+	}
+	return {
+		note,
+		warn,
+		warnOnce,
+		debugNote
+	};
+}
+//#endregion
+//#region server/core/editor-extension-core.ts
+var EDITOR_CANDIDATES = [
+	{
+		command: "codium",
+		label: "VSCodium",
+		macAppBundleName: "VSCodium"
+	},
+	{
+		command: "code",
+		label: "VS Code",
+		macAppBundleName: "Visual Studio Code"
+	},
+	{
+		command: "code-insiders",
+		label: "VS Code Insiders",
+		macAppBundleName: "Visual Studio Code - Insiders"
+	},
+	{
+		command: "cursor",
+		label: "Cursor",
+		macAppBundleName: "Cursor"
+	},
+	{
+		command: "windsurf",
+		label: "Windsurf",
+		macAppBundleName: "Windsurf"
+	}
+];
+var MACOS_BUNDLE_CLI_DIR = "Contents/Resources/app/bin";
+function editorBundleCandidatePaths(candidate, { platform, homeDir = null }) {
+	if (platform !== "darwin") return [];
+	const bundleName = candidate.macAppBundleName;
+	if (!bundleName) return [];
+	const applicationDirs = ["/Applications"];
+	if (homeDir) applicationDirs.push(path.posix.join(homeDir, "Applications"));
+	return applicationDirs.map((applicationDir) => path.posix.join(applicationDir, `${bundleName}.app`, MACOS_BUNDLE_CLI_DIR, candidate.command));
+}
+function editorLabelFor(command, platform) {
+	const byCommand = EDITOR_CANDIDATES.find((candidate) => candidate.command === command);
+	if (byCommand) return byCommand.label;
+	const basename = (platform === "win32" ? path.win32 : path.posix).basename(command);
+	return EDITOR_CANDIDATES.find((candidate) => candidate.command === basename)?.label || command;
+}
+function isAbsoluteEditorPath(requested, platform) {
+	return (platform === "win32" ? path.win32 : path.posix).isAbsolute(requested);
+}
+function resolveEditorPathsFor({ platform, homeDir = null, matchesOnPath, exists }) {
+	const resolved = {};
+	for (const candidate of EDITOR_CANDIDATES) {
+		const [firstOnPath] = matchesOnPath(candidate.command);
+		const commandPath = firstOnPath || editorBundleCandidatePaths(candidate, {
+			platform,
+			homeDir
+		}).find(exists);
+		if (!commandPath) continue;
+		resolved[candidate.command] = commandPath;
+	}
+	return resolved;
+}
+function decideEditorTargets({ requested = null, resolvedByCommand = {}, probe }) {
+	if (requested) {
+		const label = editorLabelFor(requested, probe.platform);
+		if (isAbsoluteEditorPath(requested, probe.platform)) {
+			if (!probe.exists(requested)) return {
+				targets: [],
+				reason: `editor path does not exist on disk: ${requested}`
+			};
+			return {
+				targets: [{
+					command: requested,
+					label,
+					commandPath: requested
+				}],
+				reason: "requested"
+			};
+		}
+		const commandPath = resolvedByCommand[requested];
+		if (!commandPath) return {
+			targets: [],
+			reason: `editor not found on PATH: ${requested}`
+		};
+		return {
+			targets: [{
+				command: requested,
+				label,
+				commandPath
+			}],
+			reason: "requested"
+		};
+	}
+	const targets = [];
+	for (const candidate of EDITOR_CANDIDATES) {
+		const commandPath = resolvedByCommand[candidate.command];
+		if (!commandPath) continue;
+		targets.push({
+			command: candidate.command,
+			label: candidate.label,
+			commandPath
+		});
+	}
+	if (targets.length === 0) return {
+		targets: [],
+		reason: "no VS Code family editor found on PATH or on disk"
+	};
+	return {
+		targets,
+		reason: "detected"
+	};
+}
+function relayStamp(relayPath) {
+	return `${JSON.stringify({ relayPath }, null, 2)}\n`;
+}
+function visionsExtensionFiles({ manifestJson, extensionJs, convertJs, lspCoreJs, relayPath }) {
+	return [
+		{
+			path: "package.json",
+			data: manifestJson
+		},
+		{
+			path: "extension.js",
+			data: extensionJs
+		},
+		{
+			path: "lsp-convert.js",
+			data: convertJs
+		},
+		{
+			path: "visions-lsp-core.js",
+			data: lspCoreJs
+		},
+		{
+			path: "relay-path.json",
+			data: relayStamp(relayPath)
+		}
+	];
+}
+function parseInstalledExtensions(stdout) {
+	return String(stdout || "").split(/\r?\n/).map((line) => line.trim()).filter((line) => line !== "");
+}
+function isExtensionInstalled(stdout, extensionId) {
+	const wanted = String(extensionId).toLowerCase();
+	return parseInstalledExtensions(stdout).some((line) => line.toLowerCase() === wanted);
+}
+//#endregion
+//#region server/core/editor-setup-core.ts
+function relayInvocation({ glimmervoidOnPath = true, cliPath = "", nodePath = "node" } = {}) {
+	if (glimmervoidOnPath) return {
+		command: "glimmervoid",
+		args: ["visions", "relay"]
+	};
+	return {
+		command: nodePath,
+		args: [
+			cliPath,
+			"visions",
+			"relay"
+		]
+	};
+}
+function invocationParts(invocation) {
+	return [invocation.command, ...invocation.args];
+}
+function commandLine(invocation) {
+	return invocationParts(invocation).join(" ");
+}
+function jsonCommandArray(invocation) {
+	return JSON.stringify(invocationParts(invocation));
+}
+function neovimSnippet(invocation) {
+	return [
+		"vim.api.nvim_create_autocmd('FileType', {",
+		"  pattern = 'markdown',",
+		"  callback = function()",
+		`    vim.lsp.start({ name = 'glimmervoid-visions', cmd = { ${invocationParts(invocation).map((part) => `'${part}'`).join(", ")} } })`,
+		"  end,",
+		"})"
+	].join("\n");
+}
+function helixSnippet(invocation) {
+	return [
+		"[language-server.glimmervoid-visions]",
+		`command = "${invocation.command}"`,
+		`args = ${JSON.stringify(invocation.args)}`,
+		"",
+		"[[language]]",
+		"name = \"markdown\"",
+		"language-servers = [\"marksman\", \"glimmervoid-visions\"]"
+	].join("\n");
+}
+function emacsSnippet(invocation) {
+	return [
+		"(with-eval-after-load 'eglot",
+		"  (add-to-list 'eglot-server-programs",
+		`               '(markdown-mode . (${invocationParts(invocation).map((part) => `"${part}"`).join(" ")}))))`
+	].join("\n");
+}
+function sublimeSnippet(invocation) {
+	return [
+		"{",
+		"  \"clients\": {",
+		"    \"glimmervoid-visions\": {",
+		"      \"enabled\": true,",
+		`      "command": ${jsonCommandArray(invocation)},`,
+		"      \"selector\": \"text.html.markdown\"",
+		"    }",
+		"  }",
+		"}"
+	].join("\n");
+}
+function kateSnippet(invocation) {
+	return [
+		"{",
+		"  \"servers\": {",
+		"    \"markdown\": {",
+		`      "command": ${jsonCommandArray(invocation)},`,
+		"      \"highlightingModeRegex\": \"^Markdown$\"",
+		"    }",
+		"  }",
+		"}"
+	].join("\n");
+}
+function genericSnippet(invocation) {
+	return `command: ${commandLine(invocation)}\ntransport: stdio\nlanguages: markdown`;
+}
+var EDITOR_RECIPES = [
+	{
+		id: "vscode",
+		label: "VS Code, VSCodium, Cursor, Windsurf",
+		where: "installed for you",
+		build: () => "glimmervoid visions install"
+	},
+	{
+		id: "neovim",
+		label: "Neovim",
+		where: "init.lua (or any file it loads)",
+		build: neovimSnippet
+	},
+	{
+		id: "helix",
+		label: "Helix",
+		where: "~/.config/helix/languages.toml",
+		build: helixSnippet
+	},
+	{
+		id: "emacs",
+		label: "Emacs (eglot)",
+		where: "init.el",
+		build: emacsSnippet
+	},
+	{
+		id: "sublime",
+		label: "Sublime Text (LSP package)",
+		where: "Preferences: LSP Settings",
+		build: sublimeSnippet
+	},
+	{
+		id: "kate",
+		label: "Kate",
+		where: "Settings > LSP Client > User Server Settings",
+		build: kateSnippet
+	},
+	{
+		id: "jetbrains",
+		label: "JetBrains IDEs (LSP4IJ plugin)",
+		where: "Settings > Language Servers > New > Command",
+		build: commandLine
+	},
+	{
+		id: "other",
+		label: "Any other LSP client",
+		where: "wherever it registers a language server",
+		build: genericSnippet
+	}
+];
+function recipeIds() {
+	return EDITOR_RECIPES.map((recipe) => recipe.id);
+}
+function buildSetupGuide({ editorId = null, invocation }) {
+	const recipes = editorId ? EDITOR_RECIPES.filter((recipe) => recipe.id === editorId) : EDITOR_RECIPES;
+	if (recipes.length === 0) return {
+		ok: false,
+		reason: `unknown editor: ${editorId}`,
+		sections: []
+	};
+	return {
+		ok: true,
+		reason: "ok",
+		sections: recipes.map((recipe) => ({
+			id: recipe.id,
+			label: recipe.label,
+			where: recipe.where,
+			snippet: recipe.build(invocation)
+		}))
+	};
+}
+//#endregion
+//#region server/core/visions-defaults-core.ts
+var IMPLIED_INGEST = Object.freeze({
+	enabled: true,
+	sources: Object.freeze({
+		fs: Object.freeze({ enabled: true }),
+		git: Object.freeze({ enabled: true }),
+		editor: Object.freeze({ enabled: true })
+	})
+});
+function isPlainObject(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function impliedIngestChanges(config) {
+	if (!isPlainObject(config.ingest)) return [{
+		path: ["ingest"],
+		value: JSON.parse(JSON.stringify(IMPLIED_INGEST)),
+		why: "visions needs machine context"
+	}];
+	const changes = [];
+	if (config.ingest.enabled !== true && config.ingest.enabled !== false) changes.push({
+		path: ["ingest", "enabled"],
+		value: true,
+		why: "visions needs machine context"
+	});
+	if (config.ingest.enabled === false) return changes;
+	const sources = isPlainObject(config.ingest.sources) ? config.ingest.sources : {};
+	for (const [name, value] of Object.entries(IMPLIED_INGEST.sources)) {
+		if (isPlainObject(sources[name])) continue;
+		changes.push({
+			path: [
+				"ingest",
+				"sources",
+				name
+			],
+			value: JSON.parse(JSON.stringify(value)),
+			why: `visions implies the ${name} source`
+		});
+	}
+	return changes;
+}
+function decideImpliedDefaults(config) {
+	if (!config) return { changes: [] };
+	const visions = config.visions;
+	if (!isPlainObject(visions) || visions.enabled !== true) return { changes: [] };
+	const changes = impliedIngestChanges(config);
+	if (!isPlainObject(visions.dispatch)) changes.push({
+		path: ["visions", "dispatch"],
+		value: { enabled: true },
+		why: "visions implies its model dispatch"
+	});
+	return { changes };
+}
+function applyChanges(config, changes) {
+	for (const change of changes) {
+		let cursor = config;
+		for (const key of change.path.slice(0, -1)) {
+			const existing = cursor[key];
+			if (isPlainObject(existing)) {
+				cursor = existing;
+				continue;
+			}
+			const created = {};
+			cursor[key] = created;
+			cursor = created;
+		}
+		cursor[change.path[change.path.length - 1]] = change.value;
+	}
+	return config;
+}
+//#endregion
+//#region server/core/vsix-core.ts
+var CRC_TABLE = buildCrcTable();
+var LOCAL_HEADER_SIG = 67324752;
+var CENTRAL_HEADER_SIG = 33639248;
+var END_OF_CENTRAL_SIG = 101010256;
+var STORED = 0;
+var ZIP_VERSION = 20;
+var UTF8_FLAG = 2048;
+var DOS_TIME = 0;
+var DOS_DATE = 33;
+function buildCrcTable() {
+	const table = /* @__PURE__ */ new Uint32Array(256);
+	for (let index = 0; index < 256; index += 1) {
+		let value = index;
+		for (let bit = 0; bit < 8; bit += 1) value = value & 1 ? 3988292384 ^ value >>> 1 : value >>> 1;
+		table[index] = value >>> 0;
+	}
+	return table;
+}
+function crc32(buffer) {
+	let crc = 4294967295;
+	for (let index = 0; index < buffer.length; index += 1) crc = CRC_TABLE[(crc ^ buffer[index]) & 255] ^ crc >>> 8;
+	return (crc ^ 4294967295) >>> 0;
+}
+function localHeader(entry, nameBytes) {
+	const header = Buffer.alloc(30);
+	header.writeUInt32LE(LOCAL_HEADER_SIG, 0);
+	header.writeUInt16LE(ZIP_VERSION, 4);
+	header.writeUInt16LE(UTF8_FLAG, 6);
+	header.writeUInt16LE(STORED, 8);
+	header.writeUInt16LE(DOS_TIME, 10);
+	header.writeUInt16LE(DOS_DATE, 12);
+	header.writeUInt32LE(entry.crc, 14);
+	header.writeUInt32LE(entry.size, 18);
+	header.writeUInt32LE(entry.size, 22);
+	header.writeUInt16LE(nameBytes.length, 26);
+	header.writeUInt16LE(0, 28);
+	return header;
+}
+function centralHeader(entry, nameBytes) {
+	const header = Buffer.alloc(46);
+	header.writeUInt32LE(CENTRAL_HEADER_SIG, 0);
+	header.writeUInt16LE(ZIP_VERSION, 4);
+	header.writeUInt16LE(ZIP_VERSION, 6);
+	header.writeUInt16LE(UTF8_FLAG, 8);
+	header.writeUInt16LE(STORED, 10);
+	header.writeUInt16LE(DOS_TIME, 12);
+	header.writeUInt16LE(DOS_DATE, 14);
+	header.writeUInt32LE(entry.crc, 16);
+	header.writeUInt32LE(entry.size, 20);
+	header.writeUInt32LE(entry.size, 24);
+	header.writeUInt16LE(nameBytes.length, 28);
+	header.writeUInt16LE(0, 30);
+	header.writeUInt16LE(0, 32);
+	header.writeUInt16LE(0, 34);
+	header.writeUInt16LE(0, 36);
+	header.writeUInt32LE(0, 38);
+	header.writeUInt32LE(entry.offset, 42);
+	return header;
+}
+function buildZip(files) {
+	const chunks = [];
+	const central = [];
+	let offset = 0;
+	for (const file of files) {
+		const nameBytes = Buffer.from(file.path, "utf8");
+		const data = Buffer.isBuffer(file.data) ? file.data : Buffer.from(String(file.data), "utf8");
+		const entry = {
+			crc: crc32(data),
+			size: data.length,
+			offset
+		};
+		const header = localHeader(entry, nameBytes);
+		chunks.push(header, nameBytes, data);
+		offset += header.length + nameBytes.length + data.length;
+		central.push({
+			entry,
+			nameBytes
+		});
+	}
+	const centralOffset = offset;
+	let centralSize = 0;
+	for (const { entry, nameBytes } of central) {
+		const header = centralHeader(entry, nameBytes);
+		chunks.push(header, nameBytes);
+		centralSize += header.length + nameBytes.length;
+	}
+	const end = Buffer.alloc(22);
+	end.writeUInt32LE(END_OF_CENTRAL_SIG, 0);
+	end.writeUInt16LE(0, 4);
+	end.writeUInt16LE(0, 6);
+	end.writeUInt16LE(central.length, 8);
+	end.writeUInt16LE(central.length, 10);
+	end.writeUInt32LE(centralSize, 12);
+	end.writeUInt32LE(centralOffset, 16);
+	end.writeUInt16LE(0, 20);
+	chunks.push(end);
+	return Buffer.concat(chunks);
+}
+function escapeXml(value) {
+	return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function contentTypesXml() {
+	return [
+		"<?xml version=\"1.0\" encoding=\"utf-8\"?>",
+		"<Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\">",
+		"<Default Extension=\"json\" ContentType=\"application/json\"/>",
+		"<Default Extension=\"js\" ContentType=\"application/javascript\"/>",
+		"<Default Extension=\"md\" ContentType=\"text/markdown\"/>",
+		"<Default Extension=\"vsixmanifest\" ContentType=\"text/xml\"/>",
+		"</Types>"
+	].join("");
+}
+function vsixManifestXml({ id, publisher, version, displayName, description, engine }) {
+	return [
+		"<?xml version=\"1.0\" encoding=\"utf-8\"?>",
+		"<PackageManifest Version=\"2.0.0\" xmlns=\"http://schemas.microsoft.com/developer/vsx-schema/2011\">",
+		"<Metadata>",
+		`<Identity Language="en-US" Id="${escapeXml(id)}" Version="${escapeXml(version)}" Publisher="${escapeXml(publisher)}"/>`,
+		`<DisplayName>${escapeXml(displayName)}</DisplayName>`,
+		`<Description xml:space="preserve">${escapeXml(description)}</Description>`,
+		"<Tags></Tags>",
+		"<Categories>Other</Categories>",
+		"<GalleryFlags>Public</GalleryFlags>",
+		"<Properties>",
+		`<Property Id="Microsoft.VisualStudio.Code.Engine" Value="${escapeXml(engine)}"/>`,
+		"<Property Id=\"Microsoft.VisualStudio.Code.ExtensionDependencies\" Value=\"\"/>",
+		"<Property Id=\"Microsoft.VisualStudio.Code.ExtensionPack\" Value=\"\"/>",
+		"<Property Id=\"Microsoft.VisualStudio.Code.ExtensionKind\" Value=\"workspace\"/>",
+		"</Properties>",
+		"</Metadata>",
+		"<Installation><InstallationTarget Id=\"Microsoft.VisualStudio.Code\"/></Installation>",
+		"<Dependencies/>",
+		"<Assets><Asset Type=\"Microsoft.VisualStudio.Code.Manifest\" Path=\"extension/package.json\" Addressable=\"true\"/></Assets>",
+		"</PackageManifest>"
+	].join("");
+}
+function buildVsix({ manifest, extensionFiles = [] }) {
+	const files = [{
+		path: "extension.vsixmanifest",
+		data: vsixManifestXml({
+			id: manifest.name,
+			publisher: manifest.publisher,
+			version: manifest.version,
+			displayName: manifest.displayName || manifest.name,
+			description: manifest.description || manifest.displayName || manifest.name,
+			engine: manifest.engines?.vscode || "*"
+		})
+	}, {
+		path: "[Content_Types].xml",
+		data: contentTypesXml()
+	}];
+	for (const file of extensionFiles) files.push({
+		path: `extension/${file.path}`,
+		data: file.data
+	});
+	return buildZip(files);
+}
+function extensionIdOf(manifest) {
+	return `${manifest.publisher}.${manifest.name}`;
+}
+//#endregion
+//#region server/core/editor-wire-core.ts
+var MARKER_NAME = "glimmervoid-visions";
+var SERVER_ID = "glimmervoid-visions";
+var HELIX_BEGIN = `# >>> ${MARKER_NAME}`;
+var HELIX_END = `# <<< ${MARKER_NAME}`;
+var EMACS_BEGIN = `;; >>> ${MARKER_NAME}`;
+var EMACS_END = `;; <<< ${MARKER_NAME}`;
+var UNCHANGED = "unchanged";
+function parts(invocation) {
+	return [invocation.command, ...invocation.args];
+}
+function splitMarked(text, begin, end) {
+	const startAt = text.indexOf(begin);
+	if (startAt === -1) return {
+		hasBlock: false,
+		before: text,
+		after: ""
+	};
+	const endAt = text.indexOf(end, startAt);
+	if (endAt === -1) return {
+		hasBlock: false,
+		unterminated: true,
+		before: text,
+		after: ""
+	};
+	return {
+		hasBlock: true,
+		before: text.slice(0, startAt),
+		after: text.slice(endAt + end.length)
+	};
+}
+function appendBlock(text, block) {
+	const body = text.trimEnd();
+	return `${body}${body === "" ? "" : "\n\n"}${block}\n`;
+}
+function replaceMarkedBlock(text, begin, end, block) {
+	const split = splitMarked(text, begin, end);
+	if (split.unterminated) return {
+		text,
+		changed: false,
+		reason: "unterminated-block"
+	};
+	if (!split.hasBlock) return {
+		text: appendBlock(text, block),
+		changed: true,
+		reason: "appended"
+	};
+	const merged = `${split.before}${block}${split.after}`;
+	if (merged === text) return {
+		text,
+		changed: false,
+		reason: UNCHANGED
+	};
+	return {
+		text: merged,
+		changed: true,
+		reason: "updated"
+	};
+}
+function neovimDropIn(invocation) {
+	return [
+		`-- Written by glimmervoid; edit glimmervoid's config, not this file. Delete it to unwire ${MARKER_NAME}.`,
+		"vim.api.nvim_create_autocmd('FileType', {",
+		"  pattern = 'markdown',",
+		`  callback = function()`,
+		`    vim.lsp.start({ name = '${SERVER_ID}', cmd = { ${parts(invocation).map((part) => `'${part}'`).join(", ")} } })`,
+		"  end,",
+		"})",
+		""
+	].join("\n");
+}
+function helixServerLines(invocation) {
+	return [
+		HELIX_BEGIN,
+		`[language-server.${SERVER_ID}]`,
+		`command = "${invocation.command}"`,
+		`args = ${JSON.stringify(invocation.args)}`
+	];
+}
+function helixServerBlock(invocation) {
+	return [...helixServerLines(invocation), HELIX_END].join("\n");
+}
+function helixFullBlock(invocation) {
+	return [
+		...helixServerLines(invocation),
+		"",
+		"[[language]]",
+		"name = \"markdown\"",
+		`language-servers = ["marksman", "${SERVER_ID}"]`,
+		HELIX_END
+	].join("\n");
+}
+function addToHelixMarkdown(text) {
+	const lines = text.split("\n");
+	let inMarkdown = false;
+	let sawMarkdownLanguage = false;
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index].trim();
+		if (line === "[[language]]") {
+			inMarkdown = false;
+			continue;
+		}
+		if (line.startsWith("[") && line !== "[[language]]") {
+			inMarkdown = false;
+			continue;
+		}
+		if (/^name\s*=\s*"markdown"\s*$/.test(line)) {
+			inMarkdown = true;
+			sawMarkdownLanguage = true;
+			continue;
+		}
+		if (!inMarkdown || !/^language-servers\s*=\s*\[/.test(line)) continue;
+		if (line.includes(`"glimmervoid-visions"`)) return {
+			lines,
+			sawMarkdownLanguage,
+			changed: false
+		};
+		const isEmptyArray = /\[\s*\]\s*$/.test(line);
+		lines[index] = isEmptyArray ? lines[index].replace(/\[\s*\]\s*$/, `["${SERVER_ID}"]`) : lines[index].replace(/\]\s*$/, `, "${SERVER_ID}"]`);
+		return {
+			lines,
+			sawMarkdownLanguage,
+			changed: true
+		};
+	}
+	return {
+		lines,
+		sawMarkdownLanguage,
+		changed: false
+	};
+}
+function helixMerge(existingText, invocation) {
+	const text = typeof existingText === "string" ? existingText : "";
+	const split = splitMarked(text, HELIX_BEGIN, HELIX_END);
+	if (split.unterminated) return {
+		text,
+		changed: false,
+		reason: "unterminated-block"
+	};
+	const beforeEdit = addToHelixMarkdown(split.before);
+	const afterEdit = addToHelixMarkdown(split.after);
+	const block = beforeEdit.sawMarkdownLanguage || afterEdit.sawMarkdownLanguage ? helixServerBlock(invocation) : helixFullBlock(invocation);
+	const before = beforeEdit.lines.join("\n");
+	const after = afterEdit.lines.join("\n");
+	if (split.hasBlock) {
+		const merged = `${before}${block}${after}`;
+		if (merged === text) return {
+			text,
+			changed: false,
+			reason: UNCHANGED
+		};
+		return {
+			text: merged,
+			changed: true,
+			reason: "updated"
+		};
+	}
+	const merged = appendBlock(`${before}${after}`, block);
+	if (merged === text) return {
+		text,
+		changed: false,
+		reason: UNCHANGED
+	};
+	return {
+		text: merged,
+		changed: true,
+		reason: "appended"
+	};
+}
+function removeFromHelixMarkdown(text) {
+	const lines = text.split("\n");
+	let changed = false;
+	for (let index = 0; index < lines.length; index += 1) {
+		if (!/^\s*language-servers\s*=\s*\[/.test(lines[index]) || !lines[index].includes(`"glimmervoid-visions"`)) continue;
+		lines[index] = lines[index].replace(new RegExp(`\\s*,\\s*"${SERVER_ID}"|"${SERVER_ID}"\\s*,\\s*|"${SERVER_ID}"`), "");
+		changed = true;
+	}
+	return {
+		text: lines.join("\n"),
+		changed
+	};
+}
+function helixRemove(existingText) {
+	const text = typeof existingText === "string" ? existingText : "";
+	const split = splitMarked(text, HELIX_BEGIN, HELIX_END);
+	if (split.unterminated) return {
+		text,
+		changed: false,
+		reason: "unterminated-block"
+	};
+	const cleaned = removeFromHelixMarkdown(split.hasBlock ? `${split.before.trimEnd()}\n${split.after.replace(/^\n+/, "")}` : text);
+	if (cleaned.text === text) return {
+		text,
+		changed: false,
+		reason: UNCHANGED
+	};
+	return {
+		text: cleaned.text,
+		changed: true,
+		reason: "removed"
+	};
+}
+function emacsRemove(existingText) {
+	const text = typeof existingText === "string" ? existingText : "";
+	const split = splitMarked(text, EMACS_BEGIN, EMACS_END);
+	if (split.unterminated) return {
+		text,
+		changed: false,
+		reason: "unterminated-block"
+	};
+	if (!split.hasBlock) return {
+		text,
+		changed: false,
+		reason: UNCHANGED
+	};
+	return {
+		text: `${split.before.trimEnd()}\n${split.after.replace(/^\n+/, "")}`,
+		changed: true,
+		reason: "removed"
+	};
+}
+function jsonSettingsRemove(existingText, { path: keyPath }) {
+	const parsed = parseJsonSettings(existingText);
+	if (!parsed.ok) return {
+		text: existingText,
+		changed: false,
+		reason: parsed.reason
+	};
+	let cursor = parsed.value;
+	for (const key of keyPath.slice(0, -1)) {
+		if (!cursor[key] || typeof cursor[key] !== "object") return {
+			text: existingText,
+			changed: false,
+			reason: UNCHANGED
+		};
+		cursor = cursor[key];
+	}
+	const lastKey = keyPath[keyPath.length - 1];
+	if (!(lastKey in cursor)) return {
+		text: existingText,
+		changed: false,
+		reason: UNCHANGED
+	};
+	delete cursor[lastKey];
+	return {
+		text: `${JSON.stringify(parsed.value, null, 2)}\n`,
+		changed: true,
+		reason: "removed"
+	};
+}
+function emacsMerge(existingText, invocation) {
+	return replaceMarkedBlock(typeof existingText === "string" ? existingText : "", EMACS_BEGIN, EMACS_END, [
+		EMACS_BEGIN,
+		";; Written by glimmervoid. Delete this block to unwire glimmervoid-visions.",
+		"(with-eval-after-load 'eglot",
+		"  (add-to-list 'eglot-server-programs",
+		`               '(markdown-mode . (${parts(invocation).map((part) => `"${part}"`).join(" ")}))))`,
+		EMACS_END
+	].join("\n"));
+}
+function parseJsonSettings(existingText) {
+	const text = typeof existingText === "string" ? existingText.trim() : "";
+	if (text === "") return {
+		ok: true,
+		value: {}
+	};
+	try {
+		const value = JSON.parse(text);
+		if (!value || typeof value !== "object" || Array.isArray(value)) return {
+			ok: false,
+			reason: "not-an-object"
+		};
+		return {
+			ok: true,
+			value
+		};
+	} catch {
+		return {
+			ok: false,
+			reason: "unparseable"
+		};
+	}
+}
+function jsonSettingsMerge(existingText, { path: keyPath, value }) {
+	const parsed = parseJsonSettings(existingText);
+	if (!parsed.ok) return {
+		text: existingText,
+		changed: false,
+		reason: parsed.reason
+	};
+	const settings = parsed.value;
+	let cursor = settings;
+	for (const key of keyPath.slice(0, -1)) {
+		if (!cursor[key] || typeof cursor[key] !== "object" || Array.isArray(cursor[key])) cursor[key] = {};
+		cursor = cursor[key];
+	}
+	const lastKey = keyPath[keyPath.length - 1];
+	if (JSON.stringify(cursor[lastKey]) === JSON.stringify(value)) return {
+		text: existingText,
+		changed: false,
+		reason: UNCHANGED
+	};
+	cursor[lastKey] = value;
+	return {
+		text: `${JSON.stringify(settings, null, 2)}\n`,
+		changed: true,
+		reason: "merged"
+	};
+}
+function sublimeSettings(invocation) {
+	return {
+		path: ["clients", SERVER_ID],
+		value: {
+			enabled: true,
+			command: parts(invocation),
+			selector: "text.html.markdown"
+		}
+	};
+}
+function kateSettings(invocation) {
+	return {
+		path: ["servers", "markdown"],
+		value: {
+			command: parts(invocation),
+			highlightingModeRegex: "^Markdown$"
+		}
+	};
+}
+//#endregion
+//#region server/editor-wire.ts
+function configHome(homeDir, env) {
+	if (env.XDG_CONFIG_HOME) return env.XDG_CONFIG_HOME;
+	return path.join(homeDir, ".config");
+}
+function sublimeUserDir(homeDir, platform, env) {
+	if (platform === "darwin") return path.join(homeDir, "Library", "Application Support", "Sublime Text", "Packages", "User");
+	if (platform === "win32") return path.join(env.APPDATA || path.join(homeDir, "AppData", "Roaming"), "Sublime Text", "Packages", "User");
+	return path.join(configHome(homeDir, env), "sublime-text", "Packages", "User");
+}
+function neovimConfigDir(homeDir, platform, env) {
+	if (platform === "win32") return path.join(env.LOCALAPPDATA || path.join(homeDir, "AppData", "Local"), "nvim");
+	return path.join(configHome(homeDir, env), "nvim");
+}
+function helixConfigDir(homeDir, platform, env) {
+	if (platform === "win32") return path.join(env.APPDATA || path.join(homeDir, "AppData", "Roaming"), "helix");
+	return path.join(configHome(homeDir, env), "helix");
+}
+function exists(filePath) {
+	try {
+		return fs.existsSync(filePath);
+	} catch {
+		return false;
+	}
+}
+function onPath(command, { platform, exec }) {
+	return resolvePathCommandMatches(command, {
+		platform,
+		exec
+	}).length > 0;
+}
+function editorTargets({ homeDir = os.homedir(), platform = process.platform, env = process.env, exec = execSync } = {}) {
+	const nvimDir = neovimConfigDir(homeDir, platform, env);
+	const helixDir = helixConfigDir(homeDir, platform, env);
+	const kateDir = path.join(configHome(homeDir, env), "kate", "lspclient");
+	const sublimeDir = sublimeUserDir(homeDir, platform, env);
+	const emacsInits = [path.join(homeDir, ".emacs.d", "init.el"), path.join(configHome(homeDir, env), "emacs", "init.el")];
+	const targets = [];
+	if (exists(nvimDir) || onPath("nvim", {
+		platform,
+		exec
+	})) targets.push({
+		id: "neovim",
+		label: "Neovim",
+		filePath: path.join(nvimDir, "plugin", "glimmervoid-visions.lua"),
+		owned: true,
+		create: true
+	});
+	if (exists(helixDir) || onPath("hx", {
+		platform,
+		exec
+	})) targets.push({
+		id: "helix",
+		label: "Helix",
+		filePath: path.join(helixDir, "languages.toml"),
+		merge: helixMerge,
+		unmerge: helixRemove,
+		create: true
+	});
+	if (exists(kateDir) || onPath("kate", {
+		platform,
+		exec
+	})) targets.push({
+		id: "kate",
+		label: "Kate",
+		filePath: path.join(kateDir, "settings.json"),
+		json: kateSettings,
+		create: true
+	});
+	if (exists(sublimeDir)) targets.push({
+		id: "sublime",
+		label: "Sublime Text",
+		filePath: path.join(sublimeDir, "LSP.sublime-settings"),
+		json: sublimeSettings,
+		create: true
+	});
+	const emacsInit = emacsInits.find((candidate) => exists(candidate));
+	if (emacsInit) targets.push({
+		id: "emacs",
+		label: "Emacs",
+		filePath: emacsInit,
+		merge: emacsMerge,
+		unmerge: emacsRemove,
+		create: false
+	});
+	return targets;
+}
+function readIfPresent(filePath) {
+	try {
+		return fs.readFileSync(filePath, "utf8");
+	} catch {
+		return null;
+	}
+}
+function backupOnce(filePath, existingText) {
+	const backupPath = `${filePath}.glimmervoid.bak`;
+	if (existingText === null || exists(backupPath)) return null;
+	fs.writeFileSync(backupPath, existingText);
+	return backupPath;
+}
+function planFor(target, existingText, invocation) {
+	if (target.owned) {
+		const text = neovimDropIn(invocation);
+		if (existingText === text) return {
+			text,
+			changed: false,
+			reason: "unchanged"
+		};
+		return {
+			text,
+			changed: true,
+			reason: existingText === null ? "created" : "updated"
+		};
+	}
+	if (target.merge) return target.merge(existingText, invocation);
+	return jsonSettingsMerge(existingText ?? "", target.json(invocation));
+}
+function unwirePlanFor(target, existingText) {
+	if (target.owned) return {
+		text: null,
+		changed: existingText !== null,
+		reason: existingText === null ? "unchanged" : "deleted"
+	};
+	if (target.unmerge) return target.unmerge(existingText);
+	return jsonSettingsRemove(existingText ?? "", target.json({
+		command: "",
+		args: []
+	}));
+}
+function applyPlan(target, existingText, plan, { dryRun }) {
+	if (!plan.changed) return {
+		...outcome(target),
+		action: plan.reason === "unchanged" ? "unchanged" : "skipped",
+		reason: plan.reason
+	};
+	if (dryRun) return {
+		...outcome(target),
+		action: "would-write",
+		reason: plan.reason
+	};
+	try {
+		if (plan.text === null) {
+			fs.rmSync(target.filePath, { force: true });
+			return {
+				...outcome(target),
+				action: "removed",
+				reason: plan.reason
+			};
+		}
+		fs.mkdirSync(path.dirname(target.filePath), { recursive: true });
+		backupOnce(target.filePath, existingText);
+		fs.writeFileSync(target.filePath, plan.text);
+	} catch (error) {
+		return {
+			...outcome(target),
+			action: "failed",
+			reason: error instanceof Error ? error.message : String(error)
+		};
+	}
+	return {
+		...outcome(target),
+		action: plan.text === null ? "removed" : "wrote",
+		reason: plan.reason
+	};
+}
+function unwireEditor(target, { dryRun = false } = {}) {
+	const existingText = readIfPresent(target.filePath);
+	if (existingText === null && !target.owned) return {
+		...outcome(target),
+		action: "skipped",
+		reason: "file-absent"
+	};
+	return applyPlan(target, existingText, unwirePlanFor(target, existingText), { dryRun });
+}
+function wireEditor(target, invocation, { dryRun = false } = {}) {
+	const existingText = readIfPresent(target.filePath);
+	if (existingText === null && !target.create) return {
+		...outcome(target),
+		action: "skipped",
+		reason: "file-absent"
+	};
+	return applyPlan(target, existingText, planFor(target, existingText, invocation), { dryRun });
+}
+function outcome(target) {
+	return {
+		id: target.id,
+		label: target.label,
+		filePath: target.filePath
+	};
+}
+function wireEditors({ invocation, dryRun = false, targets = null, ...detection }) {
+	return (targets || editorTargets(detection)).map((target) => wireEditor(target, invocation, { dryRun }));
+}
+function unwireEditors({ dryRun = false, targets = null, ...detection } = {}) {
+	return (targets || editorTargets(detection)).map((target) => unwireEditor(target, { dryRun }));
+}
+//#endregion
+//#region server/visions-setup.ts
+var EXTENSION_DIR = extensionDir;
+var RELAY_PATH = relayPath("visions-relay");
+var LSP_CORE_PATH = bundled ? path.join(EXTENSION_DIR, "visions-lsp-core.js") : path.join(packageRoot, "server", "core", "visions-lsp-core.ts");
+var CLI_PATH = cliPath;
+var EDITOR_TIMEOUT_MS = 6e4;
+function underTestRunner(env) {
+	return typeof env.NODE_TEST_CONTEXT === "string" && env.NODE_TEST_CONTEXT !== "";
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function commandFailureDetail(error) {
+	const failure = error ?? {};
+	return String(failure.stderr || failure.message || error).trim().split("\n").pop();
+}
+function packedSource(filePath) {
+	return stripTypeScriptTypes(fs.readFileSync(filePath, "utf8"), { mode: "strip" });
+}
+function packedLspCore(filePath) {
+	const stripped = packedSource(filePath);
+	const exportStatement = /^export \{([^}]*)\};/m;
+	if (!exportStatement.test(stripped)) throw new Error(`${filePath} has no single-line export block to rewrite for the extension host`);
+	return stripped.replace(exportStatement, "module.exports = {$1};");
+}
+function packedExtensionSources() {
+	if (bundled) return {
+		extensionJs: fs.readFileSync(path.join(EXTENSION_DIR, "extension.js"), "utf8"),
+		convertJs: fs.readFileSync(path.join(EXTENSION_DIR, "lsp-convert.js"), "utf8"),
+		lspCoreJs: fs.readFileSync(LSP_CORE_PATH, "utf8")
+	};
+	return {
+		extensionJs: packedSource(path.join(EXTENSION_DIR, "extension.ts")),
+		convertJs: packedSource(path.join(EXTENSION_DIR, "lsp-convert.ts")),
+		lspCoreJs: packedLspCore(LSP_CORE_PATH)
+	};
+}
+function packVsix() {
+	const manifestJson = fs.readFileSync(path.join(EXTENSION_DIR, "package.json"), "utf8");
+	const manifest = JSON.parse(manifestJson);
+	return {
+		manifest,
+		vsix: buildVsix({
+			manifest,
+			extensionFiles: visionsExtensionFiles({
+				manifestJson,
+				...packedExtensionSources(),
+				relayPath: RELAY_PATH
+			})
+		})
+	};
+}
+function missingInstallFiles() {
+	return [RELAY_PATH, LSP_CORE_PATH].filter((filePath) => !fs.existsSync(filePath));
+}
+function resolvedEditorPaths({ platform = process.platform, exec = execSync, homeDir = os.homedir(), exists = fs.existsSync } = {}) {
+	return resolveEditorPathsFor({
+		platform,
+		homeDir,
+		matchesOnPath: (command) => resolvePathCommandMatches(command, {
+			platform,
+			exec
+		}),
+		exists
+	});
+}
+function relayInvocationOptions({ platform = process.platform, exec = execSync } = {}) {
+	const onPath = resolvePathCommandMatches("glimmervoid", {
+		platform,
+		exec
+	}).length > 0;
+	return {
+		chosen: relayInvocation({
+			glimmervoidOnPath: onPath,
+			cliPath: CLI_PATH,
+			nodePath: process.execPath
+		}),
+		absolute: relayInvocation({
+			glimmervoidOnPath: false,
+			cliPath: CLI_PATH,
+			nodePath: process.execPath
+		}),
+		onPath
+	};
+}
+function resolveRelayInvocation(options = {}) {
+	return relayInvocationOptions(options).chosen;
+}
+async function editorExtensions(commandPath) {
+	try {
+		const { stdout } = await execFileAsync(commandPath, ["--list-extensions"], { timeout: EDITOR_TIMEOUT_MS });
+		return stdout;
+	} catch (error) {
+		return `${(error ?? {}).stdout || ""}`;
+	}
+}
+async function installInto(target, vsixPath, extensionId) {
+	try {
+		await execFileAsync(target.commandPath, [
+			"--install-extension",
+			vsixPath,
+			"--force"
+		], { timeout: EDITOR_TIMEOUT_MS });
+	} catch (error) {
+		return {
+			...target,
+			ok: false,
+			detail: commandFailureDetail(error)
+		};
+	}
+	if (!isExtensionInstalled(await editorExtensions(target.commandPath), extensionId)) return {
+		...target,
+		ok: false,
+		detail: "the editor reported no error but does not list the extension"
+	};
+	return {
+		...target,
+		ok: true,
+		detail: "installed"
+	};
+}
+async function uninstallFrom(target, extensionId) {
+	if (!isExtensionInstalled(await editorExtensions(target.commandPath), extensionId)) return {
+		...target,
+		ok: true,
+		detail: "not installed"
+	};
+	try {
+		await execFileAsync(target.commandPath, ["--uninstall-extension", extensionId], { timeout: EDITOR_TIMEOUT_MS });
+	} catch (error) {
+		return {
+			...target,
+			ok: false,
+			detail: commandFailureDetail(error)
+		};
+	}
+	return {
+		...target,
+		ok: true,
+		detail: "removed"
+	};
+}
+async function installExtensions({ requested = null, resolvedByCommand = null, platform = process.platform, exists = fs.existsSync } = {}) {
+	const { targets, reason } = decideEditorTargets({
+		requested,
+		resolvedByCommand: resolvedByCommand || resolvedEditorPaths({
+			platform,
+			exists
+		}),
+		probe: {
+			platform,
+			exists
+		}
+	});
+	if (targets.length === 0) return {
+		targets: [],
+		reason,
+		results: []
+	};
+	const { manifest, vsix } = packVsix();
+	const extensionId = extensionIdOf(manifest);
+	const vsixPath = path.join(os.tmpdir(), `${extensionId}-${manifest.version}.vsix`);
+	fs.writeFileSync(vsixPath, vsix);
+	const results = [];
+	for (const target of targets) results.push(await installInto(target, vsixPath, extensionId));
+	return {
+		targets,
+		reason,
+		results
+	};
+}
+async function uninstallExtensions({ resolvedByCommand = null, platform = process.platform, exists = fs.existsSync } = {}) {
+	const { targets } = decideEditorTargets({
+		resolvedByCommand: resolvedByCommand || resolvedEditorPaths({
+			platform,
+			exists
+		}),
+		probe: {
+			platform,
+			exists
+		}
+	});
+	const { manifest } = packVsix();
+	const extensionId = extensionIdOf(manifest);
+	const results = [];
+	for (const target of targets) results.push(await uninstallFrom(target, extensionId));
+	return {
+		targets,
+		results
+	};
+}
+async function wireEverything({ requested = null, dryRun = false } = {}) {
+	const missing = missingInstallFiles();
+	if (missing.length > 0) return {
+		ok: false,
+		reason: `missing from this install: ${missing.join(", ")}`,
+		extensions: {
+			targets: [],
+			reason: "not-run",
+			results: []
+		},
+		files: []
+	};
+	const invocation = resolveRelayInvocation();
+	return {
+		ok: true,
+		reason: "ok",
+		invocation,
+		extensions: await installExtensions({ requested }),
+		files: wireEditors({
+			invocation,
+			dryRun
+		})
+	};
+}
+async function unwireEverything() {
+	return {
+		extensions: await uninstallExtensions(),
+		files: unwireEditors()
+	};
+}
+function createVisionsSetup({ getConfig = () => ({}), configStore = null, logger = console, debug = false, env = process.env, onConfigChanged = null, wire = wireEverything, unwire = unwireEverything } = {}) {
+	const { note, warn } = createLaneLog({
+		prefix: "[visions-setup]",
+		logger,
+		debugFlag: debug
+	});
+	let appliedState = false;
+	let inFlight = null;
+	function isEnabled() {
+		return (getConfig()?.visions)?.enabled === true;
+	}
+	function reportFiles(files) {
+		for (const file of files) {
+			if (file.action === "unchanged" || file.action === "skipped") continue;
+			if (file.action === "failed") {
+				warn(`${file.label}: ${file.reason} (${file.filePath})`);
+				continue;
+			}
+			note(`${file.label}: ${file.action} ${file.filePath}`);
+		}
+	}
+	function reportConfigChanged() {
+		if (typeof onConfigChanged !== "function") return;
+		Promise.resolve().then(onConfigChanged).catch((error) => warn(`lane rebuild failed: ${errorMessage(error)}`));
+	}
+	function isEditorWiringRefused() {
+		return underTestRunner(env) && wire === wireEverything && unwire === unwireEverything;
+	}
+	function isConfigWriteRefused() {
+		if (!underTestRunner(env)) return false;
+		const configPath = configStore?.configPath;
+		if (typeof configPath !== "string" || !configPath) return false;
+		return isPathInside(os.homedir(), configPath) && !isPathInside(os.tmpdir(), configPath);
+	}
+	function writeImpliedDefaults() {
+		if (!configStore || isConfigWriteRefused()) return null;
+		if (decideImpliedDefaults(getConfig()).changes.length === 0) return null;
+		const written = [];
+		const saved = configStore.save((freshConfig) => {
+			const changes = decideImpliedDefaults(freshConfig).changes;
+			written.push(...changes);
+			applyChanges(freshConfig, changes);
+		});
+		if (!saved || written.length === 0) return null;
+		applyChanges(getConfig(), written);
+		for (const change of written) note(`config: ${change.path.join(".")} on (${change.why})`);
+		reportConfigChanged();
+		return saved;
+	}
+	async function apply(enabled) {
+		if (!enabled) {
+			if (isEditorWiringRefused()) return null;
+			const report = await unwire();
+			reportFiles(report.files);
+			for (const result of report.extensions.results) note(`${result.label}: extension ${result.detail}`);
+			return report;
+		}
+		writeImpliedDefaults();
+		if (isEditorWiringRefused()) return null;
+		const report = await wire({});
+		if (!report.ok) {
+			warn(report.reason);
+			return report;
+		}
+		reportFiles(report.files);
+		for (const result of report.extensions.results) {
+			if (result.ok) note(`${result.label}: extension ${result.detail}`);
+			if (!result.ok) warn(`${result.label}: extension install failed: ${result.detail}`);
+		}
+		return report;
+	}
+	async function maybeApply() {
+		const enabled = isEnabled();
+		if (appliedState === enabled) return null;
+		if (inFlight) return inFlight;
+		appliedState = enabled;
+		inFlight = apply(enabled).catch((error) => {
+			appliedState = null;
+			warn(`editor wiring failed: ${errorMessage(error)}`);
+			return null;
+		}).finally(() => {
+			inFlight = null;
+		});
+		return inFlight;
+	}
+	return { maybeApply };
+}
+//#endregion
+export { deriveSessionRoots as C, recordChange as D, normalizeRoots as E, relativeWithin as O, dedupeRoots as S, isIgnoredChange as T, DEFAULT_BATCH_MS as _, relayInvocationOptions as a, daemonWriteRules as b, unwireEverything as c, extensionIdOf as d, buildSetupGuide as f, createLaneLog as g, isExtensionInstalled as h, packVsix as i, wireEverything as l, recipeIds as m, createVisionsSetup as n, resolveRelayInvocation as o, commandLine as p, editorExtensions as r, resolvedEditorPaths as s, RELAY_PATH as t, editorTargets as u, buildIgnorePatterns as v, isActiveSessionState as w, decideFsEvents as x, createBatch as y };