@format.dev/cli 0.0.0 → 0.1.1

package/dist/install-BiDrmMgJ.mjs

@@ -0,0 +1,1486 @@
+import { r as detectIndent$1, s as CliError } from "./config-Dq7O4e8N.mjs";
+import { a as DEFAULT_STYLING, c as SCHEMA_DEPENDENCIES, d as STYLING_DEPENDENCIES, i as DEFAULT_SCHEMA_KIND, m as STYLING_SUPPORT, r as DEFAULT_PAGE_WIDTH, t as DEFAULT_PAGE_HEIGHT, y as methodsForFramework } from "./shared-CM3vyUlL.mjs";
+import { t as drawRandomName } from "./draw-random-name-Dpt6YmUk.mjs";
+import { createRequire } from "node:module";
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { dirname, extname, join, relative, resolve } from "node:path";
+import { applyEdits, modify } from "jsonc-parser";
+import { pathToFileURL } from "node:url";
+
+//#region src/package-manager.ts
+const LOCKFILES = [
+	["pnpm-lock.yaml", "pnpm"],
+	["yarn.lock", "yarn"],
+	["bun.lock", "bun"],
+	["bun.lockb", "bun"],
+	["package-lock.json", "npm"]
+];
+function findLockfileManager(startDir) {
+	let dir = resolve(startDir);
+	for (;;) {
+		const match = LOCKFILES.find(([lockfile]) => existsSync(join(dir, lockfile)));
+		if (match) return match[1];
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+async function detectPackageManager(projectDir) {
+	const packageJsonPath = join(projectDir, "package.json");
+	if (existsSync(packageJsonPath)) {
+		const raw = await fs.readFile(packageJsonPath, "utf8");
+		const declared = JSON.parse(raw).packageManager?.split("@")[0];
+		if (declared === "pnpm" || declared === "yarn" || declared === "bun" || declared === "npm") return declared;
+	}
+	const userAgent = process.env.npm_config_user_agent ?? "";
+	const fromUserAgent = [
+		"pnpm",
+		"yarn",
+		"bun"
+	].find((name) => userAgent.includes(`${name}/`));
+	if (fromUserAgent) return fromUserAgent;
+	return findLockfileManager(projectDir) ?? "npm";
+}
+function installCommand(packageManager) {
+	if (packageManager === "npm") return {
+		command: "npm",
+		args: ["install"]
+	};
+	if (packageManager === "pnpm") return {
+		command: "pnpm",
+		args: ["install", "--no-frozen-lockfile"]
+	};
+	if (packageManager === "yarn") return {
+		command: "yarn",
+		args: ["install", "--no-immutable"]
+	};
+	return {
+		command: packageManager,
+		args: ["install"]
+	};
+}
+function commandForPlatform(command) {
+	if (process.platform !== "win32") return command;
+	if (command === "npm" || command === "pnpm" || command === "yarn") return `${command}.cmd`;
+	return command;
+}
+
+//#endregion
+//#region src/scaffold/run-install.ts
+const MAX_OUTPUT_LINES = 40;
+function truncateForSpinner(line) {
+	const available = Math.max(20, (process.stdout.columns ?? 80) - 10);
+	if (line.length <= available) return line;
+	return `${line.slice(0, available - 1)}…`;
+}
+async function runInstall(args) {
+	const { command, args: commandArgs, cwd, onProgress } = args;
+	return new Promise((resolvePromise) => {
+		const child = spawn(commandForPlatform(command), commandArgs, {
+			cwd,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			shell: false
+		});
+		const lines = [];
+		const collect = (chunk) => {
+			chunk.toString().split("\n").map((line) => line.trim()).filter(Boolean).forEach((line) => {
+				lines.push(line);
+				onProgress?.(line);
+			});
+		};
+		child.stdout?.on("data", collect);
+		child.stderr?.on("data", collect);
+		const output = () => lines.slice(-MAX_OUTPUT_LINES).join("\n");
+		child.on("error", (error) => {
+			resolvePromise({
+				ok: false,
+				code: null,
+				error,
+				output: output()
+			});
+		});
+		child.on("exit", (code) => {
+			resolvePromise({
+				ok: code === 0,
+				code,
+				output: output()
+			});
+		});
+	});
+}
+
+//#endregion
+//#region src/scaffold/dependencies.ts
+async function writeDependenciesToManifest(args) {
+	const { projectDir, dependencies } = args;
+	if (dependencies.length === 0) return [];
+	const packageJsonPath = join(projectDir, "package.json");
+	const raw = await fs.readFile(packageJsonPath, "utf8");
+	const packageJson = JSON.parse(raw);
+	const runtime = { ...packageJson.dependencies ?? {} };
+	const development = { ...packageJson.devDependencies ?? {} };
+	const present = new Set([...Object.keys(runtime), ...Object.keys(development)]);
+	const added = [];
+	for (const dependency of dependencies) {
+		if (present.has(dependency.name)) continue;
+		const target = dependency.dev ? development : runtime;
+		target[dependency.name] = dependency.version;
+		present.add(dependency.name);
+		added.push(dependency.name);
+	}
+	if (added.length === 0) return [];
+	if (Object.keys(runtime).length > 0) packageJson.dependencies = runtime;
+	if (Object.keys(development).length > 0) packageJson.devDependencies = development;
+	const indent$2 = detectIndent$1(raw);
+	await fs.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, indent$2)}\n`, "utf8");
+	return added;
+}
+async function installManifest(args) {
+	const { projectDir, onProgress } = args;
+	const packageManager = await detectPackageManager(projectDir);
+	const { command, args: commandArgs } = installCommand(packageManager);
+	const result = await runInstall({
+		command,
+		args: commandArgs,
+		cwd: projectDir,
+		onProgress
+	});
+	if (result.ok) return {
+		ok: true,
+		packageManager
+	};
+	return {
+		ok: false,
+		packageManager,
+		message: result.error?.message ?? `${packageManager} exited with code ${result.code}`,
+		output: result.output
+	};
+}
+function joinNames(names) {
+	if (names.length <= 1) return names[0] ?? "";
+	return `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
+}
+
+//#endregion
+//#region src/scaffold/document/types.ts
+const DEFAULT_TEMPLATE = "blank";
+const EMPTY_STYLESHEET_COMMENT = "/* Your styles go here */\n";
+
+//#endregion
+//#region src/scaffold/document/document-names.ts
+const RESERVED_WORDS = new Set([
+	"await",
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"import",
+	"in",
+	"instanceof",
+	"new",
+	"null",
+	"return",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"yield",
+	"implements",
+	"interface",
+	"let",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"static",
+	"arguments",
+	"eval",
+	"globalthis",
+	"infinity",
+	"nan",
+	"undefined",
+	"any",
+	"bigint",
+	"boolean",
+	"never",
+	"number",
+	"object",
+	"string",
+	"symbol",
+	"unknown"
+]);
+const IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const isReserved = (value) => RESERVED_WORDS.has(value.toLowerCase());
+function capitalize$1(value) {
+	return value ? value[0].toUpperCase() + value.slice(1) : "";
+}
+function toCamelCase(input) {
+	const parts = input.trim().replace(/([a-z0-9])([A-Z])/g, "$1-$2").split(/[^A-Za-z0-9]+/).filter(Boolean);
+	if (!parts.length) return "document";
+	return `${parts[0].toLowerCase()}${parts.slice(1).map((part) => capitalize$1(part.toLowerCase())).join("")}` || "document";
+}
+function toSafeIdentifier(name) {
+	let safe = name;
+	if (!/^[A-Za-z_$]/.test(safe)) safe = `doc${capitalize$1(safe)}`;
+	if (!IDENTIFIER_RE.test(safe) || isReserved(safe)) safe = `doc${capitalize$1(safe.replace(/[^A-Za-z0-9_$]/g, ""))}`;
+	if (!IDENTIFIER_RE.test(safe) || isReserved(safe)) safe = "document";
+	return safe;
+}
+function getDocumentExportName(documentName) {
+	return toSafeIdentifier(toCamelCase(documentName));
+}
+function buildDocumentExportMap(documentNames) {
+	const map = /* @__PURE__ */ new Map();
+	const used = /* @__PURE__ */ new Map();
+	for (const documentName of documentNames) {
+		const exportName = getDocumentExportName(documentName);
+		const existing = used.get(exportName);
+		if (existing) throw new Error(`Document names must resolve to unique exports. "${existing}" and "${documentName}" both map to "${exportName}".`);
+		used.set(exportName, documentName);
+		map.set(documentName, exportName);
+	}
+	return map;
+}
+
+//#endregion
+//#region src/scaffold/document/validate-name.ts
+const RESERVED_DOCUMENT_NAMES = ["shared-assets", "chunks"];
+const ALLOWED_NAME = /^[A-Za-z0-9-]+$/;
+function validateDocumentName(args) {
+	const { name, existingNames } = args;
+	const trimmed = name.trim();
+	if (!trimmed) return {
+		ok: false,
+		reason: "Enter a document name."
+	};
+	if (!ALLOWED_NAME.test(trimmed)) return {
+		ok: false,
+		reason: "Document names shouldn't use spaces or non-alphanumeric characters. Use letters, numbers and dashes only."
+	};
+	if (RESERVED_DOCUMENT_NAMES.includes(trimmed)) return {
+		ok: false,
+		reason: `"${trimmed}" is a reserved name. Reserved names: ${RESERVED_DOCUMENT_NAMES.join(", ")}.`
+	};
+	const exportName = getDocumentExportName(trimmed);
+	if (RESERVED_WORDS.has(exportName.toLowerCase())) return {
+		ok: false,
+		reason: `"${trimmed}" maps to the reserved identifier "${exportName}". Pick a different name.`
+	};
+	if (existingNames.includes(trimmed)) return {
+		ok: false,
+		reason: `A document named "${trimmed}" already exists.`,
+		suggestion: suggestAvailableName({
+			name: trimmed,
+			existingNames
+		})
+	};
+	const exportCollision = existingNames.find((existing) => getDocumentExportName(existing) === exportName);
+	if (exportCollision) return {
+		ok: false,
+		reason: `"${trimmed}" and the existing document "${exportCollision}" both map to the export "${exportName}". Document names must resolve to unique exports.`,
+		suggestion: suggestAvailableName({
+			name: trimmed,
+			existingNames
+		})
+	};
+	return { ok: true };
+}
+function suggestAvailableName(args) {
+	const { name, existingNames } = args;
+	const takenNames = new Set(existingNames);
+	const takenExports = new Set(existingNames.map(getDocumentExportName));
+	const isAvailable = (candidate) => !takenNames.has(candidate) && !takenExports.has(getDocumentExportName(candidate));
+	if (isAvailable(name)) return name;
+	const base = name.replace(/-\d+$/, "");
+	let counter = 2;
+	while (!isAvailable(`${base}-${counter}`)) counter += 1;
+	return `${base}-${counter}`;
+}
+
+//#endregion
+//#region src/scaffold/document/styling/prerequisites.ts
+async function readProjectDependencies(projectRoot) {
+	try {
+		const raw = await fs.readFile(join(projectRoot, "package.json"), "utf8");
+		const pkg = JSON.parse(raw);
+		return new Set([...Object.keys(pkg.dependencies ?? {}), ...Object.keys(pkg.devDependencies ?? {})]);
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+}
+function buildReport(args) {
+	const { method, missingDependencies, missingConfig } = args;
+	const steps = [];
+	if (missingDependencies.length > 0) {
+		const names = missingDependencies.map((dependency) => dependency.name).join(" ");
+		const flag = missingDependencies.every((dependency) => dependency.dev) ? "-D " : "";
+		steps.push(`Install the required package: \`pnpm add ${flag}${names}\``);
+	}
+	for (const config of missingConfig) steps.push(config.description);
+	return {
+		method,
+		satisfied: missingDependencies.length === 0 && missingConfig.length === 0,
+		missingDependencies,
+		missingConfig,
+		steps
+	};
+}
+function satisfied(method) {
+	return buildReport({
+		method,
+		missingDependencies: [],
+		missingConfig: []
+	});
+}
+function requireDependency(args) {
+	const { method, dependency, installed, missingConfig = [] } = args;
+	return buildReport({
+		method,
+		missingDependencies: installed.has(dependency) ? [] : [{
+			name: dependency,
+			dev: true
+		}],
+		missingConfig
+	});
+}
+
+//#endregion
+//#region src/scaffold/document/panda-setup.ts
+const PANDA_CONFIG_NAMES = [
+	"panda.config.ts",
+	"panda.config.mts",
+	"panda.config.cts",
+	"panda.config.js",
+	"panda.config.mjs",
+	"panda.config.cjs"
+];
+const DEFAULT_PANDA_CONFIG_NAME = "panda.config.ts";
+const PANDA_CONFIG_TEMPLATE = (documentsDirName) => `import { defineConfig } from '@pandacss/dev'
+
+export default defineConfig({
+	include: ['./${documentsDirName}/**/*.{js,jsx,ts,tsx,vue}'],
+	outdir: './styles/styled-system'
+})
+`;
+function findExistingPandaConfig(projectRoot) {
+	let dir = resolve(projectRoot);
+	for (;;) {
+		for (const name of PANDA_CONFIG_NAMES) {
+			const candidate = join(dir, name);
+			if (existsSync(candidate)) return candidate;
+		}
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+async function writePandaConfig(args) {
+	const { projectRoot, documentsDirName } = args;
+	const configPath = join(projectRoot, DEFAULT_PANDA_CONFIG_NAME);
+	await fs.writeFile(configPath, PANDA_CONFIG_TEMPLATE(documentsDirName), "utf8");
+	return configPath;
+}
+const PANDA_LAYER_CSS = `@layer reset, base, tokens, recipes, utilities;
+
+:host {
+	display: flex;
+	flex-direction: column;
+	justify-content: center;
+	text-align: center;
+}
+`;
+async function ensurePandaLayerCss(projectRoot) {
+	const stylesDir = join(projectRoot, "styles");
+	const layerPath = join(stylesDir, "styles.css");
+	if (existsSync(layerPath)) return "exists";
+	await fs.mkdir(stylesDir, { recursive: true });
+	await fs.writeFile(layerPath, PANDA_LAYER_CSS, "utf8");
+	return "created";
+}
+function detectIndent(raw) {
+	const match = raw.match(/^[ \t]+/m);
+	return match ? match[0] : "	";
+}
+async function addPrepareScript(projectRoot) {
+	const packageJsonPath = join(projectRoot, "package.json");
+	let raw;
+	try {
+		raw = await fs.readFile(packageJsonPath, "utf8");
+	} catch {
+		return "no-package-json";
+	}
+	const packageJson = JSON.parse(raw);
+	if (packageJson.scripts?.prepare) return "exists";
+	packageJson.scripts = {
+		...packageJson.scripts,
+		prepare: "panda codegen"
+	};
+	const indent$2 = detectIndent(raw);
+	await fs.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, indent$2)}\n`, "utf8");
+	return "added";
+}
+async function enablePandaInFormatConfig(args) {
+	const { formatConfigPath, projectRoot, pandaConfigPath } = args;
+	const raw = await fs.readFile(formatConfigPath, "utf8");
+	const indent$2 = detectIndent(raw);
+	const formattingOptions = {
+		insertSpaces: !indent$2.includes("	"),
+		tabSize: indent$2.includes("	") ? 4 : indent$2.length
+	};
+	const applyConfigEdit = (content, path, value) => {
+		return applyEdits(content, modify(content, path, value, { formattingOptions }));
+	};
+	let updated = applyConfigEdit(raw, ["pandaCss", "enabled"], true);
+	if (!(resolve(pandaConfigPath) === resolve(projectRoot, DEFAULT_PANDA_CONFIG_NAME))) {
+		const relativeConfig = `./${relative(projectRoot, pandaConfigPath)}`;
+		const relativeCwd = `./${relative(projectRoot, dirname(pandaConfigPath))}`;
+		updated = applyConfigEdit(updated, ["pandaCss", "postCssConfig"], {
+			cwd: relativeCwd,
+			configPath: relativeConfig
+		});
+	}
+	await fs.writeFile(formatConfigPath, updated, "utf8");
+}
+function execArgs(packageManager, binArgs) {
+	switch (packageManager) {
+		case "pnpm": return {
+			command: "pnpm",
+			args: ["exec", ...binArgs]
+		};
+		case "yarn": return {
+			command: "yarn",
+			args: ["exec", ...binArgs]
+		};
+		case "bun": return {
+			command: "bun",
+			args: ["x", ...binArgs]
+		};
+		default: return {
+			command: "npm",
+			args: [
+				"exec",
+				"--",
+				...binArgs
+			]
+		};
+	}
+}
+async function runPandaCodegen(projectRoot) {
+	const { command, args } = execArgs(await detectPackageManager(projectRoot), ["panda", "codegen"]);
+	return new Promise((resolvePromise) => {
+		const child = spawn(commandForPlatform(command), args, {
+			cwd: projectRoot,
+			stdio: "inherit",
+			shell: false
+		});
+		child.on("error", (error) => {
+			resolvePromise({
+				ok: false,
+				message: error.message
+			});
+		});
+		child.on("exit", (code) => {
+			resolvePromise(code === 0 ? { ok: true } : {
+				ok: false,
+				message: `panda codegen exited with code ${code}`
+			});
+		});
+	});
+}
+async function setupPanda(args) {
+	const { projectRoot, documentsDirName, formatConfigPath, runCodegen = runPandaCodegen } = args;
+	const existing = findExistingPandaConfig(projectRoot);
+	const pandaConfigCreated = existing === null;
+	const pandaConfigPath = existing ?? await writePandaConfig({
+		projectRoot,
+		documentsDirName
+	});
+	const layerCss = await ensurePandaLayerCss(projectRoot);
+	const prepareScript = await addPrepareScript(projectRoot);
+	let formatConfigUpdated = false;
+	try {
+		await enablePandaInFormatConfig({
+			formatConfigPath,
+			projectRoot,
+			pandaConfigPath
+		});
+		formatConfigUpdated = true;
+	} catch {
+		formatConfigUpdated = false;
+	}
+	const codegen = await runCodegen(projectRoot);
+	return {
+		pandaConfigPath,
+		pandaConfigCreated,
+		layerCss,
+		prepareScript,
+		formatConfigUpdated,
+		codegen
+	};
+}
+
+//#endregion
+//#region src/scaffold/document/styling/strategies.ts
+const STARTER_CSS = `:host {
+	display: flex;
+	flex-direction: column;
+	justify-content: center;
+	text-align: center;
+}
+
+h1 {
+	margin-block: 0.5rem;
+	font-size: 1.5rem;
+}
+
+.hint {
+	margin: 0;
+	opacity: 0.5;
+	font-family: var(--font-mono);
+}
+`;
+const TAILWIND_CSS = `@import 'tailwindcss';
+
+@theme {
+	--font-sans: var(--font-sans-system);
+	--font-serif: var(--font-serif-system);
+	--font-mono: var(--font-mono-system);
+}
+
+:host {
+	display: flex;
+	flex-direction: column;
+	justify-content: center;
+	text-align: center;
+}
+`;
+const TAILWIND_EMPTY_CSS = `@import 'tailwindcss';
+
+@theme {
+	--font-sans: var(--font-sans-system);
+	--font-serif: var(--font-serif-system);
+	--font-mono: var(--font-mono-system);
+}
+
+${EMPTY_STYLESHEET_COMMENT}`;
+const TAILWIND_HEADING_CLASS = "my-2 text-2xl font-bold";
+const TAILWIND_HINT_CLASS = "m-0 opacity-50 font-mono";
+const STARTER_VANILLA_EXTRACT = `import { globalStyle, style } from '@vanilla-extract/css'
+
+globalStyle(':host', {
+	display: 'flex',
+	flexDirection: 'column',
+	justifyContent: 'center',
+	textAlign: 'center'
+})
+
+export const title = style({
+	marginBlock: '0.5rem',
+	fontSize: '1.5rem'
+})
+
+export const hint = style({
+	margin: 0,
+	opacity: 0.5,
+	fontFamily: 'var(--font-mono)'
+})
+`;
+const LINARIA_HOST_STYLES = `export const hostStyles = css\`
+	:global() {
+		:host {
+			display: flex;
+			flex-direction: column;
+			justify-content: center;
+			text-align: center;
+		}
+	}
+\``;
+const LINARIA_TITLE = `const Title = styled.h1\`
+	margin-block: 0.5rem;
+	font-size: 1.5rem;
+\``;
+const LINARIA_HINT = `const Hint = styled.p\`
+	margin: 0;
+	opacity: 0.5;
+	font-family: var(--font-mono);
+\``;
+function elementApplication(imports, vueStyleBlock) {
+	return {
+		imports,
+		declarations: [],
+		headingTag: "h1",
+		hintTag: "p",
+		hintClass: "hint",
+		vueStyleBlock
+	};
+}
+function tailwindApplication(imports, vueStyleBlock) {
+	return {
+		imports,
+		declarations: [],
+		headingTag: "h1",
+		hintTag: "p",
+		headingClass: TAILWIND_HEADING_CLASS,
+		hintClass: TAILWIND_HINT_CLASS,
+		vueStyleBlock
+	};
+}
+const cssStrategy = {
+	method: "css",
+	frameworks: STYLING_SUPPORT["css"],
+	files() {
+		return [{
+			path: "styles.css",
+			contents: STARTER_CSS
+		}];
+	},
+	apply({ framework }) {
+		if (framework === "vue") return elementApplication([], "<style>\n@import './styles.css';\n</style>");
+		return elementApplication(["import './styles.css'"]);
+	},
+	async checkPrerequisites() {
+		return satisfied("css");
+	}
+};
+const cssModulesStrategy = {
+	method: "css-modules",
+	frameworks: STYLING_SUPPORT["css-modules"],
+	files() {
+		return [{
+			path: "styles.module.css",
+			contents: STARTER_CSS
+		}];
+	},
+	apply() {
+		return {
+			imports: ["import styles from './styles.module.css'"],
+			declarations: [],
+			headingTag: "h1",
+			hintTag: "p",
+			hintClassExpr: "styles.hint"
+		};
+	},
+	async checkPrerequisites() {
+		return satisfied("css-modules");
+	}
+};
+const scopedStrategy = {
+	method: "vue-sfc-scoped",
+	frameworks: STYLING_SUPPORT["vue-sfc-scoped"],
+	files() {
+		return [];
+	},
+	apply() {
+		return elementApplication([], `<style scoped>\n${STARTER_CSS}</style>`);
+	},
+	async checkPrerequisites() {
+		return satisfied("vue-sfc-scoped");
+	}
+};
+const scssStrategy = {
+	method: "scss",
+	frameworks: STYLING_SUPPORT["scss"],
+	files() {
+		return [{
+			path: "styles.scss",
+			contents: STARTER_CSS
+		}];
+	},
+	apply({ framework }) {
+		if (framework === "vue") return elementApplication([], "<style lang=\"scss\">\n@use './styles.scss';\n</style>");
+		return elementApplication(["import './styles.scss'"]);
+	},
+	async checkPrerequisites() {
+		return satisfied("scss");
+	}
+};
+const tailwindStrategy = {
+	method: "tailwind",
+	frameworks: STYLING_SUPPORT["tailwind"],
+	files() {
+		return [{
+			path: "styles.css",
+			contents: TAILWIND_CSS
+		}];
+	},
+	emptyFiles() {
+		return [{
+			path: "styles.css",
+			contents: TAILWIND_EMPTY_CSS
+		}];
+	},
+	apply({ framework }) {
+		if (framework === "vue") return tailwindApplication([], "<style>\n@import './styles.css';\n</style>");
+		return tailwindApplication(["import './styles.css'"]);
+	},
+	async checkPrerequisites({ projectRoot }) {
+		return requireDependency({
+			method: "tailwind",
+			dependency: "tailwindcss",
+			installed: await readProjectDependencies(projectRoot)
+		});
+	}
+};
+const linariaStrategy = {
+	method: "linaria",
+	frameworks: STYLING_SUPPORT["linaria"],
+	files() {
+		return [];
+	},
+	apply() {
+		return {
+			imports: ["import { css } from '@linaria/core'", "import { styled } from '@linaria/react'"],
+			declarations: [
+				LINARIA_HOST_STYLES,
+				LINARIA_TITLE,
+				LINARIA_HINT
+			],
+			headingTag: "Title",
+			hintTag: "Hint"
+		};
+	},
+	async checkPrerequisites({ projectRoot }) {
+		const installed = await readProjectDependencies(projectRoot);
+		return buildReport({
+			method: "linaria",
+			missingDependencies: STYLING_DEPENDENCIES.linaria.filter((dependency) => !installed.has(dependency)).map((name) => ({
+				name,
+				dev: true
+			})),
+			missingConfig: []
+		});
+	}
+};
+const vanillaExtractStrategy = {
+	method: "vanilla-extract",
+	frameworks: STYLING_SUPPORT["vanilla-extract"],
+	files() {
+		return [{
+			path: "styles.css.ts",
+			contents: STARTER_VANILLA_EXTRACT
+		}];
+	},
+	apply() {
+		return {
+			imports: ["import { title, hint } from './styles.css'"],
+			declarations: [],
+			headingTag: "h1",
+			hintTag: "p",
+			headingClassExpr: "title",
+			hintClassExpr: "hint"
+		};
+	},
+	async checkPrerequisites({ projectRoot }) {
+		return requireDependency({
+			method: "vanilla-extract",
+			dependency: "@vanilla-extract/css",
+			installed: await readProjectDependencies(projectRoot)
+		});
+	}
+};
+const PANDA_TITLE = `const title = css({
+	marginBlock: '0.5rem',
+	fontSize: '1.5rem'
+})`;
+const PANDA_HINT = `const hint = css({
+	margin: 0,
+	opacity: 0.5,
+	fontFamily: 'var(--font-mono)'
+})`;
+const pandaStrategy = {
+	method: "panda-css",
+	frameworks: STYLING_SUPPORT["panda-css"],
+	files() {
+		return [];
+	},
+	apply() {
+		return {
+			imports: ["import { css } from '../../styles/styled-system/css'", "import '../../styles/styles.css'"],
+			declarations: [PANDA_TITLE, PANDA_HINT],
+			headingTag: "h1",
+			hintTag: "p",
+			headingClassExpr: "title",
+			hintClassExpr: "hint"
+		};
+	},
+	async checkPrerequisites({ projectRoot }) {
+		return requireDependency({
+			method: "panda-css",
+			dependency: "@pandacss/dev",
+			installed: await readProjectDependencies(projectRoot)
+		});
+	},
+	async setupProject(args) {
+		const { projectRoot, formatConfigPath, documentsGlobBase } = args;
+		const result = await setupPanda({
+			projectRoot,
+			documentsDirName: documentsGlobBase,
+			formatConfigPath
+		});
+		const summary = [
+			result.pandaConfigCreated ? "Created panda.config.ts" : "Reused existing Panda config",
+			`Panda layer stylesheet ${result.layerCss}`,
+			`prepare script ${result.prepareScript}`,
+			result.formatConfigUpdated ? "Enabled pandaCss in the Format config" : "Left the Format config unchanged",
+			result.codegen.ok ? "Ran panda codegen" : `panda codegen failed: ${result.codegen.message ?? "unknown error"}`
+		];
+		return {
+			method: "panda-css",
+			ok: result.codegen.ok,
+			summary
+		};
+	}
+};
+const STYLING_STRATEGIES = [
+	cssStrategy,
+	cssModulesStrategy,
+	scopedStrategy,
+	scssStrategy,
+	tailwindStrategy,
+	linariaStrategy,
+	vanillaExtractStrategy,
+	pandaStrategy
+];
+
+//#endregion
+//#region src/scaffold/document/styling/index.ts
+function resolveStyling(args) {
+	const { framework, method } = args;
+	const strategy = STYLING_STRATEGIES.find((candidate) => candidate.method === method);
+	if (!strategy) throw new CliError(`Unknown styling method "${method}". Available methods: ${STYLING_STRATEGIES.map((candidate) => candidate.method).join(", ")}.`);
+	if (!STYLING_SUPPORT[method].includes(framework)) throw new CliError(`The "${method}" styling method isn't supported for ${framework} projects. Supported methods: ${methodsForFramework(framework).join(", ")}.`);
+	return strategy;
+}
+
+//#endregion
+//#region src/scaffold/document/data-schema.ts
+function kindOf(value) {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "array";
+	if (typeof value === "object") return "object";
+	if (typeof value === "number") return "number";
+	if (typeof value === "boolean") return "boolean";
+	return "string";
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function indent$1(text, tabs) {
+	const pad = "	".repeat(tabs);
+	return text.split("\n").map((line) => line ? pad + line : line).join("\n");
+}
+function keyLiteral(key) {
+	return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}
+function jsonToTsType(value, depth = 0) {
+	const kind = kindOf(value);
+	if (kind === "string") return "string";
+	if (kind === "number") return "number";
+	if (kind === "boolean") return "boolean";
+	if (kind === "null") return "null";
+	if (kind === "array") {
+		const items = value;
+		return `${items.length > 0 ? jsonToTsType(items[0], depth) : "unknown"}[]`;
+	}
+	const entries = Object.entries(value);
+	if (entries.length === 0) return "Record<string, unknown>";
+	return `{\n${indent$1(entries.map(([key, child]) => `${keyLiteral(key)}: ${jsonToTsType(child, depth + 1)}`).join("\n"), 1)}\n}`;
+}
+const DIALECTS = {
+	zod: {
+		string: "z.string()",
+		number: "z.number()",
+		boolean: "z.boolean()",
+		null: "z.null()",
+		unknown: "z.unknown()",
+		object: (body) => `z.object(${body})`,
+		array: (element) => `z.array(${element})`
+	},
+	valibot: {
+		string: "v.string()",
+		number: "v.number()",
+		boolean: "v.boolean()",
+		null: "v.null()",
+		unknown: "v.unknown()",
+		object: (body) => `v.object(${body})`,
+		array: (element) => `v.array(${element})`
+	},
+	yup: {
+		string: "yup.string()",
+		number: "yup.number()",
+		boolean: "yup.boolean()",
+		null: "yup.mixed()",
+		unknown: "yup.mixed()",
+		object: (body) => `yup.object(${body})`,
+		array: (element) => `yup.array(${element})`
+	},
+	joi: {
+		string: "Joi.string()",
+		number: "Joi.number()",
+		boolean: "Joi.boolean()",
+		null: "Joi.any()",
+		unknown: "Joi.any()",
+		object: (body) => `Joi.object(${body})`,
+		array: (element) => `Joi.array().items(${element})`
+	}
+};
+function jsonToSchemaExpr(value, dialect) {
+	const syntax = DIALECTS[dialect];
+	const kind = kindOf(value);
+	if (kind === "string") return syntax.string;
+	if (kind === "number") return syntax.number;
+	if (kind === "boolean") return syntax.boolean;
+	if (kind === "null") return syntax.null;
+	if (kind === "array") {
+		const items = value;
+		const element = items.length > 0 ? jsonToSchemaExpr(items[0], dialect) : syntax.unknown;
+		return syntax.array(element);
+	}
+	const entries = Object.entries(value);
+	if (entries.length === 0) return syntax.object("{}");
+	const lines = entries.map(([key, child]) => `${keyLiteral(key)}: ${jsonToSchemaExpr(child, dialect)}`);
+	return syntax.object(`{\n${indent$1(lines.join(",\n"), 1)}\n}`);
+}
+function firstStringField(value) {
+	if (!isPlainObject(value)) return null;
+	for (const [key, child] of Object.entries(value)) if (typeof child === "string") return key;
+	return null;
+}
+
+//#endregion
+//#region src/scaffold/document/templates/utils.ts
+function starterHint(documentName, entryFile) {
+	return `Edit documents/${documentName}/${entryFile} to get started`;
+}
+function indent(text, tabs) {
+	const pad = "	".repeat(tabs);
+	return text.split("\n").map((line) => line ? pad + line : line).join("\n");
+}
+function capitalize(word) {
+	return word ? word[0].toUpperCase() + word.slice(1) : "";
+}
+function words(name) {
+	return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").split(/[^A-Za-z0-9]+/).filter(Boolean);
+}
+function pascalCase(name) {
+	return words(name).map((word) => capitalize(word.toLowerCase())).join("");
+}
+function titleize(name) {
+	return words(name).map((word) => capitalize(word.toLowerCase())).join(" ");
+}
+function dataTypeName(name) {
+	return `${pascalCase(name)}Data`;
+}
+function block(lines) {
+	return lines.filter(Boolean).join("\n");
+}
+function buildClassAttr(args) {
+	const { literal, expr, classAttr, classExprAttr } = args;
+	if (expr && classExprAttr) return classExprAttr(expr);
+	if (literal) return classAttr(literal);
+	return "";
+}
+function buildBody(args) {
+	const { application, title, hint, classAttr, classExprAttr } = args;
+	const headingClassAttr = buildClassAttr({
+		literal: application.headingClass,
+		expr: application.headingClassExpr,
+		classAttr,
+		classExprAttr
+	});
+	const hintClassAttr = buildClassAttr({
+		literal: application.hintClass,
+		expr: application.hintClassExpr,
+		classAttr,
+		classExprAttr
+	});
+	const lines = `${`<${application.headingTag}${headingClassAttr}>${title}</${application.headingTag}>`}\n${`<${application.hintTag}${hintClassAttr}>${hint}</${application.hintTag}>`}`;
+	if (!application.wrapperTag) return lines;
+	return `<${application.wrapperTag}>\n${indent(lines, 1)}\n</${application.wrapperTag}>`;
+}
+
+//#endregion
+//#region src/scaffold/document/templates/react.ts
+function buildReactEntry(args) {
+	const { documentName, application, width, height, emitSchema, data, empty } = args;
+	const component = `${pascalCase(documentName)}Document`;
+	const dataType = dataTypeName(documentName);
+	if (empty) return {
+		path: "index.tsx",
+		contents: `${block(["import { Document, Layout } from '@format.dev/react'", ...application.imports])}
+
+export default function ${component}() {
+	return (
+		<Document title="${titleize(documentName)}">
+			<Layout width={${width}} height={${height}}>
+				{/* Your content goes here */}
+			</Layout>
+		</Document>
+	)
+}
+`
+	};
+	const head = block([
+		"import { Document, Layout, type RenderProps } from '@format.dev/react'",
+		emitSchema ? `import type { ${dataType} } from './data/schema'` : "",
+		...application.imports
+	]);
+	const field = firstStringField(data);
+	return {
+		path: "index.tsx",
+		contents: `${head}
+${emitSchema ? "" : `\ntype ${dataType} = ${jsonToTsType(data)}\n`}${application.declarations.length > 0 ? `\n${application.declarations.join("\n\n")}\n` : ""}
+export default function ${component}({ data }: RenderProps<${dataType}>) {
+	return (
+		<Document title=${field ? `{data.${field}}` : `'${titleize(documentName)}'`}>
+			<Layout width={${width}} height={${height}}>
+${indent(buildBody({
+			application,
+			title: field ? `{data.${field}}` : titleize(documentName),
+			hint: starterHint(documentName, "index.tsx"),
+			classAttr: (cls) => ` className="${cls}"`,
+			classExprAttr: (expr) => ` className={${expr}}`
+		}), 4)}
+			</Layout>
+		</Document>
+	)
+}
+`
+	};
+}
+
+//#endregion
+//#region src/scaffold/document/templates/vue.ts
+function buildVueEntry(args) {
+	const { documentName, application, width, height, emitSchema, data, empty } = args;
+	const dataType = dataTypeName(documentName);
+	const trailingStyles = application.vueStyleBlock ? `\n${application.vueStyleBlock}\n` : "\n";
+	if (empty) return {
+		path: "index.vue",
+		contents: `<script setup lang="ts">
+${block(["import { Document, Layout } from '@format.dev/vue'", ...application.imports])}
+<\/script>
+
+<template>
+	<Document title="${titleize(documentName)}">
+		<Layout :width="${width}" :height="${height}">
+			<!-- Your content goes here -->
+		</Layout>
+	</Document>
+</template>
+${trailingStyles}`
+	};
+	const scriptImports = block([
+		"import { Document, Layout, type RenderProps } from '@format.dev/vue'",
+		emitSchema ? `import type { ${dataType} } from './data/schema'` : "",
+		...application.imports
+	]);
+	const field = firstStringField(data);
+	return {
+		path: "index.vue",
+		contents: `<script setup lang="ts">
+${scriptImports}
+${emitSchema ? "" : `\ntype ${dataType} = ${jsonToTsType(data)}\n`}${application.declarations.length > 0 ? `\n${application.declarations.join("\n\n")}\n` : ""}
+const props = defineProps<RenderProps<${dataType}>>()
+<\/script>
+
+<template>
+	<Document ${field ? `:title="props.data.${field}"` : `title="${titleize(documentName)}"`}>
+		<Layout :width="${width}" :height="${height}">
+${indent(buildBody({
+			application,
+			title: field ? `{{ props.data.${field} }}` : titleize(documentName),
+			hint: starterHint(documentName, "index.vue"),
+			classAttr: (cls) => ` class="${cls}"`,
+			classExprAttr: (expr) => ` :class="${expr}"`
+		}), 3)}
+		</Layout>
+	</Document>
+</template>
+${trailingStyles}`
+	};
+}
+
+//#endregion
+//#region src/scaffold/document/templates/html.ts
+function buildHtmlEntry(args) {
+	const { documentName, application, width, height, data, empty } = args;
+	const field = firstStringField(data);
+	const title = empty || !field ? titleize(documentName) : `<%= data.${field} %>`;
+	const html = `<template data-type="document" data-title="${title}">
+	<template data-type="layout" data-width="${width}px" data-height="${height}px">
+${indent(empty ? "<!-- Your content goes here -->" : buildBody({
+		application,
+		title,
+		hint: starterHint(documentName, "index.html"),
+		classAttr: (cls) => ` class="${cls}"`
+	}), 2)}
+	</template>
+</template>
+`;
+	const indexTs = block(["export { default } from './index.html'", ...application.imports]) + "\n";
+	return [{
+		path: "index.html",
+		contents: html
+	}, {
+		path: "index.ts",
+		contents: indexTs
+	}];
+}
+
+//#endregion
+//#region src/scaffold/document/templates/index.ts
+function buildEntryFiles(args) {
+	const { framework } = args;
+	if (framework === "vue") return [buildVueEntry(args)];
+	if (framework === "html") return buildHtmlEntry(args);
+	return [buildReactEntry(args)];
+}
+function buildDataFile(data) {
+	return {
+		path: "data/default.json",
+		contents: `${JSON.stringify(data, null, "	")}\n`
+	};
+}
+const SCHEMA_HEADER = {
+	zod: "import { z } from 'zod'",
+	valibot: "import * as v from 'valibot'",
+	yup: "import * as yup from 'yup'",
+	joi: "import Joi from 'joi'"
+};
+function schemaTypeExport(kind, typeName, data) {
+	if (kind === "zod") return `export type ${typeName} = z.infer<typeof schema>`;
+	if (kind === "valibot") return `export type ${typeName} = v.InferOutput<typeof schema>`;
+	if (kind === "yup") return `export type ${typeName} = yup.InferType<typeof schema>`;
+	return `export type ${typeName} = ${jsonToTsType(data)}`;
+}
+function buildSchemaFile(documentName, kind = DEFAULT_SCHEMA_KIND, data) {
+	const typeName = dataTypeName(documentName);
+	const schemaExpr = jsonToSchemaExpr(data, kind);
+	return {
+		path: "data/schema.ts",
+		contents: `${SCHEMA_HEADER[kind]}
+
+const schema = ${schemaExpr}
+
+export default schema
+
+${schemaTypeExport(kind, typeName, data)}
+`
+	};
+}
+function buildGitkeepFile() {
+	return {
+		path: "assets/.gitkeep",
+		contents: ""
+	};
+}
+
+//#endregion
+//#region src/scaffold/document/format.ts
+const PARSER_BY_EXTENSION = {
+	".tsx": "typescript",
+	".ts": "typescript",
+	".jsx": "babel",
+	".js": "babel",
+	".vue": "vue",
+	".css": "css",
+	".scss": "scss",
+	".json": "json"
+};
+const FALLBACK_OPTIONS = {
+	useTabs: true,
+	singleQuote: true,
+	semi: false
+};
+const prettierByProject = /* @__PURE__ */ new Map();
+function loadProjectPrettier(projectRoot) {
+	const cached = prettierByProject.get(projectRoot);
+	if (cached) return cached;
+	const loading = (async () => {
+		try {
+			const module = await import(pathToFileURL(createRequire(join(projectRoot, "package.json")).resolve("prettier")).href);
+			return "format" in module ? module : module.default;
+		} catch {
+			return null;
+		}
+	})();
+	prettierByProject.set(projectRoot, loading);
+	return loading;
+}
+async function formatGeneratedFile(args) {
+	const { contents, filePath, projectRoot } = args;
+	const parser = PARSER_BY_EXTENSION[extname(filePath)];
+	if (!parser || !contents.trim()) return contents;
+	const prettier = await loadProjectPrettier(projectRoot);
+	if (!prettier) return contents;
+	try {
+		const projectConfig = await prettier.resolveConfig(filePath);
+		return await prettier.format(contents, {
+			...FALLBACK_OPTIONS,
+			...projectConfig,
+			parser
+		});
+	} catch {
+		return contents;
+	}
+}
+
+//#endregion
+//#region src/scaffold/document/create-document.ts
+const DOCUMENTS_DIR_NAME = "documents";
+function getDocumentsDir(args) {
+	const { projectRoot, config } = args;
+	return join(resolve(projectRoot, config.rootDir || "./"), DOCUMENTS_DIR_NAME);
+}
+async function readExistingDocumentNames(documentsDir) {
+	try {
+		return (await fs.readdir(documentsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory() || entry.isSymbolicLink()).map((entry) => entry.name);
+	} catch {
+		return [];
+	}
+}
+async function writeFiles(args) {
+	const { documentDir, files, projectRoot } = args;
+	await Promise.all(files.map(async (file) => {
+		const fullPath = join(documentDir, file.path);
+		await fs.mkdir(dirname(fullPath), { recursive: true });
+		const contents = await formatGeneratedFile({
+			contents: file.contents,
+			filePath: fullPath,
+			projectRoot
+		});
+		await fs.writeFile(fullPath, contents, "utf8");
+	}));
+}
+function isSideEffectImport(statement) {
+	return /^\s*import\s+['"]/.test(statement);
+}
+function toEmptyApplication(application) {
+	const vueStyleBlockPullsInFile = application.vueStyleBlock ? /@(import|use)/.test(application.vueStyleBlock) : false;
+	return {
+		imports: application.imports.filter(isSideEffectImport),
+		declarations: [],
+		headingTag: application.headingTag,
+		hintTag: application.hintTag,
+		vueStyleBlock: vueStyleBlockPullsInFile ? application.vueStyleBlock : void 0
+	};
+}
+function emptyStylingFiles(strategy, args) {
+	if (strategy.emptyFiles) return strategy.emptyFiles(args);
+	return strategy.files(args).map((file) => ({
+		...file,
+		contents: EMPTY_STYLESHEET_COMMENT
+	}));
+}
+async function buildDocumentPlan(args) {
+	const { config, projectRoot, name, template = DEFAULT_TEMPLATE, schemaKind, width = DEFAULT_PAGE_WIDTH, height = DEFAULT_PAGE_HEIGHT, empty = false } = args;
+	const styling = args.styling ?? DEFAULT_STYLING;
+	const emitSchema = empty ? false : args.emitSchema ?? false;
+	const data = empty ? {} : args.data !== void 0 ? args.data : { title: name };
+	if (template !== "blank") throw new CliError(`Unknown template "${template}". Only "blank" is supported.`);
+	const documentsDir = getDocumentsDir({
+		projectRoot,
+		config
+	});
+	const validation = validateDocumentName({
+		name,
+		existingNames: await readExistingDocumentNames(documentsDir)
+	});
+	if (!validation.ok) {
+		const suffix = validation.suggestion ? ` Try "${validation.suggestion}".` : "";
+		throw new CliError(`${validation.reason}${suffix}`);
+	}
+	const documentDir = join(documentsDir, name);
+	const strategy = resolveStyling({
+		framework: config.framework,
+		method: styling
+	});
+	const exportName = getDocumentExportName(name);
+	const applyArgs = {
+		framework: config.framework,
+		documentName: name,
+		exportName
+	};
+	const fullApplication = strategy.apply(applyArgs);
+	const application = empty ? toEmptyApplication(fullApplication) : fullApplication;
+	const stylingFiles = empty ? emptyStylingFiles(strategy, applyArgs) : strategy.files(applyArgs);
+	const files = [
+		...buildEntryFiles({
+			framework: config.framework,
+			documentName: name,
+			application,
+			width,
+			height,
+			emitSchema,
+			data,
+			empty
+		}),
+		...stylingFiles,
+		buildDataFile(data),
+		buildGitkeepFile()
+	];
+	if (emitSchema) files.push(buildSchemaFile(name, schemaKind, data));
+	return {
+		documentName: name,
+		documentDir,
+		files,
+		prerequisites: await strategy.checkPrerequisites({
+			config,
+			projectRoot
+		}),
+		projectRoot
+	};
+}
+async function writeDocument(plan) {
+	try {
+		await writeFiles({
+			documentDir: plan.documentDir,
+			files: plan.files,
+			projectRoot: plan.projectRoot
+		});
+	} catch (error) {
+		await fs.rm(plan.documentDir, {
+			recursive: true,
+			force: true
+		});
+		const message = error instanceof Error ? error.message : "Unknown error";
+		throw new CliError(`Failed to write document "${plan.documentName}": ${message}`);
+	}
+}
+async function createDocument(args) {
+	const plan = await buildDocumentPlan(args);
+	await writeDocument(plan);
+	return {
+		documentName: plan.documentName,
+		documentDir: plan.documentDir,
+		filesWritten: plan.files.map((file) => file.path),
+		prerequisites: plan.prerequisites
+	};
+}
+
+//#endregion
+//#region src/scaffold/document/random-name.ts
+function generateRandomName(args) {
+	const { existingNames, maxAttempts = 10 } = args;
+	for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+		const candidate = drawRandomName();
+		if (validateDocumentName({
+			name: candidate,
+			existingNames
+		}).ok) return candidate;
+	}
+	return suggestAvailableName({
+		name: drawRandomName(),
+		existingNames
+	});
+}
+
+//#endregion
+//#region src/scaffold/recommended-versions.ts
+const RECOMMENDED_DEPENDENCY_VERSIONS = {
+	zod: "^4.4.3",
+	valibot: "^1.4.2",
+	tailwindcss: "^4.3.3",
+	"@linaria/react": "^7.0.1",
+	"@linaria/core": "^7.0.0",
+	"@vanilla-extract/css": "^1.21.1",
+	"@pandacss/dev": "^1.11.4",
+	joi: "^18.2.3",
+	yup: "^1.7.1"
+};
+function recommendedVersion(name) {
+	return RECOMMENDED_DEPENDENCY_VERSIONS[name] ?? "latest";
+}
+
+//#endregion
+//#region src/scaffold/document/install.ts
+async function writeDocumentDependencies(args) {
+	const { projectRoot, emitSchema, schemaKind, missingStylingDependencies } = args;
+	const installed = await readProjectDependencies(projectRoot);
+	const candidates = [...missingStylingDependencies];
+	if (emitSchema) candidates.push(SCHEMA_DEPENDENCIES[schemaKind ?? DEFAULT_SCHEMA_KIND]);
+	return writeDependenciesToManifest({
+		projectDir: projectRoot,
+		dependencies: [...new Set(candidates)].filter((name) => !installed.has(name)).map((name) => ({
+			name,
+			version: recommendedVersion(name),
+			dev: true
+		}))
+	});
+}
+async function maybeInstallDependencies(args) {
+	const { wanted, projectRoot, emitSchema, schemaKind, missingStylingDependencies, onInstallStart } = args;
+	const packages = await writeDocumentDependencies({
+		projectRoot,
+		emitSchema,
+		schemaKind,
+		missingStylingDependencies
+	});
+	if (!wanted || packages.length === 0) return {
+		requested: wanted,
+		attempted: false,
+		ok: true,
+		packages
+	};
+	onInstallStart?.(packages);
+	const result = await installManifest({
+		projectDir: projectRoot,
+		onProgress: args.onProgress
+	});
+	return {
+		requested: true,
+		attempted: true,
+		ok: result.ok,
+		packages,
+		packageManager: result.packageManager,
+		message: result.message,
+		output: result.output
+	};
+}
+async function maybeSetupProject(args) {
+	const { wanted, styling, config, projectRoot, formatConfigPath, documentsGlobBase } = args;
+	if (!wanted || styling === void 0) return null;
+	const strategy = resolveStyling({
+		framework: config.framework,
+		method: styling
+	});
+	if (!strategy.setupProject) return null;
+	return strategy.setupProject({
+		config,
+		projectRoot,
+		formatConfigPath,
+		documentsGlobBase
+	});
+}
+
+//#endregion
+export { joinNames as C, commandForPlatform as D, truncateForSpinner as E, detectPackageManager as O, installManifest as S, runInstall as T, RESERVED_WORDS as _, DOCUMENTS_DIR_NAME as a, DEFAULT_TEMPLATE as b, getDocumentsDir as c, resolveStyling as d, STYLING_STRATEGIES as f, validateDocumentName as g, suggestAvailableName as h, generateRandomName as i, installCommand as k, readExistingDocumentNames as l, RESERVED_DOCUMENT_NAMES as m, maybeSetupProject as n, buildDocumentPlan as o, readProjectDependencies as p, writeDocumentDependencies as r, createDocument as s, maybeInstallDependencies as t, writeDocument as u, buildDocumentExportMap as v, writeDependenciesToManifest as w, EMPTY_STYLESHEET_COMMENT as x, getDocumentExportName as y };