create-next-style-guide 0.0.0-stage → 0.1.2

package/dist/index.js

@@ -0,0 +1,3848 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import * as p4 from "@clack/prompts";
+import color4 from "picocolors";
+import path30 from "path";
+
+// src/constants.ts
+import path from "path";
+import { fileURLToPath } from "url";
+var here = path.dirname(fileURLToPath(import.meta.url));
+var TEMPLATE_DIR = path.resolve(here, "../template");
+var ADDONS_DIR = path.resolve(here, "../addons");
+var TITLE = "Next Style Guide";
+var PKG_NAME = "create-next-style-guide";
+
+// src/helpers/package-manager.ts
+function joinArgs(args) {
+  return args?.length ? ` ${args.join(" ")}` : "";
+}
+var PACKAGE_MANAGERS = {
+  pnpm: {
+    id: "pnpm",
+    packageManagerField: "pnpm@9.15.0",
+    lockfile: "pnpm-lock.yaml",
+    installArgs: ["install", "--ignore-workspace"],
+    runScript: (script, args) => `pnpm ${script}${joinArgs(args)}`,
+    exec: (bin, args) => `pnpm exec ${bin}${joinArgs(args)}`
+  },
+  npm: {
+    id: "npm",
+    packageManagerField: null,
+    lockfile: "package-lock.json",
+    // --install-strategy=hoisted keeps the app isolated if nested under another workspace tree
+    installArgs: ["install", "--install-strategy=hoisted"],
+    runScript: (script, args) => `npm run ${script}${joinArgs(args)}`,
+    exec: (bin, args) => `npx ${bin}${joinArgs(args)}`
+  },
+  yarn: {
+    id: "yarn",
+    packageManagerField: "yarn@1.22.22",
+    lockfile: "yarn.lock",
+    installArgs: ["install"],
+    runScript: (script, args) => `yarn ${script}${joinArgs(args)}`,
+    exec: (bin, args) => `yarn ${bin}${joinArgs(args)}`
+  }
+};
+function getPackageManager(id) {
+  return PACKAGE_MANAGERS[id];
+}
+function ciInstallCommand(id) {
+  switch (id) {
+    case "pnpm":
+      return "pnpm install --frozen-lockfile";
+    case "npm":
+      return "npm ci";
+    case "yarn":
+      return "yarn install --frozen-lockfile";
+  }
+}
+
+// src/helpers/slugify.ts
+function slugify(name) {
+  const slug = name.trim().toLowerCase().replace(/[\s.-]+/g, "_").replace(/[^a-z0-9_]/g, "").replace(/_+/g, "_").replace(/^_|_$/g, "");
+  if (!slug) {
+    throw new Error(`Could not derive a package slug from "${name}".`);
+  }
+  if (/^[0-9]/.test(slug)) {
+    return `app_${slug}`;
+  }
+  return slug;
+}
+
+// src/presets.ts
+var PRESET_SEEDS = {
+  minimal: {
+    packageManager: "pnpm",
+    auth: "none",
+    styling: "none",
+    ui: "none",
+    data: "rsc",
+    store: "none",
+    icons: "none",
+    validation: "zod",
+    i18n: false,
+    darkMode: false,
+    apiEnvelope: false,
+    endpoints: false,
+    seo: false,
+    eslint: false,
+    prettier: false,
+    husky: false,
+    docker: false,
+    ci: false,
+    testing: false,
+    playwright: false
+  },
+  "api-app": {
+    packageManager: "pnpm",
+    auth: "jwt",
+    styling: "tailwind",
+    ui: "shadcn",
+    data: "tanstack-query",
+    store: "zustand",
+    icons: "lucide",
+    validation: "zod",
+    i18n: false,
+    darkMode: true,
+    apiEnvelope: true,
+    endpoints: true,
+    seo: false,
+    eslint: true,
+    prettier: true,
+    husky: true,
+    docker: false,
+    ci: true,
+    testing: true,
+    playwright: false
+  },
+  marketing: {
+    packageManager: "pnpm",
+    auth: "none",
+    styling: "tailwind",
+    ui: "shadcn",
+    data: "rsc",
+    store: "none",
+    icons: "lucide",
+    validation: "zod",
+    i18n: true,
+    darkMode: true,
+    apiEnvelope: false,
+    endpoints: false,
+    seo: true,
+    eslint: true,
+    prettier: true,
+    husky: true,
+    docker: false,
+    ci: true,
+    testing: true,
+    playwright: false
+  },
+  dashboard: {
+    packageManager: "pnpm",
+    auth: "none",
+    styling: "tailwind",
+    ui: "shadcn",
+    data: "tanstack-query",
+    store: "zustand",
+    icons: "lucide",
+    validation: "zod",
+    i18n: false,
+    darkMode: true,
+    apiEnvelope: false,
+    endpoints: false,
+    seo: false,
+    eslint: true,
+    prettier: true,
+    husky: true,
+    docker: false,
+    ci: true,
+    testing: true,
+    playwright: false
+  }
+};
+function describePreset(id) {
+  const seed = PRESET_SEEDS[id];
+  return [
+    `styling=${seed.styling}`,
+    seed.ui === "shadcn" ? "shadcn" : null,
+    `auth=${seed.auth}`,
+    seed.store !== "none" ? `store=${seed.store}` : null,
+    `validation=${seed.validation}`,
+    seed.endpoints ? "endpoints" : null,
+    seed.data === "tanstack-query" ? "query" : null,
+    seed.darkMode ? "dark" : null,
+    seed.seo ? "seo" : null,
+    seed.i18n ? "i18n" : null,
+    seed.testing ? "vitest" : null
+  ].filter(Boolean).join(" \xB7 ");
+}
+function collectOptionWarnings(options) {
+  const warnings = [];
+  if (options.auth === "jwt" && !options.endpoints) {
+    warnings.push(
+      "JWT without endpoints: only token-storage is added (no axios refresh wiring)."
+    );
+  }
+  if (options.ui === "shadcn" && options.styling !== "tailwind") {
+    warnings.push("shadcn requires Tailwind \u2014 ui forced to none.");
+  }
+  if (options.darkMode && options.styling !== "tailwind") {
+    warnings.push("Dark mode requires Tailwind \u2014 disabled.");
+  }
+  if (options.apiEnvelope && !options.endpoints) {
+    warnings.push(
+      "API envelope enabled without endpoints: unwrap applies to src/lib/http.ts apiFetch."
+    );
+  }
+  if (options.playwright && !options.testing) {
+    warnings.push("Playwright was requested without Vitest \u2014 enabling testing.");
+  }
+  if (options.store !== "none" && options.data === "tanstack-query") {
+    warnings.push(
+      "Client store + TanStack Query: use Query for server cache; store for UI/session client state only."
+    );
+  }
+  return warnings;
+}
+
+// src/prompts.ts
+import * as p from "@clack/prompts";
+import color from "picocolors";
+
+// src/types.ts
+var DEFAULT_OPTIONS = {
+  packageManager: "pnpm",
+  auth: "none",
+  styling: "none",
+  ui: "none",
+  data: "rsc",
+  store: "none",
+  icons: "none",
+  validation: "zod",
+  i18n: false,
+  darkMode: false,
+  /** Neutral base — enable via preset / flags when building an API client app */
+  apiEnvelope: false,
+  endpoints: false,
+  seo: false,
+  eslint: true,
+  prettier: true,
+  husky: true,
+  docker: false,
+  ci: true,
+  testing: true,
+  playwright: false,
+  noInstall: false
+};
+var ICON_PACKAGES = {
+  lucide: { name: "lucide-react", version: "^0.469.0" },
+  tabler: { name: "@tabler/icons-react", version: "^3.46.0" }
+};
+function normalizeOptions(options) {
+  let next = { ...options };
+  if (next.styling !== "tailwind" && next.ui === "shadcn") {
+    next = { ...next, ui: "none" };
+  }
+  if (next.styling !== "tailwind" && next.darkMode) {
+    next = { ...next, darkMode: false };
+  }
+  if (next.playwright && !next.testing) {
+    next = { ...next, testing: true };
+  }
+  return next;
+}
+
+// src/prompts.ts
+function assertNotCancel(value) {
+  if (p.isCancel(value)) {
+    p.cancel("Scaffold cancelled.");
+    process.exit(0);
+  }
+  return value;
+}
+async function promptCustomOptions(base) {
+  const styling = assertNotCancel(
+    await p.select({
+      message: "Styling system?",
+      options: [
+        { value: "none", label: "None", hint: "plain CSS" },
+        {
+          value: "tailwind",
+          label: "Tailwind CSS",
+          hint: "enables optional shadcn"
+        },
+        {
+          value: "mui",
+          label: "MUI",
+          hint: "no shadcn"
+        }
+      ],
+      initialValue: base.styling
+    })
+  );
+  let ui = "none";
+  let darkMode = false;
+  if (styling === "tailwind") {
+    const useShadcn = assertNotCancel(
+      await p.confirm({
+        message: "Add shadcn/ui?",
+        initialValue: base.ui === "shadcn"
+      })
+    );
+    ui = useShadcn ? "shadcn" : "none";
+    darkMode = assertNotCancel(
+      await p.confirm({
+        message: "Add dark mode (next-themes)?",
+        initialValue: base.darkMode
+      })
+    );
+  }
+  const icons = assertNotCancel(
+    await p.select({
+      message: "Icon library?",
+      options: [
+        { value: "none", label: "None" },
+        { value: "lucide", label: "Lucide" },
+        { value: "tabler", label: "Tabler" }
+      ],
+      initialValue: base.icons
+    })
+  );
+  const validation = assertNotCancel(
+    await p.select({
+      message: "Validation library?",
+      options: [
+        { value: "zod", label: "Zod" },
+        { value: "yup", label: "Yup" }
+      ],
+      initialValue: base.validation
+    })
+  );
+  const useTanstackQuery = assertNotCancel(
+    await p.confirm({
+      message: "Add TanStack Query?",
+      initialValue: base.data === "tanstack-query"
+    })
+  );
+  const needsStore = assertNotCancel(
+    await p.confirm({
+      message: "Add a client store (global UI state)?",
+      initialValue: base.store !== "none"
+    })
+  );
+  let store = "none";
+  if (needsStore) {
+    store = assertNotCancel(
+      await p.select({
+        message: "Which store library?",
+        options: [
+          {
+            value: "zustand",
+            label: "Zustand",
+            hint: "lightweight"
+          },
+          {
+            value: "redux",
+            label: "Redux Toolkit",
+            hint: "structured slices"
+          }
+        ],
+        initialValue: base.store === "redux" ? "redux" : "zustand"
+      })
+    );
+  }
+  const endpoints = assertNotCancel(
+    await p.confirm({
+      message: "Add OpenAPI endpoints codegen?",
+      initialValue: base.endpoints
+    })
+  );
+  let apiEnvelope = base.apiEnvelope;
+  if (endpoints) {
+    apiEnvelope = assertNotCancel(
+      await p.confirm({
+        message: "Unwrap API envelopes in http/axios helpers?",
+        initialValue: true
+      })
+    );
+  } else {
+    apiEnvelope = assertNotCancel(
+      await p.confirm({
+        message: "Unwrap API envelopes in apiFetch (lib/http.ts)?",
+        initialValue: false
+      })
+    );
+  }
+  const auth = assertNotCancel(
+    await p.select({
+      message: "Auth?",
+      options: [
+        { value: "none", label: "None" },
+        {
+          value: "jwt",
+          label: "JWT",
+          hint: "Bearer + refresh"
+        },
+        {
+          value: "authjs",
+          label: "Auth.js",
+          hint: "Credentials demo"
+        }
+      ],
+      initialValue: base.auth
+    })
+  );
+  const seo = assertNotCancel(
+    await p.confirm({
+      message: "Add SEO helpers (sitemap/robots)?",
+      initialValue: base.seo
+    })
+  );
+  const i18n = assertNotCancel(
+    await p.confirm({
+      message: "Add i18n (next-intl)?",
+      initialValue: base.i18n
+    })
+  );
+  const testing = assertNotCancel(
+    await p.confirm({
+      message: "Add Vitest?",
+      initialValue: base.testing
+    })
+  );
+  let playwright = false;
+  if (testing) {
+    playwright = assertNotCancel(
+      await p.confirm({
+        message: "Also add Playwright e2e?",
+        initialValue: base.playwright
+      })
+    );
+  }
+  const eslint = assertNotCancel(
+    await p.confirm({
+      message: "Enhanced ESLint?",
+      initialValue: base.eslint
+    })
+  );
+  const prettier = assertNotCancel(
+    await p.confirm({
+      message: "Add Prettier?",
+      initialValue: base.prettier
+    })
+  );
+  const husky = assertNotCancel(
+    await p.confirm({
+      message: "Add Husky + lint-staged?",
+      initialValue: base.husky
+    })
+  );
+  const docker = assertNotCancel(
+    await p.confirm({
+      message: "Add Docker production image?",
+      initialValue: base.docker
+    })
+  );
+  const ci = assertNotCancel(
+    await p.confirm({
+      message: "Add GitHub Actions CI?",
+      initialValue: base.ci
+    })
+  );
+  return {
+    ...base,
+    styling,
+    ui,
+    darkMode,
+    icons,
+    validation,
+    data: useTanstackQuery ? "tanstack-query" : "rsc",
+    store,
+    endpoints,
+    apiEnvelope,
+    auth,
+    seo,
+    i18n,
+    testing,
+    playwright,
+    eslint,
+    prettier,
+    husky,
+    docker,
+    ci
+  };
+}
+async function runPrompts(initialName) {
+  p.intro(color.bgCyan(color.black(` ${TITLE} `)));
+  const name = assertNotCancel(
+    await p.text({
+      message: "Project name?",
+      placeholder: "my-app",
+      initialValue: initialName ?? "my-app",
+      validate(value) {
+        if (!value.trim()) return "Name is required.";
+        try {
+          slugify(value);
+        } catch (error) {
+          return error instanceof Error ? error.message : "Invalid name.";
+        }
+      }
+    })
+  );
+  const slug = slugify(name);
+  const packageManager = assertNotCancel(
+    await p.select({
+      message: "Package manager?",
+      options: [
+        { value: "pnpm", label: "pnpm", hint: "default" },
+        { value: "npm", label: "npm" },
+        { value: "yarn", label: "yarn", hint: "classic" }
+      ],
+      initialValue: "pnpm"
+    })
+  );
+  const preset = assertNotCancel(
+    await p.select({
+      message: "Preset?",
+      options: [
+        {
+          value: "minimal",
+          label: "Minimal",
+          hint: describePreset("minimal")
+        },
+        {
+          value: "api-app",
+          label: "API app",
+          hint: describePreset("api-app")
+        },
+        {
+          value: "marketing",
+          label: "Marketing / site",
+          hint: describePreset("marketing")
+        },
+        {
+          value: "dashboard",
+          label: "Dashboard",
+          hint: describePreset("dashboard")
+        },
+        {
+          value: "custom",
+          label: "Custom",
+          hint: "answer every question"
+        }
+      ],
+      initialValue: "custom"
+    })
+  );
+  let optionSeed = preset === "custom" ? { ...DEFAULT_OPTIONS, packageManager } : { ...PRESET_SEEDS[preset], packageManager };
+  if (preset === "custom") {
+    optionSeed = await promptCustomOptions(optionSeed);
+  } else {
+    p.note(describePreset(preset), `Preset: ${preset}`);
+    const tweak = assertNotCancel(
+      await p.confirm({
+        message: "Customize this preset further?",
+        initialValue: false
+      })
+    );
+    if (tweak) {
+      optionSeed = await promptCustomOptions(optionSeed);
+    }
+  }
+  const draft = normalizeOptions({
+    name: name.trim(),
+    slug,
+    ...optionSeed,
+    packageManager,
+    noInstall: false
+  });
+  const warnings = collectOptionWarnings(draft);
+  if (warnings.length) {
+    p.log.warn(warnings.join("\n"));
+  }
+  const confirmed = assertNotCancel(
+    await p.confirm({
+      message: `Create ${color.cyan(name)} (${color.dim(slug)})?`,
+      initialValue: true
+    })
+  );
+  if (!confirmed) {
+    p.cancel("Scaffold cancelled.");
+    process.exit(0);
+  }
+  return draft;
+}
+
+// src/scaffold.ts
+import fs27 from "fs-extra";
+import path28 from "path";
+import * as p2 from "@clack/prompts";
+import { execSync } from "child_process";
+import color2 from "picocolors";
+
+// src/helpers/replace-tokens.ts
+import fs from "fs-extra";
+import path2 from "path";
+var TEXT_EXT = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".json",
+  ".md",
+  ".mdc",
+  ".css",
+  ".scss",
+  ".html",
+  ".svg",
+  ".yml",
+  ".yaml",
+  ".toml",
+  ".env",
+  ".example",
+  ".gitignore",
+  ".npmrc"
+]);
+function shouldRewrite(filePath) {
+  const base = path2.basename(filePath);
+  if (base === ".env.example" || base === "LICENSE") return true;
+  const ext = path2.extname(filePath);
+  return TEXT_EXT.has(ext) || base.startsWith(".");
+}
+function applyTokens(contents, tokens) {
+  let out = contents;
+  for (const [key, value] of Object.entries(tokens)) {
+    out = out.split(key).join(value);
+  }
+  return out;
+}
+async function replaceTokensInTree(root, tokens) {
+  const entries = await fs.readdir(root, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path2.join(root, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "node_modules" || entry.name === ".git") continue;
+      await replaceTokensInTree(full, tokens);
+      continue;
+    }
+    if (!shouldRewrite(full)) continue;
+    const raw = await fs.readFile(full, "utf8");
+    const next = applyTokens(raw, tokens);
+    if (next !== raw) {
+      await fs.writeFile(full, next, "utf8");
+    }
+  }
+}
+
+// src/installers/api-envelope.ts
+import fs2 from "fs-extra";
+import path3 from "path";
+var HTTP_ENVELOPE = `import { env } from "@/lib/env";
+
+type ApiEnvelope<T> = {
+  result?: T;
+  status?: number;
+  success?: boolean;
+  messages?: unknown;
+};
+
+function unwrapEnvelope<T>(data: unknown): T {
+  if (data && typeof data === "object" && "result" in data) {
+    const result = (data as ApiEnvelope<T>).result;
+    if (result !== undefined && result !== null) {
+      return result;
+    }
+  }
+  return data as T;
+}
+
+/**
+ * JSON fetch helper that unwraps \`{ result, status, success, messages }\` envelopes.
+ */
+export async function apiFetch<T>(
+  path: string,
+  init?: RequestInit,
+): Promise<T> {
+  const url = path.startsWith("http")
+    ? path
+    : \`\${env.NEXT_PUBLIC_API_URL.replace(/\\/$/, "")}/\${path.replace(/^\\//, "")}\`;
+
+  const response = await fetch(url, {
+    ...init,
+    headers: {
+      Accept: "application/json",
+      ...(init?.headers ?? {}),
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(\`API \${response.status}: \${response.statusText}\`);
+  }
+
+  const json: unknown = await response.json();
+  return unwrapEnvelope<T>(json);
+}
+`;
+var RULE = `---
+description: API envelope unwrap for apiFetch
+globs: src/lib/http.ts
+alwaysApply: false
+---
+
+# API envelope
+
+\`apiFetch\` unwraps \`{ result, status, success, messages }\` when present.
+Prefer generated \`src/endpoints/*\` + axios when endpoints codegen is enabled.
+`;
+var apiEnvelopeInstaller = {
+  id: "api-envelope",
+  active: (o) => o.apiEnvelope,
+  async run({ projectDir, options }) {
+    await fs2.writeFile(
+      path3.join(projectDir, "src", "lib", "http.ts"),
+      HTTP_ENVELOPE,
+      "utf8"
+    );
+    await fs2.writeFile(
+      path3.join(projectDir, ".cursor", "rules", "api-envelope.mdc"),
+      RULE,
+      "utf8"
+    );
+    await fs2.outputFile(
+      path3.join(projectDir, "docs", "style-guide", "http", "envelope.md"),
+      `# API envelope
+
+\`src/lib/http.ts\` \u2192 \`apiFetch\` unwraps \`result\` from standard envelopes.
+${options.endpoints ? "Endpoints/axios: use `unwrapApiResult` from `@/utils/api-result`.\n" : ""}
+`
+    );
+  }
+};
+
+// src/helpers/app-providers.ts
+import fs3 from "fs-extra";
+import path4 from "path";
+function needsAppProviders(options) {
+  return options.data === "tanstack-query" || options.store === "redux" || options.styling === "mui" || options.i18n || options.darkMode;
+}
+function generateAppProvidersSource(options) {
+  const imports = [
+    `"use client";`,
+    ``,
+    `import type { ReactNode } from "react";`
+  ];
+  const props = [`children: ReactNode`];
+  if (options.i18n) {
+    imports.push(`import { NextIntlClientProvider } from "next-intl";`);
+    props.push(`messages: Record<string, unknown>`);
+  }
+  if (options.darkMode) {
+    imports.push(`import { ThemeProvider } from "@/providers/theme-provider";`);
+  }
+  if (options.styling === "mui") {
+    imports.push(`import { MuiProvider } from "@/providers/mui-provider";`);
+  }
+  if (options.store === "redux") {
+    imports.push(`import { StoreProvider } from "@/providers/store-provider";`);
+  }
+  if (options.data === "tanstack-query") {
+    imports.push(`import { QueryProvider } from "@/providers/query-provider";`);
+  }
+  const openers = [];
+  const closers = [];
+  if (options.i18n) {
+    openers.push(`    <NextIntlClientProvider messages={messages}>`);
+    closers.unshift(`    </NextIntlClientProvider>`);
+  }
+  if (options.darkMode) {
+    openers.push(`    <ThemeProvider>`);
+    closers.unshift(`    </ThemeProvider>`);
+  }
+  if (options.styling === "mui") {
+    openers.push(`    <MuiProvider>`);
+    closers.unshift(`    </MuiProvider>`);
+  }
+  if (options.store === "redux") {
+    openers.push(`    <StoreProvider>`);
+    closers.unshift(`    </StoreProvider>`);
+  }
+  if (options.data === "tanstack-query") {
+    openers.push(`    <QueryProvider>`);
+    closers.unshift(`    </QueryProvider>`);
+  }
+  return `${imports.join("\n")}
+
+type AppProvidersProps = {
+  ${props.join(";\n  ")};
+};
+
+/**
+ * Single composition root for client providers.
+ * Feature installers add leaf providers; this file wraps them in a stable order.
+ */
+export function AppProviders({ children${options.i18n ? ", messages" : ""} }: AppProvidersProps) {
+  return (
+${openers.join("\n")}
+      {children}
+${closers.join("\n")}
+  );
+}
+`;
+}
+async function writeAppProviders(projectDir, options) {
+  if (!needsAppProviders(options)) return;
+  const providersDir = path4.join(projectDir, "src", "providers");
+  await fs3.ensureDir(providersDir);
+  await fs3.remove(path4.join(providersDir, ".gitkeep"));
+  await fs3.writeFile(
+    path4.join(providersDir, "app-providers.tsx"),
+    generateAppProvidersSource(options),
+    "utf8"
+  );
+}
+async function wireRootLayout(projectDir, options) {
+  const layoutPath = path4.join(projectDir, "src", "app", "layout.tsx");
+  const useProviders = needsAppProviders(options);
+  const dark = options.darkMode;
+  const i18n = options.i18n;
+  const htmlLang = i18n ? "{locale}" : `"en"`;
+  const htmlExtra = dark ? " suppressHydrationWarning" : "";
+  const imports = [
+    `import type { Metadata } from "next";`,
+    ``,
+    `import "./globals.css";`
+  ];
+  if (useProviders) {
+    imports.push(
+      ``,
+      `import { AppProviders } from "@/providers/app-providers";`
+    );
+  }
+  if (i18n) {
+    imports.push(
+      `import { getLocale, getMessages } from "next-intl/server";`
+    );
+  }
+  const bodyInner = useProviders ? i18n ? `        <AppProviders messages={messages}>
+          <main>{children}</main>
+        </AppProviders>` : `        <AppProviders>
+          <main>{children}</main>
+        </AppProviders>` : `        <main>{children}</main>`;
+  const fnBody = i18n ? `  const locale = await getLocale();
+  const messages = await getMessages();
+
+  return (
+    <html lang=${htmlLang}${htmlExtra}>
+      <body>
+${bodyInner}
+      </body>
+    </html>
+  );` : `  return (
+    <html lang=${htmlLang}${htmlExtra}>
+      <body>
+${bodyInner}
+      </body>
+    </html>
+  );`;
+  const source = `${imports.join("\n")}
+
+export const metadata: Metadata = {
+  title: "__PROJECT_NAME__",
+  description: "Generated with next-style-guide",
+};
+
+export default ${i18n ? "async " : ""}function RootLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+${fnBody}
+}
+`;
+  let final = source;
+  if (await fs3.pathExists(layoutPath)) {
+    const existing = await fs3.readFile(layoutPath, "utf8");
+    const titleMatch = existing.match(/title:\s*"([^"]+)"/);
+    if (titleMatch?.[1] && titleMatch[1] !== "__PROJECT_NAME__") {
+      final = final.replace(
+        'title: "__PROJECT_NAME__"',
+        `title: "${titleMatch[1]}"`
+      );
+    }
+  }
+  await fs3.writeFile(layoutPath, final, "utf8");
+}
+
+// src/installers/app-providers.ts
+var appProvidersInstaller = {
+  id: "app-providers",
+  active: (o) => needsAppProviders(o) || o.i18n || o.darkMode,
+  async run({ projectDir, options }) {
+    await writeAppProviders(projectDir, options);
+    await wireRootLayout(projectDir, options);
+  }
+};
+
+// src/installers/auth-authjs.ts
+import fs5 from "fs-extra";
+import path6 from "path";
+
+// src/helpers/package-json.ts
+import fs4 from "fs-extra";
+import path5 from "path";
+async function readPkg(projectDir) {
+  const pkgPath = path5.join(projectDir, "package.json");
+  const pkg = await fs4.readJson(pkgPath);
+  return { pkgPath, pkg };
+}
+function sortRecord(record) {
+  return Object.fromEntries(
+    Object.entries(record).sort(([a], [b]) => a.localeCompare(b))
+  );
+}
+async function addDependencies(projectDir, deps, kind = "dependencies") {
+  const { pkgPath, pkg } = await readPkg(projectDir);
+  pkg[kind] = sortRecord({
+    ...pkg[kind] ?? {},
+    ...deps
+  });
+  await fs4.writeJson(pkgPath, pkg, { spaces: 2 });
+}
+async function addScripts(projectDir, scripts) {
+  const { pkgPath, pkg } = await readPkg(projectDir);
+  pkg.scripts = {
+    ...pkg.scripts ?? {},
+    ...scripts
+  };
+  await fs4.writeJson(pkgPath, pkg, { spaces: 2 });
+}
+async function mergePackageField(projectDir, field, value) {
+  const { pkgPath, pkg } = await readPkg(projectDir);
+  pkg[field] = value;
+  await fs4.writeJson(pkgPath, pkg, { spaces: 2 });
+}
+async function removeDependencies(projectDir, names, kind = "dependencies") {
+  const { pkgPath, pkg } = await readPkg(projectDir);
+  if (!pkg[kind]) return;
+  for (const name of names) {
+    delete pkg[kind][name];
+  }
+  pkg[kind] = sortRecord(pkg[kind]);
+  await fs4.writeJson(pkgPath, pkg, { spaces: 2 });
+}
+
+// src/installers/auth-authjs.ts
+var AUTH_TS = `import NextAuth from "next-auth";
+import Credentials from "next-auth/providers/credentials";
+
+/**
+ * Auth.js \u2014 Credentials demo provider.
+ * Replace \`authorize\` with your API/DB lookup. Set \`AUTH_SECRET\` in env.
+ */
+export const { handlers, auth, signIn, signOut } = NextAuth({
+  providers: [
+    Credentials({
+      name: "Credentials",
+      credentials: {
+        email: { label: "Email", type: "email" },
+        password: { label: "Password", type: "password" },
+      },
+      async authorize(credentials) {
+        if (!credentials?.email || !credentials?.password) {
+          return null;
+        }
+        // Demo only \u2014 wire to your backend.
+        return {
+          id: "1",
+          email: String(credentials.email),
+          name: "Demo User",
+        };
+      },
+    }),
+  ],
+  pages: {
+    signIn: "/login",
+  },
+  session: { strategy: "jwt" },
+  trustHost: true,
+});
+`;
+var ROUTE = `import { handlers } from "@/lib/auth";
+
+export const { GET, POST } = handlers;
+`;
+var MIDDLEWARE = `import { auth } from "@/lib/auth";
+import { NextResponse } from "next/server";
+
+const publicPaths = ["/login", "/api/auth"];
+
+export default auth((req) => {
+  const { pathname } = req.nextUrl;
+  const isPublic = publicPaths.some(
+    (p) => pathname === p || pathname.startsWith(\`\${p}/\`),
+  );
+
+  if (!req.auth && !isPublic) {
+    const url = new URL("/login", req.nextUrl.origin);
+    url.searchParams.set("callbackUrl", pathname);
+    return NextResponse.redirect(url);
+  }
+
+  if (req.auth && pathname === "/login") {
+    return NextResponse.redirect(new URL("/", req.nextUrl.origin));
+  }
+
+  return NextResponse.next();
+});
+
+export const config = {
+  matcher: ["/((?!_next/static|_next/image|favicon.ico).*)"],
+};
+`;
+var LOGIN_PAGE = `import { Suspense } from "react";
+
+import { LoginForm } from "@/app/login/_components/login-form";
+
+export default function LoginPage() {
+  return (
+    <section className="hero">
+      <h1>Sign in</h1>
+      <p>Auth.js Credentials demo \u2014 replace authorize with your API.</p>
+      <Suspense fallback={<p>Loading\u2026</p>}>
+        <LoginForm />
+      </Suspense>
+    </section>
+  );
+}
+`;
+var LOGIN_FORM = `"use client";
+
+import { useState, type FormEvent } from "react";
+import { signIn } from "next-auth/react";
+import { useRouter, useSearchParams } from "next/navigation";
+
+export function LoginForm() {
+  const router = useRouter();
+  const searchParams = useSearchParams();
+  const callbackUrl = searchParams.get("callbackUrl") ?? "/";
+  const [error, setError] = useState<string | null>(null);
+  const [pending, setPending] = useState(false);
+
+  async function onSubmit(event: FormEvent<HTMLFormElement>) {
+    event.preventDefault();
+    setPending(true);
+    setError(null);
+    const form = new FormData(event.currentTarget);
+    const result = await signIn("credentials", {
+      email: String(form.get("email") ?? ""),
+      password: String(form.get("password") ?? ""),
+      redirect: false,
+    });
+    setPending(false);
+    if (result?.error) {
+      setError("Invalid credentials");
+      return;
+    }
+    router.push(callbackUrl);
+    router.refresh();
+  }
+
+  return (
+    <form onSubmit={onSubmit} className="card" style={{ marginTop: "1.5rem" }}>
+      <label style={{ display: "grid", gap: "0.35rem", marginBottom: "0.75rem" }}>
+        Email
+        <input name="email" type="email" required autoComplete="email" />
+      </label>
+      <label style={{ display: "grid", gap: "0.35rem", marginBottom: "0.75rem" }}>
+        Password
+        <input
+          name="password"
+          type="password"
+          required
+          autoComplete="current-password"
+        />
+      </label>
+      {error ? <p style={{ color: "crimson" }}>{error}</p> : null}
+      <button type="submit" disabled={pending}>
+        {pending ? "Signing in\u2026" : "Sign in"}
+      </button>
+    </form>
+  );
+}
+`;
+var RULE2 = `---
+description: Auth.js (NextAuth) conventions
+globs: src/lib/auth.ts,src/app/api/auth/**/*,src/middleware.ts,src/app/login/**
+alwaysApply: false
+---
+
+# Auth.js
+
+- Config: \`src/lib/auth.ts\` (Credentials demo \u2014 replace \`authorize\`).
+- Route handlers: \`src/app/api/auth/[...nextauth]/route.ts\`.
+- Middleware: \`src/middleware.ts\` protects non-public routes; public: \`/login\`, \`/api/auth\`.
+- Login UI: \`src/app/login/\`.
+- Env: \`AUTH_SECRET\` (required in production).
+- Prefer \`auth()\` in Server Components; \`signIn\` / \`signOut\` on the client.
+`;
+var authAuthjsInstaller = {
+  id: "auth-authjs",
+  active: (o) => o.auth === "authjs",
+  async run({ projectDir }) {
+    await fs5.writeFile(
+      path6.join(projectDir, "src", "lib", "auth.ts"),
+      AUTH_TS,
+      "utf8"
+    );
+    await fs5.outputFile(
+      path6.join(
+        projectDir,
+        "src",
+        "app",
+        "api",
+        "auth",
+        "[...nextauth]",
+        "route.ts"
+      ),
+      ROUTE
+    );
+    await fs5.writeFile(
+      path6.join(projectDir, "src", "middleware.ts"),
+      MIDDLEWARE,
+      "utf8"
+    );
+    await fs5.outputFile(
+      path6.join(projectDir, "src", "app", "login", "page.tsx"),
+      LOGIN_PAGE
+    );
+    await fs5.outputFile(
+      path6.join(
+        projectDir,
+        "src",
+        "app",
+        "login",
+        "_components",
+        "login-form",
+        "index.tsx"
+      ),
+      LOGIN_FORM
+    );
+    await fs5.writeFile(
+      path6.join(projectDir, ".cursor", "rules", "auth.mdc"),
+      RULE2,
+      "utf8"
+    );
+    await fs5.outputFile(
+      path6.join(projectDir, "docs", "style-guide", "auth", "authjs.md"),
+      `# Auth.js
+
+- \`src/lib/auth.ts\` \u2014 Credentials demo (replace \`authorize\`)
+- \`src/app/api/auth/[...nextauth]/route.ts\`
+- \`src/middleware.ts\` \u2014 protect routes; public \`/login\` + \`/api/auth\`
+- \`src/app/login/\` \u2014 sample login page
+- Env: \`AUTH_SECRET\`
+`
+    );
+    const envPath = path6.join(projectDir, ".env.example");
+    if (await fs5.pathExists(envPath)) {
+      let env = await fs5.readFile(envPath, "utf8");
+      if (!env.includes("AUTH_SECRET")) {
+        env += `
+# Auth.js \u2014 generate with: openssl rand -base64 32
+AUTH_SECRET=
+`;
+        await fs5.writeFile(envPath, env, "utf8");
+      }
+    }
+    await addDependencies(projectDir, {
+      "next-auth": "^5.0.0-beta.25"
+    });
+  }
+};
+
+// src/installers/auth-jwt.ts
+import fs6 from "fs-extra";
+import path7 from "path";
+function tokenStorage(slug) {
+  const accessKey = `${slug}.accessToken`;
+  const refreshKey = `${slug}.refreshToken`;
+  return `const ACCESS_TOKEN_KEY = "${accessKey}";
+const REFRESH_TOKEN_KEY = "${refreshKey}";
+
+export type AuthTokens = {
+  access: string;
+  refresh: string;
+};
+
+export function getAccessToken(): string | null {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  return window.localStorage.getItem(ACCESS_TOKEN_KEY);
+}
+
+export function getRefreshToken(): string | null {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  return window.localStorage.getItem(REFRESH_TOKEN_KEY);
+}
+
+export function setTokens({ access, refresh }: AuthTokens) {
+  window.localStorage.setItem(ACCESS_TOKEN_KEY, access);
+  window.localStorage.setItem(REFRESH_TOKEN_KEY, refresh);
+}
+
+export function clearTokens() {
+  if (typeof window === "undefined") {
+    return;
+  }
+  window.localStorage.removeItem(ACCESS_TOKEN_KEY);
+  window.localStorage.removeItem(REFRESH_TOKEN_KEY);
+}
+`;
+}
+var AXIOS_JWT = `import axios, { type AxiosError, type InternalAxiosRequestConfig } from "axios";
+
+import { unwrapApiResult } from "@/utils/api-result";
+import {
+  clearTokens,
+  getAccessToken,
+  getRefreshToken,
+  setTokens,
+} from "@/utils/token-storage";
+
+type RetryConfig = InternalAxiosRequestConfig & { _retry?: boolean };
+
+const baseURL = process.env.NEXT_PUBLIC_API_URL ?? "";
+
+/** Shared Axios client for \`src/endpoints/*\`. Do not call from UI directly. */
+export const api = axios.create({
+  baseURL,
+  headers: {
+    Accept: "application/json",
+    "Content-Type": "application/json",
+  },
+});
+
+api.interceptors.request.use((config) => {
+  const accessToken = getAccessToken();
+  if (accessToken) {
+    config.headers.setAuthorization(\`Bearer \${accessToken}\`);
+  }
+  if (typeof FormData !== "undefined" && config.data instanceof FormData) {
+    config.headers.delete("Content-Type");
+  }
+  return config;
+});
+
+let refreshPromise: Promise<string | null> | null = null;
+
+async function refreshAccessToken(): Promise<string | null> {
+  const refresh = getRefreshToken();
+  if (!refresh || !baseURL) {
+    return null;
+  }
+
+  try {
+    const { data } = await axios.post(\`\${baseURL}/auth/refresh/\`, { refresh });
+    const payload = unwrapApiResult<{ access?: string; refresh?: string }>(data);
+    const access = payload.access;
+    if (!access) {
+      clearTokens();
+      return null;
+    }
+    setTokens({ access, refresh: payload.refresh ?? refresh });
+    return access;
+  } catch {
+    clearTokens();
+    return null;
+  }
+}
+
+function shouldSkipRefresh(url: string | undefined) {
+  if (!url) return false;
+  return (
+    url.includes("/auth/login") ||
+    url.includes("/auth/refresh") ||
+    url.includes("/auth/logout")
+  );
+}
+
+api.interceptors.response.use(
+  (response) => response,
+  async (error: AxiosError) => {
+    const original = error.config as RetryConfig | undefined;
+
+    if (
+      !original ||
+      error.response?.status !== 401 ||
+      original._retry ||
+      shouldSkipRefresh(original.url)
+    ) {
+      return Promise.reject(error);
+    }
+
+    original._retry = true;
+    refreshPromise ??= refreshAccessToken().finally(() => {
+      refreshPromise = null;
+    });
+
+    const access = await refreshPromise;
+    if (!access) {
+      return Promise.reject(error);
+    }
+
+    original.headers.setAuthorization(\`Bearer \${access}\`);
+    return api(original);
+  },
+);
+`;
+var RULE3 = `---
+description: JWT auth (Bearer + refresh) helpers
+globs: src/utils/token-storage.ts,src/utils/axios-instance.ts,src/**/*auth*.{ts,tsx}
+alwaysApply: false
+---
+
+# Auth (JWT)
+
+- Tokens: \`src/utils/token-storage.ts\` (access + refresh in \`localStorage\`).
+- Axios: Bearer on requests; 401 \u2192 \`/auth/refresh/\` once, then retry.
+- Do not store tokens in cookies unless you intentionally change the strategy.
+- Login/logout UI should call \`setTokens\` / \`clearTokens\` \u2014 never invent a second storage key.
+`;
+var authJwtInstaller = {
+  id: "auth-jwt",
+  active: (o) => o.auth === "jwt",
+  async run({ projectDir, options }) {
+    await fs6.ensureDir(path7.join(projectDir, "src", "utils"));
+    await fs6.remove(path7.join(projectDir, "src", "utils", ".gitkeep"));
+    await fs6.writeFile(
+      path7.join(projectDir, "src", "utils", "token-storage.ts"),
+      tokenStorage(options.slug),
+      "utf8"
+    );
+    if (options.endpoints) {
+      await fs6.writeFile(
+        path7.join(projectDir, "src", "utils", "axios-instance.ts"),
+        AXIOS_JWT,
+        "utf8"
+      );
+    }
+    await fs6.writeFile(
+      path7.join(projectDir, ".cursor", "rules", "auth.mdc"),
+      RULE3,
+      "utf8"
+    );
+    await fs6.outputFile(
+      path7.join(projectDir, "docs", "style-guide", "auth", "jwt.md"),
+      `# JWT auth
+
+- \`src/utils/token-storage.ts\` \u2014 access/refresh in localStorage
+- When endpoints are enabled, \`axios-instance\` attaches Bearer and refreshes on 401 via \`POST /auth/refresh/\`
+`
+    );
+  }
+};
+
+// src/installers/ci.ts
+import fs7 from "fs-extra";
+import path8 from "path";
+function workflowYaml(options) {
+  const pm = getPackageManager(options.packageManager);
+  const run = (script) => pm.runScript(script);
+  const setupSteps = [
+    `      - name: Checkout
+        uses: actions/checkout@v4
+`
+  ];
+  if (options.packageManager === "pnpm") {
+    setupSteps.push(`      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+`);
+  }
+  if (options.packageManager === "yarn") {
+    setupSteps.push(`      - name: Enable Corepack
+        run: corepack enable
+`);
+  }
+  setupSteps.push(`      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: ${options.packageManager}
+`);
+  const steps = [
+    ...setupSteps,
+    `      - name: Install
+        run: ${ciInstallCommand(options.packageManager)}
+
+      - name: Typecheck
+        run: ${run("typecheck")}`
+  ];
+  if (options.eslint) {
+    steps.push(`
+      - name: Lint
+        run: ${run("lint")}`);
+  }
+  if (options.prettier) {
+    steps.push(`
+      - name: Format check
+        run: ${run("format:check")}`);
+  }
+  if (options.testing) {
+    steps.push(`
+      - name: Test
+        run: ${run("test")}`);
+  }
+  steps.push(`
+      - name: Build
+        run: ${run("build")}
+        env:
+          NEXT_PUBLIC_APP_URL: http://localhost:3000
+          NEXT_PUBLIC_API_URL: http://localhost:8000`);
+  return `name: CI
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+
+concurrency:
+  group: ci-\${{ github.workflow }}-\${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  checks:
+    name: Checks
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+${steps.join("\n")}
+`;
+}
+var ciInstaller = {
+  id: "ci",
+  active: (o) => o.ci,
+  async run({ projectDir, options }) {
+    const addon = path8.join(ADDONS_DIR, "ci");
+    await fs7.outputFile(
+      path8.join(projectDir, ".github", "workflows", "ci.yml"),
+      workflowYaml(options)
+    );
+    await fs7.copy(
+      path8.join(addon, ".cursor", "rules", "ci.mdc"),
+      path8.join(projectDir, ".cursor", "rules", "ci.mdc")
+    );
+    await fs7.copy(
+      path8.join(addon, "docs", "style-guide", "ops", "ci.md"),
+      path8.join(projectDir, "docs", "style-guide", "ops", "ci.md")
+    );
+  }
+};
+
+// src/installers/dark-mode.ts
+import fs8 from "fs-extra";
+import path9 from "path";
+var THEME_PROVIDER = `"use client";
+
+import { ThemeProvider as NextThemesProvider } from "next-themes";
+import type { ReactNode } from "react";
+
+export function ThemeProvider({ children }: { children: ReactNode }) {
+  return (
+    <NextThemesProvider attribute="class" defaultTheme="system" enableSystem>
+      {children}
+    </NextThemesProvider>
+  );
+}
+`;
+var RULE4 = `---
+description: Dark mode (next-themes) with Tailwind
+globs: src/providers/theme-provider.tsx,src/app/globals.css
+alwaysApply: false
+---
+
+# Dark mode
+
+- \`ThemeProvider\` in \`src/providers/theme-provider.tsx\` (composed via \`AppProviders\`).
+- Tailwind: use \`dark:\` variants; \`html\` gets \`class="dark"\` from next-themes.
+- Prefer \`defaultTheme="system"\`.
+`;
+var darkModeInstaller = {
+  id: "dark-mode",
+  active: (o) => o.darkMode && o.styling === "tailwind",
+  async run({ projectDir }) {
+    const providersDir = path9.join(projectDir, "src", "providers");
+    await fs8.ensureDir(providersDir);
+    await fs8.remove(path9.join(providersDir, ".gitkeep"));
+    await fs8.writeFile(
+      path9.join(providersDir, "theme-provider.tsx"),
+      THEME_PROVIDER,
+      "utf8"
+    );
+    await fs8.writeFile(
+      path9.join(projectDir, ".cursor", "rules", "dark-mode.mdc"),
+      RULE4,
+      "utf8"
+    );
+    await fs8.outputFile(
+      path9.join(projectDir, "docs", "style-guide", "ui", "dark-mode.md"),
+      `# Dark mode
+
+next-themes + Tailwind \`dark:\` variants.
+Provider: \`src/providers/theme-provider.tsx\` (via \`AppProviders\`).
+`
+    );
+    const globalsPath = path9.join(projectDir, "src", "app", "globals.css");
+    if (await fs8.pathExists(globalsPath)) {
+      let css = await fs8.readFile(globalsPath, "utf8");
+      if (!css.includes("@custom-variant dark")) {
+        css = css.replace(
+          `@import "tailwindcss";
+`,
+          `@import "tailwindcss";
+
+@custom-variant dark (&:where(.dark, .dark *));
+`
+        );
+        await fs8.writeFile(globalsPath, css, "utf8");
+      }
+    }
+    await addDependencies(projectDir, {
+      "next-themes": "^0.4.4"
+    });
+  }
+};
+
+// src/installers/docker-compose.ts
+import fs9 from "fs-extra";
+import path10 from "path";
+var COMPOSE = `services:
+  api:
+    image: nginx:alpine
+    ports:
+      - "8000:80"
+    volumes:
+      - ./docker/api-mock:/usr/share/nginx/html:ro
+    # Replace this stub with your real API image when ready.
+    # JWT apps expect NEXT_PUBLIC_API_URL=http://localhost:8000
+
+  # Example (uncomment when you have a backend image):
+  # api:
+  #   image: your-org/api:latest
+  #   ports:
+  #     - "8000:8000"
+  #   environment:
+  #     DATABASE_URL: postgres://...
+`;
+var MOCK_README = `# Local API stub
+
+Placeholder for Docker Compose. Point \`NEXT_PUBLIC_API_URL\` at \`http://localhost:8000\`.
+
+Replace the nginx stub in \`docker-compose.yml\` with your real API service.
+`;
+var RULE5 = `---
+description: Local API via Docker Compose (JWT + endpoints)
+globs: docker-compose.yml,docker/api-mock/**
+alwaysApply: false
+---
+
+# Docker Compose (local API)
+
+- \`docker-compose.yml\` \u2014 stub API on port 8000 for JWT + endpoints apps.
+- \`docker compose up\` then set \`NEXT_PUBLIC_API_URL=http://localhost:8000\`.
+- Swap the stub service for your real backend image before production work.
+`;
+var dockerComposeInstaller = {
+  id: "docker-compose",
+  active: (o) => o.auth === "jwt" && o.endpoints,
+  async run({ projectDir }) {
+    await fs9.writeFile(
+      path10.join(projectDir, "docker-compose.yml"),
+      COMPOSE,
+      "utf8"
+    );
+    await fs9.outputFile(
+      path10.join(projectDir, "docker", "api-mock", "README.md"),
+      MOCK_README
+    );
+    await fs9.writeFile(
+      path10.join(projectDir, ".cursor", "rules", "docker-compose.mdc"),
+      RULE5,
+      "utf8"
+    );
+    await fs9.outputFile(
+      path10.join(projectDir, "docs", "style-guide", "ops", "docker-compose.md"),
+      `# Docker Compose (local API)
+
+\`\`\`bash
+docker compose up
+\`\`\`
+
+Stub listens on \`http://localhost:8000\`. Align with \`NEXT_PUBLIC_API_URL\`.
+`
+    );
+  }
+};
+
+// src/installers/docker.ts
+import fs10 from "fs-extra";
+import path11 from "path";
+var STANDALONE_CONFIG = `import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  reactStrictMode: true,
+  output: "standalone",
+};
+
+export default nextConfig;
+`;
+function dockerfileFor(pm) {
+  if (pm === "npm") {
+    return `# ---------------------------------------------------------------------------- #
+#                        Stage 1: Base & Dependencies                          #
+# ---------------------------------------------------------------------------- #
+FROM node:22-alpine AS builder
+
+RUN apk add --no-cache libc6-compat
+
+WORKDIR /app
+
+ENV HUSKY=0 \\
+    NEXT_TELEMETRY_DISABLED=1
+
+ARG NEXT_PUBLIC_APP_URL=http://localhost:3000
+ARG NEXT_PUBLIC_API_URL=http://localhost:8000
+
+ENV NEXT_PUBLIC_APP_URL=$NEXT_PUBLIC_APP_URL \\
+    NEXT_PUBLIC_API_URL=$NEXT_PUBLIC_API_URL
+
+COPY package.json package-lock.json .npmrc* ./
+RUN --mount=type=cache,id=npm,target=/root/.npm \\
+    npm ci
+
+COPY . /app/
+
+RUN npm run build
+
+# ---------------------------------------------------------------------------- #
+#                        Stage 2: Production Runner                            #
+# ---------------------------------------------------------------------------- #
+FROM node:22-alpine AS runner
+
+RUN apk add --no-cache curl
+
+WORKDIR /app
+
+ENV NODE_ENV=production \\
+    NEXT_TELEMETRY_DISABLED=1 \\
+    HOSTNAME=0.0.0.0 \\
+    PORT=3000
+
+COPY --from=builder /app/public ./public
+COPY --from=builder --chown=node:node /app/.next/standalone ./
+COPY --from=builder --chown=node:node /app/.next/static ./.next/static
+
+USER node
+
+EXPOSE 3000
+
+HEALTHCHECK --interval=30s --timeout=5s --start-period=40s --retries=3 \\
+    CMD curl -fsS http://127.0.0.1:3000/ || exit 1
+
+CMD ["node", "server.js"]
+`;
+  }
+  if (pm === "yarn") {
+    return `# ---------------------------------------------------------------------------- #
+#                        Stage 1: Base & Dependencies                          #
+# ---------------------------------------------------------------------------- #
+FROM node:22-alpine AS builder
+
+RUN apk add --no-cache libc6-compat
+RUN corepack enable && corepack prepare yarn@1.22.22 --activate
+
+WORKDIR /app
+
+ENV HUSKY=0 \\
+    NEXT_TELEMETRY_DISABLED=1
+
+ARG NEXT_PUBLIC_APP_URL=http://localhost:3000
+ARG NEXT_PUBLIC_API_URL=http://localhost:8000
+
+ENV NEXT_PUBLIC_APP_URL=$NEXT_PUBLIC_APP_URL \\
+    NEXT_PUBLIC_API_URL=$NEXT_PUBLIC_API_URL
+
+COPY package.json yarn.lock .npmrc* ./
+RUN --mount=type=cache,id=yarn,target=/usr/local/share/.cache/yarn \\
+    yarn install --frozen-lockfile
+
+COPY . /app/
+
+RUN yarn build
+
+# ---------------------------------------------------------------------------- #
+#                        Stage 2: Production Runner                            #
+# ---------------------------------------------------------------------------- #
+FROM node:22-alpine AS runner
+
+RUN apk add --no-cache curl
+
+WORKDIR /app
+
+ENV NODE_ENV=production \\
+    NEXT_TELEMETRY_DISABLED=1 \\
+    HOSTNAME=0.0.0.0 \\
+    PORT=3000
+
+COPY --from=builder /app/public ./public
+COPY --from=builder --chown=node:node /app/.next/standalone ./
+COPY --from=builder --chown=node:node /app/.next/static ./.next/static
+
+USER node
+
+EXPOSE 3000
+
+HEALTHCHECK --interval=30s --timeout=5s --start-period=40s --retries=3 \\
+    CMD curl -fsS http://127.0.0.1:3000/ || exit 1
+
+CMD ["node", "server.js"]
+`;
+  }
+  return `# ---------------------------------------------------------------------------- #
+#                        Stage 1: Base & Dependencies                          #
+# ---------------------------------------------------------------------------- #
+FROM node:22-alpine AS builder
+
+RUN apk add --no-cache libc6-compat
+RUN corepack enable && corepack prepare pnpm@9.15.0 --activate
+
+WORKDIR /app
+
+ENV HUSKY=0 \\
+    NEXT_TELEMETRY_DISABLED=1
+
+ARG NEXT_PUBLIC_APP_URL=http://localhost:3000
+ARG NEXT_PUBLIC_API_URL=http://localhost:8000
+
+ENV NEXT_PUBLIC_APP_URL=$NEXT_PUBLIC_APP_URL \\
+    NEXT_PUBLIC_API_URL=$NEXT_PUBLIC_API_URL
+
+COPY package.json pnpm-lock.yaml .npmrc* ./
+RUN --mount=type=cache,id=pnpm,target=/root/.local/share/pnpm/store \\
+    pnpm install --frozen-lockfile
+
+COPY . /app/
+
+RUN pnpm build
+
+# ---------------------------------------------------------------------------- #
+#                        Stage 2: Production Runner                            #
+# ---------------------------------------------------------------------------- #
+FROM node:22-alpine AS runner
+
+RUN apk add --no-cache curl
+
+WORKDIR /app
+
+ENV NODE_ENV=production \\
+    NEXT_TELEMETRY_DISABLED=1 \\
+    HOSTNAME=0.0.0.0 \\
+    PORT=3000
+
+COPY --from=builder /app/public ./public
+COPY --from=builder --chown=node:node /app/.next/standalone ./
+COPY --from=builder --chown=node:node /app/.next/static ./.next/static
+
+USER node
+
+EXPOSE 3000
+
+HEALTHCHECK --interval=30s --timeout=5s --start-period=40s --retries=3 \\
+    CMD curl -fsS http://127.0.0.1:3000/ || exit 1
+
+CMD ["node", "server.js"]
+`;
+}
+var dockerInstaller = {
+  id: "docker",
+  active: (o) => o.docker,
+  async run({ projectDir, options }) {
+    const addon = path11.join(ADDONS_DIR, "docker");
+    const pm = getPackageManager(options.packageManager);
+    await fs10.ensureDir(path11.join(projectDir, "docker"));
+    await fs10.writeFile(
+      path11.join(projectDir, "docker", "production.Dockerfile"),
+      dockerfileFor(options.packageManager),
+      "utf8"
+    );
+    await fs10.copy(
+      path11.join(addon, ".dockerignore"),
+      path11.join(projectDir, ".dockerignore")
+    );
+    await fs10.copy(
+      path11.join(addon, ".cursor", "rules", "docker.mdc"),
+      path11.join(projectDir, ".cursor", "rules", "docker.mdc")
+    );
+    let doc = await fs10.readFile(
+      path11.join(addon, "docs", "style-guide", "ops", "docker.md"),
+      "utf8"
+    );
+    doc = doc.replaceAll("__PROJECT_SLUG__", options.slug).replaceAll("__PACKAGE_MANAGER__", pm.id);
+    await fs10.outputFile(
+      path11.join(projectDir, "docs", "style-guide", "ops", "docker.md"),
+      doc
+    );
+    await fs10.writeFile(
+      path11.join(projectDir, "next.config.ts"),
+      STANDALONE_CONFIG,
+      "utf8"
+    );
+  }
+};
+
+// src/installers/endpoints.ts
+import fs11 from "fs-extra";
+import path12 from "path";
+var endpointsInstaller = {
+  id: "endpoints",
+  active: (o) => o.endpoints,
+  async run({ projectDir }) {
+    const addon = path12.join(ADDONS_DIR, "endpoints");
+    await fs11.copy(
+      path12.join(addon, "scripts"),
+      path12.join(projectDir, "scripts")
+    );
+    await fs11.copy(
+      path12.join(addon, "src", "endpoints"),
+      path12.join(projectDir, "src", "endpoints")
+    );
+    for (const file of [
+      "axios-instance.ts",
+      "api-result.ts",
+      "api-error.ts",
+      "search-params.ts",
+      "form-data.ts"
+    ]) {
+      await fs11.copy(
+        path12.join(addon, "src", "utils", file),
+        path12.join(projectDir, "src", "utils", file)
+      );
+    }
+    await fs11.remove(path12.join(projectDir, "src", "utils", ".gitkeep"));
+    await fs11.copy(
+      path12.join(addon, ".cursor", "rules", "endpoints.mdc"),
+      path12.join(projectDir, ".cursor", "rules", "endpoints.mdc")
+    );
+    await fs11.copy(
+      path12.join(addon, "docs", "style-guide", "http", "endpoints.md"),
+      path12.join(projectDir, "docs", "style-guide", "http", "endpoints.md")
+    );
+    await addDependencies(projectDir, { axios: "^1.7.9" });
+    await addDependencies(
+      projectDir,
+      { tsx: "^4.19.2" },
+      "devDependencies"
+    );
+    await addScripts(projectDir, {
+      "endpoints:generate": "tsx scripts/generate-endpoints.ts"
+    });
+  }
+};
+
+// src/installers/eslint.ts
+import fs12 from "fs-extra";
+import path13 from "path";
+var eslintInstaller = {
+  id: "eslint",
+  active: (o) => o.eslint,
+  async run({ projectDir }) {
+    const addon = path13.join(ADDONS_DIR, "eslint");
+    await fs12.copy(
+      path13.join(addon, "eslint.config.mjs"),
+      path13.join(projectDir, "eslint.config.mjs")
+    );
+    await fs12.copy(
+      path13.join(addon, ".cursor", "rules", "eslint.mdc"),
+      path13.join(projectDir, ".cursor", "rules", "eslint.mdc")
+    );
+    await fs12.copy(
+      path13.join(addon, "docs", "style-guide", "tooling", "eslint.md"),
+      path13.join(projectDir, "docs", "style-guide", "tooling", "eslint.md")
+    );
+    await addDependencies(
+      projectDir,
+      {
+        "eslint-config-prettier": "^10.1.8",
+        "eslint-plugin-import": "^2.32.0",
+        "eslint-plugin-simple-import-sort": "^12.1.1"
+      },
+      "devDependencies"
+    );
+    await addScripts(projectDir, {
+      lint: "eslint .",
+      "lint:fix": "eslint . --fix"
+    });
+  }
+};
+
+// src/installers/husky.ts
+import fs13 from "fs-extra";
+import path14 from "path";
+var huskyInstaller = {
+  id: "husky",
+  active: (o) => o.husky,
+  async run({ projectDir, options }) {
+    const addon = path14.join(ADDONS_DIR, "husky");
+    await fs13.copy(path14.join(addon, ".husky"), path14.join(projectDir, ".husky"));
+    await fs13.copy(
+      path14.join(addon, "docs", "style-guide", "tooling", "husky.md"),
+      path14.join(projectDir, "docs", "style-guide", "tooling", "husky.md")
+    );
+    try {
+      await fs13.chmod(path14.join(projectDir, ".husky", "pre-commit"), 493);
+    } catch {
+    }
+    await addDependencies(
+      projectDir,
+      {
+        husky: "^9.1.7",
+        "lint-staged": "^15.2.11"
+      },
+      "devDependencies"
+    );
+    await addScripts(projectDir, { prepare: "husky" });
+    const tsHooks = [];
+    if (options.prettier) tsHooks.push("prettier --write");
+    if (options.eslint) tsHooks.push("eslint --fix");
+    if (tsHooks.length === 0) tsHooks.push("echo 'husky: no lint/format tools'");
+    const lintStaged = {
+      "*.{js,jsx,ts,tsx}": tsHooks
+    };
+    if (options.prettier) {
+      lintStaged["*.{json,css,scss,md,yaml,yml}"] = ["prettier --write"];
+    }
+    await mergePackageField(projectDir, "lint-staged", lintStaged);
+  }
+};
+
+// src/installers/i18n.ts
+import fs14 from "fs-extra";
+import path15 from "path";
+var I18N_REQUEST = `import { getRequestConfig } from "next-intl/server";
+
+export default getRequestConfig(async () => {
+  const locale = "en";
+  return {
+    locale,
+    messages: (await import(\`../../messages/\${locale}.json\`)).default,
+  };
+});
+`;
+var MESSAGES_EN = `{
+  "Home": {
+    "title": "Welcome",
+    "body": "Scaffolded with next-style-guide."
+  }
+}
+`;
+var RULE6 = `---
+description: next-intl i18n conventions
+globs: src/i18n/**,messages/**,src/providers/app-providers.tsx
+alwaysApply: false
+---
+
+# i18n (next-intl)
+
+- Request config: \`src/i18n/request.ts\`.
+- Messages: \`messages/<locale>.json\`.
+- Prefer \`useTranslations\` / \`getTranslations\` \u2014 avoid hardcoded copy when a key exists.
+- \`NextIntlClientProvider\` is composed in \`AppProviders\`; root layout loads locale/messages.
+`;
+var i18nInstaller = {
+  id: "i18n",
+  active: (o) => o.i18n,
+  async run({ projectDir }) {
+    await fs14.outputFile(
+      path15.join(projectDir, "src", "i18n", "request.ts"),
+      I18N_REQUEST
+    );
+    await fs14.outputFile(
+      path15.join(projectDir, "messages", "en.json"),
+      MESSAGES_EN
+    );
+    await fs14.writeFile(
+      path15.join(projectDir, ".cursor", "rules", "i18n.mdc"),
+      RULE6,
+      "utf8"
+    );
+    await fs14.outputFile(
+      path15.join(projectDir, "docs", "style-guide", "i18n", "overview.md"),
+      `# i18n
+
+next-intl: \`src/i18n/request.ts\` + \`messages/en.json\`
+Plugin wired in \`next.config.ts\`. Provider via \`AppProviders\`.
+`
+    );
+    const nextConfigPath = path15.join(projectDir, "next.config.ts");
+    if (await fs14.pathExists(nextConfigPath)) {
+      let nextConfig = await fs14.readFile(nextConfigPath, "utf8");
+      if (!nextConfig.includes("next-intl")) {
+        if (!nextConfig.includes("createNextIntlPlugin")) {
+          nextConfig = `import createNextIntlPlugin from "next-intl/plugin";
+
+const withNextIntl = createNextIntlPlugin("./src/i18n/request.ts");
+
+${nextConfig}`;
+        }
+        nextConfig = nextConfig.replace(
+          "export default nextConfig;",
+          "export default withNextIntl(nextConfig);"
+        );
+        await fs14.writeFile(nextConfigPath, nextConfig, "utf8");
+      }
+    }
+    await addDependencies(projectDir, {
+      "next-intl": "^3.26.3"
+    });
+  }
+};
+
+// src/installers/icons.ts
+import fs15 from "fs-extra";
+import path16 from "path";
+var RULE7 = `---
+description: Icon library conventions
+globs: "src/**/*.{ts,tsx}"
+alwaysApply: false
+---
+
+# Icons
+
+__ICONS_BODY__
+`;
+var BODIES = {
+  lucide: `- Use \`lucide-react\` icons (\`import { IconName } from "lucide-react"\`).
+- Prefer Lucide when adding shadcn primitives later.`,
+  tabler: `- Use \`@tabler/icons-react\` with the \`Icon*\` prefix (\`import { IconHome } from "@tabler/icons-react"\`).
+- Do not mix Lucide and Tabler in the same app.`
+};
+var iconsInstaller = {
+  id: "icons",
+  active: (o) => o.icons !== "none",
+  async run({ projectDir, options }) {
+    if (options.icons === "none") return;
+    const pkg = ICON_PACKAGES[options.icons];
+    await addDependencies(projectDir, { [pkg.name]: pkg.version });
+    const ruleDir = path16.join(projectDir, ".cursor", "rules");
+    await fs15.ensureDir(ruleDir);
+    await fs15.writeFile(
+      path16.join(ruleDir, "icons.mdc"),
+      RULE7.replace("__ICONS_BODY__", BODIES[options.icons]),
+      "utf8"
+    );
+  }
+};
+
+// src/installers/mui.ts
+import fs16 from "fs-extra";
+import path17 from "path";
+var THEME_PROVIDER2 = `"use client";
+
+import { type ReactNode } from "react";
+
+import { CssBaseline, ThemeProvider, createTheme } from "@mui/material";
+import { AppRouterCacheProvider } from "@mui/material-nextjs/v15-appRouter";
+
+const theme = createTheme({
+  cssVariables: true,
+  palette: {
+    mode: "light",
+    primary: { main: "#0b5fff" },
+  },
+});
+
+export function MuiProvider({ children }: { children: ReactNode }) {
+  return (
+    <AppRouterCacheProvider>
+      <ThemeProvider theme={theme}>
+        <CssBaseline />
+        {children}
+      </ThemeProvider>
+    </AppRouterCacheProvider>
+  );
+}
+`;
+var RULE8 = `---
+description: MUI (Material UI) conventions
+globs: src/providers/mui-provider.tsx,src/**/*.{ts,tsx}
+alwaysApply: false
+---
+
+# MUI
+
+- Theme via \`MuiProvider\` (\`src/providers/mui-provider.tsx\`), composed in \`AppProviders\`.
+- Prefer MUI components (\`Button\`, \`TextField\`, \`Stack\`, \u2026) over ad-hoc CSS.
+- Do not add shadcn \u2014 incompatible with this styling choice.
+- Emotion cache: \`@mui/material-nextjs\` App Router provider (already wired).
+`;
+var muiInstaller = {
+  id: "mui",
+  active: (o) => o.styling === "mui",
+  async run({ projectDir }) {
+    const providersDir = path17.join(projectDir, "src", "providers");
+    await fs16.ensureDir(providersDir);
+    await fs16.remove(path17.join(providersDir, ".gitkeep"));
+    await fs16.writeFile(
+      path17.join(providersDir, "mui-provider.tsx"),
+      THEME_PROVIDER2,
+      "utf8"
+    );
+    await fs16.writeFile(
+      path17.join(projectDir, ".cursor", "rules", "mui.mdc"),
+      RULE8,
+      "utf8"
+    );
+    await addDependencies(projectDir, {
+      "@mui/material": "^6.4.0",
+      "@mui/material-nextjs": "^6.4.0",
+      "@emotion/react": "^11.14.0",
+      "@emotion/styled": "^11.14.0",
+      "@emotion/cache": "^11.14.0"
+    });
+  }
+};
+
+// src/installers/package-manager.ts
+import fs17 from "fs-extra";
+import path18 from "path";
+var packageManagerInstaller = {
+  id: "package-manager",
+  active: () => true,
+  async run({ projectDir, options }) {
+    const meta = getPackageManager(options.packageManager);
+    const pkgPath = path18.join(projectDir, "package.json");
+    const pkg = await fs17.readJson(pkgPath);
+    if (meta.packageManagerField) {
+      pkg.packageManager = meta.packageManagerField;
+    } else {
+      delete pkg.packageManager;
+    }
+    await fs17.writeJson(pkgPath, pkg, { spaces: 2 });
+  }
+};
+
+// src/installers/prettier.ts
+import fs18 from "fs-extra";
+import path19 from "path";
+var prettierInstaller = {
+  id: "prettier",
+  active: (o) => o.prettier,
+  async run({ projectDir }) {
+    const addon = path19.join(ADDONS_DIR, "prettier");
+    await fs18.copy(
+      path19.join(addon, ".prettierrc"),
+      path19.join(projectDir, ".prettierrc")
+    );
+    await fs18.copy(
+      path19.join(addon, ".cursor", "rules", "prettier.mdc"),
+      path19.join(projectDir, ".cursor", "rules", "prettier.mdc")
+    );
+    await fs18.copy(
+      path19.join(addon, "docs", "style-guide", "tooling", "prettier.md"),
+      path19.join(projectDir, "docs", "style-guide", "tooling", "prettier.md")
+    );
+    await addDependencies(
+      projectDir,
+      { prettier: "^3.6.2" },
+      "devDependencies"
+    );
+    await addScripts(projectDir, {
+      format: "prettier --write .",
+      "format:check": "prettier --check ."
+    });
+  }
+};
+
+// src/installers/seo.ts
+import fs19 from "fs-extra";
+import path20 from "path";
+var SEO_TS = `import type { Metadata } from "next";
+
+import { env } from "@/lib/env";
+
+export const SITE_NAME = process.env.NEXT_PUBLIC_SITE_NAME?.trim() || "__PROJECT_NAME__";
+export const DEFAULT_DESCRIPTION =
+  process.env.NEXT_PUBLIC_SITE_DESCRIPTION?.trim() ||
+  "Generated with next-style-guide";
+
+/** Absolute public origin (no trailing slash). */
+export function getAppUrl(): string {
+  try {
+    return new URL(env.NEXT_PUBLIC_APP_URL).origin;
+  } catch {
+    return "http://localhost:3000";
+  }
+}
+
+export function absoluteUrl(path: string): string {
+  const base = getAppUrl();
+  if (!path || path === "/") return base;
+  return \`\${base}\${path.startsWith("/") ? path : \`/\${path}\`}\`;
+}
+
+export type SitemapChangeFrequency =
+  | "always"
+  | "hourly"
+  | "daily"
+  | "weekly"
+  | "monthly"
+  | "yearly"
+  | "never";
+
+export function buildPublicMetadata(input: {
+  title: string;
+  description: string;
+  path: string;
+  absoluteTitle?: string;
+  noIndex?: boolean;
+}): Metadata {
+  const url = absoluteUrl(input.path);
+  return {
+    title: input.absoluteTitle ?? input.title,
+    description: input.description,
+    alternates: { canonical: url },
+    openGraph: {
+      title: input.absoluteTitle ?? input.title,
+      description: input.description,
+      url,
+      siteName: SITE_NAME,
+      type: "website",
+    },
+    robots: input.noIndex
+      ? { index: false, follow: false }
+      : { index: true, follow: true },
+  };
+}
+`;
+var PUBLIC_ROUTES = `import {
+  buildPublicMetadata,
+  DEFAULT_DESCRIPTION,
+  SITE_NAME,
+  type SitemapChangeFrequency,
+} from "@/lib/seo";
+
+/**
+ * Indexable URLs \u2014 single source of truth for sitemap + page metadata.
+ * Add a route under \`src/app/\`, then register it here.
+ */
+export type PublicRoute = {
+  path: string;
+  title: string;
+  description: string;
+  absoluteTitle?: string;
+  changeFrequency: SitemapChangeFrequency;
+  priority: number;
+  lastModified?: string;
+  noIndex?: boolean;
+};
+
+export const STATIC_PUBLIC_ROUTES: PublicRoute[] = [
+  {
+    path: "/",
+    title: SITE_NAME,
+    description: DEFAULT_DESCRIPTION,
+    changeFrequency: "weekly",
+    priority: 1,
+    lastModified: "2026-01-01",
+  },
+];
+
+export function publicPageMetadata(path: string) {
+  const route = STATIC_PUBLIC_ROUTES.find((item) => item.path === path);
+  if (!route) {
+    throw new Error(\`Missing public route registration for \${path}\`);
+  }
+  return buildPublicMetadata(route);
+}
+`;
+var SITEMAP = `import type { MetadataRoute } from "next";
+
+import { absoluteUrl } from "@/lib/seo";
+import { STATIC_PUBLIC_ROUTES } from "@/lib/public-routes";
+
+export default function sitemap(): MetadataRoute.Sitemap {
+  return STATIC_PUBLIC_ROUTES.filter((route) => !route.noIndex).map((route) => ({
+    url: absoluteUrl(route.path),
+    lastModified: route.lastModified,
+    changeFrequency: route.changeFrequency,
+    priority: route.priority,
+  }));
+}
+`;
+var ROBOTS = `import type { MetadataRoute } from "next";
+
+import { getAppUrl } from "@/lib/seo";
+
+export default function robots(): MetadataRoute.Robots {
+  const origin = getAppUrl();
+  return {
+    rules: {
+      userAgent: "*",
+      allow: "/",
+    },
+    sitemap: \`\${origin}/sitemap.xml\`,
+  };
+}
+`;
+var RULE9 = `---
+description: SEO + public routes
+globs: src/lib/public-routes.ts,src/lib/seo.ts,src/app/sitemap.ts,src/app/robots.ts,src/app/**/page.tsx
+alwaysApply: false
+---
+
+# SEO
+
+- Register every indexable path in \`STATIC_PUBLIC_ROUTES\` (\`src/lib/public-routes.ts\`).
+- Page metadata: \`publicPageMetadata("/path")\` \u2014 keep canonical/title/description in sync.
+- \`sitemap.ts\` / \`robots.ts\` read from that registry \u2014 don't hardcode URLs twice.
+- Single \`<main>\` in root layout only.
+- Placeholders / thin pages: \`noIndex: true\` and keep them out of the sitemap.
+- Prefer static \`lastModified\` dates over \`new Date()\` for every route.
+`;
+var seoInstaller = {
+  id: "seo",
+  active: (o) => o.seo,
+  async run({ projectDir, options }) {
+    let seo = SEO_TS.replaceAll("__PROJECT_NAME__", options.name);
+    await fs19.writeFile(path20.join(projectDir, "src", "lib", "seo.ts"), seo, "utf8");
+    await fs19.writeFile(
+      path20.join(projectDir, "src", "lib", "public-routes.ts"),
+      PUBLIC_ROUTES,
+      "utf8"
+    );
+    await fs19.writeFile(
+      path20.join(projectDir, "src", "app", "sitemap.ts"),
+      SITEMAP,
+      "utf8"
+    );
+    await fs19.writeFile(
+      path20.join(projectDir, "src", "app", "robots.ts"),
+      ROBOTS,
+      "utf8"
+    );
+    await fs19.writeFile(
+      path20.join(projectDir, ".cursor", "rules", "seo.mdc"),
+      RULE9,
+      "utf8"
+    );
+    await fs19.outputFile(
+      path20.join(projectDir, "docs", "style-guide", "seo", "overview.md"),
+      `# SEO
+
+- Registry: \`src/lib/public-routes.ts\`
+- Helpers: \`src/lib/seo.ts\`
+- \`sitemap.ts\` / \`robots.ts\` under \`src/app/\`
+
+Add a page \u2192 register the path \u2192 metadata/sitemap update automatically.
+`
+    );
+  }
+};
+
+// src/installers/shadcn.ts
+import fs20 from "fs-extra";
+import path21 from "path";
+function componentsJson(iconLibrary) {
+  return `${JSON.stringify(
+    {
+      $schema: "https://ui.shadcn.com/schema.json",
+      style: "new-york",
+      rsc: true,
+      tsx: true,
+      tailwind: {
+        config: "",
+        css: "src/app/globals.css",
+        baseColor: "neutral",
+        cssVariables: true,
+        prefix: ""
+      },
+      iconLibrary,
+      aliases: {
+        components: "@/components",
+        utils: "@/lib/utils",
+        ui: "@/components/ui",
+        lib: "@/lib",
+        hooks: "@/hooks"
+      }
+    },
+    null,
+    2
+  )}
+`;
+}
+var BUTTON = `import { cva, type VariantProps } from "class-variance-authority";
+import type { ComponentProps } from "react";
+
+import { cn } from "@/lib/utils";
+
+const buttonVariants = cva(
+  "inline-flex items-center justify-center gap-2 rounded-md text-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50",
+  {
+    variants: {
+      variant: {
+        default: "bg-neutral-900 text-white hover:bg-neutral-800",
+        outline: "border border-neutral-300 bg-transparent hover:bg-neutral-100",
+        ghost: "hover:bg-neutral-100",
+      },
+      size: {
+        default: "h-9 px-4 py-2",
+        sm: "h-8 rounded-md px-3 text-xs",
+        lg: "h-10 rounded-md px-6",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default",
+    },
+  },
+);
+
+export function Button({
+  className,
+  variant,
+  size,
+  ...props
+}: ComponentProps<"button"> & VariantProps<typeof buttonVariants>) {
+  return (
+    <button className={cn(buttonVariants({ variant, size, className }))} {...props} />
+  );
+}
+`;
+var RULE10 = `---
+description: shadcn/ui conventions
+globs: components.json,src/components/ui/**,src/lib/utils.ts
+alwaysApply: false
+---
+
+# shadcn
+
+- Primitives live flat in \`src/components/ui/*\` (CLI-compatible).
+- Starter \`Button\` is included \u2014 add more with \`npx shadcn@latest add \u2026\`.
+- \`cn()\` from \`@/lib/utils\` for class merging.
+- Config: \`components.json\`. Requires Tailwind.
+`;
+var shadcnInstaller = {
+  id: "shadcn",
+  active: (o) => o.ui === "shadcn" && o.styling === "tailwind",
+  async run({ projectDir, options }) {
+    const iconLibrary = options.icons === "tabler" ? "tabler" : "lucide";
+    await fs20.writeFile(
+      path21.join(projectDir, "components.json"),
+      componentsJson(iconLibrary),
+      "utf8"
+    );
+    await fs20.ensureDir(path21.join(projectDir, "src", "components", "ui"));
+    await fs20.writeFile(
+      path21.join(projectDir, "src", "components", "ui", "button.tsx"),
+      BUTTON,
+      "utf8"
+    );
+    await fs20.remove(path21.join(projectDir, "src", "components", "ui", ".gitkeep"));
+    await fs20.remove(path21.join(projectDir, "src", "components", ".gitkeep"));
+    await fs20.writeFile(
+      path21.join(projectDir, ".cursor", "rules", "shadcn.mdc"),
+      RULE10,
+      "utf8"
+    );
+    if (options.icons === "none") {
+      await addDependencies(projectDir, {
+        "lucide-react": "^0.469.0"
+      });
+    }
+    await addDependencies(projectDir, {
+      "class-variance-authority": "^0.7.1"
+    });
+  }
+};
+
+// src/installers/store.ts
+import fs21 from "fs-extra";
+import path22 from "path";
+var ZUSTAND_STORE = `import { create } from "zustand";
+
+type AppState = {
+  hydrated: boolean;
+  setHydrated: (value: boolean) => void;
+};
+
+/** App-wide client store \u2014 extend slices as the product grows. */
+export const useAppStore = create<AppState>((set) => ({
+  hydrated: false,
+  setHydrated: (value) => set({ hydrated: value }),
+}));
+`;
+var ZUSTAND_RULE = `---
+description: Zustand client store conventions
+globs: src/stores/**
+alwaysApply: false
+---
+
+# Zustand
+
+- Stores live under \`src/stores/\` (one file per domain slice when possible).
+- Prefer small selectors: \`useAppStore((s) => s.hydrated)\`.
+- Do not put server secrets or tokens in the client store.
+- Server Components stay free of store hooks \u2014 pass data down or use a client leaf.
+`;
+var REDUX_STORE = `import { configureStore, createSlice, type PayloadAction } from "@reduxjs/toolkit";
+
+type AppSliceState = {
+  hydrated: boolean;
+};
+
+const initialState: AppSliceState = {
+  hydrated: false,
+};
+
+const appSlice = createSlice({
+  name: "app",
+  initialState,
+  reducers: {
+    setHydrated(state, action: PayloadAction<boolean>) {
+      state.hydrated = action.payload;
+    },
+  },
+});
+
+export const { setHydrated } = appSlice.actions;
+
+export const makeStore = () =>
+  configureStore({
+    reducer: {
+      app: appSlice.reducer,
+    },
+  });
+
+export type AppStore = ReturnType<typeof makeStore>;
+export type RootState = ReturnType<AppStore["getState"]>;
+export type AppDispatch = AppStore["dispatch"];
+`;
+var REDUX_HOOKS = `import { useDispatch, useSelector, useStore } from "react-redux";
+
+import type { AppDispatch, AppStore, RootState } from "@/stores/store";
+
+export const useAppDispatch = useDispatch.withTypes<AppDispatch>();
+export const useAppSelector = useSelector.withTypes<RootState>();
+export const useAppStore = useStore.withTypes<AppStore>();
+`;
+var REDUX_PROVIDER = `"use client";
+
+import { type ReactNode, useRef } from "react";
+import { Provider } from "react-redux";
+
+import { makeStore, type AppStore } from "@/stores/store";
+
+export function StoreProvider({ children }: { children: ReactNode }) {
+  const storeRef = useRef<AppStore | null>(null);
+  if (!storeRef.current) {
+    storeRef.current = makeStore();
+  }
+
+  return <Provider store={storeRef.current}>{children}</Provider>;
+}
+`;
+var REDUX_RULE = `---
+description: Redux Toolkit client store conventions
+globs: src/stores/**,src/providers/store-provider.tsx
+alwaysApply: false
+---
+
+# Redux Toolkit
+
+- Store factory: \`src/stores/store.ts\` (\`makeStore\`).
+- Typed hooks: \`src/stores/hooks.ts\` (\`useAppDispatch\` / \`useAppSelector\`).
+- Provider: \`src/providers/store-provider.tsx\` (composed via \`AppProviders\`).
+- Prefer RTK slices; keep server secrets out of the client store.
+`;
+var storeInstaller = {
+  id: "store",
+  active: (o) => o.store !== "none",
+  async run({ projectDir, options }) {
+    const storesDir = path22.join(projectDir, "src", "stores");
+    await fs21.ensureDir(storesDir);
+    if (options.store === "zustand") {
+      await fs21.writeFile(
+        path22.join(storesDir, "app-store.ts"),
+        ZUSTAND_STORE,
+        "utf8"
+      );
+      await fs21.writeFile(
+        path22.join(projectDir, ".cursor", "rules", "store.mdc"),
+        ZUSTAND_RULE,
+        "utf8"
+      );
+      await fs21.outputFile(
+        path22.join(projectDir, "docs", "style-guide", "state", "zustand.md"),
+        `# Zustand
+
+- Store: \`src/stores/app-store.ts\`
+- Extend with domain slices under \`src/stores/\`
+`
+      );
+      await addDependencies(projectDir, { zustand: "^5.0.3" });
+      return;
+    }
+    await fs21.writeFile(path22.join(storesDir, "store.ts"), REDUX_STORE, "utf8");
+    await fs21.writeFile(path22.join(storesDir, "hooks.ts"), REDUX_HOOKS, "utf8");
+    const providersDir = path22.join(projectDir, "src", "providers");
+    await fs21.ensureDir(providersDir);
+    await fs21.remove(path22.join(providersDir, ".gitkeep"));
+    await fs21.writeFile(
+      path22.join(providersDir, "store-provider.tsx"),
+      REDUX_PROVIDER,
+      "utf8"
+    );
+    await fs21.writeFile(
+      path22.join(projectDir, ".cursor", "rules", "store.mdc"),
+      REDUX_RULE,
+      "utf8"
+    );
+    await fs21.outputFile(
+      path22.join(projectDir, "docs", "style-guide", "state", "redux.md"),
+      `# Redux Toolkit
+
+- Store: \`src/stores/store.ts\`
+- Hooks: \`src/stores/hooks.ts\`
+- Provider: \`src/providers/store-provider.tsx\` (via \`AppProviders\`)
+`
+    );
+    await addDependencies(projectDir, {
+      "@reduxjs/toolkit": "^2.5.1",
+      "react-redux": "^9.2.0"
+    });
+  }
+};
+
+// src/installers/surface.ts
+import fs22 from "fs-extra";
+import path23 from "path";
+function stackLines(options) {
+  const stylingLabel = options.styling === "tailwind" ? options.ui === "shadcn" ? "Tailwind + shadcn/ui" : "Tailwind CSS" : options.styling === "mui" ? "MUI" : "Plain CSS";
+  return [
+    `Package manager: ${options.packageManager}`,
+    `Styling: ${stylingLabel}`,
+    `Validation: ${options.validation}`,
+    `Auth: ${options.auth}`,
+    options.store === "none" ? "No client store" : `Client store: ${options.store}`,
+    options.darkMode ? "Dark mode (next-themes)" : "No dark mode",
+    options.seo ? "SEO helpers (sitemap/robots)" : "No SEO helpers",
+    options.data === "tanstack-query" ? "TanStack Query enabled" : "RSC / fetch (no TanStack Query)",
+    options.icons === "none" ? "No icon library" : `Icons: ${options.icons}`,
+    options.endpoints ? `OpenAPI endpoints codegen (\`${options.packageManager} endpoints:generate\`)` : "No endpoints codegen",
+    options.apiEnvelope ? "API envelope unwrap" : "No envelope unwrap",
+    options.i18n ? "i18n (next-intl)" : "No i18n",
+    options.testing ? options.playwright ? "Vitest + Playwright" : "Vitest" : "No tests",
+    options.eslint ? "Enhanced ESLint" : "Minimal ESLint",
+    options.prettier ? "Prettier" : "No Prettier",
+    options.husky ? "Husky + lint-staged" : "No git hooks",
+    options.docker ? "Docker standalone image" : "No Docker",
+    options.ci ? "GitHub Actions CI" : "No CI workflow"
+  ];
+}
+function welcomeCardSource(options) {
+  const items = stackLines(options).map((line) => `        <li>${escapeJsx(line)}</li>`).join("\n");
+  return `/** Homepage sample \u2014 reflects scaffold choices; replace with real UI. */
+export function WelcomeCard() {
+  return (
+    <div className="card">
+      <h2>Your scaffold</h2>
+      <ul>
+${items}
+      </ul>
+      <p className="meta" style={{ marginTop: "1rem" }}>
+        Route UI \u2192 <code>src/app/&lt;route&gt;/_components/</code> \xB7 shared \u2192{" "}
+        <code>src/components/</code>
+      </p>
+    </div>
+  );
+}
+`;
+}
+function escapeJsx(text2) {
+  return text2.replaceAll("`", "\\`");
+}
+function homePageSource(options) {
+  const uiBit = options.ui === "shadcn" ? " \xB7 ui=<code>shadcn</code>" : "";
+  return `import { WelcomeCard } from "@/app/_components/welcome-card";
+
+export default function HomePage() {
+  return (
+    <>
+      <section className="hero">
+        <h1>${options.name}</h1>
+        <p>
+          Scaffolded with <strong>next-style-guide</strong> (Next.js 16).
+          styling=<code>${options.styling}</code>${uiBit} \xB7 validation=
+          <code>${options.validation}</code> \xB7 icons=<code>${options.icons}</code> \xB7
+          data=<code>${options.data}</code>.
+        </p>
+      </section>
+
+      <WelcomeCard />
+
+      <p className="meta">
+        Read <code>AGENTS.md</code> and <code>docs/style-guide/</code> before
+        adding routes. Feature rules in <code>.cursor/rules/</code> load by glob.
+      </p>
+    </>
+  );
+}
+`;
+}
+function docsIndex(options) {
+  const rows = [
+    [
+      "[Architecture](overview/architecture.md)",
+      "Layers: app / components / lib / utils"
+    ],
+    ["[Project structure](overview/project-structure.md)", "Folder map"],
+    ["[HTTP client](http/client.md)", "`apiFetch` helper"],
+    [
+      `[Validation](validation/${options.validation}.md)`,
+      options.validation.toUpperCase()
+    ]
+  ];
+  if (options.auth === "jwt") {
+    rows.push(["[JWT auth](auth/jwt.md)", "token-storage + Bearer refresh"]);
+  }
+  if (options.auth === "authjs") {
+    rows.push(["[Auth.js](auth/authjs.md)", "NextAuth stub"]);
+  }
+  if (options.store === "zustand") {
+    rows.push(["[Zustand](state/zustand.md)", "client store"]);
+  }
+  if (options.store === "redux") {
+    rows.push(["[Redux Toolkit](state/redux.md)", "client store"]);
+  }
+  if (options.darkMode) {
+    rows.push(["[Dark mode](ui/dark-mode.md)", "next-themes"]);
+  }
+  if (options.auth === "jwt" && options.endpoints) {
+    rows.push([
+      "[Docker Compose](ops/docker-compose.md)",
+      "local API stub"
+    ]);
+  }
+  if (options.seo) {
+    rows.push(["[SEO](seo/overview.md)", "public-routes \xB7 sitemap \xB7 robots"]);
+  }
+  if (options.i18n) {
+    rows.push(["[i18n](i18n/overview.md)", "next-intl"]);
+  }
+  if (options.apiEnvelope) {
+    rows.push(["[API envelope](http/envelope.md)", "unwrap result"]);
+  }
+  if (options.testing) {
+    rows.push(["[Testing](tooling/testing.md)", "Vitest"]);
+  }
+  if (options.styling === "tailwind") {
+    rows.push(["Tailwind", "See `.cursor/rules/tailwind.mdc`"]);
+  }
+  if (options.ui === "shadcn") {
+    rows.push(["shadcn/ui", "See `.cursor/rules/shadcn.mdc` + `components.json`"]);
+  }
+  if (options.styling === "mui") {
+    rows.push(["MUI", "See `.cursor/rules/mui.mdc`"]);
+  }
+  if (options.endpoints) {
+    rows.push([
+      "[OpenAPI endpoints](http/endpoints.md)",
+      `\`${options.packageManager} endpoints:generate\``
+    ]);
+  }
+  if (options.data === "tanstack-query") {
+    rows.push([
+      "[TanStack Query](data/tanstack-query.md)",
+      "Client cache + QueryProvider"
+    ]);
+  }
+  if (options.icons !== "none") {
+    rows.push(["[Icons](ui/icons.md)", `Icon library (${options.icons})`]);
+  }
+  if (options.eslint) {
+    rows.push(["[ESLint](tooling/eslint.md)", "Import sort + style rules"]);
+  }
+  if (options.prettier) {
+    rows.push(["[Prettier](tooling/prettier.md)", "Formatting"]);
+  }
+  if (options.husky) {
+    rows.push(["[Husky](tooling/husky.md)", "Pre-commit hooks"]);
+  }
+  if (options.docker) {
+    rows.push(["[Docker](ops/docker.md)", "Standalone production image"]);
+  }
+  if (options.ci) {
+    rows.push(["[CI](ops/ci.md)", "GitHub Actions"]);
+  }
+  const table = [
+    "| Page | Topic |",
+    "|------|--------|",
+    ...rows.map(([page, topic]) => `| ${page} | ${topic} |`)
+  ].join("\n");
+  return `# Style guide \u2014 ${options.name}
+
+Living conventions for this app. Open one page at a time.
+
+${table}
+
+Coding agents: start at [\`AGENTS.md\`](../../AGENTS.md) \u2192 [\`.cursor/rules/\`](../../.cursor/rules/) (glob-scoped).
+`;
+}
+var surfaceInstaller = {
+  id: "surface",
+  active: () => true,
+  async run({ projectDir, options }) {
+    await fs22.writeFile(
+      path23.join(
+        projectDir,
+        "src",
+        "app",
+        "_components",
+        "welcome-card",
+        "index.tsx"
+      ),
+      welcomeCardSource(options),
+      "utf8"
+    );
+    await fs22.writeFile(
+      path23.join(projectDir, "src", "app", "page.tsx"),
+      homePageSource(options),
+      "utf8"
+    );
+    if (options.data === "tanstack-query") {
+      await fs22.copy(
+        path23.join(ADDONS_DIR, "docs", "data", "tanstack-query.md"),
+        path23.join(
+          projectDir,
+          "docs",
+          "style-guide",
+          "data",
+          "tanstack-query.md"
+        )
+      );
+    }
+    if (options.icons !== "none") {
+      await fs22.copy(
+        path23.join(ADDONS_DIR, "docs", "ui", "icons.md"),
+        path23.join(projectDir, "docs", "style-guide", "ui", "icons.md")
+      );
+    }
+    if (options.auth === "jwt" && options.endpoints) {
+      const exampleSrc = path23.join(
+        ADDONS_DIR,
+        "docs",
+        "examples",
+        "api-app-crud.md"
+      );
+      if (await fs22.pathExists(exampleSrc)) {
+        await fs22.copy(
+          exampleSrc,
+          path23.join(projectDir, "docs", "examples", "api-app-crud.md")
+        );
+      }
+    }
+    await fs22.writeFile(
+      path23.join(projectDir, "docs", "style-guide", "README.md"),
+      docsIndex(options),
+      "utf8"
+    );
+  }
+};
+
+// src/installers/tailwind.ts
+import fs23 from "fs-extra";
+import path24 from "path";
+var POSTCSS = `const config = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
+
+export default config;
+`;
+var GLOBALS = `@import "tailwindcss";
+
+:root {
+  color-scheme: light;
+  --background: #f6f4ef;
+  --foreground: #14201b;
+  --muted: #5b6b63;
+  --accent: #0b5fff;
+  --card: #ffffff;
+  --border: #d9e0db;
+}
+
+@theme inline {
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --color-muted: var(--muted);
+  --color-accent: var(--accent);
+  --color-card: var(--card);
+  --color-border: var(--border);
+}
+
+* {
+  box-sizing: border-box;
+}
+
+html,
+body {
+  margin: 0;
+  min-height: 100%;
+  background: radial-gradient(circle at top left, #eef3ff, transparent 40%),
+    var(--background);
+  color: var(--foreground);
+  font-family: ui-sans-serif, system-ui, sans-serif;
+}
+
+a {
+  color: var(--accent);
+  text-decoration: none;
+}
+
+a:hover {
+  text-decoration: underline;
+}
+
+main {
+  width: min(720px, calc(100% - 2rem));
+  margin: 0 auto;
+  padding: 4rem 0 3rem;
+}
+
+.hero {
+  display: grid;
+  gap: 1rem;
+}
+
+.hero h1 {
+  margin: 0;
+  font-size: clamp(2rem, 5vw, 3rem);
+  letter-spacing: -0.03em;
+}
+
+.hero p {
+  margin: 0;
+  color: var(--muted);
+  line-height: 1.6;
+  max-width: 40rem;
+}
+
+.card {
+  margin-top: 2rem;
+  padding: 1.25rem 1.5rem;
+  background: var(--card);
+  border: 1px solid var(--border);
+  border-radius: 12px;
+}
+
+.card h2 {
+  margin: 0 0 0.5rem;
+  font-size: 1rem;
+}
+
+.card ul {
+  margin: 0;
+  padding-left: 1.1rem;
+  color: var(--muted);
+  line-height: 1.7;
+}
+
+.meta {
+  margin-top: 2rem;
+  font-size: 0.875rem;
+  color: var(--muted);
+}
+`;
+var UTILS = `import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+`;
+var RULE11 = `---
+description: Tailwind CSS v4 conventions
+globs: src/app/globals.css,src/**/*.{tsx,css},postcss.config.mjs
+alwaysApply: false
+---
+
+# Tailwind
+
+- Tailwind v4 via \`@import "tailwindcss"\` in \`globals.css\` + \`@tailwindcss/postcss\`.
+- Prefer utility classes; keep semantic CSS variables in \`:root\` / \`@theme\`.
+- Class merging: \`cn()\` from \`@/lib/utils\` (clsx + tailwind-merge).
+`;
+var tailwindInstaller = {
+  id: "tailwind",
+  active: (o) => o.styling === "tailwind",
+  async run({ projectDir }) {
+    await fs23.writeFile(
+      path24.join(projectDir, "postcss.config.mjs"),
+      POSTCSS,
+      "utf8"
+    );
+    await fs23.writeFile(
+      path24.join(projectDir, "src", "app", "globals.css"),
+      GLOBALS,
+      "utf8"
+    );
+    await fs23.writeFile(
+      path24.join(projectDir, "src", "lib", "utils.ts"),
+      UTILS,
+      "utf8"
+    );
+    await fs23.writeFile(
+      path24.join(projectDir, ".cursor", "rules", "tailwind.mdc"),
+      RULE11,
+      "utf8"
+    );
+    await addDependencies(projectDir, {
+      clsx: "^2.1.1",
+      "tailwind-merge": "^3.6.0"
+    });
+    await addDependencies(
+      projectDir,
+      {
+        tailwindcss: "^4",
+        "@tailwindcss/postcss": "^4"
+      },
+      "devDependencies"
+    );
+  }
+};
+
+// src/installers/tanstack-query.ts
+import fs24 from "fs-extra";
+import path25 from "path";
+var PROVIDER = `"use client";
+
+import { type ReactNode, useState } from "react";
+
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+
+function createQueryClient() {
+  return new QueryClient({
+    defaultOptions: {
+      queries: {
+        staleTime: 60_000,
+        refetchOnWindowFocus: false,
+        retry: 1,
+      },
+      mutations: {
+        retry: false,
+      },
+    },
+  });
+}
+
+export function QueryProvider({ children }: { children: ReactNode }) {
+  const [client] = useState(createQueryClient);
+
+  return <QueryClientProvider client={client}>{children}</QueryClientProvider>;
+}
+`;
+var RULE12 = `---
+description: TanStack Query conventions
+globs: src/providers/**,src/hooks/**,src/endpoints/**,src/**/*query*.{ts,tsx},src/**/use-*.{ts,tsx}
+alwaysApply: false
+---
+
+# TanStack Query
+
+- \`QueryProvider\` (\`src/providers/query-provider.tsx\`) is composed via \`AppProviders\`.
+- Client data: \`useQuery\` / \`useMutation\`; keep RSC for server-friendly fetches.
+- Query keys: use generated \`get<EndpointName>QueryKey(...)\` when endpoints codegen is on \u2014 never ad-hoc \`["resource"]\` strings.
+- Default hook \`params\` to the matching \`*DefaultParams\` when present.
+- Errors: \`getApiErrorMessage\` / field helpers from \`@/utils/api-error\`.
+`;
+var tanstackQueryInstaller = {
+  id: "tanstack-query",
+  active: (o) => o.data === "tanstack-query",
+  async run({ projectDir }) {
+    await addDependencies(projectDir, {
+      "@tanstack/react-query": "^5.62.8"
+    });
+    const providersDir = path25.join(projectDir, "src", "providers");
+    await fs24.ensureDir(providersDir);
+    await fs24.remove(path25.join(providersDir, ".gitkeep"));
+    await fs24.writeFile(
+      path25.join(providersDir, "query-provider.tsx"),
+      PROVIDER,
+      "utf8"
+    );
+    const ruleDir = path25.join(projectDir, ".cursor", "rules");
+    await fs24.ensureDir(ruleDir);
+    await fs24.writeFile(
+      path25.join(ruleDir, "tanstack-query.mdc"),
+      RULE12,
+      "utf8"
+    );
+  }
+};
+
+// src/installers/testing.ts
+import fs25 from "fs-extra";
+import path26 from "path";
+var VITEST_CONFIG = `import react from "@vitejs/plugin-react";
+import { resolve } from "node:path";
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  plugins: [react()],
+  test: {
+    environment: "jsdom",
+    globals: true,
+    include: ["tests/**/*.test.{ts,tsx}", "src/**/*.test.{ts,tsx}"],
+  },
+  resolve: {
+    alias: {
+      "@": resolve(import.meta.dirname, "./src"),
+    },
+  },
+});
+`;
+var SAMPLE_TEST = `import { renderToStaticMarkup } from "react-dom/server";
+import { describe, expect, it } from "vitest";
+
+import { WelcomeCard } from "@/app/_components/welcome-card";
+
+describe("WelcomeCard", () => {
+  it("renders scaffold heading", () => {
+    const html = renderToStaticMarkup(<WelcomeCard />);
+    expect(html).toContain("Your scaffold");
+  });
+});
+`;
+function playwrightConfig(devCommand) {
+  return `import { defineConfig, devices } from "@playwright/test";
+
+export default defineConfig({
+  testDir: "./e2e",
+  fullyParallel: true,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 1 : 0,
+  use: {
+    baseURL: "http://127.0.0.1:3000",
+    trace: "on-first-retry",
+  },
+  projects: [{ name: "chromium", use: { ...devices["Desktop Chrome"] } }],
+  webServer: {
+    command: "${devCommand}",
+    url: "http://127.0.0.1:3000",
+    reuseExistingServer: !process.env.CI,
+  },
+});
+`;
+}
+var E2E_SMOKE = `import { expect, test } from "@playwright/test";
+
+test("home loads", async ({ page }) => {
+  await page.goto("/");
+  await expect(page.getByRole("heading", { level: 1 })).toBeVisible();
+});
+`;
+var testingInstaller = {
+  id: "testing",
+  active: (o) => o.testing,
+  async run({ projectDir, options }) {
+    const pm = getPackageManager(options.packageManager);
+    const testCmd = pm.runScript("test");
+    const e2eCmd = pm.runScript("test:e2e");
+    const rule = `---
+description: Vitest (and optional Playwright) conventions
+globs: "**/*.test.{ts,tsx}",vitest.config.*,e2e/**,playwright.config.*
+alwaysApply: false
+---
+
+# Testing
+
+- Vitest: colocated \`<name>.test.tsx\` next to components; also \`tests/**\`.
+- Prefer \`renderToStaticMarkup\` for simple server component smoke.
+- Run \`${testCmd}\`. Playwright (if enabled): \`${e2eCmd}\`.
+`;
+    await fs25.writeFile(
+      path26.join(projectDir, "vitest.config.mts"),
+      VITEST_CONFIG,
+      "utf8"
+    );
+    await fs25.outputFile(
+      path26.join(
+        projectDir,
+        "src",
+        "app",
+        "_components",
+        "welcome-card",
+        "welcome-card.test.tsx"
+      ),
+      SAMPLE_TEST
+    );
+    await fs25.writeFile(
+      path26.join(projectDir, ".cursor", "rules", "testing.mdc"),
+      rule,
+      "utf8"
+    );
+    await fs25.outputFile(
+      path26.join(projectDir, "docs", "style-guide", "tooling", "testing.md"),
+      `# Testing
+
+Vitest: \`${testCmd}\`
+Config: \`vitest.config.mts\`
+Colocate \`*.test.tsx\` with components under \`src/\`.
+${options.playwright ? `
+Playwright: \`${e2eCmd}\` \xB7 config \`playwright.config.ts\` \xB7 specs in \`e2e/\`.
+` : ""}
+`
+    );
+    await addDependencies(
+      projectDir,
+      {
+        vitest: "^3.0.5",
+        "@vitejs/plugin-react": "^4.3.4",
+        jsdom: "^26.0.0"
+      },
+      "devDependencies"
+    );
+    await addScripts(projectDir, {
+      test: "vitest run",
+      "test:watch": "vitest"
+    });
+    if (options.playwright) {
+      await fs25.writeFile(
+        path26.join(projectDir, "playwright.config.ts"),
+        playwrightConfig(pm.runScript("dev")),
+        "utf8"
+      );
+      await fs25.outputFile(path26.join(projectDir, "e2e", "home.spec.ts"), E2E_SMOKE);
+      await addDependencies(
+        projectDir,
+        { "@playwright/test": "^1.50.1" },
+        "devDependencies"
+      );
+      await addScripts(projectDir, {
+        "test:e2e": "playwright test"
+      });
+    }
+  }
+};
+
+// src/installers/validation.ts
+import fs26 from "fs-extra";
+import path27 from "path";
+var ENV_ZOD = `import { z } from "zod";
+
+/**
+ * Validated public env. Import from Client Components only for NEXT_PUBLIC_*.
+ * Server-only secrets stay out of this schema until needed.
+ */
+const publicEnvSchema = z.object({
+  NEXT_PUBLIC_APP_URL: z.string().url().default("http://localhost:3000"),
+  NEXT_PUBLIC_API_URL: z.string().url().default("http://localhost:8000"),
+});
+
+export type PublicEnv = z.infer<typeof publicEnvSchema>;
+
+export const env: PublicEnv = publicEnvSchema.parse({
+  NEXT_PUBLIC_APP_URL: process.env.NEXT_PUBLIC_APP_URL,
+  NEXT_PUBLIC_API_URL: process.env.NEXT_PUBLIC_API_URL,
+});
+`;
+var ENV_YUP = `import * as yup from "yup";
+
+/**
+ * Validated public env. Import from Client Components only for NEXT_PUBLIC_*.
+ * Server-only secrets stay out of this schema until needed.
+ */
+const publicEnvSchema = yup.object({
+  NEXT_PUBLIC_APP_URL: yup
+    .string()
+    .url()
+    .default("http://localhost:3000"),
+  NEXT_PUBLIC_API_URL: yup
+    .string()
+    .url()
+    .default("http://localhost:8000"),
+});
+
+export type PublicEnv = yup.InferType<typeof publicEnvSchema>;
+
+export const env: PublicEnv = publicEnvSchema.validateSync({
+  NEXT_PUBLIC_APP_URL: process.env.NEXT_PUBLIC_APP_URL,
+  NEXT_PUBLIC_API_URL: process.env.NEXT_PUBLIC_API_URL,
+});
+`;
+function formsRule(validation) {
+  const schemaLine = validation === "zod" ? "- RHF + `Controller` + Zod `zodResolver`. Schema `satisfies z.ZodType<*Body>` when endpoints codegen exists; field names = API keys." : "- RHF + `Controller` + Yup `yupResolver`. Schemas in `src/lib/validations/`; field names = API keys when endpoints codegen exists.";
+  return `---
+description: RHF + ${validation === "zod" ? "Zod" : "Yup"} forms aligned to API body types
+globs: src/**/*form*/**,src/**/*-form*/**,src/**/*.form.tsx,src/components/forms/**,src/lib/**/*form*.ts,src/lib/validations/**
+alwaysApply: false
+---
+
+# Forms
+
+- \`"use client"\` + named exports. \`page.tsx\` stays server when metadata-only.
+- Placement: shared \u2192 \`src/components/forms/<name>/\`; one route \u2192 \`src/app/<route>/_components/forms/<name>/\`.
+${schemaLine}
+- Reuse shared/UI controls \u2014 no ad-hoc inputs.
+- Required: derive from schema / \`*Body\`; use \`required\` on Field/Label (no handmade \`*\` text).
+- Invalid: \`data-invalid\`, \`aria-invalid\`, \`FieldError\`.
+- Server 400 envelope: \`getApiErrorMessage\` / \`extractApiFieldErrors\` (\`@/utils/api-error\`); map to \`setError\` when using RHF.
+- Never duplicate the same form state/submit logic across pages.
+`;
+}
+function validationRule(validation) {
+  return `---
+description: ${validation === "zod" ? "Zod" : "Yup"} validation conventions
+globs: src/lib/env.ts,src/lib/validations/**,src/**/*schema*.{ts,tsx}
+alwaysApply: false
+---
+
+# Validation (${validation})
+
+- Public env: \`src/lib/env.ts\` (${validation} schema).
+- Domain schemas: \`src/lib/validations/<name>.ts\`.
+- Forms: use \`${validation === "zod" ? "zodResolver" : "yupResolver"}\` from \`@hookform/resolvers\`.
+- Prefer one library \u2014 do not mix Zod and Yup in the same app.
+`;
+}
+var validationInstaller = {
+  id: "validation",
+  active: () => true,
+  async run({ projectDir, options }) {
+    const validationsDir = path27.join(projectDir, "src", "lib", "validations");
+    await fs26.ensureDir(validationsDir);
+    await fs26.writeFile(path27.join(validationsDir, ".gitkeep"), "", "utf8");
+    if (options.validation === "yup") {
+      await fs26.writeFile(
+        path27.join(projectDir, "src", "lib", "env.ts"),
+        ENV_YUP,
+        "utf8"
+      );
+      await removeDependencies(projectDir, ["zod"]);
+      await addDependencies(projectDir, { yup: "^1.6.1" });
+    } else {
+      await fs26.writeFile(
+        path27.join(projectDir, "src", "lib", "env.ts"),
+        ENV_ZOD,
+        "utf8"
+      );
+      await addDependencies(projectDir, { zod: "^3.24.1" });
+    }
+    await fs26.writeFile(
+      path27.join(projectDir, ".cursor", "rules", "forms.mdc"),
+      formsRule(options.validation),
+      "utf8"
+    );
+    await fs26.writeFile(
+      path27.join(projectDir, ".cursor", "rules", "validation.mdc"),
+      validationRule(options.validation),
+      "utf8"
+    );
+    await fs26.outputFile(
+      path27.join(
+        projectDir,
+        "docs",
+        "style-guide",
+        "validation",
+        `${options.validation}.md`
+      ),
+      `# Validation \u2014 ${options.validation}
+
+Env: \`src/lib/env.ts\`
+Schemas: \`src/lib/validations/\`
+Forms: \`@hookform/resolvers/${options.validation}\` when using RHF.
+`
+    );
+  }
+};
+
+// src/installers/index.ts
+var installers = [
+  packageManagerInstaller,
+  iconsInstaller,
+  storeInstaller,
+  tanstackQueryInstaller,
+  endpointsInstaller,
+  apiEnvelopeInstaller,
+  authJwtInstaller,
+  authAuthjsInstaller,
+  tailwindInstaller,
+  darkModeInstaller,
+  muiInstaller,
+  shadcnInstaller,
+  validationInstaller,
+  seoInstaller,
+  i18nInstaller,
+  dockerComposeInstaller,
+  testingInstaller,
+  eslintInstaller,
+  prettierInstaller,
+  huskyInstaller,
+  dockerInstaller,
+  ciInstaller,
+  appProvidersInstaller,
+  surfaceInstaller
+];
+async function runInstallers(ctx) {
+  const ran = [];
+  for (const installer of installers) {
+    if (!installer.active(ctx.options)) continue;
+    await installer.run(ctx);
+    ran.push(installer.id);
+  }
+  return ran;
+}
+
+// src/scaffold.ts
+async function scaffold(options) {
+  const projectDir = path28.resolve(process.cwd(), options.name);
+  const pm = getPackageManager(options.packageManager);
+  if (await fs27.pathExists(projectDir)) {
+    const entries = await fs27.readdir(projectDir);
+    if (entries.length > 0) {
+      throw new Error(
+        `Target directory already exists and is not empty: ${projectDir}`
+      );
+    }
+  }
+  const spin = p2.spinner();
+  spin.start("Copying template");
+  if (!await fs27.pathExists(TEMPLATE_DIR)) {
+    spin.stop("Template missing");
+    throw new Error(`Template directory not found at ${TEMPLATE_DIR}`);
+  }
+  await fs27.copy(TEMPLATE_DIR, projectDir, {
+    filter: (src) => {
+      const base = path28.basename(src);
+      return base !== "node_modules" && base !== ".next" && base !== "dist";
+    }
+  });
+  const gitignoreSrc = path28.join(projectDir, "gitignore");
+  const gitignoreDest = path28.join(projectDir, ".gitignore");
+  if (await fs27.pathExists(gitignoreSrc)) {
+    await fs27.move(gitignoreSrc, gitignoreDest, { overwrite: true });
+  }
+  spin.message("Applying project tokens");
+  await replaceTokensInTree(projectDir, {
+    __PROJECT_NAME__: options.name,
+    __PROJECT_SLUG__: options.slug,
+    __PACKAGE_MANAGER__: pm.id
+  });
+  spin.message("Running installers");
+  const ran = await runInstallers({ projectDir, options });
+  if (!options.noInstall) {
+    spin.message(`Installing dependencies (${pm.id})`);
+    try {
+      execSync(`${pm.id} ${pm.installArgs.join(" ")}`, {
+        cwd: projectDir,
+        stdio: "ignore"
+      });
+    } catch {
+      if (pm.id !== "npm") {
+        spin.message(`${pm.id} failed \u2014 trying npm`);
+        execSync("npm install", { cwd: projectDir, stdio: "ignore" });
+      } else {
+        throw new Error("npm install failed");
+      }
+    }
+  }
+  spin.stop("Project ready");
+  if (ran.length) {
+    p2.log.info(`Installers: ${ran.join(", ")}`);
+  } else {
+    p2.log.step(color2.dim("No optional installers (base template only)."));
+  }
+  return projectDir;
+}
+
+// src/upgrade.ts
+import fs28 from "fs-extra";
+import path29 from "path";
+import * as p3 from "@clack/prompts";
+import color3 from "picocolors";
+var TRACKED = [
+  "AGENTS.md",
+  ".cursor/rules/core.mdc",
+  ".cursor/rules/components.mdc",
+  ".cursor/rules/forms.mdc"
+];
+function rel(projectDir, file) {
+  return path29.join(projectDir, file);
+}
+function templatePath(file) {
+  return path29.join(TEMPLATE_DIR, file);
+}
+async function runUpgrade(options) {
+  const { projectDir, apply } = options;
+  if (!await fs28.pathExists(path29.join(projectDir, "package.json"))) {
+    throw new Error(`Not an app directory (missing package.json): ${projectDir}`);
+  }
+  if (!await fs28.pathExists(TEMPLATE_DIR)) {
+    throw new Error(`Template missing at ${TEMPLATE_DIR}`);
+  }
+  p3.intro(color3.bgCyan(color3.black(" next-style-guide upgrade ")));
+  p3.log.info(
+    apply ? `Applying template agent files \u2192 ${projectDir}` : `Diff only (pass --apply to write). Target: ${projectDir}`
+  );
+  let changed = 0;
+  let missing = 0;
+  let same = 0;
+  for (const file of TRACKED) {
+    const from = templatePath(file);
+    const to = rel(projectDir, file);
+    if (!await fs28.pathExists(from)) {
+      p3.log.warn(`Template missing ${file}`);
+      continue;
+    }
+    const next = await fs28.readFile(from, "utf8");
+    let outgoing = next;
+    if (file === "AGENTS.md" && await fs28.pathExists(to)) {
+      const current2 = await fs28.readFile(to, "utf8");
+      const nameMatch = current2.match(/^# Agents \((.+)\)$/m);
+      if (nameMatch?.[1]) {
+        outgoing = outgoing.replace("__PROJECT_NAME__", nameMatch[1]);
+      }
+      const pmMatch = current2.match(/· ([a-z]+)(\.|$)/m);
+      if (current2.includes("pnpm") || current2.includes("npm") || current2.includes("yarn")) {
+        const stackPm = current2.match(/· (pnpm|npm|yarn)\./);
+        if (stackPm?.[1]) {
+          outgoing = outgoing.replace("__PACKAGE_MANAGER__", stackPm[1]);
+        }
+      }
+    }
+    outgoing = outgoing.replaceAll("__PROJECT_NAME__", path29.basename(projectDir)).replaceAll("__PACKAGE_MANAGER__", "pnpm").replaceAll("__PROJECT_SLUG__", path29.basename(projectDir));
+    if (!await fs28.pathExists(to)) {
+      missing += 1;
+      p3.log.warn(`missing  ${file}`);
+      if (apply) {
+        await fs28.ensureDir(path29.dirname(to));
+        await fs28.writeFile(to, outgoing, "utf8");
+        p3.log.success(`wrote    ${file}`);
+      }
+      continue;
+    }
+    const current = await fs28.readFile(to, "utf8");
+    if (current === outgoing) {
+      same += 1;
+      p3.log.step(color3.dim(`same     ${file}`));
+      continue;
+    }
+    changed += 1;
+    p3.log.warn(`differs  ${file}`);
+    if (apply) {
+      await fs28.writeFile(to, outgoing, "utf8");
+      p3.log.success(`updated  ${file}`);
+    }
+  }
+  p3.note(
+    [
+      `same=${same}  differs=${changed}  missing=${missing}`,
+      apply ? "Applied template agent surface." : "Re-run with --apply to write differs/missing files.",
+      "Feature rules (.cursor/rules/* beyond core/components/forms) are not overwritten \u2014 re-scaffold options or copy manually."
+    ].join("\n"),
+    "Summary"
+  );
+  p3.outro(color3.green(apply ? "Upgrade applied." : "Diff complete."));
+}
+
+// src/index.ts
+var ICON_VALUES = /* @__PURE__ */ new Set(["none", "lucide", "tabler"]);
+var STYLING_VALUES = /* @__PURE__ */ new Set(["none", "tailwind", "mui"]);
+var VALIDATION_VALUES = /* @__PURE__ */ new Set(["zod", "yup"]);
+var AUTH_VALUES = /* @__PURE__ */ new Set(["none", "jwt", "authjs"]);
+var STORE_VALUES = /* @__PURE__ */ new Set(["none", "zustand", "redux"]);
+var PM_VALUES = /* @__PURE__ */ new Set(["pnpm", "npm", "yarn"]);
+var PRESET_VALUES = /* @__PURE__ */ new Set([
+  "custom",
+  "minimal",
+  "api-app",
+  "marketing",
+  "dashboard"
+]);
+function parseBoolFlag(arg, positive, negative) {
+  if (arg === positive) return true;
+  if (arg === negative) return false;
+  return void 0;
+}
+function readChoice(arg, flag, values, args, i) {
+  if (arg.startsWith(`${flag}=`)) {
+    const value = arg.slice(flag.length + 1);
+    if (!values.has(value)) {
+      throw new Error(`Invalid ${flag}=${value}.`);
+    }
+    return { value, nextIndex: i };
+  }
+  if (arg === flag) {
+    const value = args[i + 1];
+    if (!value || !values.has(value)) {
+      throw new Error(`Invalid ${flag}.`);
+    }
+    return { value, nextIndex: i + 1 };
+  }
+  return null;
+}
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const out = {
+    noInstall: false,
+    yes: false,
+    upgrade: false,
+    apply: false
+  };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "upgrade") {
+      out.upgrade = true;
+      continue;
+    }
+    if (arg === "--apply") {
+      out.apply = true;
+      continue;
+    }
+    if (arg === "--diff") {
+      out.upgrade = true;
+      out.apply = false;
+      continue;
+    }
+    if (arg === "--no-install") {
+      out.noInstall = true;
+      continue;
+    }
+    if (arg === "--yes" || arg === "-y") {
+      out.yes = true;
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      printHelp();
+      process.exit(0);
+    }
+    const boolKeys = [
+      ["tanstackQuery", "--tanstack-query", "--no-tanstack-query"],
+      ["endpoints", "--endpoints", "--no-endpoints"],
+      ["apiEnvelope", "--api-envelope", "--no-api-envelope"],
+      ["seo", "--seo", "--no-seo"],
+      ["i18n", "--i18n", "--no-i18n"],
+      ["darkMode", "--dark-mode", "--no-dark-mode"],
+      ["testing", "--testing", "--no-testing"],
+      ["playwright", "--playwright", "--no-playwright"],
+      ["eslint", "--eslint", "--no-eslint"],
+      ["prettier", "--prettier", "--no-prettier"],
+      ["husky", "--husky", "--no-husky"],
+      ["docker", "--docker", "--no-docker"],
+      ["ci", "--ci", "--no-ci"],
+      ["shadcn", "--shadcn", "--no-shadcn"]
+    ];
+    let matched = false;
+    for (const [key, pos, neg] of boolKeys) {
+      const v = parseBoolFlag(arg, pos, neg);
+      if (v !== void 0) {
+        out[key] = v;
+        matched = true;
+        break;
+      }
+    }
+    if (matched) continue;
+    const preset = readChoice(arg, "--preset", PRESET_VALUES, args, i);
+    if (preset) {
+      out.preset = preset.value;
+      i = preset.nextIndex;
+      continue;
+    }
+    const pm = readChoice(arg, "--pm", PM_VALUES, args, i);
+    if (pm) {
+      out.packageManager = pm.value;
+      i = pm.nextIndex;
+      continue;
+    }
+    const pmLong = readChoice(arg, "--package-manager", PM_VALUES, args, i);
+    if (pmLong) {
+      out.packageManager = pmLong.value;
+      i = pmLong.nextIndex;
+      continue;
+    }
+    const store = readChoice(arg, "--store", STORE_VALUES, args, i);
+    if (store) {
+      out.store = store.value;
+      i = store.nextIndex;
+      continue;
+    }
+    const styling = readChoice(arg, "--styling", STYLING_VALUES, args, i);
+    if (styling) {
+      out.styling = styling.value;
+      i = styling.nextIndex;
+      continue;
+    }
+    const validation = readChoice(
+      arg,
+      "--validation",
+      VALIDATION_VALUES,
+      args,
+      i
+    );
+    if (validation) {
+      out.validation = validation.value;
+      i = validation.nextIndex;
+      continue;
+    }
+    const auth = readChoice(arg, "--auth", AUTH_VALUES, args, i);
+    if (auth) {
+      out.auth = auth.value;
+      i = auth.nextIndex;
+      continue;
+    }
+    const icons = readChoice(arg, "--icons", ICON_VALUES, args, i);
+    if (icons) {
+      out.icons = icons.value;
+      i = icons.nextIndex;
+      continue;
+    }
+    if (!arg.startsWith("-") && !out.name) {
+      out.name = arg;
+    }
+  }
+  return out;
+}
+function printHelp() {
+  console.log(`
+${TITLE} \u2014 ${PKG_NAME}
+
+Usage:
+  npx create-next-style-guide [name] [options]
+  npx create-next-style-guide upgrade [--apply] [dir]
+  npx create-next-style-guide --diff [dir]
+
+Options:
+  --yes, -y
+  --no-install
+  --preset minimal|api-app|marketing|dashboard|custom
+  --pm, --package-manager pnpm|npm|yarn
+  --store none|zustand|redux
+  --styling none|tailwind|mui
+  --shadcn | --no-shadcn
+  --dark-mode | --no-dark-mode
+  --validation zod|yup
+  --auth none|jwt|authjs
+  --icons none|lucide|tabler
+  --tanstack-query | --no-tanstack-query
+  --endpoints | --no-endpoints
+  --api-envelope | --no-api-envelope
+  --seo | --no-seo
+  --i18n | --no-i18n
+  --testing | --no-testing
+  --playwright | --no-playwright
+  --eslint | --no-eslint
+  --prettier | --no-prettier
+  --husky | --no-husky
+  --docker | --no-docker
+  --ci | --no-ci
+  --help, -h
+
+Upgrade:
+  upgrade [--apply]   Diff (default) or apply AGENTS.md + core .cursor/rules
+  --diff              Alias for upgrade without --apply
+`);
+}
+function applyFlagOverrides(options, flags) {
+  let next = { ...options };
+  if (flags.packageManager !== void 0) {
+    next.packageManager = flags.packageManager;
+  }
+  if (flags.icons !== void 0) next.icons = flags.icons;
+  if (flags.styling !== void 0) next.styling = flags.styling;
+  if (flags.shadcn !== void 0) next.ui = flags.shadcn ? "shadcn" : "none";
+  if (flags.validation !== void 0) next.validation = flags.validation;
+  if (flags.auth !== void 0) next.auth = flags.auth;
+  if (flags.store !== void 0) next.store = flags.store;
+  if (flags.tanstackQuery !== void 0) {
+    next.data = flags.tanstackQuery ? "tanstack-query" : "rsc";
+  }
+  if (flags.endpoints !== void 0) next.endpoints = flags.endpoints;
+  if (flags.apiEnvelope !== void 0) next.apiEnvelope = flags.apiEnvelope;
+  if (flags.seo !== void 0) next.seo = flags.seo;
+  if (flags.i18n !== void 0) next.i18n = flags.i18n;
+  if (flags.darkMode !== void 0) next.darkMode = flags.darkMode;
+  if (flags.testing !== void 0) next.testing = flags.testing;
+  if (flags.playwright !== void 0) next.playwright = flags.playwright;
+  if (flags.eslint !== void 0) next.eslint = flags.eslint;
+  if (flags.prettier !== void 0) next.prettier = flags.prettier;
+  if (flags.husky !== void 0) next.husky = flags.husky;
+  if (flags.docker !== void 0) next.docker = flags.docker;
+  if (flags.ci !== void 0) next.ci = flags.ci;
+  return normalizeOptions(next);
+}
+async function main() {
+  const flags = parseArgs(process.argv);
+  if (flags.upgrade) {
+    const projectDir2 = path30.resolve(process.cwd(), flags.name ?? ".");
+    await runUpgrade({ projectDir: projectDir2, apply: flags.apply });
+    return;
+  }
+  let options;
+  if (flags.yes) {
+    const name = (flags.name ?? "my-app").trim();
+    const presetSeed = flags.preset && flags.preset !== "custom" ? PRESET_SEEDS[flags.preset] : DEFAULT_OPTIONS;
+    options = applyFlagOverrides(
+      {
+        name,
+        slug: slugify(name),
+        ...presetSeed,
+        noInstall: flags.noInstall
+      },
+      flags
+    );
+    p4.intro(color4.bgCyan(color4.black(` ${TITLE} `)));
+    p4.log.info(
+      [
+        `Non-interactive: ${options.name} (${options.slug})`,
+        flags.preset ? `preset=${flags.preset}` : null,
+        `pm=${options.packageManager}`,
+        `styling=${options.styling} ui=${options.ui} auth=${options.auth} store=${options.store}`,
+        `endpoints=${options.endpoints} seo=${options.seo} i18n=${options.i18n} testing=${options.testing}`
+      ].filter(Boolean).join(" \xB7 ")
+    );
+  } else {
+    options = await runPrompts(flags.name);
+    options.noInstall = flags.noInstall;
+    options = applyFlagOverrides(options, flags);
+  }
+  const warnings = collectOptionWarnings(options);
+  for (const warning of warnings) {
+    p4.log.warn(warning);
+  }
+  const projectDir = await scaffold(options);
+  const pm = getPackageManager(options.packageManager);
+  const nextSteps = [
+    `cd ${path30.relative(process.cwd(), projectDir) || "."}`,
+    options.noInstall ? `${pm.id} ${pm.installArgs.filter((a) => a !== "--ignore-workspace").join(" ")}`.trim() : null,
+    options.ui === "shadcn" ? "npx shadcn@latest add input   # optional" : null,
+    options.endpoints ? `${pm.runScript("endpoints:generate")}   # when API schema is up` : null,
+    options.testing ? pm.runScript("test") : null,
+    pm.runScript("dev")
+  ].filter(Boolean);
+  p4.note(nextSteps.join("\n"), "Next steps");
+  p4.outro(color4.green("Done. Happy shipping."));
+}
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  p4.log.error(message);
+  p4.cancel("Scaffold failed.");
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map