sv 0.6.2 → 0.6.3

package/dist/bin.js

@@ -1,30 +1,30 @@
 #!/usr/bin/env node
 import require$$0 from 'node:events';
 import require$$1, { execSync } from 'node:child_process';
-import path$2, { join } from 'node:path';
+import path$2 from 'node:path';
 import fs$3 from 'node:fs';
 import process$1$1 from 'node:process';
-import { b as be, a as commonjsGlobal, t as templates, c as create$1 } from './_commonjsHelpers-n7_cr1vO.js';
-import { u as up$1, d as dedent, p as parseJson, b as parseScript, e as imports, f as common, g as exports$1, o as object$1, v as variables, _ as _function, h as parseSvelte, j as array$1, w as walk$1, k as kit, l as addFromString, E as Element, m as index, n as parseHtml, q as parseHtml$1, A as AtRule2, s as parseCss, t as pc, x as intro, y as outro, z as cancel, B as box, C as multiselect, D as isCancel, F as log$1, G as confirm, c as createWorkspace, H as note, I as select, J as text, K as packageManagerPrompt, L as installDependencies, M as formatFiles, i as installPackages, a as createOrUpdateFiles, r as resolveCommand, N as spinner, O as getHighlighter, P as detectSync, Q as getUserAgent, R as group, S as from$1 } from './processor-SieBGHed.js';
+import { u as up$1, d as dedent, p as parseJson, a as parseScript, b as imports, c as common, e as exports$1, o as object$1, v as variables, _ as _function, f as parseSvelte, g as array$1, w as walk$1, k as kit, h as addFromString, E as Element, j as index, l as parseHtml, m as parseHtml$1, A as AtRule2, n as parseCss, q as pc, r as intro, s as outro, t as log$1, x as cancel, y as box, z as multiselect, B as isCancel, C as confirm, D as createWorkspace, F as setupAddons, G as note, H as select, I as text, J as packageManagerPrompt, K as applyAddons, L as installDependencies, M as formatFiles, N as spinner, O as getHighlighter, P as detectSync, Q as getUserAgent, R as group, S as resolveCommand, T as from$1 } from './install-aMzn70r6.js';
 import 'node:readline';
 import 'node:tty';
-import { pipeline as pipeline$1 } from 'node:stream/promises';
 import { createGunzip } from 'node:zlib';
+import { fileURLToPath } from 'node:url';
+import { pipeline as pipeline$1 } from 'node:stream/promises';
+import { a as commonjsGlobal, b as be, t as templates, c as create$1 } from './main-UNazaUHM.js';
 import require$$5 from 'events';
 import require$$1$1 from 'fs';
 import require$$1$1$1 from 'path';
-import { fileURLToPath } from 'node:url';
 import 'node:module';
+import 'os';
+import 'url';
+import 'node:fs/promises';
 import 'child_process';
 import 'process';
 import 'stream';
 import 'readline';
-import 'node:fs/promises';
-import 'os';
-import 'url';
 
 var name = "sv";
-var version = "0.6.2";
+var version = "0.6.3";
 var type = "module";
 var description = "A CLI for creating and updating SvelteKit projects";
 var license = "MIT";
