sv 0.9.15 → 0.10.1

package/dist/bin.js

@@ -1,18 +1,28 @@
 #!/usr/bin/env node
-import { B as We, F as Ge, H as ke, I as J, J as require_picocolors, K as up$1, L as Ke, N as De, O as isVersionUnsupportedBelow, P as Fe, R as T, U as ze, V as et, W as Vu, X as Option, Y as Command, Z as program, _ as parseScript, a as getUserAgent, c as packageManagerPrompt, et as __toESM, f as getSharedFiles, g as parseJson, i as addPnpmBuildDependencies, l as detect, n as templates, o as installDependencies, p as resolveCommand, q as from, r as AGENT_NAMES, s as installOption, t as create$1, v as parseSvelte, z as Ue } from "./create-BOEKhcVU.js";
-import { a as communityAddonIds, c as officialAddons, d as createDefault, f as addDefault, i as createWorkspace, l as formatFiles, m as overrideProperties, o as getCommunityAddon, p as create$2, r as setupAddons, s as getAddonDetails, t as applyAddons, u as getHighlighter } from "./install-BoYywMIH.js";
+import { $ as ke, C as getSharedFiles, D as parseJson, G as Fe, J as Ke, K as Ge, O as parseScript, Q as et, W as De, X as Ue, Y as T, Z as We, a as getUserAgent, at as program, b as detect, c as packageManagerPrompt, ct as __toESM, d as from, et as ze, f as commonFilePaths, h as getHighlighter, i as addPnpmBuildDependencies, it as Option, k as parseSvelte, m as formatFiles, n as templates, nt as require_picocolors, o as installDependencies, q as J, r as AGENT_NAMES, rt as Command, s as installOption, t as create$1, tt as Vu, u as up$1, w as resolveCommand, z as isVersionUnsupportedBelow } from "./create-BN4H6Ywy.js";
+import { a as communityAddonIds, c as officialAddons, d as create$2, f as overrideProperties, i as createWorkspace, l as createDefault, o as getCommunityAddon, r as setupAddons, s as getAddonDetails, t as applyAddons, u as addDefault } from "./install-BeymWyuI.js";
 import { exec, execSync } from "node:child_process";
 import path, { dirname, join } from "node:path";
 import fs, { existsSync } from "node:fs";
 import process from "node:process";
-import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
+import { fileURLToPath } from "node:url";
 import { createGunzip } from "node:zlib";
 import { pipeline } from "node:stream/promises";
 
 //#region package.json
 var name = "sv";
-var version = "0.9.15";
+var version = "0.10.1";
+
+//#endregion
+//#region ../../node_modules/.pnpm/empathic@1.1.0/node_modules/empathic/package.mjs
+/**
+* Find the closest "package.json" file while walking parent directories.
+* @returns The absolute path to a "package.json", if found.
+*/
+function up(options$1) {
+	return up$1("package.json", options$1);
+}
 
 //#endregion
 //#region ../../node_modules/.pnpm/valibot@0.41.0_typescript@5.9.3/node_modules/valibot/dist/index.js
@@ -428,16 +438,6 @@ function pipe(...pipe2) {
 	};
 }
 
-//#endregion
-//#region ../../node_modules/.pnpm/empathic@1.1.0/node_modules/empathic/package.mjs
-/**
-* Find the closest "package.json" file while walking parent directories.
-* @returns The absolute path to a "package.json", if found.
-*/
-function up(options$1) {
-	return up$1("package.json", options$1);
-}
-
 //#endregion
 //#region utils/errors.ts
 var UnsupportedError = class extends Error {
@@ -532,6 +532,68 @@ function parseAddonOptions(optionFlags) {
 	}
 	return options$1;
 }
+function logArgs(agent, command, args, lastArgs = []) {
+	const allArgs = [
+		"sv",
+		command,
+		...args
+	];
+	if (agent === null || agent === void 0) allArgs.push("--no-install");
+	else allArgs.push("--install", agent);
+	const res = resolveCommand(agent ?? "npm", "execute", [...allArgs, ...lastArgs]);
+	T.message(import_picocolors$3.default.dim([res.command, ...res.args].join(" ")));
+}
+function errorAndExit(message) {
+	T.error(message);
+	De("Operation failed.");
+	process.exit(1);
+}
+
+//#endregion
+//#region commands/add/verifiers.ts
+function verifyCleanWorkingDirectory(cwd, gitCheck) {
+	const verifications = [];
+	if (gitCheck) verifications.push({
+		name: "clean working directory",
+		run: async () => {
+			try {
+				const { stdout: stdout$1 } = await promisify(exec)("git status --short", { cwd });
+				if (stdout$1) return {
+					success: false,
+					message: "Found modified files"
+				};
+				return {
+					success: true,
+					message: void 0
+				};
+			} catch {
+				return {
+					success: true,
+					message: "Not a git repository"
+				};
+			}
+		}
+	});
+	return verifications;
+}
+function verifyUnsupportedAddons(addons, addonSetupResult) {
+	const verifications = [];
+	verifications.push({
+		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);
+		}
+	});
+	return verifications;
+}
 
 //#endregion
 //#region commands/add/fetch-packages.ts
