vite-plus 0.2.6 → 0.2.8

package/dist/{agent-0gFJkIKu.js → editor-CGWdbLgD.js}

@@ -1,40 +1,26 @@
-import { r as __toESM } from "./rolldown-runtime-C7HZzL1F.js";
-import { a as VITEST_AGE_GATE_EXEMPT_PACKAGES, c as VITE_PLUS_OVERRIDE_PACKAGES, d as isForceOverrideMode, l as VITE_PLUS_VERSION, n as BASEURL_TSCONFIG_WARNING, o as VITEST_VERSION, s as VITE_PLUS_NAME } from "./constants-CaXMuYUG.js";
-import { i as ensureVitePlusImportRuleDefaults, r as createDefaultVitePlusLintConfig } from "./oxlint-plugin-config-CMSCIkks.js";
-import { B as runCommandSilently, D as require_semver, E as PackageManager, M as multiselect, P as select, R as isCancel, V as require_cross_spawn, a as hasTypesToRewriteInTsconfig, b as scalarString, c as rewriteTypesInTsconfig, i as hasBaseUrlInTsconfig, j as log, k as confirm, l as cancelAndExit, n as findTsconfigFiles, o as hasVitestTypesInTsconfig, s as removeDeprecatedTsconfigFalseOption, v as editYamlFile, w as getSpinner, y as readYamlFile } from "./tsconfig-Cac-NNdT.js";
-import { a as writeJsonFile, i as readJsonFile, n as editJsonFile, r as isJsonFile } from "./json-DiRs8ceZ.js";
-import { t as require_dist } from "./dist-CKz3vcoG.js";
-import { n as detectPackageMetadata } from "./package-CP5EUXlu.js";
+import { r as __toESM } from "./rolldown-runtime-CMFfr-1z.js";
+import { a as VITEST_AGE_GATE_EXEMPT_PACKAGES, c as VITE_PLUS_OVERRIDE_PACKAGES, d as isForceOverrideMode, l as VITE_PLUS_VERSION, n as BASEURL_TSCONFIG_WARNING, o as VITEST_VERSION, s as VITE_PLUS_NAME } from "./constants-BppDcRc1.js";
+import { i as ensureVitePlusImportRuleDefaults, r as createDefaultVitePlusLintConfig } from "./oxlint-plugin-config-BHOzlwMw.js";
+import { A as isCancel, C as log, E as select, M as runCommandSilently, N as require_cross_spawn, d as readYamlFile, f as scalarString, g as getSpinner, t as cancelAndExit, u as editYamlFile, v as PackageManager, w as multiselect, x as confirm, y as require_semver } from "./prompts-DYap08te.js";
+import { a as writeJsonFile, c as parse, i as readJsonFile, n as editJsonFile, o as applyEdits, r as isJsonFile, s as modify, t as detectFormattingOptions } from "./json-BU88uu6o.js";
+import { t as require_dist } from "./dist-CSQWHI6y.js";
+import { a as hasTypesToRewriteInTsconfig, c as rewriteTypesInTsconfig, i as hasBaseUrlInTsconfig, n as findTsconfigFiles, o as hasVitestTypesInTsconfig, s as removeDeprecatedTsconfigFalseOption } from "./tsconfig-CVUKLfL8.js";
+import { n as detectPackageMetadata, r as getScopeFromPackageName } from "./package-hV-77cBb.js";
+import { f as displayRelative, l as SUPPORTED_GIT_HOOK_NAMES, p as rulesDir, u as findUnsafeHookInstallPath } from "./agent-CI79DuSy.js";
 import { n as addMigrationWarning, t as addManualStep } from "./report-BS7ULx7A.js";
 import path, { posix, win32 } from "node:path";
-import { hasConfigKey, mergeJsonConfig, mergeTsdownConfig, rewriteEslint, rewriteImportsInDirectory, rewriteScripts, wrapLazyPlugins } from "../binding/index.js";
+import { detectWorkspace, hasConfigKey, mergeJsonConfig, mergeTsdownConfig, rewriteEslint, rewriteImportsInDirectory, rewritePrettier, rewriteScripts, wrapLazyPlugins } from "../binding/index.js";
+import { styleText } from "node:util";
 import * as actualFS from "node:fs";
 import fs from "node:fs";
-import { lstatSync, readdir, readdirSync, readlinkSync, realpathSync as realpathSync$1 } from "fs";
-import { styleText } from "node:util";
-import { fileURLToPath } from "node:url";
 import os from "node:os";
+import { lstatSync as lstatSync$1, readdir, readdirSync, readlinkSync, realpathSync as realpathSync$1 } from "fs";
+import { fileURLToPath } from "node:url";
 import "oxlint";
 import fsPromises, { lstat, readdir as readdir$1, readlink, realpath } from "node:fs/promises";
 import { EventEmitter } from "node:events";
 import Stream from "node:stream";
 import { StringDecoder } from "node:string_decoder";
-//#region src/utils/path.ts
-function findPkgRoot() {
-	let dir = import.meta.dirname;
-	while (dir !== path.dirname(dir)) {
-		if (fs.existsSync(path.join(dir, "package.json"))) return dir;
-		dir = path.dirname(dir);
-	}
-	return dir;
-}
-const pkgRoot = findPkgRoot();
-const templatesDir = path.join(pkgRoot, "templates");
-const rulesDir = path.join(pkgRoot, "rules");
-function displayRelative(to, from = process.cwd()) {
-	return path.relative(from, to).replaceAll("\\", "/");
-}
-//#endregion
 //#region src/migration/migrator/shared.ts
 var import_semver = /* @__PURE__ */ __toESM(require_semver(), 1);
 const LINT_STAGED_JSON_CONFIG_FILES = [".lintstagedrc.json", ".lintstagedrc"];
@@ -743,6 +729,184 @@ async function promptEslintMigration(projectPath, interactive, packages) {
 	return true;
 }
 //#endregion
