stackpack-cli 0.3.0

package/dist/program-D9mgsLIa.js

@@ -0,0 +1,4702 @@
+import { Command, Option } from "commander";
+import pc from "picocolors";
+import * as p from "@clack/prompts";
+import fs from "node:fs/promises";
+import path from "node:path";
+import fs$1 from "node:fs";
+import { z } from "zod";
+import { applyEdits, modify, parse } from "jsonc-parser";
+import fg from "fast-glob";
+import validatePackageName from "validate-npm-package-name";
+import semver from "semver";
+import os from "node:os";
+import crypto from "node:crypto";
+import { execa } from "execa";
+//#region src/utils/errors.ts
+var StackPackError = class extends Error {
+	hints;
+	constructor(message, options) {
+		super(message, { cause: options?.cause });
+		this.name = "StackPackError";
+		this.hints = options?.hints ?? [];
+	}
+};
+var CancelledError = class extends Error {
+	constructor(message = "Operation cancelled.") {
+		super(message);
+		this.name = "CancelledError";
+	}
+};
+function toErrorMessage(error) {
+	if (error instanceof Error) return error.message;
+	return String(error);
+}
+//#endregion
+//#region src/ui/prompts.ts
+/** Unwraps a Clack prompt result, converting cancellation into a typed error. */
+function guard(value) {
+	if (p.isCancel(value)) throw new CancelledError();
+	return value;
+}
+/**
+* Unwraps a Clack prompt result, returning null on cancel (Esc) so callers
+* can treat it as "go back one level" instead of aborting the whole flow.
+*/
+function orBack(value) {
+	if (p.isCancel(value)) return null;
+	return value;
+}
+//#endregion
+//#region src/ui/errors.ts
+/**
+* Prints an actionable error. Returns the exit code the process should use.
+*/
+function printError(error, options = {}) {
+	if (error instanceof CancelledError) {
+		console.log("");
+		console.log("Operation cancelled.");
+		console.log(options.changesApplied ? "Some changes may have been applied before cancellation. Check .stackpack/backups for backups." : "No project files were changed.");
+		return 0;
+	}
+	console.error("");
+	console.error(pc.red(`✗ ${toErrorMessage(error)}`));
+	if (error instanceof StackPackError) for (const hint of error.hints) console.error(`  ${hint}`);
+	return 1;
+}
+//#endregion
+//#region src/creators/vite/adapter.ts
+/**
+* Official create-vite adapter. Fresh setups pass no --template so the
+* official creator asks for the framework (React, Vue, Svelte, ...) and the
+* variant (TypeScript, JavaScript, SWC, ...) itself. Preset runs recorded a
+* React project, so they pin the matching official React template.
+*
+* --no-immediate is always passed: it suppresses only create-vite's
+* "Install with npm and start now?" step (which would install and then
+* block on a dev server) while keeping the framework and variant prompts,
+* so dependencies install once at the end together with the integrations.
+*/
+const viteAdapter = {
+	id: "vite",
+	name: "Vite",
+	officialTool: "create-vite",
+	frameworkLabel: "Your pick from create-vite (React, Vue, Svelte, and more)",
+	templateLabel(options) {
+		if (!options.language) return "You choose the framework and variant in create-vite's prompts";
+		return options.language === "typescript" ? "Official React TypeScript template (react-ts)" : "Official React template (react)";
+	},
+	async collectOptions() {
+		return { setupStyle: "custom" };
+	},
+	buildCommand(projectName, options, packageManager, parentDirectory) {
+		const templateArgs = [...options.language ? ["--template", options.language === "typescript" ? "react-ts" : "react"] : [], "--no-immediate"];
+		switch (packageManager) {
+			case "npm": return {
+				command: "npm",
+				args: [
+					"create",
+					"vite@latest",
+					projectName,
+					"--",
+					...templateArgs
+				],
+				cwd: parentDirectory,
+				interactive: true
+			};
+			case "pnpm": return {
+				command: "pnpm",
+				args: [
+					"create",
+					"vite",
+					projectName,
+					...templateArgs
+				],
+				cwd: parentDirectory,
+				interactive: true
+			};
+			case "yarn": return {
+				command: "yarn",
+				args: [
+					"create",
+					"vite",
+					projectName,
+					...templateArgs
+				],
+				cwd: parentDirectory,
+				interactive: true
+			};
+			case "bun": return {
+				command: "bun",
+				args: [
+					"create",
+					"vite",
+					projectName,
+					...templateArgs
+				],
+				cwd: parentDirectory,
+				interactive: true
+			};
+		}
+	}
+};
+//#endregion
+//#region src/creators/next/adapter.ts
+/**
+* Official create-next-app adapter. create-next-app treats ANY "--" flag as
+* "answer everything else with the defaults", so its own step-by-step
+* prompts cannot be combined with --skip-install. To keep a single combined
+* dependency install at the end, StackPack asks the same questions itself
+* (same choices and defaults as create-next-app 16) and passes every answer
+* as a flag, always together with --skip-install.
+*/
+async function askLanguage() {
+	return guard(await p.select({
+		message: "Would you like to use TypeScript?",
+		options: [{
+			value: "typescript",
+			label: "TypeScript",
+			hint: "official recommendation"
+		}, {
+			value: "javascript",
+			label: "JavaScript"
+		}]
+	}));
+}
+async function askCustomAnswers() {
+	return {
+		linter: guard(await p.select({
+			message: "Which linter would you like to use?",
+			options: [
+				{
+					value: "eslint",
+					label: "ESLint"
+				},
+				{
+					value: "biome",
+					label: "Biome"
+				},
+				{
+					value: "none",
+					label: "None"
+				}
+			]
+		})),
+		reactCompiler: guard(await p.confirm({
+			message: "Would you like to use React Compiler?",
+			initialValue: false
+		})),
+		tailwind: guard(await p.confirm({
+			message: "Would you like to use Tailwind CSS?",
+			initialValue: true
+		})),
+		srcDir: guard(await p.confirm({
+			message: "Would you like your code inside a `src/` directory?",
+			initialValue: false
+		})),
+		appRouter: guard(await p.confirm({
+			message: "Would you like to use App Router? (recommended)",
+			initialValue: true
+		})),
+		importAlias: guard(await p.text({
+			message: "What import alias would you like configured?",
+			initialValue: "@/*",
+			validate(value) {
+				return /^.+\/\*$/.test(value ?? "") ? void 0 : "Import alias must follow the pattern <prefix>/*";
+			}
+		})),
+		agentsMd: guard(await p.confirm({
+			message: "Include AGENTS.md to guide coding agents?",
+			initialValue: true
+		}))
+	};
+}
+function customFlags(answers) {
+	return [
+		answers.linter === "eslint" ? "--eslint" : answers.linter === "biome" ? "--biome" : "--no-linter",
+		answers.reactCompiler ? "--react-compiler" : "--no-react-compiler",
+		answers.tailwind ? "--tailwind" : "--no-tailwind",
+		answers.srcDir ? "--src-dir" : "--no-src-dir",
+		answers.appRouter ? "--app" : "--no-app",
+		"--import-alias",
+		answers.importAlias,
+		answers.agentsMd ? "--agents-md" : "--no-agents-md"
+	];
+}
+//#endregion
+//#region src/creators/registry.ts
+const allCreators = [viteAdapter, {
+	id: "next",
+	name: "Next.js",
+	officialTool: "create-next-app",
+	frameworkLabel: "Next.js",
+	templateLabel(options) {
+		const language = options.language === "javascript" ? "JavaScript" : "TypeScript";
+		if (options.setupStyle === "custom" && options.nextAnswers) {
+			const a = options.nextAnswers;
+			const parts = [
+				language,
+				a.linter === "none" ? "no linter" : a.linter === "biome" ? "Biome" : "ESLint",
+				a.tailwind ? "Tailwind CSS" : "no Tailwind",
+				a.appRouter ? "App Router" : "Pages Router"
+			];
+			if (a.reactCompiler) parts.push("React Compiler");
+			if (a.srcDir) parts.push("src/ directory");
+			return `Customized: ${parts.join(", ")}`;
+		}
+		return `Official Next.js defaults with ${language}`;
+	},
+	async collectOptions() {
+		const setupStyle = guard(await p.select({
+			message: "How should the Next.js project be configured?",
+			options: [{
+				value: "custom",
+				label: "Customize step by step",
+				hint: "TypeScript, linter, React Compiler, Tailwind, src/, App Router, import alias"
+			}, {
+				value: "recommended",
+				label: "Official recommended defaults",
+				hint: "no further questions; currently Tailwind CSS, Biome, App Router"
+			}]
+		}));
+		const language = await askLanguage();
+		if (setupStyle === "recommended") return {
+			language,
+			setupStyle
+		};
+		return {
+			language,
+			setupStyle,
+			nextAnswers: await askCustomAnswers()
+		};
+	},
+	buildCommand(projectName, options, packageManager, parentDirectory) {
+		const creatorArgs = [
+			projectName,
+			options.language === "javascript" ? "--javascript" : "--typescript",
+			...options.setupStyle === "custom" && options.nextAnswers ? customFlags(options.nextAnswers) : ["--yes"],
+			`--use-${packageManager}`,
+			"--skip-install"
+		];
+		switch (packageManager) {
+			case "npm": return {
+				command: "npx",
+				args: ["create-next-app@latest", ...creatorArgs],
+				cwd: parentDirectory,
+				interactive: true
+			};
+			case "pnpm": return {
+				command: "pnpm",
+				args: [
+					"create",
+					"next-app",
+					...creatorArgs
+				],
+				cwd: parentDirectory,
+				interactive: true
+			};
+			case "yarn": return {
+				command: "yarn",
+				args: [
+					"create",
+					"next-app",
+					...creatorArgs
+				],
+				cwd: parentDirectory,
+				interactive: true
+			};
+			case "bun": return {
+				command: "bunx",
+				args: ["create-next-app@latest", ...creatorArgs],
+				cwd: parentDirectory,
+				interactive: true
+			};
+		}
+	}
+}];
+function getCreator(id) {
+	const creator = allCreators.find((adapter) => adapter.id === id);
+	if (!creator) throw new Error(`Unknown creator adapter: ${id}`);
+	return creator;
+}
+//#endregion
+//#region src/schemas/project-context.ts
+const frameworkSchema = z.enum([
+	"react",
+	"next",
+	"unknown"
+]);
+const buildToolSchema = z.enum([
+	"vite",
+	"next",
+	"unknown"
+]);
+const languageSchema = z.enum([
+	"typescript",
+	"javascript",
+	"unknown"
+]);
+const packageManagerSchema = z.enum([
+	"npm",
+	"pnpm",
+	"yarn",
+	"bun"
+]);
+const routerTypeSchema = z.enum([
+	"app-router",
+	"pages-router",
+	"client-router",
+	"unknown"
+]);
+const detectionStateSchema = z.enum([
+	"detected",
+	"partially-detected",
+	"ambiguous",
+	"unsupported"
+]);
+const packageJsonSchema = z.object({
+	name: z.string().optional(),
+	version: z.string().optional(),
+	scripts: z.record(z.string(), z.string()).optional(),
+	dependencies: z.record(z.string(), z.string()).optional(),
+	devDependencies: z.record(z.string(), z.string()).optional()
+}).loose();
+const projectContextSchema = z.object({
+	rootDirectory: z.string(),
+	framework: frameworkSchema,
+	buildTool: buildToolSchema,
+	language: languageSchema,
+	packageManager: packageManagerSchema,
+	/** All package managers whose lockfiles were found; >1 means ambiguous. */
+	packageManagerCandidates: z.array(packageManagerSchema),
+	routerType: routerTypeSchema.optional(),
+	detection: detectionStateSchema,
+	packageJson: packageJsonSchema,
+	detectedFiles: z.array(z.string()),
+	installedPackages: z.record(z.string(), z.string())
+});
+//#endregion
+//#region src/project/package-json.ts
+async function readPackageJson(projectRoot) {
+	const filePath = path.join(projectRoot, "package.json");
+	let raw;
+	try {
+		raw = await fs.readFile(filePath, "utf8");
+	} catch (error) {
+		throw new StackPackError("package.json was not found.", {
+			hints: ["StackPack must run inside a supported JavaScript project.", `Current directory: ${projectRoot}`],
+			cause: error
+		});
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (error) {
+		throw new StackPackError("package.json could not be parsed as JSON.", {
+			hints: [`File: ${filePath}`],
+			cause: error
+		});
+	}
+	const validated = packageJsonSchema.safeParse(parsed);
+	if (!validated.success) throw new StackPackError("package.json has an unexpected structure.", { hints: validated.error.issues.slice(0, 3).map((i) => `${i.path.join(".")}: ${i.message}`) });
+	return {
+		raw,
+		data: validated.data
+	};
+}
+/** Merged dependencies and devDependencies from package.json. */
+function getInstalledPackages(pkg) {
+	return {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	};
+}
+/**
+* Applies script changes to package.json using structured JSONC edits so
+* formatting and unrelated properties are preserved.
+*/
+async function updatePackageJsonScripts(projectRoot, scripts) {
+	const filePath = path.join(projectRoot, "package.json");
+	let content = await fs.readFile(filePath, "utf8");
+	for (const [name, command] of Object.entries(scripts)) {
+		const edits = modify(content, ["scripts", name], command, { formattingOptions: {
+			insertSpaces: true,
+			tabSize: 2
+		} });
+		content = applyEdits(content, edits);
+	}
+	const reparsed = parse(content);
+	if (typeof reparsed !== "object" || reparsed === null) throw new StackPackError("Refusing to write package.json: edit produced invalid JSON.");
+	await fs.writeFile(filePath, content, "utf8");
+}
+//#endregion
+//#region src/project/detect-files.ts
+const MARKER_PATTERNS = [
+	"package.json",
+	"package-lock.json",
+	"pnpm-lock.yaml",
+	"yarn.lock",
+	"bun.lock",
+	"bun.lockb",
+	"vite.config.*",
+	"vitest.config.*",
+	"next.config.*",
+	"playwright.config.*",
+	"components.json",
+	"tsconfig.json",
+	"jsconfig.json",
+	"src/main.*",
+	"src/App.*",
+	"src/test/setup.*",
+	"app/layout.*",
+	"app/page.*",
+	"src/app/layout.*",
+	"src/app/page.*",
+	"pages/_app.*",
+	"pages/index.*",
+	"src/pages/_app.*",
+	"src/pages/index.*"
+];
+const IGNORED = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/build/**",
+	"**/coverage/**",
+	"**/.git/**"
+];
+/**
+* Finds well-known project marker files. Never scans outside the given root
+* and skips dependency and build output directories.
+*/
+async function detectProjectFiles(projectRoot) {
+	const entries = await fg(MARKER_PATTERNS, {
+		cwd: projectRoot,
+		ignore: IGNORED,
+		onlyFiles: true,
+		dot: false,
+		followSymbolicLinks: false
+	});
+	return new Set(entries.map((entry) => entry.replaceAll("\\", "/")));
+}
+//#endregion
+//#region src/package-manager/detect.ts
+const LOCKFILES = [
+	["package-lock.json", "npm"],
+	["pnpm-lock.yaml", "pnpm"],
+	["yarn.lock", "yarn"],
+	["bun.lock", "bun"],
+	["bun.lockb", "bun"]
+];
+/**
+* Detects package managers from lockfiles in the project root.
+* Returns every distinct match; more than one means the project is ambiguous
+* and the user must choose.
+*/
+function detectPackageManagers(projectRoot) {
+	const found = [];
+	for (const [lockfile, manager] of LOCKFILES) if (fs$1.existsSync(path.join(projectRoot, lockfile)) && !found.includes(manager)) found.push(manager);
+	return found;
+}
+//#endregion
+//#region src/engine/detect-project.ts
+function has(files, prefix) {
+	for (const file of files) if (file.startsWith(prefix)) return true;
+	return false;
+}
+/**
+* Inspects a project directory and builds a normalized, validated context.
+* Never trusts prior selections: everything is derived from real files.
+*/
+async function detectProject(rootDirectory, options = {}) {
+	const root = path.resolve(rootDirectory);
+	const { data: packageJson } = await readPackageJson(root);
+	const files = await detectProjectFiles(root);
+	const installedPackages = getInstalledPackages(packageJson);
+	const hasNext = "next" in installedPackages;
+	const hasReact = "react" in installedPackages;
+	const hasVite = "vite" in installedPackages || has(files, "vite.config.");
+	const framework = hasNext ? "next" : hasReact ? "react" : "unknown";
+	const buildTool = hasNext ? "next" : hasVite ? "vite" : "unknown";
+	const hasTsConfig = files.has("tsconfig.json");
+	const hasTsDep = "typescript" in installedPackages;
+	const hasTsEntry = has(files, "src/main.ts") || has(files, "src/App.ts");
+	const hasJsEntry = has(files, "src/main.js") || has(files, "src/App.js") || files.has("jsconfig.json");
+	const language = hasTsConfig || hasTsDep || hasTsEntry ? "typescript" : hasJsEntry || hasReact || hasNext ? "javascript" : "unknown";
+	let routerType;
+	if (framework === "next") {
+		const hasAppDir = has(files, "app/layout.") || has(files, "app/page.") || has(files, "src/app/layout.") || has(files, "src/app/page.") || fs$1.existsSync(path.join(root, "app")) || fs$1.existsSync(path.join(root, "src", "app"));
+		const hasPagesDir = has(files, "pages/") || has(files, "src/pages/") || fs$1.existsSync(path.join(root, "pages")) || fs$1.existsSync(path.join(root, "src", "pages"));
+		routerType = hasAppDir ? "app-router" : hasPagesDir ? "pages-router" : "unknown";
+	} else if (framework === "react") routerType = "react-router-dom" in installedPackages || "react-router" in installedPackages ? "client-router" : "unknown";
+	const candidates = detectPackageManagers(root);
+	const packageManager = options.packageManagerOverride ?? candidates[0] ?? "npm";
+	let detection;
+	if (framework === "unknown") detection = "unsupported";
+	else if (candidates.length > 1 && !options.packageManagerOverride) detection = "ambiguous";
+	else if (framework === "react" && buildTool === "unknown") detection = "partially-detected";
+	else detection = "detected";
+	return projectContextSchema.parse({
+		rootDirectory: root,
+		framework,
+		buildTool,
+		language,
+		packageManager,
+		packageManagerCandidates: candidates,
+		routerType,
+		detection,
+		packageJson,
+		detectedFiles: [...files].sort(),
+		installedPackages
+	});
+}
+//#endregion
+//#region src/schemas/recipe.ts
+/** Validates the static, serializable metadata of an integration recipe. */
+const recipeMetadataSchema = z.object({
+	id: z.string().regex(/^[a-z0-9-]+$/),
+	recipeVersion: z.number().int().positive(),
+	name: z.string().min(1),
+	category: z.enum([
+		"routing",
+		"state-management",
+		"data-fetching",
+		"forms-validation",
+		"ui",
+		"orm",
+		"testing"
+	]),
+	status: z.enum([
+		"stable",
+		"experimental",
+		"deprecated"
+	]),
+	officialSource: z.object({
+		documentationUrl: z.string().url(),
+		lastVerifiedAt: z.string()
+	}),
+	requires: z.array(z.string()).default([]),
+	runsAfter: z.array(z.string()).default([]),
+	conflictsWith: z.array(z.string()).default([])
+});
+//#endregion
+//#region src/integrations/detect.ts
+/** Standard detection: any of the given packages present in package.json. */
+function detectByPackages(context, packageNames) {
+	for (const name of packageNames) {
+		const version = context.installedPackages[name];
+		if (version !== void 0) return {
+			status: "installed",
+			installedVersion: version,
+			details: `${name}@${version}`
+		};
+	}
+	return { status: "not-installed" };
+}
+function sourceExtension(context, jsx) {
+	if (context.language === "typescript") return jsx ? "tsx" : "ts";
+	return jsx ? "jsx" : "js";
+}
+//#endregion
+//#region src/integrations/react-router/recipe.ts
+const packages$3 = [{
+	name: "react-router-dom",
+	version: "latest",
+	dependencyType: "dependency",
+	reason: "Official React Router package for web applications."
+}];
+const reactRouterRecipe = {
+	id: "react-router",
+	recipeVersion: 1,
+	name: "React Router",
+	category: "routing",
+	status: "stable",
+	installationSummary: "Official documented package installation",
+	officialSource: {
+		documentationUrl: "https://reactrouter.com/start/library/installation",
+		lastVerifiedAt: "2026-07-19"
+	},
+	requires: [],
+	runsAfter: [],
+	conflictsWith: [],
+	supportedProjects: [{
+		frameworks: ["react"],
+		buildTools: ["vite"]
+	}],
+	installation: {
+		type: "official-package-install",
+		dependencies: packages$3,
+		devDependencies: []
+	},
+	detectInstalled(context) {
+		return detectByPackages(context, ["react-router-dom", "react-router"]);
+	},
+	createPlan() {
+		return {
+			packages: packages$3,
+			filesToCreate: [],
+			scripts: [],
+			postInstallNotes: ["React Router was installed without generated routing files.", "Wrap your application in <BrowserRouter> (see the official docs) when you are ready to add routes."]
+		};
+	}
+};
+//#endregion
+//#region src/integrations/zustand/recipe.ts
+const packages$2 = [{
+	name: "zustand",
+	version: "latest",
+	dependencyType: "dependency",
+	reason: "Official Zustand package."
+}];
+const zustandRecipe = {
+	id: "zustand",
+	recipeVersion: 1,
+	name: "Zustand",
+	category: "state-management",
+	status: "stable",
+	installationSummary: "Official documented package installation",
+	officialSource: {
+		documentationUrl: "https://zustand.docs.pmnd.rs/getting-started/introduction",
+		lastVerifiedAt: "2026-07-19"
+	},
+	requires: [],
+	runsAfter: [],
+	conflictsWith: [],
+	supportedProjects: [{ frameworks: ["react", "next"] }],
+	installation: {
+		type: "official-package-install",
+		dependencies: packages$2,
+		devDependencies: []
+	},
+	detectInstalled(context) {
+		return detectByPackages(context, ["zustand"]);
+	},
+	createPlan() {
+		return {
+			packages: packages$2,
+			filesToCreate: [],
+			scripts: [],
+			postInstallNotes: ["Zustand requires no configuration by default."]
+		};
+	}
+};
+//#endregion
+//#region src/integrations/redux-toolkit/recipe.ts
+const packages$1 = [{
+	name: "@reduxjs/toolkit",
+	version: "latest",
+	dependencyType: "dependency",
+	reason: "Official Redux Toolkit package."
+}, {
+	name: "react-redux",
+	version: "latest",
+	dependencyType: "dependency",
+	reason: "Official React binding for Redux."
+}];
+function storeFiles(context) {
+	const ts = context.language === "typescript";
+	const ext = sourceExtension(context, false);
+	const storeContents = ts ? `import { configureStore } from "@reduxjs/toolkit";
+
+export const store = configureStore({
+  reducer: {},
+});
+
+export type RootState = ReturnType<typeof store.getState>;
+export type AppDispatch = typeof store.dispatch;
+` : `import { configureStore } from "@reduxjs/toolkit";
+
+export const store = configureStore({
+  reducer: {},
+});
+`;
+	const files = [{
+		path: `src/store/store.${ext}`,
+		contents: storeContents,
+		description: "Basic Redux store following the official Redux Toolkit quick start."
+	}];
+	if (ts) files.push({
+		path: "src/store/hooks.ts",
+		contents: `import { useDispatch, useSelector } from "react-redux";
+import type { AppDispatch, RootState } from "./store";
+
+export const useAppDispatch = useDispatch.withTypes<AppDispatch>();
+export const useAppSelector = useSelector.withTypes<RootState>();
+`,
+		description: "Typed hooks recommended by the official Redux Toolkit TypeScript guide."
+	});
+	return files;
+}
+const reduxToolkitRecipe = {
+	id: "redux-toolkit",
+	recipeVersion: 1,
+	name: "Redux Toolkit",
+	category: "state-management",
+	status: "stable",
+	installationSummary: "Official React package installation",
+	officialSource: {
+		documentationUrl: "https://redux-toolkit.js.org/introduction/getting-started",
+		lastVerifiedAt: "2026-07-19"
+	},
+	requires: [],
+	runsAfter: [],
+	conflictsWith: [],
+	supportedProjects: [{ frameworks: ["react", "next"] }],
+	installation: {
+		type: "official-package-install",
+		dependencies: packages$1,
+		devDependencies: []
+	},
+	detectInstalled(context) {
+		return detectByPackages(context, ["@reduxjs/toolkit"]);
+	},
+	describeOptions(options) {
+		return options.generateStore === true ? "with basic store files" : void 0;
+	},
+	createPlan(context, options) {
+		const generateStore = options.generateStore === true;
+		return {
+			packages: packages$1,
+			filesToCreate: generateStore ? storeFiles(context) : [],
+			scripts: [],
+			postInstallNotes: generateStore ? ["Wrap your application in <Provider store={store}> to activate the store."] : ["Packages installed only. No store files were generated."]
+		};
+	}
+};
+//#endregion
+//#region src/integrations/tanstack-query/recipe.ts
+const mainPackage = {
+	name: "@tanstack/react-query",
+	version: "latest",
+	dependencyType: "dependency",
+	reason: "Official TanStack Query package for React."
+};
+const devtoolsPackage = {
+	name: "@tanstack/react-query-devtools",
+	version: "latest",
+	dependencyType: "dependency",
+	reason: "Officially documented development tools for TanStack Query."
+};
+function providerFiles(context, devtools) {
+	const ext = sourceExtension(context, false);
+	const jsxExt = sourceExtension(context, true);
+	return [{
+		path: `src/lib/query-client.${ext}`,
+		contents: `import { QueryClient } from "@tanstack/react-query";
+
+export const queryClient = new QueryClient();
+`,
+		description: "Shared QueryClient instance."
+	}, {
+		path: `src/lib/query-provider.${jsxExt}`,
+		contents: `import { QueryClientProvider } from "@tanstack/react-query";
+${devtools ? `import { ReactQueryDevtools } from "@tanstack/react-query-devtools";\n` : ""}${context.language === "typescript" ? `import type { ReactNode } from "react";\n` : ""}import { queryClient } from "./query-client";
+
+${context.language === "typescript" ? "export function AppQueryProvider({ children }: { children: ReactNode }) {" : "export function AppQueryProvider({ children }) {"}
+  return (
+    <QueryClientProvider client={queryClient}>
+      {children}
+${devtools ? "      <ReactQueryDevtools initialIsOpen={false} />\n" : ""}    </QueryClientProvider>
+  );
+}
+`,
+		description: "Provider component ready to wrap your application entry."
+	}];
+}
+const tanstackQueryRecipe = {
+	id: "tanstack-query",
+	recipeVersion: 1,
+	name: "TanStack Query",
+	category: "data-fetching",
+	status: "stable",
+	installationSummary: "Official documented package installation",
+	officialSource: {
+		documentationUrl: "https://tanstack.com/query/latest/docs/framework/react/installation",
+		lastVerifiedAt: "2026-07-19"
+	},
+	requires: [],
+	runsAfter: [],
+	conflictsWith: [],
+	supportedProjects: [{ frameworks: ["react", "next"] }],
+	installation: {
+		type: "official-package-install",
+		dependencies: [mainPackage],
+		devDependencies: []
+	},
+	detectInstalled(context) {
+		return detectByPackages(context, ["@tanstack/react-query"]);
+	},
+	describeOptions(options) {
+		const parts = [];
+		if (options.devtools === true) parts.push("Devtools");
+		if (options.configureProvider === true) parts.push("provider files");
+		return parts.length > 0 ? `with ${parts.join(" + ")}` : void 0;
+	},
+	createPlan(context, options) {
+		const devtools = options.devtools === true;
+		const configureProvider = options.configureProvider === true;
+		const packages = devtools ? [mainPackage, devtoolsPackage] : [mainPackage];
+		const notes = [];
+		if (configureProvider) notes.push("StackPack does not rewrite your application entry file automatically.", "Wrap your app with <AppQueryProvider> from src/lib/query-provider to finish the setup.");
+		else notes.push("Packages installed only. Create a QueryClient and provider when ready.");
+		return {
+			packages,
+			filesToCreate: configureProvider ? providerFiles(context, devtools) : [],
+			scripts: [],
+			postInstallNotes: notes
+		};
+	}
+};
+//#endregion
+//#region src/integrations/react-hook-form-zod/recipe.ts
+const packages = [
+	{
+		name: "react-hook-form",
+		version: "latest",
+		dependencyType: "dependency",
+		reason: "Form state and validation lifecycle."
+	},
+	{
+		name: "zod",
+		version: "latest",
+		dependencyType: "dependency",
+		reason: "Schema validation."
+	},
+	{
+		name: "@hookform/resolvers",
+		version: "latest",
+		dependencyType: "dependency",
+		reason: "Connects React Hook Form to Zod."
+	}
+];
+const reactHookFormZodRecipe = {
+	id: "react-hook-form-zod",
+	recipeVersion: 1,
+	name: "React Hook Form with Zod",
+	category: "forms-validation",
+	status: "stable",
+	installationSummary: "Official documented package installation",
+	officialSource: {
+		documentationUrl: "https://react-hook-form.com/get-started#SchemaValidation",
+		lastVerifiedAt: "2026-07-19"
+	},
+	requires: [],
+	runsAfter: [],
+	conflictsWith: [],
+	supportedProjects: [{ frameworks: ["react", "next"] }],
+	installation: {
+		type: "official-package-install",
+		dependencies: packages,
+		devDependencies: []
+	},
+	detectInstalled(context) {
+		const rhf = detectByPackages(context, ["react-hook-form"]);
+		if (rhf.status !== "installed") return rhf;
+		if (detectByPackages(context, ["@hookform/resolvers"]).status !== "installed") return {
+			status: "partially-configured",
+			installedVersion: rhf.installedVersion,
+			details: "react-hook-form is installed but @hookform/resolvers is missing."
+		};
+		return rhf;
+	},
+	createPlan() {
+		return {
+			packages,
+			filesToCreate: [],
+			scripts: [],
+			postInstallNotes: ["Use zodResolver from @hookform/resolvers/zod to connect your Zod schemas to useForm."]
+		};
+	}
+};
+//#endregion
+//#region src/integrations/vitest-react/recipe.ts
+const vitestPackage = {
+	name: "vitest",
+	version: "latest",
+	dependencyType: "devDependency",
+	reason: "Official Vitest test runner."
+};
+const componentTestingPackages = [
+	{
+		name: "jsdom",
+		version: "latest",
+		dependencyType: "devDependency",
+		reason: "Browser-like DOM environment for component tests."
+	},
+	{
+		name: "@testing-library/react",
+		version: "latest",
+		dependencyType: "devDependency",
+		reason: "Official React Testing Library."
+	},
+	{
+		name: "@testing-library/jest-dom",
+		version: "latest",
+		dependencyType: "devDependency",
+		reason: "DOM matchers for assertions."
+	},
+	{
+		name: "@testing-library/user-event",
+		version: "latest",
+		dependencyType: "devDependency",
+		reason: "User interaction utilities."
+	}
+];
+function vitestConfigFile(context, components) {
+	const ext = context.language === "typescript" ? "ts" : "js";
+	const hasViteConfig = context.detectedFiles.some((file) => file.startsWith("vite.config."));
+	const testBlock = components ? `  test: {
+    environment: "jsdom",
+    globals: true,
+    setupFiles: ["./src/test/setup.${ext}"],
+  },` : `  test: {
+    environment: "node",
+  },`;
+	const contents = hasViteConfig ? `import { defineConfig, mergeConfig } from "vitest/config";
+import viteConfig from "./vite.config";
+
+export default mergeConfig(
+  viteConfig,
+  defineConfig({
+${testBlock}
+  }),
+);
+` : `import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+${testBlock}
+});
+`;
+	return {
+		path: `vitest.config.${ext}`,
+		contents,
+		description: hasViteConfig ? "Vitest configuration merged with your existing Vite configuration (official pattern)." : "Standalone Vitest configuration."
+	};
+}
+function setupFile(context) {
+	return {
+		path: `src/test/setup.${sourceExtension(context, false)}`,
+		contents: `import "@testing-library/jest-dom/vitest";
+`,
+		description: "Registers Testing Library DOM matchers with Vitest."
+	};
+}
+const vitestReactRecipe = {
+	id: "vitest-react",
+	recipeVersion: 1,
+	name: "Vitest with React Testing Library",
+	category: "testing",
+	status: "stable",
+	installationSummary: "Official documented package installation and configuration",
+	officialSource: {
+		documentationUrl: "https://vitest.dev/guide/",
+		lastVerifiedAt: "2026-07-19"
+	},
+	requires: [],
+	runsAfter: [],
+	conflictsWith: [],
+	supportedProjects: [{
+		frameworks: ["react"],
+		buildTools: ["vite"]
+	}],
+	installation: {
+		type: "official-package-install",
+		dependencies: [],
+		devDependencies: [vitestPackage, ...componentTestingPackages]
+	},
+	detectInstalled(context) {
+		const vitest = detectByPackages(context, ["vitest"]);
+		if (vitest.status !== "installed") return vitest;
+		if (!context.detectedFiles.some((file) => file.startsWith("vitest.config.") || file.startsWith("vite.config."))) return {
+			status: "partially-configured",
+			installedVersion: vitest.installedVersion,
+			details: "vitest is installed but no configuration file was found."
+		};
+		return vitest;
+	},
+	describeOptions(options) {
+		return options.testTarget === "utils" ? "utility tests only" : "React component testing";
+	},
+	createPlan(context, options) {
+		const components = options.testTarget !== "utils";
+		const packages = components ? [vitestPackage, ...componentTestingPackages] : [vitestPackage];
+		const filesToCreate = [vitestConfigFile(context, components)];
+		if (components) filesToCreate.push(setupFile(context));
+		return {
+			packages,
+			filesToCreate,
+			scripts: [{
+				name: "test",
+				command: "vitest"
+			}],
+			postInstallNotes: components ? ["Run your first component test with: npm run test"] : ["Vitest is configured for utility tests only."]
+		};
+	}
+};
+//#endregion
+//#region src/integrations/playwright/recipe.ts
+const initializer$1 = {
+	description: "The official Playwright initializer will run interactively. It may ask questions, install browsers, and create configuration, example tests, and CI files.",
+	interactive: true,
+	buildCommand(packageManager, cwd) {
+		switch (packageManager) {
+			case "npm": return {
+				command: "npm",
+				args: ["init", "playwright@latest"],
+				cwd,
+				interactive: true
+			};
+			case "pnpm": return {
+				command: "pnpm",
+				args: ["create", "playwright"],
+				cwd,
+				interactive: true
+			};
+			case "yarn": return {
+				command: "yarn",
+				args: ["create", "playwright"],
+				cwd,
+				interactive: true
+			};
+			case "bun": return {
+				command: "bun",
+				args: ["create", "playwright"],
+				cwd,
+				interactive: true
+			};
+		}
+	}
+};
+const playwrightRecipe = {
+	id: "playwright",
+	recipeVersion: 1,
+	name: "Playwright",
+	category: "testing",
+	status: "stable",
+	installationSummary: "Official initializer CLI",
+	officialSource: {
+		documentationUrl: "https://playwright.dev/docs/intro",
+		lastVerifiedAt: "2026-07-19"
+	},
+	requires: [],
+	runsAfter: ["vitest-react"],
+	conflictsWith: [],
+	supportedProjects: [{ frameworks: ["react", "next"] }],
+	installation: {
+		type: "official-initializer",
+		initializer: initializer$1
+	},
+	detectInstalled(context) {
+		const byPackage = detectByPackages(context, ["@playwright/test"]);
+		if (byPackage.status === "installed") return byPackage;
+		if (context.detectedFiles.some((file) => file.startsWith("playwright.config."))) return {
+			status: "partially-configured",
+			details: "Config exists but @playwright/test is not installed."
+		};
+		return { status: "not-installed" };
+	},
+	createPlan() {
+		return {
+			packages: [],
+			filesToCreate: [],
+			scripts: [],
+			postInstallNotes: ["Playwright setup is delegated to the official initializer.", "StackPack will rescan the project after the initializer finishes."],
+			initializer: initializer$1
+		};
+	}
+};
+//#endregion
+//#region src/integrations/install-only.ts
+/**
+* Factory for recipes that install official packages and nothing else: no
+* generated files, no scripts. The developer does their own setup following
+* the official documentation (linked per recipe).
+*/
+function installOnlyRecipe(definition) {
+	const dependencies = definition.dependencies;
+	const devDependencies = definition.devDependencies ?? [];
+	const packages = [...dependencies, ...devDependencies];
+	const detectNames = dependencies.map((pkg) => pkg.name);
+	return {
+		id: definition.id,
+		recipeVersion: 1,
+		name: definition.name,
+		category: definition.category,
+		status: "stable",
+		installationSummary: "Official documented package installation",
+		officialSource: {
+			documentationUrl: definition.documentationUrl,
+			lastVerifiedAt: "2026-07-19"
+		},
+		requires: [],
+		runsAfter: [],
+		conflictsWith: [],
+		supportedProjects: [{ frameworks: ["react", "next"] }],
+		installation: {
+			type: "official-package-install",
+			dependencies,
+			devDependencies
+		},
+		detectInstalled(context) {
+			return detectByPackages(context, detectNames);
+		},
+		createPlan() {
+			return {
+				packages,
+				filesToCreate: [],
+				scripts: [],
+				postInstallNotes: definition.notes ?? []
+			};
+		}
+	};
+}
+const jotaiRecipe = installOnlyRecipe({
+	id: "jotai",
+	name: "Jotai",
+	category: "state-management",
+	documentationUrl: "https://jotai.org/docs/introduction",
+	dependencies: [{
+		name: "jotai",
+		version: "latest",
+		dependencyType: "dependency",
+		reason: "Atomic state."
+	}],
+	notes: ["Jotai needs no configuration: create atoms anywhere and use useAtom()."]
+});
+const mobxRecipe = installOnlyRecipe({
+	id: "mobx",
+	name: "MobX",
+	category: "state-management",
+	documentationUrl: "https://mobx.js.org/README.html",
+	dependencies: [{
+		name: "mobx",
+		version: "latest",
+		dependencyType: "dependency",
+		reason: "Core library."
+	}, {
+		name: "mobx-react-lite",
+		version: "latest",
+		dependencyType: "dependency",
+		reason: "Official React bindings."
+	}],
+	notes: ["Wrap components with observer() from mobx-react-lite to react to store changes."]
+});
+const valtioRecipe = installOnlyRecipe({
+	id: "valtio",
+	name: "Valtio",
+	category: "state-management",
+	documentationUrl: "https://valtio.dev/docs/introduction/getting-started",
+	dependencies: [{
+		name: "valtio",
+		version: "latest",
+		dependencyType: "dependency",
+		reason: "Proxy-based state."
+	}],
+	notes: ["Create state with proxy() and read it in components with useSnapshot()."]
+});
+const xstateRecipe = installOnlyRecipe({
+	id: "xstate",
+	name: "XState",
+	category: "state-management",
+	documentationUrl: "https://stately.ai/docs/xstate",
+	dependencies: [{
+		name: "xstate",
+		version: "latest",
+		dependencyType: "dependency",
+		reason: "State machines and statecharts."
+	}, {
+		name: "@xstate/react",
+		version: "latest",
+		dependencyType: "dependency",
+		reason: "Official React hooks."
+	}],
+	notes: ["Define machines with createMachine() and use them via useMachine() from @xstate/react."]
+});
+const valibotRecipe = installOnlyRecipe({
+	id: "valibot",
+	name: "Valibot",
+	category: "forms-validation",
+	documentationUrl: "https://valibot.dev/guides/introduction/",
+	dependencies: [{
+		name: "valibot",
+		version: "latest",
+		dependencyType: "dependency",
+		reason: "Lightweight schema validation."
+	}],
+	notes: ["Valibot is modular and tree-shakeable; import only the validators you use."]
+});
+const arktypeRecipe = installOnlyRecipe({
+	id: "arktype",
+	name: "ArkType",
+	category: "forms-validation",
+	documentationUrl: "https://arktype.io/docs/intro/setup",
+	dependencies: [{
+		name: "arktype",
+		version: "latest",
+		dependencyType: "dependency",
+		reason: "TypeScript-first runtime validation."
+	}],
+	notes: ["ArkType shines with TypeScript: definitions are inferred as precise static types."]
+});
+const axiosRecipe = installOnlyRecipe({
+	id: "axios",
+	name: "Axios",
+	category: "data-fetching",
+	documentationUrl: "https://axios-http.com/docs/intro",
+	dependencies: [{
+		name: "axios",
+		version: "latest",
+		dependencyType: "dependency",
+		reason: "HTTP request client."
+	}],
+	notes: ["Axios is an HTTP client only; pair it with TanStack Query for caching if needed."]
+});
+const ormNote = "Dependencies only — StackPack creates no ORM files; follow the official docs.";
+const driverNote = "Remember to install your database driver too (e.g. pg, mysql2, better-sqlite3).";
+const installOnlyRecipes = [
+	jotaiRecipe,
+	mobxRecipe,
+	valtioRecipe,
+	xstateRecipe,
+	valibotRecipe,
+	arktypeRecipe,
+	axiosRecipe,
+	installOnlyRecipe({
+		id: "prisma",
+		name: "Prisma",
+		category: "orm",
+		documentationUrl: "https://www.prisma.io/docs/getting-started",
+		dependencies: [{
+			name: "@prisma/client",
+			version: "latest",
+			dependencyType: "dependency",
+			reason: "Generated query client."
+		}],
+		devDependencies: [{
+			name: "prisma",
+			version: "latest",
+			dependencyType: "devDependency",
+			reason: "CLI and migrations."
+		}],
+		notes: [ormNote, "Start with \"npx prisma init\" to create schema.prisma and .env."]
+	}),
+	installOnlyRecipe({
+		id: "drizzle-orm",
+		name: "Drizzle ORM",
+		category: "orm",
+		documentationUrl: "https://orm.drizzle.team/docs/get-started",
+		dependencies: [{
+			name: "drizzle-orm",
+			version: "latest",
+			dependencyType: "dependency",
+			reason: "TypeScript SQL ORM."
+		}],
+		devDependencies: [{
+			name: "drizzle-kit",
+			version: "latest",
+			dependencyType: "devDependency",
+			reason: "Migrations and studio."
+		}],
+		notes: [ormNote, driverNote]
+	}),
+	installOnlyRecipe({
+		id: "typeorm",
+		name: "TypeORM",
+		category: "orm",
+		documentationUrl: "https://typeorm.io",
+		dependencies: [{
+			name: "typeorm",
+			version: "latest",
+			dependencyType: "dependency",
+			reason: "Entity-based ORM."
+		}, {
+			name: "reflect-metadata",
+			version: "latest",
+			dependencyType: "dependency",
+			reason: "Required for decorators."
+		}],
+		notes: [
+			ormNote,
+			driverNote,
+			"Enable \"experimentalDecorators\" and \"emitDecoratorMetadata\" in tsconfig."
+		]
+	}),
+	installOnlyRecipe({
+		id: "sequelize",
+		name: "Sequelize",
+		category: "orm",
+		documentationUrl: "https://sequelize.org/docs/v6/getting-started/",
+		dependencies: [{
+			name: "sequelize",
+			version: "latest",
+			dependencyType: "dependency",
+			reason: "Mature traditional ORM."
+		}],
+		notes: [ormNote, driverNote]
+	}),
+	installOnlyRecipe({
+		id: "mikro-orm",
+		name: "MikroORM",
+		category: "orm",
+		documentationUrl: "https://mikro-orm.io/docs/quick-start",
+		dependencies: [{
+			name: "@mikro-orm/core",
+			version: "latest",
+			dependencyType: "dependency",
+			reason: "Data Mapper ORM core."
+		}],
+		notes: [ormNote, "Add the matching driver package (e.g. @mikro-orm/postgresql) yourself."]
+	})
+];
+//#endregion
+//#region src/integrations/ui/recipes.ts
+/**
+* Every UI-library recipe ships a small test button component so the user
+* can render it immediately and confirm the installed dependency works.
+*/
+function testButtonFile(context, fileName, contents) {
+	return {
+		path: `src/components/${fileName}.${context.language === "typescript" ? "tsx" : "jsx"}`,
+		contents,
+		description: "Test button to verify the UI library works."
+	};
+}
+const uiNote = (component, path) => `Render <${component} /> (from ${path}) in any page to test that the library works.`;
+const radixRecipe = {
+	id: "radix-ui",
+	recipeVersion: 1,
+	name: "Radix UI",
+	category: "ui",
+	status: "stable",
+	installationSummary: "Official package installation + generated test button",
+	officialSource: {
+		documentationUrl: "https://www.radix-ui.com/primitives/docs/overview/getting-started",
+		lastVerifiedAt: "2026-07-19"
+	},
+	requires: [],
+	runsAfter: [],
+	conflictsWith: [],
+	supportedProjects: [{ frameworks: ["react", "next"] }],
+	installation: {
+		type: "official-package-install",
+		dependencies: [{
+			name: "radix-ui",
+			version: "latest",
+			dependencyType: "dependency",
+			reason: "Unstyled accessible primitives (unified package)."
+		}],
+		devDependencies: []
+	},
+	detectInstalled(context) {
+		return detectByPackages(context, ["radix-ui"]);
+	},
+	createPlan(context) {
+		return {
+			packages: [{
+				name: "radix-ui",
+				version: "latest",
+				dependencyType: "dependency",
+				reason: "Unstyled accessible primitives (unified package)."
+			}],
+			filesToCreate: [testButtonFile(context, "radix-test-button", `${context.framework === "next" ? `"use client";\n\n` : ""}import { Toggle } from "radix-ui";
+
+export function RadixTestButton() {
+  return (
+    <Toggle.Root
+      onPressedChange={(pressed) => console.log("Radix Toggle pressed:", pressed)}
+    >
+      Radix UI test button
+    </Toggle.Root>
+  );
+}
+`)],
+			scripts: [],
+			postInstallNotes: [uiNote("RadixTestButton", "src/components/radix-test-button"), "Radix primitives are unstyled; add your own CSS or a styling layer."]
+		};
+	}
+};
+const baseUiRecipe = {
+	id: "base-ui",
+	recipeVersion: 1,
+	name: "Base UI",
+	category: "ui",
+	status: "stable",
+	installationSummary: "Official package installation + generated test button",
+	officialSource: {
+		documentationUrl: "https://base-ui.com/react/overview/quick-start",
+		lastVerifiedAt: "2026-07-19"
+	},
+	requires: [],
+	runsAfter: [],
+	conflictsWith: [],
+	supportedProjects: [{ frameworks: ["react", "next"] }],
+	installation: {
+		type: "official-package-install",
+		dependencies: [{
+			name: "@base-ui-components/react",
+			version: "latest",
+			dependencyType: "dependency",
+			reason: "Unstyled accessible React components."
+		}],
+		devDependencies: []
+	},
+	detectInstalled(context) {
+		return detectByPackages(context, ["@base-ui-components/react"]);
+	},
+	createPlan(context) {
+		return {
+			packages: [{
+				name: "@base-ui-components/react",
+				version: "latest",
+				dependencyType: "dependency",
+				reason: "Unstyled accessible React components."
+			}],
+			filesToCreate: [testButtonFile(context, "base-ui-test-button", `${context.framework === "next" ? `"use client";\n\n` : ""}import { Toggle } from "@base-ui-components/react/toggle";
+
+export function BaseUiTestButton() {
+  return (
+    <Toggle onPressedChange={(pressed) => console.log("Base UI Toggle pressed:", pressed)}>
+      Base UI test button
+    </Toggle>
+  );
+}
+`)],
+			scripts: [],
+			postInstallNotes: [uiNote("BaseUiTestButton", "src/components/base-ui-test-button"), "Base UI components are unstyled; style them with your own CSS."]
+		};
+	}
+};
+const reactAriaRecipe = {
+	id: "react-aria",
+	recipeVersion: 1,
+	name: "React Aria",
+	category: "ui",
+	status: "stable",
+	installationSummary: "Official package installation + generated test button",
+	officialSource: {
+		documentationUrl: "https://react-spectrum.adobe.com/react-aria/getting-started.html",
+		lastVerifiedAt: "2026-07-19"
+	},
+	requires: [],
+	runsAfter: [],
+	conflictsWith: [],
+	supportedProjects: [{ frameworks: ["react", "next"] }],
+	installation: {
+		type: "official-package-install",
+		dependencies: [{
+			name: "react-aria-components",
+			version: "latest",
+			dependencyType: "dependency",
+			reason: "Adobe's accessible component library."
+		}],
+		devDependencies: []
+	},
+	detectInstalled(context) {
+		return detectByPackages(context, ["react-aria-components"]);
+	},
+	createPlan(context) {
+		return {
+			packages: [{
+				name: "react-aria-components",
+				version: "latest",
+				dependencyType: "dependency",
+				reason: "Adobe's accessible component library."
+			}],
+			filesToCreate: [testButtonFile(context, "aria-test-button", `${context.framework === "next" ? `"use client";\n\n` : ""}import { Button } from "react-aria-components";
+
+export function AriaTestButton() {
+  return (
+    <Button onPress={() => console.log("React Aria button pressed")}>
+      React Aria test button
+    </Button>
+  );
+}
+`)],
+			scripts: [],
+			postInstallNotes: [uiNote("AriaTestButton", "src/components/aria-test-button")]
+		};
+	}
+};
+//#endregion
+//#region src/integrations/shadcn/recipe.ts
+/**
+* shadcn/ui is driven by its official CLI, not a package dependency. Adding
+* the Button component on a fresh project makes the CLI run its own init
+* questions first, then generates src/components/ui/button — so the user
+* gets a real component to test immediately.
+*
+* The CLI validates two prerequisites and aborts without them: Tailwind CSS
+* and a "@/*" import alias. Next.js projects created with Tailwind already
+* satisfy both. Vite projects satisfy neither, so this recipe prepares them
+* first, following the official shadcn Vite guide
+* (https://ui.shadcn.com/docs/installation/vite): install tailwindcss +
+* @tailwindcss/vite, import Tailwind in index.css, add the plugin and alias
+* to vite.config, and register the alias in tsconfig/jsconfig.
+*/
+const initializer = {
+	description: "The official shadcn CLI runs interactively: it initializes components.json (asking its own questions) and adds the Button component so you can test it right away.",
+	interactive: true,
+	buildCommand(packageManager, cwd) {
+		switch (packageManager) {
+			case "npm": return {
+				command: "npx",
+				args: [
+					"shadcn@latest",
+					"add",
+					"button"
+				],
+				cwd,
+				interactive: true
+			};
+			case "pnpm": return {
+				command: "pnpm",
+				args: [
+					"dlx",
+					"shadcn@latest",
+					"add",
+					"button"
+				],
+				cwd,
+				interactive: true
+			};
+			case "yarn": return {
+				command: "yarn",
+				args: [
+					"dlx",
+					"shadcn@latest",
+					"add",
+					"button"
+				],
+				cwd,
+				interactive: true
+			};
+			case "bun": return {
+				command: "bunx",
+				args: [
+					"--bun",
+					"shadcn@latest",
+					"add",
+					"button"
+				],
+				cwd,
+				interactive: true
+			};
+		}
+	}
+};
+const aliasPaths = { "@/*": ["./src/*"] };
+/**
+* Rebuilds vite.config with the Tailwind plugin and @/* alias while keeping
+* the plugin variant the official template used (plain React, React
+* Compiler via @rolldown/plugin-babel, or SWC).
+*/
+function viteConfigContents(existingConfig) {
+	const usesSwc = existingConfig.includes("@vitejs/plugin-react-swc");
+	const usesReactCompiler = existingConfig.includes("reactCompilerPreset") || existingConfig.includes("@rolldown/plugin-babel");
+	let reactImports = `import react from "@vitejs/plugin-react";`;
+	let plugins = "react(), tailwindcss()";
+	if (usesSwc) reactImports = `import react from "@vitejs/plugin-react-swc";`;
+	else if (usesReactCompiler) {
+		reactImports = `import react, { reactCompilerPreset } from "@vitejs/plugin-react";
+import babel from "@rolldown/plugin-babel";`;
+		plugins = "react(), babel({ presets: [reactCompilerPreset()] }), tailwindcss()";
+	}
+	return `import path from "path";
+import tailwindcss from "@tailwindcss/vite";
+${reactImports}
+import { defineConfig } from "vite";
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [${plugins}],
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"),
+    },
+  },
+});
+`;
+}
+function vitePreparation(context) {
+	const isTypescript = context.language === "typescript";
+	const packages = [{
+		name: "tailwindcss",
+		version: "latest",
+		dependencyType: "dependency",
+		reason: "Required by shadcn/ui."
+	}, {
+		name: "@tailwindcss/vite",
+		version: "latest",
+		dependencyType: "dependency",
+		reason: "Official Tailwind CSS plugin for Vite."
+	}];
+	if (isTypescript && !("@types/node" in context.installedPackages)) packages.push({
+		name: "@types/node",
+		version: "latest",
+		dependencyType: "devDependency",
+		reason: "Types for path.resolve in vite.config (per the shadcn guide)."
+	});
+	const configFileName = isTypescript ? "vite.config.ts" : "vite.config.js";
+	let existingConfig = "";
+	try {
+		existingConfig = fs$1.readFileSync(path.join(context.rootDirectory, configFileName), "utf8");
+	} catch {}
+	const filesToCreate = [{
+		path: "src/index.css",
+		contents: `@import "tailwindcss";\n`,
+		description: "Tailwind CSS entry (replaces the Vite template styles, per the shadcn guide).",
+		requiredReason: "shadcn/ui fails without the Tailwind CSS import in this file"
+	}, {
+		path: configFileName,
+		contents: viteConfigContents(existingConfig),
+		description: "Vite config with the Tailwind plugin and the @/* alias, per the shadcn guide.",
+		requiredReason: "shadcn/ui needs the Tailwind plugin and @/* alias configured here"
+	}];
+	const jsonEdits = [];
+	if (isTypescript) {
+		jsonEdits.push({
+			path: "tsconfig.json",
+			description: "Registers the @/* import alias for the shadcn CLI.",
+			edits: [{
+				jsonPath: ["compilerOptions", "paths"],
+				value: aliasPaths
+			}]
+		});
+		if (fs$1.existsSync(path.join(context.rootDirectory, "tsconfig.app.json"))) jsonEdits.push({
+			path: "tsconfig.app.json",
+			description: "Registers the @/* import alias for the app build.",
+			edits: [{
+				jsonPath: ["compilerOptions", "paths"],
+				value: aliasPaths
+			}]
+		});
+	} else filesToCreate.push({
+		path: "jsconfig.json",
+		contents: `${JSON.stringify({ compilerOptions: { paths: aliasPaths } }, null, 2)}\n`,
+		description: "Registers the @/* import alias for the shadcn CLI."
+	});
+	return {
+		packages,
+		filesToCreate,
+		jsonEdits
+	};
+}
+const shadcnRecipe = {
+	id: "shadcn",
+	recipeVersion: 1,
+	name: "shadcn/ui",
+	category: "ui",
+	status: "stable",
+	installationSummary: "Official shadcn CLI (Vite projects get Tailwind + alias set up first)",
+	officialSource: {
+		documentationUrl: "https://ui.shadcn.com/docs/installation",
+		lastVerifiedAt: "2026-07-19"
+	},
+	requires: [],
+	runsAfter: [],
+	conflictsWith: [],
+	supportedProjects: [{ frameworks: ["react", "next"] }],
+	installation: {
+		type: "official-initializer",
+		initializer
+	},
+	detectInstalled(context) {
+		if (context.detectedFiles.includes("components.json")) return {
+			status: "installed",
+			details: "components.json exists."
+		};
+		return { status: "not-installed" };
+	},
+	createPlan(context) {
+		const needsVitePrep = context.buildTool === "vite";
+		const prep = needsVitePrep ? vitePreparation(context) : {
+			packages: [],
+			filesToCreate: [],
+			jsonEdits: []
+		};
+		return {
+			packages: prep.packages,
+			filesToCreate: prep.filesToCreate,
+			jsonEdits: prep.jsonEdits,
+			scripts: [],
+			postInstallNotes: [
+				...needsVitePrep ? ["Tailwind CSS and the @/* alias were configured following the official shadcn Vite guide."] : [],
+				"Render <Button> from @/components/ui/button in any page to test shadcn/ui.",
+				"Add more components anytime with: npx shadcn@latest add <component>."
+			],
+			initializer
+		};
+	}
+};
+//#endregion
+//#region src/integrations/registry.ts
+const allRecipes = [
+	reactRouterRecipe,
+	zustandRecipe,
+	reduxToolkitRecipe,
+	tanstackQueryRecipe,
+	reactHookFormZodRecipe,
+	...installOnlyRecipes,
+	shadcnRecipe,
+	radixRecipe,
+	baseUiRecipe,
+	reactAriaRecipe,
+	vitestReactRecipe,
+	playwrightRecipe
+];
+const seen = /* @__PURE__ */ new Set();
+for (const recipe of allRecipes) {
+	const result = recipeMetadataSchema.safeParse(recipe);
+	if (!result.success) throw new StackPackError(`Integration recipe "${recipe.id}" has invalid metadata.`, { hints: result.error.issues.slice(0, 3).map((i) => `${i.path.join(".")}: ${i.message}`) });
+	if (seen.has(recipe.id)) throw new StackPackError(`Duplicate integration recipe id "${recipe.id}".`);
+	seen.add(recipe.id);
+}
+function getRecipe(id) {
+	return allRecipes.find((recipe) => recipe.id === id);
+}
+//#endregion
+//#region src/dashboard/state.ts
+function createEmptySelection() {
+	return {
+		testing: [],
+		customPackages: [],
+		versionOverrides: {}
+	};
+}
+function selectedIntegrations(selection) {
+	return [
+		selection.routing,
+		selection.stateManagement,
+		selection.dataFetching,
+		selection.formsAndValidation,
+		selection.ui,
+		selection.orm,
+		...selection.testing
+	].filter((entry) => entry !== void 0);
+}
+function selectedIntegrationCount(selection) {
+	return selectedIntegrations(selection).length;
+}
+/** Recipe + options pairs for every selected integration, in selection order. */
+function selectedRecipes(selection) {
+	return selectedIntegrations(selection).flatMap((entry) => {
+		const recipe = getRecipe(entry.id);
+		return recipe ? [{
+			recipe,
+			options: entry.options
+		}] : [];
+	});
+}
+/** Package names visible in the version editor for the current selection. */
+function editablePackageNames(selection) {
+	const names = /* @__PURE__ */ new Set();
+	for (const { recipe, options } of selectedRecipes(selection)) for (const pkg of recipe.createPlan(fakeContextForPackageListing(), options).packages) names.add(pkg.name);
+	for (const custom of selection.customPackages) names.add(custom.name);
+	return [...names].sort();
+}
+/**
+* The version editor only needs package names, which do not depend on the
+* project; a minimal context keeps createPlan callable without a real project.
+*/
+function fakeContextForPackageListing() {
+	return {
+		rootDirectory: ".",
+		framework: "react",
+		buildTool: "vite",
+		language: "typescript",
+		packageManager: "npm",
+		packageManagerCandidates: [],
+		detection: "detected",
+		packageJson: {},
+		detectedFiles: [],
+		installedPackages: {}
+	};
+}
+//#endregion
+//#region src/integrations/types.ts
+function isProjectSupported(recipe, context) {
+	if (recipe.supportedProjects.length === 0) return true;
+	return recipe.supportedProjects.some((req) => {
+		const frameworkOk = !req.frameworks || req.frameworks.includes(context.framework);
+		const buildToolOk = !req.buildTools || req.buildTools.includes(context.buildTool);
+		return frameworkOk && buildToolOk;
+	});
+}
+//#endregion
+//#region src/engine/filter-integrations.ts
+/**
+* Evaluates every recipe against the detected project. Incompatible recipes
+* keep an explicit reason so a future info view can explain why they are
+* hidden.
+*/
+function filterIntegrations(context, recipes) {
+	return recipes.map((recipe) => {
+		if (recipe.id === "react-router" && context.framework === "next") return {
+			recipe,
+			compatibility: "incompatible",
+			reason: "React Router is unavailable because this project uses Next.js routing.",
+			detection: { status: "not-installed" }
+		};
+		if (recipe.id === "shadcn" && context.framework === "next" && !("tailwindcss" in context.installedPackages)) return {
+			recipe,
+			compatibility: "incompatible",
+			reason: "shadcn/ui needs Tailwind CSS. Create the Next.js project with Tailwind (the recommended defaults include it) or add Tailwind first.",
+			detection: { status: "not-installed" }
+		};
+		if (!isProjectSupported(recipe, context)) return {
+			recipe,
+			compatibility: "incompatible",
+			reason: `${recipe.name} does not support this project type.`,
+			detection: { status: "not-installed" }
+		};
+		const detection = recipe.detectInstalled(context);
+		if (detection.status === "installed" || detection.status === "fully-configured") return {
+			recipe,
+			compatibility: "already-installed",
+			reason: `${recipe.name} is already installed${detection.installedVersion ? ` at version ${detection.installedVersion}` : ""}.`,
+			detection
+		};
+		if (detection.status === "partially-configured") return {
+			recipe,
+			compatibility: "partially-configured",
+			reason: detection.details,
+			detection
+		};
+		return {
+			recipe,
+			compatibility: "compatible",
+			detection
+		};
+	});
+}
+//#endregion
+//#region src/dashboard/category-shared.ts
+function describeInstallation(recipe) {
+	const lines = [`Installation method\n  ${recipe.installationSummary}`];
+	if (recipe.installation.type === "official-package-install") {
+		const all = [...recipe.installation.dependencies, ...recipe.installation.devDependencies];
+		if (all.length > 0) lines.push(`Packages\n${all.map((pkg) => `  ${pkg.name}@${pc.green(pkg.version)}${pkg.reason ? ` — ${pkg.reason}` : ""}`).join("\n")}`);
+	} else lines.push(recipe.installation.initializer.description);
+	return lines.join("\n\n");
+}
+/**
+* Shared single-select category screen: pick one integration, None to remove,
+* or return without changes. Selecting an already-installed integration offers
+* keep/complete choices instead of pretending it is new.
+*/
+async function runSingleSelectCategory(params) {
+	const visible = params.availabilities.filter((a) => a.compatibility !== "incompatible");
+	if (visible.length === 0) {
+		p.log.warn("No compatible integrations are available in this category.");
+		return { kind: "unchanged" };
+	}
+	const choice = orBack(await p.select({
+		message: params.prompt,
+		initialValue: params.current?.id ?? visible[0]?.recipe.id,
+		options: [
+			...visible.map((availability) => {
+				const isCurrent = params.current?.id === availability.recipe.id;
+				const hint = availability.compatibility === "already-installed" ? `already installed${availability.detection.installedVersion ? ` at ${availability.detection.installedVersion}` : ""}` : availability.compatibility === "partially-configured" ? "installed but not fully configured" : availability.recipe.installationSummary;
+				return {
+					value: availability.recipe.id,
+					label: isCurrent ? `${availability.recipe.name} ${pc.green("✓")}` : availability.recipe.name,
+					hint: isCurrent ? pc.green("currently selected") : hint
+				};
+			}),
+			{
+				value: "__none__",
+				label: "None",
+				hint: "Remove the current selection"
+			},
+			{
+				value: "__return__",
+				label: "Return without changes"
+			}
+		]
+	}));
+	if (choice === null || choice === "__return__") return { kind: "unchanged" };
+	if (choice === "__none__") return { kind: "removed" };
+	const availability = visible.find((a) => a.recipe.id === choice);
+	if (!availability) return { kind: "unchanged" };
+	const recipe = availability.recipe;
+	if (availability.compatibility === "already-installed") {
+		const action = orBack(await p.select({
+			message: `${recipe.name} is already installed. What would you like to do?`,
+			options: [
+				{
+					value: "keep",
+					label: "Keep current setup",
+					hint: "No changes planned"
+				},
+				{
+					value: "reinstall",
+					label: "Update or complete configuration",
+					hint: "Plan it again with official packages and files"
+				},
+				{
+					value: "remove",
+					label: "Remove from current selection"
+				}
+			]
+		}));
+		if (action === null || action === "keep") return { kind: "unchanged" };
+		if (action === "remove") return { kind: "removed" };
+	}
+	p.note(describeInstallation(recipe), recipe.name);
+	const options = params.collectOptions ? await params.collectOptions(recipe, params.current?.id === recipe.id ? params.current.options : {}) : {};
+	if (options === null) return { kind: "unchanged" };
+	p.log.success(`${recipe.name} selected`);
+	return {
+		kind: "selected",
+		selection: {
+			id: recipe.id,
+			options
+		}
+	};
+}
+//#endregion
+//#region src/dashboard/categories.ts
+function applyResult(result, set) {
+	if (result.kind === "selected") set(result.selection);
+	if (result.kind === "removed") set(void 0);
+}
+async function runRoutingCategory(selection, availabilities) {
+	applyResult(await runSingleSelectCategory({
+		title: "Routing",
+		prompt: "Choose a routing integration",
+		availabilities: availabilities.filter((a) => a.recipe.category === "routing"),
+		current: selection.routing
+	}), (value) => {
+		selection.routing = value;
+	});
+}
+async function runStateManagementCategory(selection, availabilities) {
+	applyResult(await runSingleSelectCategory({
+		title: "State Management",
+		prompt: "Choose a state-management integration",
+		availabilities: availabilities.filter((a) => a.recipe.category === "state-management"),
+		current: selection.stateManagement,
+		collectOptions: async (recipe, currentOptions) => {
+			if (recipe.id !== "redux-toolkit") return {};
+			const generateStore = orBack(await p.select({
+				message: "Generate basic store files?",
+				initialValue: currentOptions.generateStore === true ? "yes" : "no",
+				options: [{
+					value: "no",
+					label: "No, install only"
+				}, {
+					value: "yes",
+					label: "Yes",
+					hint: "src/store files following the official quick start"
+				}]
+			}));
+			if (generateStore === null) return null;
+			return { generateStore: generateStore === "yes" };
+		}
+	}), (value) => {
+		selection.stateManagement = value;
+	});
+}
+async function runDataFetchingCategory(selection, availabilities) {
+	applyResult(await runSingleSelectCategory({
+		title: "Data Fetching and API",
+		prompt: "Choose an integration",
+		availabilities: availabilities.filter((a) => a.recipe.category === "data-fetching"),
+		current: selection.dataFetching,
+		collectOptions: async (recipe, currentOptions) => {
+			if (recipe.id !== "tanstack-query") return {};
+			const devtools = orBack(await p.confirm({
+				message: "Include TanStack Query Devtools?",
+				initialValue: currentOptions.devtools !== false
+			}));
+			if (devtools === null) return null;
+			const provider = orBack(await p.select({
+				message: "Generate QueryClient and provider files?",
+				initialValue: currentOptions.configureProvider === false ? "install-only" : "files",
+				options: [{
+					value: "files",
+					label: "Yes, generate provider files",
+					hint: "src/lib/query-client and src/lib/query-provider; your entry file is never rewritten"
+				}, {
+					value: "install-only",
+					label: "Install packages only"
+				}]
+			}));
+			if (provider === null) return null;
+			return {
+				devtools,
+				configureProvider: provider === "files"
+			};
+		}
+	}), (value) => {
+		selection.dataFetching = value;
+	});
+}
+async function runUiCategory(selection, availabilities) {
+	applyResult(await runSingleSelectCategory({
+		title: "UI Components",
+		prompt: "Choose a UI library",
+		availabilities: availabilities.filter((a) => a.recipe.category === "ui"),
+		current: selection.ui
+	}), (value) => {
+		selection.ui = value;
+	});
+}
+async function runOrmCategory(selection, availabilities) {
+	applyResult(await runSingleSelectCategory({
+		title: "Database / ORM",
+		prompt: "Choose an ORM (dependencies only; you write the setup files)",
+		availabilities: availabilities.filter((a) => a.recipe.category === "orm"),
+		current: selection.orm
+	}), (value) => {
+		selection.orm = value;
+	});
+}
+async function runFormsValidationCategory(selection, availabilities) {
+	applyResult(await runSingleSelectCategory({
+		title: "Forms and Validation",
+		prompt: "Choose an integration",
+		availabilities: availabilities.filter((a) => a.recipe.category === "forms-validation"),
+		current: selection.formsAndValidation
+	}), (value) => {
+		selection.formsAndValidation = value;
+	});
+}
+async function runTestingCategory(selection, availabilities) {
+	const testing = availabilities.filter((a) => a.recipe.category === "testing" && a.compatibility !== "incompatible");
+	if (testing.length === 0) {
+		p.log.warn("No compatible testing integrations are available for this project.");
+		return;
+	}
+	const hintFor = (availability) => availability.compatibility === "already-installed" ? `already installed${availability.detection.installedVersion ? ` at ${availability.detection.installedVersion}` : ""}` : availability.recipe.installationSummary;
+	const currentIds = selection.testing.map((entry) => entry.id);
+	const choice = orBack(await p.select({
+		message: "Choose testing tools",
+		initialValue: currentIds.length > 1 ? "__all__" : currentIds[0] ?? testing[0]?.recipe.id,
+		options: [
+			...testing.map((availability) => ({
+				value: availability.recipe.id,
+				label: currentIds.length === 1 && currentIds[0] === availability.recipe.id ? `${availability.recipe.name} ${pc.green("✓")}` : availability.recipe.name,
+				hint: hintFor(availability)
+			})),
+			...testing.length > 1 ? [{
+				value: "__all__",
+				label: testing.map((availability) => availability.recipe.name).join(" + ") + (currentIds.length > 1 ? ` ${pc.green("✓")}` : ""),
+				hint: "install all testing tools"
+			}] : [],
+			{
+				value: "__none__",
+				label: "None",
+				hint: "remove testing selections"
+			},
+			{
+				value: "__return__",
+				label: "Return without changes"
+			}
+		]
+	}));
+	if (choice === null || choice === "__return__") return;
+	if (choice === "__none__") {
+		selection.testing = [];
+		return;
+	}
+	const chosen = choice === "__all__" ? testing.map((availability) => availability.recipe.id) : [choice];
+	const next = [];
+	for (const id of chosen) {
+		const previous = selection.testing.find((entry) => entry.id === id);
+		if (id === "vitest-react") {
+			const target = orBack(await p.select({
+				message: "What will you test?",
+				initialValue: previous?.options.testTarget === "utils" ? "utils" : "components",
+				options: [{
+					value: "components",
+					label: "React components",
+					hint: "Vitest + jsdom + React Testing Library + matchers + user-event"
+				}, {
+					value: "utils",
+					label: "Utility functions only",
+					hint: "Vitest only"
+				}]
+			}));
+			if (target === null) return;
+			next.push({
+				id,
+				options: { testTarget: target }
+			});
+		} else if (id === "playwright") {
+			p.note("The official Playwright initializer will run interactively during installation.\nIt may ask its own questions, install browsers, and create config, tests, and CI files.", "Playwright");
+			next.push({
+				id,
+				options: previous?.options ?? {}
+			});
+		} else next.push({
+			id,
+			options: previous?.options ?? {}
+		});
+	}
+	selection.testing = next;
+}
+//#endregion
+//#region src/utils/versions.ts
+const TAG_PATTERN = /^[a-zA-Z][a-zA-Z0-9._-]*$/;
+/**
+* Parses an npm version input: an exact version ("18.3.1"), a range
+* ("18", "^18.3.1", "~18.3.1"), or a distribution tag ("latest", "beta").
+* Returns null when the input is not a valid version, range, or tag.
+*/
+function parseVersionSpec(input) {
+	const raw = input.trim();
+	if (raw.length === 0) return null;
+	if (/\s/.test(raw)) return null;
+	if (semver.validRange(raw, { loose: true }) !== null) return {
+		kind: "range",
+		raw
+	};
+	if (TAG_PATTERN.test(raw)) return {
+		kind: "tag",
+		raw
+	};
+	return null;
+}
+/**
+* Whether two version specs can be satisfied together. Tags only match the
+* exact same tag; ranges use semver intersection.
+*/
+function versionSpecsCompatible(a, b) {
+	if (a === b) return true;
+	const specA = parseVersionSpec(a);
+	const specB = parseVersionSpec(b);
+	if (specA === null || specB === null) return false;
+	if (specA.kind === "tag" || specB.kind === "tag") return false;
+	try {
+		return semver.intersects(specA.raw, specB.raw, { loose: true });
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/utils/package-specifier.ts
+/**
+* Parses user input such as "axios", "axios@1", "@scope/pkg", or
+* "@scope/pkg@2.1.0". A missing version defaults to "latest".
+*/
+function parsePackageSpecifier(input) {
+	const raw = input.trim();
+	if (raw.length === 0) return {
+		ok: false,
+		reason: "Enter a package name."
+	};
+	if (/\s/.test(raw)) return {
+		ok: false,
+		reason: "Package names cannot contain spaces."
+	};
+	if (raw.includes("\\") || raw.includes("..") || raw.startsWith(".") || raw.startsWith("/")) return {
+		ok: false,
+		reason: "Package names cannot look like filesystem paths."
+	};
+	let name = raw;
+	let version = "latest";
+	const atIndex = raw.startsWith("@") ? raw.indexOf("@", 1) : raw.indexOf("@");
+	if (atIndex > 0) {
+		name = raw.slice(0, atIndex);
+		version = raw.slice(atIndex + 1);
+		if (version.length === 0) return {
+			ok: false,
+			reason: "A version after \"@\" cannot be empty."
+		};
+	}
+	const nameResult = validatePackageName(name);
+	if (!nameResult.validForNewPackages) {
+		const problem = nameResult.errors?.[0] ?? nameResult.warnings?.[0] ?? "invalid package name";
+		return {
+			ok: false,
+			reason: `"${name}" is not a valid npm package name (${problem}).`
+		};
+	}
+	if (parseVersionSpec(version) === null) return {
+		ok: false,
+		reason: `"${version}" is not a valid npm version, range, or tag.`
+	};
+	return {
+		ok: true,
+		value: {
+			name,
+			version
+		}
+	};
+}
+function formatPackageSpecifier(pkg) {
+	return `${pkg.name}@${pkg.version}`;
+}
+//#endregion
+//#region src/storage/paths.ts
+/**
+* Global StackPack storage under the user's home directory.
+* STACKPACK_HOME overrides the base directory (used by tests).
+*/
+function getStoragePaths(baseDir) {
+	const home = baseDir ?? process.env.STACKPACK_HOME ?? path.join(os.homedir(), ".stackpack");
+	return {
+		home,
+		presetsDir: path.join(home, "presets"),
+		backupsDir: path.join(home, "backups"),
+		cacheDir: path.join(home, "cache"),
+		configFile: path.join(home, "config.json")
+	};
+}
+/** Project-local StackPack directory (may be committed to Git). */
+function getProjectLocalDir(projectRoot) {
+	return path.join(projectRoot, ".stackpack");
+}
+function getProjectLocalPresetsDir(projectRoot) {
+	return getProjectLocalDir(projectRoot);
+}
+function getProjectBackupsDir(projectRoot) {
+	return path.join(getProjectLocalDir(projectRoot), "backups");
+}
+//#endregion
+//#region src/storage/config-store.ts
+const savedCustomPackageSchema = z.object({
+	name: z.string(),
+	version: z.string(),
+	dependencyType: z.enum(["dependency", "devDependency"])
+});
+const configSchema = z.object({
+	defaultPackageManager: packageManagerSchema.optional(),
+	/** Custom packages the user added before, offered again in future setups. */
+	savedCustomPackages: z.array(savedCustomPackageSchema).optional()
+});
+async function loadConfig(globalBaseDir) {
+	const { configFile } = getStoragePaths(globalBaseDir);
+	try {
+		const raw = await fs.readFile(configFile, "utf8");
+		const parsed = configSchema.safeParse(JSON.parse(raw));
+		return parsed.success ? parsed.data : {};
+	} catch {
+		return {};
+	}
+}
+/** Adds or updates packages in the saved custom-package library. */
+async function rememberCustomPackages(packages, globalBaseDir) {
+	const config = await loadConfig(globalBaseDir);
+	const saved = [...config.savedCustomPackages ?? []];
+	for (const pkg of packages) {
+		const index = saved.findIndex((entry) => entry.name === pkg.name);
+		if (index >= 0) saved[index] = pkg;
+		else saved.push(pkg);
+	}
+	saved.sort((a, b) => a.name.localeCompare(b.name));
+	await saveConfig({
+		...config,
+		savedCustomPackages: saved
+	}, globalBaseDir);
+}
+/** Removes a package from the saved library (projects are not touched). */
+async function forgetCustomPackage(name, globalBaseDir) {
+	const config = await loadConfig(globalBaseDir);
+	await saveConfig({
+		...config,
+		savedCustomPackages: (config.savedCustomPackages ?? []).filter((entry) => entry.name !== name)
+	}, globalBaseDir);
+}
+async function saveConfig(config, globalBaseDir) {
+	const { configFile } = getStoragePaths(globalBaseDir);
+	await fs.mkdir(path.dirname(configFile), { recursive: true });
+	await fs.writeFile(configFile, JSON.stringify(configSchema.parse(config), null, 2) + "\n", "utf8");
+}
+//#endregion
+//#region src/dashboard/custom-packages.ts
+async function runCustomPackagesCategory(selection) {
+	for (;;) {
+		const saved = (await loadConfig()).savedCustomPackages ?? [];
+		const savedSelectable = saved.filter((entry) => !selection.customPackages.some((pkg) => pkg.name === entry.name));
+		const action = orBack(await p.select({
+			message: `Custom packages (${selection.customPackages.length} added)`,
+			options: [
+				{
+					value: "add",
+					label: "Add an npm package",
+					hint: "typed packages are saved for future setups"
+				},
+				...savedSelectable.length > 0 ? [{
+					value: "saved",
+					label: "Add from saved packages",
+					hint: `${savedSelectable.length} saved earlier`
+				}] : [],
+				...selection.customPackages.length > 0 ? [{
+					value: "remove",
+					label: "Remove a package from this setup"
+				}] : [],
+				...saved.length > 0 ? [{
+					value: "manage",
+					label: "Delete saved packages"
+				}] : [],
+				{
+					value: "return",
+					label: "Return to integrations"
+				}
+			]
+		}));
+		if (action === null || action === "return") return;
+		if (action === "saved") {
+			const chosen = orBack(await p.multiselect({
+				message: "Select saved packages to add (space to toggle, enter to confirm)",
+				required: false,
+				options: savedSelectable.map((entry) => ({
+					value: entry.name,
+					label: formatPackageSpecifier(entry),
+					hint: entry.dependencyType
+				}))
+			}));
+			if (chosen === null) continue;
+			for (const name of chosen) {
+				const entry = savedSelectable.find((pkg) => pkg.name === name);
+				if (entry) {
+					selection.customPackages.push({ ...entry });
+					p.log.success(`Added ${formatPackageSpecifier(entry)}`);
+				}
+			}
+			continue;
+		}
+		if (action === "manage") {
+			const chosen = orBack(await p.multiselect({
+				message: "Delete which saved packages? (no project is changed)",
+				required: false,
+				options: saved.map((entry) => ({
+					value: entry.name,
+					label: formatPackageSpecifier(entry),
+					hint: entry.dependencyType
+				}))
+			}));
+			if (chosen === null) continue;
+			for (const name of chosen) await forgetCustomPackage(name);
+			if (chosen.length > 0) p.log.success(`Deleted ${chosen.length} saved package(s).`);
+			continue;
+		}
+		if (action === "remove") {
+			const name = orBack(await p.select({
+				message: "Remove which package?",
+				options: selection.customPackages.map((pkg) => ({
+					value: pkg.name,
+					label: formatPackageSpecifier(pkg),
+					hint: pkg.dependencyType
+				}))
+			}));
+			if (name === null) continue;
+			selection.customPackages = selection.customPackages.filter((pkg) => pkg.name !== name);
+			continue;
+		}
+		const input = orBack(await p.text({
+			message: "Enter an npm package (name or name@version, Esc to go back)",
+			placeholder: "sonner@latest",
+			validate(value) {
+				const result = parsePackageSpecifier(value ?? "");
+				return result.ok ? void 0 : result.reason;
+			}
+		}));
+		if (input === null) continue;
+		const parsed = parsePackageSpecifier(input);
+		if (!parsed.ok) continue;
+		if (selection.customPackages.some((pkg) => pkg.name === parsed.value.name)) {
+			p.log.warn(`${parsed.value.name} is already in the custom package list.`);
+			continue;
+		}
+		const dependencyType = orBack(await p.select({
+			message: "Add package as",
+			options: [{
+				value: "dependency",
+				label: "dependency"
+			}, {
+				value: "devDependency",
+				label: "devDependency"
+			}]
+		}));
+		if (dependencyType === null) continue;
+		p.note("StackPack does not have a verified automatic recipe for this package.\nIt will be installed only. No configuration files will be generated.", formatPackageSpecifier(parsed.value));
+		const entry = {
+			...parsed.value,
+			dependencyType
+		};
+		selection.customPackages.push(entry);
+		await rememberCustomPackages([entry]);
+		p.log.success(`Added ${formatPackageSpecifier(parsed.value)} — saved for future setups too.`);
+	}
+}
+//#endregion
+//#region src/dashboard/version-editor.ts
+async function runVersionEditor(selection) {
+	for (;;) {
+		const names = editablePackageNames(selection);
+		if (names.length === 0) {
+			p.log.warn("Select integrations or custom packages first, then edit their versions.");
+			return;
+		}
+		const choice = orBack(await p.select({
+			message: "Choose a package to set a version for",
+			options: [...names.map((name) => ({
+				value: name,
+				label: name,
+				hint: selection.versionOverrides[name] ?? "latest"
+			})), {
+				value: "__return__",
+				label: "Return"
+			}]
+		}));
+		if (choice === null || choice === "__return__") return;
+		const input = orBack(await p.text({
+			message: `Enter an npm version, range, or tag for ${choice} (Esc to go back)`,
+			placeholder: "latest",
+			initialValue: selection.versionOverrides[choice] ?? "",
+			validate(value) {
+				if (!value || value.trim().length === 0) return void 0;
+				return parseVersionSpec(value) === null ? "Enter a valid npm version, range, or tag (e.g. 5, ^5.1.0, latest)." : void 0;
+			}
+		}));
+		if (input === null) continue;
+		const trimmed = input.trim();
+		const customPackage = selection.customPackages.find((pkg) => pkg.name === choice);
+		if (trimmed.length === 0 || trimmed === "latest") {
+			delete selection.versionOverrides[choice];
+			if (customPackage) customPackage.version = "latest";
+			p.log.success(`${choice} set to latest`);
+		} else {
+			selection.versionOverrides[choice] = trimmed;
+			if (customPackage) customPackage.version = trimmed;
+			p.log.success(`${choice} set to version ${trimmed}`);
+		}
+	}
+}
+//#endregion
+//#region src/dashboard/main-dashboard.ts
+function selectionLabel(entry) {
+	if (!entry) return void 0;
+	const recipe = getRecipe(entry.id);
+	if (!recipe) return entry.id;
+	const detail = recipe.describeOptions?.(entry.options);
+	return detail ? `${recipe.name} (${detail})` : recipe.name;
+}
+function testingLabel(selection) {
+	if (selection.testing.length === 0) return void 0;
+	return selection.testing.map((entry) => getRecipe(entry.id)?.name ?? entry.id).join(" + ");
+}
+/** Category rows turn green with a check once something is selected. */
+function categoryOption(value, label, selected) {
+	return selected ? {
+		value,
+		label: `${label} ${pc.green("✓")}`,
+		hint: pc.green(selected)
+	} : {
+		value,
+		label,
+		hint: "Not selected"
+	};
+}
+function categoryHasVisibleRecipes(availabilities, category) {
+	return availabilities.some((a) => a.recipe.category === category && a.compatibility !== "incompatible");
+}
+/**
+* The jumpable category dashboard. Selections persist in memory while the
+* user moves between categories; nothing is installed here.
+*/
+async function runDashboard(context, selection) {
+	for (;;) {
+		const availabilities = filterIntegrations(context, allRecipes);
+		const count = selectedIntegrationCount(selection);
+		const customCount = selection.customPackages.length;
+		const overrideCount = Object.keys(selection.versionOverrides).length;
+		p.log.info(`Selected integrations: ${count}   Additional packages: ${customCount}${overrideCount > 0 ? `   Version overrides: ${overrideCount}` : ""}`);
+		const options = [];
+		if (categoryHasVisibleRecipes(availabilities, "routing")) options.push(categoryOption("routing", "Routing", selectionLabel(selection.routing)));
+		options.push(categoryOption("state-management", "State Management", selectionLabel(selection.stateManagement)), categoryOption("data-fetching", "Data Fetching and API", selectionLabel(selection.dataFetching)), categoryOption("forms-validation", "Forms and Validation", selectionLabel(selection.formsAndValidation)), categoryOption("ui", "UI Components", selectionLabel(selection.ui)), categoryOption("orm", "Database / ORM", selectionLabel(selection.orm)), categoryOption("testing", "Testing", testingLabel(selection)), categoryOption("custom-packages", "Custom Packages", customCount > 0 ? `${customCount} package${customCount === 1 ? "" : "s"}` : void 0), {
+			value: "versions",
+			label: "Edit Package Versions"
+		}, {
+			value: "review",
+			label: "Review and Install"
+		});
+		switch (guard(await p.select({
+			message: "Choose a category",
+			options
+		}))) {
+			case "routing":
+				await runRoutingCategory(selection, availabilities);
+				break;
+			case "state-management":
+				await runStateManagementCategory(selection, availabilities);
+				break;
+			case "data-fetching":
+				await runDataFetchingCategory(selection, availabilities);
+				break;
+			case "forms-validation":
+				await runFormsValidationCategory(selection, availabilities);
+				break;
+			case "ui":
+				await runUiCategory(selection, availabilities);
+				break;
+			case "orm":
+				await runOrmCategory(selection, availabilities);
+				break;
+			case "testing":
+				await runTestingCategory(selection, availabilities);
+				break;
+			case "custom-packages":
+				await runCustomPackagesCategory(selection);
+				break;
+			case "versions":
+				await runVersionEditor(selection);
+				break;
+			case "review": return "review";
+		}
+	}
+}
+//#endregion
+//#region src/engine/resolve-order.ts
+/**
+* Produces a valid execution order for the selected recipes.
+* - `requires` must be present in the selection and orders before.
+* - `runsAfter` orders before only when the other recipe is selected.
+* - `conflictsWith` aborts when both are selected.
+* Detects circular dependencies before anything runs.
+*/
+function resolveExecutionOrder(selected) {
+	const ids = new Set(selected.map((r) => r.id));
+	for (const recipe of selected) {
+		for (const required of recipe.requires) if (!ids.has(required)) throw new StackPackError(`Integration "${recipe.id}" requires "${required}", which is not selected.`);
+		for (const conflict of recipe.conflictsWith) if (ids.has(conflict)) throw new StackPackError(`Integrations "${recipe.id}" and "${conflict}" cannot be installed together.`);
+	}
+	const indegree = new Map(selected.map((r) => [r.id, 0]));
+	const edges = /* @__PURE__ */ new Map();
+	for (const recipe of selected) {
+		const before = [...recipe.requires, ...recipe.runsAfter.filter((id) => ids.has(id))];
+		for (const prerequisite of before) {
+			edges.set(prerequisite, [...edges.get(prerequisite) ?? [], recipe.id]);
+			indegree.set(recipe.id, (indegree.get(recipe.id) ?? 0) + 1);
+		}
+	}
+	const queue = selected.filter((r) => (indegree.get(r.id) ?? 0) === 0).map((r) => r.id);
+	const orderedIds = [];
+	while (queue.length > 0) {
+		const id = queue.shift();
+		orderedIds.push(id);
+		for (const dependent of edges.get(id) ?? []) {
+			const remaining = (indegree.get(dependent) ?? 0) - 1;
+			indegree.set(dependent, remaining);
+			if (remaining === 0) queue.push(dependent);
+		}
+	}
+	if (orderedIds.length !== selected.length) throw new StackPackError(`Invalid recipe graph: circular dependency involving ${selected.map((r) => r.id).filter((id) => !orderedIds.includes(id)).join(", ")}.`);
+	const byId = new Map(selected.map((r) => [r.id, r]));
+	return orderedIds.map((id) => byId.get(id));
+}
+//#endregion
+//#region src/engine/resolve-dependencies.ts
+/**
+* Merges every package requirement (recipes + custom packages), applies user
+* version overrides, and detects conflicts instead of silently choosing.
+*/
+function resolveDependencies(input) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const requirement of input.requirements) {
+		const list = byName.get(requirement.name) ?? [];
+		list.push(requirement);
+		byName.set(requirement.name, list);
+	}
+	const packages = [];
+	const conflicts = [];
+	const warnings = [];
+	for (const [name, requests] of byName) {
+		const requestedBy = [...new Set(requests.map((r) => r.requestedBy))];
+		const requestedVersions = [...new Set(requests.map((r) => r.version))];
+		const dependencyTypes = new Set(requests.map((r) => r.dependencyType));
+		let dependencyType = requests[0]?.dependencyType ?? "dependency";
+		if (dependencyTypes.size > 1) {
+			dependencyType = "dependency";
+			warnings.push(`${name} was requested as both a dependency and a devDependency; installing as a dependency.`);
+		}
+		const override = input.versionOverrides[name];
+		let resolvedVersion;
+		if (override !== void 0) {
+			resolvedVersion = override;
+			if (!requestedBy.includes("version override")) requestedBy.push("version override");
+		} else if (requestedVersions.length === 1) resolvedVersion = requestedVersions[0] ?? "latest";
+		else {
+			const specific = requestedVersions.filter((v) => v !== "latest");
+			if (specific.length === 1) {
+				resolvedVersion = specific[0] ?? "latest";
+				warnings.push(`${name} was requested as "latest" and "${resolvedVersion}"; using "${resolvedVersion}".`);
+			} else if (specific.every((v, _, all) => all.every((other) => versionSpecsCompatible(v, other)))) {
+				conflicts.push({
+					name,
+					versions: requestedVersions,
+					requestedBy,
+					message: `${name} has overlapping but different version requests (${requestedVersions.join(", ")}). Set an explicit version override to resolve.`
+				});
+				continue;
+			} else {
+				conflicts.push({
+					name,
+					versions: requestedVersions,
+					requestedBy,
+					message: `${name} has incompatible version requests (${requestedVersions.join(", ")}) from ${requestedBy.join(", ")}. Set an explicit version override to resolve.`
+				});
+				continue;
+			}
+		}
+		const installed = input.installedPackages[name];
+		if (installed !== void 0) warnings.push(`${name} is already installed (${installed}); it will be updated to ${resolvedVersion}.`);
+		packages.push({
+			name,
+			requestedVersions,
+			resolvedVersion,
+			dependencyType,
+			requestedBy
+		});
+	}
+	packages.sort((a, b) => a.name.localeCompare(b.name));
+	return {
+		packages,
+		conflicts,
+		warnings
+	};
+}
+//#endregion
+//#region src/project/conflicts.ts
+/**
+* Finds package.json scripts that already exist with a different command.
+* Scripts whose current value equals the proposal are not conflicts.
+*/
+function findScriptConflicts(existing, proposed) {
+	const conflicts = [];
+	for (const [name, command] of Object.entries(proposed)) {
+		const current = existing?.[name];
+		if (current !== void 0 && current !== command) conflicts.push({
+			name,
+			current,
+			proposed: command
+		});
+	}
+	return conflicts;
+}
+/** Which of the planned files already exist in the project. */
+function findExistingFiles(projectRoot, plannedFiles) {
+	return plannedFiles.filter((relative) => fs$1.existsSync(path.join(projectRoot, relative)));
+}
+//#endregion
+//#region src/engine/build-plan.ts
+/**
+* Builds the complete installation plan for review. Pure planning: nothing is
+* installed or written here.
+*/
+function buildInstallationPlan(context, selection) {
+	const chosen = selectedRecipes(selection);
+	const integrations = resolveExecutionOrder(chosen.map(({ recipe }) => recipe)).map((recipe) => chosen.find((c) => c.recipe.id === recipe.id)).map(({ recipe, options }) => ({
+		recipe,
+		options,
+		plan: recipe.createPlan(context, options)
+	}));
+	const requirements = [];
+	for (const { recipe, plan } of integrations) for (const pkg of plan.packages) requirements.push({
+		...pkg,
+		requestedBy: recipe.name
+	});
+	for (const custom of selection.customPackages) requirements.push({
+		name: custom.name,
+		version: custom.version,
+		dependencyType: custom.dependencyType,
+		requestedBy: "custom package"
+	});
+	const resolution = resolveDependencies({
+		requirements,
+		versionOverrides: selection.versionOverrides,
+		installedPackages: context.installedPackages
+	});
+	const filesToCreate = integrations.flatMap(({ plan }) => plan.filesToCreate);
+	const jsonEdits = integrations.flatMap(({ plan }) => plan.jsonEdits ?? []);
+	const scripts = integrations.flatMap(({ plan }) => plan.scripts);
+	const initializers = integrations.flatMap(({ recipe, plan }) => plan.initializer ? [{
+		id: recipe.id,
+		name: recipe.name,
+		initializer: plan.initializer
+	}] : []);
+	const filesToModify = [];
+	if (resolution.packages.length > 0 || scripts.length > 0) filesToModify.push("package.json");
+	filesToModify.push(...jsonEdits.map((edit) => edit.path));
+	const warnings = [...resolution.warnings];
+	if (initializers.length > 0) warnings.push("Official initializers may create additional files StackPack cannot predict.");
+	return {
+		context,
+		integrations,
+		dependencies: resolution.packages.filter((p) => p.dependencyType === "dependency"),
+		devDependencies: resolution.packages.filter((p) => p.dependencyType === "devDependency"),
+		conflicts: resolution.conflicts,
+		filesToCreate,
+		jsonEdits,
+		filesToModify,
+		scripts,
+		scriptConflicts: findScriptConflicts(context.packageJson.scripts, { ...Object.fromEntries(scripts.map((s) => [s.name, s.command])) }),
+		existingFileConflicts: findExistingFiles(context.rootDirectory, filesToCreate.map((f) => f.path)),
+		initializers,
+		warnings,
+		notes: integrations.flatMap(({ plan }) => plan.postInstallNotes)
+	};
+}
+//#endregion
+//#region src/package-manager/commands.ts
+function toSpecifiers(packages) {
+	return packages.map((pkg) => `${pkg.name}@${pkg.version}`);
+}
+/** Builds the plain "install everything in package.json" command. */
+function baseInstallCommand(packageManager, cwd) {
+	return {
+		command: packageManager,
+		args: ["install"],
+		cwd,
+		interactive: true
+	};
+}
+/** Builds the official install command for the detected package manager. */
+function packageInstallCommand(packageManager, packages, options) {
+	const specs = toSpecifiers(packages);
+	switch (packageManager) {
+		case "npm": return {
+			command: "npm",
+			args: [
+				"install",
+				options.dev ? "--save-dev" : "--save",
+				...specs
+			],
+			cwd: options.cwd
+		};
+		case "pnpm": return {
+			command: "pnpm",
+			args: [
+				"add",
+				...options.dev ? ["-D"] : [],
+				...specs
+			],
+			cwd: options.cwd
+		};
+		case "yarn": return {
+			command: "yarn",
+			args: [
+				"add",
+				...options.dev ? ["-D"] : [],
+				...specs
+			],
+			cwd: options.cwd
+		};
+		case "bun": return {
+			command: "bun",
+			args: [
+				"add",
+				...options.dev ? ["-d"] : [],
+				...specs
+			],
+			cwd: options.cwd
+		};
+	}
+}
+//#endregion
+//#region src/package-manager/types.ts
+function formatCommand(cmd) {
+	return [cmd.command, ...cmd.args].join(" ");
+}
+//#endregion
+//#region src/project/safe-paths.ts
+/** Whether target (absolute or relative) stays inside root after resolution. */
+function isInsideRoot(root, target) {
+	const resolvedRoot = path.resolve(root);
+	const resolvedTarget = path.resolve(resolvedRoot, target);
+	const relative = path.relative(resolvedRoot, resolvedTarget);
+	return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+/**
+* Resolves a relative path against a project root and guarantees the result
+* stays inside the root. Throws for traversal or absolute inputs.
+*/
+function resolveInsideRoot(root, relativePath) {
+	if (path.isAbsolute(relativePath)) throw new StackPackError(`Refusing absolute path "${relativePath}" inside the project.`);
+	if (!isInsideRoot(root, relativePath)) throw new StackPackError(`Refusing path "${relativePath}" because it escapes the project directory.`);
+	return path.resolve(path.resolve(root), relativePath);
+}
+//#endregion
+//#region src/project/backups.ts
+const NEVER_BACKED_UP = [
+	"node_modules",
+	"dist",
+	"build",
+	"coverage",
+	".git"
+];
+function isBackupExcluded(relativePath) {
+	const first = relativePath.replaceAll("\\", "/").split("/")[0] ?? "";
+	return NEVER_BACKED_UP.includes(first);
+}
+/**
+* Copies existing files (relative to the project root) into the operation's
+* backup directory, preserving relative structure. Missing files are skipped.
+* Returns the list of files that were actually backed up.
+*/
+async function backupFiles(projectRoot, backupFilesDir, relativeFiles) {
+	const backedUp = [];
+	for (const relative of relativeFiles) {
+		if (isBackupExcluded(relative)) continue;
+		const source = resolveInsideRoot(projectRoot, relative);
+		try {
+			await fs.access(source);
+		} catch {
+			continue;
+		}
+		const target = path.join(backupFilesDir, relative);
+		await fs.mkdir(path.dirname(target), { recursive: true });
+		await fs.copyFile(source, target);
+		backedUp.push(relative);
+	}
+	return backedUp;
+}
+/** Restores every backed-up file to its original location. Best effort. */
+async function restoreBackup(projectRoot, backupFilesDir) {
+	const restored = [];
+	const entries = await fs.readdir(backupFilesDir, {
+		recursive: true,
+		withFileTypes: true
+	});
+	for (const entry of entries) {
+		if (!entry.isFile()) continue;
+		const absolute = path.join(entry.parentPath ?? backupFilesDir, entry.name);
+		const relative = path.relative(backupFilesDir, absolute);
+		const target = resolveInsideRoot(projectRoot, relative);
+		await fs.mkdir(path.dirname(target), { recursive: true });
+		await fs.copyFile(absolute, target);
+		restored.push(relative.replaceAll("\\", "/"));
+	}
+	return restored;
+}
+//#endregion
+//#region src/schemas/operation.ts
+const operationSummarySchema = z.object({
+	operationId: z.string(),
+	startedAt: z.string(),
+	finishedAt: z.string().optional(),
+	integrations: z.array(z.string()),
+	filesBackedUp: z.array(z.string()),
+	commandsRun: z.array(z.string()),
+	status: z.enum([
+		"started",
+		"completed",
+		"failed",
+		"cancelled"
+	])
+});
+//#endregion
+//#region src/storage/operation-store.ts
+async function createOperation(projectRoot) {
+	const id = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${crypto.randomUUID().slice(0, 8)}`;
+	const dir = path.join(getProjectBackupsDir(projectRoot), id);
+	const filesDir = path.join(dir, "files");
+	await fs.mkdir(filesDir, { recursive: true });
+	return {
+		id,
+		dir,
+		filesDir
+	};
+}
+async function writeOperationSummary(operation, summary) {
+	const validated = operationSummarySchema.parse(summary);
+	await fs.writeFile(path.join(operation.dir, "operation.json"), JSON.stringify(validated, null, 2) + "\n", "utf8");
+}
+//#endregion
+//#region src/engine/apply-plan.ts
+function renameWithSuffix(filePath) {
+	const ext = path.extname(filePath);
+	return ext.length > 0 ? `${filePath.slice(0, -ext.length)}.stackpack${ext}` : `${filePath}.stackpack`;
+}
+async function runOrThrow(runner, cmd, what, commandsRun) {
+	commandsRun.push(formatCommand(cmd));
+	const result = await runner(cmd);
+	if (result.exitCode !== 0) {
+		const stderrTail = result.stderr.split("\n").slice(-15).join("\n").trim();
+		throw new StackPackError(`${what} failed with exit code ${result.exitCode}.`, { hints: [
+			`Command: ${formatCommand(cmd)}`,
+			...stderrTail.length > 0 ? [stderrTail] : [],
+			"The project may contain partial changes; a backup was created before installation."
+		] });
+	}
+}
+/**
+* Applies a reviewed installation plan using the safe execution flow:
+* backups -> official package installs -> StackPack file changes and JSON
+* edits -> official initializers -> rescan -> package.json script updates.
+* Files come before initializers because official CLIs (e.g. shadcn)
+* validate prerequisites like Tailwind config and import aliases.
+*/
+async function applyPlan(plan, options) {
+	if (plan.conflicts.length > 0) throw new StackPackError("Unresolved dependency conflicts block installation.", { hints: plan.conflicts.map((c) => c.message) });
+	const progress = options.onProgress ?? (() => {});
+	const root = plan.context.rootDirectory;
+	const pm = plan.context.packageManager;
+	const result = {
+		dryRun: options.dryRun,
+		commandsRun: [],
+		createdFiles: [],
+		skippedFiles: [],
+		modifiedFiles: [],
+		notes: [...plan.notes]
+	};
+	const dependencyInstall = plan.dependencies.length > 0 ? packageInstallCommand(pm, plan.dependencies.map((p) => ({
+		name: p.name,
+		version: p.resolvedVersion
+	})), {
+		dev: false,
+		cwd: root
+	}) : null;
+	const devDependencyInstall = plan.devDependencies.length > 0 ? packageInstallCommand(pm, plan.devDependencies.map((p) => ({
+		name: p.name,
+		version: p.resolvedVersion
+	})), {
+		dev: true,
+		cwd: root
+	}) : null;
+	if (options.dryRun) {
+		for (const cmd of [dependencyInstall, devDependencyInstall]) if (cmd) result.commandsRun.push(formatCommand(cmd));
+		for (const entry of plan.initializers) result.commandsRun.push(formatCommand(entry.initializer.buildCommand(pm, root)));
+		result.createdFiles = plan.filesToCreate.map((f) => f.path);
+		result.modifiedFiles = plan.filesToModify;
+		result.notes.push("Dry run: no commands were executed and no files were changed.");
+		return result;
+	}
+	const operation = await createOperation(root);
+	result.operationDir = operation.dir;
+	const filesBackedUp = await backupFiles(root, operation.filesDir, [
+		"package.json",
+		...plan.filesToModify,
+		...plan.existingFileConflicts
+	]);
+	const summaryBase = {
+		operationId: operation.id,
+		startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		integrations: plan.integrations.map((i) => i.recipe.id),
+		filesBackedUp,
+		commandsRun: result.commandsRun
+	};
+	await writeOperationSummary(operation, {
+		...summaryBase,
+		status: "started"
+	});
+	try {
+		if (dependencyInstall) {
+			progress(`Installing dependencies with ${pm}...`);
+			await runOrThrow(options.runner, dependencyInstall, "Package installation", result.commandsRun);
+		}
+		if (devDependencyInstall) {
+			progress(`Installing development dependencies with ${pm}...`);
+			await runOrThrow(options.runner, devDependencyInstall, "Development package installation", result.commandsRun);
+		}
+		for (const file of plan.filesToCreate) {
+			const target = resolveInsideRoot(root, file.path);
+			let finalPath = file.path;
+			let exists = false;
+			try {
+				await fs.access(target);
+				exists = true;
+			} catch {
+				exists = false;
+			}
+			if (exists) {
+				const resolution = options.fileResolutions?.[file.path] ?? "keep";
+				if (resolution === "keep") {
+					result.skippedFiles.push(file.path);
+					result.notes.push(`Kept existing ${file.path}; the planned file was not written.`);
+					continue;
+				}
+				if (resolution === "rename") finalPath = renameWithSuffix(file.path);
+				else await backupFiles(root, operation.filesDir, [file.path]);
+			}
+			const finalTarget = resolveInsideRoot(root, finalPath);
+			await fs.mkdir(path.dirname(finalTarget), { recursive: true });
+			await fs.writeFile(finalTarget, file.contents, "utf8");
+			result.createdFiles.push(finalPath);
+		}
+		for (const edit of plan.jsonEdits) {
+			const target = resolveInsideRoot(root, edit.path);
+			try {
+				await fs.access(target);
+			} catch {
+				result.notes.push(`Skipped JSON edit: ${edit.path} does not exist.`);
+				continue;
+			}
+			progress(`Updating ${edit.path}...`);
+			let content = await fs.readFile(target, "utf8");
+			for (const change of edit.edits) {
+				const edits = modify(content, change.jsonPath, change.value, { formattingOptions: {
+					insertSpaces: true,
+					tabSize: 2
+				} });
+				content = applyEdits(content, edits);
+			}
+			const reparsed = parse(content);
+			if (typeof reparsed !== "object" || reparsed === null) throw new StackPackError(`Refusing to write ${edit.path}: edit produced invalid JSON.`);
+			await fs.writeFile(target, content, "utf8");
+			result.modifiedFiles.push(edit.path);
+		}
+		for (const entry of plan.initializers) {
+			progress(`Running the official ${entry.name} initializer...`);
+			await runOrThrow(options.runner, entry.initializer.buildCommand(pm, root), `Official ${entry.name} initializer`, result.commandsRun);
+		}
+		progress("Rescanning the project...");
+		result.refreshedContext = await detectProject(root, { packageManagerOverride: pm });
+		const finalScripts = {};
+		const conflictNames = new Set(plan.scriptConflicts.map((c) => c.name));
+		for (const script of plan.scripts) {
+			if (!conflictNames.has(script.name)) {
+				finalScripts[script.name] = script.command;
+				continue;
+			}
+			const resolution = options.scriptResolutions?.[script.name] ?? "alternate";
+			if (resolution === "skip") result.notes.push(`Kept the existing "${script.name}" script unchanged.`);
+			else if (resolution === "replace") finalScripts[script.name] = script.command;
+			else {
+				const alternate = `${script.name}:${script.command.split(" ")[0]}`;
+				finalScripts[alternate] = script.command;
+				result.notes.push(`Added the script as "${alternate}" to keep your existing "${script.name}".`);
+			}
+		}
+		if (Object.keys(finalScripts).length > 0) {
+			progress("Updating package.json scripts...");
+			await updatePackageJsonScripts(root, finalScripts);
+			result.modifiedFiles.push("package.json");
+		} else if (plan.dependencies.length > 0 || plan.devDependencies.length > 0) result.modifiedFiles.push("package.json");
+		await writeOperationSummary(operation, {
+			...summaryBase,
+			status: "completed",
+			finishedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	} catch (error) {
+		await writeOperationSummary(operation, {
+			...summaryBase,
+			status: "failed",
+			finishedAt: (/* @__PURE__ */ new Date()).toISOString()
+		}).catch(() => {});
+		throw error;
+	}
+	return result;
+}
+//#endregion
+//#region src/engine/verify-project.ts
+/**
+* Verifies the project after installation. Only runs scripts that actually
+* exist in package.json; never assumes every project has build or typecheck.
+*/
+async function verifyProject(context, plan, options) {
+	const checks = [];
+	const root = context.rootDirectory;
+	const installed = context.installedPackages;
+	const missingPackages = [...plan.dependencies, ...plan.devDependencies].map((p) => p.name).filter((name) => !(name in installed));
+	checks.push(missingPackages.length === 0 ? {
+		name: "Expected packages found",
+		status: "passed"
+	} : {
+		name: "Expected packages found",
+		status: "failed",
+		detail: `Missing from package.json: ${missingPackages.join(", ")}`
+	});
+	const missingFiles = [];
+	for (const file of plan.filesToCreate) try {
+		await fs.access(path.join(root, file.path));
+	} catch {
+		missingFiles.push(file.path);
+	}
+	checks.push(missingFiles.length === 0 ? {
+		name: "Expected files exist",
+		status: "passed"
+	} : {
+		name: "Expected files exist",
+		status: "failed",
+		detail: `Missing: ${missingFiles.join(", ")} (existing files may have been kept instead)`
+	});
+	const configFiles = ["package.json", "tsconfig.json"].filter((file) => context.detectedFiles.includes(file));
+	let configsOk = true;
+	const configProblems = [];
+	for (const file of configFiles) try {
+		const raw = await fs.readFile(path.join(root, file), "utf8");
+		const errors = [];
+		parse(raw, errors, { allowTrailingComma: true });
+		if (errors.length > 0) {
+			configsOk = false;
+			configProblems.push(file);
+		}
+	} catch {
+		configsOk = false;
+		configProblems.push(file);
+	}
+	checks.push(configsOk ? {
+		name: "Configuration files parsed",
+		status: "passed"
+	} : {
+		name: "Configuration files parsed",
+		status: "failed",
+		detail: `Could not parse: ${configProblems.join(", ")}`
+	});
+	const scripts = context.packageJson.scripts ?? {};
+	for (const scriptName of ["typecheck", "build"]) {
+		const label = scriptName === "typecheck" ? "TypeScript check" : "Production build";
+		if (!(scriptName in scripts)) {
+			checks.push({
+				name: label,
+				status: "skipped",
+				detail: `No "${scriptName}" script.`
+			});
+			continue;
+		}
+		if (!options.runCommands) {
+			checks.push({
+				name: label,
+				status: "skipped",
+				detail: "Command checks were not requested."
+			});
+			continue;
+		}
+		const cmd = {
+			command: context.packageManager,
+			args: ["run", scriptName],
+			cwd: root
+		};
+		const result = await options.runner(cmd);
+		checks.push(result.exitCode === 0 ? {
+			name: label,
+			status: "passed"
+		} : {
+			name: label,
+			status: "failed",
+			detail: `${formatCommand(cmd)} exited with code ${result.exitCode}.`
+		});
+	}
+	return checks;
+}
+//#endregion
+//#region src/package-manager/execute.ts
+/**
+* Runs a command with execa. The executable and arguments are always passed
+* separately; no shell is used. Interactive commands inherit stdio so
+* official tools can show their own prompts.
+*/
+const realCommandRunner = async (cmd) => {
+	const debug = process.env.STACKPACK_DEBUG === "1";
+	if (debug) console.error(`[debug] spawning: ${cmd.command} ${cmd.args.join(" ")} (cwd=${cmd.cwd})`);
+	const subprocess = execa(cmd.command, cmd.args, {
+		cwd: cmd.cwd,
+		stdio: cmd.interactive ? "inherit" : "pipe",
+		reject: false
+	});
+	if (debug) console.error(`[debug] spawned pid: ${subprocess.pid}`);
+	const result = await subprocess;
+	if (debug) console.error(`[debug] resolved exitCode: ${result.exitCode}`);
+	return {
+		exitCode: typeof result.exitCode === "number" ? result.exitCode : 1,
+		stdout: typeof result.stdout === "string" ? result.stdout : "",
+		stderr: typeof result.stderr === "string" ? result.stderr : ""
+	};
+};
+//#endregion
+//#region src/package-manager/registry.ts
+const cache = /* @__PURE__ */ new Map();
+/**
+* Resolves the exact version a spec (e.g. "latest" or "^5") would install
+* right now, via the npm registry. Returns null when offline or unknown so
+* callers can fall back to showing the spec.
+*/
+async function resolveRegistryVersion(name, spec) {
+	const key = `${name}@${spec}`;
+	const cached = cache.get(key);
+	if (cached !== void 0) return cached;
+	let version = null;
+	try {
+		const result = await execa("npm", [
+			"view",
+			key,
+			"version",
+			"--json"
+		], {
+			timeout: 15e3,
+			reject: false
+		});
+		const parsed = JSON.parse(typeof result.stdout === "string" ? result.stdout : "null");
+		if (typeof parsed === "string") version = parsed;
+		else if (Array.isArray(parsed)) {
+			const last = parsed[parsed.length - 1];
+			if (typeof last === "string") version = last;
+		}
+	} catch {
+		version = null;
+	}
+	cache.set(key, version);
+	return version;
+}
+/** Resolves many specs in parallel; entries that fail are simply absent. */
+async function resolveRegistryVersions(entries) {
+	const resolved = /* @__PURE__ */ new Map();
+	await Promise.all(entries.map(async ({ name, version }) => {
+		const exact = await resolveRegistryVersion(name, version);
+		if (exact !== null) resolved.set(name, exact);
+	}));
+	return resolved;
+}
+//#endregion
+//#region src/ui/messages.ts
+function frameworkLabel(context) {
+	switch (context.framework) {
+		case "react": return "React";
+		case "next": return "Next.js";
+		default: return "Unknown";
+	}
+}
+function buildToolLabel(context) {
+	switch (context.buildTool) {
+		case "vite": return "Vite";
+		case "next": return "Next.js";
+		default: return "Unknown";
+	}
+}
+function languageLabel(context) {
+	switch (context.language) {
+		case "typescript": return "TypeScript";
+		case "javascript": return "JavaScript";
+		default: return "Unknown";
+	}
+}
+function routerLabel(context) {
+	switch (context.routerType) {
+		case "app-router": return "App Router";
+		case "pages-router": return "Pages Router";
+		case "client-router": return "Client-side router";
+		default: return;
+	}
+}
+function dependencySection(title, packages) {
+	const entries = Object.entries(packages);
+	if (entries.length === 0) return void 0;
+	const cap = 12;
+	const shown = entries.slice(0, cap).map(([name, version]) => `  ${name} ${pc.green(version)}`).join("\n");
+	const more = entries.length > cap ? `\n  ${pc.dim(`…and ${entries.length - cap} more`)}` : "";
+	return `${pc.dim(title)}\n${shown}${more}`;
+}
+function describeContext(context) {
+	const lines = [
+		`${pc.dim("Framework")}\n  ${frameworkLabel(context)}`,
+		`${pc.dim("Build tool")}\n  ${buildToolLabel(context)}`,
+		`${pc.dim("Language")}\n  ${languageLabel(context)}`
+	];
+	const router = routerLabel(context);
+	if (router) lines.push(`${pc.dim("Router")}\n  ${router}`);
+	lines.push(`${pc.dim("Package manager")}\n  ${context.packageManager}`);
+	const dependencies = dependencySection("Dependencies", context.packageJson.dependencies ?? {});
+	if (dependencies) lines.push(dependencies);
+	const devDependencies = dependencySection("Development dependencies", context.packageJson.devDependencies ?? {});
+	if (devDependencies) lines.push(devDependencies);
+	return lines.join("\n");
+}
+//#endregion
+//#region src/ui/review.ts
+function section(title, lines) {
+	if (lines.length === 0) return [];
+	return [
+		"",
+		pc.bold(title),
+		...lines.map((line) => `  ${line}`)
+	];
+}
+function dependencyLine(dep, registryVersions) {
+	const exact = registryVersions?.get(dep.name);
+	const version = exact && exact !== dep.resolvedVersion ? `${dep.name}@${dep.resolvedVersion} ${pc.green(`→ ${exact}`)}` : `${dep.name}@${pc.green(dep.resolvedVersion)}`;
+	return `${pc.green("+")} ${version} ${pc.dim(`(${dep.requestedBy.join(", ")})`)}`;
+}
+/** Renders the full installation plan for the review screen. */
+function renderPlanReview(plan, registryVersions) {
+	const lines = [];
+	lines.push(pc.bold("Base project"));
+	lines.push(`  ${frameworkLabel(plan.context)} with ${buildToolLabel(plan.context)}`);
+	lines.push(`  ${languageLabel(plan.context)}`);
+	lines.push(`  ${plan.context.packageManager}`);
+	const integrationLines = plan.integrations.map(({ recipe, options }) => {
+		const detail = recipe.describeOptions?.(options);
+		return detail ? `${recipe.name} (${detail})` : recipe.name;
+	});
+	lines.push(...section("Selected integrations", integrationLines));
+	lines.push(...section("Dependencies", plan.dependencies.map((dep) => dependencyLine(dep, registryVersions))));
+	lines.push(...section("Development dependencies", plan.devDependencies.map((dep) => dependencyLine(dep, registryVersions))));
+	lines.push(...section("Official initializers (delegated changes)", plan.initializers.map((entry) => `${entry.name} — ${entry.initializer.description}`)));
+	lines.push(...section("Files StackPack plans to create", plan.filesToCreate.map((file) => `${pc.green("+")} ${file.path}`)));
+	lines.push(...section("Files StackPack plans to modify", plan.filesToModify.map((file) => `${pc.yellow("~")} ${file}`)));
+	lines.push(...section("Scripts", plan.scripts.map((script) => `${script.name}: ${script.command}`)));
+	lines.push(...section("Existing files that conflict", plan.existingFileConflicts.map((file) => `${pc.yellow("⚠")} ${file} already exists`)));
+	lines.push(...section("Script conflicts", plan.scriptConflicts.map((conflict) => `${pc.yellow("⚠")} "${conflict.name}" exists (current: ${conflict.current}, proposed: ${conflict.proposed})`)));
+	lines.push(...section("Unresolved version conflicts", plan.conflicts.map((conflict) => `${pc.red("✗")} ${conflict.message}`)));
+	lines.push(...section("Warnings", plan.warnings.map((warning) => `${pc.yellow("⚠")} ${warning}`)));
+	if (plan.initializers.length > 0) {
+		lines.push("");
+		lines.push(pc.dim("StackPack lists its own exact changes above; official initializers control their own additional changes."));
+	}
+	return lines.join("\n");
+}
+//#endregion
+//#region src/utils/names.ts
+const WINDOWS_RESERVED = /* @__PURE__ */ new Set([
+	"con",
+	"prn",
+	"aux",
+	"nul",
+	...Array.from({ length: 9 }, (_, i) => `com${i + 1}`),
+	...Array.from({ length: 9 }, (_, i) => `lpt${i + 1}`)
+]);
+/** Validates a project folder name: safe, portable, no path traversal. */
+function validateProjectName(input) {
+	const name = input.trim();
+	if (name.length === 0) return {
+		ok: false,
+		reason: "Project name is required."
+	};
+	if (name.length > 214) return {
+		ok: false,
+		reason: "Project name is too long."
+	};
+	if (name === "." || name === "..") return {
+		ok: false,
+		reason: "Project name cannot be a relative path."
+	};
+	if (/[/\\]/.test(name)) return {
+		ok: false,
+		reason: "Project name cannot contain path separators."
+	};
+	if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name)) return {
+		ok: false,
+		reason: "Use letters, numbers, dots, dashes, and underscores, starting with a letter or number."
+	};
+	if (name.includes("..")) return {
+		ok: false,
+		reason: "Project name cannot contain path traversal sequences."
+	};
+	if (WINDOWS_RESERVED.has(name.toLowerCase().split(".")[0] ?? "")) return {
+		ok: false,
+		reason: `"${name}" is a reserved name on Windows.`
+	};
+	return { ok: true };
+}
+/** Validates a preset name so it can never become an arbitrary filesystem path. */
+function validatePresetName(input) {
+	const name = input.trim();
+	if (name.length === 0) return {
+		ok: false,
+		reason: "Preset name is required."
+	};
+	if (name.length > 100) return {
+		ok: false,
+		reason: "Preset name is too long."
+	};
+	if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name) || name.includes("..")) return {
+		ok: false,
+		reason: "Use letters, numbers, dots, dashes, and underscores, starting with a letter or number."
+	};
+	return { ok: true };
+}
+const versionValueSchema = z.string().refine((value) => parseVersionSpec(value) !== null, "Invalid npm version, range, or tag.");
+const packageNameSchema = z.string().refine((value) => validatePackageName(value).validForNewPackages, "Invalid npm package name.");
+const packageMapSchema = z.record(packageNameSchema, versionValueSchema);
+const presetSchema = z.object({
+	schemaVersion: z.literal(1),
+	name: z.string().refine((value) => validatePresetName(value).ok, "Unsafe preset name."),
+	displayName: z.string().max(120).optional(),
+	scope: z.enum(["global", "local"]),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	base: z.object({
+		creator: z.enum([
+			"vite",
+			"next",
+			"vite-react"
+		]).transform((value) => value === "vite-react" ? "vite" : value),
+		language: z.enum(["typescript", "javascript"]),
+		creatorOptions: z.record(z.string(), z.unknown()).default({})
+	}),
+	project: z.object({
+		framework: z.enum(["react", "next"]),
+		buildTool: z.enum(["vite", "next"]),
+		language: z.enum(["typescript", "javascript"])
+	}),
+	integrations: z.array(z.object({
+		id: z.string().regex(/^[a-z0-9-]+$/),
+		recipeVersion: z.number().int().positive(),
+		options: z.record(z.string(), z.unknown()).default({})
+	})).default([]),
+	customPackages: z.object({
+		dependencies: packageMapSchema.default({}),
+		devDependencies: packageMapSchema.default({})
+	}).default({
+		dependencies: {},
+		devDependencies: {}
+	}),
+	versionOverrides: packageMapSchema.default({})
+});
+//#endregion
+//#region src/storage/preset-store.ts
+function presetDirFor(scope, options) {
+	if (scope === "global") return getStoragePaths(options.globalBaseDir).presetsDir;
+	if (!options.projectRoot) throw new StackPackError("A project directory is required for local presets.");
+	return getProjectLocalPresetsDir(options.projectRoot);
+}
+function presetFilePath(name, scope, options) {
+	const validation = validatePresetName(name);
+	if (!validation.ok) throw new StackPackError(`Invalid preset name: ${validation.reason}`);
+	const dir = presetDirFor(scope, options);
+	const filePath = path.resolve(dir, `${name}.json`);
+	if (path.dirname(filePath) !== path.resolve(dir)) throw new StackPackError("Preset name resolved outside the preset directory.");
+	return filePath;
+}
+function parsePresetJson(raw, source) {
+	let data;
+	try {
+		data = JSON.parse(raw);
+	} catch (error) {
+		throw new StackPackError(`Preset file is not valid JSON: ${source}`, { cause: error });
+	}
+	const versionProbe = data;
+	if (typeof versionProbe?.schemaVersion === "number" && versionProbe.schemaVersion > 1) throw new StackPackError("This preset was created by a newer StackPack version. Update StackPack before using it.");
+	const parsed = presetSchema.safeParse(data);
+	if (!parsed.success) throw new StackPackError(`Preset file failed validation: ${source}`, { hints: parsed.error.issues.slice(0, 5).map((i) => `${i.path.join(".")}: ${i.message}`) });
+	return parsed.data;
+}
+async function listPresets(options = {}) {
+	const results = [];
+	const scopes = options.projectRoot ? ["local", "global"] : ["global"];
+	for (const scope of scopes) {
+		const dir = presetDirFor(scope, options);
+		let entries;
+		try {
+			entries = await fs.readdir(dir);
+		} catch {
+			continue;
+		}
+		for (const entry of entries.sort()) {
+			if (!entry.endsWith(".json")) continue;
+			const name = entry.slice(0, -5);
+			if (!validatePresetName(name).ok) continue;
+			results.push({
+				name,
+				scope,
+				filePath: path.join(dir, entry)
+			});
+		}
+	}
+	return results;
+}
+async function findPreset(name, options = {}) {
+	return (await listPresets(options)).find((p) => p.name === name) ?? null;
+}
+async function loadPreset(name, options = {}) {
+	const location = await findPreset(name, options);
+	if (!location) throw new StackPackError(`Preset "${name}" was not found.`, { hints: ["Run: stackpack presets list"] });
+	return {
+		preset: parsePresetJson(await fs.readFile(location.filePath, "utf8"), location.filePath),
+		location
+	};
+}
+async function presetExists(name, scope, options = {}) {
+	try {
+		await fs.access(presetFilePath(name, scope, options));
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Atomically saves a preset: writes a temporary file, re-validates it,
+* then renames it into place.
+*/
+async function savePreset(preset, scope, options = {}) {
+	const validated = presetSchema.parse(preset);
+	const filePath = presetFilePath(validated.name, scope, options);
+	const dir = path.dirname(filePath);
+	await fs.mkdir(dir, { recursive: true });
+	const tmpPath = path.join(dir, `.${validated.name}.${crypto.randomUUID()}.tmp`);
+	const serialized = JSON.stringify(validated, null, 2) + "\n";
+	await fs.writeFile(tmpPath, serialized, "utf8");
+	try {
+		parsePresetJson(await fs.readFile(tmpPath, "utf8"), tmpPath);
+		await fs.rename(tmpPath, filePath);
+	} catch (error) {
+		await fs.rm(tmpPath, { force: true });
+		throw error;
+	}
+	return {
+		name: validated.name,
+		scope,
+		filePath
+	};
+}
+async function deletePreset(name, options = {}) {
+	const location = await findPreset(name, options);
+	if (!location) throw new StackPackError(`Preset "${name}" was not found.`);
+	await fs.rm(location.filePath);
+	return location;
+}
+//#endregion
+//#region src/commands/shared.ts
+async function resolveScriptConflicts(plan) {
+	const resolutions = {};
+	for (const conflict of plan.scriptConflicts) {
+		const alternate = `${conflict.name}:${conflict.proposed.split(" ")[0]}`;
+		const choice = guard(await p.select({
+			message: `Script "${conflict.name}" already exists (current: ${conflict.current})`,
+			options: [
+				{
+					value: "alternate",
+					label: `Add as ${alternate}`
+				},
+				{
+					value: "replace",
+					label: `Replace existing ${conflict.name} script`
+				},
+				{
+					value: "skip",
+					label: "Keep current script"
+				},
+				{
+					value: "cancel",
+					label: "Cancel installation"
+				}
+			]
+		}));
+		if (choice === "cancel") return "cancel";
+		resolutions[conflict.name] = choice;
+	}
+	return resolutions;
+}
+async function resolveFileConflicts(plan) {
+	const resolutions = {};
+	for (const filePath of plan.existingFileConflicts) {
+		const planned = plan.filesToCreate.find((file) => file.path === filePath);
+		const required = planned?.requiredReason;
+		for (;;) {
+			const options = required ? [
+				{
+					value: "replace",
+					label: "Replace after backup (recommended)",
+					hint: required
+				},
+				{
+					value: "show",
+					label: "Show proposed contents"
+				},
+				{
+					value: "rename",
+					label: "Create with another name",
+					hint: "adds a .stackpack suffix"
+				},
+				{
+					value: "keep",
+					label: "Keep existing file",
+					hint: "warning: the integration will not work"
+				},
+				{
+					value: "cancel",
+					label: "Cancel installation"
+				}
+			] : [
+				{
+					value: "keep",
+					label: "Keep existing file",
+					hint: "planned file is skipped"
+				},
+				{
+					value: "show",
+					label: "Show proposed contents"
+				},
+				{
+					value: "rename",
+					label: "Create with another name",
+					hint: "adds a .stackpack suffix"
+				},
+				{
+					value: "replace",
+					label: "Replace after backup"
+				},
+				{
+					value: "cancel",
+					label: "Cancel installation"
+				}
+			];
+			const choice = guard(await p.select({
+				message: `${filePath} already exists`,
+				options
+			}));
+			if (choice === "show") {
+				p.note(planned?.contents ?? "(unknown contents)", filePath);
+				continue;
+			}
+			if (choice === "cancel") return "cancel";
+			resolutions[filePath] = choice;
+			break;
+		}
+	}
+	return resolutions;
+}
+async function runVerification(refreshed, plan, runner, applyResult) {
+	const runCommands = guard(await p.confirm({
+		message: "Run available verification commands (typecheck/build)? This can take a while.",
+		initialValue: true
+	}));
+	for (;;) {
+		const spinner = p.spinner();
+		spinner.start("Verifying project...");
+		const checks = await verifyProject(refreshed, plan, {
+			runner,
+			runCommands
+		});
+		spinner.stop("Verification finished");
+		for (const check of checks) {
+			const symbol = check.status === "passed" ? pc.green("✓") : check.status === "failed" ? pc.red("✗") : pc.dim("-");
+			console.log(`  ${symbol} ${check.name}${check.detail ? pc.dim(` — ${check.detail}`) : ""}`);
+		}
+		if (checks.filter((check) => check.status === "failed").length === 0) return;
+		const choice = guard(await p.select({
+			message: "Project verification failed. What would you like to do?",
+			options: [
+				{
+					value: "keep",
+					label: "Keep changes",
+					hint: "details are shown above"
+				},
+				...applyResult.operationDir ? [{
+					value: "restore",
+					label: "Restore backed-up files"
+				}] : [],
+				{
+					value: "retry",
+					label: "Retry verification"
+				}
+			]
+		}));
+		if (choice === "keep") return;
+		if (choice === "restore") {
+			const restored = await restoreBackup(refreshed.rootDirectory, path.join(applyResult.operationDir, "files"));
+			p.log.success(`Restored ${restored.length} file(s) from backup.`);
+			p.log.warn("Installed packages are not automatically removed; review package.json.");
+			return;
+		}
+	}
+}
+/**
+* The shared review -> confirm -> install -> verify flow used by new, add,
+* and apply. Nothing is installed before the final confirmation.
+*/
+async function reviewAndInstall(params) {
+	const runner = params.runner ?? realCommandRunner;
+	for (;;) {
+		const plan = buildInstallationPlan(params.context, params.selection);
+		const plannedPackages = [...plan.dependencies, ...plan.devDependencies];
+		let registryVersions;
+		if (plannedPackages.length > 0) {
+			const spinner = p.spinner();
+			spinner.start("Checking exact versions on the npm registry...");
+			registryVersions = await resolveRegistryVersions(plannedPackages.map((dep) => ({
+				name: dep.name,
+				version: dep.resolvedVersion
+			})));
+			spinner.stop(registryVersions.size > 0 ? "Exact versions resolved from the npm registry" : "Could not reach the npm registry; showing version ranges only");
+		}
+		p.note(renderPlanReview(plan, registryVersions), "Review StackPack setup");
+		if (plan.dependencies.length === 0 && plan.devDependencies.length === 0 && plan.initializers.length === 0 && plan.filesToCreate.length === 0) {
+			p.log.warn("Nothing is selected yet.");
+			return params.allowReturnToDashboard ? "back" : "cancelled";
+		}
+		const action = guard(await p.select({
+			message: "Choose an action",
+			options: [
+				params.dryRun ? {
+					value: "install",
+					label: "Finish dry run",
+					hint: "no changes will be made"
+				} : {
+					value: "install",
+					label: "Install everything"
+				},
+				...params.allowReturnToDashboard ? [{
+					value: "back",
+					label: "Return to integration dashboard"
+				}] : [],
+				{
+					value: "versions",
+					label: "Edit package versions"
+				},
+				{
+					value: "cancel",
+					label: "Cancel"
+				}
+			]
+		}));
+		if (action === "cancel") return "cancelled";
+		if (action === "back") return "back";
+		if (action === "versions") {
+			await runVersionEditor(params.selection);
+			continue;
+		}
+		if (plan.conflicts.length > 0) {
+			p.log.error("Version conflicts must be resolved before installing:");
+			for (const conflict of plan.conflicts) p.log.message(`  ${conflict.message}`);
+			continue;
+		}
+		if (params.dryRun) {
+			const result = await applyPlan(plan, {
+				dryRun: true,
+				runner
+			});
+			p.note([
+				"Commands that would run:",
+				...result.commandsRun.map((cmd) => `  ${cmd}`),
+				"Files that would be created:",
+				...result.createdFiles.length > 0 ? result.createdFiles.map((file) => `  + ${file}`) : ["  (none)"],
+				"Files that would be modified:",
+				...result.modifiedFiles.length > 0 ? result.modifiedFiles.map((file) => `  ~ ${file}`) : ["  (none)"]
+			].join("\n"), "Dry run");
+			p.log.success("Dry run complete. No project files were changed.");
+			return "dry-run";
+		}
+		const scriptResolutions = await resolveScriptConflicts(plan);
+		if (scriptResolutions === "cancel") continue;
+		const fileResolutions = await resolveFileConflicts(plan);
+		if (fileResolutions === "cancel") continue;
+		let applyResult;
+		const spinner = p.spinner();
+		const interactive = plan.initializers.length > 0;
+		try {
+			if (!interactive) spinner.start("Installing...");
+			applyResult = await applyPlan(plan, {
+				dryRun: false,
+				runner,
+				scriptResolutions,
+				fileResolutions,
+				onProgress: (message) => {
+					if (interactive) p.log.step(message);
+					else spinner.message(message);
+				}
+			});
+			if (!interactive) spinner.stop("Installation finished");
+		} catch (error) {
+			if (!interactive) spinner.stop("Installation failed");
+			throw error;
+		}
+		if (applyResult.createdFiles.length > 0) p.log.success(`Created: ${applyResult.createdFiles.join(", ")}`);
+		if (applyResult.modifiedFiles.length > 0) p.log.success(`Modified: ${[...new Set(applyResult.modifiedFiles)].join(", ")}`);
+		for (const note of applyResult.notes) p.log.message(pc.dim(note));
+		await runVerification(applyResult.refreshedContext ?? await detectProject(params.context.rootDirectory, { packageManagerOverride: params.context.packageManager }), plan, runner, applyResult);
+		return "installed";
+	}
+}
+/** Builds a preset from the current context and selection. */
+function buildPresetFromSelection(params) {
+	const { context, selection } = params;
+	if (context.framework === "unknown" || context.language === "unknown") return null;
+	const buildTool = context.buildTool === "unknown" ? void 0 : context.buildTool;
+	if (!buildTool) return null;
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const dependencies = {};
+	const devDependencies = {};
+	for (const pkg of selection.customPackages) (pkg.dependencyType === "dependency" ? dependencies : devDependencies)[pkg.name] = pkg.version;
+	return {
+		schemaVersion: 1,
+		name: params.name,
+		displayName: params.name,
+		scope: params.scope,
+		createdAt: now,
+		updatedAt: now,
+		base: {
+			creator: context.framework === "next" ? "next" : "vite",
+			language: context.language,
+			creatorOptions: {}
+		},
+		project: {
+			framework: context.framework,
+			buildTool,
+			language: context.language
+		},
+		integrations: selectedRecipes(selection).map(({ recipe, options }) => ({
+			id: recipe.id,
+			recipeVersion: recipe.recipeVersion,
+			options
+		})),
+		customPackages: {
+			dependencies,
+			devDependencies
+		},
+		versionOverrides: selection.versionOverrides
+	};
+}
+/** Post-install offer to save the applied setup as a preset. */
+async function offerToSavePreset(context, selection) {
+	if (context.framework === "unknown" || context.language === "unknown") return;
+	if (!guard(await p.confirm({
+		message: "Save this setup as a preset?",
+		initialValue: false
+	}))) return;
+	const name = guard(await p.text({
+		message: "Preset name",
+		placeholder: "my-react-stack",
+		validate(value) {
+			const result = validatePresetName(value ?? "");
+			return result.ok ? void 0 : result.reason;
+		}
+	})).trim();
+	const scope = guard(await p.select({
+		message: "Preset location",
+		options: [{
+			value: "global",
+			label: "Global, available on this device"
+		}, {
+			value: "local",
+			label: "Local, stored inside this project",
+			hint: ".stackpack/"
+		}]
+	}));
+	const storeOptions = { projectRoot: context.rootDirectory };
+	if (await presetExists(name, scope, storeOptions)) {
+		if (guard(await p.select({
+			message: `Preset "${name}" already exists`,
+			options: [{
+				value: "cancel",
+				label: "Keep the existing preset"
+			}, {
+				value: "replace",
+				label: "Replace it"
+			}]
+		})) === "cancel") return;
+	}
+	const preset = buildPresetFromSelection({
+		name,
+		scope,
+		context,
+		selection
+	});
+	if (!preset) {
+		p.log.warn("This project cannot be represented as a preset (unknown framework or language).");
+		return;
+	}
+	const location = await savePreset(preset, scope, storeOptions);
+	p.log.success(`Preset saved\n  Name: ${name}\n  Location: ${location.filePath}`);
+}
+//#endregion
+//#region src/commands/flow.ts
+/**
+* Dashboard <-> review loop shared by new, add, and apply. The user can jump
+* back and forth until they install, finish a dry run, or cancel.
+*/
+async function dashboardInstallLoop(params) {
+	let atReview = params.startAtReview === true;
+	for (;;) {
+		if (!atReview) await runDashboard(params.context, params.selection);
+		const result = await reviewAndInstall({
+			context: params.context,
+			selection: params.selection,
+			dryRun: params.dryRun,
+			runner: params.runner,
+			allowReturnToDashboard: true
+		});
+		if (result === "back") {
+			atReview = false;
+			continue;
+		}
+		if (result === "installed") {
+			await offerToSavePreset(params.context, params.selection);
+			return "installed";
+		}
+		return result === "dry-run" ? "dry-run" : "cancelled";
+	}
+}
+//#endregion
+//#region src/commands/selection-utils.ts
+/** Places an integration into its category slot in the selection. */
+function addToSelection(selection, id, options) {
+	const recipe = getRecipe(id);
+	if (!recipe) return false;
+	const entry = {
+		id,
+		options
+	};
+	switch (recipe.category) {
+		case "routing":
+			selection.routing = entry;
+			return true;
+		case "state-management":
+			selection.stateManagement = entry;
+			return true;
+		case "data-fetching":
+			selection.dataFetching = entry;
+			return true;
+		case "forms-validation":
+			selection.formsAndValidation = entry;
+			return true;
+		case "ui":
+			selection.ui = entry;
+			return true;
+		case "orm":
+			selection.orm = entry;
+			return true;
+		case "testing":
+			if (!selection.testing.some((existing) => existing.id === id)) selection.testing.push(entry);
+			return true;
+	}
+}
+/** Rebuilds a dashboard selection from a saved preset. */
+function presetToSelection(preset) {
+	const selection = createEmptySelection();
+	for (const integration of preset.integrations) if (!addToSelection(selection, integration.id, integration.options)) p.log.warn(`Preset integration "${integration.id}" is not known to this StackPack version and was skipped.`);
+	for (const [name, version] of Object.entries(preset.customPackages.dependencies)) selection.customPackages.push({
+		name,
+		version,
+		dependencyType: "dependency"
+	});
+	for (const [name, version] of Object.entries(preset.customPackages.devDependencies)) selection.customPackages.push({
+		name,
+		version,
+		dependencyType: "devDependency"
+	});
+	selection.versionOverrides = { ...preset.versionOverrides };
+	return selection;
+}
+//#endregion
+//#region src/commands/new.ts
+async function directoryState(target) {
+	try {
+		return (await fs.readdir(target)).length === 0 ? "empty" : "occupied";
+	} catch {
+		return "missing";
+	}
+}
+async function askProjectName(initial) {
+	let candidate = initial;
+	for (;;) {
+		if (!candidate) candidate = guard(await p.text({
+			message: "Project name",
+			placeholder: "my-application",
+			validate(value) {
+				const result = validateProjectName(value ?? "");
+				return result.ok ? void 0 : result.reason;
+			}
+		})).trim();
+		const validation = validateProjectName(candidate);
+		if (!validation.ok) {
+			p.log.error(validation.reason);
+			candidate = void 0;
+			continue;
+		}
+		const destination = path.resolve(process.cwd(), candidate);
+		const state = await directoryState(destination);
+		if (state === "missing") return {
+			name: candidate,
+			destination
+		};
+		if (state === "empty") {
+			const choice = guard(await p.select({
+				message: `Folder "${candidate}" already exists but is empty.`,
+				options: [
+					{
+						value: "use",
+						label: "Use it (it is empty)"
+					},
+					{
+						value: "rename",
+						label: "Enter another name"
+					},
+					{
+						value: "cancel",
+						label: "Cancel"
+					}
+				]
+			}));
+			if (choice === "use") return {
+				name: candidate,
+				destination
+			};
+			if (choice === "cancel") throw new CancelledError();
+			candidate = void 0;
+			continue;
+		}
+		if (guard(await p.select({
+			message: `Folder "${candidate}" already exists and is not empty.`,
+			options: [{
+				value: "rename",
+				label: "Enter another name"
+			}, {
+				value: "cancel",
+				label: "Cancel"
+			}]
+		})) === "cancel") throw new CancelledError();
+		candidate = void 0;
+	}
+}
+async function runOfficialCreator(creator, projectName, creatorOptions, packageManager) {
+	const command = creator.buildCommand(projectName, creatorOptions, packageManager, process.cwd());
+	for (;;) {
+		p.log.step(`Running the official ${creator.officialTool} creator: ${formatCommand(command)}`);
+		const result = await realCommandRunner(command);
+		const generated = await fs.access(path.join(process.cwd(), projectName, "package.json")).then(() => true).catch(() => false);
+		if (result.exitCode === 0 && generated) {
+			p.log.success(`Official ${creator.name} project created`);
+			return;
+		}
+		const reason = result.exitCode === 0 ? "reported success but no package.json was generated — a file lock from an IDE or antivirus may have interrupted it" : `exit code ${result.exitCode}`;
+		const choice = guard(await p.select({
+			message: `Official project creator failed (${creator.officialTool}, ${reason}). The destination folder may contain partial files.`,
+			options: [
+				{
+					value: "retry",
+					label: "Retry"
+				},
+				{
+					value: "keep",
+					label: "Keep partial project and exit"
+				},
+				{
+					value: "exit",
+					label: "Exit"
+				}
+			]
+		}));
+		if (choice === "retry") continue;
+		if (choice === "keep") throw new StackPackError(`The official creator failed; partial files may exist in "${projectName}". Nothing was deleted.`);
+		throw new CancelledError();
+	}
+}
+/**
+* Creators run with installs skipped so all dependencies land in a single
+* install at the end. Installing integrations covers the base dependencies
+* too; this handles every path where that install did not happen.
+*/
+async function ensureDependenciesInstalled(destination, packageManager) {
+	try {
+		await fs.access(path.join(destination, "node_modules"));
+		return;
+	} catch {}
+	p.log.info("No integrations are being added. The base project's own dependencies were deferred earlier, so they install now — otherwise the app could not run.");
+	p.log.step(`Installing base project dependencies: ${packageManager} install`);
+	const result = await realCommandRunner(baseInstallCommand(packageManager, destination));
+	if (result.exitCode !== 0) p.log.warn(`Dependency installation failed (exit code ${result.exitCode}). Run "${packageManager} install" inside the project to finish setup.`);
+}
+async function runNew(projectNameArg, options) {
+	p.intro("StackPack — new project");
+	p.log.message(pc.dim("Official project tooling with real-world integrations."));
+	let preset;
+	if (options.preset) preset = (await loadPreset(options.preset, { projectRoot: process.cwd() })).preset;
+	else {
+		const available = await listPresets({ projectRoot: process.cwd() });
+		if (available.length > 0) {
+			const choice = guard(await p.select({
+				message: "Start from a saved preset?",
+				options: [{
+					value: "__fresh__",
+					label: "No, start fresh",
+					hint: "choose everything yourself"
+				}, ...available.map((entry, index) => ({
+					value: String(index),
+					label: entry.name,
+					hint: entry.scope
+				}))]
+			}));
+			if (choice !== "__fresh__") {
+				const entry = available[Number(choice)];
+				if (entry) preset = (await loadPreset(entry.name, { projectRoot: process.cwd() })).preset;
+			}
+		}
+	}
+	if (preset) {
+		const customEntries = [...Object.entries(preset.customPackages.dependencies), ...Object.entries(preset.customPackages.devDependencies).map(([name, version]) => [name, `${version} (dev)`])];
+		p.note([
+			`Preset\n  ${preset.displayName ?? preset.name}`,
+			`Base\n  ${getCreator(preset.base.creator).name}\n  ${preset.base.language === "typescript" ? "TypeScript" : "JavaScript"}`,
+			`Integrations\n${preset.integrations.length > 0 ? preset.integrations.map((i) => `  ${i.id}`).join("\n") : "  (none)"}`,
+			`Other packages\n${customEntries.length > 0 ? customEntries.map(([name, version]) => `  ${name}@${version}`).join("\n") : "  (none)"}`
+		].join("\n\n"), "Preset");
+		p.log.info("Everything above will be shown again with exact versions on the review screen before anything installs.");
+		if (!guard(await p.confirm({
+			message: "Continue?",
+			initialValue: true
+		}))) throw new CancelledError();
+	}
+	const { name, destination } = await askProjectName(projectNameArg);
+	let creator;
+	if (preset) creator = getCreator(preset.base.creator);
+	else {
+		const baseChoice = guard(await p.select({
+			message: "Choose a base project",
+			options: [...allCreators.map((adapter) => ({
+				value: adapter.id,
+				label: adapter.name,
+				hint: `official ${adapter.officialTool}`
+			})), {
+				value: "__back__",
+				label: "Back",
+				hint: "leave without creating anything"
+			}]
+		}));
+		if (baseChoice === "__back__") throw new CancelledError();
+		creator = getCreator(baseChoice);
+	}
+	const config = await loadConfig();
+	const packageManager = options.packageManager ?? config.defaultPackageManager ?? "npm";
+	let creatorOptions;
+	if (preset) creatorOptions = { language: preset.base.language };
+	else if (creator.collectOptions) creatorOptions = await creator.collectOptions();
+	else creatorOptions = { language: guard(await p.select({
+		message: "Choose a language",
+		options: [{
+			value: "typescript",
+			label: "TypeScript"
+		}, {
+			value: "javascript",
+			label: "JavaScript"
+		}]
+	})) };
+	const languageLabel = creatorOptions.language === void 0 ? `You choose in ${creator.officialTool}'s prompts` : creatorOptions.language === "typescript" ? "TypeScript" : "JavaScript";
+	p.note([
+		`Project\n  ${name}`,
+		`Official creator\n  ${creator.officialTool}`,
+		`Framework\n  ${creator.frameworkLabel}`,
+		`Language\n  ${languageLabel}`,
+		`Template\n  ${creator.templateLabel(creatorOptions)}`,
+		`Package manager\n  ${packageManager}`
+	].join("\n\n"), "Base project");
+	if (!guard(await p.confirm({
+		message: "Create the base project?",
+		initialValue: true
+	}))) throw new CancelledError();
+	await runOfficialCreator(creator, name, creatorOptions, packageManager);
+	p.log.info("Dependency installation is deferred: everything installs in one step after you pick integrations.");
+	const context = await detectProject(destination, { packageManagerOverride: packageManager });
+	p.note(describeContext(context), "Generated project detected");
+	if (context.detection === "unsupported") {
+		p.log.warn("StackPack integrations currently support React (Vite) and Next.js projects, so the integration dashboard is not available for this framework yet.");
+		await ensureDependenciesInstalled(destination, packageManager);
+		p.outro(`Base project created at ${destination}`);
+		return;
+	}
+	if (await dashboardInstallLoop({
+		context,
+		selection: preset ? presetToSelection(preset) : createEmptySelection(),
+		dryRun: false,
+		startAtReview: preset !== void 0
+	}) === "cancelled") {
+		await ensureDependenciesInstalled(destination, packageManager);
+		p.outro(`Base project created at ${destination}. No integrations were installed.`);
+		return;
+	}
+	await ensureDependenciesInstalled(destination, packageManager);
+	p.outro(`Project ready at ${destination}`);
+}
+//#endregion
+//#region src/project/git-status.ts
+/** Git is optional; any failure simply reports "not a repository". */
+async function getGitInfo(projectRoot) {
+	try {
+		const inside = await execa("git", ["rev-parse", "--is-inside-work-tree"], {
+			cwd: projectRoot,
+			reject: false
+		});
+		if (inside.exitCode !== 0 || String(inside.stdout).trim() !== "true") return {
+			isRepository: false,
+			hasUncommittedChanges: false
+		};
+		const status = await execa("git", ["status", "--porcelain"], {
+			cwd: projectRoot,
+			reject: false
+		});
+		return {
+			isRepository: true,
+			hasUncommittedChanges: status.exitCode === 0 && String(status.stdout).trim().length > 0
+		};
+	} catch {
+		return {
+			isRepository: false,
+			hasUncommittedChanges: false
+		};
+	}
+}
+//#endregion
+//#region src/commands/add.ts
+async function resolveContextWithPackageManager(cwd, packageManagerOverride) {
+	let context = await detectProject(cwd, { packageManagerOverride });
+	if (context.detection === "ambiguous" && context.packageManagerCandidates.length > 1) {
+		p.log.warn(`Multiple lockfiles detected: the project matches ${context.packageManagerCandidates.join(", ")}. The other lockfiles will not be modified or deleted.`);
+		context = await detectProject(cwd, { packageManagerOverride: guard(await p.select({
+			message: "Choose a package manager",
+			options: context.packageManagerCandidates.map((pm) => ({
+				value: pm,
+				label: pm
+			}))
+		})) });
+	}
+	return context;
+}
+async function runAdd(options) {
+	const cwd = options.cwd ?? process.cwd();
+	p.intro("StackPack — add integrations");
+	const context = await resolveContextWithPackageManager(cwd, options.packageManager);
+	if (context.detection === "unsupported") throw new StackPackError("This project is not a supported React or Next.js project.", { hints: ["StackPack currently supports React with Vite and Next.js projects.", `Detected directory: ${context.rootDirectory}`] });
+	if (context.detection === "partially-detected") p.log.warn("The project was only partially detected; some integrations may be hidden.");
+	p.note(describeContext(context), "Existing project detected");
+	if (!guard(await p.confirm({
+		message: "Continue to the integration dashboard?",
+		initialValue: true
+	}))) throw new CancelledError();
+	if (!options.dryRun) {
+		const git = await getGitInfo(context.rootDirectory);
+		if (git.isRepository && git.hasUncommittedChanges) {
+			if (!guard(await p.confirm({
+				message: "Uncommitted Git changes detected. StackPack will create its own backup, but committing first is safer. Continue?",
+				initialValue: true
+			}))) throw new CancelledError();
+		}
+	}
+	const outcome = await dashboardInstallLoop({
+		context,
+		selection: createEmptySelection(),
+		dryRun: options.dryRun === true
+	});
+	if (outcome === "cancelled") throw new CancelledError();
+	p.outro(outcome === "dry-run" ? "Dry run finished." : "Integrations installed.");
+}
+//#endregion
+//#region src/commands/scan.ts
+async function runScan(options = {}) {
+	const cwd = options.cwd ?? process.cwd();
+	p.intro("StackPack — scan");
+	const context = await detectProject(cwd);
+	p.note(describeContext(context), "Project detection");
+	if (context.packageManagerCandidates.length > 1) p.log.warn(`Multiple lockfiles detected (${context.packageManagerCandidates.join(", ")}).`);
+	const lines = filterIntegrations(context, allRecipes).map((availability) => {
+		switch (availability.compatibility) {
+			case "already-installed": return `${pc.green("●")} ${availability.recipe.name} — ${availability.reason}`;
+			case "partially-configured": return `${pc.yellow("◐")} ${availability.recipe.name} — ${availability.reason ?? "partially configured"}`;
+			case "incompatible": return `${pc.dim("○")} ${pc.dim(`${availability.recipe.name} — ${availability.reason}`)}`;
+			default: return `${pc.dim("○")} ${availability.recipe.name} — not installed`;
+		}
+	});
+	p.note(lines.join("\n"), "Known integrations");
+	p.outro(`Detection state: ${context.detection}`);
+}
+//#endregion
+//#region src/commands/save.ts
+/**
+* Packages the official creators scaffold themselves. They are not saved in
+* presets because every new base project already ships them.
+*/
+const SCAFFOLD_PACKAGES = /* @__PURE__ */ new Set([
+	"next",
+	"react",
+	"react-dom",
+	"vite",
+	"typescript",
+	"@types/react",
+	"@types/react-dom",
+	"@types/node",
+	"eslint",
+	"eslint-config-next",
+	"eslint-plugin-react-hooks",
+	"eslint-plugin-react-refresh",
+	"@eslint/js",
+	"@eslint/eslintrc",
+	"globals",
+	"typescript-eslint",
+	"@biomejs/biome",
+	"oxlint",
+	"tailwindcss",
+	"@tailwindcss/postcss",
+	"postcss",
+	"autoprefixer",
+	"@vitejs/plugin-react",
+	"@vitejs/plugin-react-swc",
+	"@rolldown/plugin-babel",
+	"babel-plugin-react-compiler",
+	"@babel/core",
+	"@types/babel__core"
+]);
+/**
+* Every dependency that is neither owned by a detected integration nor part
+* of the base scaffold is captured as a custom package, so the preset
+* reproduces the full tech stack.
+*/
+function collectExtraDependencies(context, selection) {
+	const recipeOwned = /* @__PURE__ */ new Set();
+	for (const { recipe, options } of selectedRecipes(selection)) for (const pkg of recipe.createPlan(context, options).packages) recipeOwned.add(pkg.name);
+	const extras = [];
+	const sections = [[context.packageJson.dependencies ?? {}, "dependency"], [context.packageJson.devDependencies ?? {}, "devDependency"]];
+	for (const [packages, dependencyType] of sections) for (const [name, version] of Object.entries(packages)) {
+		if (recipeOwned.has(name) || SCAFFOLD_PACKAGES.has(name)) continue;
+		if (parseVersionSpec(version) === null) {
+			p.log.warn(`Skipping ${name}: version "${version}" cannot be stored in a preset.`);
+			continue;
+		}
+		extras.push({
+			name,
+			version,
+			dependencyType
+		});
+	}
+	return extras;
+}
+/**
+* Saves the current project's detected setup as a preset: recognized
+* integrations plus every other dependency as custom packages.
+*/
+async function runSave(name, options) {
+	const cwd = options.cwd ?? process.cwd();
+	p.intro("StackPack — save preset");
+	const validation = validatePresetName(name);
+	if (!validation.ok) throw new StackPackError(`Invalid preset name: ${validation.reason}`);
+	const context = await detectProject(cwd);
+	if (context.framework === "unknown" || context.language === "unknown") throw new StackPackError("This project cannot be saved as a preset.", { hints: ["StackPack could not detect a supported framework and language."] });
+	const selection = createEmptySelection();
+	const availabilities = filterIntegrations(context, allRecipes);
+	for (const availability of availabilities) if (availability.compatibility === "already-installed" || availability.compatibility === "partially-configured") addToSelection(selection, availability.recipe.id, {});
+	selection.customPackages = collectExtraDependencies(context, selection);
+	const scope = options.local ? "local" : "global";
+	const preset = buildPresetFromSelection({
+		name,
+		scope,
+		context,
+		selection
+	});
+	if (!preset) throw new StackPackError("This project cannot be represented as a preset.");
+	const storeOptions = { projectRoot: cwd };
+	if (await presetExists(name, scope, storeOptions)) {
+		if (guard(await p.select({
+			message: `Preset "${name}" already exists`,
+			options: [{
+				value: "cancel",
+				label: "Cancel"
+			}, {
+				value: "replace",
+				label: "Replace it"
+			}]
+		})) === "cancel") {
+			p.outro("Nothing was saved.");
+			return;
+		}
+	}
+	const location = await savePreset(preset, scope, storeOptions);
+	const extraCount = Object.keys(preset.customPackages.dependencies).length + Object.keys(preset.customPackages.devDependencies).length;
+	p.log.success(`Preset saved with ${preset.integrations.length} detected integration(s) and ${extraCount} other package(s).\n  Location: ${location.filePath}`);
+	p.outro("Done.");
+}
+/** Menu version of save: asks for the preset name and storage location. */
+async function runSaveInteractive(options = {}) {
+	await runSave(guard(await p.text({
+		message: "Preset name",
+		placeholder: "my-react-stack",
+		validate(value) {
+			const result = validatePresetName(value ?? "");
+			return result.ok ? void 0 : result.reason;
+		}
+	})).trim(), {
+		local: guard(await p.select({
+			message: "Where should the preset be saved?",
+			options: [{
+				value: "global",
+				label: "Globally",
+				hint: "usable in every project on this device"
+			}, {
+				value: "local",
+				label: "In this project only",
+				hint: ".stackpack/ folder"
+			}]
+		})) === "local",
+		cwd: options.cwd
+	});
+}
+//#endregion
+//#region src/commands/apply.ts
+/** Applies a saved preset's integrations to the current project. */
+async function runApply(name, options) {
+	const cwd = options.cwd ?? process.cwd();
+	p.intro("StackPack — apply preset");
+	const { preset, location } = await loadPreset(name, { projectRoot: cwd });
+	p.log.info(`Using ${location.scope} preset: ${location.filePath}`);
+	const context = await resolveContextWithPackageManager(cwd);
+	if (context.detection === "unsupported") throw new StackPackError("This project is not a supported React or Next.js project.");
+	p.note(describeContext(context), "Existing project detected");
+	const mismatches = [];
+	if (preset.project.framework !== context.framework) mismatches.push(`framework (preset: ${preset.project.framework}, project: ${context.framework})`);
+	if (preset.project.buildTool !== context.buildTool) mismatches.push(`build tool (preset: ${preset.project.buildTool}, project: ${context.buildTool})`);
+	if (mismatches.length > 0) throw new StackPackError(`Preset "${name}" does not match this project.`, { hints: mismatches.map((m) => `Mismatched ${m}`) });
+	if (!options.dryRun) {
+		const git = await getGitInfo(context.rootDirectory);
+		if (git.isRepository && git.hasUncommittedChanges) {
+			if (!guard(await p.confirm({
+				message: "Uncommitted Git changes detected. StackPack will create its own backup, but committing first is safer. Continue?",
+				initialValue: true
+			}))) throw new CancelledError();
+		}
+	}
+	const outcome = await dashboardInstallLoop({
+		context,
+		selection: presetToSelection(preset),
+		dryRun: options.dryRun === true,
+		startAtReview: true
+	});
+	if (outcome === "cancelled") throw new CancelledError();
+	p.outro(outcome === "dry-run" ? "Dry run finished." : `Preset "${name}" applied.`);
+}
+//#endregion
+//#region src/commands/presets.ts
+async function runPresetsList(options = {}) {
+	const presets = await listPresets({ projectRoot: options.cwd ?? process.cwd() });
+	if (presets.length === 0) {
+		console.log("No presets saved yet. Save one after an installation or with: stackpack save <name>");
+		return;
+	}
+	for (const preset of presets) console.log(`${preset.name}  ${pc.dim(`[${preset.scope}]`)}  ${pc.dim(preset.filePath)}`);
+}
+async function runPresetsShow(name, options = {}) {
+	const { preset, location } = await loadPreset(name, { projectRoot: options.cwd ?? process.cwd() });
+	console.log(pc.bold(preset.displayName ?? preset.name));
+	console.log(pc.dim(`${location.scope} preset — ${location.filePath}`));
+	console.log("");
+	console.log(`Base: ${preset.base.creator} (${preset.base.language})`);
+	console.log(`Project: ${preset.project.framework} / ${preset.project.buildTool} / ${preset.project.language}`);
+	console.log("");
+	console.log("Integrations:");
+	if (preset.integrations.length === 0) console.log("  (none)");
+	for (const integration of preset.integrations) {
+		const opts = Object.entries(integration.options).map(([key, value]) => `${key}=${String(value)}`).join(", ");
+		console.log(`  - ${integration.id}${opts.length > 0 ? ` (${opts})` : ""}`);
+	}
+	const deps = Object.entries(preset.customPackages.dependencies);
+	const devDeps = Object.entries(preset.customPackages.devDependencies);
+	if (deps.length + devDeps.length > 0) {
+		console.log("");
+		console.log("Custom packages:");
+		for (const [pkg, version] of deps) console.log(`  - ${pkg}@${version}`);
+		for (const [pkg, version] of devDeps) console.log(`  - ${pkg}@${version} (dev)`);
+	}
+	const overrides = Object.entries(preset.versionOverrides);
+	if (overrides.length > 0) {
+		console.log("");
+		console.log("Version overrides:");
+		for (const [pkg, version] of overrides) console.log(`  - ${pkg}: ${version}`);
+	}
+}
+/**
+* Interactive preset browser used by the main menu: pick a preset to see its
+* contents, optionally delete it, and always have a way back.
+*/
+async function runPresetsBrowser(options = {}) {
+	const projectRoot = options.cwd ?? process.cwd();
+	for (;;) {
+		const presets = await listPresets({ projectRoot });
+		if (presets.length === 0) {
+			p.log.info("No presets saved yet. Save one after an installation or with: stackpack save <name>");
+			return;
+		}
+		const choice = guard(await p.select({
+			message: "Saved presets",
+			options: [
+				...presets.map((preset, index) => ({
+					value: String(index),
+					label: preset.name,
+					hint: `${preset.scope} — ${preset.filePath}`
+				})),
+				{
+					value: "__delete__",
+					label: "Delete a preset"
+				},
+				{
+					value: "__back__",
+					label: "Back to main menu"
+				}
+			]
+		}));
+		if (choice === "__back__") return;
+		if (choice === "__delete__") {
+			const target = guard(await p.select({
+				message: "Which preset do you want to delete?",
+				options: [...presets.map((preset, index) => ({
+					value: String(index),
+					label: preset.name,
+					hint: `${preset.scope} — ${preset.filePath}`
+				})), {
+					value: "__cancel__",
+					label: "Cancel"
+				}]
+			}));
+			if (target === "__cancel__") continue;
+			const preset = presets[Number(target)];
+			if (!preset) continue;
+			if (guard(await p.confirm({
+				message: `Delete preset "${preset.name}"?`,
+				initialValue: false
+			}))) {
+				const location = await deletePreset(preset.name, { projectRoot });
+				p.log.success(`Deleted ${location.scope} preset: ${location.filePath}`);
+			}
+			continue;
+		}
+		const selected = presets[Number(choice)];
+		if (!selected) continue;
+		await runPresetsShow(selected.name, { cwd: projectRoot });
+		const action = guard(await p.select({
+			message: `Preset "${selected.name}"`,
+			options: [
+				{
+					value: "list",
+					label: "Back to preset list"
+				},
+				{
+					value: "delete",
+					label: "Delete this preset"
+				},
+				{
+					value: "menu",
+					label: "Back to main menu"
+				}
+			]
+		}));
+		if (action === "menu") return;
+		if (action === "delete") {
+			if (guard(await p.confirm({
+				message: `Delete preset "${selected.name}"?`,
+				initialValue: false
+			}))) {
+				const location = await deletePreset(selected.name, { projectRoot });
+				p.log.success(`Deleted ${location.scope} preset: ${location.filePath}`);
+			}
+		}
+	}
+}
+async function runPresetsDelete(name, options = {}) {
+	const storeOptions = { projectRoot: options.cwd ?? process.cwd() };
+	p.intro("StackPack — delete preset");
+	if (!guard(await p.confirm({
+		message: `Delete preset "${name}"?`,
+		initialValue: false
+	}))) {
+		p.outro("Nothing was deleted.");
+		return;
+	}
+	const location = await deletePreset(name, storeOptions);
+	p.outro(`Deleted ${location.scope} preset: ${location.filePath}`);
+}
+//#endregion
+//#region src/version.ts
+const VERSION = "0.3.0";
+//#endregion
+//#region src/program.ts
+const packageManagerOption = new Option("--package-manager <manager>", "package manager to use").choices([
+	"npm",
+	"pnpm",
+	"yarn",
+	"bun"
+]);
+async function runMainMenu() {
+	p.intro("StackPack");
+	p.log.message("Official project tooling with real-world integrations.");
+	p.log.message("Presets stay on this device.");
+	p.log.message(pc.dim("Ctrl+C on any question brings you back to this menu instead of exiting."));
+	for (;;) {
+		const choice = await p.select({
+			message: "What would you like to do?",
+			options: [
+				{
+					value: "new",
+					label: "Create a new project"
+				},
+				{
+					value: "add",
+					label: "Add integrations to the current project"
+				},
+				{
+					value: "scan",
+					label: "Scan the current project"
+				},
+				{
+					value: "save",
+					label: "Save this project's stack as a preset",
+					hint: "integrations + all other dependencies"
+				},
+				{
+					value: "presets",
+					label: "View saved presets"
+				},
+				{
+					value: "exit",
+					label: "Exit"
+				}
+			]
+		});
+		if (p.isCancel(choice) || choice === "exit") {
+			p.outro("Goodbye.");
+			return;
+		}
+		try {
+			switch (choice) {
+				case "new":
+					await runNew(void 0, {});
+					break;
+				case "add":
+					await runAdd({});
+					break;
+				case "scan":
+					await runScan();
+					break;
+				case "save":
+					await runSaveInteractive();
+					break;
+				case "presets":
+					await runPresetsBrowser();
+					break;
+			}
+		} catch (error) {
+			if (error instanceof CancelledError) {
+				p.log.info("Cancelled — back to the main menu.");
+				continue;
+			}
+			printError(error);
+		}
+	}
+}
+async function runCli(argv) {
+	const program = new Command();
+	program.name("stackpack").description("Local-first terminal integration builder. Official project tooling with real-world integrations; presets stay on this device.").version(VERSION).option("--no-color", "disable colored output");
+	program.command("new").description("Create a new project with an official creator, then add integrations").argument("[project-name]", "name of the project folder to create").option("--preset <name>", "create the project from a saved preset").addOption(packageManagerOption).action(async (projectName, options) => {
+		await runNew(projectName, options);
+	});
+	program.command("add").description("Add integrations to the current project").option("--dry-run", "show the full plan without changing anything").addOption(packageManagerOption).action(async (options) => {
+		await runAdd(options);
+	});
+	program.command("scan").description("Detect the current project's stack and installed integrations").action(async () => {
+		await runScan();
+	});
+	program.command("save").description("Save the current project's detected setup as a preset").argument("<preset-name>", "name for the preset").option("--local", "store the preset inside this project (.stackpack/)").option("--global", "store the preset in your home directory (default)").action(async (name, options) => {
+		await runSave(name, options);
+	});
+	program.command("apply").description("Apply a saved preset's integrations to the current project").argument("<preset-name>", "preset to apply").option("--dry-run", "show the full plan without changing anything").action(async (name, options) => {
+		await runApply(name, options);
+	});
+	const presets = program.command("presets").description("Manage saved presets");
+	presets.command("list").description("List saved presets (global and project-local)").action(async () => {
+		await runPresetsList();
+	});
+	presets.command("show").description("Show a preset's contents").argument("<preset-name>").action(async (name) => {
+		await runPresetsShow(name);
+	});
+	presets.command("delete").description("Delete a saved preset").argument("<preset-name>").action(async (name) => {
+		await runPresetsDelete(name);
+	});
+	const hasCommand = argv.slice(2).some((arg) => !arg.startsWith("-"));
+	const onlyFlags = argv.slice(2).every((arg) => arg === "--no-color");
+	try {
+		if (!hasCommand && onlyFlags) {
+			await runMainMenu();
+			return;
+		}
+		await program.parseAsync(argv);
+	} catch (error) {
+		process.exitCode = printError(error);
+	}
+}
+//#endregion
+export { runCli };