@@ -612,52 +674,6 @@ async function fetchPackageJSON(packageName) {
 	return await resp.json();
 }
 
-//#endregion
-//#region commands/add/verifiers.ts
-function verifyCleanWorkingDirectory(cwd, gitCheck) {
-	const verifications = [];
-	if (gitCheck) verifications.push({
-		name: "clean working directory",
-		run: async () => {
-			try {
-				const { stdout: stdout$1 } = await promisify(exec)("git status --short", { cwd });
-				if (stdout$1) return {
-					success: false,
-					message: "Found modified files"
-				};
-				return {
-					success: true,
-					message: void 0
-				};
-			} catch {
-				return {
-					success: true,
-					message: "Not a git repository"
-				};
-			}
-		}
-	});
-	return verifications;
-}
-function verifyUnsupportedAddons(addons, addonSetupResult) {
-	const verifications = [];
-	verifications.push({
-		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);
-		}
-	});
-	return verifications;
-}
-
 //#endregion
 //#region commands/add/index.ts
 var import_picocolors$2 = /* @__PURE__ */ __toESM(require_picocolors(), 1);
@@ -675,24 +691,7 @@ const OptionsSchema$1 = strictObject({
 });
 const defaultPkgPath = up();
 const defaultCwd = defaultPkgPath ? path.dirname(defaultPkgPath) : void 0;
