sv 0.17.0 → 1.0.0-next.0

package/dist/bin.mjs

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
-import { _ as name, a as detectPackageManager, d as Command, g as helpConfig, h as forwardExitCode, l as from, n as add, r as create, u as program, v as version } from "./engine-B7chsCPG.mjs";
-import { color, resolveCommandArray } from "@sveltejs/sv-utils";
+import { A as Command, B as name, C as pipe, D as union, E as transform, F as forwardExitCode, G as ge, H as Ce, I as helpConfig, J as we, K as le, L as normalizePosix, O as from, P as errorAndExit, R as runAndValidateVerifications, S as picklist, T as string, U as Ee, V as version, W as R$1, Y as R, _ as array, a as verifyCleanWorkingDirectory, b as optional, c as AGENT_NAMES, d as installDependencies, f as installOption, i as create, k as program, n as prepareSvApi, o as formatFiles, p as packageManagerPrompt, q as vt, r as add, s as createWorkspace, u as detectPackageManager, v as boolean, w as strictObject, x as parse$1, y as literal, z as runCommand } from "./engine-DlJ4-99M.mjs";
+import { Walker, coerceVersion, color, isVersionUnsupportedBelow, js, loadPackageJson, parse, resolveCommandArray, svelteConfig, transforms } from "@sveltejs/sv-utils";
+import fs from "node:fs";
+import path from "node:path";
 import V from "node:process";
 import { execSync } from "node:child_process";
 //#region src/cli/check.ts
@@ -31,22 +33,2680 @@ async function runCheck(cwd, args) {
 	}
 }
 //#endregion
