sv 0.11.2 → 0.11.3

package/dist/official-P5OKi7QM.mjs

@@ -1,2586 +0,0 @@
-import { i as __toESM } from "./chunk-BjMGrMj9.mjs";
-import { C as writeFile, D as q, S as readFile, T as resolveCommand, _ as fileExists, b as getPackageJson, g as commonFilePaths, h as sanitizeName, k as getSharedFiles, r as getUserAgent, u as any, w as detect, x as installPackages, y as getHighlighter } from "./package-manager-CySZrSUa.mjs";
-import { A as property, B as parseStatement, C as addNamed, D as createCall, E as remove, F as contains, I as createLiteral, L as createSpread, M as create$1, N as addJsDocTypeComment, O as create, P as appendStatement, R as hasTypeProperty, S as addEmpty, T as find, V as dedent_default, _ as createDefault, a as toFragment, at as parseSvelte, b as declaration, c as createPrinter, ct as MagicString, d as defineAddonOptions, dt as require_picocolors, g as addHooksHandle, h as addGlobalAppInterface, it as parseScript, j as append, k as overrideProperties, lt as walk, m as getConfig, n as addSlot, nt as parseHtml, ot as parseToml, p as addPlugin, q as T, r as ensureScript, rt as parseJson, t as import_picocolors$1, tt as parseCss, u as defineAddon, v as createNamed, w as addNamespace, x as addDefault, y as createIdentifier, z as parseExpression } from "./core-D715tamU.mjs";
-import fs from "node:fs";
-import path from "node:path";
-import process from "node:process";
-
-//#region lib/cli/utils/env.ts
-const TESTING = process.env.NODE_ENV?.toLowerCase() === "test";
-
-//#endregion
-//#region lib/cli/add/workspace.ts
-async function createWorkspace({ cwd: cwd$1, packageManager, override }) {
-	const resolvedCwd = path.resolve(cwd$1);
-	const typescript = any([commonFilePaths.jsconfig, commonFilePaths.tsconfig], { cwd: cwd$1 })?.endsWith(commonFilePaths.tsconfig) ?? false;
-	const viteConfigPath = path.join(resolvedCwd, commonFilePaths.viteConfigTS);
-	const viteConfig = fs.existsSync(viteConfigPath) ? commonFilePaths.viteConfigTS : commonFilePaths.viteConfig;
-	const svelteConfigPath = path.join(resolvedCwd, commonFilePaths.svelteConfigTS);
-	const svelteConfig = fs.existsSync(svelteConfigPath) ? commonFilePaths.svelteConfigTS : commonFilePaths.svelteConfig;
-	let dependencies = {};
-	if (override?.dependencies) dependencies = override.dependencies;
-	else {
-		let directory = resolvedCwd;
-		const workspaceRoot = findWorkspaceRoot(directory);
-		const { root } = path.parse(directory);
-		while (directory && directory.length >= workspaceRoot.length) {
-			if (fs.existsSync(path.join(directory, commonFilePaths.packageJson))) {
-				const { data: packageJson } = getPackageJson(directory);
-				dependencies = {
-					...packageJson.devDependencies,
-					...packageJson.dependencies,
-					...dependencies
-				};
-			}
-			if (root === directory) break;
-			directory = path.dirname(directory);
-		}
-	}
-	for (const [key, value] of Object.entries(dependencies)) dependencies[key] = value.replaceAll(/[^\d|.]/g, "");
-	const kit = override?.kit ? override.kit : dependencies["@sveltejs/kit"] ? parseKitOptions(resolvedCwd) : void 0;
-	const stylesheet = kit ? `${kit.routesDirectory}/layout.css` : "src/app.css";
-	return {
-		cwd: resolvedCwd,
-		packageManager: packageManager ?? (await detect({ cwd: cwd$1 }))?.name ?? getUserAgent() ?? "npm",
-		typescript,
-		files: {
-			viteConfig,
-			svelteConfig,
-			stylesheet,
-			package: "package.json",
-			gitignore: ".gitignore",
-			prettierignore: ".prettierignore",
-			prettierrc: ".prettierrc",
-			eslintConfig: "eslint.config.js",
-			vscodeSettings: ".vscode/settings.json",
-			getRelative({ from, to }) {
-				from = from ?? "";
-				let relativePath = path.posix.relative(path.posix.dirname(from), to);
-				if (!relativePath.startsWith(".") && !relativePath.startsWith("/")) relativePath = `./${relativePath}`;
-				return relativePath;
-			}
-		},
-		kit,
-		dependencyVersion: (pkg) => dependencies[pkg]
-	};
-}
-function findWorkspaceRoot(cwd$1) {
-	const { root } = path.parse(cwd$1);
-	let directory = cwd$1;
-	while (directory && directory !== root) {
-		if (fs.existsSync(path.join(directory, commonFilePaths.packageJson))) {
-			if (fs.existsSync(path.join(directory, "pnpm-workspace.yaml"))) return directory;
-			const { data } = getPackageJson(directory);
-			if (data.workspaces) return directory;
-		}
-		directory = path.dirname(directory);
-	}
-	return cwd$1;
-}
-function parseKitOptions(cwd$1) {
-	const { ast } = parseScript(readFile(cwd$1, commonFilePaths.svelteConfig));
-	const defaultExport = ast.body.find((s) => s.type === "ExportDefaultDeclaration");
-	if (!defaultExport) throw Error(`Missing default export in \`${commonFilePaths.svelteConfig}\``);
-	let objectExpression;
-	if (defaultExport.declaration.type === "Identifier") {
-		const identifier = defaultExport.declaration;
-		for (const declaration$1 of ast.body) {
-			if (declaration$1.type !== "VariableDeclaration") continue;
-			const declarator = declaration$1.declarations.find((d) => d.type === "VariableDeclarator" && d.id.type === "Identifier" && d.id.name === identifier.name);
-			if (declarator?.init?.type !== "ObjectExpression") continue;
-			objectExpression = declarator.init;
-		}
-		if (!objectExpression) throw Error(`Unable to find svelte config object expression from \`${commonFilePaths.svelteConfig}\``);
-	} else if (defaultExport.declaration.type === "ObjectExpression") objectExpression = defaultExport.declaration;
-	if (!objectExpression) throw new Error(`Unexpected svelte config shape from \`${commonFilePaths.svelteConfig}\``);
-	const kit = property(objectExpression, {
-		name: "kit",
-		fallback: create({})
-	});
-	const files = property(kit, {
-		name: "files",
-		fallback: create({})
-	});
-	const routes = property(files, {
-		name: "routes",
-		fallback: createLiteral("")
-	});
-	const lib = property(files, {
-		name: "lib",
-		fallback: createLiteral("")
-	});
-	return {
-		routesDirectory: routes.value || "src/routes",
-		libDirectory: lib.value || "src/lib"
-	};
-}
-
-//#endregion
-//#region lib/addons/install.ts
-var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
-async function installAddon({ addons, cwd: cwd$1, options: options$7, packageManager = "npm" }) {
-	const workspace = await createWorkspace({
-		cwd: cwd$1,
-		packageManager
-	});
-	return await applyAddons({
-		addons,
-		workspace,
-		options: options$7,
-		addonSetupResults: setupAddons(Object.values(addons), workspace)
-	});
-}
-async function applyAddons({ addons, workspace, addonSetupResults, options: options$7 }) {
-	const filesToFormat = /* @__PURE__ */ new Set();
-	const allPnpmBuildDependencies = [];
-	const status = {};
-	const ordered = orderAddons(Object.entries(addons).map(([, addon]) => addon), addonSetupResults);
-	let hasFormatter = false;
-	for (const addon of ordered) {
-		const workspaceOptions = options$7[addon.id] || {};
-		const addonWorkspace = await createWorkspace({
-			cwd: workspace.cwd,
-			packageManager: workspace.packageManager
-		});
-		if (!hasFormatter) hasFormatter = !!addonWorkspace.dependencyVersion("prettier");
-		const { files, pnpmBuildDependencies, cancels } = await runAddon({
-			workspace: addonWorkspace,
-			workspaceOptions,
-			addon,
-			multiple: ordered.length > 1
-		});
-		files.forEach((f) => filesToFormat.add(f));
-		pnpmBuildDependencies.forEach((s) => allPnpmBuildDependencies.push(s));
-		if (cancels.length === 0) status[addon.id] = "success";
-		else status[addon.id] = cancels;
-	}
-	return {
-		filesToFormat: hasFormatter ? Array.from(filesToFormat) : [],
-		pnpmBuildDependencies: allPnpmBuildDependencies,
-		status
-	};
-}
-function setupAddons(addons, workspace) {
-	const addonSetupResults = {};
-	for (const addon of addons) {
-		const setupResult = {
-			unsupported: [],
-			dependsOn: [],
-			runsAfter: []
-		};
-		addon.setup?.({
-			...workspace,
-			dependsOn: (name) => {
-				setupResult.dependsOn.push(name);
-				setupResult.runsAfter.push(name);
-			},
-			unsupported: (reason) => setupResult.unsupported.push(reason),
-			runsAfter: (name) => setupResult.runsAfter.push(name)
-		});
-		addonSetupResults[addon.id] = setupResult;
-	}
-	return addonSetupResults;
-}
-async function runAddon({ addon, multiple, workspace, workspaceOptions }) {
-	const files = /* @__PURE__ */ new Set();
-	const options$7 = { ...workspaceOptions };
-	for (const [id, question] of Object.entries(addon.options)) if (question.condition?.(options$7) !== false) options$7[id] ??= question.default;
-	const dependencies = [];
-	const pnpmBuildDependencies = [];
-	const sv = {
-		file: (path$1, content) => {
-			try {
-				let fileContent = fileExists(workspace.cwd, path$1) ? readFile(workspace.cwd, path$1) : "";
-				fileContent = content(fileContent);
-				if (!fileContent) return fileContent;
-				writeFile(workspace, path$1, fileContent.replaceAll("<\\/script>", "<\/script>"));
-				files.add(path$1);
-			} catch (e) {
-				if (e instanceof Error) throw new Error(`Unable to process '${path$1}'. Reason: ${e.message}`);
-				throw e;
-			}
-		},
-		execute: async (commandArgs, stdio) => {
-			const { command, args } = resolveCommand(workspace.packageManager, "execute", commandArgs);
-			const addonPrefix = multiple ? `${addon.id}: ` : "";
-			const executedCommand = `${command} ${args.join(" ")}`;
-			if (!TESTING) T.step(`${addonPrefix}Running external command ${import_picocolors.default.gray(`(${executedCommand})`)}`);
-			if (workspace.packageManager === "npm") args.unshift("--yes");
-			try {
-				await q(command, args, {
-					nodeOptions: {
-						cwd: workspace.cwd,
-						stdio: TESTING ? "pipe" : stdio
-					},
-					throwOnError: true
-				});
-			} catch (error) {
-				const typedError = error;
-				throw new Error(`Failed to execute scripts '${executedCommand}': ${typedError.message}`, { cause: typedError.output });
-			}
-		},
-		dependency: (pkg, version) => {
-			dependencies.push({
-				pkg,
-				version,
-				dev: false
-			});
-		},
-		devDependency: (pkg, version) => {
-			dependencies.push({
-				pkg,
-				version,
-				dev: true
-			});
-		},
-		pnpmBuildDependency: (pkg) => {
-			pnpmBuildDependencies.push(pkg);
-		}
-	};
-	const cancels = [];
-	await addon.run({
-		cancel: (reason) => {
-			cancels.push(reason);
-		},
-		...workspace,
-		options: options$7,
-		sv
-	});
-	if (cancels.length === 0) {
-		const pkgPath = installPackages(dependencies, workspace);
-		files.add(pkgPath);
-	}
-	return {
-		files: Array.from(files),
-		pnpmBuildDependencies,
-		cancels
-	};
-}
-function orderAddons(addons, setupResults) {
-	return addons.sort((a, b) => {
-		return setupResults[a.id]?.runsAfter?.length - setupResults[b.id]?.runsAfter?.length;
-	});
-}
-
-//#endregion
-//#region lib/addons/devtools-json/index.ts
-var devtools_json_default = defineAddon({
-	id: "devtools-json",
-	shortDescription: "devtools json",
-	homepage: "https://github.com/ChromeDevTools/vite-plugin-devtools-json",
-	options: {},
-	run: ({ sv, files }) => {
-		sv.devDependency("vite-plugin-devtools-json", "^1.0.0");
-		sv.file(files.viteConfig, (content) => {
-			const { ast, generateCode } = parseScript(content);
-			const vitePluginName = "devtoolsJson";
-			addDefault(ast, {
-				as: vitePluginName,
-				from: "vite-plugin-devtools-json"
-			});
-			addPlugin(ast, { code: `${vitePluginName}()` });
-			return generateCode();
-		});
-	}
-});
-
-//#endregion
-//#region lib/addons/common.ts
-function addEslintConfigPrettier(content) {
-	const { ast, generateCode } = parseScript(content);
-	const sveltePluginImport = ast.body.filter((n) => n.type === "ImportDeclaration").find((n) => n.type === "ImportDeclaration" && n.source.value === "eslint-plugin-svelte" && n.specifiers?.some((n$1) => n$1.type === "ImportDefaultSpecifier"));
-	let svelteImportName;
-	for (const specifier of sveltePluginImport?.specifiers ?? []) if (specifier.type === "ImportDefaultSpecifier" && specifier.local?.name) svelteImportName = specifier.local.name;
-	svelteImportName ??= "svelte";
-	addDefault(ast, {
-		from: "eslint-plugin-svelte",
-		as: svelteImportName
-	});
-	addDefault(ast, {
-		from: "eslint-config-prettier",
-		as: "prettier"
-	});
-	const fallbackConfig = parseExpression("[]");
-	const eslintConfig = createDefault(ast, { fallback: fallbackConfig }).value;
-	if (eslintConfig.type !== "ArrayExpression" && eslintConfig.type !== "CallExpression") return content;
-	const prettier = parseExpression("prettier");
-	const sveltePrettierConfig = parseExpression(`${svelteImportName}.configs.prettier`);
-	const configSpread = createSpread(sveltePrettierConfig);
-	const nodesToInsert = [];
-	if (!contains(eslintConfig, prettier)) nodesToInsert.push(prettier);
-	if (!contains(eslintConfig, configSpread)) nodesToInsert.push(configSpread);
-	const elements = eslintConfig.type === "ArrayExpression" ? eslintConfig.elements : eslintConfig.arguments;
-	const idx = elements.findIndex((el) => el?.type === "SpreadElement" && el.argument.type === "MemberExpression" && el.argument.object.type === "MemberExpression" && el.argument.object.property.type === "Identifier" && el.argument.object.property.name === "configs" && el.argument.object.object.type === "Identifier" && el.argument.object.object.name === svelteImportName);
-	if (idx !== -1) elements.splice(idx + 1, 0, ...nodesToInsert);
-	else elements.push(...nodesToInsert);
-	return generateCode();
-}
-function addToDemoPage(existingContent, path$1, langTs) {
-	const { ast, generateCode } = parseSvelte(existingContent);
-	for (const node of ast.fragment.nodes) if (node.type === "RegularElement") {
-		const hrefAttribute = node.attributes.find((x) => x.type === "Attribute" && x.name === "href");
-		if (!hrefAttribute || !hrefAttribute.value) continue;
-		if (!Array.isArray(hrefAttribute.value)) continue;
-		if (hrefAttribute.value.some((x) => x.type === "Text" && x.data.includes(`/demo/${path$1}`))) return existingContent;
-	}
-	addNamed(ensureScript(ast, { langTs }), {
-		imports: ["resolve"],
-		from: "$app/paths"
-	});
-	ast.fragment.nodes.unshift(...toFragment(`<a href={resolve('/demo/${path$1}')}>${path$1}</a>`));
-	ast.fragment.nodes.unshift();
-	return generateCode();
-}
-/**
-* Returns the corresponding `@types/node` version for the version of Node.js running in the current process.
-*
-* If the installed version of Node.js is from a `Current` release, then the major is decremented to
-* the nearest `LTS` release version.
-*/
-function getNodeTypesVersion() {
-	const nodeVersion = process.versions.node;
-	const isDenoOrBun = Boolean(process.versions.deno ?? process.versions.bun);
-	const [major] = nodeVersion.split(".");
-	const majorNum = Number(major);
-	const isEvenMajor = majorNum % 2 === 0;
-	if (!!process.release.lts || isDenoOrBun && isEvenMajor) return `^${major}`;
-	return `^${isEvenMajor ? majorNum - 2 : majorNum - 1}`;
-}
-
-//#endregion
-//#region lib/addons/drizzle/index.ts
-const PORTS = {
-	mysql: "3306",
-	postgresql: "5432",
-	sqlite: ""
-};
-const options$6 = defineAddonOptions().add("database", {
-	question: "Which database would you like to use?",
-	type: "select",
-	default: "sqlite",
-	options: [
-		{
-			value: "postgresql",
-			label: "PostgreSQL"
-		},
-		{
-			value: "mysql",
-			label: "MySQL"
-		},
-		{
-			value: "sqlite",
-			label: "SQLite"
-		}
-	]
-}).add("postgresql", {
-	question: "Which PostgreSQL client would you like to use?",
-	type: "select",
-	group: "client",
-	default: "postgres.js",
-	options: [{
-		value: "postgres.js",
-		label: "Postgres.JS",
-		hint: "recommended for most users"
-	}, {
-		value: "neon",
-		label: "Neon",
-		hint: "popular hosted platform"
-	}],
-	condition: ({ database }) => database === "postgresql"
-}).add("mysql", {
-	question: "Which MySQL client would you like to use?",
-	type: "select",
-	group: "client",
-	default: "mysql2",
-	options: [{
-		value: "mysql2",
-		hint: "recommended for most users"
-	}, {
-		value: "planetscale",
-		label: "PlanetScale",
-		hint: "popular hosted platform"
-	}],
-	condition: ({ database }) => database === "mysql"
-}).add("sqlite", {
-	question: "Which SQLite client would you like to use?",
-	type: "select",
-	group: "client",
-	default: "libsql",
-	options: [
-		{
-			value: "better-sqlite3",
-			hint: "for traditional Node environments"
-		},
-		{
-			value: "libsql",
-			label: "libSQL",
-			hint: "for serverless environments"
-		},
-		{
-			value: "turso",
-			label: "Turso",
-			hint: "popular hosted platform"
-		}
-	],
-	condition: ({ database }) => database === "sqlite"
-}).add("docker", {
-	question: "Do you want to run the database locally with docker-compose?",
-	default: false,
-	type: "boolean",
-	condition: ({ database, mysql, postgresql }) => database === "mysql" && mysql === "mysql2" || database === "postgresql" && postgresql === "postgres.js"
-}).build();
-var drizzle_default = defineAddon({
-	id: "drizzle",
-	shortDescription: "database orm",
-	homepage: "https://orm.drizzle.team",
-	options: options$6,
-	setup: ({ kit, unsupported, runsAfter }) => {
-		runsAfter("prettier");
-		if (!kit) return unsupported("Requires SvelteKit");
-	},
-	run: ({ sv, typescript, options: options$7, kit, dependencyVersion, cwd: cwd$1, cancel, files }) => {
-		if (!kit) throw new Error("SvelteKit is required");
-		const ext = typescript ? "ts" : "js";
-		const baseDBPath = path.resolve(cwd$1, kit.libDirectory, "server", "db");
-		const paths = {
-			"drizzle config": path.resolve(cwd$1, `drizzle.config.${ext}`),
-			"database schema": path.resolve(baseDBPath, `schema.${ext}`),
-			database: path.resolve(baseDBPath, `index.${ext}`)
-		};
-		for (const [fileType, filePath] of Object.entries(paths)) if (fs.existsSync(filePath)) return cancel(`Preexisting ${fileType} file at '${filePath}'`);
-		sv.devDependency("drizzle-orm", "^0.45.0");
-		sv.devDependency("drizzle-kit", "^0.31.8");
-		sv.devDependency("@types/node", getNodeTypesVersion());
-		if (options$7.mysql === "mysql2") sv.dependency("mysql2", "^3.15.3");
-		if (options$7.mysql === "planetscale") sv.dependency("@planetscale/database", "^1.19.0");
-		if (options$7.postgresql === "neon") sv.dependency("@neondatabase/serverless", "^1.0.2");
-		if (options$7.postgresql === "postgres.js") sv.dependency("postgres", "^3.4.7");
-		if (options$7.sqlite === "better-sqlite3") {
-			sv.dependency("better-sqlite3", "^12.5.0");
-			sv.devDependency("@types/better-sqlite3", "^7.6.13");
-			sv.pnpmBuildDependency("better-sqlite3");
-		}
-		if (options$7.sqlite === "libsql" || options$7.sqlite === "turso") sv.devDependency("@libsql/client", "^0.15.15");
-		sv.file(".env", (content) => generateEnvFileContent(content, options$7));
-		sv.file(".env.example", (content) => generateEnvFileContent(content, options$7));
-		if (options$7.docker && (options$7.mysql === "mysql2" || options$7.postgresql === "postgres.js")) {
-			const composeFileOptions = [
-				"docker-compose.yml",
-				"docker-compose.yaml",
-				"compose.yaml"
-			];
-			let composeFile = "";
-			for (const option of composeFileOptions) {
-				composeFile = option;
-				if (fs.existsSync(path.resolve(cwd$1, option))) break;
-			}
-			if (composeFile === "") throw new Error("unreachable state...");
-			sv.file(composeFile, (content) => {
-				if (content.length > 0) return content;
-				const imageName = options$7.database === "mysql" ? "mysql" : "postgres";
-				const port = PORTS[options$7.database];
-				const USER = "root";
-				const PASSWORD = "mysecretpassword";
-				const DB_NAME = "local";
-				let dbSpecificContent = "";
-				if (options$7.mysql === "mysql2") dbSpecificContent = `
-                      MYSQL_ROOT_PASSWORD: ${PASSWORD}
-                      MYSQL_DATABASE: ${DB_NAME}
-                    volumes:
-                      - mysqldata:/var/lib/mysql
-                volumes:
-                  mysqldata:
-                `;
-				if (options$7.postgresql === "postgres.js") dbSpecificContent = `
-                      POSTGRES_USER: ${USER}
-                      POSTGRES_PASSWORD: ${PASSWORD}
-                      POSTGRES_DB: ${DB_NAME}
-                    volumes:
-                      - pgdata:/var/lib/postgresql
-                volumes:
-                  pgdata:
-                `;
-				content = dedent_default`
-                services:
-                  db:
-                    image: ${imageName}
-                    restart: always
-                    ports:
-                      - ${port}:${port}
-                    environment: ${dbSpecificContent}
-                `;
-				return content;
-			});
-		}
-		sv.file(files.package, (content) => {
-			const { data, generateCode } = parseJson(content);
-			data.scripts ??= {};
-			const scripts = data.scripts;
-			if (options$7.docker) scripts["db:start"] ??= "docker compose up";
-			scripts["db:push"] ??= "drizzle-kit push";
-			scripts["db:generate"] ??= "drizzle-kit generate";
-			scripts["db:migrate"] ??= "drizzle-kit migrate";
-			scripts["db:studio"] ??= "drizzle-kit studio";
-			return generateCode();
-		});
-		if (Boolean(dependencyVersion("prettier"))) sv.file(files.prettierignore, (content) => {
-			if (!content.includes(`/drizzle/`)) return content.trimEnd() + "\n/drizzle/";
-			return content;
-		});
-		if (options$7.database === "sqlite") sv.file(files.gitignore, (content) => {
-			if (content.length === 0) return content;
-			if (!content.includes("\n*.db")) content = content.trimEnd() + "\n\n# SQLite\n*.db";
-			return content;
-		});
-		sv.file(paths["drizzle config"], (content) => {
-			const { ast, generateCode } = parseScript(content);
-			addNamed(ast, {
-				from: "drizzle-kit",
-				imports: { defineConfig: "defineConfig" }
-			});
-			ast.body.push(parseStatement("if (!process.env.DATABASE_URL) throw new Error('DATABASE_URL is not set');"));
-			createDefault(ast, { fallback: parseExpression(`
-					defineConfig({
-						schema: "./src/lib/server/db/schema.${typescript ? "ts" : "js"}",
-						dialect: "${options$7.sqlite === "turso" ? "turso" : options$7.database}",
-						dbCredentials: {
-							${options$7.sqlite === "turso" ? "authToken: process.env.DATABASE_AUTH_TOKEN," : ""}
-							url: process.env.DATABASE_URL
-						},
-						verbose: true,
-						strict: true
-					})`) });
-			return generateCode();
-		});
-		sv.file(paths["database schema"], (content) => {
-			const { ast, generateCode } = parseScript(content);
-			let userSchemaExpression;
-			if (options$7.database === "sqlite") {
-				addNamed(ast, {
-					from: "drizzle-orm/sqlite-core",
-					imports: [
-						"integer",
-						"sqliteTable",
-						"text"
-					]
-				});
-				userSchemaExpression = parseExpression(`sqliteTable('user', {
-					id: text('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
-					age: integer('age')
-				})`);
-			}
-			if (options$7.database === "mysql") {
-				addNamed(ast, {
-					from: "drizzle-orm/mysql-core",
-					imports: [
-						"mysqlTable",
-						"serial",
-						"int"
-					]
-				});
-				userSchemaExpression = parseExpression(`mysqlTable('user', {
-					id: serial('id').primaryKey(),
-					age: int('age'),
-				})`);
-			}
-			if (options$7.database === "postgresql") {
-				addNamed(ast, {
-					from: "drizzle-orm/pg-core",
-					imports: [
-						"pgTable",
-						"serial",
-						"integer"
-					]
-				});
-				userSchemaExpression = parseExpression(`pgTable('user', {
-					id: serial('id').primaryKey(),
-					age: integer('age'),
-				})`);
-			}
-			if (!userSchemaExpression) throw new Error("unreachable state...");
-			const userIdentifier = declaration(ast, {
-				kind: "const",
-				name: "user",
-				value: userSchemaExpression
-			});
-			createNamed(ast, {
-				name: "user",
-				fallback: userIdentifier
-			});
-			return generateCode();
-		});
-		sv.file(paths["database"], (content) => {
-			const { ast, generateCode } = parseScript(content);
-			addNamed(ast, {
-				from: "$env/dynamic/private",
-				imports: ["env"]
-			});
-			addNamespace(ast, {
-				from: "./schema",
-				as: "schema"
-			});
-			const dbURLCheck = parseStatement("if (!env.DATABASE_URL) throw new Error('DATABASE_URL is not set');");
-			ast.body.push(dbURLCheck);
-			let clientExpression;
-			if (options$7.sqlite === "better-sqlite3") {
-				addDefault(ast, {
-					from: "better-sqlite3",
-					as: "Database"
-				});
-				addNamed(ast, {
-					from: "drizzle-orm/better-sqlite3",
-					imports: ["drizzle"]
-				});
-				clientExpression = parseExpression("new Database(env.DATABASE_URL)");
-			}
-			if (options$7.sqlite === "libsql" || options$7.sqlite === "turso") {
-				addNamed(ast, {
-					from: "@libsql/client",
-					imports: ["createClient"]
-				});
-				addNamed(ast, {
-					from: "drizzle-orm/libsql",
-					imports: ["drizzle"]
-				});
-				if (options$7.sqlite === "turso") {
-					addNamed(ast, {
-						from: "$app/environment",
-						imports: ["dev"]
-					});
-					const authTokenCheck = parseStatement("if (!dev && !env.DATABASE_AUTH_TOKEN) throw new Error('DATABASE_AUTH_TOKEN is not set');");
-					ast.body.push(authTokenCheck);
-					clientExpression = parseExpression("createClient({ url: env.DATABASE_URL, authToken: env.DATABASE_AUTH_TOKEN })");
-				} else clientExpression = parseExpression("createClient({ url: env.DATABASE_URL })");
-			}
-			if (options$7.mysql === "mysql2" || options$7.mysql === "planetscale") {
-				addDefault(ast, {
-					from: "mysql2/promise",
-					as: "mysql"
-				});
-				addNamed(ast, {
-					from: "drizzle-orm/mysql2",
-					imports: ["drizzle"]
-				});
-				clientExpression = parseExpression("mysql.createPool(env.DATABASE_URL)");
-			}
-			if (options$7.postgresql === "neon") {
-				addNamed(ast, {
-					from: "@neondatabase/serverless",
-					imports: ["neon"]
-				});
-				addNamed(ast, {
-					from: "drizzle-orm/neon-http",
-					imports: ["drizzle"]
-				});
-				clientExpression = parseExpression("neon(env.DATABASE_URL)");
-			}
-			if (options$7.postgresql === "postgres.js") {
-				addDefault(ast, {
-					from: "postgres",
-					as: "postgres"
-				});
-				addNamed(ast, {
-					from: "drizzle-orm/postgres-js",
-					imports: ["drizzle"]
-				});
-				clientExpression = parseExpression("postgres(env.DATABASE_URL)");
-			}
-			if (!clientExpression) throw new Error("unreachable state...");
-			ast.body.push(declaration(ast, {
-				kind: "const",
-				name: "client",
-				value: clientExpression
-			}));
-			const drizzleCall = createCall({
-				name: "drizzle",
-				args: ["client"],
-				useIdentifiers: true
-			});
-			const paramObject = create({ schema: createIdentifier("schema") });
-			if (options$7.database === "mysql") {
-				const mode = options$7.mysql === "planetscale" ? "planetscale" : "default";
-				property(paramObject, {
-					name: "mode",
-					fallback: createLiteral(mode)
-				});
-			}
-			drizzleCall.arguments.push(paramObject);
-			const db = declaration(ast, {
-				kind: "const",
-				name: "db",
-				value: drizzleCall
-			});
-			createNamed(ast, {
-				name: "db",
-				fallback: db
-			});
-			return generateCode();
-		});
-	},
-	nextSteps: ({ options: options$7, highlighter, packageManager }) => {
-		const steps = [`You will need to set ${highlighter.env("DATABASE_URL")} in your production environment`];
-		if (options$7.docker) {
-			const { command: command$1, args: args$1 } = resolveCommand(packageManager, "run", ["db:start"]);
-			steps.push(`Run ${highlighter.command(`${command$1} ${args$1.join(" ")}`)} to start the docker container`);
-		} else steps.push(`Check ${highlighter.env("DATABASE_URL")} in ${highlighter.path(".env")} and adjust it to your needs`);
-		const { command, args } = resolveCommand(packageManager, "run", ["db:push"]);
-		steps.push(`Run ${highlighter.command(`${command} ${args.join(" ")}`)} to update your database schema`);
-		return steps;
-	}
-});
-function generateEnvFileContent(content, opts) {
-	const DB_URL_KEY = "DATABASE_URL";
-	if (opts.docker) {
-		const protocol = opts.database === "mysql" ? "mysql" : "postgres";
-		const port = PORTS[opts.database];
-		content = addEnvVar(content, DB_URL_KEY, `"${protocol}://root:mysecretpassword@localhost:${port}/local"`);
-		return content;
-	}
-	if (opts.sqlite === "better-sqlite3" || opts.sqlite === "libsql") {
-		const dbFile = opts.sqlite === "libsql" ? "file:local.db" : "local.db";
-		content = addEnvVar(content, DB_URL_KEY, dbFile);
-		return content;
-	}
-	content = addEnvComment(content, "Replace with your DB credentials!");
-	if (opts.sqlite === "turso") {
-		content = addEnvVar(content, DB_URL_KEY, "\"libsql://db-name-user.turso.io\"");
-		content = addEnvVar(content, "DATABASE_AUTH_TOKEN", "\"\"");
-		content = addEnvComment(content, "A local DB can also be used in dev as well");
-		content = addEnvComment(content, `${DB_URL_KEY}="file:local.db"`);
-	}
-	if (opts.database === "mysql") content = addEnvVar(content, DB_URL_KEY, "\"mysql://user:password@host:port/db-name\"");
-	if (opts.database === "postgresql") content = addEnvVar(content, DB_URL_KEY, "\"postgres://user:password@host:port/db-name\"");
-	return content;
-}
-function addEnvVar(content, key, value) {
-	if (!content.includes(key + "=")) content = appendEnvContent(content, `${key}=${value}`);
-	return content;
-}
-function addEnvComment(content, comment) {
-	const commented = `# ${comment}`;
-	if (!content.includes(commented)) content = appendEnvContent(content, commented);
-	return content;
-}
-function appendEnvContent(existing, content) {
-	return (!existing.length || existing.endsWith("\n") ? existing : existing + "\n") + content + "\n";
-}
-
-//#endregion
-//#region lib/addons/eslint/index.ts
-var eslint_default = defineAddon({
-	id: "eslint",
-	shortDescription: "linter",
-	homepage: "https://eslint.org",
-	options: {},
-	run: ({ sv, typescript, dependencyVersion, files }) => {
-		const prettierInstalled = Boolean(dependencyVersion("prettier"));
-		sv.devDependency("eslint", "^9.39.1");
-		sv.devDependency("@eslint/compat", "^1.4.0");
-		sv.devDependency("eslint-plugin-svelte", "^3.13.1");
-		sv.devDependency("globals", "^16.5.0");
-		sv.devDependency("@eslint/js", "^9.39.1");
-		sv.devDependency("@types/node", getNodeTypesVersion());
-		if (typescript) sv.devDependency("typescript-eslint", "^8.48.1");
-		if (prettierInstalled) sv.devDependency("eslint-config-prettier", "^10.1.8");
-		sv.file(files.package, (content) => {
-			const { data, generateCode } = parseJson(content);
-			data.scripts ??= {};
-			const scripts = data.scripts;
-			const LINT_CMD = "eslint .";
-			scripts["lint"] ??= LINT_CMD;
-			if (!scripts["lint"].includes(LINT_CMD)) scripts["lint"] += ` && ${LINT_CMD}`;
-			return generateCode();
-		});
-		sv.file(files.vscodeSettings, (content) => {
-			if (!content) return content;
-			const { data, generateCode } = parseJson(content);
-			const validate = data["eslint.validate"];
-			if (validate && !validate.includes("svelte")) validate.push("svelte");
-			return generateCode();
-		});
-		sv.file(files.eslintConfig, (content) => {
-			const { ast, comments, generateCode } = parseScript(content);
-			const eslintConfigs = [];
-			addDefault(ast, {
-				from: "./svelte.config.js",
-				as: "svelteConfig"
-			});
-			const gitIgnorePathStatement = parseStatement("\nconst gitignorePath = fileURLToPath(new URL('./.gitignore', import.meta.url));");
-			appendStatement(ast, { statement: gitIgnorePathStatement });
-			const ignoresConfig = parseExpression("includeIgnoreFile(gitignorePath)");
-			eslintConfigs.push(ignoresConfig);
-			const jsConfig = parseExpression("js.configs.recommended");
-			eslintConfigs.push(jsConfig);
-			if (typescript) {
-				const tsConfig = parseExpression("ts.configs.recommended");
-				eslintConfigs.push(createSpread(tsConfig));
-			}
-			const svelteConfig = parseExpression("svelte.configs.recommended");
-			eslintConfigs.push(createSpread(svelteConfig));
-			const globalsBrowser = createSpread(parseExpression("globals.browser"));
-			const globalsNode = createSpread(parseExpression("globals.node"));
-			const globalsObjLiteral = create({});
-			globalsObjLiteral.properties = [globalsBrowser, globalsNode];
-			const rules = create({ "\"no-undef\"": "off" });
-			if (rules.properties[0].type !== "Property") throw new Error("rules.properties[0].type !== \"Property\"");
-			comments.add(rules.properties[0].key, {
-				type: "Line",
-				value: " typescript-eslint strongly recommend that you do not use the no-undef lint rule on TypeScript projects."
-			});
-			comments.add(rules.properties[0].key, {
-				type: "Line",
-				value: " see: https://typescript-eslint.io/troubleshooting/faqs/eslint/#i-get-errors-from-the-no-undef-rule-about-global-variables-not-being-defined-even-though-there-are-no-typescript-errors"
-			});
-			const globalsConfig = create({
-				languageOptions: { globals: globalsObjLiteral },
-				rules: typescript ? rules : void 0
-			});
-			eslintConfigs.push(globalsConfig);
-			if (typescript) {
-				const svelteTSParserConfig = create({
-					files: [
-						"**/*.svelte",
-						"**/*.svelte.ts",
-						"**/*.svelte.js"
-					],
-					languageOptions: { parserOptions: {
-						projectService: true,
-						extraFileExtensions: [".svelte"],
-						parser: createIdentifier("ts.parser"),
-						svelteConfig: createIdentifier("svelteConfig")
-					} }
-				});
-				eslintConfigs.push(svelteTSParserConfig);
-			} else {
-				const svelteTSParserConfig = create({
-					files: ["**/*.svelte", "**/*.svelte.js"],
-					languageOptions: { parserOptions: { svelteConfig: createIdentifier("svelteConfig") } }
-				});
-				eslintConfigs.push(svelteTSParserConfig);
-			}
-			let exportExpression;
-			if (typescript) {
-				const tsConfigCall = createCall({
-					name: "defineConfig",
-					args: []
-				});
-				tsConfigCall.arguments.push(...eslintConfigs);
-				exportExpression = tsConfigCall;
-			} else {
-				const eslintArray = create$1();
-				eslintConfigs.map((x) => append(eslintArray, x));
-				exportExpression = eslintArray;
-			}
-			const { value: defaultExport, astNode } = createDefault(ast, { fallback: exportExpression });
-			if (defaultExport !== exportExpression) {
-				T.warn("An eslint config is already defined. Skipping initialization.");
-				return content;
-			}
-			if (!typescript) addJsDocTypeComment(astNode, comments, { type: "import('eslint').Linter.Config[]" });
-			if (typescript) addDefault(ast, {
-				from: "typescript-eslint",
-				as: "ts"
-			});
-			addDefault(ast, {
-				from: "globals",
-				as: "globals"
-			});
-			if (typescript) addNamed(ast, {
-				from: "eslint/config",
-				imports: ["defineConfig"]
-			});
-			addDefault(ast, {
-				from: "eslint-plugin-svelte",
-				as: "svelte"
-			});
-			addDefault(ast, {
-				from: "@eslint/js",
-				as: "js"
-			});
-			addNamed(ast, {
-				from: "@eslint/compat",
-				imports: ["includeIgnoreFile"]
-			});
-			addNamed(ast, {
-				from: "node:url",
-				imports: ["fileURLToPath"]
-			});
-			return generateCode();
-		});
-		if (prettierInstalled) sv.file(files.eslintConfig, addEslintConfigPrettier);
-	}
-});
-
-//#endregion
-//#region lib/addons/lucia/index.ts
-const TABLE_TYPE = {
-	mysql: "mysqlTable",
-	postgresql: "pgTable",
-	sqlite: "sqliteTable",
-	turso: "sqliteTable"
-};
-let drizzleDialect;
-let schemaPath;
-const options$5 = defineAddonOptions().add("demo", {
-	type: "boolean",
-	default: true,
-	question: `Do you want to include a demo? ${import_picocolors$1.default.dim("(includes a login/register page)")}`
-}).build();
-var lucia_default = defineAddon({
-	id: "lucia",
-	shortDescription: "auth guide",
-	homepage: "https://lucia-auth.com",
-	options: options$5,
-	setup: ({ kit, dependencyVersion, unsupported, dependsOn, runsAfter }) => {
-		if (!kit) unsupported("Requires SvelteKit");
-		if (!dependencyVersion("drizzle-orm")) dependsOn("drizzle");
-		runsAfter("tailwindcss");
-	},
-	run: ({ sv, typescript, options: options$7, kit, dependencyVersion }) => {
-		const ext = typescript ? "ts" : "js";
-		sv.devDependency("@oslojs/crypto", "^1.0.1");
-		sv.devDependency("@oslojs/encoding", "^1.1.0");
-		if (options$7.demo) sv.dependency("@node-rs/argon2", "^2.0.2");
-		sv.file(`drizzle.config.${ext}`, (content) => {
-			const { ast, generateCode } = parseScript(content);
-			const isProp = (name, node) => node.key.type === "Identifier" && node.key.name === name;
-			walk(ast, null, { Property(node) {
-				if (isProp("dialect", node) && node.value.type === "Literal" && typeof node.value.value === "string") drizzleDialect = node.value.value;
-				if (isProp("schema", node) && node.value.type === "Literal" && typeof node.value.value === "string") schemaPath = node.value.value;
-			} });
-			if (!drizzleDialect) throw new Error("Failed to detect DB dialect in your `drizzle.config.[js|ts]` file");
-			if (!schemaPath) throw new Error("Failed to find schema path in your `drizzle.config.[js|ts]` file");
-			return generateCode();
-		});
-		sv.file(schemaPath, (content) => {
-			const { ast, generateCode } = parseScript(content);
-			const createTable = (name) => createCall({
-				name: TABLE_TYPE[drizzleDialect],
-				args: [name]
-			});
-			const userDecl = declaration(ast, {
-				kind: "const",
-				name: "user",
-				value: createTable("user")
-			});
-			const sessionDecl = declaration(ast, {
-				kind: "const",
-				name: "session",
-				value: createTable("session")
-			});
-			const user = createNamed(ast, {
-				name: "user",
-				fallback: userDecl
-			});
-			const session = createNamed(ast, {
-				name: "session",
-				fallback: sessionDecl
-			});
-			const userTable = getCallExpression(user);
-			const sessionTable = getCallExpression(session);
-			if (!userTable || !sessionTable) throw new Error("failed to find call expression of `user` or `session`");
-			if (userTable.arguments.length === 1) userTable.arguments.push(create({}));
-			if (sessionTable.arguments.length === 1) sessionTable.arguments.push(create({}));
-			const userAttributes = userTable.arguments[1];
-			const sessionAttributes = sessionTable.arguments[1];
-			if (userAttributes?.type !== "ObjectExpression" || sessionAttributes?.type !== "ObjectExpression") throw new Error("unexpected shape of `user` or `session` table definition");
-			if (drizzleDialect === "sqlite" || drizzleDialect === "turso") {
-				addNamed(ast, {
-					from: "drizzle-orm/sqlite-core",
-					imports: [
-						"sqliteTable",
-						"text",
-						"integer"
-					]
-				});
-				overrideProperties(userAttributes, { id: parseExpression("text('id').primaryKey()") });
-				if (options$7.demo) overrideProperties(userAttributes, {
-					username: parseExpression("text('username').notNull().unique()"),
-					passwordHash: parseExpression("text('password_hash').notNull()")
-				});
-				overrideProperties(sessionAttributes, {
-					id: parseExpression("text('id').primaryKey()"),
-					userId: parseExpression("text('user_id').notNull().references(() => user.id)"),
-					expiresAt: parseExpression("integer('expires_at', { mode: 'timestamp' }).notNull()")
-				});
-			}
-			if (drizzleDialect === "mysql") {
-				addNamed(ast, {
-					from: "drizzle-orm/mysql-core",
-					imports: [
-						"mysqlTable",
-						"varchar",
-						"datetime"
-					]
-				});
-				overrideProperties(userAttributes, { id: parseExpression("varchar('id', { length: 255 }).primaryKey()") });
-				if (options$7.demo) overrideProperties(userAttributes, {
-					username: parseExpression("varchar('username', { length: 32 }).notNull().unique()"),
-					passwordHash: parseExpression("varchar('password_hash', { length: 255 }).notNull()")
-				});
-				overrideProperties(sessionAttributes, {
-					id: parseExpression("varchar('id', { length: 255 }).primaryKey()"),
-					userId: parseExpression("varchar('user_id', { length: 255 }).notNull().references(() => user.id)"),
-					expiresAt: parseExpression("datetime('expires_at').notNull()")
-				});
-			}
-			if (drizzleDialect === "postgresql") {
-				addNamed(ast, {
-					from: "drizzle-orm/pg-core",
-					imports: [
-						"pgTable",
-						"text",
-						"timestamp"
-					]
-				});
-				overrideProperties(userAttributes, { id: parseExpression("text('id').primaryKey()") });
-				if (options$7.demo) overrideProperties(userAttributes, {
-					username: parseExpression("text('username').notNull().unique()"),
-					passwordHash: parseExpression("text('password_hash').notNull()")
-				});
-				overrideProperties(sessionAttributes, {
-					id: parseExpression("text('id').primaryKey()"),
-					userId: parseExpression("text('user_id').notNull().references(() => user.id)"),
-					expiresAt: parseExpression("timestamp('expires_at', { withTimezone: true, mode: 'date' }).notNull()")
-				});
-			}
-			let code = generateCode();
-			if (typescript) {
-				if (!code.includes("export type Session =")) code += "\n\nexport type Session = typeof session.$inferSelect;";
-				if (!code.includes("export type User =")) code += "\n\nexport type User = typeof user.$inferSelect;";
-			}
-			return code;
-		});
-		sv.file(`${kit?.libDirectory}/server/auth.${ext}`, (content) => {
-			const { ast, generateCode } = parseScript(content);
-			addNamespace(ast, {
-				from: "$lib/server/db/schema",
-				as: "table"
-			});
-			addNamed(ast, {
-				from: "$lib/server/db",
-				imports: ["db"]
-			});
-			addNamed(ast, {
-				from: "@oslojs/encoding",
-				imports: ["encodeBase64url", "encodeHexLowerCase"]
-			});
-			addNamed(ast, {
-				from: "@oslojs/crypto/sha2",
-				imports: ["sha256"]
-			});
-			addNamed(ast, {
-				from: "drizzle-orm",
-				imports: ["eq"]
-			});
-			if (typescript) addNamed(ast, {
-				from: "@sveltejs/kit",
-				imports: ["RequestEvent"],
-				isType: true
-			});
-			const ms = new MagicString(generateCode().trim());
-			const [ts] = createPrinter(typescript);
-			if (!ms.original.includes("const DAY_IN_MS")) ms.append("\n\nconst DAY_IN_MS = 1000 * 60 * 60 * 24;");
-			if (!ms.original.includes("export const sessionCookieName")) ms.append("\n\nexport const sessionCookieName = 'auth-session';");
-			if (!ms.original.includes("export function generateSessionToken")) {
-				const generateSessionToken = dedent_default`					
-					export function generateSessionToken() {
-						const bytes = crypto.getRandomValues(new Uint8Array(18));
-						const token = encodeBase64url(bytes);
-						return token;
-					}`;
-				ms.append(`\n\n${generateSessionToken}`);
-			}
-			if (!ms.original.includes("async function createSession")) {
-				const createSession = dedent_default`
-					${ts("", "/**")}
-					${ts("", " * @param {string} token")}
-					${ts("", " * @param {string} userId")}
-					${ts("", " */")}
-					export async function createSession(token${ts(": string")}, userId${ts(": string")}) {
-						const sessionId = encodeHexLowerCase(sha256(new TextEncoder().encode(token)));
-						const session${ts(": table.Session")} = {
-							id: sessionId,
-							userId,
-							expiresAt: new Date(Date.now() + DAY_IN_MS * 30)
-						};
-						await db.insert(table.session).values(session);
-						return session;
-					}`;
-				ms.append(`\n\n${createSession}`);
-			}
-			if (!ms.original.includes("async function validateSessionToken")) {
-				const validateSessionToken = dedent_default`					
-					${ts("", "/** @param {string} token */")}
-					export async function validateSessionToken(token${ts(": string")}) {
-						const sessionId = encodeHexLowerCase(sha256(new TextEncoder().encode(token)));
-						const [result] = await db
-							.select({
-								// Adjust user table here to tweak returned data
-								user: { id: table.user.id, username: table.user.username },
-								session: table.session
-							})
-							.from(table.session)
-							.innerJoin(table.user, eq(table.session.userId, table.user.id))
-							.where(eq(table.session.id, sessionId));
-
-						if (!result) {
-							return { session: null, user: null };
-						}
-						const { session, user } = result;
-
-						const sessionExpired = Date.now() >= session.expiresAt.getTime();
-						if (sessionExpired) {
-							await db.delete(table.session).where(eq(table.session.id, session.id));
-							return { session: null, user: null };
-						}
-
-						const renewSession = Date.now() >= session.expiresAt.getTime() - DAY_IN_MS * 15;
-						if (renewSession) {
-							session.expiresAt = new Date(Date.now() + DAY_IN_MS * 30);
-							await db
-								.update(table.session)
-								.set({ expiresAt: session.expiresAt })
-								.where(eq(table.session.id, session.id));
-						}
-
-						return { session, user };
-					}`;
-				ms.append(`\n\n${validateSessionToken}`);
-			}
-			if (typescript && !ms.original.includes("export type SessionValidationResult")) ms.append(`\n\nexport type SessionValidationResult = Awaited<ReturnType<typeof validateSessionToken>>;`);
-			if (!ms.original.includes("async function invalidateSession")) {
-				const invalidateSession = dedent_default`					
-					${ts("", "/** @param {string} sessionId */")}
-					export async function invalidateSession(sessionId${ts(": string")}) {
-						await db.delete(table.session).where(eq(table.session.id, sessionId));
-					}`;
-				ms.append(`\n\n${invalidateSession}`);
-			}
-			if (!ms.original.includes("export function setSessionTokenCookie")) {
-				const setSessionTokenCookie = dedent_default`					
-					${ts("", "/**")}
-					${ts("", " * @param {import(\"@sveltejs/kit\").RequestEvent} event")}
-					${ts("", " * @param {string} token")}
-					${ts("", " * @param {Date} expiresAt")}
-					${ts("", " */")}
-					export function setSessionTokenCookie(event${ts(": RequestEvent")}, token${ts(": string")}, expiresAt${ts(": Date")}) {
-						event.cookies.set(sessionCookieName, token, {
-							expires: expiresAt,
-							path: '/'
-						});
-					}`;
-				ms.append(`\n\n${setSessionTokenCookie}`);
-			}
-			if (!ms.original.includes("export function deleteSessionTokenCookie")) {
-				const deleteSessionTokenCookie = dedent_default`					
-					${ts("", "/** @param {import(\"@sveltejs/kit\").RequestEvent} event */")}
-					export function deleteSessionTokenCookie(event${ts(": RequestEvent")}) {
-						event.cookies.delete(sessionCookieName, {
-							path: '/'
-						});
-					}`;
-				ms.append(`\n\n${deleteSessionTokenCookie}`);
-			}
-			return ms.toString();
-		});
-		if (typescript) sv.file("src/app.d.ts", (content) => {
-			const { ast, generateCode } = parseScript(content);
-			const locals = addGlobalAppInterface(ast, { name: "Locals" });
-			if (!locals) throw new Error("Failed detecting `locals` interface in `src/app.d.ts`");
-			const user = locals.body.body.find((prop) => hasTypeProperty(prop, { name: "user" }));
-			const session = locals.body.body.find((prop) => hasTypeProperty(prop, { name: "session" }));
-			if (!user) locals.body.body.push(createLuciaType("user"));
-			if (!session) locals.body.body.push(createLuciaType("session"));
-			return generateCode();
-		});
-		sv.file(`src/hooks.server.${ext}`, (content) => {
-			const { ast, generateCode } = parseScript(content);
-			addNamespace(ast, {
-				from: "$lib/server/auth",
-				as: "auth"
-			});
-			addHooksHandle(ast, {
-				typescript,
-				newHandleName: "handleAuth",
-				handleContent: getAuthHandleContent()
-			});
-			return generateCode();
-		});
-		if (options$7.demo) {
-			sv.file(`${kit?.routesDirectory}/demo/+page.svelte`, (content) => {
-				return addToDemoPage(content, "lucia", typescript);
-			});
-			sv.file(`${kit.routesDirectory}/demo/lucia/login/+page.server.${ext}`, (content) => {
-				if (content) {
-					const filePath = `${kit.routesDirectory}/demo/lucia/login/+page.server.${typescript ? "ts" : "js"}`;
-					T.warn(`Existing ${import_picocolors$1.default.yellow(filePath)} file. Could not update.`);
-					return content;
-				}
-				const [ts] = createPrinter(typescript);
-				return dedent_default`
-					import { hash, verify } from '@node-rs/argon2';
-					import { encodeBase32LowerCase } from '@oslojs/encoding';
-					import { fail, redirect } from '@sveltejs/kit';
-					import { eq } from 'drizzle-orm';
-					import * as auth from '$lib/server/auth';
-					import { db } from '$lib/server/db';
-					import * as table from '$lib/server/db/schema';
-					${ts("import type { Actions, PageServerLoad } from './$types';\n")}
-					export const load${ts(": PageServerLoad")} = async (event) => {
-						if (event.locals.user) {
-							return redirect(302, '/demo/lucia');
-						}
-						return {};
-					};
-
-					export const actions${ts(": Actions")} = {
-						login: async (event) => {
-							const formData = await event.request.formData();
-							const username = formData.get('username');
-							const password = formData.get('password');
-
-							if (!validateUsername(username)) {
-								return fail(400, { message: 'Invalid username (min 3, max 31 characters, alphanumeric only)' });
-							}
-							if (!validatePassword(password)) {
-								return fail(400, { message: 'Invalid password (min 6, max 255 characters)' });
-							}
-
-							const results = await db
-								.select()
-								.from(table.user)
-								.where(eq(table.user.username, username));
-
-							const existingUser = results.at(0);
-							if (!existingUser) {
-								return fail(400, { message: 'Incorrect username or password' });
-							}
-
-							const validPassword = await verify(existingUser.passwordHash, password, {
-								memoryCost: 19456,
-								timeCost: 2,
-								outputLen: 32,
-								parallelism: 1,
-							});
-							if (!validPassword) {
-								return fail(400, { message: 'Incorrect username or password' });
-							}
-
-							const sessionToken = auth.generateSessionToken();
-							const session = await auth.createSession(sessionToken, existingUser.id);
-							auth.setSessionTokenCookie(event, sessionToken, session.expiresAt);
-
-							return redirect(302, '/demo/lucia');
-						},
-						register: async (event) => {
-							const formData = await event.request.formData();
-							const username = formData.get('username');
-							const password = formData.get('password');
-
-							if (!validateUsername(username)) {
-								return fail(400, { message: 'Invalid username' });
-							}
-							if (!validatePassword(password)) {
-								return fail(400, { message: 'Invalid password' });
-							}
-
-							const userId = generateUserId();
-							const passwordHash = await hash(password, {
-								// recommended minimum parameters
-								memoryCost: 19456,
-								timeCost: 2,
-								outputLen: 32,
-								parallelism: 1,
-							});
-
-							try {
-								await db.insert(table.user).values({ id: userId, username, passwordHash });
-
-								const sessionToken = auth.generateSessionToken();
-								const session = await auth.createSession(sessionToken, userId);
-								auth.setSessionTokenCookie(event, sessionToken, session.expiresAt);
-							} catch {
-								return fail(500, { message: 'An error has occurred' });
-							}
-							return redirect(302, '/demo/lucia');
-						},
-					};
-
-					function generateUserId() {
-						// ID with 120 bits of entropy, or about the same as UUID v4.
-						const bytes = crypto.getRandomValues(new Uint8Array(15));
-						const id = encodeBase32LowerCase(bytes);
-						return id;
-					}
-
-					function validateUsername(username${ts(": unknown")})${ts(": username is string")} {
-						return (
-							typeof username === 'string' &&
-							username.length >= 3 &&
-							username.length <= 31 &&
-							/^[a-z0-9_-]+$/.test(username)
-						);
-					}
-
-					function validatePassword(password${ts(": unknown")})${ts(": password is string")} {
-						return (
-							typeof password === 'string' &&
-							password.length >= 6 &&
-							password.length <= 255
-						);
-					}
-				`;
-			});
-			sv.file(`${kit.routesDirectory}/demo/lucia/login/+page.svelte`, (content) => {
-				if (content) {
-					const filePath = `${kit.routesDirectory}/demo/lucia/login/+page.svelte`;
-					T.warn(`Existing ${import_picocolors$1.default.yellow(filePath)} file. Could not update.`);
-					return content;
-				}
-				const tailwind = dependencyVersion("@tailwindcss/vite") !== void 0;
-				const twInputClasses = "class=\"mt-1 px-3 py-2 bg-white border border-gray-300 rounded-md shadow-sm focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500\"";
-				const twBtnClasses = "class=\"bg-blue-600 text-white px-4 py-2 rounded-md hover:bg-blue-700 transition\"";
-				const svelte5 = !!dependencyVersion("svelte")?.startsWith("5");
-				const [ts, s5] = createPrinter(typescript, svelte5);
-				return dedent_default`
-					<script ${ts("lang='ts'")}>
-						import { enhance } from '$app/forms';
-						${ts("import type { ActionData } from './$types';\n")}
-						${s5(`let { form }${ts(": { form: ActionData }")} = $props();`, `export let form${ts(": ActionData")};`)}
-					<\/script>
-
-					<h1>Login/Register</h1>
-					<form method="post" action="?/login" use:enhance>
-						<label>
-							Username
-							<input
-								name="username"
-								${tailwind ? twInputClasses : ""}
-							/>
-						</label>
-						<label>
-							Password
-							<input
-								type="password"
-								name="password"
-								${tailwind ? twInputClasses : ""}
-							/>
-						</label>
-						<button ${tailwind ? twBtnClasses : ""}
-							>Login</button>
-						<button
-							formaction="?/register"
-							${tailwind ? twBtnClasses : ""}
-							>Register</button>
-					</form>
-					<p style='color: red'>{form?.message ?? ''}</p>
-				`;
-			});
-			sv.file(`${kit.routesDirectory}/demo/lucia/+page.server.${ext}`, (content) => {
-				if (content) {
-					const filePath = `${kit.routesDirectory}/demo/lucia/+page.server.${typescript ? "ts" : "js"}`;
-					T.warn(`Existing ${import_picocolors$1.default.yellow(filePath)} file. Could not update.`);
-					return content;
-				}
-				const [ts] = createPrinter(typescript);
-				return dedent_default`
-					import * as auth from '$lib/server/auth';
-					import { fail, redirect } from '@sveltejs/kit';
-					import { getRequestEvent } from '$app/server';
-					${ts("import type { Actions, PageServerLoad } from './$types';\n")}
-					export const load${ts(": PageServerLoad")} = async () => {
-						const user = requireLogin()
-						return { user };
-					};
-
-					export const actions${ts(": Actions")} = {
-						logout: async (event) => {
-							if (!event.locals.session) {
-								return fail(401);
-							}
-							await auth.invalidateSession(event.locals.session.id);
-							auth.deleteSessionTokenCookie(event);
-
-							return redirect(302, '/demo/lucia/login');
-						},
-					};
-
-					function requireLogin() {
-					  const { locals } = getRequestEvent();
-
-					  if (!locals.user) {
-					    return redirect(302, "/demo/lucia/login");
-					  }
-
-					  return locals.user;
-					}
-				`;
-			});
-			sv.file(`${kit.routesDirectory}/demo/lucia/+page.svelte`, (content) => {
-				if (content) {
-					const filePath = `${kit.routesDirectory}/demo/lucia/+page.svelte`;
-					T.warn(`Existing ${import_picocolors$1.default.yellow(filePath)} file. Could not update.`);
-					return content;
-				}
-				const svelte5 = !!dependencyVersion("svelte")?.startsWith("5");
-				const [ts, s5] = createPrinter(typescript, svelte5);
-				return dedent_default`
-					<script ${ts("lang='ts'")}>
-						import { enhance } from '$app/forms';
-						${ts("import type { PageServerData } from './$types';\n")}
-						${s5(`let { data }${ts(": { data: PageServerData }")} = $props();`, `export let data${ts(": PageServerData")};`)}
-					<\/script>
-
-					<h1>Hi, {data.user.username}!</h1>
-					<p>Your user ID is {data.user.id}.</p>
-					<form method='post' action='?/logout' use:enhance>
-						<button>Sign out</button>
-					</form>
-				`;
-			});
-		}
-	},
-	nextSteps: ({ highlighter, options: options$7, packageManager }) => {
-		const { command, args } = resolveCommand(packageManager, "run", ["db:push"]);
-		const steps = [`Run ${highlighter.command(`${command} ${args.join(" ")}`)} to update your database schema`];
-		if (options$7.demo) steps.push(`Visit ${highlighter.route("/demo/lucia")} route to view the demo`);
-		return steps;
-	}
-});
-function createLuciaType(name) {
-	return {
-		type: "TSPropertySignature",
-		key: {
-			type: "Identifier",
-			name
-		},
-		computed: false,
-		typeAnnotation: {
-			type: "TSTypeAnnotation",
-			typeAnnotation: {
-				type: "TSIndexedAccessType",
-				objectType: {
-					type: "TSImportType",
-					argument: {
-						type: "Literal",
-						value: "$lib/server/auth"
-					},
-					qualifier: {
-						type: "Identifier",
-						name: "SessionValidationResult"
-					}
-				},
-				indexType: {
-					type: "TSLiteralType",
-					literal: {
-						type: "Literal",
-						value: name
-					}
-				}
-			}
-		}
-	};
-}
-function getAuthHandleContent() {
-	return `
-		async ({ event, resolve }) => {
-			const sessionToken = event.cookies.get(auth.sessionCookieName);
-			if (!sessionToken) {
-				event.locals.user = null;
-				event.locals.session = null;
-				return resolve(event);
-			}
-
-			const { session, user } = await auth.validateSessionToken(sessionToken);
-			if (session) {
-				auth.setSessionTokenCookie(event, sessionToken, session.expiresAt);
-			} else {
-				auth.deleteSessionTokenCookie(event);
-			}
-
-			event.locals.user = user;
-			event.locals.session = session;
-
-			return resolve(event);
-		};`;
-}
-function getCallExpression(ast) {
-	let callExpression;
-	walk(ast, null, { CallExpression(node) {
-		callExpression ??= node;
-	} });
-	return callExpression;
-}
-
-//#endregion
-//#region lib/addons/mdsvex/index.ts
-var mdsvex_default = defineAddon({
-	id: "mdsvex",
-	shortDescription: "svelte + markdown",
-	homepage: "https://mdsvex.pngwn.io",
-	options: {},
-	run: ({ sv, files }) => {
-		sv.devDependency("mdsvex", "^0.12.6");
-		sv.file(files.svelteConfig, (content) => {
-			const { ast, generateCode } = parseScript(content);
-			addNamed(ast, {
-				from: "mdsvex",
-				imports: ["mdsvex"]
-			});
-			const { value: exportDefault } = createDefault(ast, { fallback: create({}) });
-			let preprocessorArray = property(exportDefault, {
-				name: "preprocess",
-				fallback: create$1()
-			});
-			if (!(preprocessorArray.type === "ArrayExpression")) {
-				const previousElement = preprocessorArray;
-				preprocessorArray = create$1();
-				append(preprocessorArray, previousElement);
-				overrideProperties(exportDefault, { preprocess: preprocessorArray });
-			}
-			const mdsvexCall = createCall({
-				name: "mdsvex",
-				args: []
-			});
-			append(preprocessorArray, mdsvexCall);
-			const extensionsArray = property(exportDefault, {
-				name: "extensions",
-				fallback: create$1()
-			});
-			append(extensionsArray, ".svelte");
-			append(extensionsArray, ".svx");
-			return generateCode();
-		});
-	}
-});
-
-//#endregion
-//#region lib/core/tooling/html/index.ts
-function addAttribute(element, name, value) {
-	let existing = element.attributes.find((attr) => attr.type === "Attribute" && attr.name === name);
-	if (!existing) {
-		existing = {
-			type: "Attribute",
-			name,
-			value: [],
-			start: 0,
-			end: 0,
-			name_loc: {
-				start: {
-					column: 0,
-					line: 0
-				},
-				end: {
-					column: 0,
-					line: 0
-				}
-			}
-		};
-		element.attributes.push(existing);
-	}
-	existing.value = [{
-		type: "Text",
-		data: value,
-		raw: value,
-		start: 0,
-		end: 0
-	}];
-}
-
-//#endregion
-//#region lib/addons/paraglide/index.ts
-const DEFAULT_INLANG_PROJECT = {
-	$schema: "https://inlang.com/schema/project-settings",
-	modules: ["https://cdn.jsdelivr.net/npm/@inlang/plugin-message-format@4/dist/index.js", "https://cdn.jsdelivr.net/npm/@inlang/plugin-m-function-matcher@2/dist/index.js"],
-	"plugin.inlang.messageFormat": { pathPattern: "./messages/{locale}.json" }
-};
-const options$4 = defineAddonOptions().add("languageTags", {
-	question: `Which languages would you like to support? ${import_picocolors$1.default.gray("(e.g. en,de-ch)")}`,
-	type: "string",
-	default: "en, es",
-	validate(input) {
-		if (!input) return;
-		const { invalidLanguageTags, validLanguageTags } = parseLanguageTagInput(input);
-		if (invalidLanguageTags.length > 0) if (invalidLanguageTags.length === 1) return `The input "${invalidLanguageTags[0]}" is not a valid IETF BCP 47 language tag`;
-		else return `The inputs ${new Intl.ListFormat("en", {
-			style: "long",
-			type: "conjunction"
-		}).format(invalidLanguageTags.map((x) => `"${x}"`))} are not valid BCP47 language tags`;
-		if (validLanguageTags.length === 0) return "Please enter at least one valid BCP47 language tag. Eg: en";
-	}
-}).add("demo", {
-	type: "boolean",
-	default: true,
-	question: "Do you want to include a demo?"
-}).build();
-var paraglide_default = defineAddon({
-	id: "paraglide",
-	shortDescription: "i18n",
-	homepage: "https://inlang.com/m/gerre34r/library-inlang-paraglideJs",
-	options: options$4,
-	setup: ({ kit, unsupported }) => {
-		if (!kit) unsupported("Requires SvelteKit");
-	},
-	run: ({ sv, options: options$7, files, typescript, kit }) => {
-		const ext = typescript ? "ts" : "js";
-		if (!kit) throw new Error("SvelteKit is required");
-		const paraglideOutDir = "src/lib/paraglide";
-		sv.devDependency("@inlang/paraglide-js", "^2.6.0");
-		sv.file(files.viteConfig, (content) => {
-			const { ast, generateCode } = parseScript(content);
-			const vitePluginName = "paraglideVitePlugin";
-			addNamed(ast, {
-				imports: [vitePluginName],
-				from: "@inlang/paraglide-js"
-			});
-			addPlugin(ast, { code: `${vitePluginName}({ 
-					project: './project.inlang', 
-					outdir: './${paraglideOutDir}' 
-				})` });
-			return generateCode();
-		});
-		sv.file(`src/hooks.${ext}`, (content) => {
-			const { ast, generateCode } = parseScript(content);
-			addNamed(ast, {
-				from: "$lib/paraglide/runtime",
-				imports: ["deLocalizeUrl"]
-			});
-			const expression = parseExpression("(request) => deLocalizeUrl(request.url).pathname");
-			const rerouteIdentifier = declaration(ast, {
-				kind: "const",
-				name: "reroute",
-				value: expression
-			});
-			if (createNamed(ast, {
-				name: "reroute",
-				fallback: rerouteIdentifier
-			}).declaration !== rerouteIdentifier) T.warn("Adding the reroute hook automatically failed. Add it manually");
-			return generateCode();
-		});
-		sv.file(`src/hooks.server.${ext}`, (content) => {
-			const { ast, generateCode } = parseScript(content);
-			addNamed(ast, {
-				from: "$lib/paraglide/server",
-				imports: ["paraglideMiddleware"]
-			});
-			addHooksHandle(ast, {
-				typescript,
-				newHandleName: "handleParaglide",
-				handleContent: `({ event, resolve }) => paraglideMiddleware(event.request, ({ request, locale }) => {
-		event.request = request;
-		return resolve(event, {
-			transformPageChunk: ({ html }) => html.replace('%paraglide.lang%', locale)
-		});
-	});`
-			});
-			return generateCode();
-		});
-		sv.file("src/app.html", (content) => {
-			const { ast, generateCode } = parseHtml(content);
-			const htmlNode = ast.nodes.find((child) => child.type === "RegularElement" && child.name === "html");
-			if (!htmlNode) {
-				T.warn("Could not find <html> node in app.html. You'll need to add the language placeholder manually");
-				return generateCode();
-			}
-			addAttribute(htmlNode, "lang", "%paraglide.lang%");
-			return generateCode();
-		});
-		sv.file(files.gitignore, (content) => {
-			if (!content) return content;
-			if (!content.includes(`\n${paraglideOutDir}`)) content = content.trimEnd() + `\n\n# Paraglide\n${paraglideOutDir}\nproject.inlang/cache/`;
-			return content;
-		});
-		sv.file("project.inlang/settings.json", (content) => {
-			if (content) return content;
-			const { data, generateCode } = parseJson(content);
-			for (const key in DEFAULT_INLANG_PROJECT) data[key] = DEFAULT_INLANG_PROJECT[key];
-			const { validLanguageTags: validLanguageTags$1 } = parseLanguageTagInput(options$7.languageTags);
-			data.baseLocale = validLanguageTags$1[0];
-			data.locales = validLanguageTags$1;
-			return generateCode();
-		});
-		sv.file(`${kit.routesDirectory}/+layout.svelte`, (content) => {
-			const { ast, generateCode } = parseSvelte(content);
-			const scriptAst = ensureScript(ast);
-			addNamed(scriptAst, {
-				imports: ["locales", "localizeHref"],
-				from: "$lib/paraglide/runtime"
-			});
-			addNamed(scriptAst, {
-				imports: ["page"],
-				from: "$app/state"
-			});
-			ast.fragment.nodes.push(...toFragment(`<div style="display:none">
-	{#each locales as locale}
-		<a href={localizeHref(page.url.pathname, { locale })}>{locale}</a>
-	{/each}
-</div>`));
-			return generateCode();
-		});
-		if (options$7.demo) {
-			sv.file(`${kit.routesDirectory}/demo/+page.svelte`, (content) => {
-				return addToDemoPage(content, "paraglide", typescript);
-			});
-			sv.file(`${kit.routesDirectory}/demo/paraglide/+page.svelte`, (content) => {
-				const { ast, generateCode } = parseSvelte(content);
-				const scriptAst = ensureScript(ast, { langTs: typescript });
-				addNamed(scriptAst, {
-					imports: { m: "m" },
-					from: "$lib/paraglide/messages.js"
-				});
-				addNamed(scriptAst, {
-					imports: { setLocale: "setLocale" },
-					from: "$lib/paraglide/runtime"
-				});
-				let templateCode = "<h1>{m.hello_world({ name: 'SvelteKit User' })}</h1>";
-				const { validLanguageTags: validLanguageTags$1 } = parseLanguageTagInput(options$7.languageTags);
-				const links = validLanguageTags$1.map((x) => `<button onclick={() => setLocale('${x}')}>${x}</button>`).join("");
-				templateCode += `<div>${links}</div>`;
-				templateCode += "<p>If you use VSCode, install the <a href=\"https://marketplace.visualstudio.com/items?itemName=inlang.vs-code-extension\" target=\"_blank\">Sherlock i18n extension</a> for a better i18n experience.</p>";
-				ast.fragment.nodes.push(...toFragment(templateCode));
-				return generateCode();
-			});
-		}
-		const { validLanguageTags } = parseLanguageTagInput(options$7.languageTags);
-		for (const languageTag of validLanguageTags) sv.file(`messages/${languageTag}.json`, (content) => {
-			const { data, generateCode } = parseJson(content);
-			data["$schema"] = "https://inlang.com/schema/inlang-message-format";
-			data.hello_world = `Hello, {name} from ${languageTag}!`;
-			return generateCode();
-		});
-	},
-	nextSteps: ({ highlighter }) => {
-		const steps = [`Edit your messages in ${highlighter.path("messages/en.json")}`];
-		if (options$4.demo) steps.push(`Visit ${highlighter.route("/demo/paraglide")} route to view the demo`);
-		return steps;
-	}
-});
-const isValidLanguageTag = (languageTag) => RegExp("^((?<grandfathered>(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)|(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang))|((?<language>([A-Za-z]{2,3}(-(?<extlang>[A-Za-z]{3}(-[A-Za-z]{3}){0,2}))?))(-(?<script>[A-Za-z]{4}))?(-(?<region>[A-Za-z]{2}|[0-9]{3}))?(-(?<variant>[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*))$").test(languageTag);
-function parseLanguageTagInput(input) {
-	const probablyLanguageTags = input.replace(/[,:\s]/g, " ").split(" ").filter(Boolean).map((tag) => tag.toLowerCase());
-	const validLanguageTags = [];
-	const invalidLanguageTags = [];
-	for (const tag of probablyLanguageTags) if (isValidLanguageTag(tag)) validLanguageTags.push(tag);
-	else invalidLanguageTags.push(tag);
-	return {
-		validLanguageTags,
-		invalidLanguageTags
-	};
-}
-
-//#endregion
-//#region lib/addons/mcp/index.ts
-const options$3 = defineAddonOptions().add("ide", {
-	question: "Which client would you like to use?",
-	type: "multiselect",
-	default: [],
-	options: [
-		{
-			value: "claude-code",
-			label: "claude code"
-		},
-		{
-			value: "cursor",
-			label: "Cursor"
-		},
-		{
-			value: "gemini",
-			label: "Gemini"
-		},
-		{
-			value: "opencode",
-			label: "opencode"
-		},
-		{
-			value: "vscode",
-			label: "VSCode"
-		},
-		{
-			value: "other",
-			label: "Other"
-		}
-	],
-	required: true
-}).add("setup", {
-	question: "What setup would you like to use?",
-	type: "select",
-	default: "remote",
-	options: [{
-		value: "local",
-		label: "Local",
-		hint: "will use stdio"
-	}, {
-		value: "remote",
-		label: "Remote",
-		hint: "will use a remote endpoint"
-	}],
-	required: true
-}).build();
-var mcp_default = defineAddon({
-	id: "mcp",
-	shortDescription: "Svelte MCP",
-	homepage: "https://svelte.dev/docs/mcp",
-	options: options$3,
-	run: ({ sv, options: options$7 }) => {
-		const getLocalConfig = (o) => {
-			return {
-				...o?.type ? { type: o.type } : {},
-				command: o?.command ?? "npx",
-				...o?.env ? { env: {} } : {},
-				...o?.args === null ? {} : { args: o?.args ?? ["-y", "@sveltejs/mcp"] }
-			};
-		};
-		const getRemoteConfig = (o) => {
-			return {
-				...o?.type ? { type: o.type } : {},
-				url: "https://mcp.svelte.dev/mcp"
-			};
-		};
-		const configurator = {
-			"claude-code": {
-				agentPath: "CLAUDE.md",
-				mcpPath: ".mcp.json",
-				typeLocal: "stdio",
-				typeRemote: "http",
-				env: true
-			},
-			cursor: {
-				agentPath: "AGENTS.md",
-				mcpPath: ".cursor/mcp.json"
-			},
-			gemini: {
-				agentPath: "GEMINI.md",
-				schema: "https://raw.githubusercontent.com/google-gemini/gemini-cli/main/schemas/settings.schema.json",
-				mcpPath: ".gemini/settings.json"
-			},
-			opencode: {
-				agentPath: "AGENTS.md",
-				schema: "https://opencode.ai/config.json",
-				mcpServersKey: "mcp",
-				mcpPath: "opencode.json",
-				typeLocal: "local",
-				typeRemote: "remote",
-				command: [
-					"npx",
-					"-y",
-					"@sveltejs/mcp"
-				],
-				args: null
-			},
-			vscode: {
-				agentPath: "AGENTS.md",
-				mcpServersKey: "servers",
-				mcpPath: ".vscode/mcp.json"
-			},
-			other: { other: true }
-		};
-		const filesAdded = [];
-		const filesExistingAlready = [];
-		const agentFile = getSharedFiles().filter((file) => file.include.includes("mcp")).find((file) => file.name === "AGENTS.md");
-		for (const ide of options$7.ide) {
-			const value = configurator[ide];
-			if (value === void 0) continue;
-			if ("other" in value) continue;
-			const { mcpServersKey, agentPath, mcpPath, typeLocal, typeRemote, env, schema, command, args } = value;
-			if (!filesAdded.includes(agentPath)) sv.file(agentPath, (content) => {
-				if (content) {
-					filesExistingAlready.push(agentPath);
-					return content;
-				}
-				filesAdded.push(agentPath);
-				return agentFile?.contents ?? "";
-			});
-			sv.file(mcpPath, (content) => {
-				const { data, generateCode } = parseJson(content);
-				if (schema) data["$schema"] = schema;
-				const key = mcpServersKey ?? "mcpServers";
-				data[key] ??= {};
-				data[key].svelte = options$7.setup === "local" ? getLocalConfig({
-					type: typeLocal,
-					env,
-					command,
-					args
-				}) : getRemoteConfig({ type: typeRemote });
-				return generateCode();
-			});
-		}
-		if (filesExistingAlready.length > 0) {
-			const highlighter = getHighlighter();
-			T.warn(`${filesExistingAlready.map((path$1) => highlighter.path(path$1)).join(", ")} already exists, we didn't touch ${filesExistingAlready.length > 1 ? "them" : "it"}. See ${highlighter.website("https://svelte.dev/docs/mcp/overview#Usage")} for manual setup.`);
-		}
-	},
-	nextSteps({ highlighter, options: options$7 }) {
-		const steps = [];
-		if (options$7.ide.includes("other")) steps.push(`For other clients: ${highlighter.website(`https://svelte.dev/docs/mcp/${options$7.setup}-setup#Other-clients`)}`);
-		return steps;
-	}
-});
-
-//#endregion
-//#region lib/addons/playwright/index.ts
-var playwright_default = defineAddon({
-	id: "playwright",
-	shortDescription: "browser testing",
-	homepage: "https://playwright.dev",
-	options: {},
-	run: ({ sv, typescript, files }) => {
-		const ext = typescript ? "ts" : "js";
-		sv.devDependency("@playwright/test", "^1.57.0");
-		sv.file(files.package, (content) => {
-			const { data, generateCode } = parseJson(content);
-			data.scripts ??= {};
-			const scripts = data.scripts;
-			const TEST_CMD = "playwright test";
-			const RUN_TEST = "npm run test:e2e";
-			scripts["test:e2e"] ??= TEST_CMD;
-			scripts["test"] ??= RUN_TEST;
-			if (!scripts["test"].includes(RUN_TEST)) scripts["test"] += ` && ${RUN_TEST}`;
-			return generateCode();
-		});
-		sv.file(files.gitignore, (content) => {
-			if (!content) return content;
-			if (content.includes("test-results")) return content;
-			return "test-results\n" + content.trim();
-		});
-		sv.file(`e2e/demo.test.${ext}`, (content) => {
-			if (content) return content;
-			return dedent_default`
-				import { expect, test } from '@playwright/test';
-
-				test('home page has expected h1', async ({ page }) => {
-					await page.goto('/');
-					await expect(page.locator('h1')).toBeVisible();
-				});
-				`;
-		});
-		sv.file(`playwright.config.${ext}`, (content) => {
-			const { ast, generateCode } = parseScript(content);
-			const defineConfig = parseExpression("defineConfig({})");
-			const { value: defaultExport } = createDefault(ast, { fallback: defineConfig });
-			const config = {
-				webServer: {
-					command: "npm run build && npm run preview",
-					port: 4173
-				},
-				testDir: "e2e"
-			};
-			if (defaultExport.type === "CallExpression" && defaultExport.arguments[0]?.type === "ObjectExpression") {
-				addNamed(ast, {
-					imports: ["defineConfig"],
-					from: "@playwright/test"
-				});
-				overrideProperties(defaultExport.arguments[0], config);
-			} else if (defaultExport.type === "ObjectExpression") overrideProperties(defaultExport, config);
-			else T.warn("Unexpected playwright config for playwright add-on. Could not update.");
-			return generateCode();
-		});
-	}
-});
-
-//#endregion
-//#region lib/addons/prettier/index.ts
-var prettier_default = defineAddon({
-	id: "prettier",
-	shortDescription: "formatter",
-	homepage: "https://prettier.io",
-	options: {},
-	run: ({ sv, dependencyVersion, files }) => {
-		const tailwindcssInstalled = Boolean(dependencyVersion("tailwindcss"));
-		if (tailwindcssInstalled) sv.devDependency("prettier-plugin-tailwindcss", "^0.7.2");
-		sv.devDependency("prettier", "^3.7.4");
-		sv.devDependency("prettier-plugin-svelte", "^3.4.0");
-		sv.file(files.prettierignore, (content) => {
-			if (content) return content;
-			return dedent_default`
-				# Package Managers
-				package-lock.json
-				pnpm-lock.yaml
-				yarn.lock
-				bun.lock
-				bun.lockb
-
-				# Miscellaneous
-				/static/
-			`;
-		});
-		sv.file(files.prettierrc, (content) => {
-			let data, generateCode;
-			try {
-				({data, generateCode} = parseJson(content));
-			} catch {
-				T.warn(`A ${import_picocolors$1.default.yellow(".prettierrc")} config already exists and cannot be parsed as JSON. Skipping initialization.`);
-				return content;
-			}
-			if (Object.keys(data).length === 0) {
-				data.useTabs = true;
-				data.singleQuote = true;
-				data.trailingComma = "none";
-				data.printWidth = 100;
-			}
-			data.plugins ??= [];
-			const plugins$1 = data.plugins;
-			{
-				const PLUGIN_NAME = "prettier-plugin-svelte";
-				if (!plugins$1.includes(PLUGIN_NAME)) plugins$1.push(PLUGIN_NAME);
-			}
-			if (tailwindcssInstalled) {
-				const PLUGIN_NAME = "prettier-plugin-tailwindcss";
-				if (!plugins$1.includes(PLUGIN_NAME)) plugins$1.push(PLUGIN_NAME);
-				data.tailwindStylesheet ??= files.getRelative({ to: files.stylesheet });
-			}
-			data.overrides ??= [];
-			const overrides = data.overrides;
-			if (!overrides.find((o) => o?.options?.parser === "svelte")) overrides.push({
-				files: "*.svelte",
-				options: { parser: "svelte" }
-			});
-			return generateCode();
-		});
-		const eslintVersion = dependencyVersion("eslint");
-		const eslintInstalled = hasEslint(eslintVersion);
-		sv.file(files.package, (content) => {
-			const { data, generateCode } = parseJson(content);
-			data.scripts ??= {};
-			const scripts = data.scripts;
-			const CHECK_CMD = "prettier --check .";
-			scripts["format"] ??= "prettier --write .";
-			if (eslintInstalled) {
-				scripts["lint"] ??= `${CHECK_CMD} && eslint .`;
-				if (!scripts["lint"].includes(CHECK_CMD)) scripts["lint"] += ` && ${CHECK_CMD}`;
-			} else scripts["lint"] ??= CHECK_CMD;
-			return generateCode();
-		});
-		if (eslintVersion?.startsWith(SUPPORTED_ESLINT_VERSION) === false) T.warn(`An older major version of ${import_picocolors$1.default.yellow("eslint")} was detected. Skipping ${import_picocolors$1.default.yellow("eslint-config-prettier")} installation.`);
-		if (eslintInstalled) {
-			sv.devDependency("eslint-config-prettier", "^10.1.8");
-			sv.file(files.eslintConfig, addEslintConfigPrettier);
-		}
-	}
-});
-const SUPPORTED_ESLINT_VERSION = "9";
-function hasEslint(version) {
-	return !!version && version.startsWith(SUPPORTED_ESLINT_VERSION);
-}
-
-//#endregion
-//#region lib/addons/storybook/index.ts
-var storybook_default = defineAddon({
-	id: "storybook",
-	shortDescription: "frontend workshop",
-	homepage: "https://storybook.js.org",
-	options: {},
-	setup: ({ runsAfter }) => {
-		runsAfter("vitest");
-		runsAfter("eslint");
-	},
-	run: async ({ sv }) => {
-		const args = [
-			`create-storybook@latest`,
-			"--skip-install",
-			"--no-dev"
-		];
-		if (process.env.NODE_ENV?.toLowerCase() === "test") args.push(...["--no-features", "--yes"]);
-		await sv.execute(args, "inherit");
-		sv.devDependency(`@types/node`, getNodeTypesVersion());
-	}
-});
-
-//#endregion
-//#region lib/addons/sveltekit-adapter/index.ts
-const adapters = [
-	{
-		id: "auto",
-		package: "@sveltejs/adapter-auto",
-		version: "^7.0.0"
-	},
-	{
-		id: "node",
-		package: "@sveltejs/adapter-node",
-		version: "^5.4.0"
-	},
-	{
-		id: "static",
-		package: "@sveltejs/adapter-static",
-		version: "^3.0.10"
-	},
-	{
-		id: "vercel",
-		package: "@sveltejs/adapter-vercel",
-		version: "^6.2.0"
-	},
-	{
-		id: "cloudflare",
-		package: "@sveltejs/adapter-cloudflare",
-		version: "^7.2.4"
-	},
-	{
-		id: "netlify",
-		package: "@sveltejs/adapter-netlify",
-		version: "^5.2.4"
-	}
-];
-const options$2 = defineAddonOptions().add("adapter", {
-	type: "select",
-	question: "Which SvelteKit adapter would you like to use?",
-	default: "auto",
-	options: adapters.map((p) => ({
-		value: p.id,
-		label: p.id,
-		hint: p.package
-	}))
-}).add("cfTarget", {
-	condition: (options$7) => options$7.adapter === "cloudflare",
-	type: "select",
-	question: "Are you deploying to Workers (assets) or Pages?",
-	default: "workers",
-	options: [{
-		value: "workers",
-		label: "Workers",
-		hint: "Recommended way to deploy to Cloudflare"
-	}, {
-		value: "pages",
-		label: "Pages"
-	}]
-}).build();
-var sveltekit_adapter_default = defineAddon({
-	id: "sveltekit-adapter",
-	alias: "adapter",
-	shortDescription: "deployment",
-	homepage: "https://svelte.dev/docs/kit/adapters",
-	options: options$2,
-	setup: ({ kit, unsupported }) => {
-		if (!kit) unsupported("Requires SvelteKit");
-	},
-	run: ({ sv, options: options$7, files, cwd: cwd$1, packageManager, typescript }) => {
-		const adapter = adapters.find((a) => a.id === options$7.adapter);
-		sv.file(files.package, (content) => {
-			const { data, generateCode } = parseJson(content);
-			const devDeps = data["devDependencies"];
-			for (const pkg of Object.keys(devDeps)) if (pkg.startsWith("@sveltejs/adapter-")) delete devDeps[pkg];
-			if (options$7.adapter === "cloudflare") {
-				if (options$7.cfTarget === "workers") data.scripts.preview = "wrangler dev .svelte-kit/cloudflare/_worker.js --port 4173";
-				else if (options$7.cfTarget === "pages") data.scripts.preview = "wrangler pages dev .svelte-kit/cloudflare --port 4173";
-			}
-			return generateCode();
-		});
-		sv.devDependency(adapter.package, adapter.version);
-		sv.file(files.svelteConfig, (content) => {
-			const { ast, comments, generateCode } = parseScript(content);
-			const adapterImportDecl = ast.body.filter((n) => n.type === "ImportDeclaration").find((importDecl) => typeof importDecl.source.value === "string" && importDecl.source.value.startsWith("@sveltejs/adapter-") && importDecl.importKind === "value");
-			let adapterName = "adapter";
-			if (adapterImportDecl) {
-				adapterImportDecl.source.value = adapter.package;
-				adapterImportDecl.source.raw = void 0;
-				adapterName = adapterImportDecl.specifiers?.find((s) => s.type === "ImportDefaultSpecifier")?.local?.name;
-			} else addDefault(ast, {
-				from: adapter.package,
-				as: adapterName
-			});
-			const { value: config } = createDefault(ast, { fallback: create({}) });
-			overrideProperties(config, { kit: { adapter: createCall({
-				name: adapterName,
-				args: [],
-				useIdentifiers: true
-			}) } });
-			if (adapter.package !== "@sveltejs/adapter-auto") {
-				const fallback = create({});
-				const cfgKitValue = property(config, {
-					name: "kit",
-					fallback
-				});
-				comments.remove((c) => c.loc && cfgKitValue.loc && c.loc.start.line >= cfgKitValue.loc.start.line && c.loc.end.line <= cfgKitValue.loc.end.line);
-			}
-			return generateCode();
-		});
-		if (adapter.package === "@sveltejs/adapter-cloudflare") {
-			sv.devDependency("wrangler", "^4.56.0");
-			const configFormat = fileExists(cwd$1, "wrangler.toml") ? "toml" : "jsonc";
-			sv.file(`wrangler.${configFormat}`, (content) => {
-				const { data, generateCode } = configFormat === "jsonc" ? parseJson(content) : parseToml(content);
-				if (configFormat === "jsonc") data.$schema ??= "./node_modules/wrangler/config-schema.json";
-				if (!data.name) data.name = sanitizeName(parseJson(readFile(cwd$1, files.package)).data.name, "wrangler");
-				data.compatibility_date ??= (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-				data.compatibility_flags ??= [];
-				if (!data.compatibility_flags.includes("nodejs_compat") && !data.compatibility_flags.includes("nodejs_als")) data.compatibility_flags.push("nodejs_als");
-				switch (options$7.cfTarget) {
-					case "workers":
-						data.main = ".svelte-kit/cloudflare/_worker.js";
-						data.assets ??= {};
-						data.assets.binding = "ASSETS";
-						data.assets.directory = ".svelte-kit/cloudflare";
-						data.workers_dev = true;
-						data.preview_urls = true;
-						break;
-					case "pages":
-						data.pages_build_output_dir = ".svelte-kit/cloudflare";
-						break;
-				}
-				return generateCode();
-			});
-			const jsconfig = fileExists(cwd$1, "jsconfig.json");
-			if (typescript || jsconfig) {
-				sv.file(files.gitignore, (content) => {
-					return content.includes(".wrangler") && content.includes("worker-configuration.d.ts") ? content : `${content.trimEnd()}\n\n# Cloudflare Types\n/worker-configuration.d.ts`;
-				});
-				sv.file(files.package, (content) => {
-					const { data, generateCode } = parseJson(content);
-					data.scripts ??= {};
-					data.scripts.types = "wrangler types";
-					const { command, args } = resolveCommand(packageManager, "run", ["types"]);
-					data.scripts.prepare = data.scripts.prepare ? `${command} ${args.join(" ")} && ${data.scripts.prepare}` : `${command} ${args.join(" ")}`;
-					return generateCode();
-				});
-				sv.file(`${jsconfig ? "jsconfig" : "tsconfig"}.json`, (content) => {
-					const { data, generateCode } = parseJson(content);
-					data.compilerOptions ??= {};
-					data.compilerOptions.types ??= [];
-					data.compilerOptions.types.push("./worker-configuration.d.ts");
-					return generateCode();
-				});
-				sv.file("src/app.d.ts", (content) => {
-					const { ast, generateCode } = parseScript(content);
-					const platform = addGlobalAppInterface(ast, { name: "Platform" });
-					if (!platform) throw new Error("Failed detecting `platform` interface in `src/app.d.ts`");
-					platform.body.body.push(createCloudflarePlatformType("env", "Env"), createCloudflarePlatformType("ctx", "ExecutionContext"), createCloudflarePlatformType("caches", "CacheStorage"), createCloudflarePlatformType("cf", "IncomingRequestCfProperties", true));
-					return generateCode();
-				});
-			}
-		}
-	}
-});
-function createCloudflarePlatformType(name, value, optional = false) {
-	return {
-		type: "TSPropertySignature",
-		key: {
-			type: "Identifier",
-			name
-		},
-		computed: false,
-		optional,
-		typeAnnotation: {
-			type: "TSTypeAnnotation",
-			typeAnnotation: {
-				type: "TSTypeReference",
-				typeName: {
-					type: "Identifier",
-					name: value
-				}
-			}
-		}
-	};
-}
-
-//#endregion
-//#region lib/core/tooling/css/index.ts
-function addAtRule(node, options$7) {
-	let atRule = node.children.filter((x) => x.type === "Atrule").find((x) => x.name === options$7.name && x.prelude === options$7.params);
-	if (atRule) return atRule;
-	atRule = {
-		type: "Atrule",
-		name: options$7.name,
-		prelude: options$7.params,
-		block: null,
-		start: 0,
-		end: 0
-	};
-	if (!options$7.append) node.children.unshift(atRule);
-	else node.children.push(atRule);
-	return atRule;
-}
-
-//#endregion
-//#region lib/addons/tailwindcss/index.ts
-const plugins = [{
-	id: "typography",
-	package: "@tailwindcss/typography",
-	version: "^0.5.19"
-}, {
-	id: "forms",
-	package: "@tailwindcss/forms",
-	version: "^0.5.10"
-}];
-const options$1 = defineAddonOptions().add("plugins", {
-	type: "multiselect",
-	question: "Which plugins would you like to add?",
-	options: plugins.map((p) => ({
-		value: p.id,
-		label: p.id,
-		hint: p.package
-	})),
-	default: [],
-	required: false
-}).build();
-var tailwindcss_default = defineAddon({
-	id: "tailwindcss",
-	alias: "tailwind",
-	shortDescription: "css framework",
-	homepage: "https://tailwindcss.com",
-	options: options$1,
-	run: ({ sv, options: options$7, files, kit, dependencyVersion, typescript }) => {
-		const prettierInstalled = Boolean(dependencyVersion("prettier"));
-		sv.devDependency("tailwindcss", "^4.1.17");
-		sv.devDependency("@tailwindcss/vite", "^4.1.17");
-		sv.pnpmBuildDependency("@tailwindcss/oxide");
-		if (prettierInstalled) sv.devDependency("prettier-plugin-tailwindcss", "^0.7.2");
-		for (const plugin of plugins) {
-			if (!options$7.plugins.includes(plugin.id)) continue;
-			sv.devDependency(plugin.package, plugin.version);
-		}
-		sv.file(files.viteConfig, (content) => {
-			const { ast, generateCode } = parseScript(content);
-			const vitePluginName = "tailwindcss";
-			addDefault(ast, {
-				as: vitePluginName,
-				from: "@tailwindcss/vite"
-			});
-			addPlugin(ast, {
-				code: `${vitePluginName}()`,
-				mode: "prepend"
-			});
-			return generateCode();
-		});
-		sv.file(files.stylesheet, (content) => {
-			const { ast, generateCode } = parseCss(content);
-			for (const plugin of plugins) {
-				if (!options$7.plugins.includes(plugin.id)) continue;
-				addAtRule(ast, {
-					name: "plugin",
-					params: `'${plugin.package}'`,
-					append: false
-				});
-			}
-			addAtRule(ast, {
-				name: "import",
-				params: `'tailwindcss'`,
-				append: false
-			});
-			return generateCode();
-		});
-		if (!kit) {
-			const appSvelte = "src/App.svelte";
-			const stylesheetRelative = files.getRelative({
-				from: appSvelte,
-				to: files.stylesheet
-			});
-			sv.file(appSvelte, (content) => {
-				const { ast, generateCode } = parseSvelte(content);
-				const scriptAst = ensureScript(ast, { langTs: typescript });
-				addEmpty(scriptAst, { from: stylesheetRelative });
-				return generateCode();
-			});
-		} else {
-			const layoutSvelte = `${kit?.routesDirectory}/+layout.svelte`;
-			const stylesheetRelative = files.getRelative({
-				from: layoutSvelte,
-				to: files.stylesheet
-			});
-			sv.file(layoutSvelte, (content) => {
-				const { ast, generateCode } = parseSvelte(content);
-				const scriptAst = ensureScript(ast, { langTs: typescript });
-				addEmpty(scriptAst, { from: stylesheetRelative });
-				if (content.length === 0) {
-					const svelteVersion = dependencyVersion("svelte");
-					if (!svelteVersion) throw new Error("Failed to determine svelte version");
-					addSlot(ast, { svelteVersion });
-				}
-				return generateCode();
-			});
-		}
-		sv.file(files.vscodeSettings, (content) => {
-			const { data, generateCode } = parseJson(content);
-			data["files.associations"] ??= {};
-			data["files.associations"]["*.css"] = "tailwindcss";
-			return generateCode();
-		});
-		if (prettierInstalled) sv.file(files.prettierrc, (content) => {
-			const { data, generateCode } = parseJson(content);
-			data.plugins ??= [];
-			const plugins$1 = data.plugins;
-			const PLUGIN_NAME = "prettier-plugin-tailwindcss";
-			if (!plugins$1.includes(PLUGIN_NAME)) plugins$1.push(PLUGIN_NAME);
-			data.tailwindStylesheet ??= files.getRelative({ to: files.stylesheet });
-			return generateCode();
-		});
-	}
-});
-
-//#endregion
-//#region lib/addons/vitest-addon/index.ts
-const options = defineAddonOptions().add("usages", {
-	question: "What do you want to use vitest for?",
-	type: "multiselect",
-	default: ["unit", "component"],
-	options: [{
-		value: "unit",
-		label: "unit testing"
-	}, {
-		value: "component",
-		label: "component testing"
-	}],
-	required: true
-}).build();
-let vitestV3Installed = false;
-var vitest_addon_default = defineAddon({
-	id: "vitest",
-	shortDescription: "unit testing",
-	homepage: "https://vitest.dev",
-	options,
-	run: ({ sv, files, typescript, kit, options: options$7, dependencyVersion }) => {
-		const ext = typescript ? "ts" : "js";
-		const unitTesting = options$7.usages.includes("unit");
-		const componentTesting = options$7.usages.includes("component");
-		vitestV3Installed = (dependencyVersion("vitest") ?? "").replaceAll("^", "").replaceAll("~", "")?.startsWith("3.");
-		sv.devDependency("vitest", "^4.0.15");
-		if (componentTesting) {
-			sv.devDependency("@vitest/browser-playwright", "^4.0.15");
-			sv.devDependency("vitest-browser-svelte", "^2.0.1");
-			sv.devDependency("playwright", "^1.57.0");
-		}
-		sv.file(files.package, (content) => {
-			const { data, generateCode } = parseJson(content);
-			data.scripts ??= {};
-			const scripts = data.scripts;
-			const TEST_CMD = "vitest";
-			const RUN_TEST = "npm run test:unit -- --run";
-			scripts["test:unit"] ??= TEST_CMD;
-			scripts["test"] ??= RUN_TEST;
-			if (!scripts["test"].includes(RUN_TEST)) scripts["test"] += ` && ${RUN_TEST}`;
-			return generateCode();
-		});
-		if (unitTesting) sv.file(`src/demo.spec.${ext}`, (content) => {
-			if (content) return content;
-			return dedent_default`
-					import { describe, it, expect } from 'vitest';
-	
-					describe('sum test', () => {
-						it('adds 1 + 2 to equal 3', () => {
-							expect(1 + 2).toBe(3);
-						});
-					});
-				`;
-		});
-		if (componentTesting) {
-			const fileName = kit ? `${kit.routesDirectory}/page.svelte.spec.${ext}` : `src/App.svelte.test.${ext}`;
-			sv.file(fileName, (content) => {
-				if (content) return content;
-				return dedent_default`
-						import { page } from 'vitest/browser';
-						import { describe, expect, it } from 'vitest';
-						import { render } from 'vitest-browser-svelte';
-						${kit ? "import Page from './+page.svelte';" : "import App from './App.svelte';"}
-
-						describe('${kit ? "/+page.svelte" : "App.svelte"}', () => {
-							it('should render h1', async () => {
-								render(${kit ? "Page" : "App"});
-								
-								const heading = page.getByRole('heading', { level: 1 });
-								await expect.element(heading).toBeInTheDocument();
-							});
-						});
-					`;
-			});
-		}
-		sv.file(files.viteConfig, (content) => {
-			const { ast, generateCode } = parseScript(content);
-			const clientObjectExpression = create({
-				extends: `./${files.viteConfig}`,
-				test: {
-					name: "client",
-					browser: {
-						enabled: true,
-						provider: createCall({
-							name: "playwright",
-							args: []
-						}),
-						instances: [{
-							browser: "chromium",
-							headless: true
-						}]
-					},
-					include: ["src/**/*.svelte.{test,spec}.{js,ts}"],
-					exclude: ["src/lib/server/**"]
-				}
-			});
-			const serverObjectExpression = create({
-				extends: `./${files.viteConfig}`,
-				test: {
-					name: "server",
-					environment: "node",
-					include: ["src/**/*.{test,spec}.{js,ts}"],
-					exclude: ["src/**/*.svelte.{test,spec}.{js,ts}"]
-				}
-			});
-			const viteConfig = getConfig(ast);
-			const testObject = property(viteConfig, {
-				name: "test",
-				fallback: create({ expect: { requireAssertions: true } })
-			});
-			const workspaceArray = property(testObject, {
-				name: "projects",
-				fallback: create$1()
-			});
-			if (componentTesting) append(workspaceArray, clientObjectExpression);
-			if (unitTesting) append(workspaceArray, serverObjectExpression);
-			if (componentTesting) addNamed(ast, {
-				imports: ["playwright"],
-				from: "@vitest/browser-playwright"
-			});
-			const importName = "defineConfig";
-			const { statement, alias } = find(ast, {
-				name: importName,
-				from: "vite"
-			});
-			if (statement) {
-				addNamed(ast, {
-					imports: { defineConfig: alias },
-					from: "vitest/config"
-				});
-				remove(ast, {
-					name: importName,
-					from: "vite",
-					statement
-				});
-			}
-			return generateCode();
-		});
-	},
-	nextSteps: ({ highlighter, typescript, options: options$7 }) => {
-		const toReturn = [];
-		if (vitestV3Installed) {
-			if (options$7.usages.includes("component")) {
-				toReturn.push(`Uninstall ${highlighter.command("@vitest/browser")} package`);
-				toReturn.push(`Update usage from ${highlighter.command("'@vitest/browser...'")} to ${highlighter.command("'vitest/browser'")}`);
-			}
-			toReturn.push(`${highlighter.optional("Optional")} Check ${highlighter.path("./vite.config.ts")} and remove duplicate project definitions`);
-			toReturn.push(`${highlighter.optional("Optional")} Remove ${highlighter.path("./vitest-setup-client" + (typescript ? ".ts" : ".js"))} file`);
-		}
-		return toReturn;
-	}
-});
-
-//#endregion
-//#region lib/addons/_config/official.ts
-const officialAddons = {
-	prettier: prettier_default,
-	eslint: eslint_default,
-	vitest: vitest_addon_default,
-	playwright: playwright_default,
-	tailwindcss: tailwindcss_default,
-	sveltekitAdapter: sveltekit_adapter_default,
-	devtoolsJson: devtools_json_default,
-	drizzle: drizzle_default,
-	lucia: lucia_default,
-	mdsvex: mdsvex_default,
-	paraglide: paraglide_default,
-	storybook: storybook_default,
-	mcp: mcp_default
-};
-function getAddonDetails(id) {
-	const details = Object.values(officialAddons).find((a) => a.id === id);
-	if (!details) throw new Error(`Invalid add-on: ${id}`);
-	return details;
-}
-
-//#endregion
-export { setupAddons as a, installAddon as i, officialAddons as n, createWorkspace as o, applyAddons as r, getAddonDetails as t };