-const add = new Command("add").description("applies specified add-ons into a project").argument("[add-on...]", `add-ons to install`, (value, prev = []) => {
-	const [addonId, optionFlags] = value.split("=", 2);
-	if (prev.find(({ id }) => id === addonId)) {
-		console.error(`Malformed arguments: Add-on '${addonId}' is repeated multiple times.`);
-		process.exit(1);
-	}
-	try {
-		const options$1 = parseAddonOptions(optionFlags);
-		prev.push({
-			id: addonId,
-			options: options$1
-		});
-	} catch (error) {
-		if (error instanceof Error) console.error(error.message);
-		process.exit(1);
-	}
-	return prev;
-}).option("-C, --cwd <path>", "path to working directory", defaultCwd).option("--no-git-check", "even if some files are dirty, no prompt will be shown").option("--no-install", "skip installing dependencies").addOption(installOption).configureHelp({
+const add = new Command("add").description("applies specified add-ons into a project").argument("[add-on...]", `add-ons to install`, (value, previous = []) => addonArgsHandler(previous, value)).option("-C, --cwd <path>", "path to working directory", defaultCwd).option("--no-git-check", "even if some files are dirty, no prompt will be shown").option("--no-install", "skip installing dependencies").addOption(installOption).configureHelp({
 	...helpConfig,
 	formatHelp(cmd, helper) {
 		const termWidth = helper.padWidth(cmd, helper);
@@ -748,57 +747,61 @@ const add = new Command("add").description("applies specified add-ons into a pro
 		]);
 		return output.join("\n");
 	}
-}).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>`");
-		process.exit(1);
-	} else if (!fs.existsSync(path.resolve(opts.cwd, "package.json"))) {
-		console.error(`Invalid workspace: Path '${path.resolve(opts.cwd)}' is not a valid workspace.`);
-		process.exit(1);
-	}
-	const addonIds = officialAddons$1.map((addon) => addon.id);
-	const invalidAddons = addonArgs.filter(({ id }) => !addonIds.includes(id) && !aliases.includes(id)).map(({ id }) => id);
-	if (invalidAddons.length > 0) {
-		console.error(`Invalid add-ons specified: ${invalidAddons.join(", ")}`);
-		process.exit(1);
-	}
+}).action(async (addonArgs, opts) => {
+	if (opts.cwd === void 0) errorAndExit("Invalid workspace: Please verify that you are inside of a Svelte project. You can also specify the working directory with `--cwd <path>`");
+	else if (!fs.existsSync(path.resolve(opts.cwd, "package.json"))) errorAndExit(`Invalid workspace: Path '${path.resolve(opts.cwd)}' is not a valid workspace.`);
+	const selectedAddonArgs = sanitizeAddons(addonArgs);
 	const options$1 = parse(OptionsSchema$1, {
 		...opts,
 		addons: {}
 	});
-	const selectedAddons = transformAliases(addonArgs);
-	selectedAddons.forEach((addon) => options$1.addons[addon.id] = addon.options);
+	selectedAddonArgs.forEach((addon) => options$1.addons[addon.id] = addon.options);
+	const workspace = await createWorkspace({ cwd: options$1.cwd });
 	runCommand(async () => {
-		const { nextSteps } = await runAddCommand(options$1, selectedAddons.map(({ id }) => id));
+		const { answersCommunity, answersOfficial, selectedAddons } = await promptAddonQuestions({
+			options: options$1,
+			selectedAddonIds: selectedAddonArgs.map(({ id }) => id),
+			workspace
+		});
+		const { nextSteps } = await runAddonsApply({
+			answersOfficial,
+			answersCommunity,
+			options: options$1,
+			selectedAddons,
+			workspace,
+			fromCommand: "add"
+		});
 		if (nextSteps.length > 0) Ke(nextSteps.join("\n"), "Next steps", { format: (line) => line });
 	});
 });
-async function runAddCommand(options$1, selectedAddonIds) {
-	let selectedAddons = selectedAddonIds.map((id) => ({
-		type: "official",
-		addon: getAddonDetails(id)
-	}));
-	const official = {};
-	const community = {};
+async function promptAddonQuestions({ options: options$1, selectedAddonIds, workspace }) {
+	const selectedOfficialAddons = [];
+	selectedAddonIds.map((id) => {
+		if (officialAddons$1.find((a) => a.id === id)) selectedOfficialAddons.push(getAddonDetails(id));
+	});
+	const emptyAnswersReducer = (acc, id) => {
+		acc[id] = {};
+		return acc;
+	};
+	const answersOfficial = selectedOfficialAddons.map(({ id }) => id).reduce(emptyAnswersReducer, {});
 	for (const addonOption of addonOptions) {
 		const addonId = addonOption.id;
 		const specifiedOptions = options$1.addons[addonId];
 		if (!specifiedOptions) continue;
-		const details$1 = getAddonDetails(addonId);
-		if (!selectedAddons.find((d) => d.addon === details$1)) selectedAddons.push({
-			type: "official",
-			addon: details$1
-		});
-		official[addonId] ??= {};
-		const optionEntries = Object.entries(details$1.options);
+		const details = getAddonDetails(addonId);
+		if (!selectedOfficialAddons.find((d) => d === details)) selectedOfficialAddons.push(details);
+		answersOfficial[addonId] ??= {};
+		const optionEntries = Object.entries(details.options);
 		const specifiedOptionsObject = Object.fromEntries(specifiedOptions.map((option) => option.split(":", 2)));
 		for (const option of specifiedOptions) {
-			let [optionId, optionValue] = option.split(":", 2);
+			const [optionId, optionValue] = option.split(":", 2);
 			const optionEntry = optionEntries.find(([id, question$1]) => {
 				if (id === optionId) return true;
 				if (question$1.group === optionId) {
-					if (question$1.type === "select" || question$1.type === "multiselect") {
+					if (question$1.type === "select") {
 						if (!question$1.options.some((opt) => opt.value === optionValue)) return false;
+					} else if (question$1.type === "multiselect") {
+						if (!(optionValue === "none" ? [] : optionValue.split(",")).every((val) => question$1.options.some((opt) => opt.value === val.trim()))) return false;
 					}
 					if (question$1.condition) return question$1.condition(specifiedOptionsObject);
 					return true;
@@ -806,22 +809,31 @@ async function runAddCommand(options$1, selectedAddonIds) {
 				return false;
 			});
 			if (!optionEntry) {
-				const { choices } = getOptionChoices(details$1);
-				throw new Error(`Invalid '${addonId}' option: '${option}'\nAvailable options: ${choices.join(", ")}`);
+				const { choices } = getOptionChoices(details);
+				errorAndExit(`Invalid '${addonId}' add-on option: '${option}'\nAvailable options: ${choices.join(", ")}`);
+				throw new Error();
 			}
 			const [questionId, question] = optionEntry;
-			if (question.type === "multiselect" && optionValue === "none") optionValue = "";
-			let existingOption = official[addonId][questionId];
+			if (question.type === "multiselect" && questionId === optionId) {
+				const invalidValues = (optionValue === "none" || optionValue === "" ? [] : optionValue.split(",")).filter((val) => !question.options.some((opt) => opt.value === val.trim()));
+				if (invalidValues.length > 0) {
+					const validValues = question.options.map((opt) => opt.value).join(", ");
+					errorAndExit(`Invalid '${addonId}' add-on option: '${option}'\nInvalid values: ${invalidValues.join(", ")}\nAvailable values: ${validValues}`);
+				}
+			}
+			let existingOption = answersOfficial[addonId][questionId];
 			if (existingOption !== void 0) {
 				if (typeof existingOption === "boolean") existingOption = existingOption ? "yes" : "no";
-				throw new Error(`Conflicting '${addonId}' option: '${option}' conflicts with '${questionId}:${existingOption}'`);
+				errorAndExit(`Conflicting '${addonId}' option: '${option}' conflicts with '${questionId}:${existingOption}'`);
 			}
-			if (question.type === "boolean") official[addonId][questionId] = optionValue === "yes";
-			else if (question.type === "number") official[addonId][questionId] = Number(optionValue);
-			else official[addonId][questionId] = optionValue;
+			if (question.type === "boolean") answersOfficial[addonId][questionId] = optionValue === "yes";
+			else if (question.type === "number") answersOfficial[addonId][questionId] = Number(optionValue);
+			else if (question.type === "multiselect") if (optionValue === "none" || optionValue === "") answersOfficial[addonId][questionId] = [];
+			else answersOfficial[addonId][questionId] = optionValue.split(",").map((v) => v.trim());
+			else answersOfficial[addonId][questionId] = optionValue;
 		}
-		for (const [id, question] of Object.entries(details$1.options)) if (question.condition?.(official[addonId]) !== false) official[addonId][id] ??= question.default;
-		else if (official[addonId][id] !== void 0) throw new Error(`Incompatible '${addonId}' option specified: '${official[addonId][id]}'`);
+		for (const [id, question] of Object.entries(details.options)) if (question.condition?.(answersOfficial[addonId]) !== false) answersOfficial[addonId][id] ??= question.default;
+		else if (answersOfficial[addonId][id] !== void 0) throw new Error(`Incompatible '${addonId}' option specified: '${answersOfficial[addonId][id]}'`);
 	}
 	if (options$1.community === true) {
 		const promptOptions = (await Promise.all(communityAddonIds.map(async (id) => await getCommunityAddon(id)))).map((addon) => ({
@@ -843,51 +855,17 @@ async function runAddCommand(options$1, selectedAddonIds) {
 		}
 		options$1.community = selected;
 	}
-	if (Array.isArray(options$1.community) && options$1.community.length > 0) {
-		const addons$1 = options$1.community.map((id) => {
-			if (Object.values(Directive).some((directive) => id.startsWith(directive))) return id;
-			if (!communityAddonIds.includes(id)) throw new Error(`Invalid community add-on specified: '${id}'\nAvailable options: ${communityAddonIds.join(", ")}`);
-			return id;
-		});
-		const { start, stop } = J();
-		try {
-			start("Resolving community add-on packages");
-			const pkgs = await Promise.all(addons$1.map(async (id) => {
-				return await getPackageJSON({
-					cwd: options$1.cwd,
-					packageName: id
-				});
-			}));
-			stop("Resolved community add-on packages");
-			T.warn("The Svelte maintainers have not reviewed community add-ons for malicious code. Use at your discretion.");
-			const paddingName = getPadding(pkgs.map(({ pkg }) => pkg.name));
-			const paddingVersion = getPadding(pkgs.map(({ pkg }) => `(v${pkg.version})`));
-			const packageInfos = pkgs.map(({ pkg, repo: _repo }) => {
-				return `${import_picocolors$2.default.yellowBright(pkg.name.padEnd(paddingName))} ${import_picocolors$2.default.dim(`(v${pkg.version})`.padEnd(paddingVersion))} ${import_picocolors$2.default.dim(`(${_repo})`)}`;
-			});
-			T.message(packageInfos.join("\n"));
-			if (await ke({ message: "Would you like to continue?" }) !== true) {
-				De("Operation cancelled.");
-				process.exit(1);
-			}
-			start("Downloading community add-on packages");
-			const details$1 = await Promise.all(pkgs.map(async (opts) => downloadPackage(opts)));
-			for (const addon of details$1) {
-				const id = addon.id;
-				community[id] ??= {};
-				communityDetails.push(addon);
-				selectedAddons.push({
-					type: "community",
-					addon
-				});
-			}
-			stop("Downloaded community add-on packages");
-		} catch (err) {
-			stop("Failed to resolve community add-on packages", 1);
-			throw err;
-		}
-	}
-	let workspace = await createWorkspace({ cwd: options$1.cwd });
+	const selectedCommunityAddons = [];
+	const answersCommunity = selectedCommunityAddons.map(({ id }) => id).reduce(emptyAnswersReducer, {});
+	if (Array.isArray(options$1.community) && options$1.community.length > 0) selectedCommunityAddons.push(...await resolveCommunityAddons(options$1.cwd, options$1.community));
+	const selectedAddons = [...selectedOfficialAddons.map((addon) => ({
+		type: "official",
+		addon
+	})), ...selectedCommunityAddons.map((addon) => ({
+		type: "community",
+		addon
+	}))];
+	const addonSetupResults = setupAddons(selectedAddons.length ? selectedAddons.map(({ addon }) => addon) : officialAddons$1, workspace);
 	if (selectedAddons.length === 0) {
 		const allSetupResults = setupAddons(officialAddons$1, workspace);
 		const addonOptions$1 = officialAddons$1.filter(({ id }) => allSetupResults[id].unsupported.length === 0).map(({ id, homepage, shortDescription }) => ({
@@ -913,10 +891,9 @@ async function runAddCommand(options$1, selectedAddonIds) {
 		}
 	}
 	for (const { addon } of selectedAddons) {
-		workspace = await createWorkspace(workspace);
-		const missingDependencies = setupAddons(selectedAddons.map(({ addon: addon$1 }) => addon$1), workspace)[addon.id].dependsOn.filter((depId) => !selectedAddons.some((a) => a.addon.id === depId));
+		const missingDependencies = addonSetupResults[addon.id].dependsOn.filter((depId) => !selectedAddons.some((a) => a.addon.id === depId));
 		for (const depId of missingDependencies) {
-			const dependency = getAddonDetails(depId);
+			const dependency = officialAddons$1.find((a) => a.id === depId);
 			if (!dependency) throw new Error(`'${addon.id}' depends on an invalid add-on: '${depId}'`);
 			if (await ke({ message: `The ${import_picocolors$2.default.bold(import_picocolors$2.default.cyan(addon.id))} add-on requires ${import_picocolors$2.default.bold(import_picocolors$2.default.cyan(depId))} to also be setup. ${import_picocolors$2.default.green("Include it?")}` }) !== true) {
 				De("Operation cancelled.");
@@ -929,7 +906,6 @@ async function runAddCommand(options$1, selectedAddonIds) {
 		}
 	}
 	const addons = selectedAddons.map(({ addon }) => addon);
-	const addonSetupResults = setupAddons(addons, workspace);
 	const verifications = [...verifyCleanWorkingDirectory(options$1.cwd, options$1.gitCheck), ...verifyUnsupportedAddons(addons, addonSetupResults)];
 	const fails = [];
 	for (const verification of verifications) {
@@ -956,12 +932,12 @@ async function runAddCommand(options$1, selectedAddonIds) {
 		const questionPrefix = selectedAddons.length > 1 ? `${addon.id}: ` : "";
 		let values = {};
 		if (type === "official") {
-			official[addonId] ??= {};
-			values = official[addonId];
+			answersOfficial[addonId] ??= {};
+			values = answersOfficial[addonId];
 		}
 		if (type === "community") {
-			community[addonId] ??= {};
-			values = community[addonId];
+			answersCommunity[addonId] ??= {};
+			values = answersCommunity[addonId];
 		}
 		for (const [questionId, question] of Object.entries(addon.options)) {
 			if (question.condition?.(values) === false || values[questionId] !== void 0) continue;
@@ -998,19 +974,27 @@ async function runAddCommand(options$1, selectedAddonIds) {
 			values[questionId] = answer;
 		}
 	}
+	return {
+		selectedAddons,
+		answersOfficial,
+		answersCommunity
+	};
+}
+async function runAddonsApply({ answersOfficial, answersCommunity, options: options$1, selectedAddons, addonSetupResults, workspace, fromCommand }) {
+	if (!addonSetupResults) addonSetupResults = setupAddons(selectedAddons.length ? selectedAddons.map(({ addon }) => addon) : officialAddons$1, workspace);
 	if (selectedAddons.length === 0) return {
-		packageManager: null,
-		nextSteps: []
+		nextSteps: [],
+		argsFormattedAddons: []
 	};
-	const officialDetails = Object.keys(official).map((id) => getAddonDetails(id));
-	const commDetails = Object.keys(community).map((id) => communityDetails.find((a) => a.id === id));
+	const officialDetails = Object.keys(answersOfficial).map((id) => getAddonDetails(id));
+	const commDetails = Object.keys(answersCommunity).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, pnpmBuildDependencies, status } = await applyAddons({
 		workspace,
 		addonSetupResults,
 		addons: addonMap,
-		options: official
+		options: answersOfficial
 	});
 	const addonSuccess = [];
 	for (const [addonId, info] of Object.entries(status)) if (info === "success") addonSuccess.push(addonId);
@@ -1021,18 +1005,40 @@ async function runAddCommand(options$1, selectedAddonIds) {
 	if (addonSuccess.length === 0) {
 		De("All selected add-ons were canceled.");
 		process.exit(1);
-	} else if (addonSuccess.length === Object.entries(status).length) T.success("Successfully setup add-ons");
-	else T.success(`Successfully setup: ${addonSuccess.join(", ")}`);
-	let packageManager;
-	if (options$1.install) {
-		packageManager = options$1.install === true ? await packageManagerPrompt(options$1.cwd) : options$1.install;
-		if (packageManager) {
-			workspace.packageManager = packageManager;
-			await addPnpmBuildDependencies(workspace.cwd, packageManager, ["esbuild", ...pnpmBuildDependencies]);
-			await installDependencies(packageManager, options$1.cwd);
+	} else {
+		const highlighter$1 = getHighlighter();
+		T.success(`Successfully setup add-ons: ${addonSuccess.map((c) => highlighter$1.addon(c)).join(", ")}`);
+	}
+	const packageManager = options$1.install === false ? null : options$1.install === true ? await packageManagerPrompt(options$1.cwd) : options$1.install;
+	await addPnpmBuildDependencies(workspace.cwd, packageManager, ["esbuild", ...pnpmBuildDependencies]);
+	const argsFormattedAddons = [];
+	for (const { addon, type } of selectedAddons) {
+		const addonId = addon.id;
+		const answers = type === "official" ? answersOfficial[addonId] : answersCommunity[addonId];
+		if (!answers) continue;
+		const addonDetails = type === "official" ? getAddonDetails(addonId) : addon;
+		const optionParts = [];
+		for (const [optionId, value] of Object.entries(answers)) {
+			if (value === void 0) continue;
+			const question = addonDetails.options[optionId];
+			if (!question) continue;
+			let formattedValue;
+			if (question.type === "boolean") formattedValue = value ? "yes" : "no";
+			else if (question.type === "number") formattedValue = String(value);
+			else if (question.type === "multiselect") if (Array.isArray(value)) if (value.length === 0) formattedValue = "none";
+			else formattedValue = value.join(",");
+			else formattedValue = String(value);
+			else formattedValue = String(value);
+			optionParts.push(`${optionId}:${formattedValue}`);
 		}
+		if (optionParts.length > 0) argsFormattedAddons.push(`${addonId}="${optionParts.join("+")}"`);
+		else argsFormattedAddons.push(addonId);
+	}
+	if (fromCommand === "add") logArgs(packageManager, "add", argsFormattedAddons);
+	if (packageManager) {
+		workspace.packageManager = packageManager;
+		await installDependencies(packageManager, options$1.cwd);
 	}
-	workspace = await createWorkspace(workspace);
 	if (filesToFormat.length > 0 && packageManager && !!workspace.dependencyVersion("prettier")) {
 		const { start, stop } = J();
 		start("Formatting modified files");
@@ -1052,10 +1058,10 @@ async function runAddCommand(options$1, selectedAddonIds) {
 	return {
 		nextSteps: selectedAddons.map(({ addon }) => {
 			if (!addon.nextSteps) return;
-			const options$2 = official[addon.id];
+			const addonOptions$1 = answersOfficial[addon.id];
 			const addonNextSteps = addon.nextSteps({
 				...workspace,
-				options: options$2,
+				options: addonOptions$1,
 				highlighter
 			});
 			if (addonNextSteps.length === 0) return;
@@ -1063,10 +1069,40 @@ async function runAddCommand(options$1, selectedAddonIds) {
 			addonMessage += `  - ${addonNextSteps.join("\n  - ")}`;
 			return addonMessage;
 		}).filter((msg) => msg !== void 0),
-		packageManager
+		argsFormattedAddons
 	};
 }
 /**
+* Sanitizes the add-on arguments by checking for invalid add-ons and transforming aliases.
+* @param addonArgs The add-on arguments to sanitize.
+* @returns The sanitized add-on arguments.
+*/
+function sanitizeAddons(addonArgs) {
+	const officialAddonIds = officialAddons$1.map((addon) => addon.id);
+	const invalidAddons = addonArgs.filter(({ id }) => !officialAddonIds.includes(id) && !aliases.includes(id)).map(({ id }) => id);
+	if (invalidAddons.length > 0) errorAndExit(`Invalid add-ons specified: ${invalidAddons.join(", ")}`);
+	return transformAliases(addonArgs);
+}
+/**
+* Handles passed add-on arguments, accumulating them into an array of {@link AddonArgs}.
+*/
+function addonArgsHandler(acc, current) {
+	const [addonId, optionFlags] = current.split("=", 2);
+	if (acc.find(({ id }) => id === addonId)) errorAndExit(`Malformed arguments: Add-on '${addonId}' is repeated multiple times.`);
+	try {
+		const options$1 = parseAddonOptions(optionFlags);
+		acc.push({
+			id: addonId,
+			options: options$1
+		});
+	} catch (error) {
+		if (error instanceof Error) errorAndExit(error.message);
+		console.error(error);
+		process.exit(1);
+	}
+	return acc;
+}
+/**
 * Dedupes and transforms aliases into their respective addon id
 */
 function transformAliases(addons) {
@@ -1144,6 +1180,47 @@ function getOptionChoices(details) {
 		groups
 	};
 }
+async function resolveCommunityAddons(cwd, community) {
+	const selectedAddons = [];
+	const addons = community.map((id) => {
+		if (Object.values(Directive).some((directive) => id.startsWith(directive))) return id;
+		if (!communityAddonIds.includes(id)) throw new Error(`Invalid community add-on specified: '${id}'\nAvailable options: ${communityAddonIds.join(", ")}`);
+		return id;
+	});
+	const { start, stop } = J();
+	try {
+		start("Resolving community add-on packages");
+		const pkgs = await Promise.all(addons.map(async (id) => {
+			return await getPackageJSON({
+				cwd,
+				packageName: id
+			});
+		}));
+		stop("Resolved community add-on packages");
+		T.warn("The Svelte maintainers have not reviewed community add-ons for malicious code. Use at your discretion.");
+		const paddingName = getPadding(pkgs.map(({ pkg }) => pkg.name));
+		const paddingVersion = getPadding(pkgs.map(({ pkg }) => `(v${pkg.version})`));
+		const packageInfos = pkgs.map(({ pkg, repo: _repo }) => {
+			return `${import_picocolors$2.default.yellowBright(pkg.name.padEnd(paddingName))} ${import_picocolors$2.default.dim(`(v${pkg.version})`.padEnd(paddingVersion))} ${import_picocolors$2.default.dim(`(${_repo})`)}`;
+		});
+		T.message(packageInfos.join("\n"));
+		if (await ke({ message: "Would you like to continue?" }) !== true) {
+			De("Operation cancelled.");
+			process.exit(1);
+		}
+		start("Downloading community add-on packages");
+		const details = await Promise.all(pkgs.map(async (opts) => downloadPackage(opts)));
+		for (const addon of details) {
+			communityDetails.push(addon);
+			selectedAddons.push(addon);
+		}
+		stop("Downloaded community add-on packages");
+	} catch (err) {
+		stop("Failed to resolve community add-on packages", 1);
+		throw err;
+	}
+	return selectedAddons;
+}
 
 //#endregion
 //#region ../create/playground.ts
@@ -1318,16 +1395,20 @@ const langMap = {
 const templateChoices = templates.map((t) => t.name);
 const langOption = new Option("--types <lang>", "add type checking").choices(langs);
 const templateOption = new Option("--template <type>", "template to scaffold").choices(templateChoices);
+const noAddonsOption = new Option("--no-add-ons", "do not prompt to add add-ons").conflicts("add");
+const addOption = new Option("--add <addon...>", "add-on to include").default([]);
 const ProjectPathSchema = optional(string());
 const OptionsSchema = strictObject({
 	types: pipe(optional(union([picklist(langs), boolean()])), transform((lang) => langMap[String(lang)])),
 	addOns: boolean(),
+	add: array(string()),
 	install: union([boolean(), picklist(AGENT_NAMES)]),
 	template: optional(picklist(templateChoices)),
 	fromPlayground: optional(string()),
 	dirCheck: boolean()
 });
-const create = new Command("create").description("scaffolds a new SvelteKit project").argument("[path]", "where the project will be created").addOption(templateOption).addOption(langOption).option("--no-types").option("--no-add-ons", "skips interactive add-on installer").option("--no-install", "skip installing dependencies").option("--from-playground <url>", "create a project from the svelte playground").option("--no-dir-check", "even if the folder is not empty, no prompt will be shown").addOption(installOption).configureHelp(helpConfig).action((projectPath, opts) => {
+const defaultPath = "./";
+const create = new Command("create").description("scaffolds a new SvelteKit project").argument("[path]", "where the project will be created").addOption(templateOption).addOption(langOption).option("--no-types").addOption(noAddonsOption).addOption(addOption).option("--no-install", "skip installing dependencies").option("--from-playground <url>", "create a project from the svelte playground").option("--no-dir-check", "even if the folder is not empty, no prompt will be shown").addOption(installOption).configureHelp(helpConfig).action((projectPath, opts) => {
 	const cwd = parse(ProjectPathSchema, projectPath);
 	const options$1 = parse(OptionsSchema, opts);
 	if (options$1.fromPlayground && !validatePlaygroundUrl(options$1.fromPlayground)) {
@@ -1367,13 +1448,12 @@ const create = new Command("create").description("scaffolds a new SvelteKit proj
 		steps.push("", `Stuck? Visit us at ${import_picocolors$1.default.cyan("https://svelte.dev/chat")}`);
 		Ke(steps.join("\n"), "What's next?", { format: (line) => line });
 	});
-});
+}).showHelpAfterError(true);
 async function createProject(cwd, options$1) {
 	if (options$1.fromPlayground) T.warn("The Svelte maintainers have not reviewed playgrounds for malicious code. Use at your discretion.");
 	const { directory, template, language } = await We({
 		directory: () => {
 			if (cwd) return Promise.resolve(path.resolve(cwd));
-			const defaultPath = "./";
 			return et({
 				message: "Where would you like your project to be created?",
 				placeholder: `  (hit Enter to use '${defaultPath}')`,
@@ -1432,32 +1512,75 @@ async function createProject(cwd, options$1) {
 		process.exit(0);
 	} });
 	const projectPath = path.resolve(directory);
+	const projectName = path.basename(projectPath);
+	let selectedAddons = [];
+	let answersOfficial = {};
+	let answersCommunity = {};
+	let sanitizedAddonsMap = {};
+	const workspace = await createVirtualWorkspace({
+		cwd: projectPath,
+		template,
+		packageManager: "npm",
+		type: language
+	});
+	if (options$1.addOns || options$1.add.length > 0) {
+		sanitizedAddonsMap = sanitizeAddons(options$1.add.reduce(addonArgsHandler, [])).reduce((acc, curr) => {
+			acc[curr.id] = curr.options;
+			return acc;
+		}, {});
+		const result = await promptAddonQuestions({
+			options: {
+				cwd: projectPath,
+				install: false,
+				gitCheck: false,
+				community: [],
+				addons: sanitizedAddonsMap
+			},
+			selectedAddonIds: Object.keys(sanitizedAddonsMap),
+			workspace
+		});
+		selectedAddons = result.selectedAddons;
+		answersOfficial = result.answersOfficial;
+		answersCommunity = result.answersCommunity;
+	}
 	create$1(projectPath, {
-		name: path.basename(projectPath),
+		name: projectName,
 		template,
 		types: language
 	});
 	if (options$1.fromPlayground) await createProjectFromPlayground(options$1.fromPlayground, projectPath, language === "typescript");
 	T.success("Project created");
-	let packageManager;
 	let addOnNextSteps = [];
-	const installDeps = async (install) => {
-		packageManager = install === true ? await packageManagerPrompt(projectPath) : install;
-		await addPnpmBuildDependencies(projectPath, packageManager, ["esbuild"]);
-		if (packageManager) await installDependencies(packageManager, projectPath);
-	};
-	if (options$1.addOns) {
-		const { nextSteps, packageManager: pm } = await runAddCommand({
-			cwd: projectPath,
-			install: options$1.install,
-			gitCheck: false,
-			community: [],
-			addons: {}
-		}, []);
-		packageManager = pm;
+	let argsFormattedAddons = [];
+	if (options$1.addOns || options$1.add.length > 0) {
+		const { nextSteps, argsFormattedAddons: argsFormatted$1 } = await runAddonsApply({
+			answersOfficial,
+			answersCommunity,
+			options: {
+				cwd: projectPath,
+				install: false,
+				gitCheck: false,
+				community: [],
+				addons: sanitizedAddonsMap
+			},
+			selectedAddons,
+			addonSetupResults: void 0,
+			workspace,
+			fromCommand: "create"
+		});
+		argsFormattedAddons = argsFormatted$1;
 		addOnNextSteps = nextSteps;
-	} else if (options$1.install) await installDeps(options$1.install);
-	if (packageManager === null && options$1.install) await installDeps(options$1.install);
+	}
+	const packageManager = options$1.install === false ? null : options$1.install === true ? await packageManagerPrompt(projectPath) : options$1.install;
+	const argsFormatted = [];
+	argsFormatted.push("--template", template);
+	if (language === "typescript") argsFormatted.push("--types", "ts");
+	else if (language === "checkjs") argsFormatted.push("--types", "jsdoc");
+	else if (language === "none") argsFormatted.push("--no-types");
+	if (argsFormattedAddons.length > 0) argsFormatted.push("--add", ...argsFormattedAddons);
+	logArgs(packageManager, "create", argsFormatted, [cwd ?? defaultPath]);
+	await addPnpmBuildDependencies(projectPath, packageManager, ["esbuild"]);
+	if (packageManager) await installDependencies(packageManager, projectPath);
 	return {
 		directory: projectPath,
 		addOnNextSteps,
@@ -1483,6 +1606,28 @@ async function confirmExternalDependencies(dependencies) {
 	}
 	return installDeps;
 }
+async function createVirtualWorkspace({ cwd, template, packageManager, type }) {
+	const tentativeWorkspace = await createWorkspace({
+		cwd,
+		packageManager
+	});
+	const virtualWorkspace = {
+		...tentativeWorkspace,
+		typescript: type === "typescript",
+		files: {
+			...tentativeWorkspace.files,
+			viteConfig: type === "typescript" ? commonFilePaths.viteConfigTS : commonFilePaths.viteConfig,
+			svelteConfig: type === "typescript" ? commonFilePaths.svelteConfigTS : commonFilePaths.svelteConfig
+		},
+		kit: void 0,
+		dependencyVersion: () => void 0
+	};
+	if (template === "minimal" || template === "demo" || template === "library") virtualWorkspace.kit = {
+		routesDirectory: "src/routes",
+		libDirectory: "src/lib"
+	};
+	return virtualWorkspace;
+}
 
 //#endregion
 //#region commands/migrate.ts