@useinsider/eslint-config 1.13.0 → 1.14.0

package/dist/cli.cjs

@@ -0,0 +1,4538 @@
+#!/usr/bin/env node
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_chunk = require("./chunk-CKQMccvm.cjs");
+let globals = require("globals");
+globals = require_chunk.__toESM(globals, 1);
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let node_url = require("node:url");
+let node_crypto = require("node:crypto");
+let node_os = require("node:os");
+let typescript = require("typescript");
+typescript = require_chunk.__toESM(typescript, 1);
+//#region src/cli/detect.ts
+var flatConfigOrder = [
+	"eslint.config.mjs",
+	"eslint.config.js",
+	"eslint.config.cjs",
+	"eslint.config.ts",
+	"eslint.config.mts",
+	"eslint.config.cts"
+];
+var legacyConfigOrder = [
+	".eslintrc.cjs",
+	".eslintrc.js",
+	".eslintrc.mjs",
+	".eslintrc.json",
+	".eslintrc.yml",
+	".eslintrc.yaml",
+	".eslintrc"
+];
+function detectExistingEslintConfig(cwd) {
+	const flatHit = flatConfigOrder.map((name) => (0, node_path.join)(cwd, name)).find((candidate) => (0, node_fs.existsSync)(candidate));
+	if (flatHit) return {
+		path: flatHit,
+		kind: "flat"
+	};
+	const legacyHit = legacyConfigOrder.map((name) => (0, node_path.join)(cwd, name)).find((candidate) => (0, node_fs.existsSync)(candidate));
+	if (legacyHit) return {
+		path: legacyHit,
+		kind: "legacy"
+	};
+	const pkgPath = (0, node_path.join)(cwd, "package.json");
+	if (!(0, node_fs.existsSync)(pkgPath)) return null;
+	try {
+		const raw = (0, node_fs.readFileSync)(pkgPath, "utf8");
+		const parsed = JSON.parse(raw);
+		if (parsed.eslintConfig && typeof parsed.eslintConfig === "object") return {
+			path: pkgPath,
+			kind: "legacy"
+		};
+	} catch {
+		return null;
+	}
+	return null;
+}
+var stringTokenPattern = /"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/gu;
+var lineCommentPattern = /\/\/[^\n]*/gu;
+var blockCommentPattern = /\/\*[\s\S]*?\*\//gu;
+var placeholderPattern = /__JSONC_TOKEN_(\d+)__/gu;
+function stripJsonComments(source) {
+	const tokens = [];
+	return source.replace(stringTokenPattern, (match) => {
+		const index = tokens.length;
+		tokens.push(match);
+		return `__JSONC_TOKEN_${index}__`;
+	}).replace(blockCommentPattern, "").replace(lineCommentPattern, "").replace(placeholderPattern, (_match, indexValue) => tokens[Number(indexValue)]);
+}
+function stripTrailingCommas(source) {
+	return source.replace(/,(\s*[}\]])/g, "$1");
+}
+function readTsconfig(absPath) {
+	const stripped = stripTrailingCommas(stripJsonComments((0, node_fs.readFileSync)(absPath, "utf8")));
+	return JSON.parse(stripped);
+}
+function resolveTsconfigReferences(cwd) {
+	const rootPath = (0, node_path.join)(cwd, "tsconfig.json");
+	if (!(0, node_fs.existsSync)(rootPath)) return null;
+	const parsed = readTsconfig(rootPath);
+	const refs = parsed.references;
+	if (!refs || refs.length === 0) return null;
+	const hasFiles = Array.isArray(parsed.files) && parsed.files.length > 0;
+	const hasInclude = Array.isArray(parsed.include) && parsed.include.length > 0;
+	if (hasFiles || hasInclude) return null;
+	return {
+		rootPath,
+		refs: refs.map((ref) => ref.path)
+	};
+}
+//#endregion
+//#region src/cli/detectVueApiPattern.ts
+var SKIP_DIRS = new Set([
+	"node_modules",
+	".git",
+	".svn",
+	".hg",
+	"dist",
+	"build",
+	"out",
+	"coverage",
+	".next",
+	".nuxt",
+	".output",
+	".cache",
+	".turbo",
+	".parcel-cache",
+	".vite"
+]);
+var MAX_FILES = 5e3;
+var MATCH_THRESHOLD = .95;
+var MIN_SAMPLES_PER_BUCKET = 2;
+var SUFFIX_CANDIDATES = [
+	".options",
+	".classic",
+	".legacy",
+	".opts",
+	".setup",
+	".composition",
+	".modern"
+];
+var DIRECTORY_CANDIDATES = [
+	{
+		options: "options",
+		composition: "composition"
+	},
+	{
+		options: "Options",
+		composition: "Composition"
+	},
+	{
+		options: "options-api",
+		composition: "composition-api"
+	},
+	{
+		options: "classic",
+		composition: "modern"
+	},
+	{
+		options: "legacy",
+		composition: "next"
+	}
+];
+function safeReaddir(path) {
+	try {
+		return (0, node_fs.readdirSync)(path, {
+			withFileTypes: true,
+			encoding: "utf8"
+		});
+	} catch {
+		return [];
+	}
+}
+function walkDir(dir, skipDirs, limit, accumulator) {
+	if (accumulator.truncated || accumulator.files.length >= limit) return;
+	safeReaddir(dir).forEach((entry) => {
+		if (accumulator.files.length >= limit) {
+			accumulator.truncated = true;
+			return;
+		}
+		const full = (0, node_path.join)(dir, entry.name);
+		if (entry.isDirectory()) {
+			if (!skipDirs.has(entry.name)) walkDir(full, skipDirs, limit, accumulator);
+			return;
+		}
+		if (entry.isFile() && entry.name.endsWith(".vue")) accumulator.files.push(full);
+	});
+}
+function scanVueFiles(options) {
+	const limit = options.maxFiles ?? MAX_FILES;
+	const skipDirs = options.skipDirs ?? SKIP_DIRS;
+	const accumulator = {
+		files: [],
+		truncated: false
+	};
+	walkDir(options.cwd, skipDirs, limit, accumulator);
+	return {
+		files: accumulator.files,
+		truncated: accumulator.truncated
+	};
+}
+function classifyVueContent(content) {
+	const hasSetupScript = /<script[^>]*\bsetup\b/i.test(content);
+	const hasPlainScript = /<script(?:(?!\bsetup\b)[^>])*>/i.test(content);
+	if (hasSetupScript && hasPlainScript) return "mixed";
+	if (hasSetupScript) return "composition";
+	return "options";
+}
+function classifyVueFiles(absolutePaths, cwd) {
+	return absolutePaths.reduce((classifications, absolutePath) => {
+		let content;
+		try {
+			if ((0, node_fs.statSync)(absolutePath).size > 2e6) return classifications;
+			content = (0, node_fs.readFileSync)(absolutePath, "utf8");
+		} catch {
+			return classifications;
+		}
+		const api = classifyVueContent(content);
+		const relativePath = (0, node_path.relative)(cwd, absolutePath);
+		classifications.push({
+			relativePath: relativePath.split(node_path.sep).join("/"),
+			api: api === "mixed" ? "composition" : api
+		});
+		return classifications;
+	}, []);
+}
+function basenameOf(relativePath) {
+	const lastSlash = relativePath.lastIndexOf("/");
+	return lastSlash === -1 ? relativePath : relativePath.slice(lastSlash + 1);
+}
+function ratio(matched, total) {
+	return total === 0 ? 0 : matched / total;
+}
+function suffixIsViable(targetMatches, otherMatches, targetTotal, otherTotal) {
+	const targetRatio = ratio(targetMatches.length, targetTotal);
+	const otherRatio = ratio(otherMatches.length, otherTotal);
+	if (targetRatio < MATCH_THRESHOLD || otherRatio < MATCH_THRESHOLD) return false;
+	return targetMatches.length >= MIN_SAMPLES_PER_BUCKET && otherMatches.length >= MIN_SAMPLES_PER_BUCKET;
+}
+function suffixMatchesTargetingApi(suffix, targetApi, optionsFiles, compositionFiles) {
+	const fullSuffix = `${suffix}.vue`;
+	const targetIsOptions = targetApi === "options";
+	const targetFiles = targetIsOptions ? optionsFiles : compositionFiles;
+	const otherFiles = targetIsOptions ? compositionFiles : optionsFiles;
+	const targetMatches = targetFiles.filter((path) => basenameOf(path).endsWith(fullSuffix));
+	const otherMatches = otherFiles.filter((path) => !basenameOf(path).endsWith(fullSuffix));
+	if (!suffixIsViable(targetMatches, otherMatches, targetFiles.length, otherFiles.length)) return null;
+	const optionsMatches = targetIsOptions ? targetMatches : otherMatches;
+	const compositionMatches = targetIsOptions ? otherMatches : targetMatches;
+	const optionsPattern = targetIsOptions ? `**/*${fullSuffix}` : "**/*.vue";
+	return {
+		kind: "suffix",
+		compositionPattern: targetIsOptions ? "**/*.vue" : `**/*${fullSuffix}`,
+		optionsPattern,
+		suffix: fullSuffix,
+		targetApi,
+		samples: {
+			composition: compositionMatches.slice(0, 5),
+			options: optionsMatches.slice(0, 5)
+		}
+	};
+}
+function suffixMatches(suffix, optionsFiles, compositionFiles) {
+	return suffixMatchesTargetingApi(suffix, "options", optionsFiles, compositionFiles) ?? suffixMatchesTargetingApi(suffix, "composition", optionsFiles, compositionFiles);
+}
+function detectSuffix(optionsFiles, compositionFiles) {
+	return SUFFIX_CANDIDATES.reduce((found, suffix) => {
+		if (found) return found;
+		return suffixMatches(suffix, optionsFiles, compositionFiles);
+	}, null);
+}
+function directoryMatches(options, composition, optionsFiles, compositionFiles) {
+	const optionsToken = `/${options}/`;
+	const optionsPrefix = `${options}/`;
+	const inOptionsDir = (path) => path.includes(optionsToken) || path.startsWith(optionsPrefix);
+	const optionsMatches = optionsFiles.filter(inOptionsDir);
+	const compositionMatches = compositionFiles.filter((path) => !inOptionsDir(path));
+	const optionsRatio = ratio(optionsMatches.length, optionsFiles.length);
+	const compositionRatio = ratio(compositionMatches.length, compositionFiles.length);
+	if (optionsRatio < MATCH_THRESHOLD || compositionRatio < MATCH_THRESHOLD) return null;
+	if (optionsMatches.length < MIN_SAMPLES_PER_BUCKET || compositionMatches.length < MIN_SAMPLES_PER_BUCKET) return null;
+	return {
+		kind: "directory",
+		compositionPattern: `**/${composition}/**/*.vue`,
+		optionsPattern: `**/${options}/**/*.vue`,
+		compositionDir: composition,
+		optionsDir: options,
+		samples: {
+			composition: compositionMatches.slice(0, 5),
+			options: optionsMatches.slice(0, 5)
+		}
+	};
+}
+function detectDirectory(optionsFiles, compositionFiles) {
+	return DIRECTORY_CANDIDATES.reduce((found, candidate) => {
+		if (found) return found;
+		return directoryMatches(candidate.options, candidate.composition, optionsFiles, compositionFiles);
+	}, null);
+}
+function detectVueApiPattern(input) {
+	const classifications = input.classifications ?? classifyVueFiles(scanVueFiles(input).files, input.cwd);
+	if (classifications.length === 0) return {
+		kind: "none",
+		compositionFiles: [],
+		optionsFiles: []
+	};
+	const optionsFiles = classifications.filter((item) => item.api === "options").map((item) => item.relativePath);
+	const compositionFiles = classifications.filter((item) => item.api === "composition").map((item) => item.relativePath);
+	if (optionsFiles.length === 0 || compositionFiles.length === 0) return {
+		kind: "none",
+		compositionFiles,
+		optionsFiles
+	};
+	const suffixHit = detectSuffix(optionsFiles, compositionFiles);
+	if (suffixHit) return suffixHit;
+	const directoryHit = detectDirectory(optionsFiles, compositionFiles);
+	if (directoryHit) return directoryHit;
+	return {
+		kind: "ambiguous",
+		reason: "Options and Composition files do not share a consistent suffix or directory split.",
+		compositionFiles: compositionFiles.slice(0, 5),
+		optionsFiles: optionsFiles.slice(0, 5)
+	};
+}
+//#endregion
+//#region src/cli/dispatch.ts
+var yesFlags = new Set(["--yes", "-y"]);
+var noInstallFlags = new Set(["--no-install"]);
+function isYesFlag(arg) {
+	return yesFlags.has(arg);
+}
+function isNoInstallFlag(arg) {
+	return noInstallFlags.has(arg);
+}
+function parseMigrateArgs(rest) {
+	const yes = rest.some(isYesFlag);
+	const noInstall = rest.some(isNoInstallFlag);
+	const positional = rest.filter((arg) => !isYesFlag(arg) && !isNoInstallFlag(arg));
+	return {
+		target: positional.length > 0 ? positional[positional.length - 1] : void 0,
+		yes,
+		noInstall
+	};
+}
+function parseScaffoldArgs(argv) {
+	return { yes: argv.some(isYesFlag) };
+}
+function printUsage(stderr, unknown) {
+	stderr(`[useinsider/eslint-config] Unknown subcommand: ${unknown}`);
+	stderr("Usage:");
+	stderr("  npx @useinsider/eslint-config [--yes|-y]   Scaffold a new eslint.config.mjs");
+	stderr("  npx @useinsider/eslint-config migrate [path] [--yes|-y] [--no-install]");
+	stderr("                                              Migrate an existing v1 useInsider() config to v2");
+}
+function isScaffoldArgv(argv) {
+	return argv.length === 0 || argv.every((arg) => isYesFlag(arg));
+}
+async function dispatch(argv, cwd, deps) {
+	if (isScaffoldArgv(argv)) {
+		const { yes } = parseScaffoldArgs(argv);
+		return deps.scaffold({
+			cwd,
+			yes
+		});
+	}
+	const [subcommand, ...rest] = argv;
+	if (subcommand === "migrate") {
+		const { target, yes, noInstall } = parseMigrateArgs(rest);
+		return deps.migrate({
+			cwd,
+			target,
+			yes,
+			noInstall
+		});
+	}
+	printUsage(deps.stderr, subcommand);
+	return 1;
+}
+//#endregion
+//#region src/configs/jest/dependencies.ts
+var dependencies$14 = { "eslint-plugin-jest": true };
+//#endregion
+//#region src/configs/typescript/dependencies.ts
+var dependencies$13 = {
+	typescript: false,
+	"typescript-eslint": false,
+	"@typescript-eslint/parser": false,
+	"@typescript-eslint/eslint-plugin": false
+};
+//#endregion
+//#region src/configs/vitest/dependencies.ts
+var dependencies$12 = { "@vitest/eslint-plugin": true };
+//#endregion
+//#region src/configs/vue2/dependencies.ts
+var dependencies$11 = {
+	"eslint-plugin-vue": true,
+	"eslint-plugin-vue-scoped-css": true,
+	"vue-eslint-parser": true
+};
+//#endregion
+//#region src/configs/vue2-typescript/dependencies.ts
+var dependencies$10 = {
+	"eslint-plugin-vue": true,
+	"eslint-plugin-vue-scoped-css": true,
+	"vue-eslint-parser": true,
+	typescript: false,
+	"typescript-eslint": false,
+	"@typescript-eslint/parser": false,
+	"@typescript-eslint/eslint-plugin": false
+};
+//#endregion
+//#region src/configs/vue3/dependencies.ts
+var dependencies$9 = {
+	"eslint-plugin-vue": true,
+	"eslint-plugin-vue-scoped-css": true,
+	"vue-eslint-parser": true
+};
+//#endregion
+//#region src/configs/vue3-typescript/dependencies.ts
+var dependencies$8 = {
+	"eslint-plugin-vue": true,
+	"eslint-plugin-vue-scoped-css": true,
+	"vue-eslint-parser": true,
+	typescript: false,
+	"typescript-eslint": false,
+	"@typescript-eslint/parser": false,
+	"@typescript-eslint/eslint-plugin": false
+};
+//#endregion
+//#region src/cli/resolveEslintConfigManifest.ts
+function tryReadManifest(candidate) {
+	try {
+		const raw = (0, node_fs.readFileSync)(candidate, "utf8");
+		const parsed = JSON.parse(raw);
+		return parsed.name === "@useinsider/eslint-config" ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function resolveRuntimeDir() {
+	const { url } = {};
+	if (typeof url === "string" && url.startsWith("file:")) return (0, node_path.dirname)((0, node_url.fileURLToPath)(url));
+	if (typeof __dirname === "string") return __dirname;
+	return (0, node_path.resolve)(process.cwd(), "node_modules/@useinsider/eslint-config/dist");
+}
+function readOwnEslintConfigManifestFrom(runtimeDir) {
+	const found = [
+		(0, node_path.resolve)(runtimeDir, "../../package.json"),
+		(0, node_path.resolve)(runtimeDir, "../../../package.json"),
+		(0, node_path.resolve)(runtimeDir, "../package.json"),
+		(0, node_path.resolve)(process.cwd(), "node_modules/@useinsider/eslint-config/package.json")
+	].map(tryReadManifest).find((manifest) => manifest !== null);
+	if (!found) throw new Error("Unable to locate @useinsider/eslint-config package.json from CLI runtime");
+	return found;
+}
+function readOwnEslintConfigManifest$1() {
+	return readOwnEslintConfigManifestFrom(resolveRuntimeDir());
+}
+//#endregion
+//#region src/cli/install.ts
+function toRequiredManifest(manifest) {
+	return {
+		version: manifest.version ?? "0.0.0",
+		dependencies: manifest.dependencies ?? {},
+		devDependencies: manifest.devDependencies ?? {},
+		peerDependencies: manifest.peerDependencies ?? {},
+		optionalDependencies: manifest.optionalDependencies ?? {}
+	};
+}
+function lookup(manifest, name) {
+	return manifest.dependencies[name] ?? manifest.devDependencies[name] ?? manifest.peerDependencies[name] ?? manifest.optionalDependencies[name];
+}
+function pinned(manifest, name) {
+	const version = lookup(manifest, name);
+	if (!version) throw new Error(`Unable to resolve pinned version for ${name} from @useinsider/eslint-config manifest`);
+	return `${name}@${version.replace(/^(?:\^|~|>=|<=|>|<|=)/u, "")}`;
+}
+function vueDepsFor(major, wantsTypescript) {
+	if (wantsTypescript) return major === 2 ? dependencies$10 : dependencies$8;
+	return major === 2 ? dependencies$11 : dependencies$9;
+}
+function applyRecord(deps, manifest, record) {
+	Object.entries(record).forEach(([name, install]) => {
+		if (install) deps.add(pinned(manifest, name));
+	});
+}
+function buildDependencyList(answers, rawManifest = readOwnEslintConfigManifest$1()) {
+	const manifest = toRequiredManifest(rawManifest);
+	const deps = /* @__PURE__ */ new Set();
+	deps.add(`@useinsider/eslint-config@${manifest.version}`);
+	deps.add(pinned(manifest, "eslint"));
+	deps.add(pinned(manifest, "globals"));
+	const wantsTypescript = answers.languages.includes("typescript");
+	if (answers.framework === "vue") applyRecord(deps, manifest, vueDepsFor(answers.vueMajor ?? 3, wantsTypescript));
+	else if (wantsTypescript) applyRecord(deps, manifest, dependencies$13);
+	if (answers.testFramework === "jest") applyRecord(deps, manifest, dependencies$14);
+	if (answers.testFramework === "vitest") applyRecord(deps, manifest, dependencies$12);
+	return [...deps];
+}
+async function installDependencies(deps) {
+	const { installPackage } = await import("@antfu/install-pkg");
+	await installPackage([...deps], {
+		dev: true,
+		additionalArgs: ["-E"]
+	});
+}
+//#endregion
+//#region src/cli/installWithRetry.ts
+var lockfileMap = [
+	{
+		file: "pnpm-lock.yaml",
+		manager: "pnpm"
+	},
+	{
+		file: "package-lock.json",
+		manager: "npm"
+	},
+	{
+		file: "yarn.lock",
+		manager: "yarn"
+	},
+	{
+		file: "bun.lockb",
+		manager: "bun"
+	}
+];
+var knownErrorCodes = [
+	"ENOSPC",
+	"EACCES",
+	"EPERM",
+	"ENOTFOUND",
+	"ETIMEDOUT",
+	"ECONNREFUSED",
+	"ECONNRESET",
+	"EAI_AGAIN",
+	"E404",
+	"ERR_PNPM_FETCH_404",
+	"ERR_PNPM_NO_MATCHING_VERSION"
+];
+function defaultWipeFs() {
+	return {
+		rmDir: (path) => {
+			(0, node_fs.rmSync)(path, {
+				recursive: true,
+				force: true
+			});
+		},
+		rmFile: (path) => {
+			(0, node_fs.unlinkSync)(path);
+		},
+		exists: (path) => (0, node_fs.existsSync)(path)
+	};
+}
+async function defaultInstaller(specs) {
+	const { installPackage } = await import("@antfu/install-pkg");
+	await installPackage([...specs], {
+		dev: true,
+		additionalArgs: ["-E"]
+	});
+}
+function detectLockfile(dir, exists) {
+	return lockfileMap.map((entry) => ({
+		manager: entry.manager,
+		lockfilePath: (0, node_path.join)(dir, entry.file)
+	})).find((candidate) => exists(candidate.lockfilePath)) ?? null;
+}
+var addCommandMap = {
+	pnpm: "pnpm add -D -E",
+	npm: "npm install -D -E",
+	yarn: "yarn add -D -E",
+	bun: "bun add -d -E"
+};
+var removeCommandMap = {
+	pnpm: "pnpm remove",
+	npm: "npm uninstall",
+	yarn: "yarn remove",
+	bun: "bun remove"
+};
+function detectPackageManager(dir, fsOps) {
+	return detectLockfile(dir, (fsOps ?? defaultWipeFs()).exists)?.manager ?? "pnpm";
+}
+function sortPackagesCaseInsensitive(packages) {
+	return [...packages].sort((left, right) => left.toLowerCase().localeCompare(right.toLowerCase()));
+}
+function formatMultilineCommand(header, packages, blockIndent, packageIndent) {
+	if (packages.length === 0) return "";
+	const sorted = sortPackagesCaseInsensitive(packages);
+	const lastIndex = sorted.length - 1;
+	const lines = [`${blockIndent}${header} \\`];
+	sorted.forEach((pkg, index) => {
+		const suffix = index === lastIndex ? "" : " \\";
+		lines.push(`${packageIndent}${pkg}${suffix}`);
+	});
+	return lines.join("\n");
+}
+function formatNextStepsAddCommand(manager, specs, blockIndent = "    ", packageIndent = "      ") {
+	return formatMultilineCommand(addCommandMap[manager], specs, blockIndent, packageIndent);
+}
+function formatNextStepsRemoveCommand(manager, names, blockIndent = "    ", packageIndent = "      ") {
+	return formatMultilineCommand(removeCommandMap[manager], names, blockIndent, packageIndent);
+}
+function manualRecoveryCommand(dir, detected) {
+	return `cd ${dir} && rm -rf node_modules ${detected ? (0, node_path.basename)(detected.lockfilePath) : "package-lock.json"} && ${detected?.manager ?? "npm"} install`;
+}
+function buildManualHint(specs, dir, detected) {
+	return `Manually add: ${specs.join(" ")}\nRecover with: ${manualRecoveryCommand(dir, detected)}`;
+}
+function isPeerDepFailure(reason) {
+	return reason.toLowerCase().includes("--legacy-peer-deps");
+}
+function firstNonEmptyLine(reason) {
+	return reason.split(/\r?\n/u).map((segment) => segment.trim()).find((segment) => segment.length > 0) ?? reason.trim();
+}
+function detectErrorCode(reason) {
+	return knownErrorCodes.find((code) => new RegExp(`\\b${code}\\b`, "u").test(reason)) ?? null;
+}
+function buildGenericSummary(reason) {
+	const code = detectErrorCode(reason);
+	const snippet = firstNonEmptyLine(reason);
+	if (code && !snippet.includes(code)) return `Dependency install failed (${code}): ${snippet}`;
+	return `Dependency install failed: ${snippet}`;
+}
+async function confirmPeerDepWipe(clack, autoConfirm) {
+	if (autoConfirm) return true;
+	const result = await clack.confirm({
+		message: "Install failed.\n\nThis usually means stale dependencies in node_modules conflict with the new ESLint plugin versions.\n\nWipe `node_modules` and the lockfile, then retry install?",
+		initialValue: false
+	});
+	return !clack.isCancel(result) && result === true;
+}
+async function confirmCleanReinstall(clack, autoConfirm, summary) {
+	if (autoConfirm) return true;
+	const message = `${summary}\n\nWould you like to try a clean reinstall? (removes \`node_modules\` and the lockfile, then re-runs install)`;
+	const result = await clack.confirm({
+		message,
+		initialValue: true
+	});
+	return !clack.isCancel(result) && result === true;
+}
+function noteWipeFailure(clack, label, path, reason) {
+	if (clack.note) clack.note(`Could not remove ${label} at ${path}: ${reason}`, "Warning");
+}
+function safeRemoveDir(clack, fs, path) {
+	if (!fs.exists(path)) return;
+	try {
+		fs.rmDir(path);
+	} catch (error) {
+		noteWipeFailure(clack, "node_modules", path, error instanceof Error ? error.message : String(error));
+	}
+}
+function safeRemoveFile(clack, fs, path) {
+	if (!fs.exists(path)) return;
+	try {
+		fs.rmFile(path);
+	} catch (error) {
+		noteWipeFailure(clack, "lockfile", path, error instanceof Error ? error.message : String(error));
+	}
+}
+function performFullWipe(clack, context) {
+	safeRemoveDir(clack, context.fs, (0, node_path.join)(context.dir, "node_modules"));
+	if (context.detected) safeRemoveFile(clack, context.fs, context.detected.lockfilePath);
+}
+function noteError(clack, prefix, reason, context, specs) {
+	if (!clack.note) return;
+	const hint = buildManualHint(specs, context.dir, context.detected);
+	clack.note(`${prefix}${reason}\n${hint}`, "Error");
+}
+function noteGenericError(clack, summary, context, specs) {
+	if (!clack.note) return;
+	const hint = buildManualHint(specs, context.dir, context.detected);
+	clack.note(`${summary}\n${hint}`, "Error");
+}
+async function tryRetryInstall(clack, installer, deps, context) {
+	try {
+		await installer(deps);
+	} catch (retryError) {
+		noteError(clack, "Retry install failed after wipe: ", retryError instanceof Error ? retryError.message : String(retryError), context, deps);
+	}
+}
+async function tryGenericRetryInstall(clack, installer, deps, context) {
+	try {
+		await installer(deps);
+	} catch (retryError) {
+		noteGenericError(clack, buildGenericSummary(`Clean reinstall failed: ${retryError instanceof Error ? retryError.message : String(retryError)}`), context, deps);
+	}
+}
+async function handlePeerDepFailure(clack, deps, autoConfirm, installer, reason, context) {
+	if (!await confirmPeerDepWipe(clack, autoConfirm)) {
+		noteError(clack, "Install failed: ", reason, context, deps);
+		return;
+	}
+	performFullWipe(clack, context);
+	await tryRetryInstall(clack, installer, deps, context);
+}
+async function handleGenericFailure(clack, deps, autoConfirm, installer, reason, context) {
+	const summary = buildGenericSummary(reason);
+	if (!await confirmCleanReinstall(clack, autoConfirm, summary)) {
+		if (clack.note) clack.note(`${summary}\nSkipping clean reinstall. Please resolve the issue manually and re-run.`, "Error");
+		return;
+	}
+	performFullWipe(clack, context);
+	await tryGenericRetryInstall(clack, installer, deps, context);
+}
+async function installWithRetry(opts) {
+	const installer = opts.installer ?? defaultInstaller;
+	const fs = opts.fsOps ?? defaultWipeFs();
+	try {
+		await installer(opts.deps);
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		const context = {
+			dir: opts.cwd,
+			fs,
+			detected: detectLockfile(opts.cwd, fs.exists)
+		};
+		if (isPeerDepFailure(reason)) {
+			await handlePeerDepFailure(opts.clack, opts.deps, opts.autoConfirm, installer, reason, context);
+			return;
+		}
+		await handleGenericFailure(opts.clack, opts.deps, opts.autoConfirm, installer, reason, context);
+	}
+}
+//#endregion
+//#region src/cli/template.ts
+var COMPOSITION_DEFAULT_SUFFIX_CHOICES = [
+	{
+		value: ".options.vue",
+		label: "*.options.vue"
+	},
+	{
+		value: ".classic.vue",
+		label: "*.classic.vue"
+	},
+	{
+		value: ".legacy.vue",
+		label: "*.legacy.vue"
+	}
+];
+var OPTIONS_DEFAULT_SUFFIX_CHOICES = [
+	{
+		value: ".composition.vue",
+		label: "*.composition.vue"
+	},
+	{
+		value: ".setup.vue",
+		label: "*.setup.vue"
+	},
+	{
+		value: ".modern.vue",
+		label: "*.modern.vue"
+	}
+];
+function getHybridSuffixChoices(defaultApi) {
+	return defaultApi === "composition" ? COMPOSITION_DEFAULT_SUFFIX_CHOICES : OPTIONS_DEFAULT_SUFFIX_CHOICES;
+}
+function getHybridDefaultSuffix(defaultApi) {
+	return getHybridSuffixChoices(defaultApi)[0].value;
+}
+var indent$1 = "    ";
+function hasJavascript(languages) {
+	return languages.includes("javascript");
+}
+function hasTypescript(languages) {
+	return languages.includes("typescript");
+}
+function isVueBrowserLike(answers) {
+	return answers.framework === "vue" && answers.projectType !== "backend";
+}
+function isVueOptionsApi(answers) {
+	return answers.vueApiStyle === "options";
+}
+function isVueHybridApi(answers) {
+	return answers.vueApiStyle === "hybrid";
+}
+function vueJsScope(major, api) {
+	if (major === 2) return api === "options" ? "vue2OptionsApi" : "vue2";
+	return api === "options" ? "vue3OptionsApi" : "vue3";
+}
+function vueTsScope(major, api) {
+	if (major === 2) return api === "options" ? "vue2TypescriptOptionsApi" : "vue2Typescript";
+	return api === "options" ? "vue3TypescriptOptionsApi" : "vue3Typescript";
+}
+function jsAppScopes(answers) {
+	if (isVueBrowserLike(answers) && !hasTypescript(answers.languages)) return [vueJsScope(answers.vueMajor ?? 3, isVueOptionsApi(answers) ? "options" : "composition")];
+	if (answers.projectType === "backend") return ["javascriptNode"];
+	if (answers.projectType === "hybrid") return ["javascriptNode", "javascriptDom"];
+	return ["javascriptDom"];
+}
+function tsAppScopes(answers) {
+	if (isVueBrowserLike(answers)) return [vueTsScope(answers.vueMajor ?? 3, isVueOptionsApi(answers) ? "options" : "composition")];
+	if (answers.projectType === "backend") return ["typescriptNode"];
+	if (answers.projectType === "hybrid") return ["typescriptNode", "typescriptDom"];
+	return ["typescriptDom"];
+}
+function jsAppFiles(answers) {
+	if (isVueBrowserLike(answers) && !hasTypescript(answers.languages)) return ["**/*.{js,jsx,cjs,mjs,vue}"];
+	return ["**/*.{js,jsx,cjs,mjs}"];
+}
+function normalizeHybridSuffix(raw) {
+	const trimmed = raw.trim();
+	const withDot = trimmed.startsWith(".") ? trimmed : `.${trimmed}`;
+	return withDot.endsWith(".vue") ? withDot : `${withDot}.vue`;
+}
+function tsAppFiles(answers, scoped) {
+	const vue = isVueBrowserLike(answers);
+	const prefix = scoped === "app" ? "src/**/*" : "**/*";
+	if (vue) return [`${prefix}.{ts,tsx,vue}`];
+	return [`${prefix}.{ts,tsx}`];
+}
+function testFilesGlob(languages) {
+	const ts = hasTypescript(languages);
+	const js = hasJavascript(languages);
+	if (ts && js) return ["**/*.{test,spec}.{ts,tsx,js,jsx}"];
+	if (ts) return ["**/*.{test,spec}.{ts,tsx}"];
+	return ["**/*.{test,spec}.{js,jsx}"];
+}
+function jqueryFilesGlob(answers) {
+	const vue = isVueBrowserLike(answers);
+	const ts = hasTypescript(answers.languages);
+	const js = hasJavascript(answers.languages);
+	if (vue) {
+		if (ts && js) return ["**/*.{ts,tsx,js,jsx,cjs,mjs,vue}"];
+		if (ts) return ["**/*.{ts,tsx,vue}"];
+		return ["**/*.{js,jsx,cjs,mjs,vue}"];
+	}
+	if (ts && js) return ["**/*.{ts,tsx,js,jsx,cjs,mjs}"];
+	if (ts) return ["**/*.{ts,tsx}"];
+	return ["**/*.{js,jsx,cjs,mjs}"];
+}
+function jsRootConfigFiles() {
+	return [
+		"*.js",
+		"*.cjs",
+		"*.mjs"
+	];
+}
+function tsRootConfigFiles() {
+	return [
+		"*.ts",
+		"*.cts",
+		"*.mts"
+	];
+}
+function findRole(plan, role) {
+	return plan.entries.find((entry) => entry.role === role);
+}
+function isHybridVueJsContext(answers) {
+	return isVueBrowserLike(answers) && isVueHybridApi(answers) && !hasTypescript(answers.languages) && Boolean(answers.vueHybridSuffix);
+}
+function isHybridVueTsContext(answers) {
+	return isVueBrowserLike(answers) && isVueHybridApi(answers) && hasTypescript(answers.languages) && Boolean(answers.vueHybridSuffix);
+}
+function buildHybridVueJsBlocks(answers) {
+	if (!isHybridVueJsContext(answers) || !answers.vueHybridSuffix) return null;
+	const major = answers.vueMajor ?? 3;
+	const { defaultApi, suffix: rawSuffix } = answers.vueHybridSuffix;
+	const targetGlob = `**/*${normalizeHybridSuffix(rawSuffix)}`;
+	const nonDefaultApi = defaultApi === "composition" ? "options" : "composition";
+	const defaultEntry = {
+		files: ["**/*.{js,jsx,cjs,mjs,vue}"],
+		ignores: [targetGlob]
+	};
+	return [{
+		scope: vueJsScope(major, defaultApi),
+		entry: defaultEntry
+	}, {
+		scope: vueJsScope(major, nonDefaultApi),
+		entry: { files: [targetGlob] }
+	}];
+}
+function makeHybridTsEntries(answers, suffix, appEntry) {
+	const targetGlob = `**/*${suffix}`;
+	const baseFiles = tsAppFiles(answers, answers.tsconfig?.referencesOnly === true && Boolean(appEntry) ? "app" : "all");
+	const tsconfigPaths = appEntry ? [appEntry.path] : void 0;
+	const defaultEntry = {
+		files: baseFiles,
+		ignores: [targetGlob]
+	};
+	const targetEntry = { files: [targetGlob] };
+	if (tsconfigPaths) {
+		defaultEntry.tsconfigPaths = tsconfigPaths;
+		targetEntry.tsconfigPaths = tsconfigPaths;
+	}
+	return {
+		defaultEntry,
+		targetEntry
+	};
+}
+function buildHybridVueTsBlocks(answers, appEntry) {
+	if (!isHybridVueTsContext(answers) || !answers.vueHybridSuffix) return null;
+	const major = answers.vueMajor ?? 3;
+	const { defaultApi, suffix: rawSuffix } = answers.vueHybridSuffix;
+	const suffix = normalizeHybridSuffix(rawSuffix);
+	const nonDefaultApi = defaultApi === "composition" ? "options" : "composition";
+	const { defaultEntry, targetEntry } = makeHybridTsEntries(answers, suffix, appEntry);
+	return [{
+		scope: vueTsScope(major, defaultApi),
+		entry: defaultEntry
+	}, {
+		scope: vueTsScope(major, nonDefaultApi),
+		entry: targetEntry
+	}];
+}
+function buildJsAppBlocks(answers) {
+	if (!hasJavascript(answers.languages)) return [];
+	const hybridBlocks = buildHybridVueJsBlocks(answers);
+	if (hybridBlocks) return hybridBlocks;
+	const files = jsAppFiles(answers);
+	return jsAppScopes(answers).map((scope) => ({
+		scope,
+		entry: { files }
+	}));
+}
+function buildTsAppBlocks(answers, appEntry) {
+	if (!hasTypescript(answers.languages)) return [];
+	const hybridBlocks = buildHybridVueTsBlocks(answers, appEntry);
+	if (hybridBlocks) return hybridBlocks;
+	const files = tsAppFiles(answers, answers.tsconfig?.referencesOnly === true && Boolean(appEntry) ? "app" : "all");
+	return tsAppScopes(answers).map((scope) => {
+		const entry = { files };
+		if (appEntry) entry.tsconfigPaths = [appEntry.path];
+		return {
+			scope,
+			entry
+		};
+	});
+}
+function tsConfigPathsForRoot(appEntry, configEntry) {
+	if (configEntry) return [configEntry.path];
+	if (appEntry) return [appEntry.path];
+}
+function configScopeFiles(answers) {
+	const files = [...jsRootConfigFiles()];
+	if (hasTypescript(answers.languages)) files.push(...tsRootConfigFiles());
+	return files;
+}
+function buildRootConfigBlocks(answers, appEntry, configEntry) {
+	const blocks = [{
+		scope: "config",
+		entry: { files: configScopeFiles(answers) }
+	}, {
+		scope: "javascriptNode",
+		entry: { files: jsRootConfigFiles() }
+	}];
+	if (hasTypescript(answers.languages)) {
+		const entry = { files: tsRootConfigFiles() };
+		const tsconfigPaths = tsConfigPathsForRoot(appEntry, configEntry);
+		if (tsconfigPaths) entry.tsconfigPaths = tsconfigPaths;
+		blocks.push({
+			scope: "typescriptNode",
+			entry
+		});
+	}
+	return blocks;
+}
+function buildTestBlock(answers, testEntry) {
+	if (answers.testFramework === "none") return null;
+	const entry = { files: testFilesGlob(answers.languages) };
+	if (hasTypescript(answers.languages) && testEntry) entry.tsconfigPaths = [testEntry.path];
+	return {
+		scope: answers.testFramework,
+		entry
+	};
+}
+function buildJqueryBlock(answers) {
+	if (!answers.extras.jquery) return null;
+	return {
+		scope: "jquery",
+		entry: { files: jqueryFilesGlob(answers) }
+	};
+}
+function buildScopedConfigs(answers) {
+	const plan = answers.tsconfig;
+	const referencesOnly = plan?.referencesOnly === true;
+	const appEntry = plan ? findRole(plan, "app") : void 0;
+	const configEntry = referencesOnly ? findRole(plan, "config") : void 0;
+	const tail = [buildTestBlock(answers, referencesOnly ? findRole(plan, "test") : appEntry), buildJqueryBlock(answers)];
+	return [
+		...buildRootConfigBlocks(answers, appEntry, configEntry),
+		...buildJsAppBlocks(answers),
+		...buildTsAppBlocks(answers, appEntry),
+		...tail.filter((block) => block !== null)
+	];
+}
+function mergeByScope(blocks) {
+	return blocks.reduce((merged, { scope, entry }) => {
+		const existing = merged.get(scope);
+		if (existing) existing.push(entry);
+		else merged.set(scope, [entry]);
+		return merged;
+	}, /* @__PURE__ */ new Map());
+}
+function quote$1(value) {
+	return `'${value}'`;
+}
+function formatStringArray(values) {
+	return `[${values.map(quote$1).join(", ")}]`;
+}
+function formatEntry$1(entry, baseIndent) {
+	const filesLine = `files: ${formatStringArray(entry.files)}`;
+	const ignoresLine = entry.ignores ? `ignores: ${formatStringArray(entry.ignores)}` : null;
+	const tsconfigLine = entry.tsconfigPaths ? `tsconfigPaths: ${formatStringArray(entry.tsconfigPaths)}` : null;
+	if (!ignoresLine && !tsconfigLine) return `${baseIndent}{ ${filesLine} },`;
+	const childIndent = `${baseIndent}${indent$1}`;
+	const lines = [`${baseIndent}{`, `${childIndent}${filesLine},`];
+	if (ignoresLine) lines.push(`${childIndent}${ignoresLine},`);
+	if (tsconfigLine) lines.push(`${childIndent}${tsconfigLine},`);
+	lines.push(`${baseIndent}},`);
+	return lines.join("\n");
+}
+function formatScope$1(scope, entries, baseIndent) {
+	const childIndent = `${baseIndent}${indent$1}`;
+	const entryLines = entries.map((entry) => formatEntry$1(entry, childIndent));
+	return [
+		`${baseIndent}${scope}: [`,
+		...entryLines,
+		`${baseIndent}],`
+	].join("\n");
+}
+function renderUseInsiderBody(merged) {
+	return [...merged.entries()].map(([scope, entries]) => formatScope$1(scope, entries, indent$1)).join("\n");
+}
+function renderConfigFile(answers) {
+	return [
+		"import { useInsider } from '@useinsider/eslint-config';",
+		"",
+		"export default useInsider({",
+		renderUseInsiderBody(mergeByScope(buildScopedConfigs(answers))),
+		"});",
+		""
+	].join("\n");
+}
+//#endregion
+//#region src/cli/questions.ts
+var CliCancelledError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CliCancelledError";
+	}
+};
+async function loadClack() {
+	return await import("@clack/prompts");
+}
+function bail(clack, message) {
+	clack.cancel(message);
+	throw new CliCancelledError(message);
+}
+function ensure(clack, value) {
+	if (clack.isCancel(value)) bail(clack, "Cancelled.");
+	return value;
+}
+async function askProjectType(clack, initial = "backend") {
+	return ensure(clack, await clack.select({
+		message: "What kind of project are you setting up?",
+		options: [
+			{
+				value: "backend",
+				label: "Backend / Node.js"
+			},
+			{
+				value: "browser",
+				label: "Browser / frontend"
+			},
+			{
+				value: "hybrid",
+				label: "Hybrid",
+				hint: "Node + browser (isomorphic, SSR, full-stack)"
+			}
+		],
+		initialValue: initial
+	}));
+}
+async function askLanguages(clack, initial = ["typescript"]) {
+	const picked = ensure(clack, await clack.multiselect({
+		message: "Which languages will the project use? (press space to toggle, enter to confirm)",
+		options: [{
+			value: "javascript",
+			label: "JavaScript"
+		}, {
+			value: "typescript",
+			label: "TypeScript"
+		}],
+		required: true,
+		initialValues: initial
+	}));
+	if (picked.length === 0) bail(clack, "At least one language must be selected.");
+	return picked;
+}
+async function askFramework(clack, initial = "vanilla") {
+	return ensure(clack, await clack.select({
+		message: "Which frontend framework?",
+		options: [{
+			value: "vanilla",
+			label: "None / Vanilla"
+		}, {
+			value: "vue",
+			label: "Vue"
+		}],
+		initialValue: initial
+	}));
+}
+async function askVueMajor(clack, initial = 3) {
+	return ensure(clack, await clack.select({
+		message: "Which Vue major version?",
+		options: [{
+			value: 3,
+			label: "Vue 3"
+		}, {
+			value: 2,
+			label: "Vue 2"
+		}],
+		initialValue: initial
+	}));
+}
+async function askVueApiStyle(clack, initial = "composition") {
+	return ensure(clack, await clack.select({
+		message: "What API style does your Vue codebase use?",
+		options: [
+			{
+				value: "composition",
+				label: "Composition API (setup)"
+			},
+			{
+				value: "options",
+				label: "Options API"
+			},
+			{
+				value: "hybrid",
+				label: "Hybrid (both)"
+			}
+		],
+		initialValue: initial
+	}));
+}
+async function askHybridProceedWithSuffix(clack, initial = true) {
+	return ensure(clack, await clack.confirm({
+		message: "Want me to scaffold both Options + Composition blocks using a filename suffix convention?",
+		initialValue: initial
+	}));
+}
+async function askVueHybridDefaultApi(clack, initial = "composition") {
+	return ensure(clack, await clack.select({
+		message: "Which API style is the default in your codebase?",
+		options: [{
+			value: "composition",
+			label: "Composition API (setup)"
+		}, {
+			value: "options",
+			label: "Options API"
+		}],
+		initialValue: initial
+	}));
+}
+async function askHybridSuffix(clack, defaultApi, initial) {
+	const choices = getHybridSuffixChoices(defaultApi);
+	const message = defaultApi === "composition" ? "Pick a suffix for Options-API components:" : "Pick a suffix for Composition-API components:";
+	const fallback = getHybridDefaultSuffix(defaultApi);
+	const initialValue = initial && choices.some((choice) => choice.value === initial) ? initial : fallback;
+	return ensure(clack, await clack.select({
+		message,
+		options: choices.map((choice) => ({
+			value: choice.value,
+			label: choice.label
+		})),
+		initialValue
+	}));
+}
+async function askTestFramework(clack, initial = "vitest") {
+	return ensure(clack, await clack.select({
+		message: "Which testing framework?",
+		options: [
+			{
+				value: "vitest",
+				label: "Vitest"
+			},
+			{
+				value: "jest",
+				label: "Jest"
+			},
+			{
+				value: "none",
+				label: "None"
+			}
+		],
+		initialValue: initial
+	}));
+}
+async function askExtras(clack, initial = { jquery: false }) {
+	const initialValues = initial.jquery ? ["jquery"] : [];
+	return { jquery: ensure(clack, await clack.multiselect({
+		message: "Which extra libraries do you use?",
+		options: [{
+			value: "jquery",
+			label: "jQuery (adds globals)"
+		}],
+		required: false,
+		initialValues
+	})).includes("jquery") };
+}
+async function askTsconfigRole(clack, refPath, initial = "app") {
+	return ensure(clack, await clack.select({
+		message: `Map ${refPath} to a role:`,
+		options: [
+			{
+				value: "app",
+				label: "App / source code"
+			},
+			{
+				value: "test",
+				label: "Test code"
+			},
+			{
+				value: "config",
+				label: "Config / root files"
+			}
+		],
+		initialValue: initial
+	}));
+}
+async function collectRoleEntries(clack, refs, previous) {
+	const previousByPath = new Map(previous?.map((entry) => [entry.path, entry.role]) ?? []);
+	return refs.reduce(async (accumulator, ref) => {
+		const entries = await accumulator;
+		const role = await askTsconfigRole(clack, ref, previousByPath.get(ref));
+		return [...entries, {
+			path: ref,
+			role
+		}];
+	}, Promise.resolve([]));
+}
+async function askTsconfigPlan(clack, input, previous) {
+	if (!input.referencesOnly) return {
+		referencesOnly: false,
+		entries: [{
+			path: "./tsconfig.json",
+			role: "app"
+		}]
+	};
+	return {
+		referencesOnly: true,
+		entries: await collectRoleEntries(clack, input.refs, previous?.entries)
+	};
+}
+async function askExistingConfigDecision(clack, configPath, initial = "migrate") {
+	return ensure(clack, await clack.select({
+		message: `Found existing config at ${configPath}. How should we proceed?`,
+		options: [
+			{
+				value: "migrate",
+				label: "Migrate",
+				hint: "preserve current base config, port them to the v2 shape"
+			},
+			{
+				value: "override",
+				label: "Override",
+				hint: "discard the existing config and scaffold a new one"
+			},
+			{
+				value: "exit",
+				label: "Exit",
+				hint: "leave the project untouched"
+			}
+		],
+		initialValue: initial
+	}));
+}
+async function askBrowserBranch(clack, previous) {
+	const framework = await askFramework(clack, previous?.framework);
+	if (framework !== "vue") return {
+		framework,
+		vueMajor: void 0,
+		vueApiStyle: void 0
+	};
+	return {
+		framework,
+		vueMajor: await askVueMajor(clack, previous?.vueMajor),
+		vueApiStyle: await askVueApiStyle(clack, previous?.vueApiStyle)
+	};
+}
+function noteResumed(clack, previous) {
+	if (!previous || !clack.note) return;
+	clack.note("Restored your previous choices. Press Enter on each prompt to confirm, or arrow keys to change.", "Resuming previous session");
+}
+function guardTsconfig(clack, wantsTypescript, context) {
+	if (wantsTypescript && context.tsconfigMissing) bail(clack, "No tsconfig.json found in current directory. Create one and re-run.");
+}
+async function resolveBrowserBranch(clack, projectType, previous) {
+	if (projectType !== "browser" && projectType !== "hybrid") return {
+		framework: void 0,
+		vueMajor: void 0,
+		vueApiStyle: void 0
+	};
+	return askBrowserBranch(clack, previous);
+}
+async function resolveTsconfigPlan(clack, wantsTypescript, context, previous) {
+	if (!wantsTypescript || !context.tsconfigInput) return;
+	return askTsconfigPlan(clack, context.tsconfigInput, previous?.tsconfig);
+}
+async function runQuestions(context, clackOverride) {
+	const clack = clackOverride ?? await loadClack();
+	clack.intro("useinsider eslint-config setup");
+	noteResumed(clack, context.previousAnswers);
+	const previous = context.previousAnswers;
+	const projectType = await askProjectType(clack, previous?.projectType);
+	const languages = await askLanguages(clack, previous?.languages);
+	const wantsTypescript = languages.includes("typescript");
+	guardTsconfig(clack, wantsTypescript, context);
+	const browserBranch = await resolveBrowserBranch(clack, projectType, previous);
+	const testFramework = await askTestFramework(clack, previous?.testFramework);
+	const extras = await askExtras(clack, previous?.extras);
+	const tsconfig = await resolveTsconfigPlan(clack, wantsTypescript, context, previous);
+	return {
+		projectType,
+		languages,
+		framework: browserBranch.framework,
+		vueMajor: browserBranch.vueMajor,
+		vueApiStyle: browserBranch.vueApiStyle,
+		testFramework,
+		extras,
+		tsconfig
+	};
+}
+//#endregion
+//#region src/cli/sessionStore.ts
+var SCHEMA_VERSION = 4;
+var DEFAULT_TTL_MS = 3600 * 1e3;
+var FILE_PREFIX = "useinsider-eslint-config-session-";
+function hashCwd(cwd) {
+	return (0, node_crypto.createHash)("sha1").update(cwd).digest("hex").slice(0, 16);
+}
+function getSessionFilePath(cwd, tmpDirOverride) {
+	return (0, node_path.join)(tmpDirOverride ?? (0, node_os.tmpdir)(), `${FILE_PREFIX}${hashCwd(cwd)}.json`);
+}
+function safeUnlink$1(path) {
+	try {
+		(0, node_fs.unlinkSync)(path);
+	} catch {}
+}
+function ensureDir(path) {
+	if (!(0, node_fs.existsSync)(path)) (0, node_fs.mkdirSync)(path, { recursive: true });
+}
+function isSessionShape(value) {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	return candidate.v === SCHEMA_VERSION && typeof candidate.savedAt === "number" && typeof candidate.cwd === "string" && (candidate.command === "scaffold" || candidate.command === "migrate");
+}
+function saveSession(session, options) {
+	const now = options.now ?? Date.now;
+	const dir = options.tmpDir ?? (0, node_os.tmpdir)();
+	ensureDir(dir);
+	const path = getSessionFilePath(options.cwd, dir);
+	const payload = {
+		v: SCHEMA_VERSION,
+		savedAt: now(),
+		cwd: options.cwd,
+		...session
+	};
+	(0, node_fs.writeFileSync)(path, JSON.stringify(payload), {
+		encoding: "utf8",
+		mode: 384
+	});
+	try {
+		(0, node_fs.chmodSync)(path, 384);
+	} catch {}
+	return path;
+}
+function loadSession(options) {
+	const now = options.now ?? Date.now;
+	const ttl = options.ttlMs ?? DEFAULT_TTL_MS;
+	const path = getSessionFilePath(options.cwd, options.tmpDir);
+	if (!(0, node_fs.existsSync)(path)) return null;
+	let parsed;
+	try {
+		const raw = (0, node_fs.readFileSync)(path, "utf8");
+		parsed = JSON.parse(raw);
+	} catch {
+		safeUnlink$1(path);
+		return null;
+	}
+	if (!isSessionShape(parsed)) {
+		safeUnlink$1(path);
+		return null;
+	}
+	if (parsed.cwd !== options.cwd) {
+		safeUnlink$1(path);
+		return null;
+	}
+	if (now() - parsed.savedAt > ttl) {
+		safeUnlink$1(path);
+		return null;
+	}
+	return parsed;
+}
+function clearSession(options) {
+	safeUnlink$1(getSessionFilePath(options.cwd, options.tmpDir));
+}
+/* v8 ignore stop */
+//#endregion
+//#region src/configs/config/dependencies.ts
+var dependencies$7 = {};
+//#endregion
+//#region src/configs/javascript/dependencies.ts
+var dependencies$6 = {};
+//#endregion
+//#region src/configs/javascript-dom/dependencies.ts
+var dependencies$5 = {};
+//#endregion
+//#region src/configs/javascript-node/dependencies.ts
+var dependencies$4 = {};
+//#endregion
+//#region src/configs/jsdoc-based-ts/dependencies.ts
+var dependencies$3 = {
+	typescript: false,
+	"typescript-eslint": false,
+	"@typescript-eslint/parser": false,
+	"@typescript-eslint/eslint-plugin": false
+};
+//#endregion
+//#region src/configs/strict/dependencies.ts
+var dependencies$2 = { "eslint-plugin-sonarjs": false };
+//#endregion
+//#region src/configs/typescript-dom/dependencies.ts
+var dependencies$1 = {
+	typescript: false,
+	"typescript-eslint": false,
+	"@typescript-eslint/parser": false,
+	"@typescript-eslint/eslint-plugin": false
+};
+//#endregion
+//#region src/configs/typescript-node/dependencies.ts
+var dependencies = {
+	typescript: false,
+	"typescript-eslint": false,
+	"@typescript-eslint/parser": false,
+	"@typescript-eslint/eslint-plugin": false
+};
+//#endregion
+//#region src/cli/migrate/dependencies.ts
+var EXACT_PATTERNS = new Set([
+	"eslint",
+	"@useinsider/eslint-config",
+	"globals",
+	"vue-eslint-parser",
+	"typescript-eslint"
+]);
+var PREFIX_PATTERNS = [
+	"eslint-plugin-",
+	"eslint-config-",
+	"eslint-import-resolver-",
+	"eslint-formatter-",
+	"eslint-"
+];
+var SCOPED_ESLINT_PATTERNS = [/^@[^/]+\/eslint-/u, /^@typescript-eslint\//u];
+var SAFELIST = new Set(["typescript", "@types/eslint"]);
+var SCOPE_TO_DEPS = {
+	javascript: dependencies$6,
+	javascriptDom: dependencies$5,
+	javascriptNode: dependencies$4,
+	typescript: dependencies$13,
+	typescriptDom: dependencies$1,
+	typescriptNode: dependencies,
+	vue2: dependencies$11,
+	vue3: dependencies$9,
+	vue2Typescript: dependencies$10,
+	vue3Typescript: dependencies$8,
+	jest: dependencies$14,
+	vitest: dependencies$12,
+	jsdocBasedTs: dependencies$3
+};
+var ALL_PRESET_DEPS = [
+	dependencies$7,
+	dependencies$2,
+	...Object.values(SCOPE_TO_DEPS)
+];
+var PRESET_DEPENDENCY_KEYS = new Set(ALL_PRESET_DEPS.flatMap((record) => Object.keys(record)));
+function isEslintRelatedDependency(name) {
+	if (SAFELIST.has(name)) return false;
+	if (EXACT_PATTERNS.has(name)) return true;
+	if (PRESET_DEPENDENCY_KEYS.has(name)) return true;
+	if (SCOPED_ESLINT_PATTERNS.some((pattern) => pattern.test(name))) return true;
+	return PREFIX_PATTERNS.some((prefix) => name.startsWith(prefix));
+}
+function sortRecord(record) {
+	return Object.keys(record).sort((left, right) => left.localeCompare(right)).reduce((accumulator, key) => {
+		accumulator[key] = record[key];
+		return accumulator;
+	}, {});
+}
+function pruneSection(record, removed) {
+	if (!record) return record;
+	const kept = {};
+	Object.entries(record).forEach(([name, version]) => {
+		if (isEslintRelatedDependency(name)) {
+			if (!removed.includes(name)) removed.push(name);
+			return;
+		}
+		kept[name] = version;
+	});
+	return sortRecord(kept);
+}
+function parseOverrideKey(key) {
+	if (key.length === 0) return { baseName: key };
+	const searchFrom = key.startsWith("@") ? 1 : 0;
+	const atIndex = key.indexOf("@", searchFrom);
+	if (atIndex === -1) return { baseName: key };
+	return { baseName: key.slice(0, atIndex) };
+}
+function sortOverrides(record) {
+	return Object.keys(record).sort((left, right) => left.localeCompare(right)).reduce((accumulator, key) => {
+		accumulator[key] = record[key];
+		return accumulator;
+	}, {});
+}
+function pruneOverridesSection(record, removed) {
+	if (!record) return record;
+	const kept = {};
+	Object.entries(record).forEach(([key, value]) => {
+		if (!(typeof value === "string")) {
+			kept[key] = value;
+			return;
+		}
+		const { baseName } = parseOverrideKey(key);
+		if (isEslintRelatedDependency(baseName)) {
+			if (!removed.includes(baseName)) removed.push(baseName);
+			return;
+		}
+		kept[key] = value;
+	});
+	return sortOverrides(kept);
+}
+function pruneEslintDependencies(manifest) {
+	const removed = [];
+	const next = { ...manifest };
+	if (manifest.dependencies) next.dependencies = pruneSection(manifest.dependencies, removed);
+	if (manifest.devDependencies) next.devDependencies = pruneSection(manifest.devDependencies, removed);
+	if (manifest.peerDependencies) next.peerDependencies = pruneSection(manifest.peerDependencies, removed);
+	if (manifest.optionalDependencies) next.optionalDependencies = pruneSection(manifest.optionalDependencies, removed);
+	if (manifest.overrides) next.overrides = pruneOverridesSection(manifest.overrides, removed);
+	if (manifest.pnpm && typeof manifest.pnpm === "object") {
+		const nextPnpm = { ...manifest.pnpm };
+		if (manifest.pnpm.overrides) nextPnpm.overrides = pruneOverridesSection(manifest.pnpm.overrides, removed);
+		next.pnpm = nextPnpm;
+	}
+	if (manifest.resolutions) next.resolutions = pruneSection(manifest.resolutions, removed);
+	return {
+		manifest: next,
+		removed
+	};
+}
+function lookupVersion(manifest, name) {
+	return manifest.dependencies?.[name] ?? manifest.devDependencies?.[name] ?? manifest.peerDependencies?.[name] ?? manifest.optionalDependencies?.[name];
+}
+function stripRange(version) {
+	return version.replace(/^(?:\^|~|>=|<=|>|<|=)/u, "");
+}
+function appendSpec(specs, spec) {
+	if (!specs.includes(spec)) specs.push(spec);
+}
+function resolveSpec(name, manifest, fallbacks) {
+	const version = lookupVersion(manifest, name);
+	if (!version) {
+		if (!fallbacks.includes(name)) fallbacks.push(name);
+		return `${name}@latest`;
+	}
+	return `${name}@${stripRange(version)}`;
+}
+function buildInstallList(scopes, manifest) {
+	const specs = [];
+	const fallbacks = [];
+	appendSpec(specs, "@useinsider/eslint-config@latest");
+	appendSpec(specs, resolveSpec("eslint", manifest, fallbacks));
+	[...scopes].forEach((scope) => {
+		const record = SCOPE_TO_DEPS[scope];
+		if (!record) return;
+		Object.entries(record).forEach(([packageName, shouldInstall]) => {
+			if (shouldInstall) appendSpec(specs, resolveSpec(packageName, manifest, fallbacks));
+		});
+	});
+	return {
+		specs,
+		fallbacks
+	};
+}
+var readOwnEslintConfigManifest = readOwnEslintConfigManifest$1;
+//#endregion
+//#region src/cli/prunePackageJson.ts
+function detectIndent(raw) {
+	const match = /\n([ \t]+)"/u.exec(raw);
+	if (!match) return "    ";
+	return match[1];
+}
+function serializeManifest(manifest, indent) {
+	return `${JSON.stringify(manifest, null, indent)}\n`;
+}
+function tryReadConsumerManifest$1(path) {
+	try {
+		const raw = (0, node_fs.readFileSync)(path, "utf8");
+		return {
+			raw,
+			manifest: JSON.parse(raw)
+		};
+	} catch {
+		return null;
+	}
+}
+function pruneConsumerPackageJson(cwd) {
+	const packageJsonPath = (0, node_path.join)(cwd, "package.json");
+	if (!(0, node_fs.existsSync)(packageJsonPath)) return {
+		packageJsonPath: null,
+		removed: []
+	};
+	const read = tryReadConsumerManifest$1(packageJsonPath);
+	if (!read) return {
+		packageJsonPath: null,
+		removed: []
+	};
+	const { manifest, raw } = read;
+	const outcome = pruneEslintDependencies(manifest);
+	if (outcome.removed.length === 0) return {
+		packageJsonPath,
+		removed: []
+	};
+	const indent = detectIndent(raw);
+	(0, node_fs.writeFileSync)(packageJsonPath, serializeManifest(outcome.manifest, indent), "utf8");
+	return {
+		packageJsonPath,
+		removed: outcome.removed
+	};
+}
+//#endregion
+//#region src/cli/migrate/stringEntry.ts
+function toEntries(values) {
+	return values.map((value) => ({ value }));
+}
+function entryValues(entries) {
+	return entries.map((entry) => entry.value);
+}
+function cloneEntry(entry) {
+	return entry.leadingComment === void 0 ? { value: entry.value } : {
+		value: entry.value,
+		leadingComment: entry.leadingComment
+	};
+}
+function cloneEntries(entries) {
+	return entries.map(cloneEntry);
+}
+function hasValue(entries, value) {
+	return entries.some((entry) => entry.value === value);
+}
+function leadingCommentTextFor(sourceFile, node) {
+	const ranges = typescript.getLeadingCommentRanges(sourceFile.text, node.getFullStart());
+	if (!ranges || ranges.length === 0) return;
+	return ranges.map((range) => sourceFile.text.slice(range.pos, range.end)).join("\n");
+}
+//#endregion
+//#region src/cli/migrate/eslintrc/parse.ts
+function lineOf$1(sourceFile, node) {
+	const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+	return line + 1;
+}
+function isStringLiteralLike(node) {
+	return typescript.isStringLiteral(node) || typescript.isNoSubstitutionTemplateLiteral(node);
+}
+function propertyKeyName$1(property) {
+	if (!typescript.isPropertyAssignment(property) && !typescript.isShorthandPropertyAssignment(property)) return null;
+	const key = property.name;
+	if (typescript.isIdentifier(key) || typescript.isStringLiteral(key)) return key.text;
+	return null;
+}
+function findProperty$1(object, name) {
+	return object.properties.filter((property) => typescript.isPropertyAssignment(property)).find((property) => propertyKeyName$1(property) === name);
+}
+function readStringArray(initializer) {
+	if (!initializer || !typescript.isArrayLiteralExpression(initializer)) return [];
+	return initializer.elements.map((element) => isStringLiteralLike(element) ? element.text : null).filter((value) => value !== null);
+}
+function readStringEntries(initializer, sourceFile) {
+	if (!initializer || !typescript.isArrayLiteralExpression(initializer)) return [];
+	return initializer.elements.map((element) => {
+		if (!isStringLiteralLike(element)) return null;
+		const leadingComment = leadingCommentTextFor(sourceFile, element);
+		return leadingComment === void 0 ? { value: element.text } : {
+			value: element.text,
+			leadingComment
+		};
+	}).filter((entry) => entry !== null);
+}
+function readStringOrArray(initializer) {
+	if (!initializer) return [];
+	if (isStringLiteralLike(initializer)) return [initializer.text];
+	return readStringArray(initializer);
+}
+function readStringOrEntries(initializer, sourceFile) {
+	if (!initializer) return [];
+	if (isStringLiteralLike(initializer)) return [{ value: initializer.text }];
+	return readStringEntries(initializer, sourceFile);
+}
+function readGlobalValue$1(initializer) {
+	if (isStringLiteralLike(initializer)) return { value: initializer.text };
+	if (initializer.kind === typescript.SyntaxKind.TrueKeyword) return { value: true };
+	if (initializer.kind === typescript.SyntaxKind.FalseKeyword) return { value: false };
+	if (typescript.isNumericLiteral(initializer)) return { value: Number(initializer.text) };
+	return null;
+}
+function readGlobalsObject$1(initializer) {
+	if (!initializer || !typescript.isObjectLiteralExpression(initializer)) return;
+	const entries = [];
+	initializer.properties.forEach((property) => {
+		if (!typescript.isPropertyAssignment(property)) return;
+		const name = propertyKeyName$1(property);
+		if (name === null) return;
+		const wrapper = readGlobalValue$1(property.initializer);
+		if (wrapper === null) return;
+		entries.push([name, wrapper.value]);
+	});
+	if (entries.length === 0) return;
+	return Object.fromEntries(entries);
+}
+function readGlobalsTokens$1(initializer, sourceFile) {
+	if (!initializer || !typescript.isObjectLiteralExpression(initializer)) return;
+	const tokens = [];
+	initializer.properties.forEach((property) => {
+		if (typescript.isSpreadAssignment(property)) {
+			tokens.push({
+				kind: "spread",
+				raw: property.expression.getText(sourceFile)
+			});
+			return;
+		}
+		if (!typescript.isPropertyAssignment(property)) return;
+		const name = propertyKeyName$1(property);
+		if (name === null) return;
+		const wrapper = readGlobalValue$1(property.initializer);
+		if (wrapper === null) return;
+		tokens.push({
+			kind: "named",
+			key: name,
+			value: wrapper.value
+		});
+	});
+	return tokens.length > 0 ? tokens : void 0;
+}
+function readPluginsArray(initializer) {
+	if (!initializer) return [];
+	if (typescript.isArrayLiteralExpression(initializer)) return readStringArray(initializer);
+	if (typescript.isObjectLiteralExpression(initializer)) return initializer.properties.map(propertyKeyName$1).filter((name) => name !== null);
+	return [];
+}
+function readEnvBoolean(value) {
+	if (value.kind === typescript.SyntaxKind.TrueKeyword) return true;
+	if (value.kind === typescript.SyntaxKind.FalseKeyword) return false;
+	if (typescript.isNumericLiteral(value)) return Number(value.text) !== 0;
+	if (isStringLiteralLike(value)) return value.text.length > 0;
+	return false;
+}
+function readEnvFromInitializer(initializer) {
+	const env = {
+		browser: false,
+		node: false,
+		jest: false,
+		jestGlobals: false
+	};
+	if (!initializer || !typescript.isObjectLiteralExpression(initializer)) return env;
+	initializer.properties.forEach((property) => {
+		if (!typescript.isPropertyAssignment(property)) return;
+		const name = propertyKeyName$1(property);
+		if (!readEnvBoolean(property.initializer)) return;
+		if (name === "browser") env.browser = true;
+		else if (name === "node") env.node = true;
+		else if (name === "jest") env.jest = true;
+		else if (name === "jest/globals") env.jestGlobals = true;
+	});
+	return env;
+}
+function classifyExtendValue(raw) {
+	if (raw.startsWith("@useinsider/eslint-config")) {
+		const slashIndex = raw.indexOf("/", 25);
+		return {
+			raw,
+			kind: "insider",
+			insiderPreset: slashIndex >= 0 ? raw.slice(slashIndex + 1) : ""
+		};
+	}
+	if (raw.startsWith("plugin:vue/")) return {
+		raw,
+		kind: "vue",
+		vueMajor: raw.slice(11).startsWith("vue2-") ? 2 : 3
+	};
+	if (raw.startsWith("plugin:jest/")) return {
+		raw,
+		kind: "jest"
+	};
+	if (raw.startsWith("plugin:jsdoc/")) return {
+		raw,
+		kind: "jsdoc"
+	};
+	if (raw === "airbnb" || raw === "airbnb-base" || raw.startsWith("airbnb-")) return {
+		raw,
+		kind: "airbnb"
+	};
+	return {
+		raw,
+		kind: "other"
+	};
+}
+function readExtends(initializer) {
+	if (!initializer) return [];
+	if (isStringLiteralLike(initializer)) return [classifyExtendValue(initializer.text)];
+	return readStringArray(initializer).map(classifyExtendValue);
+}
+function readParserMarker(initializer) {
+	if (!initializer || !isStringLiteralLike(initializer)) return false;
+	return initializer.text.includes("typescript-eslint");
+}
+function readParserOptions(initializer, env) {
+	const options = {};
+	let parserMarker = false;
+	if (!initializer || !typescript.isObjectLiteralExpression(initializer)) return {
+		options,
+		parserMarker
+	};
+	const projectProperty = findProperty$1(initializer, "project");
+	if (projectProperty) {
+		const project = readStringOrArray(projectProperty.initializer);
+		if (project.length > 0) options.project = project;
+	}
+	const parserProperty = findProperty$1(initializer, "parser");
+	if (parserProperty && readParserMarker(parserProperty.initializer)) parserMarker = true;
+	return {
+		options,
+		parserMarker
+	};
+}
+function extractGlobalComponents$1(rulesNode, sourceFile) {
+	const rule = findProperty$1(rulesNode, "vue/no-undef-components");
+	if (!rule || !typescript.isArrayLiteralExpression(rule.initializer)) return;
+	const [, optionsNode] = rule.initializer.elements;
+	if (!optionsNode || !typescript.isObjectLiteralExpression(optionsNode)) return;
+	const ignorePatterns = findProperty$1(optionsNode, "ignorePatterns");
+	if (!ignorePatterns) return;
+	const values = readStringEntries(ignorePatterns.initializer, sourceFile);
+	return values.length > 0 ? values : void 0;
+}
+function detectSpellCheckerOff(rulesNode) {
+	const rule = findProperty$1(rulesNode, "@cspell/spellchecker");
+	if (!rule) return false;
+	return isStringLiteralLike(rule.initializer) && rule.initializer.text === "off";
+}
+function resolveSpreadKeyCount(expression, context) {
+	if (!typescript.isIdentifier(expression)) return null;
+	const target = context.constantRulesObjects.get(expression.text);
+	if (!target) return null;
+	const keys = /* @__PURE__ */ new Set();
+	target.properties.forEach((property) => {
+		const name = propertyKeyName$1(property);
+		if (name !== null && name !== "vue/no-undef-components" && name !== "@cspell/spellchecker") keys.add(name);
+	});
+	return keys.size;
+}
+function readRulesBlock$1(rulesPropertyInitializer, context) {
+	const block = {
+		customRuleCount: 0,
+		spellCheckerOff: false,
+		unresolvedSpreads: []
+	};
+	if (!rulesPropertyInitializer || !typescript.isObjectLiteralExpression(rulesPropertyInitializer)) return block;
+	block.globalComponents = extractGlobalComponents$1(rulesPropertyInitializer, context.sourceFile);
+	block.spellCheckerOff = detectSpellCheckerOff(rulesPropertyInitializer);
+	rulesPropertyInitializer.properties.forEach((property) => {
+		if (typescript.isPropertyAssignment(property)) {
+			const name = propertyKeyName$1(property);
+			if (name === null || name === "vue/no-undef-components" || name === "@cspell/spellchecker") return;
+			block.customRuleCount += 1;
+			return;
+		}
+		if (typescript.isSpreadAssignment(property)) {
+			const resolved = resolveSpreadKeyCount(property.expression, context);
+			if (resolved === null) {
+				const identifierName = typescript.isIdentifier(property.expression) ? property.expression.text : "<expr>";
+				block.unresolvedSpreads.push(identifierName);
+				return;
+			}
+			block.customRuleCount += resolved;
+		}
+	});
+	return block;
+}
+function collectConstantObjects(sourceFile) {
+	const map = /* @__PURE__ */ new Map();
+	sourceFile.statements.forEach((statement) => {
+		if (!typescript.isVariableStatement(statement)) return;
+		statement.declarationList.declarations.forEach((declaration) => {
+			if (!typescript.isIdentifier(declaration.name) || !declaration.initializer) return;
+			if (typescript.isObjectLiteralExpression(declaration.initializer)) map.set(declaration.name.text, declaration.initializer);
+		});
+	});
+	return map;
+}
+function assignCommentIfPresent(target, key, comment) {
+	if (comment !== void 0) target[key] = comment;
+}
+function collectBlockFieldComments(object, parserOptionsProperty, rulesProperty, rulesBlock, sourceFile) {
+	const fieldComments = {};
+	const filesProperty = findProperty$1(object, "files");
+	if (filesProperty) assignCommentIfPresent(fieldComments, "files", leadingCommentTextFor(sourceFile, filesProperty));
+	if (parserOptionsProperty && typescript.isObjectLiteralExpression(parserOptionsProperty.initializer)) {
+		const projectProperty = findProperty$1(parserOptionsProperty.initializer, "project");
+		if (projectProperty) assignCommentIfPresent(fieldComments, "project", leadingCommentTextFor(sourceFile, projectProperty));
+	}
+	const globalsProperty = findProperty$1(object, "globals");
+	if (globalsProperty) assignCommentIfPresent(fieldComments, "globals", leadingCommentTextFor(sourceFile, globalsProperty));
+	if (rulesProperty && rulesBlock.globalComponents) assignCommentIfPresent(fieldComments, "globalComponents", leadingCommentTextFor(sourceFile, rulesProperty));
+	return Object.keys(fieldComments).length > 0 ? fieldComments : void 0;
+}
+function readSharedBlockFields(input) {
+	const { object, line, context } = input;
+	const extendsList = readExtends(findProperty$1(object, "extends")?.initializer);
+	const env = readEnvFromInitializer(findProperty$1(object, "env")?.initializer);
+	const parserOptionsProperty = findProperty$1(object, "parserOptions");
+	const parserOptionsResult = readParserOptions(parserOptionsProperty?.initializer, env);
+	const parserProperty = findProperty$1(object, "parser");
+	const parserMarker = parserOptionsResult.parserMarker || readParserMarker(parserProperty?.initializer);
+	const globalsInit = findProperty$1(object, "globals")?.initializer;
+	const globalsTokens = readGlobalsTokens$1(globalsInit, context.sourceFile);
+	const globals = readGlobalsObject$1(globalsInit);
+	const rulesProperty = findProperty$1(object, "rules");
+	const rulesBlock = readRulesBlock$1(rulesProperty?.initializer, context);
+	const insiderPluginNames = new Set([
+		"vue",
+		"@typescript-eslint",
+		"jsdoc",
+		"import",
+		"jest",
+		"@cspell"
+	]);
+	const customPluginNames = readPluginsArray(findProperty$1(object, "plugins")?.initializer).filter((name) => !insiderPluginNames.has(name));
+	const fieldComments = collectBlockFieldComments(object, parserOptionsProperty, rulesProperty, rulesBlock, context.sourceFile);
+	return {
+		extendsList,
+		env,
+		parserOptions: parserOptionsResult.options,
+		parserMarker,
+		globals,
+		globalsTokens,
+		customPluginNames: customPluginNames.length > 0 ? customPluginNames : void 0,
+		rulesBlock,
+		fieldComments
+	};
+}
+function readOverride(object, context, elementNode) {
+	const line = lineOf$1(context.sourceFile, object);
+	const filesProperty = findProperty$1(object, "files");
+	const files = filesProperty ? readStringOrEntries(filesProperty.initializer, context.sourceFile) : [];
+	if (files.length === 0) {
+		context.warnings.push({
+			kind: "unrecognized-block",
+			line,
+			message: "overrides[] entry missing `files`; skipping"
+		});
+		return null;
+	}
+	const shared = readSharedBlockFields({
+		object,
+		line,
+		context
+	});
+	const leadingComment = leadingCommentTextFor(context.sourceFile, elementNode);
+	const override = {
+		line,
+		files,
+		extends: shared.extendsList,
+		env: shared.env,
+		parserMarker: shared.parserMarker,
+		parserOptions: shared.parserOptions,
+		globals: shared.globals,
+		globalsTokens: shared.globalsTokens,
+		customPluginNames: shared.customPluginNames,
+		rulesBlock: shared.rulesBlock,
+		fieldComments: shared.fieldComments
+	};
+	if (leadingComment !== void 0) override.leadingComment = leadingComment;
+	return override;
+}
+function readOverrides(initializer, context) {
+	if (!initializer || !typescript.isArrayLiteralExpression(initializer)) return [];
+	return initializer.elements.map((element) => typescript.isObjectLiteralExpression(element) ? readOverride(element, context, element) : null).filter((value) => value !== null);
+}
+function matchesPropertyAccess(expression, owner, member) {
+	if (!typescript.isPropertyAccessExpression(expression)) return false;
+	return typescript.isIdentifier(expression.expression) && expression.expression.text === owner && expression.name.text === member;
+}
+function isExportsTarget(expression) {
+	return matchesPropertyAccess(expression, "module", "exports") || matchesPropertyAccess(expression, "exports", "default");
+}
+function findExportObject(sourceFile) {
+	let result = null;
+	sourceFile.statements.forEach((statement) => {
+		if (result !== null) return;
+		if (!typescript.isExpressionStatement(statement)) return;
+		const { expression } = statement;
+		if (!typescript.isBinaryExpression(expression) || expression.operatorToken.kind !== typescript.SyntaxKind.EqualsToken) return;
+		if (!isExportsTarget(expression.left)) return;
+		if (typescript.isObjectLiteralExpression(expression.right)) result = expression.right;
+	});
+	return result;
+}
+function buildRoot(object, context) {
+	const line = lineOf$1(context.sourceFile, object);
+	const shared = readSharedBlockFields({
+		object,
+		line,
+		context
+	});
+	const overrides = readOverrides(findProperty$1(object, "overrides")?.initializer, context);
+	const ignorePatterns = readStringOrEntries(findProperty$1(object, "ignorePatterns")?.initializer, context.sourceFile);
+	const settingsProperty = findProperty$1(object, "settings");
+	return {
+		line,
+		extends: shared.extendsList,
+		env: shared.env,
+		parserMarker: shared.parserMarker,
+		parserOptions: shared.parserOptions,
+		globals: shared.globals,
+		globalsTokens: shared.globalsTokens,
+		customPluginNames: shared.customPluginNames,
+		rulesBlock: shared.rulesBlock,
+		overrides,
+		ignorePatterns,
+		hasSettings: Boolean(settingsProperty),
+		fieldComments: shared.fieldComments
+	};
+}
+function parseEslintrc(source, filePath) {
+	const sourceFile = typescript.createSourceFile(filePath, source, typescript.ScriptTarget.Latest, true);
+	const warnings = [];
+	const context = {
+		sourceFile,
+		warnings,
+		constantRulesObjects: collectConstantObjects(sourceFile)
+	};
+	const exportObject = findExportObject(sourceFile);
+	if (!exportObject) return {
+		found: false,
+		root: null,
+		warnings
+	};
+	return {
+		found: true,
+		root: buildRoot(exportObject, context),
+		warnings
+	};
+}
+//#endregion
+//#region src/cli/migrate/globalsFolding.ts
+var FOLDABLE_ENVS = [
+	"jest",
+	"vitest",
+	"jquery",
+	"serviceworker",
+	"worker",
+	"webextensions",
+	"node",
+	"browser"
+];
+var HIGH_THRESHOLD_ENVS = new Set(["node", "browser"]);
+function normalizeGlobalValue(value) {
+	if (value === true || value === "writable" || value === "writeable") return "writable";
+	if (value === "off") return "off";
+	return "readonly";
+}
+function envEntries(env) {
+	return globals.default[env];
+}
+function envHasName(env, name) {
+	return name in envEntries(env);
+}
+function envValueFor(env, name) {
+	const entries = envEntries(env);
+	if (!(name in entries)) return null;
+	return normalizeGlobalValue(entries[name]);
+}
+var SPREAD_PATTERN = /^globals\.([A-Za-z_$][\w$]*)$/;
+function spreadEnvKey(raw) {
+	const match = SPREAD_PATTERN.exec(raw.trim());
+	if (!match) return null;
+	const [, key] = match;
+	return FOLDABLE_ENVS.includes(key) ? key : null;
+}
+function foldGlobalsTokens(input) {
+	const preservedSpreads = [];
+	const preservedSpreadEnvs = /* @__PURE__ */ new Set();
+	const namedTokens = [];
+	input.forEach((token) => {
+		if (token.kind === "spread") {
+			preservedSpreads.push({ ...token });
+			const envKey = spreadEnvKey(token.raw);
+			if (envKey) preservedSpreadEnvs.add(envKey);
+			return;
+		}
+		namedTokens.push({ ...token });
+	});
+	const remaining = /* @__PURE__ */ new Map();
+	const namedOrder = [];
+	namedTokens.forEach((token) => {
+		if (!remaining.has(token.key)) namedOrder.push(token.key);
+		remaining.set(token.key, token);
+	});
+	const syntheticSpreads = [];
+	const addedSpreadEnvs = [];
+	FOLDABLE_ENVS.forEach((env) => {
+		if (preservedSpreadEnvs.has(env)) {
+			namedOrder.forEach((name) => {
+				const named = remaining.get(name);
+				if (!named) return;
+				const envValue = envValueFor(env, name);
+				if (envValue === null) return;
+				if (envValue !== normalizeGlobalValue(named.value)) return;
+				remaining.delete(name);
+			});
+			return;
+		}
+		const matches = [];
+		namedOrder.forEach((name) => {
+			const named = remaining.get(name);
+			if (!named) return;
+			if (!envHasName(env, name)) return;
+			const envValue = envValueFor(env, name);
+			if (envValue === null) return;
+			if (envValue !== normalizeGlobalValue(named.value)) return;
+			matches.push(name);
+		});
+		const threshold = HIGH_THRESHOLD_ENVS.has(env) ? 3 : 1;
+		if (matches.length < threshold) return;
+		matches.forEach((name) => remaining.delete(name));
+		syntheticSpreads.push({
+			kind: "spread",
+			raw: `globals.${env}`
+		});
+		addedSpreadEnvs.push(env);
+	});
+	const finalNamed = namedOrder.map((name) => remaining.get(name)).filter((token) => token !== void 0).map((token) => ({ ...token }));
+	return {
+		tokens: [
+			...syntheticSpreads,
+			...preservedSpreads,
+			...finalNamed
+		],
+		addedSpreadEnvs
+	};
+}
+//#endregion
+//#region src/cli/migrate/eslintrc/transform.ts
+var presetToScope$1 = {
+	javascript: "javascript",
+	"javascript-dom": "javascriptDom",
+	"javascript-node": "javascriptNode",
+	typescript: "typescript",
+	"typescript-dom": "typescriptDom",
+	"typescript-node": "typescriptNode",
+	vue2: "vue2",
+	vue3: "vue3",
+	"vue2-typescript": "vue2Typescript",
+	"vue3-typescript": "vue3Typescript",
+	jest: "jest",
+	vitest: "vitest",
+	"jsdoc-based-ts": "jsdocBasedTs"
+};
+var tsScopes$1 = new Set([
+	"typescript",
+	"typescriptDom",
+	"typescriptNode",
+	"vue2Typescript",
+	"vue3Typescript",
+	"jsdocBasedTs"
+]);
+var vueScopes$1 = new Set([
+	"vue2",
+	"vue3",
+	"vue2Typescript",
+	"vue3Typescript"
+]);
+var defaultJestGlob = "**/*.{test,spec}.{ts,tsx,js,jsx,vue}";
+function hasVueExtend(extendsList) {
+	return extendsList.some((extend) => extend.kind === "vue");
+}
+function hasJestExtend(extendsList) {
+	return extendsList.some((extend) => extend.kind === "jest");
+}
+function inferVueMajor(extendsList) {
+	if (extendsList.find((extend) => extend.kind === "vue")?.vueMajor === 2) return 2;
+	return 3;
+}
+function mapVueScope(vueMajor, tsMarker) {
+	if (vueMajor === 2) return tsMarker ? "vue2Typescript" : "vue2";
+	return tsMarker ? "vue3Typescript" : "vue3";
+}
+function warnEnvBothBrowserAndNode(env, line, warnings) {
+	if (!(env.browser && env.node)) return;
+	if (warnings.some((warning) => warning.kind === "env-both-browser-and-node")) return;
+	warnings.push({
+		kind: "env-both-browser-and-node",
+		line,
+		message: "env.browser and env.node both true — defaulting to Dom scope"
+	});
+}
+function inferPrimaryScope(input) {
+	const { env, extendsList, parserMarker, line, warnings } = input;
+	const jestMarker = env.jest || env.jestGlobals || hasJestExtend(extendsList);
+	warnEnvBothBrowserAndNode(env, line, warnings);
+	if (hasVueExtend(extendsList)) {
+		const vueMajor = inferVueMajor(extendsList);
+		return {
+			primary: mapVueScope(vueMajor, parserMarker),
+			addJest: jestMarker,
+			vueMajor
+		};
+	}
+	if (env.browser) return {
+		primary: parserMarker ? "typescriptDom" : "javascriptDom",
+		addJest: jestMarker
+	};
+	if (env.node) return {
+		primary: parserMarker ? "typescriptNode" : "javascriptNode",
+		addJest: jestMarker
+	};
+	return {
+		primary: null,
+		addJest: jestMarker
+	};
+}
+function freshConfig$1() {
+	return {
+		ignores: [],
+		scopes: /* @__PURE__ */ new Map(),
+		strictGlobs: [],
+		strictWholeFile: false,
+		spellChecker: { ignoredPaths: [] },
+		configFiles: []
+	};
+}
+function appendScope$1(config, scope, entry) {
+	const existing = config.scopes.get(scope);
+	if (existing) existing.push(entry);
+	else config.scopes.set(scope, [entry]);
+}
+function mergeGlobals(base, extra) {
+	if (!base && !extra) return;
+	const merged = { ...base ?? {} };
+	if (extra) Object.entries(extra).forEach(([key, value]) => {
+		if (!(key in merged)) merged[key] = value;
+	});
+	return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function applyTsconfig(entry, scope, perBlockProject, fallbackProject) {
+	if (!tsScopes$1.has(scope)) return;
+	const project = perBlockProject && perBlockProject.length > 0 ? perBlockProject : fallbackProject;
+	if (project && project.length > 0) entry.tsconfigPaths = toEntries(project);
+}
+function applyGlobalComponents(entry, scope, globalComponents) {
+	if (!vueScopes$1.has(scope) || !globalComponents || globalComponents.length === 0) return;
+	entry.globalComponents = cloneEntries(globalComponents);
+}
+function mapEslintrcFieldComments(incoming, scope) {
+	if (!incoming) return;
+	const result = {};
+	if (incoming.files !== void 0) result.files = incoming.files;
+	if (incoming.globals !== void 0) result.globals = incoming.globals;
+	if (incoming.project !== void 0 && tsScopes$1.has(scope)) result.tsconfigPaths = incoming.project;
+	if (incoming.globalComponents !== void 0 && vueScopes$1.has(scope)) result.globalComponents = incoming.globalComponents;
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+function mergeGlobalsTokens(base, extra) {
+	if (!base && !extra) return;
+	const merged = [];
+	const seenNamed = /* @__PURE__ */ new Map();
+	const append = (tokens) => {
+		tokens.forEach((token) => {
+			if (token.kind === "spread") {
+				merged.push({ ...token });
+				return;
+			}
+			const seenIndex = seenNamed.get(token.key);
+			if (seenIndex === void 0) {
+				seenNamed.set(token.key, merged.length);
+				merged.push({ ...token });
+				return;
+			}
+			merged[seenIndex] = { ...token };
+		});
+	};
+	if (base) append(base);
+	if (extra) append(extra);
+	return merged.length > 0 ? merged : void 0;
+}
+function buildEntry$1(input) {
+	const entry = { files: cloneEntries(input.files) };
+	applyTsconfig(entry, input.scope, input.perBlockProject, input.fallbackProject);
+	applyGlobalComponents(entry, input.scope, input.globalComponents);
+	const globalsTokens = mergeGlobalsTokens(input.blockGlobalsTokens, input.topLevelGlobalsTokens);
+	if (globalsTokens) entry.globalsTokens = globalsTokens;
+	const globals = mergeGlobals(input.blockGlobals, input.topLevelGlobals);
+	if (globals) entry.globals = globals;
+	const fieldComments = mapEslintrcFieldComments(input.fieldComments, input.scope);
+	if (fieldComments) entry.fieldComments = fieldComments;
+	return entry;
+}
+function collectInsiderPresets(extendsList) {
+	return extendsList.filter((extend) => extend.kind === "insider" && extend.insiderPreset).map((extend) => extend.insiderPreset ?? "");
+}
+function mapInsiderPreset(preset) {
+	if (preset === "config") return "config";
+	return presetToScope$1[preset] ?? null;
+}
+function captureConfigPresetFiles$1(input, context) {
+	input.files.forEach((file) => {
+		if (!context.config.configFiles.some((existing) => existing.value === file.value)) context.config.configFiles.push({ ...file });
+	});
+}
+function emitInsiderScopes(presets, input, context) {
+	let firstEntry = null;
+	presets.forEach((preset) => {
+		const mapped = mapInsiderPreset(preset);
+		if (mapped === null) {
+			context.warnings.push({
+				kind: "unknown-preset",
+				line: input.line,
+				message: `Unknown @useinsider preset '${preset}' — dropped`
+			});
+			return;
+		}
+		if (mapped === "config") {
+			captureConfigPresetFiles$1(input, context);
+			return;
+		}
+		const entry = buildEntry$1({
+			files: input.files,
+			scope: mapped,
+			perBlockProject: input.perBlockProject,
+			fallbackProject: context.topLevelProject,
+			globalComponents: input.globalComponents,
+			blockGlobals: input.blockGlobals,
+			blockGlobalsTokens: input.blockGlobalsTokens,
+			topLevelGlobals: context.topLevelGlobals,
+			topLevelGlobalsTokens: context.topLevelGlobalsTokens,
+			fieldComments: input.fieldComments
+		});
+		appendScope$1(context.config, mapped, entry);
+		if (!firstEntry) firstEntry = entry;
+	});
+	return firstEntry;
+}
+function emitInferredScopes(input, context) {
+	const inference = inferPrimaryScope({
+		env: input.env,
+		extendsList: input.extendsList,
+		parserMarker: input.parserMarker,
+		line: input.line,
+		warnings: context.warnings
+	});
+	let firstEntry = null;
+	if (inference.primary) {
+		const entry = buildEntry$1({
+			files: input.files,
+			scope: inference.primary,
+			perBlockProject: input.perBlockProject,
+			fallbackProject: context.topLevelProject,
+			globalComponents: input.globalComponents,
+			blockGlobals: input.blockGlobals,
+			blockGlobalsTokens: input.blockGlobalsTokens,
+			topLevelGlobals: context.topLevelGlobals,
+			topLevelGlobalsTokens: context.topLevelGlobalsTokens,
+			fieldComments: input.fieldComments
+		});
+		appendScope$1(context.config, inference.primary, entry);
+		firstEntry = entry;
+	}
+	if (inference.addJest) {
+		const entry = buildEntry$1({
+			files: [{ value: defaultJestGlob }],
+			scope: "jest",
+			blockGlobals: input.blockGlobals,
+			blockGlobalsTokens: input.blockGlobalsTokens,
+			topLevelGlobals: context.topLevelGlobals,
+			topLevelGlobalsTokens: context.topLevelGlobalsTokens
+		});
+		appendScope$1(context.config, "jest", entry);
+		if (!firstEntry) firstEntry = entry;
+	}
+	return firstEntry;
+}
+function recordDroppedRules(input, context) {
+	if (input.rulesCount > 0) {
+		context.droppedRules += input.rulesCount;
+		context.droppedBlocks += 1;
+	}
+	input.unresolvedSpreads.forEach((name) => {
+		context.warnings.push({
+			kind: "unresolved-rules-spread",
+			line: input.line,
+			message: `Could not resolve identifier '${name}' inside rules; dropping`
+		});
+	});
+}
+function applySpellChecker(input, context) {
+	if (!input.spellCheckerOff) return;
+	input.files.forEach((file) => {
+		if (!context.config.spellChecker.ignoredPaths.some((existing) => existing.value === file.value)) context.config.spellChecker.ignoredPaths.push({ ...file });
+	});
+}
+function recordDroppedPlugins(input, context) {
+	if (!input.customPluginNames || input.customPluginNames.length === 0) return;
+	input.customPluginNames.forEach((name) => context.droppedPlugins.add(name));
+	context.droppedPluginEntries += 1;
+}
+function processBlock(input, context) {
+	recordDroppedRules(input, context);
+	recordDroppedPlugins(input, context);
+	applySpellChecker(input, context);
+	const insiderPresets = collectInsiderPresets(input.extendsList);
+	const firstEntry = insiderPresets.length > 0 ? emitInsiderScopes(insiderPresets, input, context) : emitInferredScopes(input, context);
+	if (firstEntry && input.leadingComment !== void 0) firstEntry.leadingComment = input.leadingComment;
+	return firstEntry !== null;
+}
+function blockInputFromRoot(root, defaultFiles) {
+	return {
+		line: root.line,
+		files: defaultFiles,
+		extendsList: root.extends,
+		env: root.env,
+		parserMarker: root.parserMarker,
+		perBlockProject: root.parserOptions.project,
+		globalComponents: root.rulesBlock.globalComponents,
+		spellCheckerOff: root.rulesBlock.spellCheckerOff,
+		blockGlobals: void 0,
+		blockGlobalsTokens: void 0,
+		customPluginNames: root.customPluginNames,
+		rulesCount: root.rulesBlock.customRuleCount,
+		unresolvedSpreads: root.rulesBlock.unresolvedSpreads,
+		fieldComments: root.fieldComments
+	};
+}
+function isBareOverride(override) {
+	const noExtends = override.extends.length === 0;
+	const noEnv = !override.env.browser && !override.env.node && !override.env.jest && !override.env.jestGlobals;
+	const noParserMarker = !override.parserMarker;
+	return noExtends && noEnv && noParserMarker;
+}
+function blockInputFromOverride(override, root) {
+	const inherit = isBareOverride(override);
+	return {
+		line: override.line,
+		files: override.files,
+		extendsList: inherit ? root.extends : override.extends,
+		env: inherit ? root.env : override.env,
+		parserMarker: inherit ? root.parserMarker : override.parserMarker,
+		perBlockProject: override.parserOptions.project,
+		globalComponents: override.rulesBlock.globalComponents,
+		spellCheckerOff: override.rulesBlock.spellCheckerOff,
+		blockGlobals: override.globals,
+		blockGlobalsTokens: override.globalsTokens,
+		customPluginNames: override.customPluginNames,
+		rulesCount: override.rulesBlock.customRuleCount,
+		unresolvedSpreads: override.rulesBlock.unresolvedSpreads,
+		leadingComment: override.leadingComment,
+		fieldComments: override.fieldComments
+	};
+}
+function defaultRootFiles(root) {
+	if (root.env.browser && hasVueExtend(root.extends)) return toEntries(["**/*.{js,jsx,ts,tsx,vue}"]);
+	if (root.parserMarker) return toEntries(["**/*.{ts,tsx}"]);
+	return toEntries(["**/*.{js,jsx,cjs,mjs}"]);
+}
+function applyIgnorePatterns(root, config) {
+	root.ignorePatterns.forEach((ignore) => {
+		if (!config.ignores.some((existing) => existing.value === ignore.value)) config.ignores.push({ ...ignore });
+	});
+}
+function recordSettingsWarning(root, warnings) {
+	if (root.hasSettings) warnings.push({
+		kind: "dropped-settings",
+		line: root.line,
+		message: "Dropped legacy `settings` block — flat config does not support this surface"
+	});
+}
+function consolidateExtendsWarning(extendKinds, rawDropped, warnings) {
+	if (rawDropped.size === 0) return;
+	const list = [...rawDropped].sort((left, right) => left.localeCompare(right)).join(", ");
+	warnings.push({
+		kind: "dropped-extends",
+		message: `Dropped non-@useinsider extends: ${list}`
+	});
+}
+function recordNoInsiderWarning(hasInsiderExtend, warnings) {
+	if (hasInsiderExtend) return;
+	warnings.push({
+		kind: "no-insider-extends",
+		message: "Source did not extend any @useinsider/eslint-config preset — output is a best-effort inference. Custom rules were dropped; review the generated config and adjust scopes as needed."
+	});
+}
+function collectExtendKinds(root) {
+	const kinds = /* @__PURE__ */ new Set();
+	const rawDropped = /* @__PURE__ */ new Set();
+	let hasInsider = false;
+	const visit = (list) => {
+		list.forEach((extend) => {
+			kinds.add(extend.kind);
+			if (extend.kind === "insider") {
+				hasInsider = true;
+				return;
+			}
+			rawDropped.add(extend.raw);
+		});
+	};
+	visit(root.extends);
+	root.overrides.forEach((override) => visit(override.extends));
+	return {
+		kinds,
+		rawDropped,
+		hasInsider
+	};
+}
+function formatDroppedRulesMessage$1(count, blocks) {
+	return `Dropped ${count} custom ${count === 1 ? "rule override" : "rule overrides"} across ${blocks} ${blocks === 1 ? "block" : "blocks"}`;
+}
+function tokensFromRecord$2(globals) {
+	return Object.entries(globals).map(([key, value]) => ({
+		kind: "named",
+		key,
+		value
+	}));
+}
+function resolveBaseTokens$1(entry) {
+	if (entry.globalsTokens && entry.globalsTokens.length > 0) return entry.globalsTokens;
+	if (entry.globals && Object.keys(entry.globals).length > 0) return tokensFromRecord$2(entry.globals);
+}
+function applyGlobalsFolding$1(config) {
+	let anySyntheticEmitted = false;
+	config.scopes.forEach((entries) => {
+		entries.forEach((entry) => {
+			const baseTokens = resolveBaseTokens$1(entry);
+			if (!baseTokens) return;
+			const { tokens, addedSpreadEnvs } = foldGlobalsTokens(baseTokens);
+			if (addedSpreadEnvs.length > 0) anySyntheticEmitted = true;
+			entry.globalsTokens = tokens;
+			const namedRecord = {};
+			tokens.forEach((token) => {
+				if (token.kind === "named") namedRecord[token.key] = token.value;
+			});
+			entry.globals = Object.keys(namedRecord).length > 0 ? namedRecord : void 0;
+		});
+	});
+	return anySyntheticEmitted;
+}
+function buildPreservedImports(emittedSyntheticSpread) {
+	if (!emittedSyntheticSpread) return [];
+	return [{
+		raw: "import globals from 'globals';",
+		moduleSpecifier: "globals"
+	}];
+}
+function transformEslintrcToV2(parseResult) {
+	const config = freshConfig$1();
+	const warnings = [...parseResult.warnings];
+	if (!parseResult.root) return {
+		config,
+		silenceRulesCalls: [],
+		needsSilenceRulesImport: false,
+		preservedImports: [],
+		warnings,
+		droppedRuleCount: 0,
+		droppedRuleBlockCount: 0
+	};
+	const { root } = parseResult;
+	const context = {
+		config,
+		warnings,
+		topLevelGlobals: root.globals,
+		topLevelGlobalsTokens: root.globalsTokens,
+		topLevelProject: root.parserOptions.project,
+		droppedRules: 0,
+		droppedBlocks: 0,
+		droppedPlugins: /* @__PURE__ */ new Set(),
+		droppedPluginEntries: 0
+	};
+	applyIgnorePatterns(root, config);
+	recordSettingsWarning(root, warnings);
+	if (root.overrides.length > 0) {
+		root.overrides.forEach((override) => {
+			processBlock(blockInputFromOverride(override, root), context);
+		});
+		if (root.rulesBlock.customRuleCount > 0 || root.rulesBlock.unresolvedSpreads.length > 0) recordDroppedRules(blockInputFromRoot(root, defaultRootFiles(root)), context);
+	} else processBlock(blockInputFromRoot(root, defaultRootFiles(root)), context);
+	if (context.droppedRules > 0) warnings.push({
+		kind: "dropped-rules",
+		message: formatDroppedRulesMessage$1(context.droppedRules, context.droppedBlocks)
+	});
+	const { kinds, rawDropped, hasInsider } = collectExtendKinds(root);
+	consolidateExtendsWarning(kinds, rawDropped, warnings);
+	recordNoInsiderWarning(hasInsider, warnings);
+	if (context.droppedPluginEntries > 0 && context.droppedPlugins.size > 0) {
+		const sorted = [...context.droppedPlugins].sort((left, right) => left.localeCompare(right));
+		warnings.push({
+			kind: "dropped-plugins",
+			message: `Dropped custom plugins on ${context.droppedPluginEntries} entries: ${sorted.join(", ")}`
+		});
+	}
+	return {
+		config,
+		silenceRulesCalls: [],
+		needsSilenceRulesImport: false,
+		preservedImports: buildPreservedImports(applyGlobalsFolding$1(config)),
+		warnings,
+		droppedRuleCount: context.droppedRules,
+		droppedRuleBlockCount: context.droppedBlocks
+	};
+}
+//#endregion
+//#region src/cli/migrate/parse.ts
+var knownPresets = new Set([
+	"config",
+	"javascript",
+	"javascript-dom",
+	"javascript-node",
+	"typescript",
+	"typescript-dom",
+	"typescript-node",
+	"vue2",
+	"vue2-typescript",
+	"vue3",
+	"vue3-typescript",
+	"jest",
+	"vitest",
+	"jsdoc-based-ts",
+	"strict",
+	"dom",
+	"node"
+]);
+function lineOf(sourceFile, node) {
+	const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+	return line + 1;
+}
+function unwrapTypeCasts(expression) {
+	let current = expression;
+	while (typescript.isParenthesizedExpression(current) || typescript.isAsExpression(current) || typescript.isTypeAssertionExpression(current) || typescript.isSatisfiesExpression(current)) current = current.expression;
+	return current;
+}
+function unwrapAwait(expression) {
+	const peeled = unwrapTypeCasts(expression);
+	if (typescript.isAwaitExpression(peeled)) return unwrapTypeCasts(peeled.expression);
+	return peeled;
+}
+function isStringLiteral(node) {
+	return typescript.isStringLiteral(node) || typescript.isNoSubstitutionTemplateLiteral(node);
+}
+function readStringLiteralArray(node) {
+	if (!node || !typescript.isArrayLiteralExpression(node)) return;
+	const items = node.elements.map((element) => isStringLiteral(element) ? element.text : null);
+	if (items.some((item) => item === null)) return;
+	return items;
+}
+function readStringLiteralEntries(node, sourceFile) {
+	if (!node || !typescript.isArrayLiteralExpression(node)) return;
+	const entries = node.elements.map((element) => {
+		if (!isStringLiteral(element)) return null;
+		const leadingComment = leadingCommentTextFor(sourceFile, element);
+		return leadingComment === void 0 ? { value: element.text } : {
+			value: element.text,
+			leadingComment
+		};
+	});
+	if (entries.some((entry) => entry === null)) return;
+	return entries;
+}
+function propertyKeyName(property) {
+	if (!typescript.isPropertyAssignment(property)) return null;
+	const key = property.name;
+	if (typescript.isIdentifier(key) || typescript.isStringLiteral(key)) return key.text;
+	return null;
+}
+function findProperty(object, name) {
+	return object.properties.filter((property) => typescript.isPropertyAssignment(property)).find((property) => propertyKeyName(property) === name);
+}
+function readGlobalValue(initializer) {
+	if (isStringLiteral(initializer)) return { value: initializer.text };
+	if (initializer.kind === typescript.SyntaxKind.TrueKeyword) return { value: true };
+	if (initializer.kind === typescript.SyntaxKind.FalseKeyword) return { value: false };
+	if (typescript.isNumericLiteral(initializer)) return { value: Number(initializer.text) };
+	return null;
+}
+function readGlobalsObject(node) {
+	if (!node || !typescript.isObjectLiteralExpression(node)) return;
+	const entries = node.properties.map((property) => {
+		if (!typescript.isPropertyAssignment(property)) return null;
+		const name = propertyKeyName(property);
+		if (name === null) return null;
+		const valueWrapper = readGlobalValue(property.initializer);
+		if (valueWrapper === null) return null;
+		return [name, valueWrapper.value];
+	});
+	if (entries.some((entry) => entry === null)) return;
+	return Object.fromEntries(entries);
+}
+function readGlobalsTokens(node, sourceFile) {
+	if (!node || !typescript.isObjectLiteralExpression(node)) return;
+	const tokens = [];
+	node.properties.forEach((property) => {
+		if (typescript.isSpreadAssignment(property)) {
+			tokens.push({
+				kind: "spread",
+				raw: property.expression.getText(sourceFile)
+			});
+			return;
+		}
+		if (!typescript.isPropertyAssignment(property)) return;
+		const name = propertyKeyName(property);
+		if (name === null) return;
+		const valueWrapper = readGlobalValue(property.initializer);
+		if (valueWrapper === null) return;
+		tokens.push({
+			kind: "named",
+			key: name,
+			value: valueWrapper.value
+		});
+	});
+	return tokens.length > 0 ? tokens : void 0;
+}
+function namedTokensToRecord(tokens) {
+	if (!tokens) return;
+	const entries = tokens.filter((token) => token.kind === "named").map((token) => [token.key, token.value]);
+	return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+function extractGlobalComponents(rulesNode, sourceFile) {
+	const rule = findProperty(rulesNode, "vue/no-undef-components");
+	if (!rule || !typescript.isArrayLiteralExpression(rule.initializer)) return;
+	const [, optionsNode] = rule.initializer.elements;
+	if (!optionsNode || !typescript.isObjectLiteralExpression(optionsNode)) return;
+	const ignorePatterns = findProperty(optionsNode, "ignorePatterns");
+	if (!ignorePatterns) return;
+	return readStringLiteralEntries(ignorePatterns.initializer, sourceFile);
+}
+function assignFieldComment(data, field, comment) {
+	if (comment === void 0) return;
+	data.fieldComments = {
+		...data.fieldComments,
+		[field]: comment
+	};
+}
+function countExtraRules(rulesNode) {
+	return rulesNode.properties.filter((property) => {
+		const name = propertyKeyName(property);
+		return name !== null && name !== "vue/no-undef-components";
+	}).length;
+}
+function readParserProject(parserOptions, sourceFile) {
+	const projectProperty = findProperty(parserOptions, "project");
+	if (!projectProperty) return;
+	const { initializer } = projectProperty;
+	if (isStringLiteral(initializer)) return [{ value: initializer.text }];
+	return readStringLiteralEntries(initializer, sourceFile);
+}
+function readParserProjectService(parserOptions) {
+	if (findProperty(parserOptions, "projectService")?.initializer.kind === typescript.SyntaxKind.TrueKeyword) return true;
+}
+function expressionMentionsTsParser(expression, sourceFile) {
+	return expression.getText(sourceFile).includes("@typescript-eslint/parser");
+}
+function readLanguageOptions(languageOptions, data, sourceFile) {
+	const parserOptionsProperty = findProperty(languageOptions, "parserOptions");
+	if (parserOptionsProperty && typescript.isObjectLiteralExpression(parserOptionsProperty.initializer)) {
+		const parserOptions = parserOptionsProperty.initializer;
+		data.parserProject = readParserProject(parserOptions, sourceFile);
+		data.parserProjectService = readParserProjectService(parserOptions);
+	}
+	const parserProperty = findProperty(languageOptions, "parser");
+	if (parserProperty && expressionMentionsTsParser(parserProperty.initializer, sourceFile)) data.parserIsTypescript = true;
+	const globalsProperty = findProperty(languageOptions, "globals");
+	if (globalsProperty) {
+		data.globalsTokens = readGlobalsTokens(globalsProperty.initializer, sourceFile);
+		data.globals = namedTokensToRecord(data.globalsTokens) ?? readGlobalsObject(globalsProperty.initializer);
+	}
+}
+function readPluginNames(pluginsProperty) {
+	if (!typescript.isObjectLiteralExpression(pluginsProperty.initializer)) return [];
+	return pluginsProperty.initializer.properties.map(propertyKeyName).filter((name) => name !== null);
+}
+function readRulesBlock(rulesProperty, data, sourceFile) {
+	if (!typescript.isObjectLiteralExpression(rulesProperty.initializer)) return;
+	const rulesObject = rulesProperty.initializer;
+	data.globalComponents = extractGlobalComponents(rulesObject, sourceFile);
+	data.extraRuleCount = countExtraRules(rulesObject);
+}
+function captureLanguageOptionsComments(languageOptionsObject, data, sourceFile) {
+	const parserOptionsProperty = findProperty(languageOptionsObject, "parserOptions");
+	if (parserOptionsProperty && typescript.isObjectLiteralExpression(parserOptionsProperty.initializer)) {
+		const projectProperty = findProperty(parserOptionsProperty.initializer, "project");
+		if (projectProperty) assignFieldComment(data, "parserProject", leadingCommentTextFor(sourceFile, projectProperty));
+	}
+	const globalsProperty = findProperty(languageOptionsObject, "globals");
+	if (globalsProperty) assignFieldComment(data, "globals", leadingCommentTextFor(sourceFile, globalsProperty));
+}
+function processFilesProperty(configNode, data, sourceFile) {
+	const filesProperty = findProperty(configNode, "files");
+	if (!filesProperty) return;
+	data.files = readStringLiteralEntries(filesProperty.initializer, sourceFile);
+	assignFieldComment(data, "files", leadingCommentTextFor(sourceFile, filesProperty));
+}
+function processIgnoresProperty(configNode, data, sourceFile) {
+	const ignoresProperty = findProperty(configNode, "ignores");
+	if (!ignoresProperty) return;
+	data.ignores = readStringLiteralEntries(ignoresProperty.initializer, sourceFile);
+	assignFieldComment(data, "ignores", leadingCommentTextFor(sourceFile, ignoresProperty));
+}
+function processPluginsProperty(configNode, data) {
+	const pluginsProperty = findProperty(configNode, "plugins");
+	if (!pluginsProperty) return;
+	const pluginNames = readPluginNames(pluginsProperty);
+	if (pluginNames.length > 0) data.customPluginNames = pluginNames;
+}
+function processRulesProperty(configNode, data, sourceFile) {
+	const rulesProperty = findProperty(configNode, "rules");
+	if (!rulesProperty) return;
+	readRulesBlock(rulesProperty, data, sourceFile);
+	if (data.globalComponents !== void 0) assignFieldComment(data, "globalComponents", leadingCommentTextFor(sourceFile, rulesProperty));
+}
+function parseConfigObject(configNode, sourceFile) {
+	const data = { extraRuleCount: 0 };
+	processFilesProperty(configNode, data, sourceFile);
+	processIgnoresProperty(configNode, data, sourceFile);
+	const languageOptionsProperty = findProperty(configNode, "languageOptions");
+	if (languageOptionsProperty && typescript.isObjectLiteralExpression(languageOptionsProperty.initializer)) {
+		readLanguageOptions(languageOptionsProperty.initializer, data, sourceFile);
+		captureLanguageOptionsComments(languageOptionsProperty.initializer, data, sourceFile);
+	}
+	processPluginsProperty(configNode, data);
+	processRulesProperty(configNode, data, sourceFile);
+	return data;
+}
+function mergeRescuedGlobalsTokens(innerTokens, siblingTokens) {
+	if (!innerTokens || innerTokens.length === 0) return siblingTokens.map((token) => ({ ...token }));
+	const innerNamedKeys = /* @__PURE__ */ new Set();
+	innerTokens.forEach((token) => {
+		if (token.kind === "named") innerNamedKeys.add(token.key);
+	});
+	const merged = innerTokens.map((token) => ({ ...token }));
+	siblingTokens.forEach((token) => {
+		if (token.kind === "spread") {
+			merged.push({ ...token });
+			return;
+		}
+		if (innerNamedKeys.has(token.key)) return;
+		merged.push({ ...token });
+		innerNamedKeys.add(token.key);
+	});
+	return merged;
+}
+function applyRescuedGlobals(data, rescued) {
+	if (rescued.globalsTokens && rescued.globalsTokens.length > 0) {
+		data.globalsTokens = mergeRescuedGlobalsTokens(data.globalsTokens, rescued.globalsTokens);
+		data.globals = namedTokensToRecord(data.globalsTokens) ?? data.globals;
+		return true;
+	}
+	if (rescued.globals && Object.keys(rescued.globals).length > 0) {
+		const existingGlobals = data.globals ?? {};
+		data.globals = {
+			...rescued.globals,
+			...existingGlobals
+		};
+		return true;
+	}
+	return false;
+}
+function applyRescuedParserProject(data, rescued) {
+	if (!rescued.parserProject || rescued.parserProject.length === 0) return false;
+	if (data.parserProject && data.parserProject.length > 0) return false;
+	data.parserProject = rescued.parserProject;
+	return true;
+}
+function applyRescuedLanguageOptions(data, rescued) {
+	let rescuedAny = applyRescuedGlobals(data, rescued);
+	rescuedAny = applyRescuedParserProject(data, rescued) || rescuedAny;
+	if (rescued.parserIsTypescript && !data.parserIsTypescript) {
+		data.parserIsTypescript = true;
+		rescuedAny = true;
+	}
+	if (rescued.parserProjectService && data.parserProjectService === void 0) {
+		data.parserProjectService = true;
+		rescuedAny = true;
+	}
+	return rescuedAny;
+}
+function parseSiblingLanguageOptions(callArgument, sourceFile) {
+	const languageOptionsProperty = findProperty(callArgument, "languageOptions");
+	if (!languageOptionsProperty || !typescript.isObjectLiteralExpression(languageOptionsProperty.initializer)) return null;
+	const rescued = { extraRuleCount: 0 };
+	readLanguageOptions(languageOptionsProperty.initializer, rescued, sourceFile);
+	return rescued;
+}
+function mergeSiblingIgnoresIntoData(callArgument, data, sourceFile) {
+	const ignoresProperty = findProperty(callArgument, "ignores");
+	if (!ignoresProperty) return false;
+	const rescuedIgnores = readStringLiteralEntries(ignoresProperty.initializer, sourceFile);
+	if (!rescuedIgnores || rescuedIgnores.length === 0) return false;
+	const existing = data.ignores ?? [];
+	const seen = new Set(existing.map((entry) => entry.value));
+	const additions = [];
+	rescuedIgnores.forEach((entry) => {
+		if (seen.has(entry.value)) return;
+		seen.add(entry.value);
+		additions.push(entry);
+	});
+	if (additions.length === 0) return false;
+	data.ignores = [...existing, ...additions];
+	return true;
+}
+function applySiblingRescues(callArgument, data, sourceFile) {
+	const rescuedSibling = parseSiblingLanguageOptions(callArgument, sourceFile);
+	const rescuedLanguageOptions = rescuedSibling ? applyRescuedLanguageOptions(data, rescuedSibling) : false;
+	const rescuedIgnores = mergeSiblingIgnoresIntoData(callArgument, data, sourceFile);
+	return rescuedLanguageOptions || rescuedIgnores;
+}
+function classifyPresets(presetList, line, warnings) {
+	const presets = [];
+	const unknownPresets = [];
+	presetList.forEach((presetName) => {
+		if (knownPresets.has(presetName)) presets.push(presetName);
+		else {
+			unknownPresets.push(presetName);
+			warnings.push({
+				kind: "unknown-preset",
+				line,
+				message: `Unknown v1 preset '${presetName}' — dropped`
+			});
+		}
+	});
+	return {
+		presets,
+		unknownPresets
+	};
+}
+function parseUseInsiderCall(callExpression, sourceFile, warnings) {
+	const line = lineOf(sourceFile, callExpression);
+	const [firstArgument] = callExpression.arguments;
+	if (!firstArgument || !typescript.isObjectLiteralExpression(firstArgument)) {
+		warnings.push({
+			kind: "unrecognized-block",
+			line,
+			message: "useInsider call without object literal argument; skipping"
+		});
+		return null;
+	}
+	const presetProperty = findProperty(firstArgument, "preset");
+	const configProperty = findProperty(firstArgument, "config");
+	if (!presetProperty) {
+		warnings.push({
+			kind: "unrecognized-block",
+			line,
+			message: "useInsider call missing preset; skipping"
+		});
+		return null;
+	}
+	const presetList = readStringLiteralArray(presetProperty.initializer);
+	if (!presetList) {
+		warnings.push({
+			kind: "unrecognized-block",
+			line,
+			message: "useInsider preset is not a string-literal array; skipping"
+		});
+		return null;
+	}
+	const { presets, unknownPresets } = classifyPresets(presetList, line, warnings);
+	const configData = configProperty && typescript.isObjectLiteralExpression(configProperty.initializer) ? parseConfigObject(configProperty.initializer, sourceFile) : { extraRuleCount: 0 };
+	const rescuedAny = applySiblingRescues(firstArgument, configData, sourceFile);
+	const call = {
+		kind: "useInsiderCall",
+		line,
+		presets,
+		unknownPresets,
+		files: configData.files,
+		ignores: configData.ignores,
+		parserProject: configData.parserProject,
+		parserProjectService: configData.parserProjectService,
+		globals: configData.globals,
+		globalsTokens: configData.globalsTokens,
+		globalComponents: configData.globalComponents,
+		parserIsTypescript: configData.parserIsTypescript,
+		customPluginNames: configData.customPluginNames,
+		extraRuleCount: configData.extraRuleCount,
+		fieldComments: configData.fieldComments
+	};
+	if (rescuedAny) call.rescuedSiblingLanguageOptions = true;
+	return call;
+}
+function tryClassifyIgnoresBlock(objectLiteral, keys, line, sourceFile) {
+	if (keys.length !== 1 || keys[0] !== "ignores") return null;
+	const ignoresProperty = findProperty(objectLiteral, "ignores");
+	const ignores = ignoresProperty ? readStringLiteralEntries(ignoresProperty.initializer, sourceFile) : void 0;
+	if (!ignores) return null;
+	return {
+		kind: "ignoresBlock",
+		line,
+		ignores
+	};
+}
+function isSpellCheckerOffRule(rules) {
+	if (rules.length !== 1) return false;
+	const [onlyRule] = rules;
+	if (!typescript.isPropertyAssignment(onlyRule) || propertyKeyName(onlyRule) !== "@cspell/spellchecker") return false;
+	return isStringLiteral(onlyRule.initializer) && onlyRule.initializer.text === "off";
+}
+function tryClassifySpellCheckerOff(objectLiteral, keys, line, sourceFile) {
+	if (keys.length !== 2 || !keys.includes("files") || !keys.includes("rules")) return null;
+	const filesProperty = findProperty(objectLiteral, "files");
+	const rulesProperty = findProperty(objectLiteral, "rules");
+	const files = filesProperty ? readStringLiteralEntries(filesProperty.initializer, sourceFile) : void 0;
+	if (!files || !rulesProperty || !typescript.isObjectLiteralExpression(rulesProperty.initializer)) return null;
+	if (!isSpellCheckerOffRule(rulesProperty.initializer.properties)) return null;
+	return {
+		kind: "spellCheckerOff",
+		line,
+		files
+	};
+}
+function tryClassifyStandaloneGlobals(objectLiteral, keys, line, sourceFile) {
+	if (!keys.includes("files") || !keys.includes("languageOptions")) return null;
+	const filesProperty = findProperty(objectLiteral, "files");
+	const languageOptionsProperty = findProperty(objectLiteral, "languageOptions");
+	const files = filesProperty ? readStringLiteralEntries(filesProperty.initializer, sourceFile) : void 0;
+	if (!files || !languageOptionsProperty || !typescript.isObjectLiteralExpression(languageOptionsProperty.initializer)) return null;
+	const globalsProperty = findProperty(languageOptionsProperty.initializer, "globals");
+	if (!globalsProperty) return null;
+	const tokens = readGlobalsTokens(globalsProperty.initializer, sourceFile);
+	if (!tokens || tokens.length === 0) return null;
+	return {
+		kind: "standaloneGlobals",
+		line,
+		files,
+		globalsTokens: tokens
+	};
+}
+function classifyObjectElement(objectLiteral, sourceFile, warnings) {
+	const line = lineOf(sourceFile, objectLiteral);
+	const keys = objectLiteral.properties.map(propertyKeyName).filter((name) => name !== null);
+	const ignoresBlock = tryClassifyIgnoresBlock(objectLiteral, keys, line, sourceFile);
+	if (ignoresBlock) return ignoresBlock;
+	const spellCheckerOff = tryClassifySpellCheckerOff(objectLiteral, keys, line, sourceFile);
+	if (spellCheckerOff) return spellCheckerOff;
+	const standaloneGlobals = tryClassifyStandaloneGlobals(objectLiteral, keys, line, sourceFile);
+	if (standaloneGlobals) return standaloneGlobals;
+	warnings.push({
+		kind: "unrecognized-block",
+		line,
+		message: "Unrecognized array element; dropping"
+	});
+	return {
+		kind: "unrecognized",
+		line,
+		snippet: objectLiteral.getText(sourceFile)
+	};
+}
+function tryClassifyUseInsider(unwrapped, sourceFile, warnings, leadingComment) {
+	if (!typescript.isCallExpression(unwrapped)) return;
+	const callee = unwrapped.expression;
+	if (!typescript.isIdentifier(callee) || callee.text !== "useInsider") return;
+	const parsed = parseUseInsiderCall(unwrapped, sourceFile, warnings);
+	if (parsed && leadingComment !== void 0) parsed.leadingComment = leadingComment;
+	return parsed;
+}
+function classifyArrayElement(element, sourceFile, warnings) {
+	const leadingComment = leadingCommentTextFor(sourceFile, element);
+	const unwrapped = unwrapAwait(element);
+	const useInsiderResult = tryClassifyUseInsider(unwrapped, sourceFile, warnings, leadingComment);
+	if (useInsiderResult !== void 0) return useInsiderResult;
+	if (typescript.isObjectLiteralExpression(unwrapped)) {
+		const parsed = classifyObjectElement(unwrapped, sourceFile, warnings);
+		if (leadingComment !== void 0) parsed.leadingComment = leadingComment;
+		return parsed;
+	}
+	const line = lineOf(sourceFile, element);
+	warnings.push({
+		kind: "unrecognized-block",
+		line,
+		message: "Unrecognized array element; dropping"
+	});
+	const unrecognized = {
+		kind: "unrecognized",
+		line,
+		snippet: element.getText(sourceFile)
+	};
+	if (leadingComment !== void 0) unrecognized.leadingComment = leadingComment;
+	return unrecognized;
+}
+function isDefineConfigCall(expression) {
+	return typescript.isCallExpression(expression) && typescript.isIdentifier(expression.expression) && expression.expression.text === "defineConfig";
+}
+function findDefaultExportArray(sourceFile) {
+	const exportExpressions = sourceFile.statements.filter(typescript.isExportAssignment).map((statement) => unwrapTypeCasts(statement.expression));
+	const directArray = exportExpressions.find(typescript.isArrayLiteralExpression);
+	if (directArray) return directArray;
+	const defineConfigCall = exportExpressions.find(isDefineConfigCall);
+	if (!defineConfigCall) return null;
+	const [first] = defineConfigCall.arguments;
+	if (!first) return null;
+	const unwrappedFirst = unwrapTypeCasts(first);
+	if (typescript.isArrayLiteralExpression(unwrappedFirst)) return unwrappedFirst;
+	return null;
+}
+function checkDefineConfigWrap(sourceFile) {
+	return sourceFile.statements.some((statement) => {
+		if (!typescript.isExportAssignment(statement)) return false;
+		const expression = unwrapTypeCasts(statement.expression);
+		return typescript.isCallExpression(expression) && typescript.isIdentifier(expression.expression) && expression.expression.text === "defineConfig";
+	});
+}
+function getModuleSpecifierText(statement) {
+	const { moduleSpecifier } = statement;
+	if (!isStringLiteral(moduleSpecifier)) return null;
+	return moduleSpecifier.text;
+}
+function collectNamedImports(importDeclaration) {
+	const namedBindings = importDeclaration.importClause?.namedBindings;
+	if (!namedBindings || !typescript.isNamedImports(namedBindings)) return [];
+	return namedBindings.elements.map((specifier) => specifier.propertyName?.text ?? specifier.name.text);
+}
+function hasDefaultBinding(importDeclaration) {
+	return Boolean(importDeclaration.importClause?.name);
+}
+var insiderDefaultRewriteTargets = new Set([
+	"useInsider",
+	"silenceRules",
+	"silenceDependencyWarning"
+]);
+function classifyInsiderImport(statement, sourceFile, flags) {
+	collectNamedImports(statement).forEach((name) => {
+		if (name === "useInsider") flags.hasUseInsider = true;
+		if (name === "silenceRules") flags.hasSilenceRules = true;
+	});
+	if (hasDefaultBinding(statement)) {
+		const defaultLocal = statement.importClause?.name?.text ?? "";
+		if (insiderDefaultRewriteTargets.has(defaultLocal)) {
+			if (defaultLocal === "useInsider") flags.hasUseInsider = true;
+			if (defaultLocal === "silenceRules") flags.hasSilenceRules = true;
+			return;
+		}
+		flags.hasUseInsider = true;
+		const line = lineOf(sourceFile, statement);
+		flags.preserved.push({
+			raw: statement.getText(sourceFile),
+			moduleSpecifier: "@useinsider/eslint-config"
+		});
+		flags.warnings.push({
+			kind: "unrecognized-block",
+			line,
+			message: `Unexpected default import '${defaultLocal}' from '@useinsider/eslint-config'; kept literally — review before committing`
+		});
+	}
+}
+function inspectImports(sourceFile) {
+	const flags = {
+		hasUseInsider: false,
+		hasSilenceRules: false,
+		preserved: [],
+		warnings: []
+	};
+	sourceFile.statements.forEach((statement) => {
+		if (!typescript.isImportDeclaration(statement)) return;
+		const moduleSpecifier = getModuleSpecifierText(statement);
+		if (moduleSpecifier === null) return;
+		if (moduleSpecifier === "@useinsider/eslint-config") {
+			classifyInsiderImport(statement, sourceFile, flags);
+			return;
+		}
+		if (moduleSpecifier === "eslint/config") return;
+		flags.preserved.push({
+			raw: statement.getText(sourceFile),
+			moduleSpecifier
+		});
+	});
+	return flags;
+}
+function collectSilenceRulesCalls(sourceFile) {
+	return sourceFile.statements.filter(typescript.isExpressionStatement).map((statement) => {
+		const { expression } = statement;
+		if (!typescript.isCallExpression(expression) || !typescript.isIdentifier(expression.expression)) return null;
+		if (expression.expression.text !== "silenceRules") return null;
+		const [argument] = expression.arguments;
+		const rules = readStringLiteralEntries(argument, sourceFile);
+		if (!rules) return null;
+		const leadingComment = leadingCommentTextFor(sourceFile, statement);
+		const call = {
+			line: lineOf(sourceFile, statement),
+			rules
+		};
+		if (leadingComment !== void 0) call.leadingComment = leadingComment;
+		return call;
+	}).filter((call) => call !== null);
+}
+function parseV1Config(source, filePath) {
+	const sourceFile = typescript.createSourceFile(filePath, source, typescript.ScriptTarget.Latest, true);
+	const warnings = [];
+	const imports = inspectImports(sourceFile);
+	warnings.push(...imports.warnings);
+	const silenceRulesCalls = collectSilenceRulesCalls(sourceFile);
+	const arrayLiteral = findDefaultExportArray(sourceFile);
+	const arrayElements = arrayLiteral ? arrayLiteral.elements.map((element) => classifyArrayElement(element, sourceFile, warnings)).filter((entry) => entry !== null) : [];
+	return {
+		hasUseInsiderImport: imports.hasUseInsider,
+		hasSilenceRulesImport: imports.hasSilenceRules,
+		hasDefineConfigWrap: checkDefineConfigWrap(sourceFile),
+		silenceRulesCalls,
+		arrayElements,
+		preservedImports: imports.preserved,
+		warnings
+	};
+}
+//#endregion
+//#region src/cli/migrate/pruneUnusedImports.ts
+var INSIDER_MODULE_SPECIFIER = "@useinsider/eslint-config";
+function readModuleSpecifier(statement) {
+	const { moduleSpecifier } = statement;
+	if (!typescript.isStringLiteralLike(moduleSpecifier)) return null;
+	return moduleSpecifier.text;
+}
+function readImportBindings(statement) {
+	const moduleSpecifier = readModuleSpecifier(statement);
+	if (moduleSpecifier === null) return null;
+	const { importClause } = statement;
+	if (!importClause) return {
+		statement,
+		moduleSpecifier,
+		namedBindings: [],
+		isSideEffect: true
+	};
+	const bindings = {
+		statement,
+		moduleSpecifier,
+		namedBindings: [],
+		isSideEffect: false
+	};
+	if (importClause.name) bindings.defaultBinding = importClause.name.text;
+	const { namedBindings } = importClause;
+	if (namedBindings) if (typescript.isNamespaceImport(namedBindings)) bindings.namespaceBinding = namedBindings.name.text;
+	else namedBindings.elements.forEach((element) => {
+		bindings.namedBindings.push({
+			localName: element.name.text,
+			importedName: element.propertyName?.text ?? element.name.text
+		});
+	});
+	return bindings;
+}
+function isPropertyKeyPosition(node) {
+	const { parent } = node;
+	if (!parent) return false;
+	if (typescript.isPropertyAssignment(parent) && parent.name === node) return true;
+	if (typescript.isPropertyAccessExpression(parent) && parent.name === node) return true;
+	if (typescript.isQualifiedName(parent) && parent.right === node) return true;
+	return false;
+}
+function classifyIdentifier(node, referenced) {
+	const { parent } = node;
+	if (parent && typescript.isShorthandPropertyAssignment(parent) && parent.name === node) {
+		referenced.add(node.text);
+		return;
+	}
+	if (isPropertyKeyPosition(node)) return;
+	referenced.add(node.text);
+}
+function collectReferencedIdentifiers(sourceFile) {
+	const referenced = /* @__PURE__ */ new Set();
+	function visit(node) {
+		if (typescript.isImportDeclaration(node)) return;
+		if (typescript.isIdentifier(node)) classifyIdentifier(node, referenced);
+		typescript.forEachChild(node, visit);
+	}
+	sourceFile.statements.forEach((statement) => {
+		if (typescript.isImportDeclaration(statement)) return;
+		visit(statement);
+	});
+	return referenced;
+}
+function quoteModuleSpecifier(statement, sourceFile) {
+	return statement.moduleSpecifier.getText(sourceFile);
+}
+function renderNamedSpecifier(binding) {
+	if (binding.localName === binding.importedName) return binding.localName;
+	return `${binding.importedName} as ${binding.localName}`;
+}
+function rebuildImportStatement(bindings, keptNamed, sourceFile) {
+	const clauseParts = [];
+	if (bindings.defaultBinding) clauseParts.push(bindings.defaultBinding);
+	if (bindings.namespaceBinding) clauseParts.push(`* as ${bindings.namespaceBinding}`);
+	else if (keptNamed.length > 0) {
+		const list = keptNamed.map(renderNamedSpecifier).join(", ");
+		clauseParts.push(`{ ${list} }`);
+	}
+	const moduleSpecifier = quoteModuleSpecifier(bindings.statement, sourceFile);
+	if (clauseParts.length === 0) return `import ${moduleSpecifier};`;
+	return `import ${clauseParts.join(", ")} from ${moduleSpecifier};`;
+}
+function summarizeUsage(bindings, referenced) {
+	const defaultStays = bindings.defaultBinding ? referenced.has(bindings.defaultBinding) : false;
+	const namespaceStays = bindings.namespaceBinding ? referenced.has(bindings.namespaceBinding) : false;
+	const keptNamed = bindings.namedBindings.filter((named) => referenced.has(named.localName));
+	return {
+		hasDefault: Boolean(bindings.defaultBinding),
+		hasNamespace: Boolean(bindings.namespaceBinding),
+		hasNamed: bindings.namedBindings.length > 0,
+		defaultStays,
+		namespaceStays,
+		keptNamed
+	};
+}
+function isFullyUnchanged(bindings, usage) {
+	if (usage.hasDefault && !usage.defaultStays) return false;
+	if (usage.hasNamespace && !usage.namespaceStays) return false;
+	if (usage.hasNamed && usage.keptNamed.length !== bindings.namedBindings.length) return false;
+	return true;
+}
+function hasAnyBinding(usage) {
+	return usage.hasDefault || usage.hasNamespace || usage.hasNamed;
+}
+function hasAnySurvivingBinding(usage) {
+	const namedStays = usage.hasNamed && usage.keptNamed.length > 0;
+	return usage.defaultStays || usage.namespaceStays || namedStays;
+}
+function buildRebuiltBindings(bindings, usage) {
+	return {
+		...bindings,
+		defaultBinding: usage.defaultStays ? bindings.defaultBinding : void 0,
+		namespaceBinding: usage.namespaceStays ? bindings.namespaceBinding : void 0,
+		namedBindings: usage.keptNamed
+	};
+}
+function decideRewrite(bindings, referenced, sourceFile) {
+	if (bindings.moduleSpecifier === INSIDER_MODULE_SPECIFIER || bindings.isSideEffect) return { keep: true };
+	const usage = summarizeUsage(bindings, referenced);
+	if (!hasAnyBinding(usage)) return { keep: true };
+	if (!hasAnySurvivingBinding(usage)) return { keep: false };
+	if (isFullyUnchanged(bindings, usage)) return { keep: true };
+	return {
+		keep: true,
+		replacement: rebuildImportStatement(buildRebuiltBindings(bindings, usage), usage.keptNamed, sourceFile)
+	};
+}
+function lineRangeForStatement(statement, sourceFile) {
+	return {
+		start: sourceFile.getLineAndCharacterOfPosition(statement.getStart(sourceFile)).line,
+		end: sourceFile.getLineAndCharacterOfPosition(statement.getEnd()).line
+	};
+}
+function applyReplacements(source, replacements) {
+	if (replacements.length === 0) return source;
+	const lines = source.split("\n");
+	replacements.slice().sort((left, right) => right.startLine - left.startLine).forEach((replacement) => {
+		const removeCount = replacement.endLine - replacement.startLine + 1;
+		if (replacement.text === null) lines.splice(replacement.startLine, removeCount);
+		else lines.splice(replacement.startLine, removeCount, replacement.text);
+	});
+	return lines.join("\n");
+}
+function pruneUnusedImports(source) {
+	const sourceFile = typescript.createSourceFile("migrated.mjs", source, typescript.ScriptTarget.Latest, true);
+	const importStatements = sourceFile.statements.filter(typescript.isImportDeclaration);
+	if (importStatements.length === 0) return source;
+	const referenced = collectReferencedIdentifiers(sourceFile);
+	const replacements = [];
+	importStatements.forEach((statement) => {
+		const bindings = readImportBindings(statement);
+		if (!bindings) return;
+		const decision = decideRewrite(bindings, referenced, sourceFile);
+		if (decision.keep && decision.replacement === void 0) return;
+		const range = lineRangeForStatement(statement, sourceFile);
+		if (!decision.keep) {
+			replacements.push({
+				startLine: range.start,
+				endLine: range.end,
+				text: null
+			});
+			return;
+		}
+		if (decision.replacement !== void 0) replacements.push({
+			startLine: range.start,
+			endLine: range.end,
+			text: decision.replacement
+		});
+	});
+	return applyReplacements(source, replacements);
+}
+/* v8 ignore stop */
+//#endregion
+//#region src/cli/migrate/render.ts
+var indent = "    ";
+var MAX_LINE_LENGTH = 120;
+function quote(value) {
+	return `'${value.replace(/'/g, "\\'")}'`;
+}
+function anyEntryHasComment(entries) {
+	return entries.some((entry) => entry.leadingComment !== void 0);
+}
+function indentCommentBlock(raw, baseIndent) {
+	return raw.split("\n").map((line) => `${baseIndent}${line}`).join("\n");
+}
+function formatStringArrayInline(entries) {
+	return `[${entries.map((entry) => quote(entry.value)).join(", ")}]`;
+}
+function formatStringArrayMultiline(entries, baseIndent) {
+	const childIndent = `${baseIndent}${indent}`;
+	const lines = ["["];
+	entries.forEach((entry) => {
+		if (entry.leadingComment !== void 0) lines.push(indentCommentBlock(entry.leadingComment, childIndent));
+		lines.push(`${childIndent}${quote(entry.value)},`);
+	});
+	lines.push(`${baseIndent}]`);
+	return lines.join("\n");
+}
+function renderStringArrayField(label, entries, baseIndent) {
+	if (!anyEntryHasComment(entries)) {
+		const inline = `${baseIndent}${label}: ${formatStringArrayInline(entries)},`;
+		if (inline.length <= MAX_LINE_LENGTH) return inline;
+	}
+	return `${baseIndent}${label}: ${formatStringArrayMultiline(entries, baseIndent)},`;
+}
+function formatGlobalValue(value) {
+	if (typeof value === "string") return quote(value);
+	return String(value);
+}
+function tokensFromRecord$1(globals) {
+	return Object.entries(globals).map(([key, value]) => ({
+		kind: "named",
+		key,
+		value
+	}));
+}
+function formatGlobalTokenInline(token) {
+	if (token.kind === "spread") return `...${token.raw}`;
+	return `${token.key}: ${formatGlobalValue(token.value)}`;
+}
+function formatGlobalTokenLine(token, childIndent) {
+	if (token.kind === "spread") return `${childIndent}...${token.raw},`;
+	return `${childIndent}${token.key}: ${formatGlobalValue(token.value)},`;
+}
+function formatGlobalsTokensInline(tokens) {
+	return `{ ${tokens.map(formatGlobalTokenInline).join(", ")} }`;
+}
+function formatGlobalsTokensMultiline(tokens, baseIndent) {
+	const childIndent = `${baseIndent}${indent}`;
+	return [
+		"{",
+		...tokens.map((token) => formatGlobalTokenLine(token, childIndent)),
+		`${baseIndent}}`
+	].join("\n");
+}
+function renderGlobalsField(tokens, baseIndent) {
+	const inline = `${baseIndent}globals: ${formatGlobalsTokensInline(tokens)},`;
+	if (inline.length <= MAX_LINE_LENGTH) return inline;
+	return `${baseIndent}globals: ${formatGlobalsTokensMultiline(tokens, baseIndent)},`;
+}
+function resolveEntryGlobalsTokens(entry) {
+	if (entry.globalsTokens && entry.globalsTokens.length > 0) return entry.globalsTokens;
+	if (entry.globals && Object.keys(entry.globals).length > 0) return tokensFromRecord$1(entry.globals);
+}
+function pushFieldComment(lines, comment, fieldIndent) {
+	if (comment === void 0) return;
+	lines.push(indentCommentBlock(comment, fieldIndent));
+}
+function pushArrayField(lines, label, entries, fieldComment, fieldIndent) {
+	if (!entries || entries.length === 0) return;
+	pushFieldComment(lines, fieldComment, fieldIndent);
+	lines.push(renderStringArrayField(label, entries, fieldIndent));
+}
+function formatEntry(entry, baseIndent) {
+	const fieldIndent = `${baseIndent}${indent}`;
+	const lines = [`${baseIndent}{`];
+	pushFieldComment(lines, entry.fieldComments?.files, fieldIndent);
+	lines.push(renderStringArrayField("files", entry.files, fieldIndent));
+	pushArrayField(lines, "tsconfigPaths", entry.tsconfigPaths, entry.fieldComments?.tsconfigPaths, fieldIndent);
+	pushArrayField(lines, "globalComponents", entry.globalComponents, entry.fieldComments?.globalComponents, fieldIndent);
+	pushArrayField(lines, "ignores", entry.ignores, entry.fieldComments?.ignores, fieldIndent);
+	const tokens = resolveEntryGlobalsTokens(entry);
+	if (tokens) {
+		pushFieldComment(lines, entry.fieldComments?.globals, fieldIndent);
+		lines.push(renderGlobalsField(tokens, fieldIndent));
+	}
+	lines.push(`${baseIndent}},`);
+	return lines.join("\n");
+}
+function formatScope(scope, entries, baseIndent) {
+	const childIndent = `${baseIndent}${indent}`;
+	const renderedEntries = [];
+	entries.forEach((entry) => {
+		if (entry.leadingComment !== void 0) renderedEntries.push(indentCommentBlock(entry.leadingComment, childIndent));
+		renderedEntries.push(formatEntry(entry, childIndent));
+	});
+	return [
+		`${baseIndent}${scope}: [`,
+		...renderedEntries,
+		`${baseIndent}],`
+	].join("\n");
+}
+function renderInsiderImport(plan) {
+	return `import { ${(plan.needsSilenceRulesImport ? ["silenceRules", "useInsider"] : ["useInsider"]).slice().sort((left, right) => left.localeCompare(right)).join(", ")} } from '@useinsider/eslint-config';`;
+}
+function renderPreservedImports(preserved) {
+	return preserved.map((item) => item.raw);
+}
+function renderImports(plan) {
+	return [...renderPreservedImports(plan.preservedImports ?? []), renderInsiderImport(plan)].join("\n");
+}
+function renderSilenceRulesCall(rules, leadingComment) {
+	const hasComment = anyEntryHasComment(rules);
+	const prefix = leadingComment === void 0 ? "" : `${leadingComment}\n`;
+	if (!hasComment) {
+		const inline = `${prefix}silenceRules(${formatStringArrayInline(rules)});`;
+		if (inline.length - prefix.length <= MAX_LINE_LENGTH) return inline;
+	}
+	const lines = ["silenceRules(["];
+	rules.forEach((rule) => {
+		if (rule.leadingComment !== void 0) lines.push(indentCommentBlock(rule.leadingComment, indent));
+		lines.push(`${indent}${quote(rule.value)},`);
+	});
+	lines.push("]);");
+	return `${prefix}${lines.join("\n")}`;
+}
+function renderSilenceRulesCalls(plan) {
+	if (plan.silenceRulesCalls.length === 0) return "";
+	return plan.silenceRulesCalls.map((call) => renderSilenceRulesCall(call.rules, call.leadingComment)).join("\n\n");
+}
+function hasAnyContent(plan) {
+	const { config } = plan;
+	return config.scopes.size > 0 || config.ignores.length > 0 || config.strictGlobs.length > 0 || config.strictWholeFile || config.spellChecker.ignoredPaths.length > 0 || config.configFiles.length > 0;
+}
+function renderStrict(plan) {
+	if (plan.config.strictWholeFile) return `${indent}strict: true,`;
+	if (plan.config.strictGlobs.length > 0) return renderStringArrayField("strict", plan.config.strictGlobs, indent);
+	return null;
+}
+function renderSpellChecker(plan) {
+	if (plan.config.spellChecker.ignoredPaths.length === 0) return null;
+	const innerIndent = `${indent}${indent}`;
+	return [
+		`${indent}spellChecker: {`,
+		renderStringArrayField("ignoredPaths", plan.config.spellChecker.ignoredPaths, innerIndent),
+		`${indent}},`
+	].join("\n");
+}
+function renderScopes(plan) {
+	return [...plan.config.scopes.entries()].map(([scope, entries]) => formatScope(scope, entries, indent));
+}
+function renderConfigFiles(plan) {
+	if (plan.config.configFiles.length === 0) return null;
+	return renderStringArrayField("configFiles", plan.config.configFiles, indent);
+}
+function renderConfigBody(plan) {
+	const lines = [];
+	if (plan.config.ignores.length > 0) lines.push(renderStringArrayField("ignores", plan.config.ignores, indent));
+	lines.push(...renderScopes(plan));
+	const configFilesLine = renderConfigFiles(plan);
+	if (configFilesLine) lines.push(configFilesLine);
+	const strictLine = renderStrict(plan);
+	if (strictLine) lines.push(strictLine);
+	const spellCheckerSection = renderSpellChecker(plan);
+	if (spellCheckerSection) lines.push(spellCheckerSection);
+	return lines.join("\n");
+}
+function renderV2(plan) {
+	const parts = [renderImports(plan)];
+	const silenceRulesSection = renderSilenceRulesCalls(plan);
+	if (silenceRulesSection) {
+		parts.push("");
+		parts.push(silenceRulesSection);
+	}
+	parts.push("");
+	if (plan.useInsiderLeadingComment !== void 0) parts.push(plan.useInsiderLeadingComment);
+	if (!hasAnyContent(plan)) {
+		parts.push("export default useInsider({});");
+		parts.push("");
+		return pruneUnusedImports(parts.join("\n"));
+	}
+	parts.push("export default useInsider({");
+	parts.push(renderConfigBody(plan));
+	parts.push("});");
+	parts.push("");
+	return pruneUnusedImports(parts.join("\n"));
+}
+//#endregion
+//#region src/cli/migrate/transform.ts
+function appendUniqueEntry(target, incoming) {
+	if (hasValue(target, incoming.value)) return;
+	target.push(cloneEntry(incoming));
+}
+var presetToScope = {
+	javascript: "javascript",
+	"javascript-dom": "javascriptDom",
+	"javascript-node": "javascriptNode",
+	typescript: "typescript",
+	"typescript-dom": "typescriptDom",
+	"typescript-node": "typescriptNode",
+	vue2: "vue2",
+	vue3: "vue3",
+	"vue2-typescript": "vue2Typescript",
+	"vue3-typescript": "vue3Typescript",
+	jest: "jest",
+	vitest: "vitest",
+	"jsdoc-based-ts": "jsdocBasedTs"
+};
+function isTypescriptContext(call) {
+	if (call.parserIsTypescript) return true;
+	return Boolean(call.parserProject && call.parserProject.length > 0);
+}
+function resolveAliasPreset(preset, call) {
+	if (preset === "dom") return isTypescriptContext(call) ? "typescript-dom" : "javascript-dom";
+	if (preset === "node") return isTypescriptContext(call) ? "typescript-node" : "javascript-node";
+	return preset;
+}
+function promoteScopeForParser(scope, call) {
+	if (!call.parserIsTypescript) return scope;
+	if (scope === "javascript") return "typescript";
+	if (scope === "javascriptDom") return "typescriptDom";
+	if (scope === "javascriptNode") return "typescriptNode";
+	if (scope === "vue2") return "vue2Typescript";
+	if (scope === "vue3") return "vue3Typescript";
+	return scope;
+}
+var tsScopes = new Set([
+	"typescript",
+	"typescriptDom",
+	"typescriptNode",
+	"vue2Typescript",
+	"vue3Typescript",
+	"jsdocBasedTs"
+]);
+var vueScopes = new Set([
+	"vue2",
+	"vue3",
+	"vue2Typescript",
+	"vue3Typescript"
+]);
+function freshConfig() {
+	return {
+		ignores: [],
+		scopes: /* @__PURE__ */ new Map(),
+		strictGlobs: [],
+		strictWholeFile: false,
+		spellChecker: { ignoredPaths: [] },
+		configFiles: []
+	};
+}
+function appendScope(config, scope, entry) {
+	const existing = config.scopes.get(scope);
+	if (existing) existing.push(entry);
+	else config.scopes.set(scope, [entry]);
+}
+function applyTypescriptFields(entry, scope, call, warnings) {
+	if (!tsScopes.has(scope)) return;
+	if (call.parserProject && call.parserProject.length > 0) {
+		entry.tsconfigPaths = cloneEntries(call.parserProject);
+		return;
+	}
+	if (call.parserProjectService) warnings.push({
+		kind: "project-service-dropped",
+		line: call.line,
+		message: "'projectService: true' is not supported in v2 — dropped"
+	});
+}
+function applyVueFields(entry, scope, call) {
+	if (vueScopes.has(scope) && call.globalComponents && call.globalComponents.length > 0) entry.globalComponents = cloneEntries(call.globalComponents);
+}
+function mapV1FieldComments(call, scope) {
+	const incoming = call.fieldComments;
+	if (!incoming) return;
+	const result = {};
+	if (incoming.files !== void 0) result.files = incoming.files;
+	if (incoming.ignores !== void 0) result.ignores = incoming.ignores;
+	if (incoming.globals !== void 0) result.globals = incoming.globals;
+	if (incoming.parserProject !== void 0 && tsScopes.has(scope)) result.tsconfigPaths = incoming.parserProject;
+	if (incoming.globalComponents !== void 0 && vueScopes.has(scope)) result.globalComponents = incoming.globalComponents;
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+function buildEntry(call, scope, warnings) {
+	if (!call.files || call.files.length === 0) {
+		warnings.push({
+			kind: "unrecognized-block",
+			line: call.line,
+			message: `useInsider preset '${scope}' has no files glob; skipping`
+		});
+		return null;
+	}
+	const entry = { files: cloneEntries(call.files) };
+	if (call.ignores && call.ignores.length > 0) entry.ignores = cloneEntries(call.ignores);
+	applyTypescriptFields(entry, scope, call, warnings);
+	applyVueFields(entry, scope, call);
+	if (call.globalsTokens && call.globalsTokens.length > 0) entry.globalsTokens = call.globalsTokens.map((token) => ({ ...token }));
+	if (call.globals && Object.keys(call.globals).length > 0) entry.globals = { ...call.globals };
+	const fieldComments = mapV1FieldComments(call, scope);
+	if (fieldComments) entry.fieldComments = fieldComments;
+	return entry;
+}
+function handleStrictPreset(call, config) {
+	if (!call.files || call.files.length === 0) {
+		config.strictWholeFile = true;
+		return;
+	}
+	call.files.forEach((file) => appendUniqueEntry(config.strictGlobs, file));
+}
+function handlePreset(preset, call, config, warnings) {
+	if (preset === "strict") {
+		handleStrictPreset(call, config);
+		return null;
+	}
+	const baseScope = presetToScope[resolveAliasPreset(preset, call)];
+	if (!baseScope) {
+		warnings.push({
+			kind: "unknown-preset",
+			line: call.line,
+			message: `Preset '${preset}' has no v2 mapping — dropped`
+		});
+		return null;
+	}
+	const scope = promoteScopeForParser(baseScope, call);
+	const entry = buildEntry(call, scope, warnings);
+	if (entry) {
+		appendScope(config, scope, entry);
+		return entry;
+	}
+	return null;
+}
+function emptyStats() {
+	return {
+		droppedRules: 0,
+		droppedRuleBlocks: 0,
+		droppedPlugins: /* @__PURE__ */ new Set(),
+		droppedPluginEntries: 0
+	};
+}
+function captureConfigPresetFiles(call, config) {
+	if (!call.presets.includes("config") || !call.files) return;
+	call.files.forEach((file) => appendUniqueEntry(config.configFiles, file));
+}
+function processUseInsiderCall(call, config, warnings) {
+	captureConfigPresetFiles(call, config);
+	const filteredPresets = call.presets.filter((preset) => preset !== "config");
+	const stats = emptyStats();
+	stats.droppedRules = call.extraRuleCount > 0 ? call.extraRuleCount : 0;
+	stats.droppedRuleBlocks = call.extraRuleCount > 0 ? 1 : 0;
+	if (call.customPluginNames && call.customPluginNames.length > 0) {
+		call.customPluginNames.forEach((name) => stats.droppedPlugins.add(name));
+		stats.droppedPluginEntries = 1;
+	}
+	let firstEmitted = null;
+	filteredPresets.forEach((preset) => {
+		const emitted = handlePreset(preset, call, config, warnings);
+		if (emitted && !firstEmitted) firstEmitted = emitted;
+	});
+	if (firstEmitted && call.leadingComment !== void 0) firstEmitted.leadingComment = call.leadingComment;
+	return stats;
+}
+function applyIgnoresBlock(element, config) {
+	if (element.leadingComment !== void 0 && element.ignores.length > 0 && config.ignores.length === 0 && element.ignores[0].leadingComment === void 0) {
+		const first = cloneEntry(element.ignores[0]);
+		first.leadingComment = element.leadingComment;
+		config.ignores.push(first);
+		element.ignores.slice(1).forEach((ignore) => appendUniqueEntry(config.ignores, ignore));
+		return;
+	}
+	element.ignores.forEach((ignore) => appendUniqueEntry(config.ignores, ignore));
+}
+function applySpellCheckerOff(element, config) {
+	element.files.forEach((file) => appendUniqueEntry(config.spellChecker.ignoredPaths, file));
+}
+function filesOverlap(left, right) {
+	const leftValues = entryValues(left);
+	const rightValues = entryValues(right);
+	if (leftValues.length === rightValues.length && leftValues.every((value, index) => value === rightValues[index])) return true;
+	return leftValues.some((value) => rightValues.includes(value));
+}
+function findEntryForStandalone(config, files) {
+	return [...config.scopes.values()].flat().find((entry) => filesOverlap(entry.files, files)) ?? null;
+}
+function mergeStandaloneTokensIntoEntry(entry, incoming) {
+	const existing = entry.globalsTokens ?? [];
+	const namedSeen = /* @__PURE__ */ new Map();
+	existing.forEach((token, index) => {
+		if (token.kind === "named") namedSeen.set(token.key, index);
+	});
+	const merged = existing.slice();
+	incoming.forEach((token) => {
+		if (token.kind === "spread") {
+			merged.push({ ...token });
+			return;
+		}
+		const seenIndex = namedSeen.get(token.key);
+		if (seenIndex === void 0) {
+			namedSeen.set(token.key, merged.length);
+			merged.push({ ...token });
+			return;
+		}
+		merged[seenIndex] = { ...token };
+	});
+	entry.globalsTokens = merged;
+	const namedRecord = {};
+	merged.forEach((token) => {
+		if (token.kind === "named") namedRecord[token.key] = token.value;
+	});
+	entry.globals = Object.keys(namedRecord).length > 0 ? namedRecord : void 0;
+}
+function inferScopeForStandalone(files) {
+	const values = entryValues(files);
+	if (values.some((file) => file.includes(".vue"))) return "vue3";
+	if (values.some((file) => file.includes(".ts") || file.includes(".tsx"))) return "typescript";
+	return "javascript";
+}
+function applyStandaloneGlobals(element, config) {
+	const existing = findEntryForStandalone(config, element.files);
+	if (existing) {
+		mergeStandaloneTokensIntoEntry(existing, element.globalsTokens);
+		if (existing.leadingComment === void 0 && element.leadingComment !== void 0) existing.leadingComment = element.leadingComment;
+		return;
+	}
+	const scope = inferScopeForStandalone(element.files);
+	const entry = { files: cloneEntries(element.files) };
+	mergeStandaloneTokensIntoEntry(entry, element.globalsTokens);
+	if (element.leadingComment !== void 0) entry.leadingComment = element.leadingComment;
+	appendScope(config, scope, entry);
+}
+function processElement(element, config, warnings) {
+	if (element.kind === "ignoresBlock") {
+		applyIgnoresBlock(element, config);
+		return emptyStats();
+	}
+	if (element.kind === "spellCheckerOff") {
+		applySpellCheckerOff(element, config);
+		return emptyStats();
+	}
+	if (element.kind === "standaloneGlobals") {
+		applyStandaloneGlobals(element, config);
+		return emptyStats();
+	}
+	if (element.kind === "useInsiderCall") return processUseInsiderCall(element, config, warnings);
+	return emptyStats();
+}
+function formatDroppedRulesMessage(count, blocks) {
+	return `Dropped ${count} custom ${count === 1 ? "rule override" : "rule overrides"} across ${blocks} ${blocks === 1 ? "block" : "blocks"}`;
+}
+function formatDroppedPluginsMessage(pluginNames, entries) {
+	return `Dropped custom plugins on ${entries} entries: ${pluginNames.slice().sort((left, right) => left.localeCompare(right)).join(", ")}`;
+}
+function mergeStats(left, right) {
+	const merged = emptyStats();
+	merged.droppedRules = left.droppedRules + right.droppedRules;
+	merged.droppedRuleBlocks = left.droppedRuleBlocks + right.droppedRuleBlocks;
+	merged.droppedPluginEntries = left.droppedPluginEntries + right.droppedPluginEntries;
+	left.droppedPlugins.forEach((name) => merged.droppedPlugins.add(name));
+	right.droppedPlugins.forEach((name) => merged.droppedPlugins.add(name));
+	return merged;
+}
+function tokensFromRecord(globals) {
+	return Object.entries(globals).map(([key, value]) => ({
+		kind: "named",
+		key,
+		value
+	}));
+}
+function resolveBaseTokens(entry) {
+	if (entry.globalsTokens && entry.globalsTokens.length > 0) return entry.globalsTokens;
+	if (entry.globals && Object.keys(entry.globals).length > 0) return tokensFromRecord(entry.globals);
+}
+function applyGlobalsFolding(config) {
+	let anySyntheticEmitted = false;
+	config.scopes.forEach((entries) => {
+		entries.forEach((entry) => {
+			const baseTokens = resolveBaseTokens(entry);
+			if (!baseTokens) return;
+			const { tokens, addedSpreadEnvs } = foldGlobalsTokens(baseTokens);
+			if (addedSpreadEnvs.length > 0) anySyntheticEmitted = true;
+			entry.globalsTokens = tokens;
+			const namedRecord = {};
+			tokens.forEach((token) => {
+				if (token.kind === "named") namedRecord[token.key] = token.value;
+			});
+			entry.globals = Object.keys(namedRecord).length > 0 ? namedRecord : void 0;
+		});
+	});
+	return anySyntheticEmitted;
+}
+function ensureGlobalsImport(preserved) {
+	if (preserved.some((item) => item.moduleSpecifier === "globals")) return preserved;
+	return [{
+		raw: "import globals from 'globals';",
+		moduleSpecifier: "globals"
+	}, ...preserved];
+}
+function countRescuedSiblingCalls(parseResult) {
+	return parseResult.arrayElements.reduce((accumulator, element) => {
+		if (element.kind === "useInsiderCall" && element.rescuedSiblingLanguageOptions === true) return accumulator + 1;
+		return accumulator;
+	}, 0);
+}
+function formatRescuedSiblingMessage(count) {
+	return `Rescued misplaced \`languageOptions\` from ${count} \`useInsider()\` ${count === 1 ? "call" : "calls"} — these were source-level mistakes that v1 ignored silently`;
+}
+function transformToV2(parseResult) {
+	const config = freshConfig();
+	const warnings = [...parseResult.warnings];
+	const stats = parseResult.arrayElements.reduce((accumulator, element) => mergeStats(accumulator, processElement(element, config, warnings)), emptyStats());
+	if (stats.droppedRules > 0) warnings.push({
+		kind: "dropped-rules",
+		message: formatDroppedRulesMessage(stats.droppedRules, stats.droppedRuleBlocks)
+	});
+	if (stats.droppedPluginEntries > 0 && stats.droppedPlugins.size > 0) warnings.push({
+		kind: "dropped-plugins",
+		message: formatDroppedPluginsMessage([...stats.droppedPlugins], stats.droppedPluginEntries)
+	});
+	const rescuedSiblingCount = countRescuedSiblingCalls(parseResult);
+	if (rescuedSiblingCount > 0) warnings.push({
+		kind: "rescued-sibling-language-options",
+		message: formatRescuedSiblingMessage(rescuedSiblingCount)
+	});
+	const preservedImports = applyGlobalsFolding(config) ? ensureGlobalsImport(parseResult.preservedImports) : parseResult.preservedImports;
+	return {
+		config,
+		silenceRulesCalls: parseResult.silenceRulesCalls,
+		needsSilenceRulesImport: parseResult.silenceRulesCalls.length > 0,
+		preservedImports,
+		warnings,
+		droppedRuleCount: stats.droppedRules,
+		droppedRuleBlockCount: stats.droppedRuleBlocks
+	};
+}
+//#endregion
+//#region src/cli/migrate/warnings.ts
+function formatWarnings(warnings) {
+	if (warnings.length === 0) return "";
+	return warnings.map((warning) => {
+		return `  - ${warning.line === void 0 ? "" : `line ${warning.line}: `}${warning.message}`;
+	}).join("\n");
+}
+//#endregion
+//#region src/cli/migrate/writer.ts
+function writeMigration(targetPath, newSource) {
+	(0, node_fs.writeFileSync)(targetPath, newSource, "utf8");
+	return { targetPath };
+}
+function writeMigrationLegacy(sourcePath, writePath, newSource) {
+	(0, node_fs.writeFileSync)(writePath, newSource, "utf8");
+	return {
+		targetPath: writePath,
+		deletedSourceCandidate: (0, node_path.basename)(sourcePath) === (0, node_path.basename)(writePath) ? void 0 : sourcePath
+	};
+}
+//#endregion
+//#region src/cli/migrate/index.ts
+var flatConfigCandidates = [
+	"eslint.config.mjs",
+	"eslint.config.js",
+	"eslint.config.cjs"
+];
+var eslintrcCandidates = [
+	".eslintrc.cjs",
+	".eslintrc.js",
+	".eslintrc.mjs",
+	".eslintrc.json"
+];
+var unsupportedEslintrcExtensions = [
+	".json",
+	".yml",
+	".yaml"
+];
+function flatLooksLikeV1(filePath) {
+	try {
+		const source = (0, node_fs.readFileSync)(filePath, "utf8");
+		return source.includes("useInsider") && /\b(import|require)\b/.test(source);
+	} catch {
+		return false;
+	}
+}
+function resolveTargetPath(input) {
+	if (input.target) {
+		const absolute = (0, node_path.isAbsolute)(input.target) ? input.target : (0, node_path.resolve)(input.cwd, input.target);
+		if ((0, node_fs.existsSync)(absolute)) return absolute;
+		return null;
+	}
+	const flatFound = flatConfigCandidates.map((name) => (0, node_path.join)(input.cwd, name)).find((candidate) => (0, node_fs.existsSync)(candidate));
+	const legacyFound = eslintrcCandidates.map((name) => (0, node_path.join)(input.cwd, name)).find((candidate) => (0, node_fs.existsSync)(candidate));
+	if (flatFound && legacyFound) return flatLooksLikeV1(flatFound) ? flatFound : legacyFound;
+	return flatFound ?? legacyFound ?? null;
+}
+function detectFormatByName(filePath) {
+	const name = (0, node_path.basename)(filePath);
+	if (name.startsWith("eslint.config.")) return "flat";
+	if (!name.startsWith(".eslintrc")) return null;
+	if (unsupportedEslintrcExtensions.find((extension) => name.endsWith(extension))) return "eslintrc-unsupported";
+	return "eslintrc";
+}
+function detectFormatByContent(source) {
+	if (source.includes("export default") && source.includes("useInsider")) return "flat";
+	if (/\bmodule\.exports\s*=/.test(source)) return "eslintrc";
+	return "flat";
+}
+function detectFormat(filePath, source) {
+	const byName = detectFormatByName(filePath);
+	if (byName) return byName;
+	return detectFormatByContent(source);
+}
+function isV1Shape(parseResult) {
+	if (!parseResult.hasUseInsiderImport) return false;
+	return parseResult.arrayElements.some((element) => element.kind === "useInsiderCall");
+}
+function describeScopes(plan) {
+	if (plan.config.scopes.size === 0) return "Scopes detected: (none)";
+	return `Scopes detected: ${[...plan.config.scopes.entries()].map(([scope, entries]) => `${scope} (${entries.length})`).join(", ")}`;
+}
+function describeStrict(plan) {
+	if (plan.config.strictWholeFile) return "Strict scopes: global (true)";
+	if (plan.config.strictGlobs.length > 0) return `Strict scopes: 1 (${plan.config.strictGlobs.length} globs)`;
+	return "Strict scopes: 0";
+}
+function summary(plan, format) {
+	const lines = [];
+	if (format === "eslintrc") lines.push("Source: legacy .eslintrc");
+	else lines.push("Source: flat eslint.config.*");
+	lines.push(describeScopes(plan));
+	lines.push(describeStrict(plan));
+	lines.push(`spellChecker.ignoredPaths: ${plan.config.spellChecker.ignoredPaths.length}`);
+	const blocksLabel = plan.droppedRuleBlockCount === 1 ? "block" : "blocks";
+	lines.push(`Dropped custom rules: ${plan.droppedRuleCount} across ${plan.droppedRuleBlockCount} ${blocksLabel}`);
+	lines.push(`Warnings: ${plan.warnings.length}`);
+	return lines.join("\n");
+}
+function planFromSource(source, filePath, format) {
+	if (format === "flat") {
+		const parseResult = parseV1Config(source, filePath);
+		if (!isV1Shape(parseResult)) return null;
+		const plan = transformToV2(parseResult);
+		return {
+			plan,
+			rendered: renderV2(plan)
+		};
+	}
+	const parseResult = parseEslintrc(source, filePath);
+	if (!parseResult.found) return null;
+	const plan = transformEslintrcToV2(parseResult);
+	return {
+		plan,
+		rendered: renderV2(plan)
+	};
+}
+function targetWritePath(cwd, sourcePath, format) {
+	if (format !== "eslintrc") return sourcePath;
+	const base = (0, node_path.basename)(sourcePath);
+	const dir = sourcePath.slice(0, sourcePath.length - base.length);
+	return (0, node_path.join)(dir.length > 0 ? dir : cwd, "eslint.config.mjs");
+}
+function parseEslintIgnoreContents(raw) {
+	return raw.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+}
+function findEslintIgnore(sourcePath) {
+	const candidate = (0, node_path.join)((0, node_path.dirname)(sourcePath), ".eslintignore");
+	if (!(0, node_fs.existsSync)(candidate)) return null;
+	return {
+		path: candidate,
+		patterns: parseEslintIgnoreContents((0, node_fs.readFileSync)(candidate, "utf8"))
+	};
+}
+function mergeIgnorePatterns(plan, extra) {
+	extra.forEach((pattern) => {
+		if (!plan.config.ignores.some((existing) => existing.value === pattern)) plan.config.ignores.push({ value: pattern });
+	});
+}
+function safeUnlink(filePath, clack, label) {
+	try {
+		(0, node_fs.unlinkSync)(filePath);
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		if (clack.note) clack.note(`Could not delete ${label} at ${filePath}: ${reason}`, "Warning");
+	}
+}
+function describeDepChanges(depChanges) {
+	if (!depChanges || !depChanges.packageJsonPath) return null;
+	const lines = ["The following dependency changes will be applied to package.json:"];
+	if (depChanges.removed.length > 0) lines.push(`- Remove (${depChanges.removed.length}): ${depChanges.removed.join(", ")}`);
+	else lines.push("- Remove (0): (none)");
+	lines.push(`- Install (${depChanges.install.specs.length}): ${depChanges.install.specs.join(", ")}`);
+	return lines.join("\n");
+}
+async function confirmWrite(clack, writePath, initial = true) {
+	const message = `Write migrated config to ${writePath}?`;
+	const result = await clack.confirm({
+		message,
+		initialValue: initial
+	});
+	return !clack.isCancel(result) && result === true;
+}
+async function confirmInstall(clack, depSummary, initial = true) {
+	const head = describeDepChanges(depSummary) ?? "";
+	const message = head ? `${head}\nInstall dependencies now?` : "Install dependencies now?";
+	const result = await clack.confirm({
+		message,
+		initialValue: initial
+	});
+	return !clack.isCancel(result) && result === true;
+}
+function renderNextStepsMessage(input) {
+	const hasRemove = input.removed.length > 0;
+	const hasInstall = input.installSpecs.length > 0;
+	if (!hasRemove && !hasInstall) return null;
+	const blocks = ["Skipped dependency installation. Run these to apply manually:"];
+	if (hasRemove) blocks.push(formatNextStepsRemoveCommand(input.manager, input.removed));
+	if (hasInstall) blocks.push(formatNextStepsAddCommand(input.manager, input.installSpecs));
+	return blocks.join("\n\n");
+}
+function emitInstallNextSteps(clack, depSummary, cwd) {
+	if (!clack.note) return;
+	const message = renderNextStepsMessage({
+		manager: detectPackageManager(cwd),
+		removed: depSummary.removed,
+		installSpecs: depSummary.install.specs
+	});
+	if (message === null) return;
+	clack.note(message, "Next steps");
+}
+function emitSummary(clack, plan, format) {
+	if (clack.note) clack.note(summary(plan, format), "Migration summary");
+	if (plan.warnings.length > 0 && clack.note) clack.note(formatWarnings(plan.warnings), "Warnings");
+}
+function writeAndAnnounce(clack, targetPath, writePath, rendered, format) {
+	if (format === "eslintrc") {
+		const result = writeMigrationLegacy(targetPath, writePath, rendered);
+		clack.outro(`Wrote ${writePath}`);
+		return { deletedSourceCandidate: result.deletedSourceCandidate };
+	}
+	writeMigration(targetPath, rendered);
+	clack.outro(`Wrote ${targetPath}`);
+	return {};
+}
+async function confirmOverwriteExistingOutput(clack, writePath, sourcePath, initial = false) {
+	const message = `An \`${(0, node_path.basename)(writePath)}\` already exists. Overwrite + delete \`${(0, node_path.basename)(sourcePath)}\`?`;
+	const result = await clack.confirm({
+		message,
+		initialValue: initial
+	});
+	return !clack.isCancel(result) && result === true;
+}
+function resolveSource(input, clack) {
+	const targetPath = resolveTargetPath(input);
+	if (!targetPath) {
+		clack.cancel("No eslint.config.{mjs,js,cjs} or .eslintrc.{cjs,js,mjs} found.");
+		return {
+			ok: false,
+			exitCode: 1
+		};
+	}
+	const source = (0, node_fs.readFileSync)(targetPath, "utf8");
+	const format = detectFormat(targetPath, source);
+	if (format === "eslintrc-unsupported") {
+		const message = `Legacy ${(0, node_path.basename)(targetPath)} migration not supported in this release; convert manually first.`;
+		clack.cancel(message);
+		return {
+			ok: false,
+			exitCode: 1
+		};
+	}
+	return {
+		ok: true,
+		resolved: {
+			targetPath,
+			source,
+			format
+		}
+	};
+}
+function prepareMigration(resolved, input) {
+	const planResult = planFromSource(resolved.source, resolved.targetPath, resolved.format);
+	if (!planResult) return null;
+	const { plan } = planResult;
+	const writePath = targetWritePath(input.cwd, resolved.targetPath, resolved.format);
+	const eslintIgnore = findEslintIgnore(resolved.targetPath);
+	if (eslintIgnore && eslintIgnore.patterns.length > 0) mergeIgnorePatterns(plan, eslintIgnore.patterns);
+	return {
+		plan,
+		rendered: renderV2(plan),
+		writePath,
+		eslintIgnore
+	};
+}
+async function runConfirmations(clack, input, targetPath, writePath, previous) {
+	if (writePath !== targetPath && (0, node_fs.existsSync)(writePath)) {
+		if (!await confirmOverwriteExistingOutput(clack, writePath, targetPath, previous?.overwriteExisting ?? false)) {
+			clack.outro("Aborted: existing output kept.");
+			return false;
+		}
+	}
+	if (!input.yes) {
+		if (!await confirmWrite(clack, writePath, previous?.proceed ?? true)) {
+			clack.outro("Aborted: original config kept.");
+			return false;
+		}
+	}
+	return true;
+}
+function consumerPackageJsonPath(writePath) {
+	return (0, node_path.join)((0, node_path.dirname)(writePath), "package.json");
+}
+function tryReadConsumerManifest(path) {
+	try {
+		const raw = (0, node_fs.readFileSync)(path, "utf8");
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+function computeDepSummary(plan, writePath, overrides) {
+	const pkgPath = consumerPackageJsonPath(writePath);
+	const manifest = tryReadConsumerManifest(pkgPath);
+	if (!manifest) return {
+		removed: [],
+		install: {
+			specs: [],
+			fallbacks: []
+		},
+		packageJsonPath: null
+	};
+	const pruneOutcome = pruneEslintDependencies(manifest);
+	const ownManifest = (overrides?.readEslintConfigManifest ?? readOwnEslintConfigManifest)();
+	const install = buildInstallList(new Set(plan.config.scopes.keys()), ownManifest);
+	return {
+		removed: pruneOutcome.removed,
+		install,
+		packageJsonPath: pkgPath
+	};
+}
+function persistPrunedManifest(depSummary) {
+	if (!depSummary.packageJsonPath) return;
+	pruneConsumerPackageJson((0, node_path.dirname)(depSummary.packageJsonPath));
+}
+function noteFallbacks(clack, depSummary) {
+	if (depSummary.install.fallbacks.length === 0 || !clack.note) return;
+	const list = depSummary.install.fallbacks.join(", ");
+	clack.note(`Falling back to @latest for: ${list}`, "Warning");
+}
+function resolveInstallCwd(depSummary, input) {
+	if (depSummary.packageJsonPath) return (0, node_path.dirname)(depSummary.packageJsonPath);
+	return input.cwd;
+}
+async function runInstaller(clack, depSummary, input) {
+	await installWithRetry({
+		deps: depSummary.install.specs,
+		cwd: resolveInstallCwd(depSummary, input),
+		autoConfirm: Boolean(input.yes),
+		clack,
+		fsOps: input.overrides?.wipeFs,
+		installer: input.overrides?.installer
+	});
+}
+async function applyDepChanges(clack, depSummary, input) {
+	if (!depSummary.packageJsonPath) {
+		if (clack.note) clack.note("No package.json found alongside the migrated config — skipping dependency updates.", "Notice");
+		return;
+	}
+	persistPrunedManifest(depSummary);
+	if (input.noInstall) {
+		emitInstallNextSteps(clack, depSummary, input.cwd);
+		return;
+	}
+	if (!input.yes) {
+		if (!await confirmInstall(clack, depSummary)) {
+			emitInstallNextSteps(clack, depSummary, input.cwd);
+			return;
+		}
+	}
+	noteFallbacks(clack, depSummary);
+	await runInstaller(clack, depSummary, input);
+}
+function performWriteAndCleanup(clack, resolved, prepared) {
+	const outcome = writeAndAnnounce(clack, resolved.targetPath, prepared.writePath, prepared.rendered, resolved.format);
+	if (prepared.eslintIgnore) safeUnlink(prepared.eslintIgnore.path, clack, ".eslintignore");
+	if (outcome.deletedSourceCandidate) safeUnlink(outcome.deletedSourceCandidate, clack, "source config");
+}
+function loadPreviousMigrate(clack, cwd) {
+	const restored = loadSession({ cwd });
+	const previousMigrate = restored?.command === "migrate" ? restored.migrate : void 0;
+	if (previousMigrate && clack.note) clack.note("Restored your previous choices. Press Enter on each prompt to confirm, or arrow keys to change.", "Resuming previous session");
+	return previousMigrate;
+}
+function emitNothingToMigrate(clack, format) {
+	clack.outro(format === "eslintrc" ? "No legacy `.eslintrc` shape found — nothing to migrate." : "No v1 useInsider patterns found — nothing to migrate.");
+}
+function persistMigrateSession(input, prepared, resolved) {
+	const overwriteExisting = prepared.writePath !== resolved.targetPath && (0, node_fs.existsSync)(prepared.writePath);
+	saveSession({
+		command: "migrate",
+		migrate: {
+			target: input.target,
+			yes: input.yes,
+			noInstall: input.noInstall,
+			overwriteExisting,
+			proceed: true
+		}
+	}, { cwd: input.cwd });
+}
+async function runMigrate(input, clackOverride) {
+	const clack = clackOverride ?? await loadClack();
+	const sourceResult = resolveSource(input, clack);
+	if (!sourceResult.ok) return sourceResult.exitCode;
+	const { resolved } = sourceResult;
+	clack.intro(`Migrating ${resolved.targetPath}`);
+	const previousMigrate = loadPreviousMigrate(clack, input.cwd);
+	const prepared = prepareMigration(resolved, input);
+	if (!prepared) {
+		emitNothingToMigrate(clack, resolved.format);
+		return 0;
+	}
+	emitSummary(clack, prepared.plan, resolved.format);
+	const depSummary = computeDepSummary(prepared.plan, prepared.writePath, input.overrides);
+	if (!await runConfirmations(clack, input, resolved.targetPath, prepared.writePath, previousMigrate)) return 0;
+	persistMigrateSession(input, prepared, resolved);
+	performWriteAndCleanup(clack, resolved, prepared);
+	if (depSummary) await applyDepChanges(clack, depSummary, input);
+	clearSession({ cwd: input.cwd });
+	return 0;
+}
+//#endregion
+//#region src/cli/index.ts
+function resolveTsconfigInput(cwd) {
+	const referencesResult = resolveTsconfigReferences(cwd);
+	if (referencesResult) return {
+		input: {
+			referencesOnly: true,
+			rootPath: referencesResult.rootPath,
+			refs: referencesResult.refs
+		},
+		missing: false
+	};
+	const rootPath = (0, node_path.join)(cwd, "tsconfig.json");
+	if ((0, node_fs.existsSync)(rootPath)) return {
+		input: {
+			referencesOnly: false,
+			rootPath,
+			refs: []
+		},
+		missing: false
+	};
+	return {
+		input: null,
+		missing: true
+	};
+}
+function decisionToChoice(decision) {
+	return decision;
+}
+function isPackageJsonSource(existing) {
+	return existing.path.endsWith("package.json");
+}
+async function handleExistingConfig(clack, input, existing, initial) {
+	const decision = await askExistingConfigDecision(clack, existing.path, initial);
+	saveSession({
+		command: "scaffold",
+		scaffold: { existingConfigChoice: decisionToChoice(decision) }
+	}, { cwd: input.cwd });
+	if (decision === "exit") {
+		clearSession({ cwd: input.cwd });
+		clack.outro("Exited: existing config kept.");
+		return {
+			continueScaffold: false,
+			exitCode: 0
+		};
+	}
+	if (decision === "migrate") {
+		clearSession({ cwd: input.cwd });
+		if (isPackageJsonSource(existing)) {
+			clack.cancel("Migration from package.json `eslintConfig` is not supported; extract it to .eslintrc.cjs first, or pick Override.");
+			return {
+				continueScaffold: false,
+				exitCode: 1
+			};
+		}
+		return {
+			continueScaffold: false,
+			exitCode: await runMigrate({
+				cwd: input.cwd,
+				target: existing.path,
+				yes: input.yes
+			}, clack)
+		};
+	}
+	return {
+		continueScaffold: true,
+		viaOverride: true
+	};
+}
+function isScaffoldChoice(value) {
+	return value === "override" || value === "migrate" || value === "exit";
+}
+function decisionInitial(persistedChoice) {
+	if (persistedChoice && isScaffoldChoice(persistedChoice)) return persistedChoice;
+	return "migrate";
+}
+function buildQuestionsContext(input, restoredAnswers) {
+	const { input: tsconfigInput, missing } = resolveTsconfigInput(input.cwd);
+	return {
+		tsconfigInput,
+		tsconfigMissing: missing,
+		previousAnswers: restoredAnswers
+	};
+}
+function noteOverridePrune(clack, removed) {
+	if (removed.length === 0 || !clack.note) return;
+	const list = removed.join(", ");
+	clack.note(`Removed stale ESLint-related entries from package.json: ${list}`, "Override cleanup");
+}
+function describeHybridPattern(detection) {
+	if (detection.kind === "suffix") return `Detected suffix convention: Options API files match \`${detection.optionsPattern}\`.`;
+	if (detection.kind === "directory") return `Detected directory convention: \`${detection.optionsDir}/\` vs \`${detection.compositionDir}/\`.`;
+	return "";
+}
+function noteHybridFound(clack, detection) {
+	if (!clack.note) return;
+	if (detection.kind !== "suffix" && detection.kind !== "directory") return;
+	clack.note(describeHybridPattern(detection), "Hybrid Vue pattern detected");
+}
+function noteHybridMissing(clack) {
+	if (!clack.note) return;
+	clack.note("Hybrid Vue selected, but your `.vue` files do not follow a distinguishing naming pattern (e.g. `*.options.vue` vs `*.vue`). The generated config will treat every `.vue` file with one preset (composition by default). To get proper per-file linting, rename your Options-API components to `*.options.vue` (or similar) and re-run this CLI.", "No hybrid pattern detected");
+}
+function noteHybridSuffixScaffold(clack, suffix) {
+	if (!clack.note) return;
+	clack.note(`Rename your Options-API files to end with \`${suffix}\` and they will be picked up by the Options preset automatically. Composition components keep the plain \`.vue\` extension.`, "Suffix convention scaffolded");
+}
+async function resolveVueHybridPlan(clack, cwd, yes, previous) {
+	const detection = detectVueApiPattern({ cwd });
+	if (detection.kind === "suffix") {
+		noteHybridFound(clack, detection);
+		const detectedDefault = detection.targetApi === "options" ? "composition" : "options";
+		return {
+			suffix: detection.suffix,
+			defaultApi: detectedDefault,
+			fallbackToComposition: false
+		};
+	}
+	if (detection.kind === "directory") {
+		noteHybridFound(clack, detection);
+		return {
+			suffix: void 0,
+			defaultApi: void 0,
+			fallbackToComposition: false
+		};
+	}
+	noteHybridMissing(clack);
+	if (yes) return {
+		suffix: void 0,
+		defaultApi: void 0,
+		fallbackToComposition: true
+	};
+	if (!await askHybridProceedWithSuffix(clack)) return {
+		suffix: void 0,
+		defaultApi: void 0,
+		fallbackToComposition: true
+	};
+	const defaultApi = await askVueHybridDefaultApi(clack, previous?.defaultApi);
+	const suffix = await askHybridSuffix(clack, defaultApi, previous?.suffix);
+	noteHybridSuffixScaffold(clack, suffix);
+	return {
+		suffix,
+		defaultApi,
+		fallbackToComposition: false
+	};
+}
+async function resolveHybridAnswers(clack, input, answers) {
+	if (answers.framework !== "vue" || answers.vueApiStyle !== "hybrid") return answers;
+	const plan = await resolveVueHybridPlan(clack, input.cwd, Boolean(input.yes), answers.vueHybridSuffix);
+	if (plan.fallbackToComposition) return {
+		...answers,
+		vueApiStyle: "composition",
+		vueHybridSuffix: void 0
+	};
+	if (plan.suffix && plan.defaultApi) return {
+		...answers,
+		vueHybridSuffix: {
+			defaultApi: plan.defaultApi,
+			suffix: plan.suffix
+		}
+	};
+	return answers;
+}
+async function installAndWrite(clack, input, answers, options) {
+	if (options.pruneBeforeInstall) noteOverridePrune(clack, pruneConsumerPackageJson(input.cwd).removed);
+	const deps = buildDependencyList(answers);
+	if (clack.note) clack.note(deps.map((dep) => `  - ${dep}`).join("\n"), "Installing dev dependencies");
+	await installWithRetry({
+		deps,
+		cwd: input.cwd,
+		autoConfirm: Boolean(input.yes),
+		clack,
+		installer: input.overrides?.installer ?? installDependencies,
+		fsOps: input.overrides?.wipeFs
+	});
+	const targetPath = (0, node_path.join)(input.cwd, "eslint.config.mjs");
+	(0, node_fs.writeFileSync)(targetPath, renderConfigFile(answers), "utf8");
+	return targetPath;
+}
+async function runScaffold(input, clackOverride) {
+	const clack = clackOverride ?? await loadClack();
+	const existing = detectExistingEslintConfig(input.cwd);
+	const restored = loadSession({ cwd: input.cwd });
+	const restoredScaffold = restored?.command === "scaffold" ? restored.scaffold : void 0;
+	let viaOverride = false;
+	if (existing) {
+		const outcome = await handleExistingConfig(clack, input, existing, decisionInitial(restoredScaffold?.existingConfigChoice));
+		if (!outcome.continueScaffold) return outcome.exitCode;
+		({viaOverride} = outcome);
+	}
+	const resolvedAnswers = await resolveHybridAnswers(clack, input, await runQuestions(buildQuestionsContext(input, restoredScaffold?.answers), clack));
+	saveSession({
+		command: "scaffold",
+		scaffold: {
+			answers: resolvedAnswers,
+			existingConfigChoice: "override"
+		}
+	}, { cwd: input.cwd });
+	const targetPath = await installAndWrite(clack, input, resolvedAnswers, { pruneBeforeInstall: viaOverride });
+	clearSession({ cwd: input.cwd });
+	clack.outro(`Wrote ${targetPath}`);
+	return 0;
+}
+async function runScaffoldSubcommand(scaffoldInput) {
+	return runScaffold(scaffoldInput);
+}
+async function runMigrateSubcommand(input) {
+	return runMigrate({
+		cwd: input.cwd,
+		target: input.target,
+		yes: input.yes,
+		noInstall: input.noInstall
+	});
+}
+function writeStderr(line) {
+	console.error(line);
+}
+async function main() {
+	return dispatch(process.argv.slice(2), process.cwd(), {
+		scaffold: runScaffoldSubcommand,
+		migrate: runMigrateSubcommand,
+		stderr: writeStderr
+	});
+}
+function exitCleanly(code) {
+	process.exit(code);
+}
+function isUnderTest() {
+	return Boolean(process.env.VITEST) || process.env.NODE_ENV === "test";
+}
+if (!isUnderTest()) main().then(exitCleanly).catch((error) => {
+	if (!(error instanceof CliCancelledError)) {
+		const message = error instanceof Error ? error.message : String(error);
+		console.error(`[useinsider/eslint-config] ${message}`);
+	}
+	exitCleanly(1);
+});
+//#endregion
+exports.runScaffold = runScaffold;
+
+//# sourceMappingURL=cli.cjs.map