@@ -54,7 +54,7 @@ var exports = {
 	}
 };
 var devDependencies = {
-	"@sveltejs/adders": "workspace:*",
+	"@sveltejs/addons": "workspace:*",
 	"@sveltejs/clack-prompts": "workspace:*",
 	"@sveltejs/cli-core": "workspace:*",
 	"@sveltejs/create": "workspace:*",
@@ -4345,10 +4345,10 @@ function up(options) {
 	return up$1("package.json", options);
 }
 
-function defineAdder(config) {
+function defineAddon(config) {
   return config;
 }
-function defineAdderOptions(options) {
+function defineAddonOptions(options) {
   return options;
 }
 var eastasianwidth = { exports: {} };
@@ -4880,7 +4880,7 @@ const PORTS = {
   postgresql: "5432",
   sqlite: ""
 };
-const options$4 = defineAdderOptions({
+const options$4 = defineAddonOptions({
   database: {
     question: "Which database would you like to use?",
     type: "select",
@@ -4932,73 +4932,31 @@ const options$4 = defineAdderOptions({
     condition: ({ database, mysql, postgresql }) => database === "mysql" && mysql === "mysql2" || database === "postgresql" && postgresql === "postgres.js"
   }
 });
-var drizzle = defineAdder({
+var drizzle = defineAddon({
   id: "drizzle",
-  environments: { svelte: false, kit: true },
   homepage: "https://orm.drizzle.team",
   options: options$4,
-  packages: [
-    { name: "drizzle-orm", version: "^0.33.0", dev: false },
-    { name: "drizzle-kit", version: "^0.22.0", dev: true },
-    // MySQL
-    {
-      name: "mysql2",
-      version: "^3.11.0",
-      dev: false,
-      condition: ({ options: options2 }) => options2.mysql === "mysql2"
-    },
-    {
-      name: "@planetscale/database",
-      version: "^1.18.0",
-      dev: false,
-      condition: ({ options: options2 }) => options2.mysql === "planetscale"
-    },
-    // PostgreSQL
-    {
-      name: "@neondatabase/serverless",
-      version: "^0.9.4",
-      dev: false,
-      condition: ({ options: options2 }) => options2.postgresql === "neon"
-    },
-    {
-      name: "postgres",
-      version: "^3.4.4",
-      dev: false,
-      condition: ({ options: options2 }) => options2.postgresql === "postgres.js"
-    },
-    // SQLite
-    {
-      name: "better-sqlite3",
-      version: "^11.1.2",
-      dev: false,
-      condition: ({ options: options2 }) => options2.sqlite === "better-sqlite3"
-    },
-    {
-      name: "@types/better-sqlite3",
-      version: "^7.6.11",
-      dev: true,
-      condition: ({ options: options2 }) => options2.sqlite === "better-sqlite3"
-    },
-    {
-      name: "@libsql/client",
-      version: "^0.9.0",
-      dev: false,
-      condition: ({ options: options2 }) => options2.sqlite === "libsql" || options2.sqlite === "turso"
-    }
-  ],
-  files: [
-    {
-      name: () => ".env",
-      content: generateEnvFileContent
-    },
-    {
-      name: () => ".env.example",
-      content: generateEnvFileContent
-    },
-    {
-      name: () => "docker-compose.yml",
-      condition: ({ options: options2 }) => options2.docker && (options2.mysql === "mysql2" || options2.postgresql === "postgres.js"),
-      content: ({ content, options: options2 }) => {
+  setup: ({ kit, unsupported }) => {
+    if (!kit) unsupported("Requires SvelteKit");
+  },
+  run: ({ sv, typescript, options: options2, kit }) => {
+    const ext = typescript ? "ts" : "js";
+    sv.dependency("drizzle-orm", "^0.33.0");
+    sv.devDependency("drizzle-kit", "^0.22.0");
+    if (options2.mysql === "mysql2") sv.dependency("mysql2", "^3.11.0");
+    if (options2.mysql === "planetscale") sv.dependency("@planetscale/database", "^1.18.0");
+    if (options2.postgresql === "neon") sv.dependency("@neondatabase/serverless", "^0.9.4");
+    if (options2.postgresql === "postgres.js") sv.dependency("postgres", "^3.4.4");
+    if (options2.sqlite === "better-sqlite3") {
+      sv.dependency("better-sqlite3", "^11.1.2");
+      sv.devDependency("@types/better-sqlite3", "^7.6.11");
+    }
+    if (options2.sqlite === "libsql" || options2.sqlite === "turso")
+      sv.dependency("@libsql/client", "^0.9.0");
+    sv.file(".env", (content) => generateEnvFileContent(content, options2));
+    sv.file(".env.example", (content) => generateEnvFileContent(content, options2));
+    if (options2.docker && (options2.mysql === "mysql2" || options2.postgresql === "postgres.js")) {
+      sv.file("docker-compose.yml", (content) => {
         if (content.length > 0) return content;
         const imageName = options2.database === "mysql" ? "mysql" : "postgres";
         const port = PORTS[options2.database];
@@ -5029,177 +4987,160 @@ var drizzle = defineAdder({
                     environment: ${dbSpecificContent}
                 `;
         return content;
-      }
-    },
-    {
-      name: () => "package.json",
-      content: ({ content, options: options2 }) => {
-        const { data, generateCode } = parseJson(content);
-        data.scripts ?? (data.scripts = {});
-        const scripts = data.scripts;
-        if (options2.docker) scripts["db:start"] ?? (scripts["db:start"] = "docker compose up");
-        scripts["db:push"] ?? (scripts["db:push"] = "drizzle-kit push");
-        scripts["db:migrate"] ?? (scripts["db:migrate"] = "drizzle-kit migrate");
-        scripts["db:studio"] ?? (scripts["db:studio"] = "drizzle-kit studio");
-        return generateCode();
-      }
-    },
-    {
-      // Adds the db file to the gitignore if an ignore is present
-      name: () => ".gitignore",
-      condition: ({ options: options2 }) => options2.database === "sqlite",
-      content: ({ content }) => {
+      });
+    }
+    sv.file("package.json", (content) => {
+      const { data, generateCode } = parseJson(content);
+      data.scripts ?? (data.scripts = {});
+      const scripts = data.scripts;
+      if (options2.docker) scripts["db:start"] ?? (scripts["db:start"] = "docker compose up");
+      scripts["db:push"] ?? (scripts["db:push"] = "drizzle-kit push");
+      scripts["db:migrate"] ?? (scripts["db:migrate"] = "drizzle-kit migrate");
+      scripts["db:studio"] ?? (scripts["db:studio"] = "drizzle-kit studio");
+      return generateCode();
+    });
+    if (options2.database === "sqlite") {
+      sv.file(".gitignore", (content) => {
         if (content.length === 0) return content;
         if (!content.includes("\n*.db")) {
           content = content.trimEnd() + "\n\n# SQLite\n*.db";
         }
         return content;
-      }
-    },
-    {
-      name: ({ typescript }) => `drizzle.config.${typescript ? "ts" : "js"}`,
-      content: ({ options: options2, content, typescript }) => {
-        const { ast, generateCode } = parseScript(content);
-        imports.addNamed(ast, "drizzle-kit", { defineConfig: "defineConfig" });
-        const envCheckStatement = common.statementFromString(
-          "if (!process.env.DATABASE_URL) throw new Error('DATABASE_URL is not set');"
-        );
-        common.addStatement(ast, envCheckStatement);
-        const fallback = common.expressionFromString("defineConfig({})");
-        const { value: exportDefault } = exports$1.defaultExport(ast, fallback);
-        if (exportDefault.type !== "CallExpression") return content;
-        const objExpression = exportDefault.arguments?.[0];
-        if (!objExpression || objExpression.type !== "ObjectExpression") return content;
-        const driver = options2.sqlite === "turso" ? common.createLiteral("turso") : void 0;
-        const authToken = options2.sqlite === "turso" ? common.expressionFromString("process.env.DATABASE_AUTH_TOKEN") : void 0;
-        object$1.properties(objExpression, {
-          schema: common.createLiteral(`./src/lib/server/db/schema.${typescript ? "ts" : "js"}`),
-          dbCredentials: object$1.create({
-            url: common.expressionFromString("process.env.DATABASE_URL"),
-            authToken
-          }),
-          verbose: { type: "BooleanLiteral", value: true },
-          strict: { type: "BooleanLiteral", value: true },
-          driver
+      });
+    }
+    sv.file(`drizzle.config.${ext}`, (content) => {
+      const { ast, generateCode } = parseScript(content);
+      imports.addNamed(ast, "drizzle-kit", { defineConfig: "defineConfig" });
+      const envCheckStatement = common.statementFromString(
+        "if (!process.env.DATABASE_URL) throw new Error('DATABASE_URL is not set');"
+      );
+      common.addStatement(ast, envCheckStatement);
+      const fallback = common.expressionFromString("defineConfig({})");
+      const { value: exportDefault } = exports$1.defaultExport(ast, fallback);
+      if (exportDefault.type !== "CallExpression") return content;
+      const objExpression = exportDefault.arguments?.[0];
+      if (!objExpression || objExpression.type !== "ObjectExpression") return content;
+      const driver = options2.sqlite === "turso" ? common.createLiteral("turso") : void 0;
+      const authToken = options2.sqlite === "turso" ? common.expressionFromString("process.env.DATABASE_AUTH_TOKEN") : void 0;
+      object$1.properties(objExpression, {
+        schema: common.createLiteral(`./src/lib/server/db/schema.${typescript ? "ts" : "js"}`),
+        dbCredentials: object$1.create({
+          url: common.expressionFromString("process.env.DATABASE_URL"),
+          authToken
+        }),
+        verbose: { type: "BooleanLiteral", value: true },
+        strict: { type: "BooleanLiteral", value: true },
+        driver
+      });
+      object$1.overrideProperties(objExpression, {
+        dialect: common.createLiteral(options2.database)
+      });
+      if (options2.database !== "sqlite") object$1.removeProperty(objExpression, "driver");
+      return generateCode();
+    });
+    sv.file(`${kit?.libDirectory}/server/db/schema.${ext}`, (content) => {
+      const { ast, generateCode } = parseScript(content);
+      let userSchemaExpression;
+      if (options2.database === "sqlite") {
+        imports.addNamed(ast, "drizzle-orm/sqlite-core", {
+          sqliteTable: "sqliteTable",
+          text: "text",
+          integer: "integer"
         });
-        object$1.overrideProperties(objExpression, {
-          dialect: common.createLiteral(options2.database)
+        userSchemaExpression = common.expressionFromString(`sqliteTable('user', {
+					id: integer('id').primaryKey(),
+					age: integer('age')
+				})`);
+      }
+      if (options2.database === "mysql") {
+        imports.addNamed(ast, "drizzle-orm/mysql-core", {
+          mysqlTable: "mysqlTable",
+          serial: "serial",
+          text: "text",
+          int: "int"
         });
-        if (options2.database !== "sqlite") object$1.removeProperty(objExpression, "driver");
-        return generateCode();
-      }
-    },
-    {
-      name: ({ kit, typescript }) => `${kit?.libDirectory}/server/db/schema.${typescript ? "ts" : "js"}`,
-      content: ({ content, options: options2 }) => {
-        const { ast, generateCode } = parseScript(content);
-        let userSchemaExpression;
-        if (options2.database === "sqlite") {
-          imports.addNamed(ast, "drizzle-orm/sqlite-core", {
-            sqliteTable: "sqliteTable",
-            text: "text",
-            integer: "integer"
-          });
-          userSchemaExpression = common.expressionFromString(`sqliteTable('user', {
-                        id: integer('id').primaryKey(),
-                        age: integer('age')
-                    })`);
-        }
-        if (options2.database === "mysql") {
-          imports.addNamed(ast, "drizzle-orm/mysql-core", {
-            mysqlTable: "mysqlTable",
-            serial: "serial",
-            text: "text",
-            int: "int"
-          });
-          userSchemaExpression = common.expressionFromString(`mysqlTable('user', {
-                        id: serial('id').primaryKey(),
-                        age: int('age'),
-                    })`);
-        }
-        if (options2.database === "postgresql") {
-          imports.addNamed(ast, "drizzle-orm/pg-core", {
-            pgTable: "pgTable",
-            serial: "serial",
-            text: "text",
-            integer: "integer"
-          });
-          userSchemaExpression = common.expressionFromString(`pgTable('user', {
-                        id: serial('id').primaryKey(),
-                        age: integer('age'),
-                    })`);
-        }
-        if (!userSchemaExpression) throw new Error("unreachable state...");
-        const userIdentifier = variables.declaration(ast, "const", "user", userSchemaExpression);
-        exports$1.namedExport(ast, "user", userIdentifier);
-        return generateCode();
-      }
-    },
-    {
-      name: ({ kit, typescript }) => `${kit?.libDirectory}/server/db/index.${typescript ? "ts" : "js"}`,
-      content: ({ content, options: options2 }) => {
-        const { ast, generateCode } = parseScript(content);
-        imports.addNamed(ast, "$env/dynamic/private", { env: "env" });
-        const dbURLCheck = common.statementFromString(
-          "if (!env.DATABASE_URL) throw new Error('DATABASE_URL is not set');"
-        );
-        common.addStatement(ast, dbURLCheck);
-        let clientExpression;
-        if (options2.sqlite === "better-sqlite3") {
-          imports.addDefault(ast, "better-sqlite3", "Database");
-          imports.addNamed(ast, "drizzle-orm/better-sqlite3", { drizzle: "drizzle" });
-          clientExpression = common.expressionFromString("new Database(env.DATABASE_URL)");
-        }
-        if (options2.sqlite === "libsql" || options2.sqlite === "turso") {
-          imports.addNamed(ast, "@libsql/client", { createClient: "createClient" });
-          imports.addNamed(ast, "drizzle-orm/libsql", { drizzle: "drizzle" });
-          if (options2.sqlite === "turso") {
-            imports.addNamed(ast, "$app/environment", { dev: "dev" });
-            const authTokenCheck = common.statementFromString(
-              "if (!dev && !env.DATABASE_AUTH_TOKEN) throw new Error('DATABASE_AUTH_TOKEN is not set');"
-            );
-            common.addStatement(ast, authTokenCheck);
-            clientExpression = common.expressionFromString(
-              "createClient({ url: env.DATABASE_URL, authToken: env.DATABASE_AUTH_TOKEN })"
-            );
-          } else {
-            clientExpression = common.expressionFromString(
-              "createClient({ url: env.DATABASE_URL })"
-            );
-          }
-        }
-        if (options2.mysql === "mysql2") {
-          imports.addDefault(ast, "mysql2/promise", "mysql");
-          imports.addNamed(ast, "drizzle-orm/mysql2", { drizzle: "drizzle" });
+        userSchemaExpression = common.expressionFromString(`mysqlTable('user', {
+					id: serial('id').primaryKey(),
+					age: int('age'),
+				})`);
+      }
+      if (options2.database === "postgresql") {
+        imports.addNamed(ast, "drizzle-orm/pg-core", {
+          pgTable: "pgTable",
+          serial: "serial",
+          text: "text",
+          integer: "integer"
+        });
+        userSchemaExpression = common.expressionFromString(`pgTable('user', {
+					id: serial('id').primaryKey(),
+					age: integer('age'),
+				})`);
+      }
+      if (!userSchemaExpression) throw new Error("unreachable state...");
+      const userIdentifier = variables.declaration(ast, "const", "user", userSchemaExpression);
+      exports$1.namedExport(ast, "user", userIdentifier);
+      return generateCode();
+    });
+    sv.file(`${kit?.libDirectory}/server/db/index.${ext}`, (content) => {
+      const { ast, generateCode } = parseScript(content);
+      imports.addNamed(ast, "$env/dynamic/private", { env: "env" });
+      const dbURLCheck = common.statementFromString(
+        "if (!env.DATABASE_URL) throw new Error('DATABASE_URL is not set');"
+      );
+      common.addStatement(ast, dbURLCheck);
+      let clientExpression;
+      if (options2.sqlite === "better-sqlite3") {
+        imports.addDefault(ast, "better-sqlite3", "Database");
+        imports.addNamed(ast, "drizzle-orm/better-sqlite3", { drizzle: "drizzle" });
+        clientExpression = common.expressionFromString("new Database(env.DATABASE_URL)");
+      }
+      if (options2.sqlite === "libsql" || options2.sqlite === "turso") {
+        imports.addNamed(ast, "@libsql/client", { createClient: "createClient" });
+        imports.addNamed(ast, "drizzle-orm/libsql", { drizzle: "drizzle" });
+        if (options2.sqlite === "turso") {
+          imports.addNamed(ast, "$app/environment", { dev: "dev" });
+          const authTokenCheck = common.statementFromString(
+            "if (!dev && !env.DATABASE_AUTH_TOKEN) throw new Error('DATABASE_AUTH_TOKEN is not set');"
+          );
+          common.addStatement(ast, authTokenCheck);
           clientExpression = common.expressionFromString(
-            "await mysql.createConnection(env.DATABASE_URL)"
+            "createClient({ url: env.DATABASE_URL, authToken: env.DATABASE_AUTH_TOKEN })"
           );
+        } else {
+          clientExpression = common.expressionFromString("createClient({ url: env.DATABASE_URL })");
         }
-        if (options2.mysql === "planetscale") {
-          imports.addNamed(ast, "@planetscale/database", { Client: "Client" });
-          imports.addNamed(ast, "drizzle-orm/planetscale-serverless", { drizzle: "drizzle" });
-          clientExpression = common.expressionFromString("new Client({ url: env.DATABASE_URL })");
-        }
-        if (options2.postgresql === "neon") {
-          imports.addNamed(ast, "@neondatabase/serverless", { neon: "neon" });
-          imports.addNamed(ast, "drizzle-orm/neon-http", { drizzle: "drizzle" });
-          clientExpression = common.expressionFromString("neon(env.DATABASE_URL)");
-        }
-        if (options2.postgresql === "postgres.js") {
-          imports.addDefault(ast, "postgres", "postgres");
-          imports.addNamed(ast, "drizzle-orm/postgres-js", { drizzle: "drizzle" });
-          clientExpression = common.expressionFromString("postgres(env.DATABASE_URL)");
-        }
-        if (!clientExpression) throw new Error("unreachable state...");
-        const clientIdentifier = variables.declaration(ast, "const", "client", clientExpression);
-        common.addStatement(ast, clientIdentifier);
-        const drizzleCall = _function.callByIdentifier("drizzle", ["client"]);
-        const db = variables.declaration(ast, "const", "db", drizzleCall);
-        exports$1.namedExport(ast, "db", db);
-        return generateCode();
       }
-    }
-  ],
+      if (options2.mysql === "mysql2") {
+        imports.addDefault(ast, "mysql2/promise", "mysql");
+        imports.addNamed(ast, "drizzle-orm/mysql2", { drizzle: "drizzle" });
+        clientExpression = common.expressionFromString(
+          "await mysql.createConnection(env.DATABASE_URL)"
+        );
+      }
+      if (options2.mysql === "planetscale") {
+        imports.addNamed(ast, "@planetscale/database", { Client: "Client" });
+        imports.addNamed(ast, "drizzle-orm/planetscale-serverless", { drizzle: "drizzle" });
+        clientExpression = common.expressionFromString("new Client({ url: env.DATABASE_URL })");
+      }
+      if (options2.postgresql === "neon") {
+        imports.addNamed(ast, "@neondatabase/serverless", { neon: "neon" });
+        imports.addNamed(ast, "drizzle-orm/neon-http", { drizzle: "drizzle" });
+        clientExpression = common.expressionFromString("neon(env.DATABASE_URL)");
+      }
+      if (options2.postgresql === "postgres.js") {
+        imports.addDefault(ast, "postgres", "postgres");
+        imports.addNamed(ast, "drizzle-orm/postgres-js", { drizzle: "drizzle" });
+        clientExpression = common.expressionFromString("postgres(env.DATABASE_URL)");
+      }
+      if (!clientExpression) throw new Error("unreachable state...");
+      const clientIdentifier = variables.declaration(ast, "const", "client", clientExpression);
+      common.addStatement(ast, clientIdentifier);
+      const drizzleCall = _function.callByIdentifier("drizzle", ["client"]);
+      const db = variables.declaration(ast, "const", "db", drizzleCall);
+      exports$1.namedExport(ast, "db", db);
+      return generateCode();
+    });
+  },
   nextSteps: ({ options: options2, highlighter, packageManager }) => {
     const steps = [
       `You will need to set ${highlighter.env("DATABASE_URL")} in your production environment`
@@ -5215,7 +5156,7 @@ var drizzle = defineAdder({
     return steps;
   }
 });
-function generateEnvFileContent({ content, options: opts }) {
+function generateEnvFileContent(content, opts) {
   const DB_URL_KEY = "DATABASE_URL";
   if (opts.docker) {
     const protocol = opts.database === "mysql" ? "mysql" : "postgres";
@@ -5265,7 +5206,7 @@ function appendEnvContent(existing, content) {
   return withNewLine + content + "\n";
 }
 
-function addEslintConfigPrettier({ content }) {
+function addEslintConfigPrettier(content) {
   const { ast, generateCode } = parseScript(content);
   const importNodes = ast.body.filter((n) => n.type === "ImportDeclaration");
   const sveltePluginImport = importNodes.find(
@@ -5304,7 +5245,7 @@ function addEslintConfigPrettier({ content }) {
   }
   return generateCode();
 }
-function addToDemoPage({ content }, path) {
+function addToDemoPage(content, path) {
   const { template, generateCode } = parseSvelte(content);
   for (const node of template.ast.childNodes) {
     if (node.type === "tag" && node.attribs["href"] === `/demo/${path}`) {
@@ -5316,125 +5257,101 @@ function addToDemoPage({ content }, path) {
   return generateCode({ template: src });
 }
 
-var eslint = defineAdder({
+var eslint = defineAddon({
   id: "eslint",
-  environments: { svelte: true, kit: true },
   homepage: "https://eslint.org",
   options: {},
-  packages: [
-    { name: "eslint", version: "^9.7.0", dev: true },
-    { name: "@types/eslint", version: "^9.6.0", dev: true },
-    { name: "globals", version: "^15.0.0", dev: true },
-    {
-      name: "typescript-eslint",
-      version: "^8.0.0",
-      dev: true,
-      condition: ({ typescript }) => typescript
-    },
-    { name: "eslint-plugin-svelte", version: "^2.36.0", dev: true },
-    {
-      name: "eslint-config-prettier",
-      version: "^9.1.0",
-      dev: true,
-      condition: ({ dependencyVersion }) => Boolean(dependencyVersion("prettier"))
-    }
-  ],
-  files: [
-    {
-      name: () => "package.json",
-      content: ({ content }) => {
-        const { data, generateCode } = parseJson(content);
-        data.scripts ?? (data.scripts = {});
-        const scripts = data.scripts;
-        const LINT_CMD = "eslint .";
-        scripts["lint"] ?? (scripts["lint"] = LINT_CMD);
-        if (!scripts["lint"].includes(LINT_CMD)) scripts["lint"] += ` && ${LINT_CMD}`;
-        return generateCode();
-      }
-    },
-    {
-      name: () => ".vscode/settings.json",
-      // we'll only want to run this step if the file exists
-      condition: ({ cwd }) => fs$3.existsSync(path$2.join(cwd, ".vscode", "settings.json")),
-      content: ({ content }) => {
-        const { data, generateCode } = parseJson(content);
-        const validate = data["eslint.validate"];
-        if (validate && !validate.includes("svelte")) {
-          validate.push("svelte");
-        }
-        return generateCode();
-      }
-    },
-    {
-      name: () => "eslint.config.js",
-      content: ({ content, typescript }) => {
-        const { ast, generateCode } = parseScript(content);
-        const eslintConfigs = [];
-        const jsConfig = common.expressionFromString("js.configs.recommended");
-        eslintConfigs.push(jsConfig);
-        if (typescript) {
-          const tsConfig = common.expressionFromString("ts.configs.recommended");
-          eslintConfigs.push(common.createSpreadElement(tsConfig));
-        }
-        const svelteConfig = common.expressionFromString('svelte.configs["flat/recommended"]');
-        eslintConfigs.push(common.createSpreadElement(svelteConfig));
-        const globalsBrowser = common.createSpreadElement(
-          common.expressionFromString("globals.browser")
-        );
-        const globalsNode = common.createSpreadElement(common.expressionFromString("globals.node"));
-        const globalsObjLiteral = object$1.createEmpty();
-        globalsObjLiteral.properties = [globalsBrowser, globalsNode];
-        const globalsConfig = object$1.create({
+  run: ({ sv, typescript, dependencyVersion }) => {
+    const prettierInstalled = Boolean(dependencyVersion("prettier"));
+    sv.devDependency("eslint", "^9.7.0");
+    sv.devDependency("@types/eslint", "^9.6.0");
+    sv.devDependency("globals", "^15.0.0");
+    sv.devDependency("eslint-plugin-svelte", "^2.36.0");
+    if (typescript) sv.devDependency("typescript-eslint", "^8.0.0");
+    if (prettierInstalled) sv.devDependency("eslint-config-prettier", "^9.1.0");
+    sv.file("package.json", (content) => {
+      const { data, generateCode } = parseJson(content);
+      data.scripts ?? (data.scripts = {});
+      const scripts = data.scripts;
+      const LINT_CMD = "eslint .";
+      scripts["lint"] ?? (scripts["lint"] = LINT_CMD);
+      if (!scripts["lint"].includes(LINT_CMD)) scripts["lint"] += ` && ${LINT_CMD}`;
+      return generateCode();
+    });
+    sv.file(".vscode/settings.json", (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("eslint.config.js", (content) => {
+      const { ast, generateCode } = parseScript(content);
+      const eslintConfigs = [];
+      const jsConfig = common.expressionFromString("js.configs.recommended");
+      eslintConfigs.push(jsConfig);
+      if (typescript) {
+        const tsConfig = common.expressionFromString("ts.configs.recommended");
+        eslintConfigs.push(common.createSpreadElement(tsConfig));
+      }
+      const svelteConfig = common.expressionFromString('svelte.configs["flat/recommended"]');
+      eslintConfigs.push(common.createSpreadElement(svelteConfig));
+      const globalsBrowser = common.createSpreadElement(
+        common.expressionFromString("globals.browser")
+      );
+      const globalsNode = common.createSpreadElement(common.expressionFromString("globals.node"));
+      const globalsObjLiteral = object$1.createEmpty();
+      globalsObjLiteral.properties = [globalsBrowser, globalsNode];
+      const globalsConfig = object$1.create({
+        languageOptions: object$1.create({
+          globals: globalsObjLiteral
+        })
+      });
+      eslintConfigs.push(globalsConfig);
+      if (typescript) {
+        const svelteTSParserConfig = object$1.create({
+          files: common.expressionFromString('["**/*.svelte"]'),
           languageOptions: object$1.create({
-            globals: globalsObjLiteral
-          })
-        });
-        eslintConfigs.push(globalsConfig);
-        if (typescript) {
-          const svelteTSParserConfig = object$1.create({
-            files: common.expressionFromString('["**/*.svelte"]'),
-            languageOptions: object$1.create({
-              parserOptions: object$1.create({
-                parser: common.expressionFromString("ts.parser")
-              })
+            parserOptions: object$1.create({
+              parser: common.expressionFromString("ts.parser")
             })
-          });
-          eslintConfigs.push(svelteTSParserConfig);
-        }
-        const ignoresConfig = object$1.create({
-          ignores: common.expressionFromString('["build/", ".svelte-kit/", "dist/"]')
+          })
         });
-        eslintConfigs.push(ignoresConfig);
-        let exportExpression;
-        if (typescript) {
-          const tsConfigCall = _function.call("ts.config", []);
-          tsConfigCall.arguments.push(...eslintConfigs);
-          exportExpression = tsConfigCall;
-        } else {
-          const eslintArray = array$1.createEmpty();
-          eslintConfigs.map((x) => array$1.push(eslintArray, x));
-          exportExpression = eslintArray;
-        }
-        const defaultExport = exports$1.defaultExport(ast, exportExpression);
-        if (defaultExport.value !== exportExpression) {
-          log.warn("An eslint config is already defined. Skipping initialization.");
-          return content;
-        }
-        if (!typescript)
-          common.addJsDocTypeComment(defaultExport.astNode, "import('eslint').Linter.Config[]");
-        if (typescript) imports.addDefault(ast, "typescript-eslint", "ts");
-        imports.addDefault(ast, "globals", "globals");
-        imports.addDefault(ast, "eslint-plugin-svelte", "svelte");
-        imports.addDefault(ast, "@eslint/js", "js");
-        return generateCode();
+        eslintConfigs.push(svelteTSParserConfig);
       }
-    },
-    {
-      name: () => "eslint.config.js",
-      condition: ({ dependencyVersion }) => Boolean(dependencyVersion("prettier")),
-      content: addEslintConfigPrettier
+      const ignoresConfig = object$1.create({
+        ignores: common.expressionFromString('["build/", ".svelte-kit/", "dist/"]')
+      });
+      eslintConfigs.push(ignoresConfig);
+      let exportExpression;
+      if (typescript) {
+        const tsConfigCall = _function.call("ts.config", []);
+        tsConfigCall.arguments.push(...eslintConfigs);
+        exportExpression = tsConfigCall;
+      } else {
+        const eslintArray = array$1.createEmpty();
+        eslintConfigs.map((x) => array$1.push(eslintArray, x));
+        exportExpression = eslintArray;
+      }
+      const defaultExport = exports$1.defaultExport(ast, exportExpression);
+      if (defaultExport.value !== exportExpression) {
+        log.warn("An eslint config is already defined. Skipping initialization.");
+        return content;
+      }
+      if (!typescript)
+        common.addJsDocTypeComment(defaultExport.astNode, "import('eslint').Linter.Config[]");
+      if (typescript) imports.addDefault(ast, "typescript-eslint", "ts");
+      imports.addDefault(ast, "globals", "globals");
+      imports.addDefault(ast, "eslint-plugin-svelte", "svelte");
+      imports.addDefault(ast, "@eslint/js", "js");
+      return generateCode();
+    });
+    if (prettierInstalled) {
+      sv.file("eslint.config.js", addEslintConfigPrettier);
     }
-  ]
+  }
 });
 
 const comma = ','.charCodeAt(0);
@@ -6785,8 +6702,8 @@ class MagicString {
 }
 
 var __freeze = Object.freeze;
-var __defProp = Object.defineProperty;
-var __template = (cooked, raw) => __freeze(__defProp(cooked, "raw", { value: __freeze(cooked.slice()) }));
+var __defProp$1 = Object.defineProperty;
+var __template = (cooked, raw) => __freeze(__defProp$1(cooked, "raw", { value: __freeze(cooked.slice()) }));
 var _a, _b;
 const TABLE_TYPE = {
   mysql: "mysqlTable",
@@ -6795,316 +6712,302 @@ const TABLE_TYPE = {
 };
 let drizzleDialect;
 let schemaPath;
-const options$3 = defineAdderOptions({
+const options$3 = defineAddonOptions({
   demo: {
     type: "boolean",
     default: true,
     question: `Do you want to include a demo? ${picocolors.dim("(includes a login/register page)")}`
   }
 });
-var lucia = defineAdder({
+var lucia = defineAddon({
   id: "lucia",
-  environments: { svelte: false, kit: true },
   homepage: "https://lucia-auth.com",
   options: options$3,
-  packages: [
-    { name: "@oslojs/crypto", version: "^1.0.1", dev: false },
-    { name: "@oslojs/encoding", version: "^1.1.0", dev: false },
-    // password hashing for demo
-    {
-      name: "@node-rs/argon2",
-      version: "^1.1.0",
-      condition: ({ options: options2 }) => options2.demo,
-      dev: false
-    }
-  ],
-  dependsOn: ["drizzle"],
-  files: [
-    {
-      name: ({ typescript }) => `drizzle.config.${typescript ? "ts" : "js"}`,
-      content: ({ content }) => {
-        const { ast, generateCode } = parseScript(content);
-        const isProp = (name, node) => node.key.type === "Identifier" && node.key.name === name;
-        walk$1.walk(ast, {}, {
-          ObjectProperty(node) {
-            if (isProp("dialect", node) && node.value.type === "StringLiteral") {
-              drizzleDialect = node.value.value;
-            }
-            if (isProp("schema", node) && node.value.type === "StringLiteral") {
-              schemaPath = node.value.value;
-            }
+  setup: ({ kit, dependencyVersion, unsupported, dependsOn }) => {
+    if (!kit) unsupported("Requires SvelteKit");
+    if (!dependencyVersion("drizzle-orm")) dependsOn("drizzle");
+  },
+  run: ({ sv, typescript, options: options2, kit: kit$1, dependencyVersion }) => {
+    const ext = typescript ? "ts" : "js";
+    sv.dependency("@oslojs/crypto", "^1.0.1");
+    sv.dependency("@oslojs/encoding", "^1.1.0");
+    if (options2.demo) {
+      sv.dependency("@node-rs/argon2", "^1.1.0");
+    }
+    sv.file(`drizzle.config.${ext}`, (content) => {
+      const { ast, generateCode } = parseScript(content);
+      const isProp = (name, node) => node.key.type === "Identifier" && node.key.name === name;
+      walk$1.walk(ast, {}, {
+        ObjectProperty(node) {
+          if (isProp("dialect", node) && node.value.type === "StringLiteral") {
+            drizzleDialect = 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();
-      }
-    },
-    {
-      name: () => schemaPath,
-      content: ({ content, options: options2, typescript }) => {
-        const { ast, generateCode } = parseScript(content);
-        const createTable = (name) => _function.call(TABLE_TYPE[drizzleDialect], [name]);
-        const userDecl = variables.declaration(ast, "const", "user", createTable("user"));
-        const sessionDecl = variables.declaration(ast, "const", "session", createTable("session"));
-        const user = exports$1.namedExport(ast, "user", userDecl);
-        const session = exports$1.namedExport(ast, "session", 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(object$1.createEmpty());
-        }
-        if (sessionTable.arguments.length === 1) {
-          sessionTable.arguments.push(object$1.createEmpty());
-        }
-        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") {
-          imports.addNamed(ast, "drizzle-orm/sqlite-core", {
-            sqliteTable: "sqliteTable",
-            text: "text",
-            integer: "integer"
-          });
-          object$1.overrideProperties(userAttributes, {
-            id: common.expressionFromString("text('id').primaryKey()")
-          });
-          if (options2.demo) {
-            object$1.overrideProperties(userAttributes, {
-              username: common.expressionFromString("text('username').notNull().unique()"),
-              passwordHash: common.expressionFromString("text('password_hash').notNull()")
-            });
+          if (isProp("schema", node) && node.value.type === "StringLiteral") {
+            schemaPath = node.value.value;
           }
-          object$1.overrideProperties(sessionAttributes, {
-            id: common.expressionFromString("text('id').primaryKey()"),
-            userId: common.expressionFromString(
-              "text('user_id').notNull().references(() => user.id)"
-            ),
-            expiresAt: common.expressionFromString(
-              "integer('expires_at', { mode: 'timestamp' }).notNull()"
-            )
-          });
         }
-        if (drizzleDialect === "mysql") {
-          imports.addNamed(ast, "drizzle-orm/mysql-core", {
-            mysqlTable: "mysqlTable",
-            varchar: "varchar",
-            datetime: "datetime"
-          });
+      });
+      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) => _function.call(TABLE_TYPE[drizzleDialect], [name]);
+      const userDecl = variables.declaration(ast, "const", "user", createTable("user"));
+      const sessionDecl = variables.declaration(ast, "const", "session", createTable("session"));
+      const user = exports$1.namedExport(ast, "user", userDecl);
+      const session = exports$1.namedExport(ast, "session", 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(object$1.createEmpty());
+      }
+      if (sessionTable.arguments.length === 1) {
+        sessionTable.arguments.push(object$1.createEmpty());
+      }
+      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") {
+        imports.addNamed(ast, "drizzle-orm/sqlite-core", {
+          sqliteTable: "sqliteTable",
+          text: "text",
+          integer: "integer"
+        });
+        object$1.overrideProperties(userAttributes, {
+          id: common.expressionFromString("text('id').primaryKey()")
+        });
+        if (options2.demo) {
           object$1.overrideProperties(userAttributes, {
-            id: common.expressionFromString("varchar('id', { length: 255 }).primaryKey()")
-          });
-          if (options2.demo) {
-            object$1.overrideProperties(userAttributes, {
-              username: common.expressionFromString(
-                "varchar('username', { length: 32 }).notNull().unique()"
-              ),
-              passwordHash: common.expressionFromString(
-                "varchar('password_hash', { length: 255 }).notNull()"
-              )
-            });
-          }
-          object$1.overrideProperties(sessionAttributes, {
-            id: common.expressionFromString("varchar('id', { length: 255 }).primaryKey()"),
-            userId: common.expressionFromString(
-              "varchar('user_id', { length: 255 }).notNull().references(() => user.id)"
-            ),
-            expiresAt: common.expressionFromString("datetime('expires_at').notNull()")
+            username: common.expressionFromString("text('username').notNull().unique()"),
+            passwordHash: common.expressionFromString("text('password_hash').notNull()")
           });
         }
-        if (drizzleDialect === "postgresql") {
-          imports.addNamed(ast, "drizzle-orm/pg-core", {
-            pgTable: "pgTable",
-            text: "text",
-            timestamp: "timestamp"
-          });
+        object$1.overrideProperties(sessionAttributes, {
+          id: common.expressionFromString("text('id').primaryKey()"),
+          userId: common.expressionFromString(
+            "text('user_id').notNull().references(() => user.id)"
+          ),
+          expiresAt: common.expressionFromString(
+            "integer('expires_at', { mode: 'timestamp' }).notNull()"
+          )
+        });
+      }
+      if (drizzleDialect === "mysql") {
+        imports.addNamed(ast, "drizzle-orm/mysql-core", {
+          mysqlTable: "mysqlTable",
+          varchar: "varchar",
+          datetime: "datetime"
+        });
+        object$1.overrideProperties(userAttributes, {
+          id: common.expressionFromString("varchar('id', { length: 255 }).primaryKey()")
+        });
+        if (options2.demo) {
           object$1.overrideProperties(userAttributes, {
-            id: common.expressionFromString("text('id').primaryKey()")
-          });
-          if (options2.demo) {
-            object$1.overrideProperties(userAttributes, {
-              username: common.expressionFromString("text('username').notNull().unique()"),
-              passwordHash: common.expressionFromString("text('password_hash').notNull()")
-            });
-          }
-          object$1.overrideProperties(sessionAttributes, {
-            id: common.expressionFromString("text('id').primaryKey()"),
-            userId: common.expressionFromString(
-              "text('user_id').notNull().references(() => user.id)"
+            username: common.expressionFromString(
+              "varchar('username', { length: 32 }).notNull().unique()"
             ),
-            expiresAt: common.expressionFromString(
-              "timestamp('expires_at', { withTimezone: true, mode: 'date' }).notNull()"
+            passwordHash: common.expressionFromString(
+              "varchar('password_hash', { length: 255 }).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;
+        object$1.overrideProperties(sessionAttributes, {
+          id: common.expressionFromString("varchar('id', { length: 255 }).primaryKey()"),
+          userId: common.expressionFromString(
+            "varchar('user_id', { length: 255 }).notNull().references(() => user.id)"
+          ),
+          expiresAt: common.expressionFromString("datetime('expires_at').notNull()")
+        });
       }
-    },
-    {
-      name: ({ kit: kit2, typescript }) => `${kit2?.libDirectory}/server/auth.${typescript ? "ts" : "js"}`,
-      content: ({ content, typescript }) => {
-        const { ast, generateCode } = parseScript(content);
-        imports.addNamespace(ast, "$lib/server/db/schema", "table");
-        imports.addNamed(ast, "$lib/server/db", { db: "db" });
-        imports.addNamed(ast, "@oslojs/encoding", {
-          encodeBase32LowerCase: "encodeBase32LowerCase",
-          encodeHexLowerCase: "encodeHexLowerCase"
+      if (drizzleDialect === "postgresql") {
+        imports.addNamed(ast, "drizzle-orm/pg-core", {
+          pgTable: "pgTable",
+          text: "text",
+          timestamp: "timestamp"
         });
-        imports.addNamed(ast, "@oslojs/crypto/sha2", { sha256: "sha256" });
-        imports.addNamed(ast, "drizzle-orm", { eq: "eq" });
-        if (typescript) {
-          imports.addNamed(ast, "@sveltejs/kit", { RequestEvent: "RequestEvent" }, true);
+        object$1.overrideProperties(userAttributes, {
+          id: common.expressionFromString("text('id').primaryKey()")
+        });
+        if (options2.demo) {
+          object$1.overrideProperties(userAttributes, {
+            username: common.expressionFromString("text('username').notNull().unique()"),
+            passwordHash: common.expressionFromString("text('password_hash').notNull()")
+          });
         }
-        const ms = new MagicString(generateCode().trim());
-        const [ts] = utils.createPrinter(typescript);
-        if (!ms.original.includes("const DAY_IN_MS")) {
-          ms.append("\n\nconst DAY_IN_MS = 1000 * 60 * 60 * 24;");
+        object$1.overrideProperties(sessionAttributes, {
+          id: common.expressionFromString("text('id').primaryKey()"),
+          userId: common.expressionFromString(
+            "text('user_id').notNull().references(() => user.id)"
+          ),
+          expiresAt: common.expressionFromString(
+            "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 (!ms.original.includes("export const sessionCookieName")) {
-          ms.append("\n\nexport const sessionCookieName = 'auth-session';");
+        if (!code.includes("export type User =")) {
+          code += "\n\nexport type User = typeof user.$inferSelect;";
         }
-        if (!ms.original.includes("export function generateSessionToken")) {
-          const generateSessionToken = dedent`					
-						export function generateSessionToken() {
-							const bytes = crypto.getRandomValues(new Uint8Array(20));
-							const token = encodeBase32LowerCase(bytes);
-							return token;
-						}`;
-          ms.append(`
+      }
+      return code;
+    });
+    sv.file(`${kit$1?.libDirectory}/server/auth.${ext}`, (content) => {
+      const { ast, generateCode } = parseScript(content);
+      imports.addNamespace(ast, "$lib/server/db/schema", "table");
+      imports.addNamed(ast, "$lib/server/db", { db: "db" });
+      imports.addNamed(ast, "@oslojs/encoding", {
+        encodeBase64url: "encodeBase64url",
+        encodeHexLowerCase: "encodeHexLowerCase"
+      });
+      imports.addNamed(ast, "@oslojs/crypto/sha2", { sha256: "sha256" });
+      imports.addNamed(ast, "drizzle-orm", { eq: "eq" });
+      if (typescript) {
+        imports.addNamed(ast, "@sveltejs/kit", { RequestEvent: "RequestEvent" }, true);
+      }
+      const ms = new MagicString(generateCode().trim());
+      const [ts] = utils.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`					
+					export function generateSessionToken() {
+						const bytes = crypto.getRandomValues(new Uint8Array(18));
+						const token = encodeBase64url(bytes);
+						return token;
+					}`;
+        ms.append(`
 
 ${generateSessionToken}`);
-        }
-        if (!ms.original.includes("async function createSession")) {
-          const createSession = dedent`
-						${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(`
+      }
+      if (!ms.original.includes("async function createSession")) {
+        const createSession = dedent`
+					${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(`
 
 ${createSession}`);
-        }
-        if (!ms.original.includes("async function validateSessionToken")) {
-          const validateSessionToken = dedent`					
-						${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(`
+      }
+      if (!ms.original.includes("async function validateSessionToken")) {
+        const validateSessionToken = dedent`					
+					${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(`
 
 ${validateSessionToken}`);
-        }
-        if (typescript && !ms.original.includes("export type SessionValidationResult")) {
-          const sessionType = "export type SessionValidationResult = Awaited<ReturnType<typeof validateSessionToken>>;";
-          ms.append(`
+      }
+      if (typescript && !ms.original.includes("export type SessionValidationResult")) {
+        const sessionType = "export type SessionValidationResult = Awaited<ReturnType<typeof validateSessionToken>>;";
+        ms.append(`
 
 ${sessionType}`);
-        }
-        if (!ms.original.includes("async function invalidateSession")) {
-          const invalidateSession = dedent`					
-						${ts("", "/** @param {string} sessionId */")}
-						export async function invalidateSession(sessionId${ts(": string")}) {
-							await db.delete(table.session).where(eq(table.session.id, sessionId));
-						}`;
-          ms.append(`
+      }
+      if (!ms.original.includes("async function invalidateSession")) {
+        const invalidateSession = dedent`					
+					${ts("", "/** @param {string} sessionId */")}
+					export async function invalidateSession(sessionId${ts(": string")}) {
+						await db.delete(table.session).where(eq(table.session.id, sessionId));
+					}`;
+        ms.append(`
 
 ${invalidateSession}`);
-        }
-        if (!ms.original.includes("export function setSessionTokenCookie")) {
-          const setSessionTokenCookie = dedent`					
-						${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(`
+      }
+      if (!ms.original.includes("export function setSessionTokenCookie")) {
+        const setSessionTokenCookie = dedent`					
+					${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(`
 
 ${setSessionTokenCookie}`);
-        }
-        if (!ms.original.includes("export function deleteSessionTokenCookie")) {
-          const deleteSessionTokenCookie = dedent`					
-						${ts("", '/** @param {import("@sveltejs/kit").RequestEvent} event */')}
-						export function deleteSessionTokenCookie(event${ts(": RequestEvent")}) {
-							event.cookies.delete(sessionCookieName, {
-								path: '/'
-							});
-						}`;
-          ms.append(`
+      }
+      if (!ms.original.includes("export function deleteSessionTokenCookie")) {
+        const deleteSessionTokenCookie = dedent`					
+					${ts("", '/** @param {import("@sveltejs/kit").RequestEvent} event */')}
+					export function deleteSessionTokenCookie(event${ts(": RequestEvent")}) {
+						event.cookies.delete(sessionCookieName, {
+							path: '/'
+						});
+					}`;
+        ms.append(`
 
 ${deleteSessionTokenCookie}`);
-        }
-        return ms.toString();
       }
-    },
-    {
-      name: () => "src/app.d.ts",
-      condition: ({ typescript }) => typescript,
-      content: ({ content }) => {
+      return ms.toString();
+    });
+    if (typescript) {
+      sv.file("src/app.d.ts", (content) => {
         const { ast, generateCode } = parseScript(content);
         const locals = kit.addGlobalAppInterface(ast, "Locals");
         if (!locals) {
@@ -7119,30 +7022,21 @@ ${deleteSessionTokenCookie}`);
           locals.body.body.push(createLuciaType("session"));
         }
         return generateCode();
-      }
-    },
-    {
-      name: ({ typescript }) => `src/hooks.server.${typescript ? "ts" : "js"}`,
-      content: ({ content, typescript }) => {
-        const { ast, generateCode } = parseScript(content);
-        imports.addNamespace(ast, "$lib/server/auth.js", "auth");
-        kit.addHooksHandle(ast, typescript, "handleAuth", getAuthHandleContent());
-        return generateCode();
-      }
-    },
-    // DEMO
-    // login/register
-    {
-      name: ({ kit: kit2 }) => `${kit2?.routesDirectory}/demo/+page.svelte`,
-      condition: ({ options: options2 }) => options2.demo,
-      content: (editor) => addToDemoPage(editor, "lucia")
-    },
-    {
-      name: ({ kit: kit2, typescript }) => `${kit2.routesDirectory}/demo/lucia/login/+page.server.${typescript ? "ts" : "js"}`,
-      condition: ({ options: options2 }) => options2.demo,
-      content({ content, typescript, kit: kit2 }) {
+      });
+    }
+    sv.file(`src/hooks.server.${ext}`, (content) => {
+      const { ast, generateCode } = parseScript(content);
+      imports.addNamespace(ast, "$lib/server/auth.js", "auth");
+      kit.addHooksHandle(ast, typescript, "handleAuth", getAuthHandleContent());
+      return generateCode();
+    });
+    if (options2.demo) {
+      sv.file(`${kit$1?.routesDirectory}/demo/+page.svelte`, (content) => {
+        return addToDemoPage(content, "lucia");
+      });
+      sv.file(`${kit$1.routesDirectory}/demo/lucia/login/+page.server.${ext}`, (content) => {
         if (content) {
-          const filePath = `${kit2.routesDirectory}/demo/lucia/login/+page.server.${typescript ? "ts" : "js"}`;
+          const filePath = `${kit$1.routesDirectory}/demo/lucia/login/+page.server.${typescript ? "ts" : "js"}`;
           log.warn(`Existing ${picocolors.yellow(filePath)} file. Could not update.`);
           return content;
         }
@@ -7260,29 +7154,20 @@ ${deleteSessionTokenCookie}`);
 						);
 					}
 				`;
-      }
-    },
-    {
-      name: ({ kit: kit2 }) => `${kit2.routesDirectory}/demo/lucia/login/+page.svelte`,
-      condition: ({ options: options2 }) => options2.demo,
-      content({ content, dependencyVersion, typescript, kit: kit2 }) {
+      });
+      sv.file(`${kit$1.routesDirectory}/demo/lucia/login/+page.svelte`, (content) => {
         if (content) {
-          const filePath = `${kit2.routesDirectory}/demo/lucia/login/+page.svelte`;
+          const filePath = `${kit$1.routesDirectory}/demo/lucia/login/+page.svelte`;
           log.warn(`Existing ${picocolors.yellow(filePath)} file. Could not update.`);
           return content;
         }
         const svelte5 = !!dependencyVersion("svelte")?.startsWith("5");
         const [ts, s5] = utils.createPrinter(typescript, svelte5);
         return dedent(_a || (_a = __template(["\n					<script ", ">\n						import { enhance } from '$app/forms';\n						", "\n						", "\n					<\/script>\n\n					<h1>Login/Register</h1>\n					<form method='post' action='?/login' use:enhance>\n						<label>\n							Username\n							<input name='username' />\n						</label>\n						<label>\n							Password\n							<input type='password' name='password' />\n						</label>\n						<button>Login</button>\n						<button formaction='?/register'>Register</button>\n					</form>\n					<p style='color: red'>{form?.message ?? ''}</p>\n				"])), ts("lang='ts'"), ts("import type { ActionData } from './$types';\n"), s5(`let { form }${ts(": { form: ActionData }")} = $props();`, `export let form${ts(": ActionData")};`));
-      }
-    },
-    // logout
-    {
-      name: ({ kit: kit2, typescript }) => `${kit2.routesDirectory}/demo/lucia/+page.server.${typescript ? "ts" : "js"}`,
-      condition: ({ options: options2 }) => options2.demo,
-      content({ content, typescript, kit: kit2 }) {
+      });
+      sv.file(`${kit$1.routesDirectory}/demo/lucia/+page.server.${ext}`, (content) => {
         if (content) {
-          const filePath = `${kit2.routesDirectory}/demo/lucia/+page.server.${typescript ? "ts" : "js"}`;
+          const filePath = `${kit$1.routesDirectory}/demo/lucia/+page.server.${typescript ? "ts" : "js"}`;
           log.warn(`Existing ${picocolors.yellow(filePath)} file. Could not update.`);
           return content;
         }
@@ -7310,23 +7195,19 @@ ${deleteSessionTokenCookie}`);
 						},
 					};
 				`;
-      }
-    },
-    {
-      name: ({ kit: kit2 }) => `${kit2.routesDirectory}/demo/lucia/+page.svelte`,
-      condition: ({ options: options2 }) => options2.demo,
-      content({ content, dependencyVersion, typescript, kit: kit2 }) {
+      });
+      sv.file(`${kit$1.routesDirectory}/demo/lucia/+page.svelte`, (content) => {
         if (content) {
-          const filePath = `${kit2.routesDirectory}/demo/lucia/+page.svelte`;
+          const filePath = `${kit$1.routesDirectory}/demo/lucia/+page.svelte`;
           log.warn(`Existing ${picocolors.yellow(filePath)} file. Could not update.`);
           return content;
         }
         const svelte5 = !!dependencyVersion("svelte")?.startsWith("5");
         const [ts, s5] = utils.createPrinter(typescript, svelte5);
         return dedent(_b || (_b = __template(["\n					<script ", ">\n						import { enhance } from '$app/forms';\n						", "\n						", "\n					<\/script>\n\n					<h1>Hi, {data.user.username}!</h1>\n					<p>Your user ID is {data.user.id}.</p>\n					<form method='post' action='?/logout' 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")};`));
-      }
+      });
     }
-  ],
+  },
   nextSteps: ({ highlighter, options: options2, packageManager }) => {
     const steps = [
       `Run ${highlighter.command(`${packageManager} run db:push`)} to update your database schema`
@@ -7400,36 +7281,32 @@ function getCallExpression(ast) {
   return callExpression;
 }
 
-var mdsvex = defineAdder({
+var mdsvex = defineAddon({
   id: "mdsvex",
-  environments: { svelte: true, kit: true },
   homepage: "https://mdsvex.pngwn.io",
   options: {},
-  packages: [{ name: "mdsvex", version: "^0.11.2", dev: true }],
-  files: [
-    {
-      name: () => "svelte.config.js",
-      content: ({ content }) => {
-        const { ast, generateCode } = parseScript(content);
-        imports.addNamed(ast, "mdsvex", { mdsvex: "mdsvex" });
-        const { value: exportDefault } = exports$1.defaultExport(ast, object$1.createEmpty());
-        let preprocessorArray = object$1.property(exportDefault, "preprocess", array$1.createEmpty());
-        const isArray = preprocessorArray.type === "ArrayExpression";
-        if (!isArray) {
-          const previousElement = preprocessorArray;
-          preprocessorArray = array$1.createEmpty();
-          array$1.push(preprocessorArray, previousElement);
-          object$1.overrideProperty(exportDefault, "preprocess", preprocessorArray);
-        }
-        const mdsvexCall = _function.call("mdsvex", []);
-        array$1.push(preprocessorArray, mdsvexCall);
-        const extensionsArray = object$1.property(exportDefault, "extensions", array$1.createEmpty());
-        array$1.push(extensionsArray, ".svelte");
-        array$1.push(extensionsArray, ".svx");
-        return generateCode();
-      }
-    }
-  ]
+  run: ({ sv }) => {
+    sv.devDependency("mdsvex", "^0.11.2");
+    sv.file("svelte.config.js", (content) => {
+      const { ast, generateCode } = parseScript(content);
+      imports.addNamed(ast, "mdsvex", { mdsvex: "mdsvex" });
+      const { value: exportDefault } = exports$1.defaultExport(ast, object$1.createEmpty());
+      let preprocessorArray = object$1.property(exportDefault, "preprocess", array$1.createEmpty());
+      const isArray = preprocessorArray.type === "ArrayExpression";
+      if (!isArray) {
+        const previousElement = preprocessorArray;
+        preprocessorArray = array$1.createEmpty();
+        array$1.push(preprocessorArray, previousElement);
+        object$1.overrideProperty(exportDefault, "preprocess", preprocessorArray);
+      }
+      const mdsvexCall = _function.call("mdsvex", []);
+      array$1.push(preprocessorArray, mdsvexCall);
+      const extensionsArray = object$1.property(exportDefault, "extensions", array$1.createEmpty());
+      array$1.push(extensionsArray, ".svelte");
+      array$1.push(extensionsArray, ".svx");
+      return generateCode();
+    });
+  }
 });
 
 function element(tagName, attributes = {}) {
@@ -7472,7 +7349,7 @@ const DEFAULT_INLANG_PROJECT = {
     pathPattern: "./messages/{languageTag}.json"
   }
 };
-const options$2 = defineAdderOptions({
+const options$2 = defineAddonOptions({
   availableLanguageTags: {
     question: `Which languages would you like to support? ${picocolors.gray("(e.g. en,de-ch)")}`,
     type: "string",
@@ -7498,162 +7375,118 @@ const options$2 = defineAdderOptions({
     question: "Do you want to include a demo?"
   }
 });
-var paraglide = defineAdder({
+var paraglide = defineAddon({
   id: "paraglide",
-  environments: { svelte: false, kit: true },
   homepage: "https://inlang.com",
   options: options$2,
-  packages: [
-    {
-      name: "@inlang/paraglide-sveltekit",
-      version: "^0.11.1",
-      dev: false
-    }
-  ],
-  files: [
-    {
-      // create an inlang project if it doesn't exist yet
-      name: () => "project.inlang/settings.json",
-      condition: ({ cwd }) => !fs$3.existsSync(path$2.join(cwd, "project.inlang/settings.json")),
-      content: ({ options: options2, content }) => {
-        const { data, generateCode } = parseJson(content);
-        for (const key in DEFAULT_INLANG_PROJECT) {
-          data[key] = DEFAULT_INLANG_PROJECT[key];
-        }
-        const { validLanguageTags } = parseLanguageTagInput(options2.availableLanguageTags);
-        const sourceLanguageTag = validLanguageTags[0];
-        data.sourceLanguageTag = sourceLanguageTag;
-        data.languageTags = validLanguageTags;
-        return generateCode();
-      }
-    },
-    {
-      // add the vite plugin
-      name: ({ typescript }) => `vite.config.${typescript ? "ts" : "js"}`,
-      content: ({ content }) => {
-        const { ast, generateCode } = parseScript(content);
-        const vitePluginName = "paraglide";
-        imports.addNamed(ast, "@inlang/paraglide-sveltekit/vite", { paraglide: vitePluginName });
-        const { value: rootObject } = exports$1.defaultExport(
-          ast,
-          _function.call("defineConfig", [])
-        );
-        const param1 = _function.argumentByIndex(rootObject, 0, object$1.createEmpty());
-        const pluginsArray = object$1.property(param1, "plugins", array$1.createEmpty());
-        const pluginFunctionCall = _function.call(vitePluginName, []);
-        const pluginConfig = object$1.create({
-          project: common.createLiteral("./project.inlang"),
-          outdir: common.createLiteral("./src/lib/paraglide")
-        });
-        _function.argumentByIndex(pluginFunctionCall, 0, pluginConfig);
-        array$1.push(pluginsArray, pluginFunctionCall);
-        return generateCode();
-      }
-    },
-    {
-      // src/lib/i18n file
-      name: ({ typescript }) => `src/lib/i18n.${typescript ? "ts" : "js"}`,
-      content({ content }) {
-        const { ast, generateCode } = parseScript(content);
-        imports.addNamed(ast, "@inlang/paraglide-sveltekit", { createI18n: "createI18n" });
-        imports.addDefault(ast, "$lib/paraglide/runtime", "* as runtime");
-        const createI18nExpression = common.expressionFromString("createI18n(runtime)");
-        const i18n = variables.declaration(ast, "const", "i18n", createI18nExpression);
-        const existingExport = exports$1.namedExport(ast, "i18n", i18n);
-        if (existingExport.declaration != i18n) {
-          log.warn("Setting up $lib/i18n failed because it already exports an i18n function");
-        }
-        return generateCode();
-      }
-    },
-    {
-      // reroute hook
-      name: ({ typescript }) => `src/hooks.${typescript ? "ts" : "js"}`,
-      content({ content }) {
-        const { ast, generateCode } = parseScript(content);
-        imports.addNamed(ast, "$lib/i18n", {
-          i18n: "i18n"
-        });
-        const expression = common.expressionFromString("i18n.reroute()");
-        const rerouteIdentifier = variables.declaration(ast, "const", "reroute", expression);
-        const existingExport = exports$1.namedExport(ast, "reroute", rerouteIdentifier);
-        if (existingExport.declaration != rerouteIdentifier) {
-          log.warn("Adding the reroute hook automatically failed. Add it manually");
-        }
-        return generateCode();
-      }
-    },
-    {
-      // handle hook
-      name: ({ typescript }) => `src/hooks.server.${typescript ? "ts" : "js"}`,
-      content({ content, typescript }) {
-        const { ast, generateCode } = parseScript(content);
-        imports.addNamed(ast, "$lib/i18n", {
-          i18n: "i18n"
-        });
-        const hookHandleContent = "i18n.handle()";
-        kit.addHooksHandle(ast, typescript, "handleParaglide", hookHandleContent);
-        return generateCode();
-      }
-    },
-    {
-      // add the <ParaglideJS> component to the layout
-      name: ({ kit: kit2 }) => `${kit2?.routesDirectory}/+layout.svelte`,
-      content: ({ content, dependencyVersion, typescript }) => {
-        const { script, template, generateCode } = parseSvelte(content, { typescript });
-        const paraglideComponentName = "ParaglideJS";
-        imports.addNamed(script.ast, "@inlang/paraglide-sveltekit", {
-          [paraglideComponentName]: paraglideComponentName
-        });
-        imports.addNamed(script.ast, "$lib/i18n", {
-          i18n: "i18n"
-        });
-        if (template.source.length === 0) {
-          const svelteVersion = dependencyVersion("svelte");
-          if (!svelteVersion) throw new Error("Failed to determine svelte version");
-          addSlot(script.ast, template.ast, svelteVersion);
-        }
-        const templateCode = new MagicString(template.generateCode());
-        if (!templateCode.original.includes("<ParaglideJS")) {
-          templateCode.indent();
-          templateCode.prepend("<ParaglideJS {i18n}>\n");
-          templateCode.append("\n</ParaglideJS>");
-        }
-        return generateCode({ script: script.generateCode(), template: templateCode.toString() });
-      }
-    },
-    {
-      // add the text-direction and lang attribute placeholders to app.html
-      name: () => "src/app.html",
-      content: ({ content }) => {
-        const { ast, generateCode } = parseHtml$1(content);
-        const htmlNode = ast.children.find(
-          (child) => child.type === index.Tag && child.name === "html"
+  setup: ({ kit, unsupported }) => {
+    if (!kit) unsupported("Requires SvelteKit");
+  },
+  run: ({ sv, options: options2, typescript, kit: kit$1, dependencyVersion }) => {
+    const ext = typescript ? "ts" : "js";
+    if (!kit$1) throw new Error("SvelteKit is required");
+    sv.dependency("@inlang/paraglide-sveltekit", "^0.11.1");
+    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: validLanguageTags2 } = parseLanguageTagInput(options2.availableLanguageTags);
+      const sourceLanguageTag = validLanguageTags2[0];
+      data.sourceLanguageTag = sourceLanguageTag;
+      data.languageTags = validLanguageTags2;
+      return generateCode();
+    });
+    sv.file(`vite.config.${ext}`, (content) => {
+      const { ast, generateCode } = parseScript(content);
+      const vitePluginName = "paraglide";
+      imports.addNamed(ast, "@inlang/paraglide-sveltekit/vite", { paraglide: vitePluginName });
+      const { value: rootObject } = exports$1.defaultExport(ast, _function.call("defineConfig", []));
+      const param1 = _function.argumentByIndex(rootObject, 0, object$1.createEmpty());
+      const pluginsArray = object$1.property(param1, "plugins", array$1.createEmpty());
+      const pluginFunctionCall = _function.call(vitePluginName, []);
+      const pluginConfig = object$1.create({
+        project: common.createLiteral("./project.inlang"),
+        outdir: common.createLiteral("./src/lib/paraglide")
+      });
+      _function.argumentByIndex(pluginFunctionCall, 0, pluginConfig);
+      array$1.push(pluginsArray, pluginFunctionCall);
+      return generateCode();
+    });
+    sv.file(`src/lib/i18n.${ext}`, (content) => {
+      const { ast, generateCode } = parseScript(content);
+      imports.addNamed(ast, "@inlang/paraglide-sveltekit", { createI18n: "createI18n" });
+      imports.addDefault(ast, "$lib/paraglide/runtime", "* as runtime");
+      const createI18nExpression = common.expressionFromString("createI18n(runtime)");
+      const i18n = variables.declaration(ast, "const", "i18n", createI18nExpression);
+      const existingExport = exports$1.namedExport(ast, "i18n", i18n);
+      if (existingExport.declaration !== i18n) {
+        log.warn("Setting up $lib/i18n failed because it already exports an i18n function");
+      }
+      return generateCode();
+    });
+    sv.file(`src/hooks.${ext}`, (content) => {
+      const { ast, generateCode } = parseScript(content);
+      imports.addNamed(ast, "$lib/i18n", { i18n: "i18n" });
+      const expression = common.expressionFromString("i18n.reroute()");
+      const rerouteIdentifier = variables.declaration(ast, "const", "reroute", expression);
+      const existingExport = exports$1.namedExport(ast, "reroute", rerouteIdentifier);
+      if (existingExport.declaration !== rerouteIdentifier) {
+        log.warn("Adding the reroute hook automatically failed. Add it manually");
+      }
+      return generateCode();
+    });
+    sv.file(`src/hooks.server.${ext}`, (content) => {
+      const { ast, generateCode } = parseScript(content);
+      imports.addNamed(ast, "$lib/i18n", { i18n: "i18n" });
+      const hookHandleContent = "i18n.handle()";
+      kit.addHooksHandle(ast, typescript, "handleParaglide", hookHandleContent);
+      return generateCode();
+    });
+    sv.file(`${kit$1.routesDirectory}/+layout.svelte`, (content) => {
+      const { script, template, generateCode } = parseSvelte(content, { typescript });
+      const paraglideComponentName = "ParaglideJS";
+      imports.addNamed(script.ast, "@inlang/paraglide-sveltekit", {
+        [paraglideComponentName]: paraglideComponentName
+      });
+      imports.addNamed(script.ast, "$lib/i18n", { i18n: "i18n" });
+      if (template.source.length === 0) {
+        const svelteVersion = dependencyVersion("svelte");
+        if (!svelteVersion) throw new Error("Failed to determine svelte version");
+        addSlot(script.ast, template.ast, svelteVersion);
+      }
+      const templateCode = new MagicString(template.generateCode());
+      if (!templateCode.original.includes("<ParaglideJS")) {
+        templateCode.indent();
+        templateCode.prepend("<ParaglideJS {i18n}>\n");
+        templateCode.append("\n</ParaglideJS>");
+      }
+      return generateCode({ script: script.generateCode(), template: templateCode.toString() });
+    });
+    sv.file("src/app.html", (content) => {
+      const { ast, generateCode } = parseHtml$1(content);
+      const htmlNode = ast.children.find(
+        (child) => child.type === index.Tag && child.name === "html"
+      );
+      if (!htmlNode) {
+        log.warn(
+          "Could not find <html> node in app.html. You'll need to add the language placeholder manually"
         );
-        if (!htmlNode) {
-          log.warn(
-            "Could not find <html> node in app.html. You'll need to add the language placeholder manually"
-          );
-          return generateCode();
-        }
-        htmlNode.attribs = {
-          ...htmlNode.attribs,
-          lang: "%paraglide.lang%",
-          dir: "%paraglide.textDirection%"
-        };
         return generateCode();
       }
-    },
-    {
-      name: ({ kit: kit2 }) => `${kit2?.routesDirectory}/demo/+page.svelte`,
-      condition: ({ options: options2 }) => options2.demo,
-      content: (editor) => addToDemoPage(editor, "paraglide")
-    },
-    {
-      // add usage example
-      name: ({ kit: kit2 }) => `${kit2?.routesDirectory}/demo/paraglide/+page.svelte`,
-      condition: ({ options: options2 }) => options2.demo,
-      content({ content, options: options2, typescript }) {
+      htmlNode.attribs = {
+        ...htmlNode.attribs,
+        lang: "%paraglide.lang%",
+        dir: "%paraglide.textDirection%"
+      };
+      return generateCode();
+    });
+    if (options2.demo) {
+      sv.file(`${kit$1.routesDirectory}/demo/+page.svelte`, (content) => {
+        return addToDemoPage(content, "paraglide");
+      });
+      sv.file(`${kit$1.routesDirectory}/demo/paraglide/+page.svelte`, (content) => {
         const { script, template, generateCode } = parseSvelte(content, { typescript });
         imports.addDefault(script.ast, "$lib/paraglide/messages.js", "* as m");
         imports.addNamed(script.ast, "$app/navigation", { goto: "goto" });
@@ -7673,41 +7506,36 @@ var paraglide = defineAdder({
           scriptCode.trim();
           scriptCode.append("\n\n");
           scriptCode.append(dedent`
-					${ts("", "/**")} 
-					${ts("", '* @param import("$lib/paraglide/runtime").AvailableLanguageTag newLanguage')} 
-					${ts("", "*/")} 
-					function switchToLanguage(newLanguage${ts(": AvailableLanguageTag")}) {
-						const canonicalPath = i18n.route($page.url.pathname);
-						const localisedPath = i18n.resolveRoute(canonicalPath, newLanguage);
-						goto(localisedPath);
-					}
-				`);
+						${ts("", "/**")} 
+						${ts("", '* @param import("$lib/paraglide/runtime").AvailableLanguageTag newLanguage')} 
+						${ts("", "*/")} 
+						function switchToLanguage(newLanguage${ts(": AvailableLanguageTag")}) {
+							const canonicalPath = i18n.route($page.url.pathname);
+							const localisedPath = i18n.resolveRoute(canonicalPath, newLanguage);
+							goto(localisedPath);
+						}
+					`);
         }
         const templateCode = new MagicString(template.source);
         templateCode.append("\n\n<h1>{m.hello_world({ name: 'SvelteKit User' })}</h1>\n");
-        const { validLanguageTags } = parseLanguageTagInput(options2.availableLanguageTags);
-        const links = validLanguageTags.map(
+        const { validLanguageTags: validLanguageTags2 } = parseLanguageTagInput(options2.availableLanguageTags);
+        const links = validLanguageTags2.map(
           (x) => `${templateCode.getIndentString()}<button onclick={() => switchToLanguage('${x}')}>${x}</button>`
         ).join("\n");
         templateCode.append(`<div>
 ${links}
 </div>`);
         return generateCode({ script: scriptCode.toString(), template: templateCode.toString() });
-      }
+      });
     }
-  ],
-  postInstall: ({ cwd, options: options2 }) => {
-    const jsonData = {};
-    jsonData["$schema"] = "https://inlang.com/schema/inlang-message-format";
     const { validLanguageTags } = parseLanguageTagInput(options2.availableLanguageTags);
     for (const languageTag of validLanguageTags) {
-      jsonData.hello_world = `Hello, {name} from ${languageTag}!`;
-      const filePath = `messages/${languageTag}.json`;
-      const directoryPath = path$2.dirname(filePath);
-      const fullDirectoryPath = path$2.join(cwd, directoryPath);
-      const fullFilePath = path$2.join(cwd, filePath);
-      fs$3.mkdirSync(fullDirectoryPath, { recursive: true });
-      fs$3.writeFileSync(fullFilePath, JSON.stringify(jsonData, null, 2) + "\n");
+      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 }) => {
@@ -7741,181 +7569,142 @@ function parseLanguageTagInput(input) {
   };
 }
 
-var playwright = defineAdder({
+var playwright = defineAddon({
   id: "playwright",
-  environments: { svelte: true, kit: true },
   homepage: "https://playwright.dev",
   options: {},
-  packages: [{ name: "@playwright/test", version: "^1.45.3", dev: true }],
-  files: [
-    {
-      name: () => "package.json",
-      content: ({ content }) => {
-        const { data, generateCode } = parseJson(content);
-        data.scripts ?? (data.scripts = {});
-        const scripts = data.scripts;
-        const TEST_CMD = "playwright test";
-        const RUN_TEST = "npm run test:e2e";
-        scripts["test:e2e"] ?? (scripts["test:e2e"] = TEST_CMD);
-        scripts["test"] ?? (scripts["test"] = RUN_TEST);
-        if (!scripts["test"].includes(RUN_TEST)) scripts["test"] += ` && ${RUN_TEST}`;
-        return generateCode();
-      }
-    },
-    {
-      name: () => ".gitignore",
-      condition: ({ cwd }) => fs$3.existsSync(join(cwd, ".gitignore")),
-      content: ({ content }) => {
-        if (content.includes("test-results")) return content;
-        return "test-results\n" + content.trim();
-      }
-    },
-    {
-      name: ({ typescript }) => `e2e/demo.test.${typescript ? "ts" : "js"}`,
-      content: ({ content }) => {
-        if (content) return content;
-        return dedent`
-					import { expect, test } from '@playwright/test';
-
-					test('home page has expected h1', async ({ page }) => {
-						await page.goto('/');
-						await expect(page.locator('h1')).toBeVisible();
-					});
-					`;
-      }
-    },
-    {
-      name: ({ typescript }) => `playwright.config.${typescript ? "ts" : "js"}`,
-      content: ({ content }) => {
-        const { ast, generateCode } = parseScript(content);
-        const defineConfig = common.expressionFromString("defineConfig({})");
-        const defaultExport = exports$1.defaultExport(ast, defineConfig);
-        const config = {
-          webServer: object$1.create({
-            command: common.createLiteral("npm run build && npm run preview"),
-            port: common.expressionFromString("4173")
-          }),
-          testDir: common.createLiteral("e2e")
-        };
-        if (defaultExport.value.type === "CallExpression" && defaultExport.value.arguments[0]?.type === "ObjectExpression") {
-          imports.addNamed(ast, "@playwright/test", { defineConfig: "defineConfig" });
-          object$1.properties(defaultExport.value.arguments[0], config);
-        } else if (defaultExport.value.type === "ObjectExpression") {
-          object$1.properties(defaultExport.value, config);
-        } else {
-          log.warn("Unexpected playwright config for playwright adder. Could not update.");
-        }
-        return generateCode();
+  run: ({ sv, typescript }) => {
+    const ext = typescript ? "ts" : "js";
+    sv.devDependency("@playwright/test", "^1.45.3");
+    sv.file("package.json", (content) => {
+      const { data, generateCode } = parseJson(content);
+      data.scripts ?? (data.scripts = {});
+      const scripts = data.scripts;
+      const TEST_CMD = "playwright test";
+      const RUN_TEST = "npm run test:e2e";
+      scripts["test:e2e"] ?? (scripts["test:e2e"] = TEST_CMD);
+      scripts["test"] ?? (scripts["test"] = RUN_TEST);
+      if (!scripts["test"].includes(RUN_TEST)) scripts["test"] += ` && ${RUN_TEST}`;
+      return generateCode();
+    });
+    sv.file(".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`
+				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 = common.expressionFromString("defineConfig({})");
+      const defaultExport = exports$1.defaultExport(ast, defineConfig);
+      const config = {
+        webServer: object$1.create({
+          command: common.createLiteral("npm run build && npm run preview"),
+          port: common.expressionFromString("4173")
+        }),
+        testDir: common.createLiteral("e2e")
+      };
+      if (defaultExport.value.type === "CallExpression" && defaultExport.value.arguments[0]?.type === "ObjectExpression") {
+        imports.addNamed(ast, "@playwright/test", { defineConfig: "defineConfig" });
+        object$1.properties(defaultExport.value.arguments[0], config);
+      } else if (defaultExport.value.type === "ObjectExpression") {
+        object$1.properties(defaultExport.value, config);
+      } else {
+        log.warn("Unexpected playwright config for playwright add-on. Could not update.");
       }
-    }
-  ]
+      return generateCode();
+    });
+  }
 });
 
-var prettier = defineAdder({
+var prettier = defineAddon({
   id: "prettier",
-  environments: { svelte: true, kit: true },
   homepage: "https://prettier.io",
   options: {},
-  packages: [
-    { name: "prettier", version: "^3.3.2", dev: true },
-    { name: "prettier-plugin-svelte", version: "^3.2.6", dev: true },
-    {
-      name: "eslint-config-prettier",
-      version: "^9.1.0",
-      dev: true,
-      condition: ({ dependencyVersion }) => hasEslint(dependencyVersion)
-    }
-  ],
-  files: [
-    {
-      name: () => ".prettierignore",
-      content: ({ content }) => {
-        if (content) return content;
-        return dedent`
-                    # Package Managers
-                    package-lock.json
-                    pnpm-lock.yaml
-                    yarn.lock
-                `;
-      }
-    },
-    {
-      name: () => ".prettierrc",
-      content: ({ content }) => {
-        const { data, generateCode } = parseJson(content);
-        if (Object.keys(data).length === 0) {
-          data.useTabs = true;
-          data.singleQuote = true;
-          data.trailingComma = "none";
-          data.printWidth = 100;
-        }
-        data.plugins ?? (data.plugins = []);
-        data.overrides ?? (data.overrides = []);
-        const plugins = data.plugins;
-        if (!plugins.includes("prettier-plugin-svelte")) {
-          data.plugins.unshift("prettier-plugin-svelte");
-        }
-        const overrides = data.overrides;
-        const override = overrides.find((o) => o?.options?.parser === "svelte");
-        if (!override) {
-          overrides.push({ files: "*.svelte", options: { parser: "svelte" } });
-        }
-        return generateCode();
-      }
-    },
-    {
-      name: () => "package.json",
-      content: ({ content, dependencyVersion }) => {
-        const { data, generateCode } = parseJson(content);
-        data.scripts ?? (data.scripts = {});
-        const scripts = data.scripts;
-        const CHECK_CMD = "prettier --check .";
-        scripts["format"] ?? (scripts["format"] = "prettier --write .");
-        if (hasEslint(dependencyVersion)) {
-          scripts["lint"] ?? (scripts["lint"] = `${CHECK_CMD} && eslint .`);
-          if (!scripts["lint"].includes(CHECK_CMD)) scripts["lint"] += ` && ${CHECK_CMD}`;
-        } else {
-          scripts["lint"] ?? (scripts["lint"] = CHECK_CMD);
-        }
-        return generateCode();
+  run: ({ sv, dependencyVersion }) => {
+    sv.devDependency("prettier", "^3.3.2");
+    sv.devDependency("prettier-plugin-svelte", "^3.2.6");
+    sv.file(".prettierignore", (content) => {
+      if (content) return content;
+      return dedent`
+				# Package Managers
+				package-lock.json
+				pnpm-lock.yaml
+				yarn.lock
+			`;
+    });
+    sv.file(".prettierrc", (content) => {
+      const { data, generateCode } = parseJson(content);
+      if (Object.keys(data).length === 0) {
+        data.useTabs = true;
+        data.singleQuote = true;
+        data.trailingComma = "none";
+        data.printWidth = 100;
+      }
+      data.plugins ?? (data.plugins = []);
+      data.overrides ?? (data.overrides = []);
+      const plugins = data.plugins;
+      if (!plugins.includes("prettier-plugin-svelte")) {
+        data.plugins.unshift("prettier-plugin-svelte");
+      }
+      const overrides = data.overrides;
+      const override = overrides.find((o) => o?.options?.parser === "svelte");
+      if (!override) {
+        overrides.push({ files: "*.svelte", options: { parser: "svelte" } });
+      }
+      return generateCode();
+    });
+    const eslintVersion = dependencyVersion("eslint");
+    const eslintInstalled = hasEslint(eslintVersion);
+    sv.file("package.json", (content) => {
+      const { data, generateCode } = parseJson(content);
+      data.scripts ?? (data.scripts = {});
+      const scripts = data.scripts;
+      const CHECK_CMD = "prettier --check .";
+      scripts["format"] ?? (scripts["format"] = "prettier --write .");
+      if (eslintInstalled) {
+        scripts["lint"] ?? (scripts["lint"] = `${CHECK_CMD} && eslint .`);
+        if (!scripts["lint"].includes(CHECK_CMD)) scripts["lint"] += ` && ${CHECK_CMD}`;
+      } else {
+        scripts["lint"] ?? (scripts["lint"] = CHECK_CMD);
       }
-    },
-    {
-      name: () => "eslint.config.js",
-      condition: ({ dependencyVersion }) => {
-        if (dependencyVersion("eslint")?.startsWith(SUPPORTED_ESLINT_VERSION) === false) {
-          log.warn(
-            `An older major version of ${picocolors.yellow(
-              "eslint"
-            )} was detected. Skipping ${picocolors.yellow("eslint-config-prettier")} installation.`
-          );
-        }
-        return hasEslint(dependencyVersion);
-      },
-      content: addEslintConfigPrettier
+      return generateCode();
+    });
+    if (eslintVersion?.startsWith(SUPPORTED_ESLINT_VERSION) === false) {
+      log.warn(
+        `An older major version of ${picocolors.yellow(
+          "eslint"
+        )} was detected. Skipping ${picocolors.yellow("eslint-config-prettier")} installation.`
+      );
     }
-  ]
+    if (eslintInstalled) {
+      sv.devDependency("eslint-config-prettier", "^9.1.0");
+      sv.file("eslint.config.js", addEslintConfigPrettier);
+    }
+  }
 });
 const SUPPORTED_ESLINT_VERSION = "9";
-function hasEslint(dependencyVersion) {
-  const version = dependencyVersion("eslint");
+function hasEslint(version) {
   return !!version && version.startsWith(SUPPORTED_ESLINT_VERSION);
 }
 
-var storybook = defineAdder({
+var storybook = defineAddon({
   id: "storybook",
-  environments: { kit: true, svelte: true },
   homepage: "https://storybook.js.org",
   options: {},
-  packages: [],
-  scripts: [
-    {
-      description: "applies storybook",
-      args: ["storybook@8.3.6", "init", "--skip-install", "--no-dev"],
-      stdio: "inherit"
-    }
-  ],
-  files: []
+  run: async ({ sv }) => {
+    await sv.execute(["storybook@latest", "init", "--skip-install", "--no-dev"], "inherit");
+  }
 });
 
 function addImports(ast, imports) {
@@ -7959,13 +7748,7 @@ const plugins = [
     identifier: "aspectRatio"
   }
 ];
-const pluginPackages = plugins.map((x) => ({
-  name: x.package,
-  version: x.version,
-  dev: true,
-  condition: ({ options: options2 }) => options2.plugins.includes(x.id)
-}));
-const options$1 = defineAdderOptions({
+const options$1 = defineAddonOptions({
   plugins: {
     type: "multiselect",
     question: "Which plugins would you like to add?",
@@ -7973,102 +7756,86 @@ const options$1 = defineAdderOptions({
     default: []
   }
 });
-var tailwindcss = defineAdder({
+var tailwindcss = defineAddon({
   id: "tailwindcss",
   alias: "tailwind",
-  environments: { svelte: true, kit: true },
   homepage: "https://tailwindcss.com",
   options: options$1,
-  packages: [
-    { name: "tailwindcss", version: "^3.4.9", dev: true },
-    { name: "autoprefixer", version: "^10.4.20", dev: true },
-    {
-      name: "prettier-plugin-tailwindcss",
-      version: "^0.6.5",
-      dev: true,
-      condition: ({ dependencyVersion }) => Boolean(dependencyVersion("prettier"))
-    },
-    ...pluginPackages
-  ],
-  files: [
-    {
-      name: ({ typescript }) => `tailwind.config.${typescript ? "ts" : "js"}`,
-      content: ({ options: options2, typescript, content }) => {
-        const { ast, generateCode } = parseScript(content);
-        let root;
-        const rootExport = object$1.createEmpty();
-        if (typescript) {
-          imports.addNamed(ast, "tailwindcss", { Config: "Config" }, true);
-          root = common.satisfiesExpression(rootExport, "Config");
-        }
-        const { astNode: exportDeclaration, value: node } = exports$1.defaultExport(
-          ast,
-          root ?? rootExport
-        );
-        const config = node.type === "TSSatisfiesExpression" ? node.expression : node;
-        if (config.type !== "ObjectExpression") {
-          throw new Error(`Unexpected tailwind config shape: ${config.type}`);
-        }
-        if (!typescript) {
-          common.addJsDocTypeComment(exportDeclaration, "import('tailwindcss').Config");
-        }
-        const contentArray = object$1.property(config, "content", array$1.createEmpty());
-        array$1.push(contentArray, "./src/**/*.{html,js,svelte,ts}");
-        const themeObject = object$1.property(config, "theme", object$1.createEmpty());
-        object$1.property(themeObject, "extend", object$1.createEmpty());
-        const pluginsArray = object$1.property(config, "plugins", array$1.createEmpty());
-        for (const plugin of plugins) {
-          if (!options2.plugins.includes(plugin.id)) continue;
-          imports.addDefault(ast, plugin.package, plugin.identifier);
-          array$1.push(pluginsArray, { type: "Identifier", name: plugin.identifier });
-        }
-        return generateCode();
-      }
-    },
-    {
-      name: () => "postcss.config.js",
-      content: ({ content }) => {
-        const { ast, generateCode } = parseScript(content);
-        const { value: rootObject } = exports$1.defaultExport(ast, object$1.createEmpty());
-        const pluginsObject = object$1.property(rootObject, "plugins", object$1.createEmpty());
-        object$1.property(pluginsObject, "tailwindcss", object$1.createEmpty());
-        object$1.property(pluginsObject, "autoprefixer", object$1.createEmpty());
-        return generateCode();
+  run: ({ sv, options: options2, typescript, kit, dependencyVersion }) => {
+    const ext = typescript ? "ts" : "js";
+    const prettierInstalled = Boolean(dependencyVersion("prettier"));
+    sv.devDependency("tailwindcss", "^3.4.9");
+    sv.devDependency("autoprefixer", "^10.4.20");
+    if (prettierInstalled) sv.devDependency("prettier-plugin-tailwindcss", "^0.6.5");
+    for (const plugin of plugins) {
+      if (!options2.plugins.includes(plugin.id)) continue;
+      sv.dependency(plugin.package, plugin.version);
+    }
+    sv.file(`tailwind.config.${ext}`, (content) => {
+      const { ast, generateCode } = parseScript(content);
+      let root;
+      const rootExport = object$1.createEmpty();
+      if (typescript) {
+        imports.addNamed(ast, "tailwindcss", { Config: "Config" }, true);
+        root = common.satisfiesExpression(rootExport, "Config");
+      }
+      const { astNode: exportDeclaration, value: node } = exports$1.defaultExport(
+        ast,
+        root ?? rootExport
+      );
+      const config = node.type === "TSSatisfiesExpression" ? node.expression : node;
+      if (config.type !== "ObjectExpression") {
+        throw new Error(`Unexpected tailwind config shape: ${config.type}`);
+      }
+      if (!typescript) {
+        common.addJsDocTypeComment(exportDeclaration, "import('tailwindcss').Config");
+      }
+      const contentArray = object$1.property(config, "content", array$1.createEmpty());
+      array$1.push(contentArray, "./src/**/*.{html,js,svelte,ts}");
+      const themeObject = object$1.property(config, "theme", object$1.createEmpty());
+      object$1.property(themeObject, "extend", object$1.createEmpty());
+      const pluginsArray = object$1.property(config, "plugins", array$1.createEmpty());
+      for (const plugin of plugins) {
+        if (!options2.plugins.includes(plugin.id)) continue;
+        imports.addDefault(ast, plugin.package, plugin.identifier);
+        array$1.push(pluginsArray, { type: "Identifier", name: plugin.identifier });
+      }
+      return generateCode();
+    });
+    sv.file("postcss.config.js", (content) => {
+      const { ast, generateCode } = parseScript(content);
+      const { value: rootObject } = exports$1.defaultExport(ast, object$1.createEmpty());
+      const pluginsObject = object$1.property(rootObject, "plugins", object$1.createEmpty());
+      object$1.property(pluginsObject, "tailwindcss", object$1.createEmpty());
+      object$1.property(pluginsObject, "autoprefixer", object$1.createEmpty());
+      return generateCode();
+    });
+    sv.file("src/app.css", (content) => {
+      const layerImports = ["base", "components", "utilities"].map(
+        (layer) => `tailwindcss/${layer}`
+      );
+      if (layerImports.every((i) => content.includes(i))) {
+        return content;
       }
-    },
-    {
-      name: () => "src/app.css",
-      content: ({ content }) => {
-        const layerImports = ["base", "components", "utilities"].map(
-          (layer) => `tailwindcss/${layer}`
-        );
-        if (layerImports.every((i) => content.includes(i))) {
-          return content;
-        }
-        const { ast, generateCode } = parseCss(content);
-        const originalFirst = ast.first;
-        const specifiers = layerImports.map((i) => `'${i}'`);
-        const nodes = addImports(ast, specifiers);
-        if (originalFirst !== ast.first && originalFirst?.type === "atrule" && originalFirst.name === "import") {
-          originalFirst.raws.before = "\n";
-        }
-        nodes.shift();
-        nodes.forEach((n) => n.raws.before = "\n");
-        return generateCode();
+      const { ast, generateCode } = parseCss(content);
+      const originalFirst = ast.first;
+      const specifiers = layerImports.map((i) => `'${i}'`);
+      const nodes = addImports(ast, specifiers);
+      if (originalFirst !== ast.first && originalFirst?.type === "atrule" && originalFirst.name === "import") {
+        originalFirst.raws.before = "\n";
       }
-    },
-    {
-      name: () => "src/App.svelte",
-      content: ({ content, typescript }) => {
+      nodes.shift();
+      nodes.forEach((n) => n.raws.before = "\n");
+      return generateCode();
+    });
+    if (!kit) {
+      sv.file("src/App.svelte", (content) => {
         const { script, generateCode } = parseSvelte(content, { typescript });
         imports.addEmpty(script.ast, "./app.css");
         return generateCode({ script: script.generateCode() });
-      },
-      condition: ({ kit }) => !kit
-    },
-    {
-      name: ({ kit }) => `${kit?.routesDirectory}/+layout.svelte`,
-      content: ({ content, typescript, dependencyVersion }) => {
+      });
+    } else {
+      sv.file(`${kit?.routesDirectory}/+layout.svelte`, (content) => {
         const { script, template, generateCode } = parseSvelte(content, { typescript });
         imports.addEmpty(script.ast, "../app.css");
         if (content.length === 0) {
@@ -8080,103 +7847,91 @@ var tailwindcss = defineAdder({
           script: script.generateCode(),
           template: content.length === 0 ? template.generateCode() : void 0
         });
-      },
-      condition: ({ kit }) => Boolean(kit)
-    },
-    {
-      name: () => ".prettierrc",
-      content: ({ content }) => {
+      });
+    }
+    if (dependencyVersion("prettier")) {
+      sv.file(".prettierrc", (content) => {
         const { data, generateCode } = parseJson(content);
         const PLUGIN_NAME = "prettier-plugin-tailwindcss";
         data.plugins ?? (data.plugins = []);
         const plugins2 = data.plugins;
         if (!plugins2.includes(PLUGIN_NAME)) plugins2.push(PLUGIN_NAME);
         return generateCode();
-      },
-      condition: ({ dependencyVersion }) => Boolean(dependencyVersion("prettier"))
+      });
     }
-  ]
+  }
 });
 
-var vitest = defineAdder({
+var vitest = defineAddon({
   id: "vitest",
-  environments: { svelte: true, kit: true },
   homepage: "https://vitest.dev",
   options: {},
-  packages: [{ name: "vitest", version: "^2.0.4", dev: true }],
-  files: [
-    {
-      name: () => "package.json",
-      content: ({ content }) => {
-        const { data, generateCode } = parseJson(content);
-        data.scripts ?? (data.scripts = {});
-        const scripts = data.scripts;
-        const TEST_CMD = "vitest";
-        const RUN_TEST = "npm run test:unit -- --run";
-        scripts["test:unit"] ?? (scripts["test:unit"] = TEST_CMD);
-        scripts["test"] ?? (scripts["test"] = RUN_TEST);
-        if (!scripts["test"].includes(RUN_TEST)) scripts["test"] += ` && ${RUN_TEST}`;
-        return generateCode();
-      }
-    },
-    {
-      name: ({ typescript }) => `src/demo.spec.${typescript ? "ts" : "js"}`,
-      content: ({ content }) => {
-        if (content) return content;
-        return dedent`
-					import { describe, it, expect } from 'vitest';
-
-					describe('sum test', () => {
-						it('adds 1 + 2 to equal 3', () => {
-							expect(1 + 2).toBe(3);
-						});
+  run: ({ sv, typescript }) => {
+    const ext = typescript ? "ts" : "js";
+    sv.devDependency("vitest", "^2.0.4");
+    sv.file("package.json", (content) => {
+      const { data, generateCode } = parseJson(content);
+      data.scripts ?? (data.scripts = {});
+      const scripts = data.scripts;
+      const TEST_CMD = "vitest";
+      const RUN_TEST = "npm run test:unit -- --run";
+      scripts["test:unit"] ?? (scripts["test:unit"] = TEST_CMD);
+      scripts["test"] ?? (scripts["test"] = RUN_TEST);
+      if (!scripts["test"].includes(RUN_TEST)) scripts["test"] += ` && ${RUN_TEST}`;
+      return generateCode();
+    });
+    sv.file(`src/demo.spec.${ext}`, (content) => {
+      if (content) return content;
+      return dedent`
+				import { describe, it, expect } from 'vitest';
+
+				describe('sum test', () => {
+					it('adds 1 + 2 to equal 3', () => {
+						expect(1 + 2).toBe(3);
 					});
-					`;
+				});
+			`;
+    });
+    sv.file(`vite.config.${ext}`, (content) => {
+      const { ast, generateCode } = parseScript(content);
+      const importDecls = ast.body.filter((n) => n.type === "ImportDeclaration");
+      const defineConfigImportDecl = importDecls.find(
+        (importDecl) => (importDecl.source.value === "vite" || importDecl.source.value === "vitest/config") && importDecl.importKind === "value" && importDecl.specifiers?.some(
+          (specifier) => specifier.type === "ImportSpecifier" && specifier.imported.name === "defineConfig"
+        )
+      );
+      if (defineConfigImportDecl?.specifiers?.length === 1) {
+        const idxToRemove = ast.body.indexOf(defineConfigImportDecl);
+        ast.body.splice(idxToRemove, 1);
+      } else {
+        const idxToRemove = defineConfigImportDecl?.specifiers?.findIndex(
+          (s) => s.type === "ImportSpecifier" && s.imported.name === "defineConfig"
+        );
+        if (idxToRemove) defineConfigImportDecl?.specifiers?.splice(idxToRemove, 1);
       }
-    },
-    {
-      name: ({ typescript }) => `vite.config.${typescript ? "ts" : "js"}`,
-      content: ({ content }) => {
-        const { ast, generateCode } = parseScript(content);
-        const importDecls = ast.body.filter((n) => n.type === "ImportDeclaration");
-        const defineConfigImportDecl = importDecls.find(
-          (importDecl) => (importDecl.source.value === "vite" || importDecl.source.value === "vitest/config") && importDecl.importKind === "value" && importDecl.specifiers?.some(
-            (specifier) => specifier.type === "ImportSpecifier" && specifier.imported.name === "defineConfig"
-          )
+      const config = common.expressionFromString("defineConfig({})");
+      const defaultExport = exports$1.defaultExport(ast, config);
+      const test = object$1.create({
+        include: common.expressionFromString("['src/**/*.{test,spec}.{js,ts}']")
+      });
+      if (defaultExport.value.type === "CallExpression" && defaultExport.value.arguments[0]?.type === "ObjectExpression") {
+        const importSpecifier = defineConfigImportDecl?.specifiers?.find(
+          (sp) => sp.type === "ImportSpecifier" && sp.imported.name === "defineConfig"
         );
-        if (defineConfigImportDecl?.specifiers?.length === 1) {
-          const idxToRemove = ast.body.indexOf(defineConfigImportDecl);
-          ast.body.splice(idxToRemove, 1);
-        } else {
-          const idxToRemove = defineConfigImportDecl?.specifiers?.findIndex(
-            (s) => s.type === "ImportSpecifier" && s.imported.name === "defineConfig"
-          );
-          if (idxToRemove) defineConfigImportDecl?.specifiers?.splice(idxToRemove, 1);
-        }
-        const config = common.expressionFromString("defineConfig({})");
-        const defaultExport = exports$1.defaultExport(ast, config);
-        const test = object$1.create({
-          include: common.expressionFromString("['src/**/*.{test,spec}.{js,ts}']")
-        });
-        if (defaultExport.value.type === "CallExpression" && defaultExport.value.arguments[0]?.type === "ObjectExpression") {
-          const importSpecifier = defineConfigImportDecl?.specifiers?.find(
-            (sp) => sp.type === "ImportSpecifier" && sp.imported.name === "defineConfig"
-          );
-          const defineConfigAlias = importSpecifier?.local?.name ?? "defineConfig";
-          imports.addNamed(ast, "vitest/config", { defineConfig: defineConfigAlias });
-          object$1.properties(defaultExport.value.arguments[0], { test });
-        } else if (defaultExport.value.type === "ObjectExpression") {
-          object$1.properties(defaultExport.value, { test });
-        } else {
-          log.warn("Unexpected vite config for vitest adder. Could not update.");
-        }
-        return generateCode();
+        const defineConfigAlias = importSpecifier?.local?.name ?? "defineConfig";
+        imports.addNamed(ast, "vitest/config", { defineConfig: defineConfigAlias });
+        object$1.properties(defaultExport.value.arguments[0], { test });
+      } else if (defaultExport.value.type === "ObjectExpression") {
+        object$1.properties(defaultExport.value, { test });
+      } else {
+        log.warn("Unexpected vite config for vitest add-on. Could not update.");
       }
-    }
-  ]
+      return generateCode();
+    });
+  }
 });
 
-const officialAdders = [
+const officialAddons = [
   prettier,
   eslint,
   vitest,
@@ -8188,18 +7943,18 @@ const officialAdders = [
   paraglide,
   storybook
 ];
-function getAdderDetails(id) {
-  const details = officialAdders.find((a) => a.id === id);
+function getAddonDetails(id) {
+  const details = officialAddons.find((a) => a.id === id);
   if (!details) {
-    throw new Error(`Invalid adder: ${id}`);
+    throw new Error(`Invalid add-on: ${id}`);
   }
   return details;
 }
 
 function __variableDynamicImportRuntime0__(path) {
   switch (path) {
-    case '../../../community-adders/unocss.ts': return import('./unocss-CQk-PWUl.js');
-    case '../../../community-adders/unplugin-icons.ts': return import('./unplugin-icons-D6icB7Q_.js');
+    case '../../../community-addons/unocss.ts': return import('./unocss-CQk-PWUl.js');
+    case '../../../community-addons/unplugin-icons.ts': return import('./unplugin-icons-D6icB7Q_.js');
     default: return new Promise(function(resolve, reject) {
       (typeof queueMicrotask === 'function' ? queueMicrotask : setTimeout)(
         reject.bind(null, new Error("Unknown variable dynamic import: " + path))
@@ -8207,11 +7962,23 @@ function __variableDynamicImportRuntime0__(path) {
     })
    }
  }
-const communityAdderIds = ["unocss","unplugin-icons"];async function getCommunityAdder(name) {
-  const { default: details } = await __variableDynamicImportRuntime0__(`../../../community-adders/${name}.ts`);
+const communityAddonIds = ["unocss","unplugin-icons"];async function getCommunityAddon(name) {
+  const { default: details } = await __variableDynamicImportRuntime0__(`../../../community-addons/${name}.ts`);
   return details;
 }
 
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+class UnsupportedError extends Error {
+  constructor(reasons) {
+    super();
+    __publicField(this, "name", "Unsupported Environment");
+    __publicField(this, "reasons", []);
+    this.reasons = reasons;
+  }
+}
+
 const NO_PREFIX = "--no-";
 let options = [];
 function getLongFlag(flags) {
@@ -8263,58 +8030,23 @@ async function runCommand(action) {
     await action();
     outro("You're all set!");
   } catch (e) {
-    cancel("Operation failed.");
-    if (e instanceof Error) {
-      console.error(e.stack ?? e);
+    if (e instanceof UnsupportedError) {
+      const padding = getPadding(e.reasons.map((r) => r.id));
+      const message = e.reasons.map((r) => `  ${r.id.padEnd(padding)}  ${pc.red(r.reason)}`).join("\n");
+      log$1.error(`${e.name}
+
+${message}`);
+      log$1.message();
+    } else if (e instanceof Error) {
+      log$1.error(e.stack ?? String(e));
+      log$1.message();
     }
+    cancel("Operation failed.");
   }
 }
-
-function getGlobalPreconditions(cwd, projectType, adders) {
-  return {
-    name: "global checks",
-    preconditions: [
-      {
-        name: "clean working directory",
-        run: async () => {
-          try {
-            const { stdout } = await be("git", ["status", "--short"], {
-              nodeOptions: { cwd },
-              throwOnError: true
-            });
-            if (stdout) {
-              return { success: false, message: "Found modified files" };
-            }
-            return { success: true, message: void 0 };
-          } catch {
-            return { success: true, message: "Not a git repository" };
-          }
-        }
-      },
-      {
-        name: "supported environments",
-        run: () => {
-          const addersForInvalidEnvironment = adders.filter((a) => {
-            const supportedEnvironments = a.environments;
-            if (projectType === "kit" && !supportedEnvironments.kit) return true;
-            if (projectType === "svelte" && !supportedEnvironments.svelte) return true;
-            return false;
-          });
-          if (addersForInvalidEnvironment.length === 0) {
-            return { success: true, message: void 0 };
-          }
-          const messages = addersForInvalidEnvironment.map((a) => {
-            if (projectType === "kit") {
-              return `'${a.id}' does not support SvelteKit`;
-            } else {
-              return `'${a.id}' requires SvelteKit`;
-            }
-          });
-          throw new Error(messages.join("\n"));
-        }
-      }
-    ]
-  };
+function getPadding(lines) {
+  const lengths = lines.map((s) => s.length);
+  return Math.max(...lengths);
 }
 
 var tarStream = {};
@@ -11479,14 +11211,14 @@ function verifyPackage(pkg, specifier) {
   const deps = { ...pkg.dependencies, ...pkg.peerDependencies };
   if (!deps["@sveltejs/cli-core"]) {
     throw new Error(
-      `Invalid adder package specified: '${specifier}' is missing a dependency on '@sveltejs/cli-core' in its 'package.json'`
+      `Invalid add-on package specified: '${specifier}' is missing a dependency on '@sveltejs/cli-core' in its 'package.json'`
     );
   }
   for (const dep of Object.keys(deps)) {
     if (dep === "@sveltejs/cli-core") continue;
     throw new Error(
-      `Invalid adder package detected: '${specifier}'
-Community adders should not have any external 'dependencies' besides '@sveltejs/cli-core'. Consider bundling your dependencies if they are necessary`
+      `Invalid add-on package detected: '${specifier}'
+Community addons should not have any external 'dependencies' besides '@sveltejs/cli-core'. Consider bundling your dependencies if they are necessary`
     );
   }
 }
@@ -11562,8 +11294,45 @@ async function fetchPackageJSON(packageName) {
   return await resp.json();
 }
 
-const AddersSchema = array(string());
-const AdderOptionFlagsSchema = object({
+function getGlobalPreconditions(cwd, addons, addonSetupResult) {
+  return {
+    name: "global checks",
+    preconditions: [
+      {
+        name: "clean working directory",
+        run: async () => {
+          try {
+            const { stdout } = await be("git", ["status", "--short"], {
+              nodeOptions: { cwd },
+              throwOnError: true
+            });
+            if (stdout) {
+              return { success: false, message: "Found modified files" };
+            }
+            return { success: true, message: void 0 };
+          } catch {
+            return { success: true, message: "Not a git repository" };
+          }
+        }
+      },
+      {
+        name: "unsupported add-ons",
+        run: () => {
+          const reasons = addons.flatMap(
+            (a) => addonSetupResult[a.id].unsupported.map((reason) => ({ id: a.id, reason }))
+          );
+          if (reasons.length === 0) {
+            return { success: true, message: void 0 };
+          }
+          throw new UnsupportedError(reasons);
+        }
+      }
+    ]
+  };
+}
+
+const AddonsSchema = array(string());
+const AddonOptionFlagsSchema = object({
   tailwindcss: optional(array(string())),
   drizzle: optional(array(string())),
   lucia: optional(array(string())),
@@ -11573,15 +11342,15 @@ const OptionsSchema$1 = strictObject({
   cwd: string(),
   install: boolean(),
   preconditions: boolean(),
-  community: optional(union([AddersSchema, boolean()])),
-  ...AdderOptionFlagsSchema.entries
+  community: optional(union([AddonsSchema, boolean()])),
+  ...AddonOptionFlagsSchema.entries
 });
-const aliases = officialAdders.map((c) => c.alias).filter((v2) => v2 !== void 0);
-const addersOptions = getAdderOptionFlags();
+const aliases = officialAddons.map((c) => c.alias).filter((v2) => v2 !== void 0);
+const addonsOptions = getAddonOptionFlags();
 const communityDetails = [];
 const defaultPkgPath = up();
 const defaultCwd = defaultPkgPath ? path$2.dirname(defaultPkgPath) : void 0;
-const add = new Command("add").description("applies specified add-ons into a project").argument("[add-on...]", "add-ons to install").option("-C, --cwd <path>", "path to working directory", defaultCwd).option("--no-install", "skip installing dependencies").option("--no-preconditions", "skip validating preconditions").configureHelp(helpConfig).action((adderArgs, opts) => {
+const add = new Command("add").description("applies specified add-ons into a project").argument("[add-on...]", "add-ons to install").option("-C, --cwd <path>", "path to working directory", defaultCwd).option("--no-install", "skip installing dependencies").option("--no-preconditions", "skip validating preconditions").configureHelp(helpConfig).action((addonArgs, opts) => {
   if (opts.cwd === void 0) {
     console.error(
       "Invalid workspace: Please verify that you are inside of a Svelte project. You can also specify the working directory with `--cwd <path>`"
@@ -11593,43 +11362,43 @@ const add = new Command("add").description("applies specified add-ons into a pro
     );
     process$1$1.exit(1);
   }
-  const specifiedAdders = parse(AddersSchema, adderArgs);
+  const specifiedAddons = parse(AddonsSchema, addonArgs);
   const options = parse(OptionsSchema$1, opts);
-  const adderIds = officialAdders.map((adder) => adder.id);
-  const invalidAdders = specifiedAdders.filter(
-    (a) => !adderIds.includes(a) && !aliases.includes(a)
+  const addonIds = officialAddons.map((addon) => addon.id);
+  const invalidAddons = specifiedAddons.filter(
+    (a) => !addonIds.includes(a) && !aliases.includes(a)
   );
-  if (invalidAdders.length > 0) {
-    console.error(`Invalid adders specified: ${invalidAdders.join(", ")}`);
+  if (invalidAddons.length > 0) {
+    console.error(`Invalid add-ons specified: ${invalidAddons.join(", ")}`);
     process$1$1.exit(1);
   }
-  const selectedAdders = transformAliases(specifiedAdders);
+  const selectedAddons = transformAliases(specifiedAddons);
   runCommand(async () => {
-    const { nextSteps } = await runAddCommand(options, selectedAdders);
+    const { nextSteps } = await runAddCommand(options, selectedAddons);
     if (nextSteps) box(nextSteps, "Next steps");
   });
 });
-for (const option of addersOptions) {
+for (const option of addonsOptions) {
   add.addOption(option);
 }
-async function runAddCommand(options, selectedAdderIds) {
+async function runAddCommand(options, selectedAddonIds) {
   var _a;
-  const selectedAdders = selectedAdderIds.map((id) => ({
+  const selectedAddons = selectedAddonIds.map((id) => ({
     type: "official",
-    adder: getAdderDetails(id)
+    addon: getAddonDetails(id)
   }));
   const official = {};
   const community = {};
-  for (const adderOption of addersOptions) {
-    const adderId = adderOption.attributeName();
-    const specifiedOptions = options[adderId];
+  for (const addonOption of addonsOptions) {
+    const addonId = addonOption.attributeName();
+    const specifiedOptions = options[addonId];
     if (!specifiedOptions) continue;
-    const details = getAdderDetails(adderId);
-    if (!selectedAdders.find((d) => d.adder === details)) {
-      selectedAdders.push({ type: "official", adder: details });
+    const details2 = getAddonDetails(addonId);
+    if (!selectedAddons.find((d) => d.addon === details2)) {
+      selectedAddons.push({ type: "official", addon: details2 });
     }
-    official[adderId] ?? (official[adderId] = {});
-    const optionEntries = Object.entries(details.options);
+    official[addonId] ?? (official[addonId] = {});
+    const optionEntries = Object.entries(details2.options);
     for (const specifiedOption of specifiedOptions) {
       if (!specifiedOption || specifiedOption === "none") continue;
       const optionEntry = optionEntries.find(([id, question2]) => {
@@ -11641,44 +11410,44 @@ async function runAddCommand(options, selectedAdderIds) {
         }
       });
       if (!optionEntry) {
-        const { choices } = getOptionChoices(details);
+        const { choices } = getOptionChoices(details2);
         throw new Error(
-          `Invalid '--${adderId}' option: '${specifiedOption}'
+          `Invalid '--${addonId}' option: '${specifiedOption}'
 Available options: ${choices.join(", ")}`
         );
       }
       const [questionId, question] = optionEntry;
-      let existingOption = official[adderId][questionId];
+      let existingOption = official[addonId][questionId];
       if (existingOption !== void 0) {
         if (typeof existingOption === "boolean") {
           existingOption = existingOption ? questionId : `no-${questionId}`;
         }
         throw new Error(
-          `Conflicting '--${adderId}' option: '${specifiedOption}' conflicts with '${existingOption}'`
+          `Conflicting '--${addonId}' option: '${specifiedOption}' conflicts with '${existingOption}'`
         );
       }
-      official[adderId][questionId] = question.type === "boolean" ? !specifiedOption.startsWith("no-") : specifiedOption;
+      official[addonId][questionId] = question.type === "boolean" ? !specifiedOption.startsWith("no-") : specifiedOption;
     }
-    for (const [id, question] of Object.entries(details.options)) {
-      if (question.condition?.(official[adderId]) !== false) {
-        (_a = official[adderId])[id] ?? (_a[id] = question.default);
+    for (const [id, question] of Object.entries(details2.options)) {
+      if (question.condition?.(official[addonId]) !== false) {
+        (_a = official[addonId])[id] ?? (_a[id] = question.default);
       } else {
-        if (official[adderId][id] !== void 0) {
+        if (official[addonId][id] !== void 0) {
           throw new Error(
-            `Incompatible '--${adderId}' option specified: '${official[adderId][id]}'`
+            `Incompatible '--${addonId}' option specified: '${official[addonId][id]}'`
           );
         }
       }
     }
   }
   if (options.community === true) {
-    const communityAdders = await Promise.all(
-      communityAdderIds.map(async (id) => await getCommunityAdder(id))
+    const communityAddons = await Promise.all(
+      communityAddonIds.map(async (id) => await getCommunityAddon(id))
     );
-    const promptOptions = communityAdders.map((adder) => ({
-      value: adder.id,
-      label: adder.id,
-      hint: "https://www.npmjs.com/package/" + adder.id
+    const promptOptions = communityAddons.map((addon) => ({
+      value: addon.id,
+      label: addon.id,
+      hint: "https://www.npmjs.com/package/" + addon.id
     }));
     const selected = await multiselect({
       message: "Which community tools would you like to add to your project?",
@@ -11689,35 +11458,35 @@ Available options: ${choices.join(", ")}`
       cancel("Operation cancelled.");
       process$1$1.exit(1);
     } else if (selected.length === 0) {
-      cancel("No adders selected. Exiting.");
+      cancel("No add-ons selected. Exiting.");
       process$1$1.exit(1);
     }
     options.community = selected;
   }
   if (Array.isArray(options.community) && options.community.length > 0) {
-    const adders = options.community.map((id) => {
+    const addons = options.community.map((id) => {
       const hasDirective = Object.values(Directive).some((directive) => id.startsWith(directive));
       if (hasDirective) return id;
-      const validAdder = communityAdderIds.includes(id);
-      if (!validAdder) {
+      const validAddon = communityAddonIds.includes(id);
+      if (!validAddon) {
         throw new Error(
-          `Invalid community adder specified: '${id}'
-Available options: ${communityAdderIds.join(", ")}`
+          `Invalid community add-on specified: '${id}'
+Available options: ${communityAddonIds.join(", ")}`
         );
       }
       return id;
     });
     const { start, stop } = spinner();
     try {
-      start("Resolving community adder packages");
+      start("Resolving community add-on packages");
       const pkgs = await Promise.all(
-        adders.map(async (id) => {
+        addons.map(async (id) => {
           return await getPackageJSON({ cwd: options.cwd, packageName: id });
         })
       );
-      stop("Resolved community adder packages");
+      stop("Resolved community add-on packages");
       log$1.warn(
-        "The Svelte maintainers have not reviewed community adders for malicious code. Use at your discretion."
+        "The Svelte maintainers have not reviewed community add-ons for malicious code. Use at your discretion."
       );
       const paddingName = getPadding(pkgs.map(({ pkg: pkg2 }) => pkg2.name));
       const paddingVersion = getPadding(pkgs.map(({ pkg: pkg2 }) => `(v${pkg2.version})`));
@@ -11733,70 +11502,60 @@ Available options: ${communityAdderIds.join(", ")}`
         cancel("Operation cancelled.");
         process$1$1.exit(1);
       }
-      start("Downloading community adder packages");
-      const details = await Promise.all(pkgs.map(async (opts) => downloadPackage(opts)));
-      for (const adder of details) {
-        const id = adder.id;
+      start("Downloading community add-on packages");
+      const details2 = await Promise.all(pkgs.map(async (opts) => downloadPackage(opts)));
+      for (const addon of details2) {
+        const id = addon.id;
         community[id] ?? (community[id] = {});
-        communityDetails.push(adder);
-        selectedAdders.push({ type: "community", adder });
+        communityDetails.push(addon);
+        selectedAddons.push({ type: "community", addon });
       }
-      stop("Downloaded community adder packages");
+      stop("Downloaded community add-on packages");
     } catch (err) {
-      stop("Failed to resolve community adder packages", 1);
+      stop("Failed to resolve community add-on packages", 1);
       throw err;
     }
   }
-  if (selectedAdders.length === 0) {
-    const workspace2 = createWorkspace({ cwd: options.cwd });
-    const projectType = workspace2.kit ? "kit" : "svelte";
-    const adderOptions = officialAdders.map((adder) => {
-      if (projectType === "kit" && !adder.environments.kit) return;
-      if (projectType === "svelte" && !adder.environments.svelte) return;
-      return {
-        label: adder.id,
-        value: adder.id,
-        hint: adder.homepage
-      };
-    }).filter((a) => !!a);
+  let workspace = createWorkspace({ cwd: options.cwd });
+  const addonSetupResults = setupAddons(officialAddons, workspace);
+  if (selectedAddons.length === 0) {
+    const addonOptions = officialAddons.filter(({ id }) => addonSetupResults[id].unsupported.length === 0).map(({ id, homepage }) => ({ label: id, value: id, hint: homepage }));
     const selected = await multiselect({
       message: `What would you like to add to your project? ${pc.dim("(use arrow keys / space bar)")}`,
-      options: adderOptions,
+      options: addonOptions,
       required: false
     });
     if (isCancel(selected)) {
       cancel("Operation cancelled.");
       process$1$1.exit(1);
     }
-    selected.forEach((id) => selectedAdders.push({ type: "official", adder: getAdderDetails(id) }));
-  }
-  for (const { adder } of selectedAdders) {
-    const dependents = adder.dependsOn?.filter((dep) => !selectedAdders.some((a) => a.adder.id === dep)) ?? [];
-    const workspace2 = createWorkspace({ cwd: options.cwd });
-    for (const depId of dependents) {
-      const dependent = officialAdders.find((a) => a.id === depId);
-      if (!dependent) throw new Error(`Adder '${adder.id}' depends on an invalid '${depId}'`);
-      let installed = false;
-      installed = dependent.packages.every(
-        // we'll skip the conditions since we don't have any options to supply it
-        (p2) => p2.condition !== void 0 || !!workspace2.dependencyVersion(p2.name)
-      );
-      if (installed) continue;
+    for (const id of selected) {
+      const addon = officialAddons.find((addon2) => addon2.id === id);
+      selectedAddons.push({ type: "official", addon });
+    }
+  }
+  for (const { addon } of selectedAddons) {
+    workspace = createWorkspace(workspace);
+    const setupResult = addonSetupResults[addon.id];
+    const missingDependencies = setupResult.dependsOn.filter(
+      (depId) => !selectedAddons.some((a) => a.addon.id === depId)
+    );
+    for (const depId of missingDependencies) {
+      const dependency = officialAddons.find((a) => a.id === depId);
+      if (!dependency) throw new Error(`'${addon.id}' depends on an invalid add-on: '${depId}'`);
       const install = await confirm({
-        message: `The ${pc.bold(pc.cyan(adder.id))} add-on requires ${pc.bold(pc.cyan(depId))} to also be setup. ${pc.green("Include it?")}`
+        message: `The ${pc.bold(pc.cyan(addon.id))} add-on requires ${pc.bold(pc.cyan(depId))} to also be setup. ${pc.green("Include it?")}`
       });
       if (install !== true) {
         cancel("Operation cancelled.");
         process$1$1.exit(1);
       }
-      selectedAdders.push({ type: "official", adder: dependent });
+      selectedAddons.push({ type: "official", addon: dependency });
     }
   }
-  if (options.preconditions && selectedAdders.length > 0) {
-    const { kit } = createWorkspace({ cwd: options.cwd });
-    const projectType = kit ? "kit" : "svelte";
-    const adders = selectedAdders.map(({ adder }) => adder);
-    const { preconditions } = getGlobalPreconditions(options.cwd, projectType, adders);
+  if (options.preconditions && selectedAddons.length > 0) {
+    const addons = selectedAddons.map(({ addon }) => addon);
+    const { preconditions } = getGlobalPreconditions(options.cwd, addons, addonSetupResults);
     const fails = [];
     for (const condition of preconditions) {
       const { message, success } = await condition.run();
@@ -11815,19 +11574,19 @@ Available options: ${communityAdderIds.join(", ")}`
       }
     }
   }
-  for (const { adder, type } of selectedAdders) {
-    const adderId = adder.id;
-    const questionPrefix = selectedAdders.length > 1 ? `${adder.id}: ` : "";
+  for (const { addon, type } of selectedAddons) {
+    const addonId = addon.id;
+    const questionPrefix = selectedAddons.length > 1 ? `${addon.id}: ` : "";
     let values = {};
     if (type === "official") {
-      official[adderId] ?? (official[adderId] = {});
-      values = official[adderId];
+      official[addonId] ?? (official[addonId] = {});
+      values = official[addonId];
     }
     if (type === "community") {
-      community[adderId] ?? (community[adderId] = {});
-      values = community[adderId];
+      community[addonId] ?? (community[addonId] = {});
+      values = community[addonId];
     }
-    for (const [questionId, question] of Object.entries(adder.options)) {
+    for (const [questionId, question] of Object.entries(addon.options)) {
       const shouldAsk = question.condition?.(values);
       if (shouldAsk === false || values[questionId] !== void 0) continue;
       let answer;
@@ -11868,17 +11627,29 @@ Available options: ${communityAdderIds.join(", ")}`
       values[questionId] = answer;
     }
   }
-  if (selectedAdders.length === 0) return { packageManager: null };
+  if (selectedAddons.length === 0) return { packageManager: null };
   let packageManager;
   if (options.install) {
     packageManager = await packageManagerPrompt(options.cwd);
+    if (packageManager) workspace.packageManager = packageManager;
   }
-  const filesToFormat = await runAdders({ cwd: options.cwd, packageManager, official, community });
+  const officialDetails = Object.keys(official).map((id) => getAddonDetails(id));
+  const commDetails = Object.keys(community).map(
+    (id) => communityDetails.find((a) => a.id === id)
+  );
+  const details = officialDetails.concat(commDetails);
+  const addonMap = Object.assign({}, ...details.map((a) => ({ [a.id]: a })));
+  const filesToFormat = await applyAddons({
+    workspace,
+    addonSetupResults,
+    addons: addonMap,
+    options: official
+  });
   log$1.success("Successfully setup add-ons");
   if (packageManager && options.install) {
     await installDependencies(packageManager, options.cwd);
   }
-  const workspace = createWorkspace({ cwd: options.cwd, packageManager });
+  workspace = createWorkspace(workspace);
   if (filesToFormat.length > 0 && packageManager && !!workspace.dependencyVersion("prettier")) {
     const { start, stop } = spinner();
     start("Formatting modified files");
@@ -11891,92 +11662,39 @@ Available options: ${communityAdderIds.join(", ")}`
     }
   }
   const highlighter = getHighlighter();
-  const nextSteps = selectedAdders.filter(({ adder }) => adder.nextSteps).map(({ adder }) => {
-    let adderMessage = "";
-    if (selectedAdders.length > 1) {
-      adderMessage = `${pc.green(adder.id)}:
+  const nextSteps = selectedAddons.filter(({ addon }) => addon.nextSteps).map(({ addon }) => {
+    let addonMessage = "";
+    if (selectedAddons.length > 1) {
+      addonMessage = `${pc.green(addon.id)}:
 `;
     }
-    const adderNextSteps = adder.nextSteps({
+    const addonNextSteps = addon.nextSteps({
       ...workspace,
-      options: official[adder.id],
+      options: official[addon.id],
       highlighter
     });
-    adderMessage += `- ${adderNextSteps.join("\n- ")}`;
-    return adderMessage;
+    addonMessage += `- ${addonNextSteps.join("\n- ")}`;
+    return addonMessage;
   }).join("\n\n") || void 0;
   return { nextSteps, packageManager };
 }
-async function runAdders({
-  cwd,
-  official = {},
-  community = {},
-  packageManager
-}) {
-  const adderDetails = Object.keys(official).map((id) => getAdderDetails(id));
-  const commDetails = Object.keys(community).map(
-    (id) => communityDetails.find((a) => a.id === id)
-  );
-  const details = adderDetails.concat(commDetails);
-  details.sort((a, b) => {
-    if (!a.dependsOn && !b.dependsOn) return 0;
-    if (!a.dependsOn) return -1;
-    if (!b.dependsOn) return 1;
-    return a.dependsOn.includes(b.id) ? 1 : b.dependsOn.includes(a.id) ? -1 : 0;
-  });
-  const filesToFormat = /* @__PURE__ */ new Set();
-  for (const config of details) {
-    const adderId = config.id;
-    const workspace = createWorkspace({ cwd, packageManager });
-    workspace.options = official[adderId] ?? community[adderId];
-    await config.preInstall?.(workspace);
-    const pkgPath = installPackages(config, workspace);
-    filesToFormat.add(pkgPath);
-    const changedFiles = createOrUpdateFiles(config.files, workspace);
-    changedFiles.forEach((file) => filesToFormat.add(file));
-    await config.postInstall?.(workspace);
-    if (config.scripts && config.scripts.length > 0) {
-      for (const script of config.scripts) {
-        if (script.condition?.(workspace) === false) continue;
-        const { command, args } = resolveCommand(workspace.packageManager, "execute", script.args);
-        const adderPrefix = details.length > 1 ? `${config.id}: ` : "";
-        log$1.step(
-          `${adderPrefix}Running external command ${pc.gray(`(${command} ${args.join(" ")})`)}`
-        );
-        if (workspace.packageManager === "npm") args.unshift("--yes");
-        try {
-          await be(command, args, {
-            nodeOptions: { cwd: workspace.cwd, stdio: script.stdio },
-            throwOnError: true
-          });
-        } catch (error) {
-          const typedError = error;
-          throw new Error(
-            `Failed to execute scripts '${script.description}': ` + typedError.message
-          );
-        }
-      }
-    }
-  }
-  return Array.from(filesToFormat);
-}
 function transformAliases(ids) {
   const set = /* @__PURE__ */ new Set();
   for (const id of ids) {
     if (aliases.includes(id)) {
-      const adder = officialAdders.find((a) => a.alias === id);
-      set.add(adder.id);
+      const addon = officialAddons.find((a) => a.alias === id);
+      set.add(addon.id);
     } else {
       set.add(id);
     }
   }
   return Array.from(set);
 }
-function getAdderOptionFlags() {
+function getAddonOptionFlags() {
   const options = [];
-  for (const adder of officialAdders) {
-    const id = adder.id;
-    const details = getAdderDetails(id);
+  for (const addon of officialAddons) {
+    const id = addon.id;
+    const details = getAddonDetails(id);
     if (Object.values(details.options).length === 0) continue;
     const { defaults, groups } = getOptionChoices(details);
     const choices = Object.entries(groups).map(([group, choices2]) => `${pc.dim(`${group}:`)} ${choices2.join(", ")}`).join("\n");
@@ -12030,10 +11748,6 @@ function getOptionChoices(details) {
   }
   return { choices, defaults, groups };
 }
-function getPadding(lines) {
-  const lengths = lines.map((s) => s.length);
-  return Math.max(...lengths);
-}
 
 const langs = ["ts", "jsdoc"];
 const langMap = {