+//#region src/migration/migrator/prettier.ts
+function detectPrettierProject(projectPath, packages) {
+	const packageJsonPath = path.join(projectPath, "package.json");
+	if (!fs.existsSync(packageJsonPath)) return { hasDependency: false };
+	const pkg = readJsonFile(packageJsonPath);
+	let hasDependency = !!(pkg.devDependencies?.prettier || pkg.dependencies?.prettier);
+	const configFile = detectConfigs(projectPath).prettierConfig;
+	if (!hasDependency && packages) for (const wp of packages) {
+		const pkgJsonPath = path.join(projectPath, wp.path, "package.json");
+		if (!fs.existsSync(pkgJsonPath)) continue;
+		const wpPkg = readJsonFile(pkgJsonPath);
+		if (wpPkg.devDependencies?.prettier || wpPkg.dependencies?.prettier) {
+			hasDependency = true;
+			break;
+		}
+	}
+	return {
+		hasDependency,
+		configFile
+	};
+}
+/**
+* Run `vp fmt --migrate=prettier` step with graceful error handling.
+* Returns true on success, false on failure.
+*/
+async function runPrettierMigrateStep(vpBin, cwd, spinner, failMessage, manualHint) {
+	try {
+		const result = await runCommandSilently({
+			command: vpBin,
+			args: ["fmt", "--migrate=prettier"],
+			cwd,
+			envs: process.env
+		});
+		if (result.exitCode !== 0) {
+			spinner.stop(failMessage);
+			const stderr = result.stderr.toString().trim();
+			if (stderr) log.warn(`⚠ ${stderr}`);
+			log.info(manualHint);
+			return false;
+		}
+		return true;
+	} catch {
+		spinner.stop(failMessage);
+		log.info(manualHint);
+		return false;
+	}
+}
+async function migratePrettierToOxfmt(projectPath, interactive, prettierConfigFile, packages, options) {
+	const vpBin = process.env.VP_CLI_BIN ?? "vp";
+	const spinner = options?.silent ? {
+		start: () => {},
+		stop: () => {},
+		pause: () => {},
+		resume: () => {},
+		cancel: () => {},
+		error: () => {},
+		clear: () => {},
+		message: () => {},
+		isCancelled: false
+	} : getSpinner(interactive);
+	if (prettierConfigFile) {
+		let tempPrettierConfig;
+		if (prettierConfigFile === "package.json#prettier") {
+			const packageJsonPath = path.join(projectPath, "package.json");
+			const pkg = readJsonFile(packageJsonPath);
+			if (pkg.prettier) {
+				tempPrettierConfig = path.join(projectPath, ".prettierrc.json");
+				fs.writeFileSync(tempPrettierConfig, JSON.stringify(pkg.prettier, null, 2));
+			} else return true;
+		}
+		try {
+			spinner.start("Migrating Prettier config to Oxfmt...");
+			if (!await runPrettierMigrateStep(vpBin, projectPath, spinner, "Prettier migration failed", "You can run `vp fmt --migrate=prettier` manually later")) return false;
+			spinner.stop("Prettier config migrated to .oxfmtrc.json");
+		} finally {
+			if (tempPrettierConfig) try {
+				fs.unlinkSync(tempPrettierConfig);
+			} catch {}
+		}
+	}
+	if (options?.report) options.report.prettierMigrated = true;
+	deletePrettierConfigFiles(projectPath, options?.report, options?.silent);
+	rewritePrettierPackageJson(path.join(projectPath, "package.json"));
+	if (packages) for (const pkg of packages) rewritePrettierPackageJson(path.join(projectPath, pkg.path, "package.json"));
+	rewritePrettierLintStagedConfigFiles(projectPath, options?.report);
+	const prettierIgnorePath = path.join(projectPath, ".prettierignore");
+	if (fs.existsSync(prettierIgnorePath)) warnMigration(`${displayRelative(prettierIgnorePath)} found — Oxfmt supports .prettierignore, but using the \`ignorePatterns\` option is recommended.`, options?.report);
+	return true;
+}
+function deletePrettierConfigFiles(basePath, report, silent = false) {
+	const configs = detectConfigs(basePath);
+	if (configs.prettierConfig && configs.prettierConfig !== "package.json#prettier") {
+		const configPath = path.join(basePath, configs.prettierConfig);
+		if (fs.existsSync(configPath)) {
+			fs.unlinkSync(configPath);
+			if (report) report.removedConfigCount++;
+			if (!silent) log.success(`✔ Removed ${displayRelative(configPath)}`);
+		}
+	}
+	for (const file of PRETTIER_CONFIG_FILES) {
+		if (file === configs.prettierConfig) continue;
+		const configPath = path.join(basePath, file);
+		if (fs.existsSync(configPath)) {
+			fs.unlinkSync(configPath);
+			if (report) report.removedConfigCount++;
+			if (!silent) log.success(`✔ Removed ${displayRelative(configPath)}`);
+		}
+	}
+	editJsonFile(path.join(basePath, "package.json"), (pkg) => {
+		if (pkg.prettier) {
+			delete pkg.prettier;
+			return pkg;
+		}
+	});
+}
+function rewritePrettierPackageJson(packageJsonPath) {
+	if (!fs.existsSync(packageJsonPath)) return;
+	editJsonFile(packageJsonPath, (pkg) => {
+		let changed = false;
+		if (pkg.devDependencies) {
+			for (const dep of Object.keys(pkg.devDependencies)) if (dep === "prettier" || dep.startsWith("prettier-plugin-")) {
+				delete pkg.devDependencies[dep];
+				changed = true;
+			}
+		}
+		if (pkg.dependencies) {
+			for (const dep of Object.keys(pkg.dependencies)) if (dep === "prettier" || dep.startsWith("prettier-plugin-")) {
+				delete pkg.dependencies[dep];
+				changed = true;
+			}
+		}
+		if (pkg.scripts) {
+			const updated = rewritePrettier(JSON.stringify(pkg.scripts));
+			if (updated) {
+				pkg.scripts = JSON.parse(updated);
+				changed = true;
+			}
+		}
+		if (pkg["lint-staged"]) {
+			const updated = rewritePrettier(JSON.stringify(pkg["lint-staged"]));
+			if (updated) {
+				pkg["lint-staged"] = JSON.parse(updated);
+				changed = true;
+			}
+		}
+		return changed ? pkg : void 0;
+	});
+}
+function rewritePrettierLintStagedConfigFiles(projectPath, report) {
+	rewriteToolLintStagedConfigFiles(projectPath, rewritePrettier, "prettier", report);
+}
+function warnPackageLevelPrettier() {
+	log.warn("Prettier detected in workspace packages but no root config found. Package-level Prettier must be migrated manually.");
+}
+async function confirmPrettierMigration(interactive) {
+	if (interactive) {
+		const confirmed = await confirm({
+			message: "Migrate Prettier to Oxfmt?\n  " + styleText("gray", "Oxfmt is Vite+'s built-in formatter that replaces Prettier with faster performance. Your configuration will be converted automatically."),
+			initialValue: true
+		});
+		if (isCancel(confirmed)) cancelAndExit();
+		return confirmed;
+	}
+	log.info("Prettier configuration detected. Auto-migrating to Oxfmt...");
+	return true;
+}
+async function promptPrettierMigration(projectPath, interactive, packages) {
+	const prettierProject = detectPrettierProject(projectPath, packages);
+	if (!prettierProject.hasDependency) return false;
+	if (!prettierProject.configFile) {
+		warnPackageLevelPrettier();
+		return false;
+	}
+	if (!await confirmPrettierMigration(interactive)) return false;
+	if (!await migratePrettierToOxfmt(projectPath, interactive, prettierProject.configFile, packages)) cancelAndExit("Prettier migration failed.", 1);
+	return true;
+}
+//#endregion
 //#region src/migration/migrator/tsconfig.ts
 function cleanupDeprecatedTsconfigOptions(projectPath, silent = false, report) {
 	const deprecatedOptions = ["esModuleInterop", "allowSyntheticDefaultImports"];
@@ -767,6 +931,66 @@ function hasTsconfigTypesToRewrite(projectPath) {
 	return findTsconfigFiles(projectPath).some((filePath) => hasTypesToRewriteInTsconfig(filePath));
 }
 //#endregion
+//#region src/migration/migrator/framework-shim.ts
+const FRAMEWORK_SHIMS = {
+	vue: [
+		"declare module '*.vue' {",
+		"  import type { DefineComponent } from 'vue';",
+		"  const component: DefineComponent<{}, {}, unknown>;",
+		"  export default component;",
+		"}"
+	].join("\n"),
+	astro: "/// <reference types=\"astro/client\" />"
+};
+function detectFramework(projectPath) {
+	const packageJsonPath = path.join(projectPath, "package.json");
+	if (!fs.existsSync(packageJsonPath)) return [];
+	const pkg = readJsonFile(packageJsonPath);
+	const allDeps = {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	};
+	return ["vue", "astro"].filter((framework) => !!allDeps[framework]);
+}
+function getEnvDtsPath(projectPath) {
+	const srcEnvDts = path.join(projectPath, "src", "env.d.ts");
+	const rootEnvDts = path.join(projectPath, "env.d.ts");
+	for (const candidate of [srcEnvDts, rootEnvDts]) if (fs.existsSync(candidate)) return candidate;
+	return fs.existsSync(path.join(projectPath, "src")) ? srcEnvDts : rootEnvDts;
+}
+function hasFrameworkShim(projectPath, framework) {
+	const dirsToScan = [projectPath, path.join(projectPath, "src")];
+	for (const dir of dirsToScan) {
+		if (!fs.existsSync(dir)) continue;
+		let entries;
+		try {
+			entries = fs.readdirSync(dir);
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (!entry.endsWith(".d.ts")) continue;
+			const content = fs.readFileSync(path.join(dir, entry), "utf-8");
+			if (framework === "astro") {
+				if (content.includes("astro/client")) return true;
+			} else if (content.includes(`'*.${framework}'`) || content.includes(`"*.${framework}"`)) return true;
+		}
+	}
+	return false;
+}
+function addFrameworkShim(projectPath, framework, report) {
+	const envDtsPath = getEnvDtsPath(projectPath);
+	const shim = FRAMEWORK_SHIMS[framework];
+	if (fs.existsSync(envDtsPath)) {
+		const existing = fs.readFileSync(envDtsPath, "utf-8");
+		fs.writeFileSync(envDtsPath, `${existing.trimEnd()}\n\n${shim}\n`, "utf-8");
+	} else {
+		fs.mkdirSync(path.dirname(envDtsPath), { recursive: true });
+		fs.writeFileSync(envDtsPath, `${shim}\n`, "utf-8");
+	}
+	if (report) report.frameworkShimAdded = true;
+}
+//#endregion
 //#region src/migration/migrator/vitest-ecosystem.ts
 var import_dist = require_dist();
 const VITEST_ALIGN_EXCLUDED = /* @__PURE__ */ new Set(["@vitest/eslint-plugin", "@vitest/coverage-c8"]);
@@ -1062,7 +1286,6 @@ function collectVitestEcosystemInstallDependencyNames(rootDir, packages) {
 }
 //#endregion
 //#region ../../node_modules/.pnpm/balanced-match@4.0.4/node_modules/balanced-match/dist/esm/index.js
-var import_cross_spawn = /* @__PURE__ */ __toESM(require_cross_spawn(), 1);
 const balanced = (a, b, str) => {
 	const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
 	const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
@@ -1252,7 +1475,7 @@ function expand_(str, max, isTop) {
 }
 //#endregion
 //#region ../../node_modules/.pnpm/minimatch@10.2.4/node_modules/minimatch/dist/esm/assert-valid-pattern.js
-const MAX_PATTERN_LENGTH = 1024 * 64;
+const MAX_PATTERN_LENGTH = 65536;
 const assertValidPattern = (pattern) => {
 	if (typeof pattern !== "string") throw new TypeError("invalid pattern");
 	if (pattern.length > MAX_PATTERN_LENGTH) throw new TypeError("pattern is too long");
@@ -3982,12 +4205,15 @@ while (this[FLUSHCHUNK](this[BUFFERSHIFT]()) && this[BUFFER].length);
 		return isStream;
 	}
 };
+//#endregion
+//#region ../../node_modules/.pnpm/path-scurry@2.0.1/node_modules/path-scurry/dist/esm/index.js
+const realpathSync$2 = realpathSync$1.native;
 const defaultFS = {
-	lstatSync,
+	lstatSync: lstatSync$1,
 	readdir,
 	readdirSync,
 	readlinkSync,
-	realpathSync: realpathSync$1.native,
+	realpathSync: realpathSync$2,
 	promises: {
 		lstat,
 		readdir: readdir$1,
@@ -4055,7 +4281,7 @@ var ResolveCache = class extends L {
 * @internal
 */
 var ChildrenCache = class extends L {
-	constructor(maxSize = 16 * 1024) {
+	constructor(maxSize = 16384) {
 		super({
 			maxSize,
 			sizeCalculation: (a) => a.length + 1
@@ -4388,7 +4614,7 @@ var PathBase = class {
 		return this[`is${type}`]();
 	}
 	getType() {
-		return this.isUnknown() ? "Unknown" : this.isDirectory() ? "Directory" : this.isFile() ? "File" : this.isSymbolicLink() ? "SymbolicLink" : this.isFIFO() ? "FIFO" : this.isCharacterDevice() ? "CharacterDevice" : this.isBlockDevice() ? "BlockDevice" : 		/* c8 ignore start */ this.isSocket() ? "Socket" : "Unknown";
+		return this.isUnknown() ? "Unknown" : this.isDirectory() ? "Directory" : this.isFile() ? "File" : this.isSymbolicLink() ? "SymbolicLink" : this.isFIFO() ? "FIFO" : this.isCharacterDevice() ? "CharacterDevice" : this.isBlockDevice() ? "BlockDevice" : /* c8 ignore start */ this.isSocket() ? "Socket" : "Unknown";
 		/* c8 ignore stop */
 	}
 	/**
@@ -5013,7 +5239,7 @@ var PathScurryBase = class {
 	*
 	* @internal
 	*/
-	constructor(cwd = process.cwd(), pathImpl, sep, { nocase, childrenCacheSize = 16 * 1024, fs = defaultFS } = {}) {
+	constructor(cwd = process.cwd(), pathImpl, sep, { nocase, childrenCacheSize = 16384, fs = defaultFS } = {}) {
 		this.#fs = fsFromOption(fs);
 		if (cwd instanceof URL || cwd.startsWith("file://")) cwd = fileURLToPath(cwd);
 		const cwdPath = pathImpl.resolve(cwd);
@@ -6504,6 +6730,96 @@ const glob = Object.assign(glob_, {
 });
 glob.glob = glob;
 //#endregion
+//#region src/utils/workspace.ts
+async function detectWorkspace$1(rootDir) {
+	const bindingResult = await detectWorkspace(rootDir);
+	const result = {
+		rootDir,
+		packageManager: void 0,
+		packageManagerVersion: "latest",
+		isMonorepo: false,
+		monorepoScope: "",
+		workspacePatterns: [],
+		parentDirs: [],
+		packages: []
+	};
+	if (bindingResult.packageManagerName) result.packageManager = bindingResult.packageManagerName;
+	if (bindingResult.packageManagerVersion) result.packageManagerVersion = bindingResult.packageManagerVersion;
+	if (bindingResult.isMonorepo) result.isMonorepo = bindingResult.isMonorepo;
+	if (bindingResult.root) result.rootDir = bindingResult.root;
+	if (result.isMonorepo) {
+		const pnpmWorkspaceFile = path.join(result.rootDir, "pnpm-workspace.yaml");
+		const packageJsonFile = path.join(result.rootDir, "package.json");
+		if (fs.existsSync(pnpmWorkspaceFile)) {
+			const workspaceConfig = readYamlFile(pnpmWorkspaceFile);
+			if (Array.isArray(workspaceConfig.packages)) result.workspacePatterns = workspaceConfig.packages;
+		} else if (fs.existsSync(packageJsonFile)) {
+			const pkg = readJsonFile(packageJsonFile);
+			if (Array.isArray(pkg.workspaces)) result.workspacePatterns = pkg.workspaces;
+			else if (pkg.workspaces && Array.isArray(pkg.workspaces.packages)) result.workspacePatterns = pkg.workspaces.packages;
+		}
+		const dirs = /* @__PURE__ */ new Set();
+		for (const pattern of result.workspacePatterns) {
+			if (!pattern.endsWith("*")) continue;
+			const dir = pattern.replace(/\/\*{1,2}$/, "");
+			if (dir) dirs.add(dir);
+		}
+		result.parentDirs = Array.from(dirs).sort();
+		const pkg = readJsonFile(packageJsonFile);
+		if (pkg.name) result.monorepoScope = getScopeFromPackageName(pkg.name);
+		result.packages = discoverWorkspacePackages(result.workspacePatterns, result.rootDir);
+	}
+	return result;
+}
+function isBingoTemplate(pkg) {
+	return !!pkg.dependencies?.bingo;
+}
+function discoverWorkspacePackages(workspacePatterns, rootDir) {
+	const packages = [];
+	if (workspacePatterns.length === 0) return packages;
+	const packageJsonRelativePaths = globSync(workspacePatterns.map((pattern) => `${pattern}/package.json`), {
+		absolute: false,
+		cwd: rootDir,
+		ignore: ["**/node_modules/**"]
+	});
+	for (const packageJsonRelativePath of packageJsonRelativePaths) {
+		const packageJsonPath = path.join(rootDir, packageJsonRelativePath);
+		const pkg = readJsonFile(packageJsonPath);
+		if (!pkg.name) continue;
+		packages.push({
+			name: pkg.name,
+			path: path.dirname(packageJsonRelativePath).split(path.sep).join("/"),
+			description: pkg.description,
+			version: pkg.version
+		});
+	}
+	return packages;
+}
+function updatePackageJsonWithDeps(rootDir, projectDir, dependencies, dependencyType) {
+	const packageJsonPath = path.join(rootDir, projectDir, "package.json");
+	editJsonFile(packageJsonPath, (pkg) => {
+		if (!pkg[dependencyType]) pkg[dependencyType] = {};
+		for (const dep of dependencies) pkg[dependencyType][dep] = "workspace:*";
+		return pkg;
+	});
+}
+function updateWorkspaceConfig(projectPath, workspaceInfo) {
+	for (const pattern of workspaceInfo.workspacePatterns) if (minimatch(projectPath, pattern)) return;
+	const parentDir = path.dirname(projectPath);
+	const pattern = parentDir === "." ? projectPath : `${parentDir}/*`;
+	if (workspaceInfo.packageManager === PackageManager.pnpm) editYamlFile(path.join(workspaceInfo.rootDir, "pnpm-workspace.yaml"), (doc) => {
+		let packages = doc.getIn(["packages"]);
+		if (!packages) packages = new import_dist.YAMLSeq();
+		packages.add(new import_dist.Scalar(pattern));
+		doc.setIn(["packages"], packages);
+	});
+	else editJsonFile(path.join(workspaceInfo.rootDir, "package.json"), (pkg) => {
+		if (pkg.workspaces && !Array.isArray(pkg.workspaces)) pkg.workspaces.packages = [...pkg.workspaces.packages || [], pattern];
+		else pkg.workspaces = [...pkg.workspaces || [], pattern];
+		return pkg;
+	});
+}
+//#endregion
 //#region src/migration/migrator/catalog.ts
 const BROWSER_PROVIDER_POSTINSTALL_PACKAGES = ["edgedriver", "geckodriver"];
 const PUBLIC_PEER_DEPENDENCY_FALLBACKS = {
@@ -6684,7 +7000,8 @@ function rewritePnpmWorkspaceYaml(projectPath, pnpmMajorVersion, shouldAllowBrow
 * so all overrides must live in pnpm-workspace.yaml.
 */
 function migratePnpmOverridesToWorkspaceYaml(projectPath, overrides) {
-	editYamlFile(path.join(projectPath, "pnpm-workspace.yaml"), (doc) => {
+	const pnpmWorkspaceYamlPath = path.join(projectPath, "pnpm-workspace.yaml");
+	editYamlFile(pnpmWorkspaceYamlPath, (doc) => {
 		for (const [key, value] of Object.entries(overrides)) doc.setIn(["overrides", scalarString(key)], scalarString(value));
 	});
 }
@@ -8059,6 +8376,24 @@ function isProtocolPinnedSpec(spec) {
 }
 //#endregion
 //#region src/migration/migrator/vite-config.ts
+const SVELTE_RUNE_GLOBALS = {
+	$state: "readonly",
+	$derived: "readonly",
+	$effect: "readonly",
+	$props: "readonly",
+	$bindable: "readonly",
+	$inspect: "readonly",
+	$host: "readonly"
+};
+function ensureSvelteRuneGlobals(config) {
+	for (const override of config.overrides ?? []) {
+		if (!override.files.some((file) => !file.startsWith("!") && braceExpand(file).some((pattern) => pattern.includes(".svelte")))) continue;
+		override.globals = {
+			...SVELTE_RUNE_GLOBALS,
+			...override.globals
+		};
+	}
+}
 function removeLintStagedFromPackageJson(packageJsonPath) {
 	editJsonFile(packageJsonPath, (pkg) => {
 		if (pkg["lint-staged"]) {
@@ -8125,7 +8460,8 @@ function mergeTsdownConfigFile(projectPath, silent = false, report) {
 		mergeAndRemoveJsonConfig(projectPath, viteConfig, configs.tsdownConfig, "pack", silent, report);
 		return;
 	}
-	const result = mergeTsdownConfig(fullViteConfigPath, `./${configs.tsdownConfig}`);
+	const tsdownRelativePath = `./${configs.tsdownConfig}`;
+	const result = mergeTsdownConfig(fullViteConfigPath, tsdownRelativePath);
 	if (result.updated) {
 		fs.writeFileSync(fullViteConfigPath, result.content);
 		if (report) report.tsdownImportCount++;
@@ -8149,7 +8485,9 @@ function mergeViteConfigFiles(projectPath, silent = false, report, packages, wor
 			if (oxlintJson.options.typeCheck === void 0) oxlintJson.options.typeCheck = true;
 		} else warnMigration(BASEURL_TSCONFIG_WARNING, report);
 		sanitizeMigratedOxlintConfig(oxlintJson, collectInstalledPackageNames(workspaceRoot ?? projectPath, packages), report);
-		writeJsonFile(fullOxlintPath, ensureVitePlusImportRuleDefaults(oxlintJson));
+		ensureSvelteRuneGlobals(oxlintJson);
+		const normalizedOxlintConfig = ensureVitePlusImportRuleDefaults(oxlintJson);
+		writeJsonFile(fullOxlintPath, normalizedOxlintConfig);
 		mergeAndRemoveJsonConfig(projectPath, viteConfig, configs.oxlintConfig, "lint", silent, report);
 	}
 	if (configs.oxfmtConfig) mergeAndRemoveJsonConfig(projectPath, viteConfig, configs.oxfmtConfig, "fmt", silent, report);
@@ -8296,54 +8634,40 @@ function rewriteAllImports(projectPath, silent = false, report, preserveNuxtVite
 }
 //#endregion
 //#region src/migration/migrator/git-hooks.ts
-/**
-* Check if the project has an unsupported husky version (<9.0.0).
-* Uses `semver.coerce` to handle ranges like `^8.0.0` → `8.0.0`.
-* When the specifier is a catalog reference (e.g. `"catalog:"`), resolves
-* it from the active package manager's catalog first — a `catalog:` spec is
-* only meaningful to the manager that owns the workspace, so we never read a
-* leftover/foreign catalog file. When it is still not coercible (e.g.
-* `"latest"`), falls back to the installed version in node_modules via
-* `detectPackageMetadata`.
-* Returns a reason string if hooks migration should be skipped, or null
-* if husky is absent or compatible.
-*/
-function checkUnsupportedHuskyVersion(projectPath, deps, prodDeps, packageManager) {
-	const huskyVersion = deps?.husky ?? prodDeps?.husky;
-	if (!huskyVersion) return null;
-	let coerced = import_semver.default.coerce(huskyVersion);
-	if (coerced == null && packageManager != null && huskyVersion.startsWith("catalog:")) {
-		const resolved = createCatalogDependencyResolver(projectPath, packageManager)?.(huskyVersion, "husky");
-		if (resolved) coerced = import_semver.default.coerce(resolved);
-	}
-	if (coerced == null) {
-		const installed = detectPackageMetadata(projectPath, "husky");
-		if (installed) coerced = import_semver.default.coerce(installed.version);
-		if (coerced == null) return `Could not determine husky version from "${huskyVersion}" — please specify a semver-compatible version (e.g., "^9.0.0") and re-run migration.`;
-	}
-	if (import_semver.default.satisfies(coerced, "<9.0.0")) return "Detected husky <9.0.0 — please upgrade to husky v9+ first, then re-run migration.";
-	return null;
-}
+var import_cross_spawn = /* @__PURE__ */ __toESM(require_cross_spawn(), 1);
 const OTHER_HOOK_TOOLS = [
 	"simple-git-hooks",
 	"lefthook",
 	"yorkie"
 ];
-const REPLACED_HOOK_PACKAGES = ["husky", "lint-staged"];
-function removeReplacedHookPackages(packageJsonPath) {
+const SUPPORTED_GIT_HOOK_NAME_SET = new Set(SUPPORTED_GIT_HOOK_NAMES);
+function removeReplacedStagedPackage(packageJsonPath) {
 	editJsonFile(packageJsonPath, (pkg) => {
-		for (const name of REPLACED_HOOK_PACKAGES) {
-			if (pkg.devDependencies?.[name]) delete pkg.devDependencies[name];
-			if (pkg.dependencies?.[name]) delete pkg.dependencies[name];
-		}
+		if (pkg.devDependencies?.["lint-staged"]) delete pkg.devDependencies["lint-staged"];
+		if (pkg.dependencies?.["lint-staged"]) delete pkg.dependencies["lint-staged"];
 		return pkg;
 	});
 }
 function detectLegacyGitHooksMigrationCandidate(projectPath) {
 	const packageJsonPath = path.join(projectPath, "package.json");
 	if (!fs.existsSync(packageJsonPath)) return false;
-	const pkg = readJsonFile(packageJsonPath);
-	return getOldHooksDir(projectPath) !== void 0 || pkg["lint-staged"] !== void 0;
+	return readJsonFile(packageJsonPath)["lint-staged"] !== void 0;
+}
+function hasHuskySetup(projectPath, pkg) {
+	return pkg.devDependencies?.husky !== void 0 || pkg.dependencies?.husky !== void 0 || pkg.optionalDependencies?.husky !== void 0 || pkg.peerDependencies?.husky !== void 0 || pkg.husky !== void 0 || (pkg.scripts?.prepare ? /\bhusky\b/.test(pkg.scripts.prepare) : false) || fs.existsSync(path.join(projectPath, ".husky"));
+}
+function hasExistingViteHooksPolicy(projectPath) {
+	const hooksDir = path.join(projectPath, ".vite-hooks");
+	if (!fs.lstatSync(hooksDir, { throwIfNoEntry: false })?.isDirectory()) return false;
+	return fs.readdirSync(hooksDir, { withFileTypes: true }).some((entry) => entry.isFile() && SUPPORTED_GIT_HOOK_NAME_SET.has(entry.name));
+}
+function findNonRegularViteHookPath(projectPath) {
+	for (const hookName of SUPPORTED_GIT_HOOK_NAMES) {
+		const hookPath = path.join(projectPath, ".vite-hooks", hookName);
+		const stats = fs.lstatSync(hookPath, { throwIfNoEntry: false });
+		if (stats && !stats.isFile()) return path.join(".vite-hooks", hookName);
+	}
+	return null;
 }
 /**
 * Walk up from `startPath` looking for `.git` (directory or file — submodules
@@ -8358,36 +8682,45 @@ function findGitRoot(startPath) {
 		dir = parent;
 	}
 }
-/**
-* Normalize "husky install [dir]" → "husky [dir]" so downstream regex
-* and ast-grep rules can match a single pattern.
-*/
-function collapseHuskyInstall(script) {
-	return script.replace("husky install ", "husky ").replace("husky install", "husky");
-}
-/**
-* High-level helper: detect old hooks dir, set up git hooks, and rewrite
-* the prepare script.  Returns true if hooks were successfully installed.
-*/
-function installGitHooks(projectPath, silent = false, report, packageManager) {
-	if (setupGitHooks(projectPath, getOldHooksDir(projectPath), silent, report, packageManager)) {
-		rewritePrepareScript(projectPath);
-		return true;
+function findWorkspacePackageHookPolicy(workspaceRoot, packages) {
+	for (const pkg of packages) {
+		const packagePath = path.join(workspaceRoot, pkg.path);
+		if (hasExistingViteHooksPolicy(packagePath)) return `Detected project-owned Vite+ hooks in workspace package "${pkg.path}" — leaving the existing hook setup unchanged.`;
+		const packageJsonPath = path.join(packagePath, "package.json");
+		const pkgContent = fs.existsSync(packageJsonPath) ? readJsonFile(packageJsonPath) : {};
+		if (hasHuskySetup(packagePath, pkgContent)) return `Detected Husky in workspace package "${pkg.path}" — leaving its hooks, configuration, and dependencies unchanged.`;
+		const deps = pkgContent.devDependencies;
+		const prodDeps = pkgContent.dependencies;
+		for (const tool of OTHER_HOOK_TOOLS) if (deps?.[tool] || prodDeps?.[tool] || pkgContent[tool]) return `Detected ${tool} in workspace package "${pkg.path}" — leaving the existing hook setup unchanged.`;
+		const gitRoot = findGitRoot(packagePath);
+		if (gitRoot && path.resolve(packagePath) === path.resolve(gitRoot)) {
+			const configuredHooksPath = getConfiguredHooksPath(packagePath);
+			const normalizedHooksPath = normalizeGitHooksPath(configuredHooksPath);
+			if (configuredHooksPath && normalizedHooksPath !== ".vite-hooks/_") return `core.hooksPath is already set to "${configuredHooksPath}" in workspace package "${pkg.path}" — leaving the existing hook setup unchanged.`;
+		}
 	}
-	return false;
+	return null;
+}
+function getConfiguredHooksPath(projectPath) {
+	const result = import_cross_spawn.default.sync("git", [
+		"config",
+		"--get",
+		"core.hooksPath"
+	], {
+		cwd: projectPath,
+		stdio: "pipe"
+	});
+	return result.status === 0 ? result.stdout?.toString().trim() ?? "" : "";
+}
+function normalizeGitHooksPath(hooksPath) {
+	return path.posix.normalize(hooksPath.replaceAll("\\", "/")).replace(/\/$/, "");
 }
 /**
-* Read-only probe: extract the old husky hooks directory from `scripts.prepare`
-* without modifying package.json. Returns undefined when no husky reference is found.
+* High-level helper that sets up Vite+ hooks when no other hook tool owns the
+* project. Husky setups are deliberately preserved for a dedicated migration.
 */
-function getOldHooksDir(rootDir) {
-	const packageJsonPath = path.join(rootDir, "package.json");
-	if (!fs.existsSync(packageJsonPath)) return;
-	const pkg = readJsonFile(packageJsonPath);
-	if (!pkg.scripts?.prepare) return;
-	const match = collapseHuskyInstall(pkg.scripts.prepare).match(/\bhusky(?:\s+([\w./-]+))?/);
-	if (!match) return;
-	return match[1] ?? ".husky";
+function installGitHooks(projectPath, silent = false, report, packageManager, packages = []) {
+	return setupGitHooks(projectPath, silent, report, packageManager, packages);
 }
 /**
 * Pre-flight check: verify that git hooks can be set up for this project.
@@ -8397,10 +8730,9 @@ function getOldHooksDir(rootDir) {
 * These checks are deterministic and read-only — they do not modify
 * the project in any way, making them safe to call before migration.
 *
-* `packageManager` is the project's detected manager; it scopes `catalog:`
-* resolution to that manager's catalog so a foreign catalog file is ignored.
+* The package manager argument remains for API compatibility with callers.
 */
-function preflightGitHooksSetup(projectPath, packageManager) {
+function preflightGitHooksSetup(projectPath, _packageManager, packages = []) {
 	const gitRoot = findGitRoot(projectPath);
 	if (gitRoot && path.resolve(projectPath) !== path.resolve(gitRoot)) return "Subdirectory project detected — skipping git hooks setup. Configure hooks at the repository root.";
 	const packageJsonPath = path.join(projectPath, "package.json");
@@ -8408,19 +8740,41 @@ function preflightGitHooksSetup(projectPath, packageManager) {
 	const pkgContent = readJsonFile(packageJsonPath);
 	const deps = pkgContent.devDependencies;
 	const prodDeps = pkgContent.dependencies;
+	const configuredHooksPath = gitRoot ? getConfiguredHooksPath(projectPath) : "";
+	const normalizedHooksPath = normalizeGitHooksPath(configuredHooksPath);
+	if (hasHuskySetup(projectPath, pkgContent) || normalizedHooksPath === ".husky" || normalizedHooksPath.startsWith(".husky/")) return "Detected Husky — leaving its hooks, configuration, and dependencies unchanged. Migrate Husky manually before enabling Vite+ hooks.";
 	for (const tool of OTHER_HOOK_TOOLS) if (deps?.[tool] || prodDeps?.[tool] || pkgContent[tool]) return `Detected ${tool} — skipping git hooks setup. Please configure git hooks manually, see https://viteplus.dev/guide/migrate#git-hook-tools`;
-	const huskyReason = checkUnsupportedHuskyVersion(projectPath, deps, prodDeps, packageManager);
-	if (huskyReason) return huskyReason;
+	const workspacePackageReason = findWorkspacePackageHookPolicy(projectPath, packages);
+	if (workspacePackageReason) return workspacePackageReason;
+	const disabledHooksEnvironment = [
+		"HUSKY",
+		"VP_GIT_HOOKS",
+		"VITE_GIT_HOOKS"
+	].find((name) => process.env[name] === "0");
+	if (disabledHooksEnvironment) return `Git hooks are disabled through ${disabledHooksEnvironment}=0 — skipping git hooks setup.`;
+	if (configuredHooksPath && normalizedHooksPath !== ".vite-hooks/_") return `core.hooksPath is already set to "${configuredHooksPath}" — leaving the existing hook setup unchanged.`;
+	const unsafeInstallPath = findUnsafeHookInstallPath(projectPath, ".vite-hooks");
+	if (unsafeInstallPath) return `Git hook dispatcher path "${unsafeInstallPath.relativePath}" is unsafe — leaving the existing hook setup unchanged.`;
+	const nonRegularHookPath = findNonRegularViteHookPath(projectPath);
+	if (nonRegularHookPath) return `Git hook path "${nonRegularHookPath}" is not a regular file — leaving the existing hook setup unchanged.`;
 	if (hasUnsupportedLintStagedConfig(projectPath)) return "Unsupported lint-staged config format — skipping git hooks setup. Please configure git hooks manually.";
 	return null;
 }
 /**
+* Decide whether config rewriting must leave lint-staged configuration in
+* place. Call this after scaffolding but before rewriting the project so an
+* existing hook owner never observes a partially migrated configuration.
+*/
+function shouldSkipStagedMigrationForHooks(projectPath, shouldSetupHooks, packageManager, packages = []) {
+	return !shouldSetupHooks || hasExistingViteHooksPolicy(projectPath) || preflightGitHooksSetup(projectPath, packageManager, packages) !== null;
+}
+/**
 * Set up git hooks with husky + lint-staged via vp commands.
 * Skips if another hook tool is detected (warns user).
 * Returns true if hooks were successfully set up, false if skipped.
 */
-function setupGitHooks(projectPath, oldHooksDir, silent = false, report, packageManager) {
-	const reason = preflightGitHooksSetup(projectPath, packageManager);
+function setupGitHooks(projectPath, silent = false, report, packageManager, packages = []) {
+	const reason = preflightGitHooksSetup(projectPath, packageManager, packages);
 	if (reason) {
 		warnMigration(reason, report);
 		return false;
@@ -8428,73 +8782,29 @@ function setupGitHooks(projectPath, oldHooksDir, silent = false, report, package
 	const packageJsonPath = path.join(projectPath, "package.json");
 	if (!fs.existsSync(packageJsonPath)) return false;
 	const gitRoot = findGitRoot(projectPath);
-	const isCustomDir = oldHooksDir != null && oldHooksDir !== ".husky";
-	const hooksDir = isCustomDir ? oldHooksDir : ".vite-hooks";
+	const hooksDir = ".vite-hooks";
+	const hasExistingHookPolicy = hasExistingViteHooksPolicy(projectPath);
 	editJsonFile(packageJsonPath, (pkg) => {
 		if (!pkg.scripts) pkg.scripts = {};
 		if (!pkg.scripts.prepare) pkg.scripts.prepare = "vp config";
-		else if (!pkg.scripts.prepare.includes("vp config") && !/\bhusky\b/.test(pkg.scripts.prepare)) pkg.scripts.prepare = `vp config && ${pkg.scripts.prepare}`;
+		else if (!pkg.scripts.prepare.includes("vp config")) pkg.scripts.prepare = `vp config && ${pkg.scripts.prepare}`;
 		return pkg;
 	});
 	let stagedMerged = hasStagedConfigInViteConfig(projectPath);
 	const hasStandaloneConfig = hasStandaloneLintStagedConfig(projectPath);
-	if (!stagedMerged && !hasStandaloneConfig) {
+	if (!hasExistingHookPolicy && !stagedMerged && !hasStandaloneConfig) {
 		const stagedConfig = readJsonFile(packageJsonPath)?.["lint-staged"] ?? DEFAULT_STAGED_CONFIG;
 		const updated = rewriteScripts(JSON.stringify(stagedConfig), readRulesYaml());
 		stagedMerged = mergeStagedConfigToViteConfig(projectPath, updated ? JSON.parse(updated) : stagedConfig, silent, report);
 	}
-	if (stagedMerged) removeLintStagedFromPackageJson(packageJsonPath);
-	if (oldHooksDir && !isCustomDir) {
-		const oldDir = path.join(projectPath, oldHooksDir);
-		if (fs.existsSync(oldDir)) {
-			const targetDir = path.join(projectPath, hooksDir);
-			fs.mkdirSync(targetDir, { recursive: true });
-			for (const entry of fs.readdirSync(oldDir, { withFileTypes: true })) {
-				if (entry.isDirectory() || entry.name.startsWith(".")) continue;
-				const src = path.join(oldDir, entry.name);
-				const dest = path.join(targetDir, entry.name);
-				fs.copyFileSync(src, dest);
-				fs.chmodSync(dest, 493);
-			}
-			fs.rmSync(oldDir, {
-				recursive: true,
-				force: true
-			});
-		}
-	}
-	if (stagedMerged) createPreCommitHook(projectPath, hooksDir);
+	if (!hasExistingHookPolicy && stagedMerged) removeLintStagedFromPackageJson(packageJsonPath);
+	if (!hasExistingHookPolicy && stagedMerged) createPreCommitHook(projectPath, hooksDir);
 	if (!gitRoot) {
-		removeReplacedHookPackages(packageJsonPath);
+		if (!hasExistingHookPolicy && stagedMerged) removeReplacedStagedPackage(packageJsonPath);
 		return true;
 	}
-	if (oldHooksDir) {
-		const checkResult = import_cross_spawn.default.sync("git", [
-			"config",
-			"--local",
-			"core.hooksPath"
-		], {
-			cwd: projectPath,
-			stdio: "pipe"
-		});
-		const existingPath = checkResult.status === 0 ? checkResult.stdout?.toString().trim() : "";
-		if (existingPath === `${oldHooksDir}/_` || existingPath === oldHooksDir) import_cross_spawn.default.sync("git", [
-			"config",
-			"--local",
-			"--unset",
-			"core.hooksPath"
-		], {
-			cwd: projectPath,
-			stdio: "pipe"
-		});
-	}
 	const vpBin = process.env.VP_CLI_BIN ?? "vp";
-	const configArgs = isCustomDir ? [
-		"config",
-		"--no-agent",
-		"--hooks-dir",
-		hooksDir
-	] : ["config", "--no-agent"];
-	const configResult = import_cross_spawn.default.sync(vpBin, configArgs, {
+	const configResult = import_cross_spawn.default.sync(vpBin, ["config", "--no-agent"], {
 		cwd: projectPath,
 		stdio: "pipe"
 	});
@@ -8504,7 +8814,7 @@ function setupGitHooks(projectPath, oldHooksDir, silent = false, report, package
 			warnMigration(`Git hooks not configured — ${stdout}`, report);
 			return false;
 		}
-		removeReplacedHookPackages(packageJsonPath);
+		if (!hasExistingHookPolicy && stagedMerged) removeReplacedStagedPackage(packageJsonPath);
 		if (report) report.gitHooksConfigured = true;
 		if (!silent) log.success("✔ Git hooks configured");
 		return true;
@@ -8529,85 +8839,14 @@ function hasUnsupportedLintStagedConfig(projectPath) {
 	if (fs.existsSync(lintstagedrcPath) && !isJsonFile(lintstagedrcPath)) return true;
 	return false;
 }
-/**
-* Create pre-commit hook file in the hooks directory.
-*/
-const STALE_LINT_STAGED_PATTERNS = [/^((?:[A-Z_][A-Z0-9_]*(?:=\S*)?\s+)*)(pnpm|pnpm exec|npx|yarn|yarn run|npm exec|npm run|bunx|bun run|bun x)\s+lint-staged\b/, /^((?:[A-Z_][A-Z0-9_]*(?:=\S*)?\s+)*)lint-staged\b/];
 const DEFAULT_STAGED_CONFIG = { "*": "vp check --fix" };
-/**
-* Ensure the pre-commit hook exists with `vp staged`, and that
-* vite.config.ts contains a `staged` block (using the default config
-* if none is present). Called by `vp config` after hook installation.
-*/
-function ensurePreCommitHook(projectPath, dir = ".vite-hooks") {
-	if (!hasStagedConfigInViteConfig(projectPath)) mergeStagedConfigToViteConfig(projectPath, DEFAULT_STAGED_CONFIG, true);
-	createPreCommitHook(projectPath, dir);
-}
 function createPreCommitHook(projectPath, dir = ".vite-hooks") {
 	const huskyDir = path.join(projectPath, dir);
 	fs.mkdirSync(huskyDir, { recursive: true });
 	const hookPath = path.join(huskyDir, "pre-commit");
-	if (fs.existsSync(hookPath)) {
-		const existing = fs.readFileSync(hookPath, "utf8");
-		if (existing.includes("vp staged")) return;
-		const lines = existing.split("\n");
-		let replaced = false;
-		const result = [];
-		for (const line of lines) {
-			const trimmed = line.trim();
-			if (!replaced) {
-				let matched = false;
-				for (const pattern of STALE_LINT_STAGED_PATTERNS) {
-					const match = pattern.exec(trimmed);
-					if (match) {
-						const parts = [
-							match[1]?.trim() ?? "",
-							"vp staged",
-							trimmed.slice(match[0].length).trim()
-						].filter(Boolean);
-						result.push(parts.join(" "));
-						replaced = true;
-						matched = true;
-						break;
-					}
-				}
-				if (matched) continue;
-			}
-			result.push(line);
-		}
-		if (!replaced) fs.writeFileSync(hookPath, `${result.join("\n").trimEnd()}\nvp staged\n`);
-		else fs.writeFileSync(hookPath, result.join("\n"));
-	} else {
-		fs.writeFileSync(hookPath, "vp staged\n");
-		fs.chmodSync(hookPath, 493);
-	}
-}
-/**
-* Rewrite only `scripts.prepare` in the root package.json using vite-prepare.yml rules.
-* Collapses "husky install" → "husky" before applying ast-grep so that the
-* replace-husky rule produces "vp config" with any directory argument preserved.
-* Returns the old husky hooks dir (if any) for migration to .vite-hooks.
-* Called only when hooks are being set up (not with --no-hooks).
-*/
-function rewritePrepareScript(rootDir) {
-	const packageJsonPath = path.join(rootDir, "package.json");
-	if (!fs.existsSync(packageJsonPath)) return;
-	let oldDir;
-	editJsonFile(packageJsonPath, (pkg) => {
-		if (!pkg.scripts?.prepare) return pkg;
-		const prepare = collapseHuskyInstall(pkg.scripts.prepare);
-		const updated = rewriteScripts(JSON.stringify({ prepare }), readPrepareRulesYaml());
-		if (updated) {
-			let newPrepare = JSON.parse(updated).prepare;
-			newPrepare = newPrepare.replace(/\bvp config(?:\s+(?!-)([\w./-]+))?/, (_match, dir) => {
-				oldDir = dir ?? ".husky";
-				return dir ? `vp config --hooks-dir ${dir}` : "vp config";
-			});
-			pkg.scripts.prepare = newPrepare;
-		} else if (prepare !== pkg.scripts.prepare) pkg.scripts.prepare = prepare;
-		return pkg;
-	});
-	return oldDir;
+	if (fs.existsSync(hookPath)) return;
+	fs.writeFileSync(hookPath, "vp staged\n");
+	fs.chmodSync(hookPath, 493);
 }
 //#endregion
 //#region src/migration/migrator/setup.ts
@@ -8750,10 +8989,9 @@ function migrateNodeVersionManagerFile(projectPath, detection, report) {
 //#endregion
 //#region src/migration/migrator/core-finalization.ts
 const RULES_YAML_PATH = path.join(rulesDir, "vite-tools.yml");
-const PREPARE_RULES_YAML_PATH = path.join(rulesDir, "vite-prepare.yml");
+path.join(rulesDir, "vite-prepare.yml");
 let cachedRulesYaml;
 let cachedRulesYamlNoLintStaged;
-let cachedPrepareRulesYaml;
 function readRulesYaml() {
 	cachedRulesYaml ??= fs.readFileSync(RULES_YAML_PATH, "utf8");
 	return cachedRulesYaml;
@@ -8764,10 +9002,6 @@ function getScriptRulesYaml(skipStagedMigration) {
 	cachedRulesYamlNoLintStaged ??= yaml.split("\n\n\n").filter((block) => !block.includes("id: replace-lint-staged")).join("\n\n\n");
 	return cachedRulesYamlNoLintStaged;
 }
-function readPrepareRulesYaml() {
-	cachedPrepareRulesYaml ??= fs.readFileSync(PREPARE_RULES_YAML_PATH, "utf8");
-	return cachedPrepareRulesYaml;
-}
 function getCoreMigrationProjectPaths(workspaceInfo) {
 	return [workspaceInfo.rootDir, ...(workspaceInfo.packages ?? []).map((pkg) => path.join(workspaceInfo.rootDir, pkg.path))];
 }
@@ -8995,300 +9229,186 @@ function rewriteMonorepoProject(projectPath, packageManager, skipStagedMigration
 	if (!deferLazyPluginWrapping) wrapLazyPluginsInViteConfig(projectPath, silent, report);
 }
 //#endregion
-//#region src/utils/agent.ts
-const AGENTS = [
-	{
-		id: "agents",
-		label: "AGENTS.md",
-		targetPath: "AGENTS.md",
-		hint: "Codex, Amp, OpenCode, and similar agents",
-		aliases: [
-			"agents.md",
-			"chatgpt",
-			"chatgpt-codex",
-			"codex",
-			"amp",
-			"kilo",
-			"kilo-code",
-			"kiro",
-			"kiro-cli",
-			"opencode",
-			"other"
-		]
-	},
-	{
-		id: "claude",
-		label: "CLAUDE.md",
-		targetPath: "CLAUDE.md",
-		hint: "Claude Code",
-		aliases: ["claude.md", "claude-code"]
-	},
-	{
-		id: "gemini",
-		label: "GEMINI.md",
-		targetPath: "GEMINI.md",
-		hint: "Gemini CLI",
-		aliases: ["gemini.md", "gemini-cli"]
-	},
-	{
-		id: "copilot",
-		label: ".github/copilot-instructions.md",
-		targetPath: ".github/copilot-instructions.md",
-		hint: "GitHub Copilot",
-		aliases: ["github-copilot", "copilot-instructions.md"]
-	},
-	{
-		id: "cursor",
-		label: ".cursor/rules/viteplus.mdc",
-		targetPath: ".cursor/rules/viteplus.mdc",
-		hint: "Cursor",
-		aliases: ["viteplus.mdc"]
+//#region src/utils/editor.ts
+const VSCODE_SETTINGS = {
+	"editor.defaultFormatter": "oxc.oxc-vscode",
+	"[javascript]": { "editor.defaultFormatter": "oxc.oxc-vscode" },
+	"[javascriptreact]": { "editor.defaultFormatter": "oxc.oxc-vscode" },
+	"[typescript]": { "editor.defaultFormatter": "oxc.oxc-vscode" },
+	"[typescriptreact]": { "editor.defaultFormatter": "oxc.oxc-vscode" },
+	"oxc.fmt.configPath": "./vite.config.ts",
+	"editor.formatOnSave": true,
+	"editor.formatOnSaveMode": "file",
+	"editor.codeActionsOnSave": { "source.fixAll.oxc": "explicit" }
+};
+const VSCODE_EXTENSIONS = { recommendations: ["VoidZero.vite-plus-extension-pack"] };
+const ZED_SETTINGS = {
+	lsp: {
+		oxlint: { initialization_options: { settings: {
+			run: "onType",
+			fixKind: "safe_fix",
+			typeAware: true,
+			unusedDisableDirectives: "deny"
+		} } },
+		oxfmt: { initialization_options: { settings: {
+			"fmt.configPath": "./vite.config.ts",
+			run: "onSave"
+		} } }
 	},
-	{
-		id: "jetbrains",
-		label: ".aiassistant/rules/viteplus.md",
-		targetPath: ".aiassistant/rules/viteplus.md",
-		hint: "JetBrains AI Assistant",
-		aliases: [
-			"jetbrains",
-			"jetbrains-ai-assistant",
-			"aiassistant",
-			"viteplus.md"
-		]
+	languages: Object.fromEntries([
+		"CSS",
+		"GraphQL",
+		"Handlebars",
+		"HTML",
+		"JavaScript",
+		"JSX",
+		"JSON",
+		"JSON5",
+		"JSONC",
+		"Less",
+		"Markdown",
+		"MDX",
+		"SCSS",
+		"TypeScript",
+		"TSX",
+		"Vue.js",
+		"YAML"
+	].map((language) => [language, {
+		format_on_save: "on",
+		prettier: { allowed: false },
+		formatter: [{ language_server: { name: "oxfmt" } }],
+		...language === "JavaScript" ? { code_action: "source.fixAll.oxc" } : {}
+	}]))
+};
+const EDITORS = [{
+	id: "vscode",
+	label: "VSCode",
+	targetDir: ".vscode",
+	files: {
+		"settings.json": VSCODE_SETTINGS,
+		"extensions.json": VSCODE_EXTENSIONS
+	}
+}, {
+	id: "zed",
+	label: "Zed",
+	targetDir: ".zed",
+	files: { "settings.json": ZED_SETTINGS }
+}];
+async function selectEditor({ interactive, editor, onCancel }) {
+	if (editor === false) return;
+	if (interactive && !editor) {
+		const editorOptions = EDITORS.map((option) => ({
+			label: option.label,
+			value: option.id,
+			hint: option.targetDir
+		}));
+		const otherOption = {
+			label: "Other",
+			value: null,
+			hint: "Skip writing editor configs"
+		};
+		const selectedEditor = await select({
+			message: "Which editor are you using?\n  " + styleText("gray", "Writes editor config files to enable recommended extensions and Oxlint/Oxfmt integrations."),
+			options: [...editorOptions, otherOption],
+			initialValue: "vscode"
+		});
+		if (isCancel(selectedEditor)) {
+			onCancel();
+			return;
+		}
+		if (selectedEditor === null) return;
+		return resolveEditorId(selectedEditor);
 	}
-];
-const AGENT_DEFAULT_ID = "agents";
-const AGENT_STANDARD_PATH = "AGENTS.md";
-const COPILOT_AGENT_ID = "copilot";
-const COPILOT_SETUP_WORKFLOW_PATH = ".github/workflows/copilot-setup-steps.yml";
-const AGENT_INSTRUCTIONS_START_MARKER = "<!--VITE PLUS START-->";
-const AGENT_INSTRUCTIONS_END_MARKER = "<!--VITE PLUS END-->";
-const AGENT_ALIASES = Object.fromEntries(AGENTS.flatMap((option) => (option.aliases ?? []).map((alias) => [normalizeAgentName(alias), option.id])));
-const COPILOT_SETUP_WORKFLOW_CONTENT = `name: "Copilot Setup Steps"
-
-on:
-  workflow_dispatch:
-  push:
-    paths:
-      - .github/workflows/copilot-setup-steps.yml
-  pull_request:
-    paths:
-      - .github/workflows/copilot-setup-steps.yml
-
-jobs:
-  copilot-setup-steps:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
-      - name: Set up Vite+
-        uses: voidzero-dev/setup-vp@v1
-        with:
-          cache: true
-          run-install: true
-      - name: Verify Vite+
-        run: vp --version
-`;
-async function selectAgentTargets({ interactive, agent, onCancel }) {
-	if (agent === false) return {
-		targetPaths: void 0,
-		selectedAgents: []
-	};
-	if (interactive && !agent) {
-		const selectedAgentIds = await multiselect({
-			message: "Which coding agent instruction files should Vite+ create?",
-			options: AGENTS.map((option) => ({
+	if (editor) return resolveEditorId(editor);
+}
+async function selectEditors({ interactive, editor, onCancel }) {
+	if (editor === false) return;
+	if (interactive && !editor) {
+		const selectedEditors = await multiselect({
+			message: "Which editors are you using?\n  " + styleText("gray", "Writes editor config files to enable recommended extensions and Oxlint/Oxfmt integrations."),
+			options: EDITORS.map((option) => ({
 				label: option.label,
 				value: option.id,
-				hint: option.hint
+				hint: option.targetDir
 			})),
-			initialValues: [AGENT_DEFAULT_ID],
+			initialValues: ["vscode"],
 			required: false
 		});
-		if (isCancel(selectedAgentIds)) {
+		if (isCancel(selectedEditors)) {
 			onCancel();
-			return {
-				targetPaths: void 0,
-				selectedAgents: []
-			};
+			return;
 		}
-		if (selectedAgentIds.length === 0) return {
-			targetPaths: void 0,
-			selectedAgents: []
-		};
-		const selectedAgents = resolveAgentOptions(selectedAgentIds);
-		return {
-			targetPaths: getAgentTargetPaths(selectedAgents),
-			selectedAgents
-		};
+		return selectedEditors.length === 0 ? void 0 : resolveEditorIds(selectedEditors);
 	}
-	const selectedAgents = resolveAgentOptions(agent ?? AGENT_DEFAULT_ID);
-	return {
-		targetPaths: getAgentTargetPaths(selectedAgents),
-		selectedAgents
-	};
-}
-async function selectAgentTargetPaths({ interactive, agent, onCancel }) {
-	return (await selectAgentTargets({
-		interactive,
-		agent,
-		onCancel
-	})).targetPaths;
-}
-function detectExistingAgentTargetPaths(projectRoot) {
-	const detectedPaths = [];
-	const seenTargetPaths = /* @__PURE__ */ new Set();
-	for (const option of AGENTS) {
-		if (seenTargetPaths.has(option.targetPath)) continue;
-		seenTargetPaths.add(option.targetPath);
-		const targetPath = path.join(projectRoot, option.targetPath);
-		if (fs.existsSync(targetPath) && !fs.lstatSync(targetPath).isSymbolicLink()) detectedPaths.push(option.targetPath);
+	if (editor) {
+		const editorId = resolveEditorId(editor);
+		return editorId ? [editorId] : void 0;
 	}
-	return detectedPaths.length > 0 ? detectedPaths : void 0;
-}
-/**
-* Silently update agent instruction files that contain Vite+ markers.
-* - No agent files → no writes
-* - No Vite+ markers → no writes
-* - Markers present, content up to date → no writes
-* - Markers present, content outdated → update marked section
-*/
-function updateExistingAgentInstructions(projectRoot) {
-	const targetPaths = detectExistingAgentTargetPaths(projectRoot);
-	if (!targetPaths) return;
-	const templatePath = path.join(pkgRoot, "AGENTS.md");
-	if (!fs.existsSync(templatePath)) return;
-	const templateContent = fs.readFileSync(templatePath, "utf-8");
-	for (const targetPath of targetPaths) try {
-		const fullPath = path.join(projectRoot, targetPath);
-		const existing = fs.readFileSync(fullPath, "utf-8");
-		const updated = replaceMarkedAgentInstructionsSection(existing, templateContent);
-		if (updated !== void 0 && updated !== existing) fs.writeFileSync(fullPath, updated);
-	} catch {}
 }
-function resolveAgentOptions(agent) {
-	const agentNames = parseAgentNames(agent);
-	const resolvedAgentNames = agentNames.length > 0 ? agentNames : [AGENT_DEFAULT_ID];
-	const dedupedAgents = [];
-	const seenAgentIds = /* @__PURE__ */ new Set();
-	for (const name of resolvedAgentNames) {
-		const option = resolveSingleAgentOption(name);
-		if (seenAgentIds.has(option.id)) continue;
-		seenAgentIds.add(option.id);
-		dedupedAgents.push(option);
-	}
-	return dedupedAgents;
-}
-function getAgentTargetPaths(agents) {
-	const dedupedTargetPaths = [];
-	const seenTargetPaths = /* @__PURE__ */ new Set();
-	for (const agent of agents) {
-		if (seenTargetPaths.has(agent.targetPath)) continue;
-		seenTargetPaths.add(agent.targetPath);
-		dedupedTargetPaths.push(agent.targetPath);
-	}
-	return dedupedTargetPaths;
-}
-function parseAgentNames(agent) {
-	if (!agent) return [];
-	return (Array.isArray(agent) ? agent : [agent]).filter((value) => typeof value === "string").flatMap((value) => value.split(",")).map((value) => value.trim()).filter((value) => value.length > 0);
-}
-function resolveSingleAgentOption(agent) {
-	const normalized = normalizeAgentName(agent);
-	const alias = AGENT_ALIASES[normalized];
-	const resolved = alias ? normalizeAgentName(alias) : normalized;
-	return AGENTS.find((option) => normalizeAgentName(option.id) === resolved || normalizeAgentName(option.label) === resolved || normalizeAgentName(option.targetPath) === resolved || option.aliases?.some((candidate) => normalizeAgentName(candidate) === resolved)) ?? AGENTS.find((option) => option.id === AGENT_DEFAULT_ID);
+function detectExistingEditors(projectRoot) {
+	const editors = [];
+	for (const option of EDITORS) for (const fileName of Object.keys(option.files)) {
+		const filePath = path.join(projectRoot, option.targetDir, fileName);
+		if (fs.existsSync(filePath)) {
+			editors.push(option.id);
+			break;
+		}
+	}
+	return editors.length === 0 ? void 0 : editors;
 }
 /**
-* Detect agent instruction files that would conflict (exist without markers).
-* Returns only files that need a user decision (append or skip).
+* Detect editor config files that would conflict (already exist).
 * Read-only — does not write or modify any files.
 */
-async function detectAgentConflicts({ projectRoot, targetPaths }) {
-	if (!targetPaths || targetPaths.length === 0) return [];
-	const sourcePath = path.join(pkgRoot, "AGENTS.md");
-	if (!fs.existsSync(sourcePath)) return [];
-	const incomingContent = await fsPromises.readFile(sourcePath, "utf-8");
-	const shouldLinkToAgents = targetPaths.includes(AGENT_STANDARD_PATH);
-	const orderedPaths = shouldLinkToAgents ? [AGENT_STANDARD_PATH, ...targetPaths.filter((p) => p !== AGENT_STANDARD_PATH)] : targetPaths;
+function detectEditorConflicts({ projectRoot, editorId }) {
+	if (!editorId) return [];
+	const editorConfig = EDITORS.find((e) => e.id === editorId);
+	if (!editorConfig) return [];
 	const conflicts = [];
-	const seenDestinationPaths = /* @__PURE__ */ new Set();
-	const seenRealPaths = /* @__PURE__ */ new Set();
-	for (const targetPathToCheck of orderedPaths) {
-		const destinationPath = path.join(projectRoot, targetPathToCheck);
-		const destinationKey = path.resolve(destinationPath);
-		if (seenDestinationPaths.has(destinationKey)) continue;
-		seenDestinationPaths.add(destinationKey);
-		if (shouldLinkToAgents && targetPathToCheck !== AGENT_STANDARD_PATH) {
-			if (await getExistingPathKind(destinationPath) !== "file") continue;
-		}
-		if (fs.existsSync(destinationPath)) {
-			if (fs.lstatSync(destinationPath).isSymbolicLink()) continue;
-			const destinationRealPath = await fsPromises.realpath(destinationPath);
-			if (seenRealPaths.has(destinationRealPath)) continue;
-			if (replaceMarkedAgentInstructionsSection(await fsPromises.readFile(destinationPath, "utf-8"), incomingContent) !== void 0) {
-				seenRealPaths.add(destinationRealPath);
-				continue;
-			}
-			conflicts.push({ targetPath: targetPathToCheck });
-			seenRealPaths.add(destinationRealPath);
-		}
+	for (const fileName of Object.keys(editorConfig.files)) {
+		const filePath = path.join(projectRoot, editorConfig.targetDir, fileName);
+		if (fs.existsSync(filePath)) conflicts.push({
+			fileName,
+			displayPath: `${editorConfig.targetDir}/${fileName}`
+		});
 	}
 	return conflicts;
 }
-async function writeAgentInstructions({ projectRoot, targetPath, targetPaths, interactive, conflictDecisions, silent = false }) {
-	const paths = [...targetPaths ?? [], ...targetPath ? [targetPath] : []];
-	if (paths.length === 0) return;
-	const sourcePath = path.join(pkgRoot, "AGENTS.md");
-	if (!fs.existsSync(sourcePath)) {
-		if (!silent) log.warn("Agent instructions template not found; skipping.");
-		return;
-	}
-	const seenDestinationPaths = /* @__PURE__ */ new Set();
-	const seenRealPaths = /* @__PURE__ */ new Set();
-	const incomingContent = await fsPromises.readFile(sourcePath, "utf-8");
-	const shouldLinkToAgents = paths.includes(AGENT_STANDARD_PATH);
-	const orderedPaths = shouldLinkToAgents ? [AGENT_STANDARD_PATH, ...paths.filter((p) => p !== AGENT_STANDARD_PATH)] : paths;
-	for (const targetPathToWrite of orderedPaths) {
-		const destinationPath = path.join(projectRoot, targetPathToWrite);
-		const destinationKey = path.resolve(destinationPath);
-		if (seenDestinationPaths.has(destinationKey)) continue;
-		seenDestinationPaths.add(destinationKey);
-		await fsPromises.mkdir(path.dirname(destinationPath), { recursive: true });
-		if (shouldLinkToAgents && targetPathToWrite !== AGENT_STANDARD_PATH) {
-			if (await tryLinkTargetToAgents(projectRoot, targetPathToWrite, silent)) continue;
-		}
-		if (fs.existsSync(destinationPath)) {
-			if (fs.lstatSync(destinationPath).isSymbolicLink()) {
-				if (!silent) log.info(`Skipped writing ${targetPathToWrite} (symlink)`);
-				continue;
-			}
-			const destinationRealPath = await fsPromises.realpath(destinationPath);
-			if (seenRealPaths.has(destinationRealPath)) {
-				if (!silent) log.info(`Skipped writing ${targetPathToWrite} (duplicate target)`);
-				continue;
-			}
-			const existingContent = await fsPromises.readFile(destinationPath, "utf-8");
-			const updatedContent = replaceMarkedAgentInstructionsSection(existingContent, incomingContent);
-			if (updatedContent !== void 0) {
-				if (updatedContent !== existingContent) await fsPromises.writeFile(destinationPath, updatedContent);
-				seenRealPaths.add(destinationRealPath);
-				continue;
-			}
+async function writeEditorConfigs({ projectRoot, editorId, interactive, conflictDecisions, silent = false, extraVsCodeSettings }) {
+	const editorIds = normalizeEditorSelection(editorId);
+	if (editorIds.length === 0) return;
+	for (const currentEditorId of editorIds) await writeEditorConfig({
+		projectRoot,
+		editorId: currentEditorId,
+		interactive,
+		conflictDecisions,
+		silent,
+		extraVsCodeSettings
+	});
+}
+async function writeEditorConfig({ projectRoot, editorId, interactive, conflictDecisions, silent, extraVsCodeSettings }) {
+	const editorConfig = EDITORS.find((e) => e.id === editorId);
+	if (!editorConfig) return;
+	const targetDir = path.join(projectRoot, editorConfig.targetDir);
+	await fsPromises.mkdir(targetDir, { recursive: true });
+	for (const [fileName, baseIncoming] of Object.entries(editorConfig.files)) {
+		const incoming = editorId === "vscode" && fileName === "settings.json" && extraVsCodeSettings ? {
+			...extraVsCodeSettings,
+			...baseIncoming
+		} : baseIncoming;
+		const filePath = path.join(targetDir, fileName);
+		if (fs.existsSync(filePath)) {
+			const displayPath = `${editorConfig.targetDir}/${fileName}`;
 			let conflictAction;
-			const preResolved = conflictDecisions?.get(targetPathToWrite);
+			const preResolved = conflictDecisions?.get(displayPath) ?? conflictDecisions?.get(fileName);
 			if (preResolved) conflictAction = preResolved;
 			else if (interactive) {
 				const action = await select({
-					message: `Agent instructions already exist at ${targetPathToWrite}.\n  ` + styleText("gray", "The Vite+ template includes guidance on `vp` commands, the build pipeline, and project conventions."),
+					message: `${displayPath} already exists.\n  ` + styleText("gray", `Vite+ adds ${editorConfig.label} settings for the built-in linter and formatter. Merge adds new keys without overwriting existing ones.`),
 					options: [{
-						label: "Append",
-						value: "append",
-						hint: "Add template content to the end"
+						label: "Merge",
+						value: "merge",
+						hint: "Merge new settings into existing file"
 					}, {
 						label: "Skip",
 						value: "skip",
@@ -9296,86 +9416,96 @@ async function writeAgentInstructions({ projectRoot, targetPath, targetPaths, in
 					}],
 					initialValue: "skip"
 				});
-				conflictAction = isCancel(action) || action === "skip" ? "skip" : "append";
-			} else conflictAction = "skip";
-			if (conflictAction === "append") await appendAgentContent(destinationPath, targetPathToWrite, existingContent, incomingContent, silent);
-			else {
-				const suffix = !preResolved && !interactive ? " (already exists)" : "";
-				if (!silent) log.info(`Skipped writing ${targetPathToWrite}${suffix}`);
-			}
-			seenRealPaths.add(destinationRealPath);
+				conflictAction = isCancel(action) || action === "skip" ? "skip" : "merge";
+			} else conflictAction = "merge";
+			if (conflictAction === "merge") mergeAndWriteEditorConfig(filePath, incoming, fileName, displayPath, silent);
+			else if (!silent) log.info(`Skipped writing ${displayPath}`);
 			continue;
 		}
-		await fsPromises.writeFile(destinationPath, incomingContent);
-		if (!silent) log.success(`Wrote agent instructions to ${targetPathToWrite}`);
-		seenRealPaths.add(await fsPromises.realpath(destinationPath));
+		writeJsonFile(filePath, incoming);
+		if (!silent) log.success(`Wrote editor config to ${editorConfig.targetDir}/${fileName}`);
 	}
 }
-async function writeCopilotSetupWorkflow({ projectRoot, silent = false }) {
-	const destinationPath = path.join(projectRoot, COPILOT_SETUP_WORKFLOW_PATH);
-	await fsPromises.mkdir(path.dirname(destinationPath), { recursive: true });
-	if (fs.existsSync(destinationPath)) {
-		if (!silent) log.info(`Skipped writing ${COPILOT_SETUP_WORKFLOW_PATH} (already exists)`);
+function normalizeEditorSelection(editorId) {
+	if (!editorId) return [];
+	return [...new Set(Array.isArray(editorId) ? editorId : [editorId])];
+}
+/**
+* Merge incoming settings into an existing editor JSON/JSONC file by patching the
+* original text with `jsonc-parser` instead of re-serializing a merged object.
+* This preserves comments, key order, trailing commas, and untouched formatting.
+* Existing values always win; only missing keys/branches are inserted.
+*/
+function mergeAndWriteEditorConfig(filePath, incoming, fileName, displayPath, silent = false) {
+	const originalText = fs.readFileSync(filePath, "utf-8");
+	const existing = parse(originalText);
+	if (!isPlainObject(existing)) throw new Error(`Cannot merge editor config: ${displayPath} is not a JSON object`);
+	const formattingOptions = detectFormattingOptions(originalText);
+	const newText = fileName === "extensions.json" ? mergeExtensionsText(originalText, existing, incoming, formattingOptions) : mergeSettingsText(originalText, existing, incoming, formattingOptions);
+	if (newText === originalText) {
+		if (!silent) log.info(`No changes needed for ${displayPath}`);
 		return;
 	}
-	await fsPromises.writeFile(destinationPath, COPILOT_SETUP_WORKFLOW_CONTENT);
-	if (!silent) log.success(`Wrote Copilot setup workflow to ${COPILOT_SETUP_WORKFLOW_PATH}`);
-}
-async function appendAgentContent(destinationPath, targetPath, existingContent, incomingContent, silent = false) {
-	const separator = existingContent.endsWith("\n") ? "" : "\n";
-	await fsPromises.appendFile(destinationPath, `${separator}\n${incomingContent}`);
-	if (!silent) log.success(`Appended agent instructions to ${targetPath}`);
-}
-function normalizeAgentName(value) {
-	return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "");
-}
-function replaceMarkedAgentInstructionsSection(existing, incoming) {
-	const existingRange = getMarkedRange(existing, AGENT_INSTRUCTIONS_START_MARKER, AGENT_INSTRUCTIONS_END_MARKER);
-	if (!existingRange) return;
-	const incomingRange = getMarkedRange(incoming, AGENT_INSTRUCTIONS_START_MARKER, AGENT_INSTRUCTIONS_END_MARKER);
-	if (!incomingRange) return;
-	return `${existing.slice(0, existingRange.start)}${incoming.slice(incomingRange.start, incomingRange.end)}${existing.slice(existingRange.end)}`;
-}
-async function tryLinkTargetToAgents(projectRoot, targetPath, silent = false) {
-	const destinationPath = path.join(projectRoot, targetPath);
-	const agentsPath = path.join(projectRoot, AGENT_STANDARD_PATH);
-	const symlinkTarget = path.relative(path.dirname(destinationPath), agentsPath);
-	const existing = await getExistingPathKind(destinationPath);
-	if (existing === "file") return false;
-	if (existing === "symlink") {
-		const currentLink = await fsPromises.readlink(destinationPath);
-		if (path.resolve(path.dirname(destinationPath), currentLink) === agentsPath) {
-			if (!silent) log.info(`Skipped linking ${targetPath} (already linked to ${AGENT_STANDARD_PATH})`);
-			return true;
-		}
-		await fsPromises.unlink(destinationPath);
-	}
-	try {
-		await fsPromises.symlink(symlinkTarget, destinationPath);
-	} catch (err) {
-		if (err.code === "EPERM") {
-			await fsPromises.copyFile(agentsPath, destinationPath);
-			if (!silent) log.success(`Copied ${AGENT_STANDARD_PATH} to ${targetPath}`);
-			return true;
+	fs.writeFileSync(filePath, newText, "utf-8");
+	if (!silent) log.success(`Merged editor config into ${displayPath}`);
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Apply a single `jsonc-parser` modification to `text` and return the patched text. */
+function applyJsoncEdit(text, path, value, options) {
+	return applyEdits(text, modify(text, path, value, options));
+}
+/**
+* Deep-merge missing keys from `incoming` into the existing text. Inserts a whole
+* branch when it is absent, and recurses only when both sides are non-array objects
+* so comments inside existing branches are preserved.
+*/
+function mergeSettingsText(text, existing, incoming, formattingOptions) {
+	let currentText = text;
+	const insertMissing = (existingNode, incomingNode, basePath) => {
+		for (const [key, value] of Object.entries(incomingNode)) {
+			const fullPath = [...basePath, key];
+			if (!(key in existingNode)) currentText = applyJsoncEdit(currentText, fullPath, value, { formattingOptions });
+			else if (isPlainObject(existingNode[key]) && isPlainObject(value)) insertMissing(existingNode[key], value, fullPath);
 		}
-		throw err;
+	};
+	insertMissing(existing, incoming, []);
+	return currentText;
+}
+/**
+* For `extensions.json`, append missing recommendations without rebuilding the array,
+* so comments inside the array survive. Existing entries always win.
+*/
+function mergeExtensionsText(text, existing, incoming, formattingOptions) {
+	const incomingRecs = Array.isArray(incoming["recommendations"]) ? incoming["recommendations"] : [];
+	const existingValue = existing["recommendations"];
+	if (!("recommendations" in existing)) return applyJsoncEdit(text, ["recommendations"], incomingRecs, { formattingOptions });
+	if (!Array.isArray(existingValue)) return text;
+	const existingRecs = new Set(existingValue);
+	let currentText = text;
+	let nextIndex = existingValue.length;
+	for (const rec of incomingRecs) {
+		if (existingRecs.has(rec)) continue;
+		currentText = applyJsoncEdit(currentText, ["recommendations", nextIndex], rec, {
+			formattingOptions,
+			isArrayInsertion: true
+		});
+		nextIndex++;
 	}
-	if (!silent) log.success(`Linked ${targetPath} to ${AGENT_STANDARD_PATH}`);
-	return true;
+	return currentText;
 }
-async function getExistingPathKind(filePath) {
-	if (!fs.existsSync(filePath)) return "missing";
-	return (await fsPromises.lstat(filePath)).isSymbolicLink() ? "symlink" : "file";
+function resolveEditorId(editor) {
+	const normalized = editor.trim().toLowerCase();
+	return EDITORS.find((option) => option.id === normalized || option.label.toLowerCase() === normalized)?.id;
 }
-function getMarkedRange(content, startMarker, endMarker) {
-	const start = content.indexOf(startMarker);
-	if (start === -1) return;
-	const endMarkerIndex = content.indexOf(endMarker, start + startMarker.length);
-	if (endMarkerIndex === -1) return;
-	return {
-		start,
-		end: endMarkerIndex + endMarker.length
-	};
+function resolveEditorIds(editors) {
+	const editorIds = editors.flatMap((editor) => {
+		const editorId = resolveEditorId(editor);
+		return editorId ? [editorId] : [];
+	});
+	const uniqueEditorIds = [...new Set(editorIds)];
+	return uniqueEditorIds.length === 0 ? void 0 : uniqueEditorIds;
 }
 //#endregion
-export { globSync as A, warnPackageLevelEslint as B, injectLintTypeCheckDefaults as C, ensureVitePlusBootstrap as D, detectVitePlusBootstrapPending as E, migrateEslintToOxlint as F, checkVitestVersion as G, PRETTIER_PACKAGE_JSON_CONFIG as H, promptEslintMigration as I, templatesDir as J, warnMigration as K, rewriteToolLintStagedConfigFiles as L, confirmEslintMigration as M, detectEslintProject as N, configureYarnNodeModulesMode as O, detectIncompatibleEslintIntegration as P, warnIncompatibleEslintIntegration as R, injectCreateDefaultTemplate as S, collectToolchainVersionChanges as T, detectConfigs as U, PRETTIER_CONFIG_FILES as V, checkViteVersion as W, detectLegacyGitHooksMigrationCandidate as _, selectAgentTargets as a, preflightGitHooksSetup as b, writeCopilotSetupWorkflow as c, rewriteStandaloneProject as d, detectPendingCoreMigration as f, setPackageManager as g, migrateNodeVersionManagerFile as h, selectAgentTargetPaths as i, minimatch as j, detectYarnPnpMode as k, rewriteMonorepo as l, detectNodeVersionManagerFile as m, detectAgentConflicts as n, updateExistingAgentInstructions as o, finalizeCoreMigrationForExistingVitePlus as p, displayRelative as q, detectExistingAgentTargetPaths as r, writeAgentInstructions as s, COPILOT_AGENT_ID as t, rewriteMonorepoProject as u, ensurePreCommitHook as v, mergeViteConfigFiles as w, hasStagedConfigInViteConfig as x, installGitHooks as y, warnLegacyEslintConfig as z };
+export { addFrameworkShim as A, detectIncompatibleEslintIntegration as B, ensureVitePlusBootstrap as C, isBingoTemplate as D, detectWorkspace$1 as E, migratePrettierToOxfmt as F, warnPackageLevelEslint as G, promptEslintMigration as H, promptPrettierMigration as I, checkViteVersion as K, warnPackageLevelPrettier as L, hasFrameworkShim as M, confirmPrettierMigration as N, updatePackageJsonWithDeps as O, detectPrettierProject as P, confirmEslintMigration as R, detectVitePlusBootstrapPending as S, detectYarnPnpMode as T, warnIncompatibleEslintIntegration as U, migrateEslintToOxlint as V, warnLegacyEslintConfig as W, shouldSkipStagedMigrationForHooks as _, writeEditorConfigs as a, mergeViteConfigFiles as b, rewriteStandaloneProject as c, detectNodeVersionManagerFile as d, migrateNodeVersionManagerFile as f, preflightGitHooksSetup as g, installGitHooks as h, selectEditors as i, detectFramework as j, updateWorkspaceConfig as k, detectPendingCoreMigration as l, detectLegacyGitHooksMigrationCandidate as m, detectExistingEditors as n, rewriteMonorepo as o, setPackageManager as p, checkVitestVersion as q, selectEditor as r, rewriteMonorepoProject as s, detectEditorConflicts as t, finalizeCoreMigrationForExistingVitePlus as u, injectCreateDefaultTemplate as v, configureYarnNodeModulesMode as w, collectToolchainVersionChanges as x, injectLintTypeCheckDefaults as y, detectEslintProject as z };