sv 1.0.0-next.5 → 1.0.0-next.7

package/dist/addons-DWX20ipF.mjs

@@ -0,0 +1,2306 @@
+import { T as getSharedFiles, _ as defineAddon, dt as R, v as defineAddonOptions } from "./engine-w0Kq5hjN.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import { Walker, coerceVersion, color, createPrinter, dedent, defineEnv, fileExists, isKit3, loadPackageJson, pnpm, resolveCommandArray, resolveLibPrefix, sanitizeName, svelteConfig, transforms } from "@sveltejs/sv-utils";
+import V from "node:process";
+import crypto from "node:crypto";
+//#region src/addons/ai-tools.ts
+const REGEX_MD = /\.md$/;
+const CLIENTS = {
+	"claude-code": {
+		label: "Claude Code",
+		pluginSettings: {
+			path: ".claude/settings.json",
+			marketplace: "svelte",
+			repo: "sveltejs/ai-tools",
+			id: "svelte@svelte"
+		},
+		agentPath: "AGENTS.md",
+		agentLink: {
+			path: ".claude/CLAUDE.md",
+			contents: "@../AGENTS.md\n"
+		},
+		configPath: ".mcp.json",
+		skillsPath: ".claude/skills",
+		agentsPath: ".claude/agents",
+		mcpOptions: {
+			typeLocal: "stdio",
+			typeRemote: "http",
+			env: true
+		}
+	},
+	cursor: {
+		label: "Cursor",
+		agentPath: "AGENTS.md",
+		configPath: ".cursor/mcp.json",
+		skillsPath: ".cursor/skills",
+		agentsPath: ".cursor/agents",
+		mcpOptions: {}
+	},
+	gemini: {
+		label: "Gemini",
+		agentPath: "GEMINI.md",
+		configPath: ".gemini/settings.json",
+		skillsPath: ".gemini/skills",
+		agentsPath: ".gemini/agents",
+		schema: "https://raw.githubusercontent.com/google-gemini/gemini-cli/main/schemas/settings.schema.json",
+		mcpOptions: {}
+	},
+	opencode: {
+		label: "OpenCode",
+		pluginOnly: true,
+		agentPath: "AGENTS.md",
+		configPath: ".opencode/opencode.json",
+		schema: "https://opencode.ai/config.json",
+		customData: { plugin: ["@sveltejs/opencode"] },
+		extraFiles: [{
+			path: ".opencode/svelte.json",
+			data: { $schema: "https://svelte.dev/opencode/schema.json" }
+		}]
+	},
+	vscode: {
+		label: "VS Code",
+		agentPath: "AGENTS.md",
+		configPath: ".vscode/mcp.json",
+		skillsPath: ".github/skills",
+		agentsPath: ".github/agents",
+		agentExtension: ".agent.md",
+		mcpOptions: { serversKey: "servers" }
+	},
+	other: {
+		label: "Other",
+		agentPath: "AGENTS.md"
+	}
+};
+const acceptsTools = (client) => Boolean(client && !client.pluginOnly && (client.skillsPath || client.agentsPath || client.configPath));
+const wantsLooseTools = (client, delivery) => acceptsTools(client) && (!client.pluginSettings || delivery !== "plugin");
+const wantsMcpConfig = (client, delivery) => Boolean(client?.mcpOptions) && wantsLooseTools(client, delivery);
+const TOOLS = {
+	mcp: {
+		label: "MCP server",
+		kind: "mcp"
+	},
+	"svelte-code-writer": {
+		label: "svelte-code-writer",
+		kind: "skill",
+		hint: "skill"
+	},
+	"svelte-core-bestpractices": {
+		label: "svelte-core-bestpractices",
+		kind: "skill",
+		hint: "skill"
+	},
+	"svelte-file-editor": {
+		label: "svelte-file-editor",
+		kind: "agent",
+		hint: "sub-agent"
+	}
+};
+var ai_tools_default = defineAddon({
+	id: "ai-tools",
+	shortDescription: "Svelte AI tools",
+	homepage: "https://svelte.dev/docs/ai",
+	options: defineAddonOptions().add("ide", {
+		question: "Which client would you like to use?",
+		type: "multiselect",
+		default: [],
+		options: Object.entries(CLIENTS).map(([value, client]) => ({
+			value,
+			label: client.label
+		})),
+		required: true
+	}).add("delivery", {
+		question: "How would you like to add the Svelte tools?",
+		type: "select",
+		default: "plugin",
+		options: [{
+			value: "plugin",
+			label: "Svelte plugin",
+			hint: "recommended, auto-installs & updates"
+		}, {
+			value: "tools",
+			label: "Individual tools",
+			hint: "choose exactly what to add"
+		}],
+		condition: ({ ide }) => ide.some((i) => CLIENTS[i]?.pluginSettings)
+	}).add("tools", {
+		question: "Which tools would you like to add?",
+		type: "multiselect",
+		default: Object.keys(TOOLS),
+		options: Object.entries(TOOLS).map(([value, t]) => ({
+			value,
+			label: t.label,
+			hint: t.hint
+		})),
+		required: false,
+		condition: ({ ide, delivery }) => ide.some((i) => wantsLooseTools(CLIENTS[i], delivery))
+	}).add("mcpSetup", {
+		question: "Which MCP 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"
+		}],
+		condition: ({ ide, delivery, tools }) => (tools === void 0 || tools.includes("mcp")) && ide.some((i) => wantsMcpConfig(CLIENTS[i], delivery))
+	}).build(),
+	run: ({ sv, options }) => {
+		const usePlugin = options.delivery === "plugin";
+		const selected = options.tools ?? Object.keys(TOOLS);
+		const selectedSkills = selected.filter((t) => TOOLS[t]?.kind === "skill");
+		const selectedAgents = selected.filter((t) => TOOLS[t]?.kind === "agent");
+		const wantsMcp = selected.includes("mcp");
+		const getLocalConfig = (o) => {
+			return {
+				...o?.typeLocal ? { type: o.typeLocal } : {},
+				command: o?.command ?? "npx",
+				...o?.env ? { env: {} } : {},
+				...o?.args === null ? {} : { args: o?.args ?? ["-y", "@sveltejs/mcp"] }
+			};
+		};
+		const getRemoteConfig = (o) => {
+			return {
+				...o?.typeRemote ? { type: o.typeRemote } : {},
+				url: "https://mcp.svelte.dev/mcp"
+			};
+		};
+		const filesAdded = [];
+		const filesExistingAlready = [];
+		const sharedFiles = getSharedFiles();
+		const mcpFiles = sharedFiles.filter((file) => file.include.includes("mcp"));
+		const skillFiles = sharedFiles.filter((file) => file.include.includes("skills"));
+		const agentFiles = sharedFiles.filter((file) => file.include.includes("agents"));
+		const agentFile = mcpFiles.find((file) => file.name === "AGENTS.md");
+		const addFile = (path, contents) => {
+			sv.file(path, (content) => {
+				if (content) {
+					filesExistingAlready.push(path);
+					return false;
+				}
+				if (!filesAdded.includes(path)) filesAdded.push(path);
+				return contents;
+			});
+		};
+		for (const ide of options.ide) {
+			const client = CLIENTS[ide];
+			if (!client) continue;
+			if (client.pluginSettings && usePlugin) {
+				const plugin = client.pluginSettings;
+				sv.file(plugin.path, transforms.json(({ data }) => {
+					data.extraKnownMarketplaces ??= {};
+					data.extraKnownMarketplaces[plugin.marketplace] ??= { source: {
+						source: "github",
+						repo: plugin.repo
+					} };
+					data.enabledPlugins ??= {};
+					data.enabledPlugins[plugin.id] = true;
+				}));
+				continue;
+			}
+			if (!client.agentPath) continue;
+			const { mcpOptions, agentPath, agentLink, configPath, skillsPath, agentsPath, agentExtension, schema, customData, extraFiles } = client;
+			if (!filesAdded.includes(agentPath)) sv.file(agentPath, (content) => {
+				if (content) {
+					if (!filesExistingAlready.includes(agentPath)) filesExistingAlready.push(agentPath);
+					return false;
+				}
+				filesAdded.push(agentPath);
+				return agentFile?.contents ?? "";
+			});
+			if (agentLink) addFile(agentLink.path, agentLink.contents);
+			const writeMcp = Boolean(mcpOptions) && wantsMcp;
+			if (configPath && (writeMcp || customData)) sv.file(configPath, transforms.json(({ data }) => {
+				if (schema) data["$schema"] = schema;
+				if (customData) for (const [key, value] of Object.entries(customData)) data[key] = value;
+				if (writeMcp) {
+					const key = mcpOptions.serversKey ?? "mcpServers";
+					data[key] ??= {};
+					data[key].svelte = options.mcpSetup === "local" ? getLocalConfig(mcpOptions) : getRemoteConfig(mcpOptions);
+				}
+			}));
+			if (extraFiles) for (const extra of extraFiles) sv.file(extra.path, transforms.json(({ data }) => {
+				for (const [key, value] of Object.entries(extra.data)) data[key] = value;
+			}));
+			if (skillsPath) for (const file of skillFiles) {
+				if (!selectedSkills.includes(file.name.split("/")[0])) continue;
+				addFile(`${skillsPath}/${file.name}`, file.contents);
+			}
+			if (agentsPath) for (const file of agentFiles) {
+				if (!selectedAgents.includes(file.name.replace(REGEX_MD, ""))) continue;
+				const ext = agentExtension ?? ".md";
+				addFile(`${agentsPath}/${file.name.replace(REGEX_MD, ext)}`, file.contents);
+			}
+		}
+		if (filesExistingAlready.length > 0) R.warn(`${filesExistingAlready.map((path) => color.path(path)).join(", ")} already exists, we didn't touch ${filesExistingAlready.length > 1 ? "them" : "it"}. See ${color.website("https://svelte.dev/docs/ai")} for manual setup.`);
+	},
+	nextSteps({ options, cwd }) {
+		const steps = [];
+		for (const ide of options.ide) {
+			const client = CLIENTS[ide];
+			if (!client?.pluginSettings) continue;
+			const plugin = client.pluginSettings;
+			const settingsPath = path.resolve(cwd, plugin.path);
+			if (!fs.existsSync(settingsPath)) continue;
+			let pluginEnabled = false;
+			try {
+				pluginEnabled = Boolean(JSON.parse(fs.readFileSync(settingsPath, "utf8")).enabledPlugins?.[plugin.id]);
+			} catch {}
+			if (!pluginEnabled) continue;
+			const looseDirs = [client.skillsPath, client.agentsPath].filter((dir) => Boolean(dir) && fs.existsSync(path.resolve(cwd, dir)) && fs.readdirSync(path.resolve(cwd, dir)).some((entry) => Object.keys(TOOLS).includes(entry.replace(REGEX_MD, ""))));
+			if (looseDirs.length === 0) continue;
+			steps.push(`${client.label}: the Svelte plugin is enabled and ${looseDirs.map((d) => color.path(d)).join(" + ")} also exist${looseDirs.length > 1 ? "" : "s"} - remove ${looseDirs.length > 1 ? "them" : "it"} (or disable the plugin) to avoid duplicate skills/sub-agents.`);
+		}
+		if (options.delivery === "plugin" && options.ide.includes("claude-code")) steps.push(`Open the project in Claude Code and trust the workspace - the Svelte plugin installs automatically.`);
+		if (options.ide.includes("other")) steps.push(`For other clients: ${color.website(`https://svelte.dev/docs/ai/${options.mcpSetup ?? "remote"}-setup#Other-clients`)}`);
+		return steps;
+	}
+});
+//#endregion
+//#region src/addons/common.ts
+const ESLINT_VERSION = "^10.4.1";
+const addEslintConfigPrettier = transforms.script(({ ast, js }) => {
+	const sveltePluginImport = ast.body.filter((n) => n.type === "ImportDeclaration").find((n) => n.type === "ImportDeclaration" && n.source.value === "eslint-plugin-svelte" && n.specifiers?.some((n) => n.type === "ImportDefaultSpecifier"));
+	let svelteImportName;
+	for (const specifier of sveltePluginImport?.specifiers ?? []) if (specifier.type === "ImportDefaultSpecifier" && specifier.local?.name) svelteImportName = specifier.local.name;
+	svelteImportName ??= "svelte";
+	js.imports.addDefault(ast, {
+		from: "eslint-plugin-svelte",
+		as: svelteImportName
+	});
+	js.imports.addDefault(ast, {
+		from: "eslint-config-prettier",
+		as: "prettier"
+	});
+	const fallbackConfig = js.common.parseExpression("[]");
+	const eslintConfig = js.exports.createDefault(ast, { fallback: fallbackConfig }).value;
+	let elements = [];
+	if (eslintConfig.type === "ArrayExpression") elements = eslintConfig.elements;
+	else if (eslintConfig.type === "CallExpression") if (eslintConfig.arguments.length === 1 && eslintConfig.arguments[0].type === "ArrayExpression") elements = eslintConfig.arguments[0].elements;
+	else elements = eslintConfig.arguments;
+	else return false;
+	const prettier = js.common.parseExpression("prettier");
+	const sveltePrettierConfig = js.common.parseExpression(`${svelteImportName}.configs.prettier`);
+	const nodesToInsert = [];
+	if (!js.common.contains(eslintConfig, prettier)) nodesToInsert.push(prettier);
+	if (!js.common.contains(eslintConfig, sveltePrettierConfig)) nodesToInsert.push(sveltePrettierConfig);
+	const isSvelteConfig = (maybeSpread) => {
+		const el = maybeSpread?.type === "SpreadElement" ? maybeSpread?.argument : maybeSpread;
+		return el?.type === "MemberExpression" && el.object.type === "MemberExpression" && el.object.object.type === "Identifier" && el.object.object.name === svelteImportName && el.object.property.type === "Identifier" && el.object.property.name === "configs";
+	};
+	const idx = elements.findIndex(isSvelteConfig);
+	if (idx !== -1) elements.splice(idx + 1, 0, ...nodesToInsert);
+	else elements.push(...nodesToInsert);
+});
+/**
+* Path of the prettier config file we generate. We always emit a `.js` file (with a JSDoc `@type`)
+* rather than `.ts`, since the VSCode prettier extension can't load a `.ts` config without a recent
+* enough Node in its extension host (see prettier/prettier-vscode#3989).
+*/
+function prettierConfigPath() {
+	return "prettier.config.js";
+}
+/**
+* Creates a `prettier.config.js` file with our defaults. Bails (leaving the file untouched)
+* if a config is already defined.
+*/
+const createPrettierConfig = (opts) => transforms.script(({ ast, comments, js }) => {
+	if (ast.body.some((node) => node.type === "ExportDefaultDeclaration")) {
+		R.warn(`A ${color.warning("prettier")} config already exists. Skipping initialization.`);
+		return false;
+	}
+	const plugins = ["prettier-plugin-svelte"];
+	if (opts.tailwind) plugins.push("prettier-plugin-tailwindcss");
+	const properties = [
+		"useTabs: true",
+		"singleQuote: true",
+		`trailingComma: 'none'`,
+		"printWidth: 100",
+		`plugins: [${plugins.map((p) => `'${p}'`).join(", ")}]`,
+		`overrides: [{ files: '*.svelte', options: { parser: 'svelte' } }]`
+	];
+	if (opts.tailwind && opts.stylesheet) properties.push(`tailwindStylesheet: '${opts.stylesheet}'`);
+	js.common.appendFromString(ast, {
+		comments,
+		code: `
+				/** @type {import("prettier").Config} */
+				const config = { ${properties.join(", ")} };
+				export default config;
+			`
+	});
+});
+/**
+* Augments an existing `prettier.config.js` config object with the tailwindcss plugin and
+* stylesheet. Used when prettier was added before tailwindcss.
+*/
+const addPrettierTailwind = (opts) => transforms.script(({ ast, js }) => {
+	if (!ast.body.some((node) => node.type === "ExportDefaultDeclaration")) return false;
+	const { value } = js.exports.createDefault(ast, { fallback: js.object.create({}) });
+	if (value.type !== "ObjectExpression") return false;
+	const plugins = js.object.property(value, {
+		name: "plugins",
+		fallback: js.array.create()
+	});
+	if (plugins.type === "ArrayExpression") js.array.append(plugins, "prettier-plugin-tailwindcss");
+	if (!value.properties.some((p) => p.type === "Property" && p.key.type === "Identifier" && p.key.name === "tailwindStylesheet")) js.object.property(value, {
+		name: "tailwindStylesheet",
+		fallback: js.common.createLiteral(opts.stylesheet)
+	});
+});
+const addToDemoPage = (path, language) => transforms.svelteScript({ language }, ({ ast, js, svelte }) => {
+	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}`))) return false;
+	}
+	js.imports.addNamed(ast.instance.content, {
+		imports: ["resolve"],
+		from: "$app/paths"
+	});
+	svelte.addFragment(ast, `<a href={resolve('/demo/${path}')}>${path}</a>`, { mode: "prepend" });
+});
+/**
+* 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 = V.versions.node;
+	const isDenoOrBun = Boolean(V.versions.deno ?? V.versions.bun);
+	const [major] = nodeVersion.split(".");
+	const majorNum = Number(major);
+	const isEvenMajor = majorNum % 2 === 0;
+	if (!!V.release.lts || isDenoOrBun && isEvenMajor) return `^${major}`;
+	return `^${isEvenMajor ? majorNum - 2 : majorNum - 1}`;
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.137.0/helpers/esm/taggedTemplateLiteral.js
+function _taggedTemplateLiteral(e, t) {
+	return t || (t = e.slice(0)), Object.freeze(Object.defineProperties(e, { raw: { value: Object.freeze(t) } }));
+}
+//#endregion
+//#region src/addons/better-auth.ts
+var _templateObject$1;
+var _templateObject2;
+var better_auth_default = defineAddon({
+	id: "better-auth",
+	shortDescription: "auth library",
+	homepage: "https://www.better-auth.com",
+	options: defineAddonOptions().add("demo", {
+		question: "Which demo would you like to include?",
+		type: "multiselect",
+		default: ["password"],
+		options: [{
+			value: "password",
+			label: "Email & Password"
+		}, {
+			value: "github",
+			label: "GitHub OAuth"
+		}],
+		required: false
+	}).build(),
+	setup: ({ isKit, dependencyVersion, unsupported, dependsOn, runsAfter }) => {
+		if (!isKit) unsupported("Requires SvelteKit");
+		if (!dependencyVersion("drizzle-orm")) dependsOn("drizzle");
+		runsAfter("sveltekitAdapter");
+		runsAfter("tailwindcss");
+		runsAfter("experimental");
+	},
+	run: ({ sv, cwd, language, options, directory, dependencyVersion, file }) => {
+		const lib = resolveLibPrefix(dependencyVersion("@sveltejs/kit"));
+		const svelteVersion = dependencyVersion("svelte");
+		const svelte5 = !!svelteVersion && coerceVersion(svelteVersion).major === 5;
+		const [ts, s5] = createPrinter(language === "ts", svelte5);
+		const demoPassword = options.demo.includes("password");
+		const demoGithub = options.demo.includes("github");
+		const hasDemo = demoPassword || demoGithub;
+		let drizzleDialect;
+		let d1 = false;
+		sv.devDependency("auth", "^1.6.24");
+		sv.devDependency("better-auth", "^1.6.24");
+		sv.file(`drizzle.config.${language}`, transforms.script(({ ast }) => {
+			const isProp = (name, node) => node.key.type === "Identifier" && node.key.name === name;
+			Walker.walk(ast, null, { Property(node) {
+				if (isProp("dialect", node) && node.value.type === "Literal" && typeof node.value.value === "string") drizzleDialect = node.value.value;
+				if (isProp("driver", node) && node.value.type === "Literal" && node.value.value === "d1-http") d1 = true;
+			} });
+			if (!drizzleDialect) throw new Error("Failed to detect DB dialect in your `drizzle.config.[js|ts]` file");
+			return false;
+		}));
+		sv.file(".env", generateEnv$1(demoGithub, false));
+		sv.file(".env.example", generateEnv$1(demoGithub, true));
+		const env = defineEnv({
+			sv,
+			cwd,
+			dependencyVersion
+		});
+		env.define({
+			name: "ORIGIN",
+			description: "The app origin (base URL), e.g. `http://localhost:5173`."
+		});
+		env.define({
+			name: "BETTER_AUTH_SECRET",
+			description: "Secret used to sign tokens. For production use 32 characters generated with high entropy. See [Better Auth installation](https://www.better-auth.com/docs/installation)."
+		});
+		if (demoGithub) {
+			env.define({
+				name: "GITHUB_CLIENT_ID",
+				description: "GitHub OAuth client ID. See [Better Auth GitHub provider](https://www.better-auth.com/docs/authentication/github)."
+			});
+			env.define({
+				name: "GITHUB_CLIENT_SECRET",
+				description: "GitHub OAuth client secret. See [Better Auth GitHub provider](https://www.better-auth.com/docs/authentication/github)."
+			});
+		}
+		sv.file(`${directory.lib}/server/auth.${language}`, transforms.script(({ ast, comments, js }) => {
+			js.imports.addNamed(ast, {
+				from: `${lib}/server/db/index.${language}`,
+				imports: [d1 ? "getDb" : "db"]
+			});
+			js.imports.addNamed(ast, {
+				from: "$app/server",
+				imports: ["getRequestEvent"]
+			});
+			js.imports.addNamed(ast, {
+				from: "better-auth/svelte-kit",
+				imports: ["sveltekitCookies"]
+			});
+			js.imports.addNamed(ast, {
+				from: "better-auth/adapters/drizzle",
+				imports: ["drizzleAdapter"]
+			});
+			js.imports.addNamed(ast, {
+				from: "better-auth/minimal",
+				imports: ["betterAuth"]
+			});
+			const origin = env.reference(ast, js, { name: "ORIGIN" });
+			const secret = env.reference(ast, js, { name: "BETTER_AUTH_SECRET" });
+			const githubId = demoGithub ? env.reference(ast, js, { name: "GITHUB_CLIENT_ID" }) : "";
+			const githubSecret = demoGithub ? env.reference(ast, js, { name: "GITHUB_CLIENT_SECRET" }) : "";
+			const provider = {
+				mysql: "mysql",
+				postgresql: "pg",
+				sqlite: "sqlite",
+				turso: "sqlite"
+			}[drizzleDialect];
+			const githubProvider = demoGithub ? `
+				socialProviders: {
+					github: {
+						clientId: ${githubId},
+						clientSecret: ${githubSecret},
+					},
+				},` : "";
+			let authConfig = "";
+			if (d1) authConfig = dedent`
+					const authConfig = {
+						baseURL: ${origin},
+						secret: ${secret},
+						emailAndPassword: {
+							enabled: true
+						},${githubProvider}
+						plugins: [
+							sveltekitCookies(getRequestEvent) // make sure this is the last plugin in the array
+						],
+					}${ts(" satisfies Omit<Parameters<typeof betterAuth>[0], \"database\">")};
+
+					export const createAuth = (d1${ts(": D1Database")}) => betterAuth({
+						...authConfig,
+						database: drizzleAdapter(getDb(d1), { provider: '${provider}' }),
+					});
+
+					/**
+					 * DO NOT USE!
+					 *
+					 * This instance is used by the \`auth\` CLI for schema generation ONLY.
+					 * To access \`auth\` at runtime, use \`event.locals.auth\`.
+					 */
+					export const auth = createAuth(null${ts("!")});`;
+			else authConfig = dedent`
+					export const auth = betterAuth({
+						baseURL: ${origin},
+						secret: ${secret},
+						database: drizzleAdapter(db, { provider: '${provider}' }),
+						emailAndPassword: {
+							enabled: true
+						},${githubProvider}
+						plugins: [
+							sveltekitCookies(getRequestEvent) // make sure this is the last plugin in the array
+						],
+					});`;
+			js.common.appendFromString(ast, {
+				code: authConfig,
+				comments
+			});
+		}));
+		const authConfigPath = `${directory.lib}/server/auth.${language}`;
+		const authSchemaPath = `${directory.lib}/server/db/auth.schema.${language}`;
+		sv.file(file.package, transforms.json(({ data, json }) => {
+			json.packageScriptsUpsert(data, "auth:schema", `auth generate --config ${authConfigPath} --output ${authSchemaPath} --yes`);
+		}));
+		sv.file(`${directory.lib}/server/db/auth.schema.${language}`, transforms.text(({ content }) => {
+			if (content) return false;
+			return dedent`
+					// If you see this file, you have not run the auth:schema script yet, but you should!
+					export {};
+				`;
+		}));
+		sv.file(`${directory.lib}/server/db/schema.${language}`, transforms.script(({ ast, js }) => {
+			js.exports.addNamespace(ast, { from: "./auth.schema" });
+		}));
+		sv.file("src/app.d.ts", transforms.script(({ ast, comments, js }) => {
+			if (d1) js.imports.addNamed(ast, {
+				imports: ["createAuth"],
+				from: `${lib}/server/auth.${language}`
+			});
+			js.imports.addNamed(ast, {
+				imports: ["User", "Session"],
+				from: "better-auth",
+				isType: true
+			});
+			const locals = js.kit.addGlobalAppInterface(ast, { name: "Locals" });
+			if (!locals) throw new Error("Failed detecting `locals` interface in `src/app.d.ts`");
+			comments.remove((c) => c.type === "Line" && c.value.trim() === "interface Locals {}");
+			const user = locals.body.body.find((prop) => js.common.hasTypeProperty(prop, { name: "user" }));
+			const session = locals.body.body.find((prop) => js.common.hasTypeProperty(prop, { name: "session" }));
+			const auth = locals.body.body.find((prop) => js.common.hasTypeProperty(prop, { name: "auth" }));
+			if (!user) locals.body.body.push(js.common.createTypeProperty("user", "User", true));
+			if (!session) locals.body.body.push(js.common.createTypeProperty("session", "Session", true));
+			if (d1 && !auth) locals.body.body.push(js.common.createTypeProperty("auth", "ReturnType<typeof createAuth>", false));
+		}));
+		sv.file(`src/hooks.server.${language}`, transforms.script(({ ast, comments, js }) => {
+			js.imports.addNamed(ast, {
+				imports: ["svelteKitHandler"],
+				from: "better-auth/svelte-kit"
+			});
+			js.imports.addNamed(ast, {
+				imports: [d1 ? "createAuth" : "auth"],
+				from: `${lib}/server/auth.${language}`
+			});
+			env.importEnv(ast, js, ["building"]);
+			const handleContent = dedent`
+				async ({ event, resolve }) => {${d1 ? dedent`
+					if (!event.platform?.env?.DB) throw new Error('D1 binding "DB" not found - are you running with wrangler?');
+					event.locals.auth = createAuth(event.platform.env.DB);
+					const { auth } = event.locals;\n` : ""}
+					// Fetch current session from Better Auth
+					const session = await auth.api.getSession({
+						headers: event.request.headers
+					});
+					// Make session and user available on server
+					if (session) {
+						event.locals.session = session.session;
+						event.locals.user = session.user;
+					}
+					return svelteKitHandler({ event, resolve, auth, building });
+				};
+
+				export const handle = sequence(handleBetterAuth, handleSession);
+			`;
+			js.kit.addHooksHandle(ast, {
+				language,
+				newHandleName: "handleBetterAuth",
+				handleContent,
+				comments
+			});
+		}));
+		if (hasDemo) {
+			sv.file(`${directory.kitRoutes}/demo/+page.svelte`, addToDemoPage("better-auth", language));
+			sv.file(`${directory.kitRoutes}/demo/better-auth/login/+page.server.${language}`, (content) => {
+				if (content) {
+					const filePath = `${directory.kitRoutes}/demo/better-auth/login/+page.server.${language}`;
+					R.warn(`Existing ${color.warning(filePath)} file. Could not update.`);
+					return false;
+				}
+				const d1AuthLine = d1 ? "\n							const { auth } = event.locals;\n" : "";
+				const signInEmailAction = demoPassword ? `
+						signInEmail: async (event) => {${d1AuthLine}
+							const formData = await event.request.formData();
+							const email = formData.get('email')?.toString() ?? '';
+							const password = formData.get('password')?.toString() ?? '';
+
+							try {
+								await auth.api.signInEmail({
+									body: {
+										email,
+										password,
+										callbackURL: '/auth/verification-success'
+									}
+								});
+							} catch (error) {
+								if (error instanceof APIError) {
+									return fail(400, { message: error.message || 'Signin failed' });
+								}
+								return fail(500, { message: 'Unexpected error' });
+							}
+
+							return redirect(302, '/demo/better-auth');
+						},
+						signUpEmail: async (event) => {${d1AuthLine}
+							const formData = await event.request.formData();
+							const email = formData.get('email')?.toString() ?? '';
+							const password = formData.get('password')?.toString() ?? '';
+							const name = formData.get('name')?.toString() ?? '';
+
+							try {
+								await auth.api.signUpEmail({
+									body: {
+										email,
+										password,
+										name,
+										callbackURL: '/auth/verification-success'
+									}
+								});
+							} catch (error) {
+								if (error instanceof APIError) {
+									return fail(400, { message: error.message || 'Registration failed' });
+								}
+								return fail(500, { message: 'Unexpected error' });
+							}
+
+							return redirect(302, '/demo/better-auth');
+						},` : "";
+				const signInSocialAction = demoGithub ? `
+						signInSocial: async (event) => {${d1AuthLine}
+							const formData = await event.request.formData();
+							const provider = formData.get('provider')?.toString() ?? 'github';
+							const callbackURL = formData.get('callbackURL')?.toString() ?? '/demo/better-auth';
+
+							const result = await auth.api.signInSocial({
+								body: {
+									provider: provider${ts(" as \"github\"")},
+									callbackURL
+								}
+							});
+
+							if (result.url) {
+								return redirect(302, result.url);
+							}
+							return fail(400, { message: 'Social sign-in failed' });
+						},` : "";
+				const needsAPIError = demoPassword;
+				return dedent`
+					import { fail, redirect } from '@sveltejs/kit';
+					${ts("import type { Actions } from './$types';")}
+					${ts("import type { PageServerLoad } from './$types';")}
+					${!d1 ? `import { auth } from '${lib}/server/auth.${language}';` : ""}
+					${needsAPIError ? "import { APIError } from 'better-auth/api';" : ""}
+
+					export const load${ts(": PageServerLoad")} = (event) => {
+						if (event.locals.user) {
+							return redirect(302, '/demo/better-auth');
+						}
+						return {};
+					};
+
+					export const actions${ts(": Actions")} = {${signInEmailAction}${signInSocialAction}
+					};
+				`;
+			});
+			sv.file(`${directory.kitRoutes}/demo/better-auth/login/+page.svelte`, (content) => {
+				if (content) {
+					const filePath = `${directory.kitRoutes}/demo/better-auth/login/+page.svelte`;
+					R.warn(`Existing ${color.warning(filePath)} file. Could not update.`);
+					return false;
+				}
+				const tailwind = dependencyVersion("@tailwindcss/vite") !== void 0;
+				const input = tailwind ? " 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 btn = tailwind ? " class=\"bg-blue-600 text-white px-4 py-2 rounded-md hover:bg-blue-700 transition\"" : "";
+				const passwordForm = demoPassword ? `
+					<form method="post" action="?/signInEmail" use:enhance>
+						<label>
+							Email
+							<input type="email" name="email"${input} />
+						</label>
+						<label>
+							Password
+							<input type="password" name="password"${input} />
+						</label>
+						<label>
+							Name (for registration)
+							<input name="name"${input} />
+						</label>
+						<button${btn}>Login</button>
+						<button formaction="?/signUpEmail"${btn}>Register</button>
+					</form>
+					${tailwind ? `<p class="text-red-500">{form?.message ?? ''}</p>` : `<p style="color: red">{form?.message ?? ''}</p>`}` : "";
+				const separator = demoPassword && demoGithub ? `\n\n\t\t\t\t\t<hr ${tailwind ? "class=\"my-4\"" : ""} />\n` : "";
+				const githubForm = demoGithub ? `
+					<form method="post" action="?/signInSocial" use:enhance>
+						<input type="hidden" name="provider" value="github" />
+						<input type="hidden" name="callbackURL" value="/demo/better-auth" />
+						<button${btn}>Sign in with GitHub</button>
+					</form>` : "";
+				return dedent(_templateObject$1 || (_templateObject$1 = _taggedTemplateLiteral([
+					"\n					<script ",
+					">\n						import { enhance } from '$app/forms';\n						",
+					"\n						",
+					"\n					<\/script>\n\n					<h1>Login</h1>",
+					"",
+					"",
+					"\n				"
+				])), ts("lang='ts'"), ts("import type { ActionData } from './$types';\n"), s5(`let { form }${ts(": { form: ActionData }")} = $props();`, `export let form${ts(": ActionData")};`), passwordForm, separator, githubForm);
+			});
+			sv.file(`${directory.kitRoutes}/demo/better-auth/+page.server.${language}`, (content) => {
+				if (content) {
+					const filePath = `${directory.kitRoutes}/demo/better-auth/+page.server.${language}`;
+					R.warn(`Existing ${color.warning(filePath)} file. Could not update.`);
+					return false;
+				}
+				const d1AuthLine = d1 ? "\n							const { auth } = event.locals;\n" : "";
+				return dedent`
+					import { redirect } from '@sveltejs/kit';
+					${ts("import type { Actions } from './$types';")}
+					${ts("import type { PageServerLoad } from './$types';")}
+					${!d1 ? `import { auth } from '${lib}/server/auth.${language}';` : ""}
+
+					export const load${ts(": PageServerLoad")} = (event) => {
+						if (!event.locals.user) {
+							return redirect(302, '/demo/better-auth/login');
+						}
+						return { user: event.locals.user };
+					};
+
+					export const actions${ts(": Actions")} = {
+						signOut: async (event) => {${d1AuthLine}
+							await auth.api.signOut({
+								headers: event.request.headers
+							});
+							return redirect(302, '/demo/better-auth/login');
+						}
+					};
+				`;
+			});
+			sv.file(`${directory.kitRoutes}/demo/better-auth/+page.svelte`, (content) => {
+				if (content) {
+					const filePath = `${directory.kitRoutes}/demo/better-auth/+page.svelte`;
+					R.warn(`Existing ${color.warning(filePath)} file. Could not update.`);
+					return false;
+				}
+				const tailwind = dependencyVersion("@tailwindcss/vite") !== void 0;
+				return dedent(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral([
+					"\n					<script ",
+					">\n						import { enhance } from '$app/forms';\n						",
+					"\n						",
+					"\n					<\/script>\n\n					<h1>Hi, {data.user.name}!</h1>\n					<p>Your user ID is {data.user.id}.</p>\n					<form method=\"post\" action=\"?/signOut\" use:enhance>\n						<button ",
+					">Sign out</button>\n					</form>\n				"
+				])), ts("lang='ts'"), ts("import type { PageServerData } from './$types';\n"), s5(`let { data }${ts(": { data: PageServerData }")} = $props();`, `export let data${ts(": PageServerData")};`), tailwind ? "class=\"bg-blue-600 text-white px-4 py-2 rounded-md hover:bg-blue-700 transition\"" : "");
+			});
+		}
+	},
+	nextSteps: ({ options, packageManager }) => {
+		const steps = [
+			`Run ${color.command(resolveCommandArray(packageManager, "run", ["auth:schema"]))} to generate the auth schema`,
+			`Run ${color.command(resolveCommandArray(packageManager, "run", ["db:push"]))} to update your database`,
+			`Check ${color.env("ORIGIN")} & ${color.env("BETTER_AUTH_SECRET")} in ${color.path(".env")} and adjust it to your needs`
+		];
+		if (options.demo.includes("github")) steps.push(`Set your ${color.env("GITHUB_CLIENT_ID")} and ${color.env("GITHUB_CLIENT_SECRET")} in ${color.path(".env")}`);
+		if (options.demo.length > 0) steps.push(`Visit ${color.route("/demo/better-auth")} route to view the demo`);
+		return steps;
+	}
+});
+const generateEnv$1 = (demoGithub, isExample) => transforms.text(({ content, text }) => {
+	content = text.upsert(content, "ORIGIN", {
+		value: isExample ? `""` : `"http://localhost:5173"`,
+		separator: true
+	});
+	content = text.upsert(content, "BETTER_AUTH_SECRET", {
+		value: isExample ? `""` : `"${crypto.randomUUID()}"`,
+		comment: [
+			"Better Auth",
+			"For production use 32 characters and generated with high entropy",
+			"https://www.better-auth.com/docs/installation"
+		],
+		separator: true
+	});
+	if (demoGithub) {
+		content = text.upsert(content, "GITHUB_CLIENT_ID", {
+			value: `""`,
+			comment: "GitHub OAuth\n# https://www.better-auth.com/docs/authentication/github"
+		});
+		content = text.upsert(content, "GITHUB_CLIENT_SECRET", { value: `""` });
+	}
+	return content;
+});
+//#endregion
+//#region src/addons/drizzle.ts
+const PORTS = {
+	mysql: "3306",
+	postgresql: "5432",
+	sqlite: "",
+	d1: ""
+};
+var drizzle_default = defineAddon({
+	id: "drizzle",
+	shortDescription: "database orm",
+	homepage: "https://orm.drizzle.team",
+	options: 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"
+			},
+			{
+				value: "d1",
+				label: "Cloudflare D1"
+			}
+		]
+	}).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: "node-sqlite",
+				label: "node:sqlite",
+				hint: "built-in to Node.js and Deno"
+			},
+			{
+				value: "better-sqlite3",
+				hint: "for server 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(),
+	setup: ({ isKit, unsupported, runsAfter }) => {
+		runsAfter("prettier");
+		runsAfter("sveltekitAdapter");
+		runsAfter("experimental");
+		if (!isKit) return unsupported("Requires SvelteKit");
+	},
+	run: ({ sv, language, options, directory, dependencyVersion, cwd, cancel, file }) => {
+		const [ts] = createPrinter(language === "ts");
+		const baseDBPath = path.resolve(cwd, directory.lib, "server", "db");
+		const paths = {
+			"drizzle config": path.resolve(cwd, `drizzle.config.${language}`),
+			"database schema": path.resolve(baseDBPath, `schema.${language}`),
+			database: path.resolve(baseDBPath, `index.${language}`)
+		};
+		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.2");
+		sv.devDependency("drizzle-kit", "^0.31.10");
+		sv.devDependency("@types/node", getNodeTypesVersion());
+		if (options.mysql === "mysql2") sv.devDependency("mysql2", "^3.22.4");
+		if (options.mysql === "planetscale") sv.devDependency("@planetscale/database", "^1.20.1");
+		if (options.postgresql === "neon") sv.devDependency("@neondatabase/serverless", "^1.1.0");
+		if (options.postgresql === "postgres.js") sv.devDependency("postgres", "^3.4.9");
+		if (options.sqlite === "better-sqlite3") {
+			sv.dependency("better-sqlite3", "^13.0.2");
+			sv.devDependency("@types/better-sqlite3", "^9.6.0");
+		}
+		if (options.sqlite === "libsql" || options.sqlite === "turso") sv.devDependency("@libsql/client", "^0.17.3");
+		sv.file(".env", generateEnv(options, false));
+		sv.file(".env.example", generateEnv(options, true));
+		if (options.docker && (options.mysql === "mysql2" || options.postgresql === "postgres.js")) {
+			const composeFile = [
+				"compose.yaml",
+				"compose.yml",
+				"docker-compose.yaml",
+				"docker-compose.yml"
+			].find((option) => fs.existsSync(path.resolve(cwd, option))) ?? "compose.yaml";
+			sv.file(composeFile, (content) => {
+				if (content.length > 0) return false;
+				const imageName = options.database === "mysql" ? "mysql" : "postgres";
+				const port = PORTS[options.database];
+				const USER = "root";
+				const PASSWORD = "mysecretpassword";
+				const DB_NAME = "local";
+				let dbSpecificContent = "";
+				if (options.mysql === "mysql2") dbSpecificContent = `
+                      MYSQL_ROOT_PASSWORD: ${PASSWORD}
+                      MYSQL_DATABASE: ${DB_NAME}
+                    volumes:
+                      - mysqldata:/var/lib/mysql
+                volumes:
+                  mysqldata:
+                `;
+				if (options.postgresql === "postgres.js") dbSpecificContent = `
+                      POSTGRES_USER: ${USER}
+                      POSTGRES_PASSWORD: ${PASSWORD}
+                      POSTGRES_DB: ${DB_NAME}
+                    volumes:
+                      - pgdata:/var/lib/postgresql
+                volumes:
+                  pgdata:
+                `;
+				return dedent`
+                services:
+                  db:
+                    image: ${imageName}
+                    restart: always
+                    ports:
+                      - ${port}:${port}
+                    environment: ${dbSpecificContent}
+                `;
+			});
+		}
+		sv.file(file.package, transforms.json(({ data, json }) => {
+			if (options.docker) json.packageScriptsUpsert(data, "db:start", "docker compose up");
+			json.packageScriptsUpsert(data, "db:push", "drizzle-kit push");
+			json.packageScriptsUpsert(data, "db:generate", "drizzle-kit generate");
+			json.packageScriptsUpsert(data, "db:migrate", "drizzle-kit migrate");
+			json.packageScriptsUpsert(data, "db:studio", "drizzle-kit studio");
+		}));
+		if (Boolean(dependencyVersion("prettier"))) sv.file(".prettierignore", transforms.text(({ content, text }) => text.upsert(content, "/drizzle/")));
+		if (options.database === "sqlite") sv.file(file.gitignore, transforms.text(({ content, text }) => {
+			if (content.length === 0) return false;
+			return text.upsert(content, "*.db", { comment: "SQLite" });
+		}));
+		sv.file(paths["drizzle config"], transforms.script(({ ast, js }) => {
+			const d1 = options.database === "d1";
+			const turso = options.sqlite === "turso";
+			js.imports.addNamed(ast, {
+				from: "drizzle-kit",
+				imports: { defineConfig: "defineConfig" }
+			});
+			if (d1) ast.body.push(js.common.parseStatement("if (!process.env.CLOUDFLARE_ACCOUNT_ID) throw new Error('CLOUDFLARE_ACCOUNT_ID is not set');"), js.common.parseStatement("if (!process.env.CLOUDFLARE_DATABASE_ID) throw new Error('CLOUDFLARE_DATABASE_ID is not set');"), js.common.parseStatement("if (!process.env.CLOUDFLARE_D1_TOKEN) throw new Error('CLOUDFLARE_D1_TOKEN is not set');"));
+			else ast.body.push(js.common.parseStatement("if (!process.env.DATABASE_URL) throw new Error('DATABASE_URL is not set');"));
+			const getDialect = () => {
+				if (d1) return "sqlite";
+				if (turso) return "turso";
+				return options.database;
+			};
+			const getCredentials = () => {
+				const creds = [];
+				if (d1) {
+					creds.push("accountId: process.env.CLOUDFLARE_ACCOUNT_ID,");
+					creds.push("databaseId: process.env.CLOUDFLARE_DATABASE_ID,");
+					creds.push("token: process.env.CLOUDFLARE_D1_TOKEN,");
+				}
+				if (turso) creds.push("authToken: process.env.DATABASE_AUTH_TOKEN,");
+				if (!d1) creds.push("url: process.env.DATABASE_URL,");
+				return creds.join("\n");
+			};
+			js.exports.createDefault(ast, { fallback: js.common.parseExpression(`
+					defineConfig({
+						schema: "./${directory.lib}/server/db/schema.${language}",
+						dialect: "${getDialect()}",
+						${d1 ? "driver: 'd1-http'," : ""}
+						dbCredentials: {
+							${getCredentials()}
+						},
+						verbose: true,
+						strict: true
+					})
+				`) });
+		}));
+		if (isKit3(dependencyVersion("@sveltejs/kit"))) {
+			const configFile = language === "ts" ? "tsconfig.json" : "jsconfig.json";
+			if (fileExists(cwd, configFile)) sv.file(configFile, transforms.json(({ data }) => {
+				const include = data.include ??= ["src"];
+				if (!include.includes(`drizzle.config.${language}`)) include.push(`drizzle.config.${language}`);
+			}));
+		} else svelteConfig.edit({
+			sv,
+			cwd
+		}, ({ override, js }) => {
+			override({ typescript: { config: js.common.parseExpression(`(config) => { config.include.push('../drizzle.config.${language}')}`) } });
+		});
+		sv.file(paths["database schema"], transforms.script(({ ast, js }) => {
+			let taskSchemaExpression;
+			if (options.database === "sqlite" || options.database === "d1") {
+				js.imports.addNamed(ast, {
+					from: "drizzle-orm/sqlite-core",
+					imports: [
+						"integer",
+						"sqliteTable",
+						"text"
+					]
+				});
+				taskSchemaExpression = js.common.parseExpression(`sqliteTable('task', {
+				id: text('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+				title: text('title').notNull(),
+				priority: integer('priority').notNull().default(1)
+			})`);
+			}
+			if (options.database === "mysql") {
+				js.imports.addNamed(ast, {
+					from: "drizzle-orm/mysql-core",
+					imports: [
+						"mysqlTable",
+						"serial",
+						"int",
+						"text"
+					]
+				});
+				taskSchemaExpression = js.common.parseExpression(`mysqlTable('task', {
+				id: serial('id').primaryKey(),
+				title: text('title').notNull(),
+				priority: int('priority').notNull().default(1)
+			})`);
+			}
+			if (options.database === "postgresql") {
+				js.imports.addNamed(ast, {
+					from: "drizzle-orm/pg-core",
+					imports: [
+						"pgTable",
+						"serial",
+						"integer",
+						"text"
+					]
+				});
+				taskSchemaExpression = js.common.parseExpression(`pgTable('task', {
+				id: serial('id').primaryKey(),
+				title: text('title').notNull(),
+				priority: integer('priority').notNull().default(1)
+			})`);
+			}
+			if (!taskSchemaExpression) throw new Error("unreachable state...");
+			const taskIdentifier = js.variables.declaration(ast, {
+				kind: "const",
+				name: "task",
+				value: taskSchemaExpression
+			});
+			js.exports.createNamed(ast, {
+				name: "task",
+				fallback: taskIdentifier
+			});
+		}));
+		const env = defineEnv({
+			sv,
+			cwd,
+			dependencyVersion
+		});
+		if (options.database !== "d1") {
+			env.define({
+				name: "DATABASE_URL",
+				description: "The database connection string."
+			});
+			if (options.sqlite === "turso") env.define({
+				name: "DATABASE_AUTH_TOKEN",
+				description: "Auth token for the [Turso](https://turso.tech) database."
+			});
+		}
+		sv.file(paths.database, transforms.script(({ ast, js }) => {
+			if (options.database === "d1") {
+				js.imports.addNamespace(ast, {
+					from: "./schema",
+					as: "schema"
+				});
+				js.imports.addNamed(ast, {
+					from: "drizzle-orm/d1",
+					imports: ["drizzle"]
+				});
+				const getDbFn = js.common.parseStatement(`export const getDb = (d1${ts(": D1Database")}) => drizzle(d1, { schema });`);
+				ast.body.push(getDbFn);
+				return;
+			}
+			const dbUrl = env.reference(ast, js, { name: "DATABASE_URL" });
+			js.imports.addNamespace(ast, {
+				from: "./schema",
+				as: "schema"
+			});
+			ast.body.push(js.common.parseStatement(`if (!${dbUrl}) throw new Error('DATABASE_URL is not set');`));
+			let clientExpression;
+			if (options.sqlite === "better-sqlite3") {
+				js.imports.addDefault(ast, {
+					from: "better-sqlite3",
+					as: "Database"
+				});
+				js.imports.addNamed(ast, {
+					from: "drizzle-orm/better-sqlite3",
+					imports: ["drizzle"]
+				});
+				clientExpression = js.common.parseExpression(`new Database(${dbUrl})`);
+			}
+			if (options.sqlite === "libsql" || options.sqlite === "turso") {
+				js.imports.addNamed(ast, {
+					from: "@libsql/client",
+					imports: ["createClient"]
+				});
+				js.imports.addNamed(ast, {
+					from: "drizzle-orm/libsql",
+					imports: ["drizzle"]
+				});
+				if (options.sqlite === "turso") {
+					const dbToken = env.reference(ast, js, { name: "DATABASE_AUTH_TOKEN" });
+					ast.body.push(js.common.parseStatement(`if (!${dbToken}) throw new Error('DATABASE_AUTH_TOKEN is not set');`));
+					clientExpression = js.common.parseExpression(`createClient({ url: ${dbUrl}, authToken: ${dbToken} })`);
+				} else clientExpression = js.common.parseExpression(`createClient({ url: ${dbUrl} })`);
+			}
+			if (options.sqlite === "node-sqlite") {
+				js.imports.addNamed(ast, {
+					from: "node:sqlite",
+					imports: ["DatabaseSync"]
+				});
+				js.imports.addNamed(ast, {
+					from: "drizzle-orm/node-sqlite",
+					imports: ["drizzle"]
+				});
+				clientExpression = js.common.parseExpression(`new DatabaseSync(${dbUrl})`);
+			}
+			if (options.mysql === "mysql2" || options.mysql === "planetscale") {
+				js.imports.addDefault(ast, {
+					from: "mysql2/promise",
+					as: "mysql"
+				});
+				js.imports.addNamed(ast, {
+					from: "drizzle-orm/mysql2",
+					imports: ["drizzle"]
+				});
+				clientExpression = js.common.parseExpression(`mysql.createPool(${dbUrl})`);
+			}
+			if (options.postgresql === "neon") {
+				js.imports.addNamed(ast, {
+					from: "@neondatabase/serverless",
+					imports: ["neon"]
+				});
+				js.imports.addNamed(ast, {
+					from: "drizzle-orm/neon-http",
+					imports: ["drizzle"]
+				});
+				clientExpression = js.common.parseExpression(`neon(${dbUrl})`);
+			}
+			if (options.postgresql === "postgres.js") {
+				js.imports.addDefault(ast, {
+					from: "postgres",
+					as: "postgres"
+				});
+				js.imports.addNamed(ast, {
+					from: "drizzle-orm/postgres-js",
+					imports: ["drizzle"]
+				});
+				clientExpression = js.common.parseExpression(`postgres(${dbUrl})`);
+			}
+			if (!clientExpression) throw new Error("unreachable state...");
+			ast.body.push(js.variables.declaration(ast, {
+				kind: "const",
+				name: "client",
+				value: clientExpression
+			}));
+			const drizzleCall = js.functions.createCall({
+				name: "drizzle",
+				args: ["client"],
+				useIdentifiers: true
+			});
+			const paramObject = js.object.create({ schema: js.variables.createIdentifier("schema") });
+			if (options.database === "mysql") {
+				const mode = options.mysql === "planetscale" ? "planetscale" : "default";
+				js.object.property(paramObject, {
+					name: "mode",
+					fallback: js.common.createLiteral(mode)
+				});
+			}
+			drizzleCall.arguments.push(paramObject);
+			const db = js.variables.declaration(ast, {
+				kind: "const",
+				name: "db",
+				value: drizzleCall
+			});
+			js.exports.createNamed(ast, {
+				name: "db",
+				fallback: db
+			});
+		}));
+	},
+	nextSteps: ({ options, packageManager, cwd, dependencyVersion }) => {
+		const pm = (command, args) => color.command(resolveCommandArray(packageManager, command, args));
+		const steps = [];
+		if (options.database === "d1") {
+			if (!dependencyVersion("@sveltejs/adapter-cloudflare")) steps.push(`Cloudflare D1 requires ${color.addon("@sveltejs/adapter-cloudflare")}. Run ${pm("execute", [
+				"sv",
+				"add",
+				"sveltekit-adapter=adapter:cloudflare"
+			])} to add it`);
+			steps.push(`Add your ${color.env("CLOUDFLARE_ACCOUNT_ID")}, ${color.env("CLOUDFLARE_DATABASE_ID")}, and ${color.env("CLOUDFLARE_D1_TOKEN")} to ${color.path(".env")}`);
+			const ext = fileExists(cwd, "wrangler.toml") ? "toml" : "jsonc";
+			steps.push(`Run ${pm("execute-local", [
+				"wrangler",
+				"d1",
+				"create",
+				"<DATABASE_NAME>"
+			])} to generate a D1 database ID for your ${color.path(`wrangler.${ext}`)}`);
+		}
+		if (options.docker) steps.push(`Run ${pm("run", ["db:start"])} to start the docker container`);
+		else if (options.database !== "d1") steps.push(`Check ${color.env("DATABASE_URL")} in ${color.path(".env")} and adjust it to your needs`);
+		steps.push(`Run ${pm("run", ["db:push"])} to update your database schema`);
+		return steps;
+	}
+});
+const generateEnv = (opts, isExample) => transforms.text(({ content, text }) => {
+	const DB_URL_KEY = "DATABASE_URL";
+	if (opts.database === "d1") {
+		content = text.upsert(content, "CLOUDFLARE_ACCOUNT_ID", {
+			value: "\"\"",
+			comment: ["Cloudflare D1"],
+			separator: true
+		});
+		content = text.upsert(content, "CLOUDFLARE_DATABASE_ID", { value: "\"\"" });
+		content = text.upsert(content, "CLOUDFLARE_D1_TOKEN", { value: "\"\"" });
+		return content;
+	}
+	let value;
+	const comment = ["Drizzle"];
+	if (opts.docker) value = `"${opts.database === "mysql" ? "mysql" : "postgres"}://root:mysecretpassword@localhost:${PORTS[opts.database]}/local"`;
+	else if ([
+		"better-sqlite3",
+		"libsql",
+		"node-sqlite"
+	].includes(opts.sqlite)) value = opts.sqlite === "libsql" ? "file:local.db" : "local.db";
+	else if (opts.sqlite === "turso") if (isExample) {
+		value = "\"libsql://db-name-user.turso.io\"";
+		comment.push("Replace with your DB credentials!", {
+			text: "A local DB can also be used in dev as well",
+			mode: "append"
+		}, {
+			text: `${DB_URL_KEY}="file:local.db"`,
+			mode: "append"
+		});
+	} else {
+		value = "\"file:local.db\"";
+		comment.push("Replace with your DB credentials!", `${DB_URL_KEY}="libsql://db-name-user.turso.io"`, "A local DB can also be used in dev as well");
+	}
+	else if (opts.database === "mysql") {
+		value = "\"mysql://user:password@host:port/db-name\"";
+		comment.push("Replace with your DB credentials!");
+	} else if (opts.database === "postgresql") {
+		value = "\"postgres://user:password@host:port/db-name\"";
+		comment.push("Replace with your DB credentials!");
+	} else value = "";
+	content = text.upsert(content, DB_URL_KEY, {
+		value,
+		comment,
+		separator: true
+	});
+	if (opts.sqlite === "turso") content = text.upsert(content, "DATABASE_AUTH_TOKEN", { value: isExample ? `""` : `"${crypto.randomUUID()}"` });
+	return content;
+});
+//#endregion
+//#region src/addons/eslint.ts
+var eslint_default = defineAddon({
+	id: "eslint",
+	shortDescription: "linter",
+	homepage: "https://eslint.org",
+	options: {},
+	run: ({ sv, language, dependencyVersion, file, cwd }) => {
+		const typescript = language === "ts";
+		const prettierInstalled = Boolean(dependencyVersion("prettier"));
+		const configLocation = svelteConfig.find(cwd);
+		const svelteConfigFile = configLocation?.kind === "svelte" ? configLocation.path : void 0;
+		sv.devDependency("eslint", ESLINT_VERSION);
+		sv.devDependency("eslint-plugin-svelte", "^3.19.0");
+		sv.devDependency("globals", "^17.6.0");
+		sv.devDependency("@eslint/js", "^10.0.1");
+		sv.devDependency("@types/node", getNodeTypesVersion());
+		if (typescript) sv.devDependency("typescript-eslint", "^8.60.1");
+		if (prettierInstalled) sv.devDependency("eslint-config-prettier", "^10.1.8");
+		sv.file(file.package, transforms.json(({ data, json }) => {
+			json.packageScriptsUpsert(data, "lint", "eslint .");
+		}));
+		sv.file("eslint.config.js", transforms.script(({ ast, comments, js }) => {
+			const eslintConfigs = [];
+			if (svelteConfigFile) js.imports.addDefault(ast, {
+				from: `./${svelteConfigFile}`,
+				as: "svelteConfig"
+			});
+			const gitIgnorePathStatement = js.common.parseStatement("\nconst gitignorePath = path.resolve(import.meta.dirname, '.gitignore');");
+			js.common.appendStatement(ast, { statement: gitIgnorePathStatement });
+			const ignoresConfig = js.common.parseExpression("includeIgnoreFile(gitignorePath)");
+			eslintConfigs.push(ignoresConfig);
+			const jsConfig = js.common.parseExpression("js.configs.recommended");
+			eslintConfigs.push(jsConfig);
+			if (typescript) {
+				const tsConfig = js.common.parseExpression("ts.configs.recommended");
+				eslintConfigs.push(tsConfig);
+			}
+			const svelteConfig = js.common.parseExpression("svelte.configs.recommended");
+			eslintConfigs.push(svelteConfig);
+			const globalsBrowser = js.common.createSpread(js.common.parseExpression("globals.browser"));
+			const globalsNode = js.common.createSpread(js.common.parseExpression("globals.node"));
+			const globalsObjLiteral = js.object.create({});
+			globalsObjLiteral.properties = [globalsBrowser, globalsNode];
+			const rules = js.object.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 = js.object.create({
+				languageOptions: { globals: globalsObjLiteral },
+				rules: typescript ? rules : void 0
+			});
+			eslintConfigs.push(globalsConfig);
+			const svelteConfigProp = svelteConfigFile ? { svelteConfig: js.variables.createIdentifier("svelteConfig") } : {};
+			if (typescript) {
+				const svelteTSParserConfig = js.object.create({
+					files: [
+						"**/*.svelte",
+						"**/*.svelte.ts",
+						"**/*.svelte.js"
+					],
+					languageOptions: { parserOptions: {
+						projectService: true,
+						extraFileExtensions: [".svelte"],
+						parser: js.variables.createIdentifier("ts.parser"),
+						...svelteConfigProp
+					} }
+				});
+				eslintConfigs.push(svelteTSParserConfig);
+			} else {
+				const svelteTSParserConfig = js.object.create({
+					files: ["**/*.svelte", "**/*.svelte.js"],
+					languageOptions: { parserOptions: { ...svelteConfigProp } }
+				});
+				eslintConfigs.push(svelteTSParserConfig);
+			}
+			const rulesOverride = js.object.create({ rules: {} });
+			eslintConfigs.push(rulesOverride);
+			if (rulesOverride.properties[0].type !== "Property") throw new Error("rulesOverride.properties[0].type !== \"Property\"");
+			comments.add(rulesOverride.properties[0].key, {
+				type: "Line",
+				value: " Override or add rule settings here, such as:"
+			});
+			comments.add(rulesOverride.properties[0].key, {
+				type: "Line",
+				value: " 'svelte/button-has-type': 'error'"
+			});
+			const exportExpression = js.functions.createCall({
+				name: "defineConfig",
+				args: []
+			});
+			if (typescript) exportExpression.arguments.push(...eslintConfigs);
+			else {
+				const eslintArray = js.array.create();
+				eslintConfigs.map((x) => js.array.append(eslintArray, x));
+				exportExpression.arguments.push(eslintArray);
+			}
+			const { value: defaultExport } = js.exports.createDefault(ast, { fallback: exportExpression });
+			if (defaultExport !== exportExpression) {
+				R.warn("An eslint config is already defined. Skipping initialization.");
+				return false;
+			}
+			if (typescript) js.imports.addDefault(ast, {
+				from: "typescript-eslint",
+				as: "ts"
+			});
+			js.imports.addDefault(ast, {
+				from: "globals",
+				as: "globals"
+			});
+			js.imports.addNamed(ast, {
+				from: "eslint/config",
+				imports: ["defineConfig"]
+			});
+			js.imports.addDefault(ast, {
+				from: "eslint-plugin-svelte",
+				as: "svelte"
+			});
+			js.imports.addDefault(ast, {
+				from: "@eslint/js",
+				as: "js"
+			});
+			js.imports.addNamed(ast, {
+				from: "eslint/config",
+				imports: ["includeIgnoreFile"]
+			});
+			js.imports.addDefault(ast, {
+				from: "node:path",
+				as: "path"
+			});
+		}));
+		sv.file(".vscode/extensions.json", transforms.json(({ data, json }) => {
+			json.arrayUpsert(data, "recommendations", "dbaeumer.vscode-eslint");
+		}));
+		if (prettierInstalled) sv.file("eslint.config.js", addEslintConfigPrettier);
+	}
+});
+//#endregion
+//#region src/addons/experimental.ts
+const FEATURES = {
+	async: {
+		label: "async",
+		hint: "await in components",
+		path: "compilerOptions.experimental.async"
+	},
+	remoteFunctions: { label: "remote functions" },
+	forkPreloads: {
+		label: "forked preloading",
+		off: true
+	}
+};
+var experimental_default = defineAddon({
+	id: "experimental",
+	shortDescription: "svelte & kit experimental features",
+	homepage: "https://svelte.dev/docs/kit/configuration#experimental",
+	options: defineAddonOptions().add("features", {
+		question: "Which experimental features do you want to enable?",
+		type: "multiselect",
+		default: Object.entries(FEATURES).filter(([, f]) => !f.off).map(([value]) => value),
+		options: Object.entries(FEATURES).map(([value, { label, hint }]) => ({
+			value,
+			label,
+			hint
+		})),
+		required: false
+	}).build(),
+	run: ({ sv, cwd, options }) => {
+		const config = {};
+		for (const [name, f] of Object.entries(FEATURES)) {
+			if (!options.features.includes(name)) continue;
+			const keys = (f.path ?? `experimental.${name}`).split(".");
+			let target = config;
+			for (const key of keys.slice(0, -1)) target = target[key] ??= {};
+			target[keys.at(-1)] = true;
+		}
+		if (Object.keys(config).length) svelteConfig.edit({
+			sv,
+			cwd
+		}, ({ override }) => override(config));
+	}
+});
+//#endregion
+//#region src/addons/mdsvex.ts
+var mdsvex_default = defineAddon({
+	id: "mdsvex",
+	shortDescription: "svelte + markdown",
+	homepage: "https://mdsvex.pngwn.io",
+	options: {},
+	run: ({ sv, cwd }) => {
+		sv.devDependency("mdsvex", "^0.12.7");
+		svelteConfig.edit({
+			sv,
+			cwd
+		}, ({ ast, property, override, js }) => {
+			js.imports.addNamed(ast, {
+				from: "mdsvex",
+				imports: ["mdsvex"]
+			});
+			let preprocessorArray = property("preprocess", { fallback: js.array.create() });
+			if (!(preprocessorArray.type === "ArrayExpression")) {
+				const previousElement = preprocessorArray;
+				preprocessorArray = js.array.create();
+				js.array.append(preprocessorArray, previousElement);
+				override({ preprocess: preprocessorArray });
+			}
+			const mdsvexCall = js.functions.createCall({
+				name: "mdsvex",
+				args: []
+			});
+			mdsvexCall.arguments.push(js.object.create({ extensions: [".svx", ".md"] }));
+			js.array.append(preprocessorArray, mdsvexCall);
+			const extensionsArray = property("extensions", { fallback: js.array.create() });
+			js.array.append(extensionsArray, ".svelte");
+			js.array.append(extensionsArray, ".svx");
+			js.array.append(extensionsArray, ".md");
+		});
+	}
+});
+//#endregion
+//#region src/addons/paraglide.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$3 = defineAddonOptions().add("languageTags", {
+	question: `Which languages would you like to support? ${color.optional("(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$3,
+	setup: ({ isKit, unsupported, runsAfter }) => {
+		if (!isKit) unsupported("Requires SvelteKit");
+		runsAfter("experimental");
+	},
+	run: ({ sv, options, file, language, directory, dependencyVersion }) => {
+		const [ts] = createPrinter(language === "ts");
+		const kitRange = dependencyVersion("@sveltejs/kit");
+		const lib = resolveLibPrefix(kitRange);
+		const pathType = isKit3(kitRange) ? "Path" : "Pathname";
+		const paraglideOutDir = `${directory.lib}/paraglide`;
+		sv.devDependency("@inlang/paraglide-js", "^2.18.2");
+		sv.file(file.viteConfig, transforms.script(({ ast, js }) => {
+			const vitePluginName = "paraglideVitePlugin";
+			js.imports.addNamed(ast, {
+				imports: [vitePluginName],
+				from: "@inlang/paraglide-js"
+			});
+			js.vite.addPlugin(ast, { code: `${vitePluginName}({
+					project: './project.inlang',
+					outdir: './${paraglideOutDir}',
+					emitTsDeclarations: true
+				})` });
+		}));
+		sv.file(`src/hooks.${language}`, transforms.script(({ ast, comments, js }) => {
+			js.imports.addNamed(ast, {
+				from: `${lib}/paraglide/runtime.js`,
+				imports: ["deLocalizeUrl"]
+			});
+			const expression = js.common.parseExpression("(request) => deLocalizeUrl(request.url).pathname");
+			const rerouteIdentifier = js.variables.declaration(ast, {
+				kind: "const",
+				name: `reroute${language === "ts" ? ": Reroute" : ""}`,
+				value: expression
+			});
+			const existingExport = js.exports.createNamed(ast, {
+				name: "reroute",
+				fallback: rerouteIdentifier
+			});
+			if (existingExport.declaration !== rerouteIdentifier) R.warn("Adding the reroute hook automatically failed. Add it manually");
+			if (language === "ts") js.imports.addNamed(ast, {
+				from: "@sveltejs/kit/hooks",
+				imports: ["Reroute"],
+				isType: true
+			});
+			else js.common.addJsDocTypeComment(existingExport, comments, { type: "import('@sveltejs/kit/hooks').Reroute" });
+		}));
+		sv.file(`src/hooks.server.${language}`, transforms.script(({ ast, comments, js }) => {
+			js.imports.addNamed(ast, {
+				from: `${lib}/paraglide/server.js`,
+				imports: ["paraglideMiddleware"]
+			});
+			js.imports.addNamed(ast, {
+				from: `${lib}/paraglide/runtime.js`,
+				imports: ["getTextDirection"]
+			});
+			js.kit.addHooksHandle(ast, {
+				language,
+				newHandleName: "handleParaglide",
+				handleContent: `({ event, resolve }) => paraglideMiddleware(event.request, ({ request, locale }) => {
+		return resolve({ ...event, request }, {
+			transformPageChunk: ({ html }) => html.replace('%paraglide.lang%', locale).replace('%paraglide.dir%', getTextDirection(locale))
+		});
+	});`,
+				comments
+			});
+		}));
+		sv.file("src/app.html", transforms.html(({ ast, html }) => {
+			const htmlNode = ast.nodes.find((child) => child.type === "RegularElement" && child.name === "html");
+			if (!htmlNode) {
+				R.warn("Could not find <html> node in app.html. You'll need to add the language placeholder manually");
+				return false;
+			}
+			html.addAttribute(htmlNode, "lang", "%paraglide.lang%");
+			html.addAttribute(htmlNode, "dir", "%paraglide.dir%");
+		}));
+		sv.file(file.gitignore, transforms.text(({ content, text }) => {
+			if (!content) return false;
+			content = text.upsert(content, paraglideOutDir, { comment: "Paraglide" });
+			content = text.upsert(content, "project.inlang/cache/");
+			return content;
+		}));
+		sv.file("project.inlang/settings.json", transforms.json(({ data }) => {
+			if (Object.keys(data).length > 0) return false;
+			for (const key in DEFAULT_INLANG_PROJECT) data[key] = DEFAULT_INLANG_PROJECT[key];
+			const { validLanguageTags } = parseLanguageTagInput(options.languageTags);
+			data.baseLocale = validLanguageTags[0];
+			data.locales = validLanguageTags;
+		}));
+		sv.file(`${directory.kitRoutes}/+layout.svelte`, transforms.svelteScript({ language }, ({ ast, svelte, js }) => {
+			js.imports.addNamed(ast.instance.content, {
+				imports: ["locales", "localizeHref"],
+				from: `${lib}/paraglide/runtime.js`
+			});
+			js.imports.addNamed(ast.instance.content, {
+				imports: ["page"],
+				from: "$app/state"
+			});
+			js.imports.addNamed(ast.instance.content, {
+				imports: ["resolve"],
+				from: "$app/paths"
+			});
+			if (language === "ts") js.imports.addNamed(ast.instance.content, {
+				imports: [pathType],
+				from: "$app/types",
+				isType: true
+			});
+			svelte.addFragment(ast, dedent`
+						<div style="display:none">
+							{#each locales as locale (locale)}
+								<a href={resolve(localizeHref(page.url.pathname, { locale })${ts(` as ${pathType}`)})}>{locale}</a>
+							{/each}
+						</div>`, { language });
+		}));
+		if (options.demo) {
+			sv.file(`${directory.kitRoutes}/demo/+page.svelte`, addToDemoPage("paraglide", language));
+			sv.file(`${directory.kitRoutes}/demo/paraglide/+page.svelte`, transforms.svelteScript({ language }, ({ ast, svelte, js }) => {
+				js.imports.addNamed(ast.instance.content, {
+					imports: { m: "m" },
+					from: `${lib}/paraglide/messages.js`
+				});
+				js.imports.addNamed(ast.instance.content, {
+					imports: { setLocale: "setLocale" },
+					from: `${lib}/paraglide/runtime.js`
+				});
+				let templateCode = "<h1>{m.hello_world({ name: 'SvelteKit User' })}</h1>";
+				const { validLanguageTags } = parseLanguageTagInput(options.languageTags);
+				const links = validLanguageTags.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>";
+				svelte.addFragment(ast, templateCode);
+			}));
+		}
+		const { validLanguageTags } = parseLanguageTagInput(options.languageTags);
+		for (const languageTag of validLanguageTags) sv.file(`messages/${languageTag}.json`, transforms.json(({ data }) => {
+			data["$schema"] = "https://inlang.com/schema/inlang-message-format";
+			data.hello_world = `Hello, {name} from ${languageTag}!`;
+		}));
+	},
+	nextSteps: () => [`Edit your messages in ${color.path("messages/en.json")}`, options$3.demo && `Visit ${color.route("/demo/paraglide")} route to view the demo`].filter((line) => Boolean(line))
+});
+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 src/addons/playwright.ts
+var playwright_default = defineAddon({
+	id: "playwright",
+	shortDescription: "browser testing",
+	homepage: "https://playwright.dev",
+	options: {},
+	run: ({ sv, language, file, isKit, directory }) => {
+		sv.devDependency("@playwright/test", "^1.60.0");
+		sv.file(file.package, transforms.json(({ data, json }) => {
+			json.packageScriptsUpsert(data, "test:e2e", "playwright test");
+			json.packageScriptsUpsert(data, "test:e2e", "playwright install", { mode: "prepend" });
+			json.packageScriptsUpsert(data, "test", "npm run test:e2e");
+		}));
+		sv.file(file.gitignore, transforms.text(({ content, text }) => {
+			if (!content) return false;
+			return text.upsert(content, "test-results", { comment: "Playwright" });
+		}));
+		const testDir = isKit ? `${directory.kitRoutes}/demo/playwright` : directory.src;
+		const testRoute = isKit ? "/demo/playwright" : "/";
+		if (isKit) {
+			sv.file(`${directory.kitRoutes}/demo/+page.svelte`, addToDemoPage("playwright", language));
+			sv.file(`${testDir}/+page.svelte`, transforms.text(({ content }) => {
+				if (content) return false;
+				return dedent`
+						<h1>Playwright e2e test demo</h1>
+					`;
+			}));
+		}
+		sv.file(`${testDir}/${isKit ? "page" : "app"}.svelte.e2e.${language}`, transforms.text(({ content }) => {
+			if (content) return false;
+			return dedent`
+					import { expect, test } from '@playwright/test';
+
+					test('has expected h1', async ({ page }) => {
+						await page.goto('${testRoute}');
+						await expect(page.locator('h1')).toBeVisible();
+					});
+				`;
+		}));
+		sv.file(`playwright.config.${language}`, transforms.script(({ ast, js }) => {
+			const defineConfig = js.common.parseExpression("defineConfig({})");
+			const { value: defaultExport } = js.exports.createDefault(ast, { fallback: defineConfig });
+			const config = {
+				webServer: {
+					command: "npm run build && npm run preview",
+					port: 4173
+				},
+				testMatch: "**/*.e2e.{ts,js}"
+			};
+			if (defaultExport.type === "CallExpression" && defaultExport.arguments[0]?.type === "ObjectExpression") {
+				js.imports.addNamed(ast, {
+					imports: ["defineConfig"],
+					from: "@playwright/test"
+				});
+				js.object.overrideProperties(defaultExport.arguments[0], config);
+			} else if (defaultExport.type === "ObjectExpression") js.object.overrideProperties(defaultExport, config);
+			else R.warn("Unexpected playwright config for playwright add-on. Could not update.");
+		}));
+	},
+	nextSteps: ({ isKit, packageManager }) => {
+		const steps = [];
+		steps.push(`Run ${color.command(resolveCommandArray(packageManager, "execute-local", ["playwright", "install"]))} to download browsers`);
+		if (isKit) steps.push(`Visit ${color.route("/demo/playwright")} to see the demo page`);
+		steps.push(`Run ${color.command(resolveCommandArray(packageManager, "run", ["test:e2e"]))} to execute the example tests`);
+		return steps;
+	}
+});
+//#endregion
+//#region src/addons/prettier.ts
+var prettier_default = defineAddon({
+	id: "prettier",
+	shortDescription: "formatter",
+	homepage: "https://prettier.io",
+	options: {},
+	run: ({ sv, dependencyVersion, file }) => {
+		const tailwindcssInstalled = Boolean(dependencyVersion("tailwindcss"));
+		if (tailwindcssInstalled) sv.devDependency("prettier-plugin-tailwindcss", "^0.8.0");
+		sv.devDependency("prettier", "^3.8.3");
+		sv.devDependency("prettier-plugin-svelte", "^4.1.0");
+		sv.file(".prettierignore", transforms.text(({ content }) => {
+			if (content) return false;
+			return dedent`
+					# Package Managers
+					package-lock.json
+					pnpm-lock.yaml
+					yarn.lock
+					bun.lock
+					bun.lockb
+
+					# Miscellaneous
+					/static/
+				`;
+		}));
+		sv.file(prettierConfigPath(), createPrettierConfig({
+			tailwind: tailwindcssInstalled,
+			stylesheet: tailwindcssInstalled ? file.getRelative({ to: file.stylesheet }) : void 0
+		}));
+		const eslintInfo = checkEslint(dependencyVersion("eslint"));
+		sv.file(file.package, transforms.json(({ data, json }) => {
+			json.packageScriptsUpsert(data, "lint", "prettier --check .", { mode: "prepend" });
+			json.packageScriptsUpsert(data, "format", "prettier --write .");
+		}));
+		sv.file(".vscode/extensions.json", transforms.json(({ data, json }) => {
+			json.arrayUpsert(data, "recommendations", "esbenp.prettier-vscode");
+		}));
+		if (eslintInfo.installed && !eslintInfo.supported) R.warn(`An unsupported major version of ${color.warning("eslint")} was detected. Skipping ${color.warning("eslint-config-prettier")} installation.`);
+		if (eslintInfo.supported) {
+			sv.devDependency("eslint-config-prettier", "^10.1.8");
+			sv.file("eslint.config.js", addEslintConfigPrettier);
+		}
+	}
+});
+function checkEslint(version) {
+	if (!version) return {
+		installed: false,
+		supported: false
+	};
+	const supportedMajor = coerceVersion(ESLINT_VERSION).major;
+	return {
+		installed: true,
+		supported: coerceVersion(version).major === supportedMajor
+	};
+}
+//#endregion
+//#region src/addons/storybook.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 (V.env.NODE_ENV?.toLowerCase() === "test") args.push(...["--no-features", "--yes"]);
+		await sv.execute(args, "inherit");
+		sv.devDependency(`@types/node`, getNodeTypesVersion());
+	}
+});
+//#endregion
+//#region src/addons/sveltekit-adapter.ts
+const adapters = [
+	{
+		id: "auto",
+		package: "@sveltejs/adapter-auto",
+		version: "^8.0.0-next.3"
+	},
+	{
+		id: "node",
+		package: "@sveltejs/adapter-node",
+		version: "^6.0.0-next.10"
+	},
+	{
+		id: "static",
+		package: "@sveltejs/adapter-static",
+		version: "^4.0.0-next.4"
+	},
+	{
+		id: "vercel",
+		package: "@sveltejs/adapter-vercel",
+		version: "^7.0.0-next.6"
+	},
+	{
+		id: "cloudflare",
+		package: "@sveltejs/adapter-cloudflare",
+		version: "^8.0.0-next.6"
+	},
+	{
+		id: "netlify",
+		package: "@sveltejs/adapter-netlify",
+		version: "^7.0.0-next.8"
+	}
+];
+var sveltekit_adapter_default = defineAddon({
+	id: "sveltekit-adapter",
+	alias: "adapter",
+	shortDescription: "deployment",
+	homepage: "https://svelte.dev/docs/kit/adapters",
+	options: 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) => options.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(),
+	setup: ({ isKit, unsupported }) => {
+		if (!isKit) unsupported("Requires SvelteKit");
+	},
+	run: ({ sv, options, packageManager, file, cwd }) => {
+		const adapter = adapters.find((a) => a.id === options.adapter);
+		sv.file(file.package, transforms.json(({ data }) => {
+			const devDeps = data["devDependencies"];
+			for (const pkg of Object.keys(devDeps)) if (pkg.startsWith("@sveltejs/adapter-")) delete devDeps[pkg];
+			if (options.adapter === "cloudflare") {
+				const preview = options.cfTarget === "workers" ? "wrangler dev .svelte-kit/cloudflare/_worker.js --port 4173" : "wrangler pages dev .svelte-kit/cloudflare --port 4173";
+				data.scripts.preview = preview;
+			}
+		}));
+		sv.devDependency(adapter.package, adapter.version);
+		svelteConfig.edit({
+			sv,
+			cwd
+		}, ({ ast, override, js }) => {
+			const adapterImports = 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 (adapterImports) {
+				adapterImports.source.value = adapter.package;
+				adapterImports.source.raw = void 0;
+				adapterName = (adapterImports.specifiers?.find((s) => s.type === "ImportDefaultSpecifier")).local.name;
+			} else js.imports.addDefault(ast, {
+				from: adapter.package,
+				as: adapterName
+			});
+			override({ adapter: js.functions.createCall({
+				name: adapterName,
+				args: [],
+				useIdentifiers: true
+			}) }, adapter.package === "@sveltejs/adapter-auto" ? void 0 : { dropLeadingComments: ["adapter"] });
+		});
+		if (adapter.package === "@sveltejs/adapter-cloudflare") {
+			sv.devDependency("wrangler", "^4.97.0");
+			if (packageManager === "pnpm") sv.file(file.findUp("pnpm-workspace.yaml"), pnpm.allowBuilds("workerd"));
+			const ext = fileExists(cwd, "wrangler.toml") ? "toml" : "jsonc";
+			const applyWranglerConfig = (data) => {
+				if (ext === "jsonc") data.$schema ??= "./node_modules/wrangler/config-schema.json";
+				if (!data.name) data.name = sanitizeName(loadPackageJson(cwd).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.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;
+				}
+			};
+			sv.file(`wrangler.${ext}`, ext === "toml" ? transforms.toml(({ data }) => applyWranglerConfig(data)) : transforms.json(({ data }) => applyWranglerConfig(data)));
+			if (file.typeConfig) {
+				sv.file(file.package, transforms.json(({ data, json }) => {
+					json.packageScriptsUpsert(data, "gen", "wrangler types");
+					json.packageScriptsUpsert(data, "check", "wrangler types --check", { mode: "prepend" });
+					json.packageScriptsUpsert(data, "build", "wrangler types --check", { mode: "prepend" });
+				}));
+				sv.file(file.typeConfig, transforms.json(({ data }) => {
+					data.compilerOptions ??= {};
+					data.compilerOptions.types ??= [];
+					data.compilerOptions.types.push("./worker-configuration.d.ts");
+				}));
+				sv.file("src/app.d.ts", transforms.script(({ ast, comments, js }) => {
+					const platform = js.kit.addGlobalAppInterface(ast, { name: "Platform" });
+					if (!platform) throw new Error("Failed detecting `platform` interface in `src/app.d.ts`");
+					comments.remove((c) => c.type === "Line" && c.value.trim() === "interface Platform {}");
+					platform.body.body.push(js.common.createTypeProperty("env", "Env"), js.common.createTypeProperty("ctx", "ExecutionContext"), js.common.createTypeProperty("caches", "CacheStorage"), js.common.createTypeProperty("cf", "IncomingRequestCfProperties", true));
+				}));
+			}
+		}
+	},
+	nextSteps({ options, packageManager }) {
+		const steps = [];
+		if (options.adapter === "cloudflare") steps.push(`Run ${color.command(resolveCommandArray(packageManager, "run", ["gen"]))} to update ${color.addon("cloudflare")} types`);
+		return steps;
+	}
+});
+//#endregion
+//#region src/addons/tailwindcss.ts
+const plugins = [{
+	id: "typography",
+	package: "@tailwindcss/typography",
+	version: "^0.5.19"
+}, {
+	id: "forms",
+	package: "@tailwindcss/forms",
+	version: "^0.5.11"
+}];
+var tailwindcss_default = defineAddon({
+	id: "tailwindcss",
+	alias: "tailwind",
+	shortDescription: "css framework",
+	homepage: "https://tailwindcss.com",
+	options: 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(),
+	run: ({ sv, options, file, isKit, directory, dependencyVersion, language }) => {
+		const prettierInstalled = Boolean(dependencyVersion("prettier"));
+		sv.devDependency("tailwindcss", "^4.3.0");
+		sv.devDependency("@tailwindcss/vite", "^4.3.0");
+		if (prettierInstalled) sv.devDependency("prettier-plugin-tailwindcss", "^0.8.0");
+		for (const plugin of plugins) {
+			if (!options.plugins.includes(plugin.id)) continue;
+			sv.devDependency(plugin.package, plugin.version);
+		}
+		sv.file(file.viteConfig, transforms.script(({ ast, js }) => {
+			const vitePluginName = "tailwindcss";
+			js.imports.addDefault(ast, {
+				as: vitePluginName,
+				from: "@tailwindcss/vite"
+			});
+			js.vite.addPlugin(ast, {
+				code: `${vitePluginName}()`,
+				mode: "prepend"
+			});
+		}));
+		sv.file(file.stylesheet, transforms.css(({ ast, css }) => {
+			for (const plugin of plugins) {
+				if (!options.plugins.includes(plugin.id)) continue;
+				css.addAtRule(ast, {
+					name: "plugin",
+					params: `'${plugin.package}'`,
+					append: false
+				});
+			}
+			css.addAtRule(ast, {
+				name: "import",
+				params: `'tailwindcss'`,
+				append: false
+			});
+		}));
+		if (isKit) {
+			const layoutSvelte = `${directory.kitRoutes}/+layout.svelte`;
+			const stylesheetRelative = file.getRelative({
+				from: layoutSvelte,
+				to: file.stylesheet
+			});
+			sv.file(layoutSvelte, transforms.svelteScript({ language }, ({ ast, svelte, js }) => {
+				js.imports.addEmpty(ast.instance.content, { from: stylesheetRelative });
+				if (ast.fragment.nodes.length === 0) {
+					const svelteVersion = dependencyVersion("svelte");
+					if (!svelteVersion) throw new Error("Failed to determine svelte version");
+					svelte.addSlot(ast, { svelteVersion });
+				}
+			}));
+		} else {
+			const appSvelte = `${directory.src}/App.svelte`;
+			const stylesheetRelative = file.getRelative({
+				from: appSvelte,
+				to: file.stylesheet
+			});
+			sv.file(appSvelte, transforms.svelteScript({ language }, ({ ast, js }) => {
+				js.imports.addEmpty(ast.instance.content, { from: stylesheetRelative });
+			}));
+		}
+		sv.file(".vscode/settings.json", transforms.json(({ data }) => {
+			data["files.associations"] ??= {};
+			data["files.associations"]["*.css"] = "tailwindcss";
+		}));
+		sv.file(".vscode/extensions.json", transforms.json(({ data, json }) => {
+			json.arrayUpsert(data, "recommendations", "bradlc.vscode-tailwindcss");
+		}));
+		if (prettierInstalled) sv.file(prettierConfigPath(), addPrettierTailwind({ stylesheet: file.getRelative({ to: file.stylesheet }) }));
+	}
+});
+//#endregion
+//#region src/addons/vitest-addon.ts
+var _templateObject;
+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;
+//#endregion
+//#region src/addons/index.ts
+const officialAddons = {
+	prettier: prettier_default,
+	eslint: eslint_default,
+	vitest: defineAddon({
+		id: "vitest",
+		shortDescription: "unit testing",
+		homepage: "https://vitest.dev",
+		options,
+		run: ({ sv, file, language, directory, options, dependencyVersion }) => {
+			const unitTesting = options.usages.includes("unit");
+			const componentTesting = options.usages.includes("component");
+			const vitestVersion = dependencyVersion("vitest");
+			if (vitestVersion) vitestV3Installed = coerceVersion(vitestVersion).major === 3;
+			sv.devDependency("vitest", "^4.1.8");
+			if (componentTesting) {
+				sv.devDependency("@vitest/browser-playwright", "^4.1.8");
+				sv.devDependency("vitest-browser-svelte", "^2.1.1");
+				sv.devDependency("playwright", "^1.60.0");
+			}
+			sv.file(file.package, transforms.json(({ data, json }) => {
+				json.packageScriptsUpsert(data, "test:unit", "vitest");
+				json.packageScriptsUpsert(data, "test", "npm run test:unit -- --run", { mode: "prepend" });
+			}));
+			const examplesDir = `${directory.lib}/vitest-examples`;
+			const [ts] = createPrinter(language === "ts");
+			if (unitTesting || componentTesting) sv.file(`${examplesDir}/greet.${language}`, transforms.text(({ content }) => {
+				if (content) return false;
+				return dedent`
+						export function greet(name${ts(": string")})${ts(": string")} {
+							return 'Hello, ' + name + '!';
+						}
+					`;
+			}));
+			if (unitTesting) sv.file(`${examplesDir}/greet.spec.${language}`, transforms.text(({ content }) => {
+				if (content) return false;
+				return dedent`
+						import { describe, it, expect } from 'vitest';
+						import { greet } from './greet';
+
+						describe('greet', () => {
+							it('returns a greeting', () => {
+								expect(greet('Svelte')).toBe('Hello, Svelte!');
+							});
+						});
+					`;
+			}));
+			if (componentTesting) {
+				sv.file(`${examplesDir}/Welcome.svelte`, transforms.text(({ content }) => {
+					if (content) return false;
+					return dedent(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n						<script>\n							import { greet } from './greet';\n\n							let { host = 'SvelteKit', guest = 'Vitest' } = $props();\n						<\/script>\n\n						<h1>{greet(host)}</h1>\n						<p>{greet(guest)}</p>\n					"])));
+				}));
+				sv.file(`${examplesDir}/Welcome.svelte.spec.${language}`, transforms.text(({ content }) => {
+					if (content) return false;
+					return dedent`
+						import { page } from 'vitest/browser';
+						import { describe, expect, it } from 'vitest';
+						import { render } from 'vitest-browser-svelte';
+						import Welcome from './Welcome.svelte';
+
+						describe('Welcome.svelte', () => {
+							it('renders greetings for host and guest', async () => {
+								render(Welcome, { host: 'SvelteKit', guest: 'Vitest' });
+
+								await expect.element(page.getByRole('heading', { level: 1 })).toHaveTextContent('Hello, SvelteKit!');
+								await expect.element(page.getByText('Hello, Vitest!')).toBeInTheDocument();
+							});
+						});
+					`;
+				}));
+			}
+			sv.file(file.viteConfig, transforms.script(({ ast, js }) => {
+				const clientObjectExpression = js.object.create({
+					extends: `./${file.viteConfig}`,
+					test: {
+						name: "client",
+						browser: {
+							enabled: true,
+							provider: js.functions.createCall({
+								name: "playwright",
+								args: []
+							}),
+							instances: [{
+								browser: "chromium",
+								headless: true
+							}]
+						},
+						include: ["src/**/*.svelte.{test,spec}.{js,ts}"],
+						exclude: ["src/lib/server/**"]
+					}
+				});
+				const serverObjectExpression = js.object.create({
+					extends: `./${file.viteConfig}`,
+					test: {
+						name: "server",
+						environment: "node",
+						include: ["src/**/*.{test,spec}.{js,ts}"],
+						exclude: ["src/**/*.svelte.{test,spec}.{js,ts}"]
+					}
+				});
+				const viteConfig = js.vite.getConfig(ast);
+				const testObject = js.object.property(viteConfig, {
+					name: "test",
+					fallback: js.object.create({ expect: { requireAssertions: true } })
+				});
+				const workspaceArray = js.object.property(testObject, {
+					name: "projects",
+					fallback: js.array.create()
+				});
+				if (componentTesting) js.array.append(workspaceArray, clientObjectExpression);
+				if (unitTesting) js.array.append(workspaceArray, serverObjectExpression);
+				if (componentTesting) js.imports.addNamed(ast, {
+					imports: ["playwright"],
+					from: "@vitest/browser-playwright"
+				});
+				const importName = "defineConfig";
+				const { statement, alias } = js.imports.find(ast, {
+					name: importName,
+					from: "vite"
+				});
+				if (statement) {
+					js.imports.addNamed(ast, {
+						imports: { defineConfig: alias },
+						from: "vitest/config"
+					});
+					js.imports.remove(ast, {
+						name: importName,
+						from: "vite",
+						statement
+					});
+				}
+			}));
+		},
+		nextSteps: ({ language, options }) => {
+			const toReturn = [];
+			if (vitestV3Installed) {
+				if (options.usages.includes("component")) {
+					toReturn.push(`Uninstall ${color.command("@vitest/browser")} package`);
+					toReturn.push(`Update usage from ${color.command("'@vitest/browser...'")} to ${color.command("'vitest/browser'")}`);
+				}
+				toReturn.push(`${color.optional("Optional")} Check ${color.path("./vite.config.ts")} and remove duplicate project definitions`);
+				toReturn.push(`${color.optional("Optional")} Remove ${color.path(`./vitest-setup-client.${language}`)} file`);
+			}
+			return toReturn;
+		}
+	}),
+	playwright: playwright_default,
+	tailwindcss: tailwindcss_default,
+	sveltekitAdapter: sveltekit_adapter_default,
+	drizzle: drizzle_default,
+	betterAuth: better_auth_default,
+	mdsvex: mdsvex_default,
+	paraglide: paraglide_default,
+	storybook: storybook_default,
+	aiTools: ai_tools_default,
+	experimental: experimental_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 { officialAddons as n, getAddonDetails as t };