-//#region src/cli/migrate.ts
-const migrate = new Command("migrate").description("a CLI for migrating Svelte(Kit) codebases").argument("[migration]", "migration to run").option("-C, --cwd <path>", "path to working directory", V.cwd()).action(async (migration, options) => {
-	await runMigrate(options.cwd, [migration]);
+//#region src/migrate/index.ts
+function defineMigration(migration) {
+	return migration;
+}
+function defineMigrationTask(task) {
+	return task;
+}
+//#endregion
+//#region src/migrate/migration-task.ts
+/** Marker prefixing every manual follow-up a migration leaves in the user's code. */
+const MIGRATION_TASK_MARKER = "@migration-task";
+let migrationTaskCount = 0;
+/** Running total of `@migration-task` comments left in the user's code during this migration run. */
+function getMigrationTaskCount() {
+	return migrationTaskCount;
+}
+/** Resets the running total; call before starting a migration run. */
+function resetMigrationTaskCount() {
+	migrationTaskCount = 0;
+}
+/**
+* Leaves a standardized `@migration-task` comment for the user to resolve manually, and bumps the
+* running total so the post-migration summary can report it without re-reading files.
+*
+* The placement depends on the `target` you pass:
+* - `{ comments, node }` for a JS/TS AST (`transforms.script`)
+* - `{ fragment }` for a `.svelte` component (`transforms.svelte` / `svelteScript`)
+*
+* @example
+* ```ts
+* addMigrationTask('rewrite this manually', { comments, node });
+* addMigrationTask('rewrite this manually', { fragment: ast.fragment, anchor });
+* ```
+*/
+function addMigrationTask(message, target) {
+	if ("fragment" in target) addSvelteComment(target.fragment, message, target.anchor);
+	else target.comments.add(target.node, {
+		type: "Line",
+		value: ` ${MIGRATION_TASK_MARKER} ${message}`
+	}, target.position ? { position: target.position } : void 0);
+	migrationTaskCount++;
+}
+/**
+* Returns a standalone `// @migration-task` line comment for files that are generated from strings
+* (rather than through an AST), and bumps the running total so the post-migration summary can
+* report it. Prefer `addMigrationTask` whenever an AST is available.
+*/
+function createMigrationTaskComment(message) {
+	migrationTaskCount++;
+	return `// ${MIGRATION_TASK_MARKER} ${message}`;
+}
+function addSvelteComment(fragment, message, anchor) {
+	const comment = {
+		type: "Comment",
+		data: ` ${MIGRATION_TASK_MARKER} ${message} `,
+		start: 0,
+		end: 0
+	};
+	const newline = {
+		type: "Text",
+		data: "\n",
+		raw: "\n",
+		start: 0,
+		end: 0
+	};
+	const index = anchor ? fragment.nodes.indexOf(anchor) : -1;
+	if (index === -1) fragment.nodes.unshift(comment, newline);
+	else fragment.nodes.splice(index, 0, comment, newline);
+}
+//#endregion
+//#region src/migrate/migrations/app-state/tasks/app-state/migrate.ts
+const OLD_SOURCE$1 = "$app/stores";
+const NEW_SOURCE$1 = "$app/state";
+const NAVIGATING_REVIEW_MESSAGE = "`navigating` is always defined now - review this usage; use `navigating.to` for the pending navigation";
+/** Stores exported from `$app/stores` that we know how to migrate. */
+const KNOWN_STORES = /* @__PURE__ */ new Set([
+	"page",
+	"navigating",
+	"updated",
+	"getStores"
+]);
+/**
+* Migrate `$app/stores` usage to `$app/state` in one Svelte component.
+* Returns whether anything changed.
+*/
+function migrateAppState(ast, fragment) {
+	const imports = js.imports.findAll(ast, { from: OLD_SOURCE$1 }).filter((found) => found.kind === "static");
+	if (imports.length === 0) return false;
+	const locals = /* @__PURE__ */ new Map();
+	for (const binding of js.imports.bindings(ast, { from: OLD_SOURCE$1 })) {
+		if (!KNOWN_STORES.has(binding.imported)) continue;
+		locals.set(`$${binding.local}`, {
+			name: binding.local,
+			store: binding.imported
+		});
+	}
+	if (locals.size === 0) return false;
+	const bailReason = findBailReason(ast, locals);
+	if (bailReason) {
+		addMigrationTask(`could not auto-migrate \`${OLD_SOURCE$1}\` to \`${NEW_SOURCE$1}\`: ${bailReason}; migrate manually`, { fragment });
+		return true;
+	}
+	for (const found of imports) js.imports.setSource(found, NEW_SOURCE$1);
+	const state = { needsNavigatingReview: false };
+	derefStores(ast, locals, state);
+	derefStores(fragment, locals, state);
+	if (state.needsNavigatingReview) addMigrationTask(NAVIGATING_REVIEW_MESSAGE, { fragment });
+	return true;
+}
+/**
+* Migrate `$app/stores` usage in a `.svelte.ts` / `.svelte.js` module.
+*
+* Modules never used the `$store` auto-subscription syntax, so the only mechanical change is
+* renaming the import. `.subscribe(...)` / `get(store)` reactivity can't be auto-ported to runes,
+* so those are flagged for manual follow-up. Returns whether anything changed.
+*/
+function migrateAppStateModule(ast, comments) {
+	const imports = js.imports.findAll(ast, { from: OLD_SOURCE$1 }).filter((found) => found.kind === "static");
+	if (imports.length === 0) return false;
+	const storeNames = /* @__PURE__ */ new Set();
+	let getStoresImport;
+	for (const binding of js.imports.bindings(ast, { from: OLD_SOURCE$1 })) {
+		if (!KNOWN_STORES.has(binding.imported)) continue;
+		if (binding.imported === "getStores") getStoresImport = binding.declaration;
+		else storeNames.add(binding.local);
+	}
+	if (storeNames.size === 0 && !getStoresImport) return false;
+	for (const found of imports) js.imports.setSource(found, NEW_SOURCE$1);
+	if (getStoresImport) addMigrationTask("`getStores()` is not available; migrate manually", {
+		comments,
+		node: getStoresImport
+	});
+	Walker.walk(ast, null, {
+		MemberExpression(node, ctx) {
+			if (node.object.type === "Identifier" && storeNames.has(node.object.name) && node.property.type === "Identifier" && node.property.name === "subscribe") addMigrationTask("convert `" + node.object.name + ".subscribe(...)` to a rune (`$derived`/`$effect`)", {
+				comments,
+				node: enclosingStatement(ctx.path) ?? node
+			});
+			ctx.next();
+		},
+		CallExpression(node, ctx) {
+			if (node.callee.type === "Identifier" && node.callee.name === "get" && node.arguments[0]?.type === "Identifier" && storeNames.has(node.arguments[0].name)) addMigrationTask("replace `get(" + node.arguments[0].name + ")` - read the value directly (no longer a store)", {
+				comments,
+				node: enclosingStatement(ctx.path) ?? node
+			});
+			ctx.next();
+		}
+	});
+	return true;
+}
+function enclosingStatement(path) {
+	for (let i = path.length - 1; i >= 0; i -= 1) {
+		const node = path[i];
+		if (node.type === "VariableDeclaration" || node.type === "ExpressionStatement" || node.type === "ReturnStatement") return node;
+	}
+}
+/**
+* Detect usage that can't be mechanically migrated. Returns a human-readable reason, or
+* `undefined` when the file is safe to migrate.
+*/
+function findBailReason(ast, locals) {
+	for (const local of locals.values()) if (local.store === "getStores") return "`getStores()` is not available";
+	const storeNames = new Set([...locals.values()].map((local) => local.name));
+	let reason;
+	Walker.walk(ast, null, {
+		LabeledStatement(node, ctx) {
+			if (node.label.name === "$") reason ??= "legacy reactive statement (`$:`)";
+			ctx.next();
+		},
+		ExportNamedDeclaration(node, ctx) {
+			if (node.declaration?.type === "VariableDeclaration" && node.declaration.kind === "let") reason ??= "legacy `export let` props";
+			ctx.next();
+		},
+		CallExpression(node, ctx) {
+			if (node.callee.type === "Identifier" && node.callee.name === "derived" && node.arguments[0]?.type === "Identifier" && storeNames.has(node.arguments[0].name)) reason ??= "`derived(...)` store";
+			ctx.next();
+		}
+	});
+	return reason;
+}
+/** Rewrite `$store` auto-subscription identifiers to their `$app/state` equivalent. */
+function derefStores(node, locals, state) {
+	Walker.walk(node, null, { Identifier(node, ctx) {
+		const local = locals.get(node.name);
+		if (local === void 0) return;
+		const parent = ctx.path[ctx.path.length - 1];
+		if (!js.identifiers.isReference(node, parent)) return;
+		if (parent.type === "Property" && parent.shorthand && parent.key === node) {
+			parent.key = { ...node };
+			parent.shorthand = false;
+		}
+		if (local.store === "updated") {
+			js.common.replaceChild(parent, node, memberExpression(local.name, "current"));
+			return;
+		}
+		if (local.store === "navigating") {
+			if (isBooleanPosition(node, parent)) {
+				js.common.replaceChild(parent, node, memberExpression(local.name, "to"));
+				return;
+			}
+			if (!isMemberAccessObject(node, parent)) state.needsNavigatingReview = true;
+		}
+		node.name = local.name;
+	} });
+}
+/** Whether `node` is the object being accessed in `parent` (e.g. `$navigating` in `$navigating.to`). */
+function isMemberAccessObject(node, parent) {
+	return parent.type === "MemberExpression" && parent.object === node;
+}
+/**
+* Whether `node` sits in a boolean (truthiness-tested) position, where a bare
+* `navigating` should become `navigating.to`.
+*/
+function isBooleanPosition(node, parent) {
+	switch (parent.type) {
+		case "IfBlock":
+		case "IfStatement":
+		case "WhileStatement":
+		case "DoWhileStatement":
+		case "ConditionalExpression": return parent.test === node;
+		case "UnaryExpression": return parent.operator === "!" && parent.argument === node;
+		case "LogicalExpression": return (parent.operator === "&&" || parent.operator === "||") && parent.left === node;
+		default: return false;
+	}
+}
+function memberExpression(object, property) {
+	return {
+		type: "MemberExpression",
+		object: {
+			type: "Identifier",
+			name: object
+		},
+		property: {
+			type: "Identifier",
+			name: property
+		},
+		computed: false,
+		optional: false
+	};
+}
+//#endregion
+//#region src/migrate/migrations/app-state/tasks/app-state.ts
+var app_state_default$1 = defineMigrationTask({
+	id: "app-state",
+	description: "Migrate from \"$app/stores\" to \"$app/state\"",
+	run: ({ sv, language }) => {
+		sv.files({
+			include: "**/*.{svelte,svelte.ts,svelte.js}",
+			where: (content) => content.includes("$app/stores")
+		}, (content, path) => {
+			if (path.endsWith(".svelte")) return transforms.svelteScript({ language }, ({ ast }) => {
+				if (!migrateAppState(ast.instance.content, ast.fragment)) return false;
+			})(content);
+			return transforms.script(({ ast, comments }) => {
+				if (!migrateAppStateModule(ast, comments)) return false;
+			})(content);
+		});
+	}
 });
-async function runMigrate(cwd, args) {
-	const pm = await detectPackageManager(cwd);
+//#endregion
+//#region src/migrate/migrations/app-state/index.ts
+var app_state_default = defineMigration({
+	id: "app-state",
+	description: "Migrate from \"$app/stores\" to \"$app/state\"",
+	setup: ({ pkg }) => {
+		const kitPackageName = "@sveltejs/kit";
+		if (!pkg.devDependencies?.[kitPackageName]) throw new Error(`${color.command(kitPackageName)} is not a devDependency in package.json - this doesn't look like a SvelteKit project.\nPoint to one with ${color.command("--cwd <path>")}, or see ${color.command("sv migrate --help")}.`);
+	},
+	collect: ({ tasks }) => {
+		tasks.add(app_state_default$1, { prerequisite: true });
+	}
+});
+//#endregion
+//#region src/migrate/migrations/legacy-migrations/index.ts
+function legacyTask(name, description) {
+	return defineMigrationTask({
+		id: name,
+		description,
+		run: async ({ sv }) => {
+			await sv.execute(["svelte-migrate@1", name], "inherit");
+		}
+	});
+}
+function legacyMigration(name, description) {
+	return defineMigration({
+		id: name,
+		description,
+		legacy: true,
+		setup: () => {},
+		collect: ({ tasks }) => {
+			tasks.add(legacyTask(name, description), { prerequisite: true });
+		}
+	});
+}
+const legacyMigrations = [
+	legacyMigration("svelte-5", "Migrate from Svelte 4 to Svelte 5"),
+	legacyMigration("self-closing-tags", "Migrate to the new self-closing tag syntax"),
+	legacyMigration("svelte-4", "Migrate from Svelte 3 to Svelte 4"),
+	legacyMigration("sveltekit-2", "Migrate from SvelteKit 1.0 to SvelteKit 2.0"),
+	legacyMigration("package", "Migrate from @sveltejs/package@1 to @sveltejs/package@2"),
+	legacyMigration("routes", "Migrate from SvelteKit pre-1.0 routing to SvelteKit 1.0 routing")
+];
+//#endregion
+//#region src/migrate/migrations/sveltekit-3/tasks/collect-migration-instructions.ts
+const REPORT_PATH = "MIGRATION_TASKS.md";
+const GUIDE_URL = "https://next.svelte.dev/docs/kit/migrating-to-sveltekit-3";
+const CODE_FILES = "**/*.{js,ts,svelte,mjs,mts,cjs,cts}";
+const GENERATED_MARKER = "<!-- Generated by sv migrate sveltekit-3:collect-migration-instructions -->";
+function guideLink(anchor) {
+	return [{
+		label: "Migrating to SvelteKit v3",
+		url: `${GUIDE_URL}#${anchor}`
+	}];
+}
+const migrationTasks = [
+	{
+		title: "Migrate remaining `base`, `assets`, and `resolveRoute` from `$app/paths` usages",
+		checks: [{
+			include: CODE_FILES,
+			patterns: [/^(?=[\s\S]*['"]\$app\/paths['"])(?=[\s\S]*(?:\bbase\b|\bassets\b|\bresolveRoute\b))/]
+		}],
+		summary: "The automatic migration can leave `base`, `assets`, and `resolveRoute` usages from `$app/paths`.",
+		instructions: "The deprecated base, assets, and resolveRoute exports have been removed from $app/paths. Use asset and resolve instead:```diff// instead of this...\nconst pathname = base + resolveRoute('/blog/[slug]', { slug });\nconst file = assets + '/foo.png';\n\n// ...do this:\nconst pathname = resolve('/blog/[slug]', { slug });\nconst file = asset('foo.png');\n```\nThe `Pathname` and `Asset` types have also been renamed to `Path` and `AssetPath`, and the leading `/` has been removed from those types — so `asset('/foo.png')` should now be `asset('foo.png')`, and pathnames passed to `resolve` no longer start with `/` (e.g. `resolve('blog/hello-world')`). Only route IDs start with `/` now.",
+		links: guideLink("$app-paths-base-assets-and-resolveRoute-removed")
+	},
+	{
+		title: "Migrate remaining `$app/stores` usages",
+		checks: [{
+			include: CODE_FILES,
+			patterns: ["$app/stores"]
+		}],
+		summary: "The automatic migration can leave `$app/stores` references when their store semantics require application context.",
+		instructions: "Replace each remaining `$app/stores` reference with `$app/state`. Remove auto-subscription prefixes, read `page` and `navigating` directly, and use `updated.current`. Rewrite `getStores()`, `get(store)`, subscriptions, re-exports, and dynamic imports according to how the value is used rather than only changing the module name.",
+		links: guideLink("$app-stores-(removed)")
+	},
+	{
+		title: "Migrate the removed `$service-worker` module",
+		checks: [{
+			include: CODE_FILES,
+			patterns: ["$service-worker"]
+		}],
+		summary: "SvelteKit 3 removes `$service-worker` and replaces its exports with several new modules.",
+		instructions: "Import `version` from `$app/env`, application asset metadata from `$app/manifest`, and path helpers from `$app/paths`. Account for the new manifest value shapes rather than blindly renaming `build` or `files` imports.",
+		links: guideLink("$service-worker-(removed)")
+	},
+	{
+		title: "Create a TypeScript project for the service worker",
+		checks: [{
+			include: ["src/service-worker.ts", "src/service-worker/**/*.ts"],
+			patterns: [/\S/]
+		}],
+		summary: "TypeScript service workers now need a separate project with service-worker-specific types.",
+		instructions: "Exclude the service worker from the root tsconfig and ensure `src/service-worker/tsconfig.json` extends `$app/tsconfig/service-worker`. Move a flat `src/service-worker.ts` entry to `src/service-worker/index.ts` if necessary, preserving any tooling references.",
+		links: guideLink("$app-tsconfig-service-worker")
+	},
+	{
+		title: "Make the service worker module-compatible",
+		checks: [{
+			include: ["src/service-worker.{js,ts}", "src/service-worker/**/*.{js,ts}"],
+			patterns: [/\bimportScripts\s*\(/]
+		}],
+		summary: "SvelteKit 3 registers service workers as modules, where classic worker APIs may not work.",
+		instructions: "Replace `importScripts(...)` and any other classic-worker-only assumptions with module imports or module-compatible equivalents.",
+		links: guideLink("Miscellaneous-Service-worker-registrations-use-type:-'module'")
+	},
+	{
+		title: "Copy `page.url` before mutating it",
+		checks: [{
+			include: CODE_FILES,
+			patterns: [
+				/\bpage\s*\.\s*url\s*\.\s*searchParams\s*\.\s*(?:append|delete|set|sort)\s*\(/,
+				/\bpage\s*\.\s*url\s*\.\s*(?:hash|host|hostname|href|password|pathname|port|protocol|search|username)\s*(?:=|\+\+|--)/,
+				"new URL(page.url)"
+			]
+		}],
+		summary: "`page.url` and its search parameters are readonly in SvelteKit 3.",
+		instructions: "Create a mutable copy with `new URL(page.url.href)`, mutate that copy, and use it for navigation or serialization. Leave readonly accesses unchanged.",
+		links: guideLink("$app-state-page.url-is-now-readonly")
+	},
+	{
+		title: "Review `goto` destinations",
+		checks: [{
+			include: CODE_FILES,
+			patterns: [/^(?=[\s\S]*['"]\$app\/navigation['"])(?=[\s\S]*\bgoto\s*\()/]
+		}],
+		summary: "`goto(...)` now rejects destinations that do not resolve to an application route.",
+		instructions: "Confirm each destination is an internal route. Use `window.location.href` for external browser navigation, and handle rejected dynamic destinations where they can fail to resolve.",
+		links: guideLink("$app-navigation-goto-rejects-for-URLs-that-don't-resolve-to-a-route")
+	},
+	{
+		title: "Adjust noScroll/keepFocus usage",
+		checks: [{
+			include: CODE_FILES,
+			patterns: [
+				/^(?=[\s\S]*['"]\$app\/navigation['"])(?=[\s\S]*\bgoto\s*\([\s\S]*(noScroll|keepFocus))/,
+				"data-sveltekit-noscroll",
+				"data-sveltekit-keepfocus"
+			]
+		}],
+		summary: "The options `noScroll` and `keepFocus` of `goto(...)` are merged into a single `reset` option.",
+		instructions: "replace the `noScroll` and `keepFocus` options of `goto` with a single `reset` option, and the `data-sveltekit-noscroll` and `data-sveltekit-keepfocus` attributes with `data-sveltekit-reset`. `noScroll: false / keepFocus: false` becomes `reset: true` and `noScroll: true / keepFocus: true` becomes `reset: false`.",
+		links: guideLink("$app-navigation-goto-options-are-updated")
+	},
+	{
+		title: "Adjust error(...) usage",
+		checks: [{
+			include: CODE_FILES,
+			patterns: [
+				/^(?=[\s\S]*['"]@sveltejs\/kit['"])(?=[\s\S]*\berror\s*\([0-9]+,\s*{)/,
+				"data-sveltekit-noscroll",
+				"data-sveltekit-keepfocus"
+			]
+		}],
+		summary: "Signature of `error(...)` from `@sveltejs/kit` has changed.",
+		instructions: "Replace `error(status, { message, ... })` with `error(status, message, { ... })`.",
+		links: guideLink("Error-handling-error()-arguments-changed")
+	},
+	{
+		title: "Replace `invalidateAll` with `refreshAll`",
+		checks: [{
+			include: CODE_FILES,
+			patterns: [/^(?=[\s\S]*['"]\$app\/navigation['"])(?=[\s\S]*\bgoto\s*\()/]
+		}],
+		summary: "`invalidateAll` is deprecated in favor of `refreshAll`",
+		instructions: "Replace `invalidateAll()` with `refreshAll()`. Note that `refreshAll()` will keep `page.state` intact. Check if that has unwanted impact on the application; if yes point this out in a comment with steps to take instead of replacing that instance of `invalidateAll()`. Similarly, replace goto(..., { invalidateAll: true }) with goto(..., { refreshAll: true }).",
+		links: guideLink("$app-navigation-invalidateAll-is-deprecated-in-favour-of-refreshAll")
+	},
+	{
+		title: "`data-sveltekit-*` uses `false` instead of `\"off\"`",
+		checks: [{
+			include: "**/*.{svelte,html}",
+			patterns: [/data-sveltekit-[\w-]+=["']off["']/]
+		}],
+		summary: "The `\"off\"` value for `data-sveltekit-*` link attributes has been removed in favour of `false`.",
+		instructions: "Replace `data-sveltekit-...=\"off\"` with `data-sveltekit-...=\"false\"`.",
+		links: guideLink("Miscellaneous-data-sveltekit-uses-false-instead-of-'off'")
+	},
+	{
+		title: "Guard navigation `delta` access",
+		checks: [{
+			include: CODE_FILES,
+			patterns: [/^(?=[\s\S]*['"]\$app\/navigation['"])(?=[\s\S]*(?:\.\s*delta\b|\{[^}]*\bdelta\b))/]
+		}],
+		summary: "Navigation `delta` is now only defined for `popstate` navigations.",
+		instructions: "Check the navigation type or handle `undefined` before using `delta`. Do not treat an absent delta as zero unless that has the intended application meaning.",
+		links: guideLink("$app-navigation-delta-only-exists-for-popstate-navigations")
+	},
+	{
+		title: "Handle `preloadData` errors",
+		checks: [{
+			include: CODE_FILES,
+			patterns: [/^(?=[\s\S]*['"]\$app\/navigation['"])(?=[\s\S]*\bpreloadData\s*\()/]
+		}],
+		summary: "`preloadData(...)` can now return an error result, and redirects report their real status.",
+		instructions: "Inspect the complete result flow and add handling for `{ type: \"error\", status, error }` where absent. Do not assume every non-redirect result is loaded or has status 200.",
+		links: guideLink("$app-navigation-preloadData-can-return-an-error-result")
+	},
+	{
+		title: "Review enhanced forms with explicit actions",
+		checks: [{
+			include: "**/*.svelte",
+			patterns: [/^(?=[\s\S]*\buse:enhance\b)(?=[\s\S]*<form\b[^>]*\baction\s*=)/]
+		}],
+		summary: "Enhanced forms that submit to another page now navigate to that page.",
+		instructions: "Determine whether each action resolves to another page and confirm navigation is intended. If the form must remain on the current page, implement that behavior explicitly in the enhancement callback.",
+		links: guideLink("$app-forms")
+	},
+	{
+		title: "Migrate `handleValidationError`",
+		checks: [{
+			include: "**/hooks*.{js,ts,mjs,mts}",
+			patterns: ["handleValidationError"]
+		}],
+		summary: "`handleValidationError` is removed in SvelteKit 3.",
+		instructions: "Move validation-error handling into `handleError` and branch on `kind === \"validation\"`. Merge it carefully with any existing `handleError` logic.",
+		links: guideLink("Error-handling-handleValidationError-is-removed")
+	},
+	{
+		title: "Review `handleError` behavior",
+		checks: [{
+			include: "**/hooks*.{js,ts,mjs,mts}",
+			patterns: ["handleError"]
+		}],
+		summary: "SvelteKit 3 sends expected, validation, and rendering errors through `handleError`.",
+		instructions: "Review filtering, logging, reporting, returned error properties, and status handling for the broader set of errors. If `hooks.client` has an async hook, enable `compilerOptions.experimental.async` in `sveltekit(...)`.",
+		links: guideLink("Error-handling-handleError-receives-all-errors")
+	},
+	{
+		title: "CORS for static assets in development is handled by Vite",
+		summary: "SvelteKit no longer sets `access-control-allow-origin: *` on every static asset request in development. CORS is now delegated to Vite's built-in middleware.",
+		instructions: "If you rely on cross-origin access to static assets in dev, configure it in your Vite config by adding server.cors.origin = \"*\" to your config.",
+		links: guideLink("Security-CORS-for-static-assets-in-development-is-handled-by-Vite")
+	},
+	{
+		title: "`json` and `text` are deprecated",
+		checks: [{
+			include: CODE_FILES,
+			patterns: [/^(?=[\s\S]*['"]@sveltejs\/kit['"])(?=[\s\S]*\b(json|text)\s*\()/]
+		}],
+		summary: "The `json(...)` and `text(...)` helpers from `@sveltejs/kit` for generating responses are deprecated.",
+		instructions: "Use `Response.json(...)` and `new Response(text)` instead.",
+		links: guideLink("sveltejs-kit-json-and-text-are-deprecated")
+	},
+	{
+		title: "Remove the Node polyfills import",
+		checks: [{
+			include: CODE_FILES,
+			patterns: ["@sveltejs/kit/node/polyfills"]
+		}],
+		summary: "`@sveltejs/kit/node/polyfills` is removed because SvelteKit 3 requires modern Node.",
+		instructions: "Remove the obsolete side-effect import and verify that the custom server or adapter runs on Node 22.17 or newer.",
+		links: guideLink("sveltejs-kit-node-polyfills-(removed)")
+	},
+	{
+		title: "Remove `await` from synchronous Node helpers",
+		checks: [{
+			include: CODE_FILES,
+			patterns: [/^(?=[\s\S]*['"]@sveltejs\/kit\/node['"])(?=[\s\S]*\bawait\s+(?:\w+\.)?(?:getRequest|setResponse)\s*\()/]
+		}],
+		summary: "`getRequest` and `setResponse` from `@sveltejs/kit/node` are now synchronous.",
+		instructions: "Remove `await` only from calls bound to those SvelteKit helpers, then review surrounding promise composition and return types.",
+		links: guideLink("sveltejs-kit-node")
+	},
+	{
+		title: "Rename cookie option types",
+		checks: [{
+			include: CODE_FILES,
+			patterns: ["CookieSerializeOptions", "CookieParseOptions"]
+		}],
+		summary: "Cookie v2 renames its serialization and parsing option types.",
+		instructions: "Rename `CookieSerializeOptions` to `SerializeOptions` and `CookieParseOptions` to `ParseOptions`, changing only types imported from the `cookie` package.",
+		links: guideLink("Cookies-Updated-to-cookie-v2")
+	},
+	{
+		title: "Replace non-ASCII cookie names",
+		checks: [{
+			include: CODE_FILES,
+			patterns: [/\bcookies\s*\.\s*(?:get|getAll|set|delete|serialize)\s*\(\s*['"][^'"]*[^\x00-\x7f][^'"]*['"]/]
+		}],
+		summary: "Cookie v2 rejects cookie names containing non-ASCII characters.",
+		instructions: "Choose a stable ASCII replacement and consider compatibility or cleanup for cookies already issued under the old name.",
+		links: guideLink("Cookies-Updated-to-cookie-v2")
+	},
+	{
+		title: "Rename Cloudflare `platform.context`",
+		checks: [{
+			include: CODE_FILES,
+			patterns: [/\bplatform\s*(?:\?\.|\.)\s*context\b/]
+		}],
+		summary: "The Cloudflare adapter replaces `platform.context` with `platform.ctx`.",
+		instructions: "Confirm the value is the Cloudflare platform execution context, then rename it to `platform.ctx` and update related platform typings.",
+		links: guideLink("Adapters-adapter-cloudflare")
+	},
+	{
+		title: "Move adapter-node `ORIGIN` to `paths.origin`",
+		checks: [{
+			include: [
+				"Dockerfile*",
+				"**/Dockerfile*",
+				"**/*.{js,ts,mjs,mts,json,jsonc,yml,yaml,toml}"
+			],
+			patterns: [
+				/\bprocess\.env\.ORIGIN\b/,
+				/\benv\s*\[\s*['"]ORIGIN['"]\s*\]/,
+				/^\s*(?:ENV|ARG)\s+ORIGIN\b/m,
+				/^\s*ORIGIN\s*[:=]/m
+			]
+		}],
+		summary: "The adapter-node `ORIGIN` environment variable is removed.",
+		instructions: "If this value configures adapter-node, move the public-facing origin to `paths.origin` in `sveltekit(...)`. Remove the environment variable only after confirming it has no unrelated use.",
+		links: guideLink("Adapters-adapter-node")
+	},
+	{
+		title: "Replace the Vercel edge runtime",
+		checks: [{
+			include: "**/*.{js,ts,mjs,mts,json,jsonc}",
+			patterns: [/\bruntime\s*:\s*['"]edge['"]/]
+		}],
+		summary: "The Vercel adapter no longer supports the edge runtime.",
+		instructions: "Select a supported Vercel runtime and review runtime-specific APIs, dependencies, and deployment behavior before changing the configuration.",
+		links: guideLink("Adapters-adapter-vercel")
+	},
+	{
+		title: "Replace `builder.createEntries` in custom adapters",
+		checks: [{
+			include: CODE_FILES,
+			patterns: [/\bbuilder\s*\.\s*createEntries\s*\(/]
+		}],
+		summary: "The adapter API removes `builder.createEntries`.",
+		instructions: "Replace it with the appropriate `builder.writeClient`, `builder.writeServer`, and `builder.writePrerendered` flow for the adapter output model.",
+		links: guideLink("Adapters-Adapter-API-changes")
+	},
+	{
+		title: "Remove request route data from remote queries",
+		checks: [{
+			include: [
+				"**/*.remote.{js,ts}",
+				"**/*.remote.*.{js,ts}",
+				"**/remote.{js,ts}"
+			],
+			patterns: [/\bevent\s*\.\s*(?:url|params|route)\b/]
+		}],
+		summary: "Remote queries can no longer access `event.url`, `event.params`, or `event.route`.",
+		instructions: "Pass the required values explicitly as validated query arguments and remove the request-specific event access.",
+		links: guideLink("Remote-functions-event.url-event.params-and-event.route-cannot-be-accessed-inside-queries")
+	},
+	{
+		title: "Use remote form field attributes",
+		checks: [{
+			include: "**/*.svelte",
+			patterns: [/^(?=[\s\S]*(?:from\s*['"][^'"]+\.remote(?:\.[^'"]+)?['"]|import\(\s*['"][^'"]+\.remote))(?=[\s\S]*\bname\s*=)/]
+		}],
+		summary: "Remote form controls must use attributes from the current form field.",
+		instructions: "Replace manually specified control names with attributes from the corresponding field `.as(...)` method, verifying that the field belongs to the submitted form (e.g. `<input name=\"foo\">` -> `<input {...myForm.fields.foo.as(\"text\")}>`).",
+		links: guideLink("Remote-functions-Form-submissions-require-field.as()")
+	},
+	{
+		title: "Review consumers of 204 responses",
+		checks: [{
+			include: ["src/routes/**/+server.{js,ts}", "**/*.{test,spec}.{js,ts,mjs,mts}"],
+			patterns: [/\bstatus\s*:\s*204\b/]
+		}],
+		summary: "SvelteKit 3 returns no body for 204 and other empty 2xx responses.",
+		instructions: "Find callers and tests for the matched endpoint and ensure they do not parse JSON or text from its empty response. Keep the endpoint response unchanged if it is already spec-compliant.",
+		links: guideLink("Responses-204-responses-return-no-content")
+	},
+	{
+		title: "Replace remaining `csrf.checkOrigin` configuration",
+		checks: [{
+			include: "**/{svelte,vite}.config.{js,ts,mjs,mts,cjs,cts}",
+			patterns: ["checkOrigin"]
+		}],
+		summary: "`csrf.checkOrigin` is removed and CSRF protection is always enabled.",
+		instructions: "Remove `checkOrigin`. If cross-origin submissions are intentional, configure the narrowest possible `csrf.trustedOrigins` allowlist instead of disabling protection.",
+		links: guideLink("Security-csrf.checkOrigin-replaced-by-csrf.trustedOrigins")
+	},
+	{
+		title: "Review cross-origin form submissions",
+		checks: [{
+			include: "**/*.svelte",
+			patterns: [/<form\b[^>]*\baction\s*=\s*['"](?:https?:)?\/\//]
+		}],
+		summary: "Cross-origin mutative requests without a `Content-Type` header are rejected as CSRF.",
+		instructions: "Ensure the submission sends an appropriate `Content-Type` header or add the destination to the narrowest possible `csrf.trustedOrigins` allowlist.",
+		links: guideLink("Security-Cross-origin-form-submissions-require-a-Content-Type-header")
+	}
+];
+var collect_migration_instructions_default = defineMigrationTask({
+	id: "collect-migration-instructions",
+	description: `Collect instructions for non-automated migration tasks; creates ${REPORT_PATH} whose instructions you should follow to complete the migration`,
+	run: ({ sv }) => {
+		const findings = [];
+		for (const task of migrationTasks) {
+			const files = /* @__PURE__ */ new Set();
+			if (!task.checks) findings.push({
+				task,
+				files: []
+			});
+			else {
+				for (const check of task.checks) sv.files({
+					include: check.include,
+					exclude: [REPORT_PATH],
+					where: (content) => check.patterns.some((pattern) => matches(content, pattern))
+				}, (_content, file) => {
+					files.add(file);
+					return false;
+				});
+				if (files.size > 0) findings.push({
+					task,
+					files: [...files].sort()
+				});
+			}
+		}
+		if (findings.length === 0) return;
+		sv.file(REPORT_PATH, (content) => {
+			if (content && !content.includes("<!-- Generated by sv migrate sveltekit-3:collect-migration-instructions -->")) throw new Error(`'${REPORT_PATH}' already exists and was not generated by this migration. Move or rename it before rerunning the task.`);
+			return renderReport(findings);
+		});
+	}
+});
+function matches(content, pattern) {
+	return typeof pattern === "string" ? content.includes(pattern) : pattern.test(content);
+}
+function renderReport(findings) {
+	return `${GENERATED_MARKER}
+# SvelteKit 3 migration tasks
+
+Some migrations are uncommon, context-dependent, or disproportionately difficult to automate safely. This document lists them.
+
+The findings are intentionally broad and may include files that do not require changes.
+
+AI agents can work through the migration tasks below one at a time:
+
+1. Read the linked documentation or pull request before changing code.
+2. Inspect every listed file and its surrounding context.
+3. Ignore a finding when the file is not actually affected.
+4. Make the smallest necessary change. Do not perform unrelated refactors or introduce unnecessary abstractions.
+5. Ask the user when application intent cannot be inferred.
+6. Run the project's appropriate checks after editing.
+
+Also search the project for \`@migration-task\` comments. They may describe additional manual migration work that must be resolved.
+
+## Migration tasks
+
+${findings.map(({ task, files }) => {
+		const links = task.links.map(({ label, url }) => `- [${label}](${url})`).join("\n");
+		const locations = files.map((file) => `- [ ] \`${normalizePosix(file)}\``).join("\n");
+		let output = `### ${task.title}
+
+${task.summary}
+
+#### What to do
+
+${task.instructions}
+
+#### References
+
+${links}`;
+		if (locations.length) output += `
+
+#### Files to review
+
+${locations}`;
+		return output;
+	}).join("\n\n")}
+
+## Final verification
+
+- [ ] Review every migration task and ignore any irrelevant findings.
+- [ ] Resolve remaining \`@migration-task\` comments.
+- [ ] Run the project's type checker and tests.
+- [ ] Build the project successfully.
+- [ ] Delete this file when all migration work is complete.
+`;
+}
+//#endregion
+//#region src/migrate/migrations/sveltekit-3/tasks/environment/env-namespace.ts
+const OLD_SOURCE = "$app/environment";
+const NEW_SOURCE = "$app/env";
+/** Rename `$app/environment` imports to `$app/env`. Returns whether anything changed. */
+function renameEnvNamespace(ast) {
+	return js.imports.renameSource(ast, {
+		from: OLD_SOURCE,
+		to: NEW_SOURCE
+	});
+}
+//#endregion
+//#region src/migrate/migrations/sveltekit-3/tasks/environment/explicit-env-vars.ts
+const ENV_MODULE = /^\$env\/(dynamic|static)\/(public|private)$/;
+/** Migrate `$env/*` imports/usages to `$app/env/*` for one program. Returns whether it mutated `ast`. */
+function migrateExplicitEnvVars(ast, envVars, template, comments) {
+	let mutated = false;
+	const envImports = collectEnvImports(ast, template, comments);
+	if (envImports === "migration-task") mutated = true;
+	else if (envImports.length > 0) {
+		changeEnvImports(ast, envImports);
+		replaceEnvUsages(envImports);
+		collectEnvVars(envImports, envVars);
+		mutated = true;
+	}
+	if (migrateDynamicEnvImports(ast, envVars, comments, template)) mutated = true;
+	if (template && migrateDynamicEnvImports(template, envVars, comments, template)) mutated = true;
+	return mutated;
+}
+/**
+* Rewrite dynamic `import('$env/*')` expressions to `import('$app/env/*')`.
+* Names destructured from the result are collected for the `src/env.ts` declaration;
+* other shapes (namespace binding, rest element, computed keys) are flagged for manual work.
+*/
+function migrateDynamicEnvImports(node, envVars, comments, svelteFragment) {
+	let mutated = false;
+	for (const found of js.imports.findAll(node, { from: ENV_MODULE })) {
+		if (found.kind !== "dynamic") continue;
+		const [, type, scope] = found.source.match(ENV_MODULE);
+		js.imports.setSource(found, `$app/env/${scope}`);
+		mutated = true;
+		const names = getDestructuredEnvNames(found.path);
+		if (names) for (const name of names) envVars.set(name, {
+			type,
+			scope,
+			name
+		});
+		else addUnsupportedDynamicImportComment(comments, findCommentTarget(found.path) ?? found.node, svelteFragment);
+	}
+	return mutated;
+}
+function getDestructuredEnvNames(path) {
+	for (let i = path.length - 1; i >= 0; i -= 1) {
+		const node = path[i];
+		if (node.type !== "VariableDeclarator") continue;
+		if (node.id.type !== "ObjectPattern") return;
+		const names = [];
+		for (const property of node.id.properties) {
+			if (property.type !== "Property") return;
+			if (property.key.type !== "Identifier" || property.computed) return;
+			names.push(property.key.name);
+		}
+		return names;
+	}
+}
+function addUnsupportedDynamicImportComment(comments, node, svelteFragment) {
+	const message = "Declare the imported env variables in src/env.ts manually.";
+	if (svelteFragment) {
+		addMigrationTask(message, {
+			fragment: svelteFragment,
+			anchor: node
+		});
+		return;
+	}
+	if (!comments) return;
+	addMigrationTask(message, {
+		comments,
+		node
+	});
+}
+function collectEnvImports(ast, template, comments) {
+	const envImports = [];
+	let hasMigrationTask = false;
+	const relevantImports = js.imports.findAll(ast, { from: /^\$env\// }).filter((found) => found.kind === "static");
+	if (relevantImports.length === 0) return envImports;
+	for (const found of relevantImports) {
+		const match = found.source.match(ENV_MODULE);
+		if (!match) continue;
+		const type = match[1];
+		const scope = match[2];
+		const envImport = type === "dynamic" ? collectDynamicEnvImport(ast, found, scope, template, comments) : collectStaticEnvImport(ast, found, scope);
+		if (envImport === "migration-task") {
+			hasMigrationTask = true;
+			continue;
+		}
+		if (envImport) envImports.push(envImport);
+	}
+	if (envImports.length === 0 && hasMigrationTask) return "migration-task";
+	return envImports;
+}
+function collectDynamicEnvImport(ast, found, scope, template, comments) {
+	const importNames = new Set(js.imports.bindings(ast, {
+		from: found.source,
+		name: "env"
+	}).filter((binding) => binding.declaration === found.node).map((binding) => binding.local));
+	if (importNames.size === 0) return;
+	const usages = getDynamicEnvUsages(ast, importNames, comments, template);
+	if (!usages) return "migration-task";
+	if (template) {
+		const templateUsages = getDynamicEnvUsages(template, importNames, comments, template);
+		if (!templateUsages) return "migration-task";
+		usages.push(...templateUsages);
+	}
+	if (usages.length === 0) return;
+	return {
+		type: "dynamic",
+		scope,
+		found,
+		usages
+	};
+}
+function collectStaticEnvImport(ast, found, scope) {
+	const importNames = js.imports.bindings(ast, { from: found.source }).filter((binding) => binding.kind === "named" && binding.declaration === found.node).map((binding) => binding.imported);
+	if (importNames.length === 0) return;
+	return {
+		type: "static",
+		scope,
+		found,
+		importNames
+	};
+}
+function getDynamicEnvUsages(node, importNames, comments, svelteFragment) {
+	const usages = [];
+	let hasUnsupportedUsage = false;
+	Walker.walk(node, null, { MemberExpression(node, walkContext) {
+		if (node.object.type === "Identifier" && importNames.has(node.object.name)) {
+			const name = getDynamicEnvUsageName(node);
+			if (!name) {
+				hasUnsupportedUsage = true;
+				addUnsupportedDynamicEnvComment(comments, findCommentTarget(walkContext.path) ?? node, svelteFragment);
+				walkContext.next();
+				return;
+			}
+			usages.push({
+				node,
+				parent: walkContext.path[walkContext.path.length - 1],
+				name
+			});
+		}
+		walkContext.next();
+	} });
+	if (hasUnsupportedUsage) return;
+	return usages;
+}
+function addUnsupportedDynamicEnvComment(comments, node, svelteFragment) {
+	const message = "Rewrite dynamic env lookup manually.";
+	if (svelteFragment) {
+		addMigrationTask(message, {
+			fragment: svelteFragment,
+			anchor: node
+		});
+		return;
+	}
+	if (!comments) return;
+	addMigrationTask(message, {
+		comments,
+		node
+	});
+}
+function findCommentTarget(path) {
+	for (let i = path.length - 1; i >= 0; i -= 1) {
+		const node = path[i];
+		if (node.type === "VariableDeclaration" || node.type === "ExpressionStatement" || node.type === "ReturnStatement") return node;
+	}
+}
+function getDynamicEnvUsageName(node) {
+	if (!node.computed && node.property.type === "Identifier") return node.property.name;
+	if (node.computed && node.property.type === "Literal" && typeof node.property.value === "string" && isValidIdentifierName(node.property.value)) return node.property.value;
+}
+function isValidIdentifierName(name) {
+	return /^[$A-Z_a-z][$\w]*$/.test(name);
+}
+function changeEnvImports(ast, envImports) {
+	const staticImports = envImports.filter((x) => x.type === "static");
+	for (const { scope, found } of staticImports) js.imports.setSource(found, `$app/env/${scope}`);
+	const dynamicImports = envImports.filter((x) => x.type === "dynamic");
+	for (const { scope, found, usages } of dynamicImports) {
+		js.imports.setSource(found, `$app/env/${scope}`);
+		found.node.specifiers = [];
+		const uniqueUsages = new Set(usages.map((usage) => usage.name));
+		for (const name of uniqueUsages) found.node.specifiers.push({
+			type: "ImportSpecifier",
+			imported: {
+				type: "Identifier",
+				name
+			},
+			local: {
+				type: "Identifier",
+				name
+			}
+		});
+	}
+	mergeEnvImports(ast);
+}
+/**
+* If we initially have two imports from $env/static/public and $env/dynamic/public
+* they will produce two separate imports which is not totally clean.
+* This function merges multiple imports from the same new source into a single import.
+*
+* Specifiers of duplicated imports are assumed to be unique and are merged together.
+*/
+function mergeEnvImports(ast) {
+	const seenImports = /* @__PURE__ */ new Map();
+	for (let i = 0; i < ast.body.length; i += 1) {
+		const node = ast.body[i];
+		if (node.type !== "ImportDeclaration") continue;
+		const source = node.source.value;
+		if (typeof source !== "string" || !source.startsWith("$app/env/")) continue;
+		const existingImport = seenImports.get(source);
+		if (!existingImport) {
+			seenImports.set(source, node);
+			continue;
+		}
+		existingImport.specifiers.push(...node.specifiers);
+		ast.body.splice(i, 1);
+		i -= 1;
+	}
+}
+function replaceEnvUsages(envImports) {
+	const dynamicImports = envImports.filter((x) => x.type === "dynamic");
+	for (const { usages } of dynamicImports) for (const usage of usages) {
+		if (!usage.parent) continue;
+		js.common.replaceChild(usage.parent, usage.node, {
+			type: "Identifier",
+			name: usage.name
+		});
+	}
+}
+function collectEnvVars(envImports, envVars) {
+	for (const envImport of envImports) if (envImport.type === "static") for (const name of envImport.importNames) envVars.set(name, {
+		type: envImport.type,
+		scope: envImport.scope,
+		name
+	});
+	else for (const usage of envImport.usages) envVars.set(usage.name, {
+		type: envImport.type,
+		scope: envImport.scope,
+		name: usage.name
+	});
+}
+function addEnvDeclarationFile(ast, comments, envVars) {
+	if (envVars.size === 0) return false;
+	js.imports.addNamed(ast, {
+		from: "@sveltejs/kit/env",
+		imports: ["defineEnvVars"]
+	});
+	const defineCall = js.functions.createCall({
+		name: "defineEnvVars",
+		args: []
+	});
+	const variablesObject = js.functions.getArgument(defineCall, {
+		index: 0,
+		fallback: js.object.create({})
+	});
+	const variablesIdentifier = js.variables.declaration(ast, {
+		kind: "const",
+		name: "variables",
+		value: defineCall
+	});
+	const exportDeclaration = js.exports.createNamed(ast, {
+		name: "variables",
+		fallback: variablesIdentifier
+	});
+	let has_dynamic = false;
+	for (const envVar of envVars.values()) {
+		const value = js.object.property(variablesObject, {
+			name: envVar.name,
+			fallback: js.object.create({})
+		});
+		has_dynamic ||= envVar.type === "dynamic";
+		js.object.overrideProperties(value, {
+			public: envVar.scope === "public" ? true : void 0,
+			static: envVar.type === "static" ? true : void 0,
+			schema: envVar.type === "dynamic" ? js.functions.createArrow({
+				params: ["input"],
+				body: {
+					type: "LogicalExpression",
+					operator: "??",
+					left: {
+						type: "Identifier",
+						name: "input"
+					},
+					right: {
+						type: "Literal",
+						value: "",
+						raw: "''"
+					}
+				},
+				async: false
+			}) : void 0
+		});
+	}
+	if (has_dynamic) addMigrationTask("Review usage of dynamic environment variables. They fall back to the empty string if not present, which may not be what you want.", {
+		comments,
+		node: exportDeclaration
+	});
+}
+//#endregion
+//#region src/migrate/migrations/sveltekit-3/tasks/environment.ts
+var environment_default = defineMigrationTask({
+	id: "environment",
+	description: "Migrate to explicit environment variables ($app/env)",
+	run: ({ sv, language }) => {
+		const envVars = /* @__PURE__ */ new Map();
+		sv.files({
+			include: "**/*.{ts,js,svelte}",
+			where: (content) => content.includes("$env/") || content.includes("$app/environment")
+		}, (content, path) => {
+			if (path.endsWith(".svelte")) return transforms.svelteScript({ language }, ({ ast }) => {
+				const renamed = renameEnvNamespace(ast.instance.content);
+				const migrated = migrateExplicitEnvVars(ast.instance.content, envVars, ast.fragment);
+				if (!renamed && !migrated) return false;
+			})(content);
+			return transforms.script(({ ast, comments }) => {
+				const renamed = renameEnvNamespace(ast);
+				const migrated = migrateExplicitEnvVars(ast, envVars, void 0, comments);
+				if (!renamed && !migrated) return false;
+			})(content);
+		});
+		if (envVars.size > 0) sv.file(`src/env.${language}`, transforms.script(({ ast, comments }) => addEnvDeclarationFile(ast, comments, envVars)));
+	}
+});
+//#endregion
+//#region src/migrate/migrations/sveltekit-3/tasks/external-redirects.ts
+const KIT_MODULE$1 = "@sveltejs/kit";
+const REDIRECT = "redirect";
+const BASES = ["https://sveltekit-a.invalid", "https://sveltekit-b.invalid"];
+/** Stands in for the dynamic remainder of a partially static destination (e.g. `https://${domain}`). */
+const PLACEHOLDER = "x";
+var external_redirects_default = defineMigrationTask({
+	id: "external-redirects",
+	description: "Opt external redirects into the new redirect behavior",
+	run: ({ sv }) => {
+		sv.files({
+			include: "**/*.{js,ts,svelte}",
+			where: (content) => content.includes(KIT_MODULE$1) && content.includes(REDIRECT)
+		}, (content, file) => {
+			if (file.endsWith(".svelte")) return transforms.svelte(({ ast }) => {
+				let changed = false;
+				if (ast.module && migrateExternalRedirects(ast.module.content)) changed = true;
+				if (ast.instance && migrateExternalRedirects(ast.instance.content)) changed = true;
+				if (!changed) return false;
+			})(content);
+			return transforms.script(({ ast }) => {
+				if (!migrateExternalRedirects(ast)) return false;
+			})(content);
+		});
+	}
+});
+function migrateExternalRedirects(ast) {
+	const { locals, namespaces } = collectRedirectImports(ast);
+	if (locals.size === 0 && namespaces.size === 0) return false;
+	let changed = false;
+	Walker.walk(ast, null, { CallExpression(node, { next }) {
+		const destination = node.arguments[1];
+		if (isRedirectCall(node, locals, namespaces) && node.arguments.length === 2 && destination?.type !== "SpreadElement") {
+			const external = externalValue(destination);
+			if (external !== void 0) {
+				node.arguments.push(js.object.create({ external: js.common.createLiteral(external) }));
+				changed = true;
+			}
+		}
+		next();
+	} });
+	return changed;
+}
+function collectRedirectImports(ast) {
+	const bindings = js.imports.bindings(ast, { from: KIT_MODULE$1 });
+	return {
+		locals: new Set(bindings.filter((binding) => binding.kind === "named" && binding.imported === REDIRECT && !binding.isType).map((binding) => binding.local)),
+		namespaces: new Set(bindings.filter((binding) => binding.kind === "namespace" && !binding.isType).map((binding) => binding.local))
+	};
+}
+function isRedirectCall(node, locals, namespaces) {
+	const callee = node.callee;
+	if (callee.type === "Identifier") return locals.has(callee.name);
+	if (callee.type === "MemberExpression" && callee.object.type === "Identifier") {
+		if (!namespaces.has(callee.object.name)) return false;
+		if (callee.computed) return callee.property.type === "Literal" && callee.property.value === REDIRECT;
+		return callee.property.type === "Identifier" && callee.property.name === REDIRECT;
+	}
+	return false;
+}
+function externalValue(destination) {
+	const prefix = staticPrefix(destination);
+	if (prefix === void 0) return void 0;
+	let result = classify(prefix.value);
+	if (result === void 0 && !prefix.complete) result = classify(prefix.value + PLACEHOLDER);
+	return result === false ? void 0 : result;
+}
+/**
+* Classifies a destination string: `true` for external, `'javascript:'` for javascript URLs,
+* `false` for same-origin, and `undefined` when it cannot be parsed as a URL.
+*/
+function classify(value) {
 	try {
-		const cmdArgs = ["svelte-migrate@latest", ...args];
-		if (pm === "npm") cmdArgs.unshift("--yes");
-		execSync(resolveCommandArray(pm, "execute", cmdArgs).join(" "), {
-			stdio: "inherit",
+		const urls = BASES.map((base) => new URL(value, base));
+		if (urls.some((url) => url.protocol === "javascript:")) return "javascript:";
+		return urls.some((url, index) => url.origin !== BASES[index]) || false;
+	} catch {
+		return;
+	}
+}
+function staticPrefix(expression) {
+	if (expression.type === "Literal") return typeof expression.value === "string" ? {
+		value: expression.value,
+		complete: true
+	} : void 0;
+	if (expression.type === "TemplateLiteral") {
+		const value = expression.quasis[0]?.value.cooked ?? expression.quasis[0]?.value.raw;
+		if (value === void 0) return void 0;
+		return {
+			value,
+			complete: expression.expressions.length === 0
+		};
+	}
+	if (expression.type === "BinaryExpression" && expression.operator === "+") {
+		if (expression.left.type === "PrivateIdentifier") return void 0;
+		const left = staticPrefix(expression.left);
+		return left && {
+			value: left.value,
+			complete: false
+		};
+	}
+}
+//#endregion
+//#region src/migrate/migrations/sveltekit-3/tasks/imports.ts
+const KIT_MODULE = "@sveltejs/kit";
+const MOVED_EXPORTS = /* @__PURE__ */ new Map([
+	["ActionResult", "$app/forms"],
+	["AfterNavigate", "$app/navigation"],
+	["BeforeNavigate", "$app/navigation"],
+	["CaughtError", "@sveltejs/kit/hooks"],
+	["ClientCaughtError", "@sveltejs/kit/hooks"],
+	["ClientInit", "@sveltejs/kit/hooks"],
+	["DefinedEnvVars", "@sveltejs/kit/env"],
+	["DefinedParams", "@sveltejs/kit/params"],
+	["EnvVarConfig", "@sveltejs/kit/env"],
+	["GotoOptions", "$app/navigation"],
+	["Handle", "@sveltejs/kit/hooks"],
+	["HandleClientError", "@sveltejs/kit/hooks"],
+	["HandleFetch", "@sveltejs/kit/hooks"],
+	["HandleServerError", "@sveltejs/kit/hooks"],
+	["InvalidField", "$app/server"],
+	["LiveQueryRequestedResult", "$app/server"],
+	["LiveRequestedEntry", "$app/server"],
+	["MatcherParam", "@sveltejs/kit/params"],
+	["Navigation", "$app/navigation"],
+	["NavigationBase", "$app/navigation"],
+	["NavigationEnter", "$app/navigation"],
+	["NavigationExternal", "$app/navigation"],
+	["NavigationFormSubmit", "$app/navigation"],
+	["NavigationGoto", "$app/navigation"],
+	["NavigationLeave", "$app/navigation"],
+	["NavigationLink", "$app/navigation"],
+	["NavigationPopState", "$app/navigation"],
+	["NavigationTarget", "$app/navigation"],
+	["NavigationType", "$app/navigation"],
+	["OnNavigate", "$app/navigation"],
+	["Page", "$app/state"],
+	["ParamDefinition", "@sveltejs/kit/params"],
+	["ParamMatcher", "@sveltejs/kit/params"],
+	["ParamValue", "@sveltejs/kit/params"],
+	["QueryRequestedResult", "$app/server"],
+	["ReadonlyURL", "$app/state"],
+	["ReadonlyURLSearchParams", "$app/state"],
+	["RemoteCommand", "$app/server"],
+	["RemoteForm", "$app/server"],
+	["RemoteFormEnhanceCallback", "$app/server"],
+	["RemoteFormEnhanceInstance", "$app/server"],
+	["RemoteFormField", "$app/server"],
+	["RemoteFormFields", "$app/server"],
+	["RemoteFormFieldType", "$app/server"],
+	["RemoteFormFieldValue", "$app/server"],
+	["RemoteFormInput", "$app/server"],
+	["RemoteFormIssue", "$app/server"],
+	["RemoteLiveQuery", "$app/server"],
+	["RemoteLiveQueryFunction", "$app/server"],
+	["RemotePrerenderFunction", "$app/server"],
+	["RemoteQuery", "$app/server"],
+	["RemoteQueryFunction", "$app/server"],
+	["RemoteQueryOverride", "$app/server"],
+	["RemoteQueryUpdate", "$app/server"],
+	["RemoteResource", "$app/server"],
+	["RequestedEntry", "$app/server"],
+	["RequestedResult", "$app/server"],
+	["Reroute", "@sveltejs/kit/hooks"],
+	["ResolveOptions", "@sveltejs/kit/hooks"],
+	["ServerInit", "@sveltejs/kit/hooks"],
+	["SubmitFunction", "$app/forms"],
+	["Transport", "@sveltejs/kit/hooks"],
+	["Transporter", "@sveltejs/kit/hooks"],
+	["ValidationError", "$app/server"],
+	["defineParams", "@sveltejs/kit/params"]
+]);
+var imports_default = defineMigrationTask({
+	id: "imports",
+	description: "Move SvelteKit APIs to their new modules",
+	run: ({ sv }) => {
+		sv.files({
+			include: "**/*.{js,ts,mjs,mts,cjs,cts,svelte}",
+			where: (content) => content.includes(KIT_MODULE)
+		}, (content, file) => {
+			if (file.endsWith(".svelte")) return transforms.svelte(({ ast }) => {
+				let changed = false;
+				if (ast.module && migrateProgram(ast.module.content)) changed = true;
+				if (ast.instance && migrateProgram(ast.instance.content)) changed = true;
+				if (migrateComments(ast.comments)) changed = true;
+				if (!changed) return false;
+			})(content);
+			return transforms.script(({ ast, comments }) => {
+				const programChanged = migrateProgram(ast);
+				const commentsChanged = migrateComments(comments.list());
+				if (!programChanged && !commentsChanged) return false;
+			})(content);
+		});
+	}
+});
+function migrateProgram(ast) {
+	let changed = migrateNamedImports(ast);
+	const body = [];
+	for (const statement of ast.body) {
+		if (statement.type === "ExportNamedDeclaration" && statement.source?.value === KIT_MODULE) {
+			const replacements = splitExportSpecifiers(statement);
+			if (replacements) {
+				body.push(...replacements);
+				changed = true;
+				continue;
+			}
+		}
+		body.push(statement);
+	}
+	ast.body = body;
+	return migrateImportTypes(ast) || changed;
+}
+function migrateNamedImports(ast) {
+	const bindings = js.imports.bindings(ast, { from: KIT_MODULE }).filter((binding) => binding.kind === "named");
+	if (!bindings.some((binding) => MOVED_EXPORTS.has(binding.imported))) return false;
+	const bySource = /* @__PURE__ */ new Map();
+	for (const binding of bindings) {
+		const source = MOVED_EXPORTS.get(binding.imported) ?? KIT_MODULE;
+		const group = bySource.get(source) ?? [];
+		group.push(binding);
+		bySource.set(source, group);
+	}
+	for (const imported of new Set(bindings.map((binding) => binding.imported))) js.imports.remove(ast, {
+		from: KIT_MODULE,
+		name: imported
+	});
+	for (const [source, group] of [...bySource].reverse()) for (const binding of group) js.imports.addNamed(ast, {
+		from: source,
+		imports: { [binding.imported]: binding.local },
+		isType: binding.isType
+	});
+	return true;
+}
+function splitExportSpecifiers(declaration) {
+	const moved = /* @__PURE__ */ new Map();
+	const remaining = [];
+	for (const specifier of declaration.specifiers) {
+		const name = specifier.local.type === "Identifier" ? specifier.local.name : String(specifier.local.value);
+		const destination = MOVED_EXPORTS.get(name);
+		if (!destination) {
+			remaining.push(specifier);
+			continue;
+		}
+		const specifiers = moved.get(destination) ?? [];
+		specifiers.push(specifier);
+		moved.set(destination, specifiers);
+	}
+	if (moved.size === 0) return;
+	const declarations = [];
+	if (remaining.length > 0) declarations.push({
+		...declaration,
+		specifiers: remaining
+	});
+	for (const [source, specifiers] of moved) declarations.push({
+		...declaration,
+		specifiers,
+		source: {
+			type: "Literal",
+			value: source
+		}
+	});
+	return declarations;
+}
+function migrateImportTypes(node) {
+	if (!node || typeof node !== "object") return false;
+	if (Array.isArray(node)) {
+		let changed = false;
+		for (const child of node) if (migrateImportTypes(child)) changed = true;
+		return changed;
+	}
+	const record = node;
+	let changed = false;
+	if (record.type === "TSImportType") {
+		const argument = record.argument;
+		const qualifier = record.qualifier;
+		if (argument?.value === KIT_MODULE && qualifier?.type === "Identifier" && typeof qualifier.name === "string") {
+			const destination = MOVED_EXPORTS.get(qualifier.name);
+			if (destination) {
+				argument.value = destination;
+				argument.raw = void 0;
+				changed = true;
+			}
+		}
+	}
+	for (const child of Object.values(record)) if (migrateImportTypes(child)) changed = true;
+	return changed;
+}
+function migrateComments(comments) {
+	let changed = false;
+	for (const comment of comments) {
+		let value = comment.value.replace(/import(\s*\(\s*)(['"])@sveltejs\/kit\2(\s*\)\s*\.\s*)([A-Za-z_$][\w$]*)/g, (match, open, quote, close, name) => {
+			const destination = MOVED_EXPORTS.get(name);
+			if (!destination) return match;
+			changed = true;
+			return `import${open}${quote}${destination}${quote}${close}${name}`;
+		});
+		value = value.replace(/@import\s*\{([^}]+)\}\s*from\s*(['"])@sveltejs\/kit\2(;?)/g, (match, list, quote, semicolon) => {
+			const groups = /* @__PURE__ */ new Map();
+			for (const specifier of list.split(",")) {
+				const imported = /^(?:type\s+)?([A-Za-z_$][\w$]*)/.exec(specifier.trim())?.[1];
+				const source = imported && MOVED_EXPORTS.get(imported);
+				const group = groups.get(source ?? KIT_MODULE) ?? [];
+				group.push(specifier.trim());
+				groups.set(source ?? KIT_MODULE, group);
+			}
+			if (groups.size === 1 && groups.has(KIT_MODULE)) return match;
+			changed = true;
+			return [...groups].map(([source, specifiers]) => `@import { ${specifiers.join(", ")} } from ${quote}${source}${quote}${semicolon}`).join("\n * ");
+		});
+		comment.value = value;
+	}
+	return changed;
+}
+//#endregion
+//#region src/migrate/migrations/sveltekit-3/tasks/lib-alias.ts
+const LIB_ALIAS = /(?<=['"`])\$lib(\/(.+)['"`]|['"`])/g;
+function libSubpathImports(libDir) {
+	return {
+		"#lib": `./${libDir}/index.js`,
+		"#lib/*": `./${libDir}/*`
+	};
+}
+var lib_alias_default = defineMigrationTask({
+	id: "lib-alias",
+	description: "Replace the $lib alias with #lib subpath imports",
+	run: ({ sv, cwd, directory }) => {
+		sv.file("package.json", transforms.json(({ data }) => {
+			data.imports = {
+				...libSubpathImports(directory.lib),
+				...data.imports
+			};
+		}));
+		sv.files({
+			include: `${directory.src}/**/*.{svelte,svelte.ts,svelte.js,ts,js,svx,md}`,
+			where: (content) => content.includes("$lib")
+		}, (content) => {
+			const rewritten = content.replace(LIB_ALIAS, (match, _, import_path) => {
+				match = match.replace("$lib", "#lib");
+				if (import_path && !import_path.endsWith(".js") && !import_path.endsWith(".ts")) {
+					for (const ending of [
+						".js",
+						".ts",
+						"/index.js",
+						"/index.ts"
+					]) if (fs.existsSync(`${cwd}/${directory.lib}/${import_path}${ending}`)) return match.slice(0, -1) + ending.replace(".ts", ".js") + match.slice(-1);
+				}
+				return match;
+			});
+			return rewritten === content ? false : rewritten;
+		});
+	}
+});
+//#endregion
+//#region src/migrate/migrations/sveltekit-3/tasks/package-json.ts
+const KIT3_PEERS = {
+	vite: "^8.0.12",
+	"@sveltejs/vite-plugin-svelte": "^7.0.0",
+	svelte: "^5.56.4",
+	"svelte-check": "^4.7.5",
+	typescript: "^6.0.0"
+};
+var package_json_default = defineMigrationTask({
+	id: "package-json",
+	description: "Update package.json to be compatible with SvelteKit 3.0",
+	run: ({ sv, cwd, language, dependencyVersion }) => {
+		sv.devDependency("@sveltejs/kit", "next");
+		for (const [pkg, range] of Object.entries(KIT3_PEERS)) {
+			if (pkg === "typescript" && language !== "ts") continue;
+			const current = dependencyVersion(pkg);
+			if (current && isVersionUnsupportedBelow(current, range)) sv.devDependency(pkg, range);
+		}
+		const { data: pkg } = loadPackageJson(cwd);
+		const dependencies = {
+			...pkg.devDependencies,
+			...pkg.dependencies
+		};
+		for (const name of Object.keys(dependencies)) if (name.startsWith("@sveltejs/adapter-")) sv.devDependency(name, "next");
+	}
+});
+//#endregion
+//#region src/migrate/migrations/sveltekit-3/tasks/params.ts
+const MATCHER_FILE = /^\w+\.[jt]s$/;
+const TEST_HARNESS_FILE = /\.template\.[jt]s$/;
+var params_default = defineMigrationTask({
+	id: "params",
+	description: "Consolidate parameter matchers into src/params.js or src/params.ts",
+	run: ({ sv, cwd, directory, language }) => {
+		const paramsDirectory = path.posix.join(directory.src, "params");
+		const absoluteParamsDirectory = path.join(cwd, paramsDirectory);
+		if (!fs.existsSync(absoluteParamsDirectory)) return;
+		const entries = fs.readdirSync(absoluteParamsDirectory, { withFileTypes: true });
+		const isMatcher = (entry) => entry.isFile() && MATCHER_FILE.test(entry.name);
+		const foreignEntries = entries.filter((entry) => !isMatcher(entry) && !TEST_HARNESS_FILE.test(entry.name));
+		const matcherFiles = entries.filter(isMatcher).map((entry) => path.posix.join(paramsDirectory, entry.name)).sort();
+		if (matcherFiles.length === 0) return;
+		const target = `${paramsDirectory}.${language}`;
+		if (fs.existsSync(path.join(cwd, target))) throw new Error(`Cannot migrate parameter matchers because '${target}' already exists`);
+		const context = {
+			usedNames: /* @__PURE__ */ new Set(["defineParams", "params"]),
+			imports: /* @__PURE__ */ new Map(),
+			sideEffectImports: /* @__PURE__ */ new Set()
+		};
+		context.imports.set("named:defineParams:@sveltejs/kit/params", {
+			source: "@sveltejs/kit/params",
+			kind: "named",
+			imported: "defineParams",
+			local: "defineParams",
+			typeOnly: false
+		});
+		const matchers = matcherFiles.map((file) => migrateMatcher(cwd, file, target, context));
+		const parts = [];
+		if (foreignEntries.length > 0) {
+			const names = foreignEntries.map((entry) => entry.name).sort().join(", ");
+			parts.push(createMigrationTaskComment(`'${paramsDirectory}' contains entries that are not parameter matchers (${names}) and was left in place - migrate them and delete the directory manually`));
+		}
+		parts.push(...generateImportCode(context), "");
+		for (const matcher of matchers) if (matcher.hoisted) parts.push(matcher.hoisted, "");
+		parts.push("export const params = defineParams({", matchers.map((matcher) => matcher.entry).join(",\n"), "});", "");
+		const content = parts.join("\n");
+		sv.file(target, () => content);
+		if (foreignEntries.length > 0) return;
+		for (const file of matcherFiles) fs.unlinkSync(path.join(cwd, file));
+		if (fs.readdirSync(absoluteParamsDirectory).length === 0) fs.rmdirSync(absoluteParamsDirectory);
+	}
+});
+function migrateMatcher(cwd, file, target, context) {
+	const name = path.posix.basename(file).slice(0, -3);
+	const content = stripParamMatcherComments(fs.readFileSync(path.join(cwd, file), "utf8"));
+	const parsed = parse.script(content);
+	const importDeclarations = [];
+	const body = [];
+	const paramMatcherTypes = /* @__PURE__ */ new Set(["ParamMatcher"]);
+	let declaresMatch = false;
+	let exportsMatch = false;
+	for (const statement of parsed.ast.body) {
+		if (statement.type === "ImportDeclaration") {
+			if (statement.source.value === "@sveltejs/kit" || statement.source.value === "@sveltejs/kit/params") {
+				for (const specifier of statement.specifiers) if (specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "ParamMatcher") paramMatcherTypes.add(specifier.local.name);
+				statement.specifiers = statement.specifiers.filter((specifier) => specifier.type !== "ImportSpecifier" || specifier.imported.type !== "Identifier" || specifier.imported.name !== "ParamMatcher");
+				if (statement.specifiers.length === 0) continue;
+			}
+			let source = String(statement.source.value);
+			if (source.startsWith(".")) source = relocateImport(source, file, target);
+			if (statement.specifiers.length === 0) context.sideEffectImports.add(source);
+			else importDeclarations.push({
+				declaration: statement,
+				source
+			});
+			continue;
+		}
+		if (statement.type === "ExportDefaultDeclaration") throw new Error(`Cannot migrate '${file}' because it contains a default export`);
+		if (statement.type === "ExportAllDeclaration") throw new Error(`Cannot migrate '${file}' because it re-exports another module`);
+		if (statement.type === "ExportNamedDeclaration") {
+			if (statement.declaration) {
+				stripParamMatcherType(statement.declaration, paramMatcherTypes);
+				if (declares(statement.declaration, "match")) {
+					declaresMatch = true;
+					exportsMatch = true;
+				}
+				body.push(statement.declaration);
+			} else exportsMatch ||= statement.specifiers.some((specifier) => specifier.exported.type === "Identifier" && specifier.exported.name === "match");
+			continue;
+		}
+		stripParamMatcherType(statement, paramMatcherTypes);
+		declaresMatch ||= declares(statement, "match");
+		body.push(statement);
+	}
+	if (!declaresMatch || !exportsMatch) throw new Error(`Cannot migrate '${file}' because it does not export a local 'match' declaration`);
+	const renames = /* @__PURE__ */ new Map();
+	for (const { declaration, source } of importDeclarations) {
+		const typeOnly = declaration.importKind === "type";
+		for (const specifier of declaration.specifiers) {
+			const local = specifier.local.name;
+			const finalLocal = registerImport(context, {
+				source,
+				kind: specifier.type === "ImportDefaultSpecifier" ? "default" : specifier.type === "ImportNamespaceSpecifier" ? "namespace" : "named",
+				imported: specifier.type === "ImportDefaultSpecifier" ? "default" : specifier.type === "ImportNamespaceSpecifier" ? "*" : specifier.imported.type === "Identifier" ? specifier.imported.name : String(specifier.imported.value),
+				local,
+				typeOnly
+			});
+			if (finalLocal !== local) renames.set(local, finalLocal);
+		}
+	}
+	const nestedBindings = js.scope.nestedBindingNames(body);
+	for (const local of renames.keys()) if (nestedBindings.has(local)) throw new Error(`Cannot migrate '${file}' because the imported name '${local}' conflicts with another matcher and cannot be renamed safely`);
+	const identifier = name.replace(/\W/g, "_");
+	const preferredMatchName = `match${identifier.charAt(0).toUpperCase()}${identifier.slice(1)}`;
+	parsed.ast.body = body;
+	const topLevelBindings = js.scope.topLevelBindings([parsed.ast]);
+	const tentativeNames = new Set(context.usedNames);
+	const bodyRenames = /* @__PURE__ */ new Map();
+	for (const binding of topLevelBindings) {
+		const preferred = binding === "match" ? preferredMatchName : binding;
+		const finalName = js.identifiers.uniqueName(preferred, tentativeNames);
+		if (finalName !== binding) bodyRenames.set(binding, finalName);
+	}
+	const hoistable = [...bodyRenames.keys()].every((binding) => !nestedBindings.has(binding));
+	if (hoistable) {
+		for (const binding of topLevelBindings) context.usedNames.add(bodyRenames.get(binding) ?? binding);
+		for (const [from, to] of bodyRenames) renames.set(from, to);
+	}
+	js.identifiers.renameReferences([parsed.ast], renames);
+	const bodyCode = parsed.generateCode().trim();
+	if (hoistable) {
+		const matchName = bodyRenames.get("match");
+		return {
+			entry: `\t${propertyName(name)}: (param) => (${matchName}(param) ? param : undefined)`,
+			hoisted: bodyCode
+		};
+	}
+	return { entry: `\t${propertyName(name)}: (() => {\n${indent(bodyCode, 2)}\n\n\t\treturn (param) => (match(param) ? param : undefined);\n\t})()` };
+}
+/** Registers an import binding, deduplicating it and returning the module-level local name. */
+function registerImport(context, binding) {
+	const key = `${binding.kind}:${binding.imported}:${binding.source}`;
+	const existing = context.imports.get(key);
+	if (existing) {
+		existing.typeOnly &&= binding.typeOnly;
+		return existing.local;
+	}
+	const local = js.identifiers.uniqueName(binding.local, context.usedNames);
+	context.imports.set(key, {
+		...binding,
+		local
+	});
+	return local;
+}
+function generateImportCode(context) {
+	const bySource = /* @__PURE__ */ new Map();
+	for (const binding of context.imports.values()) {
+		const group = bySource.get(binding.source) ?? [];
+		group.push(binding);
+		bySource.set(binding.source, group);
+	}
+	const lines = [];
+	for (const [source, bindings] of bySource) {
+		const from = `from ${quoteString(source)};`;
+		const defaultBinding = bindings.find((binding) => binding.kind === "default");
+		const namespaceBinding = bindings.find((binding) => binding.kind === "namespace");
+		const namedBindings = bindings.filter((binding) => binding.kind === "named");
+		let defaultEmitted = false;
+		if (namespaceBinding) {
+			const prefix = defaultBinding && namedBindings.length === 0 ? `${defaultBinding.local}, ` : "";
+			defaultEmitted = prefix !== "";
+			lines.push(`import ${prefix}* as ${namespaceBinding.local} ${from}`);
+		}
+		if (namedBindings.length > 0 || defaultBinding && !defaultEmitted) {
+			const typeOnly = namedBindings.length > 0 && namedBindings.every((binding) => binding.typeOnly) && (!defaultBinding || defaultEmitted);
+			const specifiers = namedBindings.map((binding) => {
+				const imported = /^[$A-Z_a-z][$\w]*$/.test(binding.imported) ? binding.imported : quoteString(binding.imported);
+				const specifier = imported === binding.local ? binding.local : `${imported} as ${binding.local}`;
+				return !typeOnly && binding.typeOnly ? `type ${specifier}` : specifier;
+			}).join(", ");
+			const clauses = [];
+			if (defaultBinding && !defaultEmitted) clauses.push(defaultBinding.local);
+			if (namedBindings.length > 0) clauses.push(`{ ${specifiers} }`);
+			lines.push(`import ${typeOnly ? "type " : ""}${clauses.join(", ")} ${from}`);
+		}
+	}
+	for (const source of context.sideEffectImports) lines.push(`import ${quoteString(source)};`);
+	return lines;
+}
+function stripParamMatcherType(node, paramMatcherTypes) {
+	if (node.type !== "VariableDeclaration") return;
+	const declaration = node.declarations.find((declaration) => declaration.id.type === "Identifier" && declaration.id.name === "match");
+	if (!declaration || declaration.id.type !== "Identifier") return;
+	const annotation = declaration.id.typeAnnotation?.typeAnnotation;
+	if (annotation?.type === "TSTypeReference" && annotation.typeName.type === "Identifier" && paramMatcherTypes.has(annotation.typeName.name)) delete declaration.id.typeAnnotation;
+	if ((declaration.init?.type === "TSSatisfiesExpression" || declaration.init?.type === "TSAsExpression") && declaration.init.typeAnnotation.type === "TSTypeReference" && declaration.init.typeAnnotation.typeName.type === "Identifier" && paramMatcherTypes.has(declaration.init.typeAnnotation.typeName.name)) declaration.init = declaration.init.expression;
+}
+function stripParamMatcherComments(content) {
+	return content.replace(/\/\*\*[\s\S]*?\*\//g, (comment) => {
+		if (!comment.includes("ParamMatcher")) return comment;
+		const lines = comment.split("\n").filter((line) => !line.includes("ParamMatcher"));
+		return lines.length > 2 ? lines.join("\n") : "";
+	});
+}
+function declares(node, name) {
+	if ((node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") && node.id?.name === name) return true;
+	return node.type === "VariableDeclaration" && node.declarations.some((declaration) => declaration.id.type === "Identifier" && js.scope.collectPatternNames(declaration.id).includes(name));
+}
+function relocateImport(source, from, to) {
+	const resolved = path.posix.normalize(path.posix.join(path.posix.dirname(from), source));
+	let relative = path.posix.relative(path.posix.dirname(to), resolved);
+	if (!relative.startsWith(".")) relative = `./${relative}`;
+	return relative;
+}
+function propertyName(name) {
+	return /^[$A-Z_a-z][$\w]*$/.test(name) ? name : quoteString(name);
+}
+function quoteString(value) {
+	return `'${value.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}'`;
+}
+function indent(content, level) {
+	const prefix = "	".repeat(level);
+	return content.split("\n").map((line) => line ? `${prefix}${line}` : line).join("\n");
+}
+//#endregion
+//#region src/migrate/migrations/sveltekit-3/tasks/paths.ts
+const PATHS_MODULE = "$app/paths";
+const TYPES_MODULE = "$app/types";
+var paths_default = defineMigrationTask({
+	id: "paths",
+	description: "Migrate deprecated $app/paths APIs and path types",
+	run: ({ sv }) => {
+		sv.files({
+			include: "**/*.{js,ts,svelte}",
+			where: (content) => content.includes(PATHS_MODULE) || content.includes(TYPES_MODULE)
+		}, (content, file) => {
+			if (file.endsWith(".svelte")) return transforms.svelte(({ ast }) => {
+				const programs = [];
+				if (ast.module) programs.push(ast.module.content);
+				if (ast.instance) programs.push(ast.instance.content);
+				if (!migratePaths(programs, ast.fragment)) return false;
+			})(content);
+			return transforms.script(({ ast }) => {
+				if (!migratePaths([ast])) return false;
+			})(content);
+		});
+	}
+});
+function migratePaths(programs, fragment) {
+	const roots = fragment ? [...programs, fragment] : programs;
+	const pathBindings = programs.flatMap((program) => js.imports.bindings(program, { from: PATHS_MODULE }));
+	const typeBindings = programs.flatMap((program) => js.imports.bindings(program, { from: TYPES_MODULE }));
+	if (pathBindings.length === 0 && typeBindings.length === 0) return false;
+	const baseLocals = importedLocals(pathBindings, "base");
+	const assetsLocals = importedLocals(pathBindings, "assets");
+	const resolveRouteLocals = importedLocals(pathBindings, "resolveRoute");
+	const existingResolve = importAlias(pathBindings, "resolve");
+	const existingAsset = importAlias(pathBindings, "asset");
+	const needsResolve = baseLocals.length > 0 || resolveRouteLocals.length > 0;
+	const needsAsset = assetsLocals.length > 0;
+	const resolveLocal = existingResolve ?? preferredReplacementLocal(resolveRouteLocals, "resolve") ?? availableImportLocal(programs, "resolve", "resolvePath", [...baseLocals, ...resolveRouteLocals]);
+	const assetLocal = existingAsset ?? availableImportLocal(programs, "asset", "assetPath", assetsLocals);
+	const shadowedIdentifiers = js.scope.findShadowedIdentifiers(roots, [
+		...baseLocals,
+		...assetsLocals,
+		...resolveRouteLocals,
+		resolveLocal,
+		assetLocal
+	]);
+	const resolveRouteCalls = /* @__PURE__ */ new Set();
+	for (const root of roots) Walker.walk(root, null, { CallExpression(node, ctx) {
+		if (isNamedIdentifier(node.callee, resolveRouteLocals) && !shadowedIdentifiers.has(node.callee)) resolveRouteCalls.add(node);
+		ctx.next();
+	} });
+	let changed = false;
+	if (baseLocals.length > 0 || assetsLocals.length > 0) changed = collapsePathPrefixes(roots, baseLocals, assetsLocals, resolveRouteLocals, resolveLocal, assetLocal, shadowedIdentifiers);
+	if (js.identifiers.replaceReferences(roots, baseLocals, () => js.functions.createCall({
+		name: resolveLocal,
+		args: [""]
+	}))) changed = true;
+	if (js.identifiers.replaceReferences(roots, assetsLocals, () => js.functions.createCall({
+		name: assetLocal,
+		args: [""]
+	}))) changed = true;
+	if (js.imports.renameBinding(roots, {
+		from: PATHS_MODULE,
+		name: "assets",
+		to: "asset",
+		local: assetLocal
+	})) changed = true;
+	if (js.imports.renameBinding(roots, {
+		from: PATHS_MODULE,
+		name: "base",
+		to: "resolve",
+		local: resolveLocal
+	})) changed = true;
+	if (js.imports.renameBinding(roots, {
+		from: PATHS_MODULE,
+		name: "resolveRoute",
+		to: "resolve",
+		local: resolveLocal
+	})) changed = true;
+	const renamedAsset = renameImportedType(programs, roots, typeBindings, "Asset", "AssetPath");
+	if (renameImportedType(programs, roots, typeBindings, "Pathname", "Path") || renamedAsset) changed = true;
+	if (normalizePathCalls(roots, existingResolve !== void 0 || needsResolve ? resolveLocal : void 0, existingAsset !== void 0 || needsAsset ? assetLocal : void 0, resolveRouteCalls, shadowedIdentifiers)) changed = true;
+	return changed;
+}
+function importAlias(bindings, name) {
+	return bindings.find((binding) => binding.imported === name)?.local;
+}
+function importedLocals(bindings, name) {
+	return bindings.filter((binding) => binding.kind === "named" && binding.imported === name).map((binding) => binding.local);
+}
+function preferredReplacementLocal(locals, replacement) {
+	const local = locals[0];
+	if (!local) return void 0;
+	return local === "resolveRoute" ? replacement : local;
+}
+function collapsePathPrefixes(roots, baseLocals, assetsLocals, resolveRouteLocals, resolveLocal, assetLocal, shadowedIdentifiers) {
+	let changed = false;
+	const visitors = {
+		BinaryExpression(node, ctx) {
+			if (node.operator !== "+" || node.left.type !== "Identifier" || shadowedIdentifiers.has(node.left)) {
+				ctx.next();
+				return;
+			}
+			let replacement;
+			if (baseLocals.includes(node.left.name)) replacement = isResolveRouteCall(node.right, resolveRouteLocals, shadowedIdentifiers) ? node.right : js.functions.createCall({
+				name: resolveLocal,
+				args: [withoutLeadingSlash(node.right)]
+			});
+			else if (assetsLocals.includes(node.left.name)) replacement = js.functions.createCall({
+				name: assetLocal,
+				args: [withoutLeadingSlash(node.right)]
+			});
+			if (!replacement) {
+				ctx.next();
+				return;
+			}
+			js.common.replaceChild(ctx.path[ctx.path.length - 1], node, replacement);
+			changed = true;
+		},
+		TemplateLiteral(node, ctx) {
+			const first = node.expressions[0];
+			const parent = ctx.path[ctx.path.length - 1];
+			if (first?.type !== "Identifier" || shadowedIdentifiers.has(first) || node.quasis[0]?.value.raw !== "" || parent.type === "TaggedTemplateExpression" && parent.quasi === node) {
+				ctx.next();
+				return;
+			}
+			let callee;
+			if (baseLocals.includes(first.name)) callee = resolveLocal;
+			if (assetsLocals.includes(first.name)) callee = assetLocal;
+			if (!callee) {
+				ctx.next();
+				return;
+			}
+			const rest = {
+				type: "TemplateLiteral",
+				expressions: node.expressions.slice(1),
+				quasis: node.quasis.slice(1)
+			};
+			if (baseLocals.includes(first.name) && rest.quasis[0]?.value.raw === "" && rest.expressions[0] && isResolveRouteCall(rest.expressions[0], resolveRouteLocals, shadowedIdentifiers)) {
+				const onlyCall = rest.expressions.length === 1 && rest.quasis.every((quasi) => quasi.value.raw === "");
+				js.common.replaceChild(parent, node, onlyCall ? rest.expressions[0] : rest);
+				changed = true;
+				return;
+			}
+			js.common.replaceChild(parent, node, js.functions.createCall({
+				name: callee,
+				args: [withoutLeadingSlash(rest)]
+			}));
+			changed = true;
+		}
+	};
+	for (const root of roots) Walker.walk(root, null, visitors);
+	return changed;
+}
+function renameImportedType(programs, roots, bindings, oldName, newName) {
+	const oldLocals = importedLocals(bindings, oldName);
+	if (oldLocals.length === 0) return false;
+	const targetLocal = importAlias(bindings, newName) ?? (oldLocals[0] === oldName ? availableImportLocal(programs, newName, `App${newName}`, oldLocals) : oldLocals[0]);
+	return js.imports.renameBinding(roots, {
+		from: TYPES_MODULE,
+		name: oldName,
+		to: newName,
+		local: targetLocal
+	});
+}
+function availableImportLocal(programs, preferred, fallback, replacedLocals) {
+	const bindings = js.scope.topLevelBindings(programs);
+	for (const local of replacedLocals) bindings.delete(local);
+	if (!bindings.has(preferred) || replacedLocals.includes(preferred)) return preferred;
+	return js.identifiers.uniqueName(fallback, bindings);
+}
+function normalizePathCalls(roots, resolveLocal, assetLocal, resolveRouteCalls, shadowedIdentifiers) {
+	let changed = false;
+	const visitors = { CallExpression(node, ctx) {
+		const argument = node.arguments[0];
+		if (!argument || argument.type === "SpreadElement") {
+			ctx.next();
+			return;
+		}
+		const isAsset = assetLocal !== void 0 && node.callee.type === "Identifier" && node.callee.name === assetLocal;
+		const isPathname = resolveLocal !== void 0 && node.callee.type === "Identifier" && node.callee.name === resolveLocal && node.arguments.length === 1 && !resolveRouteCalls.has(node) && !looksLikeRouteId(argument);
+		if ((isAsset || isPathname) && node.callee.type === "Identifier" && !shadowedIdentifiers.has(node.callee) && removeStaticLeadingSlash(argument)) changed = true;
+		ctx.next();
+	} };
+	for (const root of roots) Walker.walk(root, null, visitors);
+	return changed;
+}
+function looksLikeRouteId(expression) {
+	if (expression.type === "Literal" && typeof expression.value === "string") return /[[(]/.test(expression.value);
+	if (expression.type === "TemplateLiteral") return expression.quasis.some((quasi) => /[[(]/.test(quasi.value.raw));
+	return false;
+}
+function withoutLeadingSlash(expression) {
+	if (removeStaticLeadingSlash(expression)) return expression;
+	return {
+		type: "CallExpression",
+		callee: {
+			type: "MemberExpression",
+			object: expression,
+			property: {
+				type: "Identifier",
+				name: "slice"
+			},
+			computed: false,
+			optional: false
+		},
+		arguments: [js.common.createLiteral(1)],
+		optional: false
+	};
+}
+function removeStaticLeadingSlash(expression) {
+	if (expression.type === "Literal" && typeof expression.value === "string") {
+		if (!expression.value.startsWith("/")) return false;
+		expression.value = expression.value.slice(1);
+		expression.raw = void 0;
+		return true;
+	}
+	if (expression.type === "TemplateLiteral") {
+		const quasi = expression.quasis[0];
+		if (!quasi?.value.raw.startsWith("/")) return false;
+		quasi.value.raw = quasi.value.raw.slice(1);
+		if (quasi.value.cooked !== void 0 && quasi.value.cooked !== null) quasi.value.cooked = quasi.value.cooked.slice(1);
+		return true;
+	}
+	return false;
+}
+function isResolveRouteCall(expression, resolveRouteLocals, shadowedIdentifiers) {
+	return expression.type === "CallExpression" && isNamedIdentifier(expression.callee, resolveRouteLocals) && !shadowedIdentifiers.has(expression.callee);
+}
+function isNamedIdentifier(node, names) {
+	return node.type === "Identifier" && names.includes(node.name);
+}
+//#endregion
+//#region src/migrate/migrations/sveltekit-3/tasks/shallow-routing.ts
+const NAVIGATION_MODULE = "$app/navigation";
+const SHALLOW_METHODS = /* @__PURE__ */ new Map([["pushState", false], ["replaceState", true]]);
+const NAVIGATION_HOOKS = /* @__PURE__ */ new Set([
+	"beforeNavigate",
+	"afterNavigate",
+	"onNavigate"
+]);
+var shallow_routing_default = defineMigrationTask({
+	id: "shallow-routing",
+	description: "Migrate shallow routing to goto()",
+	run: ({ sv, language }) => {
+		sv.files({
+			include: "**/*.{js,ts,svelte}",
+			where: (content) => content.includes(NAVIGATION_MODULE)
+		}, (content, file) => {
+			if (file.endsWith(".svelte")) return transforms.svelteScript({ language }, ({ ast }) => {
+				if (!migrateShallowRouting(ast.instance.content)) return false;
+			})(content);
+			return transforms.script(({ ast }) => {
+				if (!migrateShallowRouting(ast)) return false;
+			})(content);
+		});
+	}
+});
+function migrateShallowRouting(ast) {
+	const methods = /* @__PURE__ */ new Map();
+	const hooks = /* @__PURE__ */ new Set();
+	const oldSpecifiers = [];
+	const navigationImports = [];
+	let gotoLocal;
+	for (const binding of js.imports.bindings(ast, { from: NAVIGATION_MODULE })) {
+		if (binding.imported === "goto") gotoLocal = binding.local;
+		if (NAVIGATION_HOOKS.has(binding.imported)) hooks.add(binding.local);
+		const replace = SHALLOW_METHODS.get(binding.imported);
+		if (replace !== void 0) methods.set(binding.local, replace);
+		if (replace !== void 0 && binding.kind === "named") oldSpecifiers.push(binding.specifier);
+	}
+	for (const statement of ast.body) {
+		if (statement.type !== "ImportDeclaration" || statement.source.value !== NAVIGATION_MODULE) continue;
+		navigationImports.push(statement);
+	}
+	if (methods.size === 0 && hooks.size === 0) return false;
+	const { unmigratable, migratable } = scanMethodCalls(ast, methods);
+	const removable = oldSpecifiers.filter((specifier) => !unmigratable.has(specifier.local.name));
+	let changed = false;
+	if (!gotoLocal && migratable) {
+		const specifier = removable.shift();
+		if (specifier) {
+			const wasUnaliased = specifier.local.name === specifier.imported.name;
+			gotoLocal = specifier.local.name;
+			if (wasUnaliased && js.identifiers.freeName([ast], "goto") === "goto") {
+				specifier.imported.name = "goto";
+				specifier.local.name = "goto";
+				gotoLocal = "goto";
+			} else specifier.imported = js.variables.createIdentifier("goto");
+		} else {
+			gotoLocal = js.identifiers.freeName([ast], "goto");
+			navigationImports.find((navigationImport) => navigationImport.specifiers.some((s) => oldSpecifiers.includes(s))).specifiers.push({
+				type: "ImportSpecifier",
+				imported: js.variables.createIdentifier("goto"),
+				local: js.variables.createIdentifier(gotoLocal)
+			});
+		}
+		changed = true;
+	}
+	if (removable.length > 0) {
+		const emptiedImports = /* @__PURE__ */ new Set();
+		for (const declaration of navigationImports) {
+			if (declaration.specifiers.length === 0) continue;
+			declaration.specifiers = declaration.specifiers.filter((specifier) => !removable.includes(specifier));
+			if (declaration.specifiers.length === 0) emptiedImports.add(declaration);
+		}
+		ast.body = ast.body.filter((statement) => statement.type !== "ImportDeclaration" || !emptiedImports.has(statement));
+		changed = true;
+	}
+	Walker.walk(ast, null, { CallExpression(node, { next }) {
+		if (node.callee.type !== "Identifier") {
+			next();
+			return;
+		}
+		const replace = methods.get(node.callee.name);
+		if (replace !== void 0 && gotoLocal && !node.arguments.some((argument) => argument.type === "SpreadElement")) {
+			const state = node.arguments[1];
+			node.callee.name = gotoLocal;
+			node.arguments = [...node.arguments[0] ? [node.arguments[0]] : [], gotoOptions(replace, state)];
+			changed = true;
+		}
+		if (hooks.has(node.callee.name) && migrateNavigationHook(node)) changed = true;
+		next();
+	} });
+	return changed;
+}
+function scanMethodCalls(ast, methods) {
+	const unmigratable = /* @__PURE__ */ new Set();
+	let migratable = false;
+	Walker.walk(ast, null, { CallExpression(node, { next }) {
+		if (node.callee.type === "Identifier" && methods.has(node.callee.name)) if (node.arguments.some((argument) => argument.type === "SpreadElement")) unmigratable.add(node.callee.name);
+		else migratable = true;
+		next();
+	} });
+	return {
+		unmigratable,
+		migratable
+	};
+}
+function gotoOptions(replace, state) {
+	return js.object.create({
+		shallow: js.common.createLiteral(true),
+		replace: replace ? js.common.createLiteral(true) : void 0,
+		state
+	});
+}
+function migrateNavigationHook(call) {
+	const callback = call.arguments[0];
+	if (callback?.type !== "ArrowFunctionExpression" && callback?.type !== "FunctionExpression") return false;
+	const shallow = shallowTest(callback);
+	if (!shallow) return false;
+	const guard = {
+		type: "IfStatement",
+		test: shallow,
+		consequent: {
+			type: "ReturnStatement",
+			argument: null
+		}
+	};
+	if (callback.body.type === "BlockStatement") {
+		if (startsWithShallowGuard(callback.body, shallow)) return false;
+		callback.body.body.unshift(guard);
+	} else callback.body = {
+		type: "BlockStatement",
+		body: [guard, {
+			type: "ReturnStatement",
+			argument: callback.body
+		}]
+	};
+	return true;
+}
+function shallowTest(callback) {
+	const parameter = callback.params[0];
+	if (!parameter) {
+		callback.params.push({
+			type: "ObjectPattern",
+			properties: [patternProperty("shallow")]
+		});
+		return js.variables.createIdentifier("shallow");
+	}
+	if (parameter.type === "Identifier") return member(parameter.name, "shallow");
+	if (parameter.type === "AssignmentPattern" && parameter.left.type === "Identifier") return member(parameter.left.name, "shallow");
+	if (parameter.type !== "ObjectPattern") return void 0;
+	for (const entry of parameter.properties) {
+		if (entry.type !== "Property") continue;
+		const key = entry.key;
+		if ((key.type !== "Identifier" || key.name !== "shallow") && (key.type !== "Literal" || key.value !== "shallow")) continue;
+		if (entry.value.type === "Identifier") return js.variables.createIdentifier(entry.value.name);
+		if (entry.value.type === "AssignmentPattern" && entry.value.left.type === "Identifier") return js.variables.createIdentifier(entry.value.left.name);
+		return;
+	}
+	const restIndex = parameter.properties.findIndex((entry) => entry.type === "RestElement");
+	const shallowProperty = patternProperty("shallow");
+	if (restIndex === -1) parameter.properties.push(shallowProperty);
+	else parameter.properties.splice(restIndex, 0, shallowProperty);
+	return js.variables.createIdentifier("shallow");
+}
+function startsWithShallowGuard(body, shallow) {
+	const first = body.body[0];
+	return first?.type === "IfStatement" && first.consequent.type === "ReturnStatement" && first.consequent.argument === null && sameExpression(first.test, shallow);
+}
+function sameExpression(left, right) {
+	if (left.type === "Identifier" && right.type === "Identifier") return left.name === right.name;
+	return left.type === "MemberExpression" && right.type === "MemberExpression" && left.object.type === "Identifier" && right.object.type === "Identifier" && left.object.name === right.object.name && left.property.type === "Identifier" && right.property.type === "Identifier" && left.property.name === right.property.name;
+}
+function patternProperty(name) {
+	const value = js.variables.createIdentifier(name);
+	return {
+		type: "Property",
+		key: js.variables.createIdentifier(name),
+		value,
+		kind: "init",
+		method: false,
+		shorthand: true,
+		computed: false
+	};
+}
+function member(object, property) {
+	return {
+		type: "MemberExpression",
+		object: js.variables.createIdentifier(object),
+		property: js.variables.createIdentifier(property),
+		computed: false,
+		optional: false
+	};
+}
+//#endregion
+//#region src/migrate/migrations/sveltekit-3/tasks/svelte-config.ts
+const SVELTE_CONFIG_IMPORT = /(^|\/)svelte\.config(\.[mc]?[jt]s)?$/;
+var svelte_config_default = defineMigrationTask({
+	id: "svelte-config",
+	description: "Migrate svelte.config.* to vite.config.*",
+	run: ({ sv, cwd }) => {
+		const configSource = svelteConfig.find(cwd);
+		if (!configSource) return;
+		if (configSource.kind === "vite") return;
+		const originalConfigObject = svelteConfig.read(cwd);
+		if (!originalConfigObject) return;
+		fs.unlinkSync(path.join(cwd, configSource.path));
+		svelteConfig.edit({
+			sv,
 			cwd
+		}, ({ ast, override, comments }) => {
+			const configDeclaration = originalConfigObject.ast.body.find((node) => node.type === "VariableDeclaration" && node.declarations.some((d) => d.init === originalConfigObject.config));
+			const originalImports = [];
+			const originalStatements = [];
+			for (const node of originalConfigObject.ast.body) if (node.type === "ImportDeclaration") originalImports.push(node);
+			else if (node.type !== "ExportDefaultDeclaration" && node !== configDeclaration) originalStatements.push(node);
+			ast.body.unshift(...originalImports);
+			const exportIndex = ast.body.findIndex((node) => node.type === "ExportDefaultDeclaration");
+			ast.body.splice(exportIndex, 0, ...originalStatements);
+			const attachments = collectComments(originalConfigObject.ast, originalConfigObject.comments);
+			const propComments = /* @__PURE__ */ new Map();
+			const newConfigProperties = [...originalConfigObject.config.properties, ...originalConfigObject.kit.properties];
+			const keyedConfig = {};
+			let trustsAllOrigins = false;
+			for (const prop of newConfigProperties) {
+				if (prop.type !== "Property") continue;
+				if (prop.key.type !== "Identifier") continue;
+				if (prop.key.name === "kit") continue;
+				const propAttachment = attachments.get(prop);
+				keyedConfig[prop.key.name] = prop.value;
+				if (propAttachment) propComments.set(prop.key.name, propAttachment);
+			}
+			for (const [key, value] of Object.entries(keyedConfig)) {
+				if (key === "experimental" && value.type === "ObjectExpression") {
+					removeProperty(value, "handleRenderingErrors");
+					removeProperty(value, "instrumentation");
+					const index = value.properties.findIndex((prop) => prop.type === "Property" && prop.key.type === "Identifier" && prop.key.name === "tracing");
+					if (index !== -1) {
+						keyedConfig.tracing = value.properties[index].value;
+						value.properties.splice(index, 1);
+					}
+				}
+				if (key === "prerender" && value.type === "ObjectExpression") {
+					const originProp = value.properties.find((prop) => prop.type === "Property" && prop.key.type === "Identifier" && prop.key.name === "origin");
+					if (originProp) {
+						keyedConfig.paths ??= {
+							type: "ObjectExpression",
+							properties: []
+						};
+						keyedConfig.paths.properties.push({
+							type: "Property",
+							key: {
+								type: "Identifier",
+								name: "origin"
+							},
+							value: originProp.value,
+							kind: "init",
+							method: false,
+							shorthand: false,
+							computed: false
+						});
+						removeProperty(value, "origin");
+						if (value.properties.length === 0) delete keyedConfig.prerender;
+					}
+				}
+				if (key === "csrf" && value.type === "ObjectExpression") {
+					const checkOrigin = findDisabledCheckOrigin(value);
+					if (checkOrigin) {
+						checkOrigin.key.name = "trustedOrigins";
+						checkOrigin.value = {
+							type: "ArrayExpression",
+							elements: [{
+								type: "Literal",
+								value: "*"
+							}]
+						};
+						trustsAllOrigins = true;
+					}
+				}
+			}
+			delete keyedConfig.preloadStrategy;
+			override(keyedConfig);
+			if (trustsAllOrigins) Walker.walk(ast, null, { Property(node, { next }) {
+				if (node.key.type === "Identifier" && node.key.name === "trustedOrigins") addMigrationTask("trusting all origins with '*' is generally not recommended, see https://svelte.dev/docs/kit/configuration#csrf", {
+					comments,
+					node
+				});
+				next();
+			} });
+			const apply = (node, record) => {
+				for (const comment of record?.leading ?? []) comments.add(node, comment);
+				for (const comment of record?.trailing ?? []) comments.add(node, comment, { position: "trailing" });
+			};
+			let rootConfig;
+			forEachNode(ast, (node) => {
+				apply(node, attachments.get(node));
+				if (node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "sveltekit" && node.arguments[0]?.type === "ObjectExpression") rootConfig = node.arguments[0];
+			});
+			for (const prop of rootConfig?.properties ?? []) if (prop.type === "Property" && prop.key.type === "Identifier") apply(prop, propComments.get(prop.key.name));
 		});
-	} catch (error) {
-		forwardExitCode(error);
+		let addedConfigLoader = false;
+		sv.files({
+			include: "**/*.{js,ts,mjs,mts,cjs,cts}",
+			where: (content) => content.includes("svelte.config")
+		}, (content, filePath) => {
+			if (/(^|\/)eslint\.config\.[mc]?[jt]s$/.test(filePath)) {
+				const { ast } = parse.script(content);
+				const configImport = js.imports.findAll(ast, { from: SVELTE_CONFIG_IMPORT }).find((item) => item.kind === "static");
+				if (configImport?.node.loc) {
+					const start = offsetAt(content, configImport.node.loc.start);
+					const end = offsetAt(content, configImport.node.loc.end);
+					const replacement = "import { loadConfig } from '@sveltejs/load-config';\n\nconst svelteConfig = (await loadConfig('./', { traverse: false }))?.config;";
+					addedConfigLoader = true;
+					return content.slice(0, start) + replacement + content.slice(end);
+				}
+			}
+			return transforms.script(({ ast, comments, js }) => {
+				const found = js.imports.findAll(ast, { from: SVELTE_CONFIG_IMPORT });
+				if (found.length === 0) return false;
+				for (const imp of found) addMigrationTask("svelte.config was removed; switch to `import { loadConfig } from '@sveltejs/load-config'` to read your config", {
+					comments,
+					node: imp.node
+				});
+			})(content);
+		});
+		if (addedConfigLoader) sv.devDependency("@sveltejs/load-config", "^0.2.2");
+	}
+});
+const posKey = (p) => p.line * 1e6 + p.column;
+function offsetAt(content, pos) {
+	let offset = 0;
+	for (let line = 1; line < pos.line; line++) offset = content.indexOf("\n", offset) + 1;
+	return offset + pos.column;
+}
+/** Visits every AST node (objects with a `type`) reachable from `root`, including `root` itself. */
+function forEachNode(root, visit) {
+	if (!root || typeof root !== "object") return;
+	if (Array.isArray(root)) {
+		for (const item of root) forEachNode(item, visit);
+		return;
+	}
+	const node = root;
+	if (typeof node.type === "string") visit(node);
+	for (const key in node) {
+		if (key === "loc" || key === "range" || key === "parent") continue;
+		forEachNode(node[key], visit);
+	}
+}
+/** Removes a statically named property from an object literal. */
+function removeProperty(value, name) {
+	const index = value.properties.findIndex((prop) => prop.type === "Property" && prop.key.type === "Identifier" && prop.key.name === name);
+	if (index !== -1) value.properties.splice(index, 1);
+}
+/**
+* Maps each source comment to the node it documents, returned keyed by node identity. A comment is
+* the trailing comment of the node it sits behind on the same line, otherwise the leading comment of
+* the next node that starts after it. Nodes are sorted start-ascending then end-descending so an
+* outer node (e.g. a `Property`) wins over a node it encloses that starts at the same spot (its key).
+*/
+function collectComments(ast, source) {
+	const nodes = [];
+	forEachNode(ast, (node) => {
+		if (node.loc) nodes.push({
+			node,
+			start: posKey(node.loc.start),
+			end: posKey(node.loc.end)
+		});
+	});
+	nodes.sort((a, b) => a.start - b.start || b.end - a.end);
+	const topLevel = new Set(ast.body);
+	const map = /* @__PURE__ */ new Map();
+	const recordFor = (node) => {
+		let record = map.get(node);
+		if (!record) map.set(node, record = {
+			leading: [],
+			trailing: []
+		});
+		return record;
+	};
+	for (const comment of source.list()) {
+		const start = posKey(comment.loc.start);
+		const end = posKey(comment.loc.end);
+		let prev;
+		let next;
+		for (const item of nodes) {
+			if (item.end <= start && (!prev || item.end > prev.end)) prev = item;
+			if (item.start >= end) {
+				next = item;
+				break;
+			}
+		}
+		if (prev && comment.loc.start.line === prev.node.loc.end.line) {
+			const safeInline = comment.type === "Block" || topLevel.has(prev.node);
+			const value = safeInline ? comment.value : ` ${comment.value.trim()} `;
+			recordFor(prev.node).trailing.push({
+				type: safeInline ? comment.type : "Block",
+				value
+			});
+		} else if (next) recordFor(next.node).leading.push({
+			type: comment.type,
+			value: comment.value
+		});
+	}
+	return map;
+}
+/** Returns the `checkOrigin: false` property of a `csrf` object, if present. */
+function findDisabledCheckOrigin(value) {
+	return value.properties.find((p) => p.type === "Property" && p.key.type === "Identifier" && p.key.name === "checkOrigin" && p.value.type === "Literal" && p.value.value === false);
+}
+//#endregion
+//#region src/migrate/migrations/sveltekit-3/tasks/tsconfig.ts
+const GENERATED_CONFIG = /(^|\/)\.svelte-kit\/tsconfig\.json$/;
+const LEADING_PARENT = /^\.\.\//;
+/** The config SvelteKit now generates into `node_modules`, replacing `.svelte-kit/tsconfig.json`. */
+const PARENT_CONFIG = "$app/tsconfig";
+/**
+* Options the generated config already sets. A local copy of the same value is noise, but a
+* different value is a deliberate override and stays.
+*/
+const INHERITED_OPTIONS = {
+	allowImportingTsExtensions: true,
+	allowJs: true,
+	checkJs: true,
+	esModuleInterop: true,
+	forceConsistentCasingInFileNames: true,
+	isolatedModules: true,
+	module: "esnext",
+	moduleDetection: "force",
+	moduleResolution: "bundler",
+	noEmit: true,
+	resolveJsonModule: true,
+	skipLibCheck: true,
+	target: "esnext",
+	verbatimModuleSyntax: true
+};
+var tsconfig_default = defineMigrationTask({
+	id: "tsconfig",
+	description: "Extend the generated $app/tsconfig instead of .svelte-kit/tsconfig.json",
+	run: ({ sv, cwd, file }) => {
+		if (!file.typeConfig) return;
+		const moved = dropTypescriptOption(sv, cwd);
+		sv.file(path.relative(cwd, file.typeConfig), transforms.json(({ data }) => {
+			const extended = Array.isArray(data.extends) ? [...data.extends] : [data.extends];
+			const index = extended.findIndex((entry) => entry && GENERATED_CONFIG.test(entry));
+			if (index === -1 && !extended.includes(PARENT_CONFIG)) return false;
+			if (index !== -1) {
+				extended[index] = PARENT_CONFIG;
+				data.extends = Array.isArray(data.extends) ? extended : PARENT_CONFIG;
+			}
+			const include = data.include ??= ["src"];
+			include.push(...moved.filter((entry) => !include.includes(entry)));
+			if (data.compilerOptions?.types) {
+				const types = data.compilerOptions.types;
+				if (!types.includes("$app/types")) types.push("$app/types");
+			}
+			for (const [key, value] of Object.entries(data.compilerOptions ?? {})) if (INHERITED_OPTIONS[key] === value) delete data.compilerOptions[key];
+		}));
+	}
+});
+/**
+* Removes the deprecated `typescript.config` option, returning the paths its hook pushed onto
+* `include` so they can move to the project's own config. Hooks that do anything else are left in
+* place and flagged, since their intent can't be expressed as `include` entries.
+*/
+function dropTypescriptOption(sv, cwd) {
+	if (!svelteConfig.find(cwd)) return [];
+	const moved = [];
+	svelteConfig.edit({
+		sv,
+		cwd
+	}, ({ ast, comments }) => {
+		const found = findProperty(ast, "typescript");
+		if (!found) return false;
+		const pushed = includePushes(found.property.value);
+		if (!pushed) {
+			addMigrationTask("`typescript.config` is deprecated; configure TypeScript in tsconfig.json directly", {
+				comments,
+				node: found.property
+			});
+			return;
+		}
+		moved.push(...pushed.map((entry) => entry.replace(LEADING_PARENT, "")));
+		found.remove();
+	});
+	return moved;
+}
+/** Finds a property by name anywhere in the config, wherever the config keeps it. */
+function findProperty(ast, name) {
+	let found;
+	Walker.walk(ast, null, { ObjectExpression(node, { next }) {
+		const property = node.properties.find((p) => p.type === "Property" && p.key.type === "Identifier" && p.key.name === name);
+		if (property) found ??= {
+			property,
+			remove: () => node.properties.splice(node.properties.indexOf(property), 1)
+		};
+		next();
+	} });
+	return found;
+}
+/** The literal paths a `typescript.config` hook pushes onto `include`, if that's all it does. */
+function includePushes(option) {
+	if (option.type !== "ObjectExpression" || option.properties.length !== 1) return void 0;
+	const [config] = option.properties;
+	if (config.type !== "Property" || config.key.type !== "Identifier") return void 0;
+	if (config.key.name !== "config") return void 0;
+	const fn = config.value;
+	if (fn.type !== "ArrowFunctionExpression" && fn.type !== "FunctionExpression") return void 0;
+	if (fn.body.type !== "BlockStatement") return void 0;
+	const paths = [];
+	for (const statement of fn.body.body) {
+		if (statement.type !== "ExpressionStatement") return void 0;
+		const call = statement.expression;
+		if (call.type !== "CallExpression" || !isIncludePush(call.callee)) return void 0;
+		for (const argument of call.arguments) {
+			if (argument.type !== "Literal" || typeof argument.value !== "string") return void 0;
+			paths.push(argument.value);
+		}
+	}
+	return paths;
+}
+const memberName = (node) => node.property.type === "Identifier" ? node.property.name : void 0;
+/** Matches the callee of `config.include.push(...)`. */
+function isIncludePush(callee) {
+	return callee.type === "MemberExpression" && memberName(callee) === "push" && callee.object.type === "MemberExpression" && memberName(callee.object) === "include";
+}
+//#endregion
+//#region src/cli/migrate.ts
+const migrations = [
+	defineMigration({
+		id: "sveltekit-3",
+		changelog: "https://next.svelte.dev/docs/kit/migrating-to-sveltekit-3",
+		description: "A set of migrations for SvelteKit 3.0",
+		setup: ({ pkg, requires }) => {
+			const kitPackageName = "@sveltejs/kit";
+			if (!pkg.devDependencies?.[kitPackageName]) throw new Error(`${color.command(kitPackageName)} is not a devDependency in package.json - this doesn't look like a SvelteKit project.\nPoint to one with ${color.command("--cwd <path>")}, or see ${color.command("sv migrate --help")}.`);
+			const kitVersion = coerceVersion(pkg.devDependencies[kitPackageName]);
+			if (kitVersion.major && kitVersion.major < 2) requires("sveltekit-2");
+		},
+		collect: ({ tasks }) => {
+			tasks.add(package_json_default, { prerequisite: true });
+			tasks.add(tsconfig_default, { prerequisite: true });
+			tasks.add(svelte_config_default, { prerequisite: false });
+			tasks.add(environment_default, { prerequisite: false });
+			tasks.add(paths_default, { prerequisite: false });
+			tasks.add(external_redirects_default, { prerequisite: false });
+			tasks.add(shallow_routing_default, { prerequisite: false });
+			tasks.add(params_default, { prerequisite: false });
+			tasks.add(imports_default, { prerequisite: false });
+			tasks.add(lib_alias_default, { prerequisite: false });
+			tasks.add(app_state_default$1, { prerequisite: false });
+			tasks.add(collect_migration_instructions_default, { prerequisite: false });
+		}
+	}),
+	app_state_default,
+	...legacyMigrations
+];
+const MigrationScheme = optional(picklist(migrations.map((m) => m.id)));
+function normalizeTasksOption(tasks) {
+	return tasks === true ? [] : tasks;
+}
+const OptionsSchema = strictObject({
+	cwd: optional(string(), "./"),
+	files: optional(string()),
+	gitCheck: boolean(),
+	tasks: pipe(optional(union([array(string()), literal(true)])), transform(normalizeTasksOption)),
+	confirm: optional(boolean(), false),
+	install: optional(union([boolean(), picklist(AGENT_NAMES)]), true)
+});
+const migrate = new Command("migrate").description("a CLI for migrating Svelte(Kit) codebases").argument("[migration]", `migration to run`).option("--cwd <path>", "working directory to run the migration in").option("--files <glob>", "only run the migration on a subset of files matching the provided glob pattern").option("--no-git-check", "even if some files are dirty, no prompt will be shown").option("--tasks [task...]", "migration tasks to run. Omit list of tasks to show available tasks. Use `--task all` to run all migration tasks.").option("--confirm", "skip the final confirmation prompt").option("--no-install", "skip installing dependencies").addOption(installOption).action((migrationName, options) => {
+	if (hasInstallConflict(V.argv)) {
+		errorAndExit(`The ${color.command("--install")} and ${color.command("--no-install")} options cannot be used together.`);
+		return;
+	}
+	let verifiedMigrationName = parse$1(MigrationScheme, migrationName);
+	const verifiedOptions = parse$1(OptionsSchema, options);
+	runCommand(async () => {
+		const pkg = ensureValidWorkspace(verifiedOptions.cwd);
+		if (!pkg) return;
+		if (verifiedOptions.tasks?.length !== 0) await runAndValidateVerifications([...verifyCleanWorkingDirectory(options.cwd, options.gitCheck)]);
+		if (!verifiedMigrationName) verifiedMigrationName = await Ee({
+			message: "Select a migration to run",
+			options: migrations.map((m) => ({
+				value: m.id,
+				label: m.id,
+				hint: m.description
+			}))
+		});
+		if (R(verifiedMigrationName)) {
+			ge("Operation cancelled.");
+			V.exit(1);
+		}
+		const migration = migrations.find((m) => m.id === verifiedMigrationName);
+		if (!migration) {
+			errorAndExit(`Migration ${verifiedMigrationName} not found`);
+			return;
+		}
+		const legacyMigration = migration.legacy ?? false;
+		if (legacyMigration && verifiedOptions.tasks !== void 0) {
+			errorAndExit(`The migration ${migration.id} does not support task selection.`);
+			return;
+		}
+		if (verifiedOptions.tasks?.length === 0) {
+			const allTasks = await collectMigrationTasks(migration, verifiedOptions.cwd);
+			if (allTasks.length === 0) {
+				errorAndExit(`Migration "${migration.id}" did not return any tasks.`);
+				return;
+			}
+			Ce(formatAvailableTasks(allTasks), `Available tasks for ${migration.id}`, { format: (line) => line });
+			return;
+		}
+		const tasks = await determineTasks(migration, verifiedOptions, pkg);
+		if (!tasks) return;
+		resetMigrationTaskCount();
+		const modifiedFiles = await applyTasks(verifiedOptions, tasks, legacyMigration);
+		if (legacyMigration) return;
+		const workspace = await createWorkspace({ cwd: verifiedOptions.cwd });
+		await formatFiles({
+			cwd: workspace.cwd,
+			packageManager: workspace.packageManager,
+			filesToFormat: modifiedFiles.values().toArray(),
+			strategy: "project-script-then-files-only"
+		});
+		const packageManager = verifiedOptions.install === false ? null : verifiedOptions.install === true ? await packageManagerPrompt(workspace.cwd) : verifiedOptions.install;
+		if (packageManager) await installDependencies(packageManager, workspace.cwd);
+		reportNextSteps();
+	});
+});
+function ensureValidWorkspace(cwd) {
+	try {
+		return loadPackageJson(cwd).data;
+	} catch {
+		errorAndExit(`No package.json found in ${path.resolve(cwd)}.\nPoint to a project with ${color.command("--cwd <path>")}, or see ${color.command("sv migrate --help")}.`);
+	}
+}
+async function determineTasks(migration, options, pkg) {
+	const requiredMigrations = [];
+	const setupOptions = {
+		pkg,
+		cwd: options.cwd,
+		requires: (migrationId) => {
+			requiredMigrations.push(migrationId);
+		}
+	};
+	try {
+		await migration.setup(setupOptions);
+	} catch (err) {
+		errorAndExit(err instanceof Error ? err.message : String(err));
+		return;
+	}
+	if (requiredMigrations.length > 0) {
+		errorAndExit(`The migration ${migration.id} requires the following migrations to be run first: ${requiredMigrations.join(", ")}`);
+		return;
+	}
+	const allTasks = await collectMigrationTasks(migration, options.cwd);
+	if (allTasks.length === 0) {
+		errorAndExit(`Migration "${migration.id}" did not return any tasks to run.`);
+		return;
+	}
+	const prerequisiteTasks = allTasks.filter((t) => t.prerequisite);
+	const selectableTasks = allTasks.filter((t) => !t.prerequisite);
+	if (!options.tasks?.length && selectableTasks.length > 0) {
+		const workflow = [];
+		if (migration.changelog) workflow.push("Make sure to read the changelog for this migration before running it:", color.website(migration.changelog), "");
+		workflow.push(`To make migration changes easier to review, run ${color.command("one selectable task at a time")} and ${color.command("commit after each run")}.`, "Tasks are intended to create focused commits, not independent migration paths.", `Most projects need ${color.warning("all applicable tasks")} before they work correctly.`);
+		Ce(workflow.join("\n"), "Recommended workflow", { format: (line) => line });
+	}
+	const tasksToRun = [...prerequisiteTasks];
+	if (options.tasks) tasksToRun.push(...selectTasksFromArgs(options.tasks, selectableTasks));
+	else if (selectableTasks.length > 0) {
+		const prerequisiteIds = prerequisiteTasks.map((t) => t.id).join(", ");
+		const selectedTaskIds = await we({
+			message: prerequisiteTasks.length ? `Select tasks to run; prerequisites always included: ${color.command(prerequisiteIds)}` : "Select the tasks to run",
+			options: selectableTasks.map((t) => ({
+				value: t.id,
+				label: t.id,
+				hint: t.description
+			})),
+			required: false
+		});
+		if (R(selectedTaskIds)) {
+			ge("Operation cancelled.");
+			V.exit(1);
+		}
+		const selectedTasks = selectableTasks.filter((t) => selectedTaskIds.includes(t.id));
+		tasksToRun.push(...selectedTasks);
+	}
+	if (tasksToRun.length === 0) {
+		errorAndExit("No tasks selected to run.");
+		return;
+	}
+	Ce(`- ${tasksToRun.map(({ id, description }) => {
+		return `${id} ${color.optional(`(${description})`)}`;
+	}).join("\n- ")}`, "Migration steps", { format: (line) => line });
+	if (!options.confirm) {
+		const proceed = await le({
+			message: "Do you want to proceed?",
+			initialValue: false
+		});
+		if (R(proceed)) {
+			ge("Operation cancelled.");
+			V.exit(1);
+		}
+		if (!proceed) {
+			errorAndExit("Migration cancelled by the user.");
+			return;
+		}
+	}
+	return tasksToRun;
+}
+async function collectMigrationTasks(migration, cwd) {
+	const allTasks = [];
+	const collectOptions = {
+		cwd,
+		tasks: { add: (task, options) => {
+			allTasks.push({
+				...task,
+				...options
+			});
+		} }
+	};
+	await migration.collect(collectOptions);
+	return allTasks;
+}
+function formatAvailableTasks(tasks) {
+	return tasks.map(({ id, description, prerequisite }) => `- ${id}${prerequisite ? color.warning(" (prerequisite)") : ""}: ${color.optional(description)}`).join("\n");
+}
+function selectTasksFromArgs(selectedTaskIds, selectableTasks) {
+	if (selectedTaskIds.length > 1 && (selectedTaskIds.includes("all") || selectedTaskIds.includes("prerequisite"))) errorAndExit(`The ${color.command("--tasks")} values ${color.command("all")} and ${color.command("prerequisite")} cannot be combined with other tasks.`);
+	if (selectedTaskIds[0] === "prerequisite") return [];
+	if (selectedTaskIds[0] === "all") return selectableTasks;
+	const invalidTasks = selectedTaskIds.filter((id) => !selectableTasks.some((t) => t.id === id));
+	if (invalidTasks.length > 0) errorAndExit(`Unknown migration task${invalidTasks.length === 1 ? "" : "s"}: ${invalidTasks.map((id) => color.command(id)).join(", ")}\nAvailable tasks: ${selectableTasks.map((t) => color.command(t.id)).join(", ")}`);
+	return selectableTasks.filter((task) => selectedTaskIds.includes(task.id));
+}
+/** Prints a summary of the `@migration-task` comments left for the user to resolve, if any. */
+function reportNextSteps() {
+	const total = getMigrationTaskCount();
+	if (total === 0) return;
+	Ce([`${total} ${total === 1 ? "comment" : "comments"} to review.`, `Search for ${color.command(MIGRATION_TASK_MARKER)} to resolve ${total === 1 ? "it" : "them"}.`].join("\n"), "Next steps", { format: (line) => line });
+}
+function hasInstallConflict(argv) {
+	return argv.some((arg) => arg === "--install" || arg.startsWith("--install=")) && argv.includes("--no-install");
+}
+async function applyTasks(options, tasks, legacyMigration) {
+	let allModifiedFiles = /* @__PURE__ */ new Set();
+	let allUnmodifiedFiles = /* @__PURE__ */ new Set();
+	const { start, stop, message, error } = vt();
+	if (!legacyMigration) start("Applying migration tasks...");
+	for (let i = 0; i < tasks.length; i++) {
+		const task = tasks[i];
+		if (!legacyMigration) message(`${i + 1}/${tasks.length}: ${task.id}`);
+		try {
+			const workspace = await createWorkspace({ cwd: options.cwd });
+			const { sv, finalize } = prepareSvApi(workspace, {
+				executeOutputPrefix: `${task.id}:`,
+				filesFilter: options.files
+			});
+			await task.run({
+				sv,
+				...workspace
+			});
+			if (!legacyMigration) {
+				const { modifiedFiles, unmodifiedFiles } = finalize();
+				allModifiedFiles = allModifiedFiles.union(modifiedFiles);
+				allUnmodifiedFiles = allUnmodifiedFiles.union(unmodifiedFiles);
+			}
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			const message = `Task '${task.id}' failed: ${errorMessage}`;
+			if (!legacyMigration) error(message);
+			R$1.message();
+			ge("Migration failed.");
+			V.exit(1);
+		}
 	}
+	if (!legacyMigration) stop("All tasks applied successfully!");
+	if (allUnmodifiedFiles.size > 0) Ce(`The following files were modified by the migration,\nbut their content was not saved:\n- ${Array.from(allUnmodifiedFiles).join("\n- ")}`, "Unmodified files", { format: (line) => line });
+	return allModifiedFiles;
 }
 //#endregion
 //#region bin.ts