@msishamim/create-next-monorepo 1.0.0 → 2.0.0

package/dist/index.js

@@ -44,6 +44,30 @@ var LicenseType = {
   Unlicense: "Unlicense",
   Proprietary: "proprietary"
 };
+var Docker = { full: "full", minimal: "minimal", none: "none" };
+var I18n = { nextIntl: "next-intl", none: "none" };
+var Payments = {
+  stripe: "stripe",
+  lemonsqueezy: "lemonsqueezy",
+  paddle: "paddle",
+  none: "none"
+};
+var Email = {
+  resend: "resend",
+  nodemailer: "nodemailer",
+  sendgrid: "sendgrid",
+  none: "none"
+};
+var ApiDocs = { swagger: "swagger", redoc: "redoc", none: "none" };
+var Storage = {
+  s3: "s3",
+  uploadthing: "uploadthing",
+  cloudinary: "cloudinary",
+  none: "none"
+};
+var E2e = { playwright: "playwright", cypress: "cypress", none: "none" };
+var Cache = { redis: "redis", none: "none" };
+var Logging = { pino: "pino", winston: "winston", default: "default" };
 var backendDisplayName = {
   nestjs: "NestJS",
   express: "Express"
@@ -84,6 +108,16 @@ var ProjectConfig = class {
   packageManager;
   gitInit;
   githubFiles;
+  docker;
+  i18n;
+  payments;
+  email;
+  apiDocs;
+  storage;
+  e2e;
+  storybook;
+  cache;
+  logging;
   /** Resolved npm package versions — set by Generator before template rendering */
   versions = {};
   constructor(options) {
@@ -99,6 +133,16 @@ var ProjectConfig = class {
     this.packageManager = options.packageManager ?? "pnpm";
     this.gitInit = options.gitInit ?? true;
     this.githubFiles = options.githubFiles ?? false;
+    this.docker = options.docker ?? "none";
+    this.i18n = options.i18n ?? "none";
+    this.payments = options.payments ?? "none";
+    this.email = options.email ?? "none";
+    this.apiDocs = options.apiDocs ?? "none";
+    this.storage = options.storage ?? "none";
+    this.e2e = options.e2e ?? "none";
+    this.storybook = options.storybook ?? false;
+    this.cache = options.cache ?? "none";
+    this.logging = options.logging ?? "default";
   }
   // ── Derived name variants ──────────────────────────────────────
   /** PascalCase (e.g. "my-app" → "MyApp") */
@@ -127,6 +171,33 @@ var ProjectConfig = class {
   get usesTailwind() {
     return this.styling === "tailwind";
   }
+  get hasDocker() {
+    return this.docker !== "none";
+  }
+  get hasI18n() {
+    return this.i18n !== "none";
+  }
+  get hasPayments() {
+    return this.payments !== "none";
+  }
+  get hasEmail() {
+    return this.email !== "none";
+  }
+  get hasApiDocs() {
+    return this.apiDocs !== "none";
+  }
+  get hasStorage() {
+    return this.storage !== "none";
+  }
+  get hasE2e() {
+    return this.e2e !== "none";
+  }
+  get hasCache() {
+    return this.cache !== "none";
+  }
+  get hasLogging() {
+    return this.logging !== "default";
+  }
   /** Install command for the selected package manager */
   get installCommand() {
     switch (this.packageManager) {
@@ -213,6 +284,32 @@ var ProjectConfig = class {
       packages.push("jest", "@types/jest", "ts-jest");
     }
     packages.push("zod");
+    if (this.i18n === "next-intl") packages.push("next-intl");
+    if (this.payments === "stripe") packages.push("stripe");
+    if (this.payments === "lemonsqueezy") packages.push("@lemonsqueezy/lemonsqueezy.js");
+    if (this.payments === "paddle") packages.push("@paddle/paddle-node-sdk");
+    if (this.email === "resend") packages.push("resend", "@react-email/components");
+    if (this.email === "nodemailer") packages.push("nodemailer", "@types/nodemailer");
+    if (this.email === "sendgrid") packages.push("@sendgrid/mail");
+    if (this.apiDocs === "swagger" || this.apiDocs === "redoc") {
+      if (this.backend === "nestjs") {
+        packages.push("@nestjs/swagger");
+      } else {
+        packages.push("swagger-jsdoc", "swagger-ui-express", "@types/swagger-jsdoc", "@types/swagger-ui-express");
+      }
+    }
+    if (this.apiDocs === "redoc") packages.push("redoc-express");
+    if (this.storage === "s3") packages.push("@aws-sdk/client-s3", "@aws-sdk/s3-request-presigner");
+    if (this.storage === "uploadthing") packages.push("uploadthing", "@uploadthing/react");
+    if (this.storage === "cloudinary") packages.push("cloudinary");
+    if (this.e2e === "playwright") packages.push("@playwright/test");
+    if (this.e2e === "cypress") packages.push("cypress");
+    if (this.storybook) {
+      packages.push("storybook", "@storybook/react", "@storybook/react-vite", "@storybook/addon-essentials");
+    }
+    if (this.cache === "redis") packages.push("ioredis");
+    if (this.logging === "pino") packages.push("pino", "pino-pretty");
+    if (this.logging === "winston") packages.push("winston");
     return packages;
   }
 };
@@ -287,7 +384,47 @@ var FALLBACK_VERSIONS = {
   "@types/jest": "^29.5.14",
   "ts-jest": "^29.3.2",
   // Validation
-  zod: "^3.24.3"
+  zod: "^3.24.3",
+  // ── v2.0 options ──
+  // i18n
+  "next-intl": "^4.1.0",
+  // Payments
+  stripe: "^17.7.0",
+  "@lemonsqueezy/lemonsqueezy.js": "^4.0.0",
+  "@paddle/paddle-node-sdk": "^1.7.0",
+  // Email
+  resend: "^4.1.0",
+  "@react-email/components": "^0.0.36",
+  nodemailer: "^6.10.0",
+  "@types/nodemailer": "^6.4.17",
+  "@sendgrid/mail": "^8.1.0",
+  // API Docs
+  "@nestjs/swagger": "^8.1.0",
+  "swagger-jsdoc": "^6.2.8",
+  "swagger-ui-express": "^5.0.1",
+  "@types/swagger-jsdoc": "^6.0.4",
+  "@types/swagger-ui-express": "^4.1.8",
+  "redoc-express": "^2.1.0",
+  // Storage
+  "@aws-sdk/client-s3": "^3.750.0",
+  "@aws-sdk/s3-request-presigner": "^3.750.0",
+  uploadthing: "^7.6.0",
+  "@uploadthing/react": "^7.3.0",
+  cloudinary: "^2.6.0",
+  // E2E
+  "@playwright/test": "^1.50.0",
+  cypress: "^14.0.0",
+  // Storybook
+  storybook: "^8.5.0",
+  "@storybook/react": "^8.5.0",
+  "@storybook/react-vite": "^8.5.0",
+  "@storybook/addon-essentials": "^8.5.0",
+  // Cache
+  ioredis: "^5.6.0",
+  // Logging
+  pino: "^9.6.0",
+  "pino-pretty": "^13.0.0",
+  winston: "^3.17.0"
 };
 var VersionResolver = class {
   resolved = {};
@@ -477,11 +614,27 @@ function getExpectedDirectories(config) {
     dirs.push(stateDir);
   }
   if (config.githubFiles) {
-    dirs.push(
-      ".github/ISSUE_TEMPLATE",
-      ".github/workflows"
-    );
-  }
+    dirs.push(".github/ISSUE_TEMPLATE", ".github/workflows");
+  }
+  if (config.docker === "full") dirs.push("nginx");
+  if (config.hasI18n) dirs.push("apps/web/i18n", "apps/web/messages", "apps/web/app/[locale]");
+  if (config.hasPayments) {
+    dirs.push("packages/payments/src");
+    dirs.push("apps/web/app/pricing");
+    if (config.backend === "nestjs") dirs.push("apps/api/src/payments");
+  }
+  if (config.hasEmail) dirs.push("packages/email/src", "packages/email/src/templates");
+  if (config.hasApiDocs) dirs.push("apps/api/src/docs");
+  if (config.hasStorage) {
+    dirs.push("packages/storage/src");
+    if (config.storage === "uploadthing") dirs.push("apps/web/app/api/uploadthing");
+  }
+  if (config.hasE2e) {
+    dirs.push(config.e2e === "playwright" ? "apps/web/e2e" : "apps/web/cypress/e2e");
+  }
+  if (config.storybook) dirs.push("packages/ui/.storybook");
+  if (config.hasCache) dirs.push("packages/cache/src");
+  if (config.hasLogging) dirs.push("packages/lib/src/logger");
   return dirs;
 }
 function getExpectedFiles(config) {
@@ -642,6 +795,94 @@ function getExpectedFiles(config) {
       ".github/workflows/ci.yml"
     );
   }
+  if (config.hasDocker) {
+    files.push("apps/web/Dockerfile", "apps/api/Dockerfile", "docker-compose.prod.yml", ".dockerignore");
+    if (config.docker === "full") files.push("nginx/nginx.conf", "nginx/Dockerfile");
+  }
+  if (config.hasI18n) {
+    files.push(
+      "apps/web/i18n/request.ts",
+      "apps/web/i18n/routing.ts",
+      "apps/web/i18n/navigation.ts",
+      "apps/web/messages/en.json",
+      "apps/web/messages/ar.json",
+      "apps/web/app/[locale]/layout.tsx",
+      "apps/web/app/[locale]/page.tsx",
+      "apps/web/components/language-switcher.tsx"
+    );
+  }
+  if (config.hasPayments) {
+    files.push(
+      "packages/payments/package.json",
+      "packages/payments/tsconfig.json",
+      "packages/payments/src/index.ts",
+      "packages/payments/src/client.ts",
+      "packages/payments/src/webhook.ts",
+      "packages/payments/src/checkout.ts",
+      "packages/payments/src/subscription.ts",
+      "apps/web/app/pricing/page.tsx"
+    );
+    if (config.backend === "nestjs") {
+      files.push("apps/api/src/payments/payments.controller.ts");
+    } else {
+      files.push("apps/api/src/routes/payments.ts");
+    }
+  }
+  if (config.hasEmail) {
+    files.push(
+      "packages/email/package.json",
+      "packages/email/tsconfig.json",
+      "packages/email/src/index.ts",
+      "packages/email/src/client.ts",
+      "packages/email/src/send.ts",
+      "packages/email/src/templates/welcome.tsx",
+      "packages/email/src/templates/reset-password.tsx"
+    );
+  }
+  if (config.hasApiDocs) {
+    files.push("apps/api/src/docs/swagger-config.ts", "apps/api/src/docs/setup.ts");
+  }
+  if (config.hasStorage) {
+    files.push(
+      "packages/storage/package.json",
+      "packages/storage/tsconfig.json",
+      "packages/storage/src/index.ts",
+      "packages/storage/src/client.ts",
+      "packages/storage/src/upload.ts",
+      "packages/storage/src/download.ts"
+    );
+    if (config.storage === "uploadthing") {
+      files.push("apps/web/app/api/uploadthing/core.ts", "apps/web/app/api/uploadthing/route.ts");
+    }
+  }
+  if (config.hasE2e) {
+    if (config.e2e === "playwright") {
+      files.push("apps/web/playwright.config.ts", "apps/web/e2e/example.spec.ts");
+    } else {
+      files.push("apps/web/cypress.config.ts", "apps/web/cypress/e2e/example.cy.ts");
+    }
+  }
+  if (config.storybook) {
+    files.push(
+      "packages/ui/.storybook/main.ts",
+      "packages/ui/.storybook/preview.ts",
+      "packages/ui/src/components/button.stories.tsx",
+      "packages/ui/src/components/card.stories.tsx",
+      "packages/ui/src/components/input.stories.tsx"
+    );
+  }
+  if (config.hasCache) {
+    files.push(
+      "packages/cache/package.json",
+      "packages/cache/tsconfig.json",
+      "packages/cache/src/index.ts",
+      "packages/cache/src/client.ts",
+      "packages/cache/src/service.ts"
+    );
+  }
+  if (config.hasLogging) {
+    files.push("packages/lib/src/logger/index.ts", "packages/lib/src/logger/logger.ts");
+  }
   return files;
 }
 
@@ -3168,287 +3409,511 @@ ${setupPm}
 `;
 }
 
-// src/templates/strategies/nestjs-templates.ts
-var NestjsTemplateStrategy = class {
-  packageJson(config) {
-    return `{
-  "name": "@${config.name}/api",
-  "version": "0.0.0",
+// src/templates/cache-templates.ts
+function cachePackageJson(config) {
+  return `{
+  "name": "@${config.name}/cache",
+  "version": "1.0.0",
   "private": true,
-  "scripts": {
-    "build": "nest build",
-    "dev": "nest start --watch",
-    "start": "nest start",
-    "start:prod": "node dist/main",
-    "lint": "eslint src --ext .ts",
-    "test": "${config.testing === "vitest" ? "vitest run" : "jest"}"
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./client": "./src/client.ts",
+    "./service": "./src/service.ts"
   },
   "dependencies": {
-    "@nestjs/common": "${config.versions["@nestjs/common"] ?? "^11.0.20"}",
-    "@nestjs/core": "${config.versions["@nestjs/core"] ?? "^11.0.20"}",
-    "@nestjs/platform-express": "${config.versions["@nestjs/platform-express"] ?? "^11.0.20"}",
-    "reflect-metadata": "${config.versions["reflect-metadata"] ?? "^0.2.2"}",
-    "rxjs": "${config.versions["rxjs"] ?? "^7.8.2"}",
-    "@${config.name}/lib": "workspace:*"${config.hasDatabase ? `,
-    "@${config.name}/database": "workspace:*"` : ""}
+    "ioredis": "${config.versions["ioredis"] ?? "^5.6.0"}"
   },
   "devDependencies": {
-    "@nestjs/cli": "${config.versions["@nestjs/cli"] ?? "^11.0.5"}",
-    "@nestjs/testing": "${config.versions["@nestjs/testing"] ?? "^11.0.20"}",
-    "@types/node": "${config.versions["@types/node"] ?? "^22.15.3"}",
     "typescript": "${config.versions["typescript"] ?? "^5.8.3"}"
   }
 }
 `;
-  }
-  tsConfig(config) {
-    return `{
-  "extends": "@${config.name}/config/typescript/node",
+}
+function cacheTsConfig(config) {
+  return `{
+  "extends": "@${config.name}/config/typescript/base",
   "compilerOptions": {
     "outDir": "./dist",
-    "rootDir": "./src"
+    "rootDir": "./src",
+    "verbatimModuleSyntax": false
   },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "test"]
+  "include": ["src/**/*"]
 }
 `;
-  }
-  mainEntry(config) {
-    return `import { NestFactory } from '@nestjs/core';
-import { ValidationPipe } from '@nestjs/common';
-import { AppModule } from './app.module.js';
-import { HttpExceptionFilter } from './common/filters/http-exception.filter.js';
-import { LoggingInterceptor } from './common/interceptors/logging.interceptor.js';
+}
+function cacheIndex() {
+  return `export { redis } from './client.js';
+export { CacheService } from './service.js';
+`;
+}
+function cacheClient() {
+  return `import Redis from 'ioredis';
 
-async function bootstrap() {
-  const app = await NestFactory.create(AppModule);
+const redisUrl = process.env.REDIS_URL ?? 'redis://localhost:6379';
 
-  app.enableCors({
-    origin: process.env.CORS_ORIGIN ?? 'http://localhost:3000',
-    credentials: true,
-  });
+const globalForRedis = globalThis as unknown as {
+  redis: Redis | undefined;
+};
 
-  app.setGlobalPrefix('api');
-  app.useGlobalPipes(new ValidationPipe({ whitelist: true, transform: true }));
-  app.useGlobalFilters(new HttpExceptionFilter());
-  app.useGlobalInterceptors(new LoggingInterceptor());
+export const redis = globalForRedis.redis ?? new Redis(redisUrl, {
+  maxRetriesPerRequest: 3,
+  retryStrategy(times) {
+    if (times > 3) return null;
+    return Math.min(times * 200, 2000);
+  },
+});
 
-  const port = process.env.PORT ?? 3001;
-  await app.listen(port);
-  console.log(\`\u{1F680} ${config.pascalCase} API running on http://localhost:\${port}/api\`);
+if (process.env.NODE_ENV !== 'production') {
+  globalForRedis.redis = redis;
 }
-
-bootstrap();
 `;
+}
+function cacheService() {
+  return `import { redis } from './client.js';
+
+/** Simple cache wrapper around Redis with JSON serialization and TTL support */
+export class CacheService {
+  private defaultTtl: number;
+
+  constructor(defaultTtl = 3600) {
+    this.defaultTtl = defaultTtl;
   }
-  appSetup(_config) {
-    return `import { Module } from '@nestjs/common';
-import { AppController } from './app.controller.js';
-import { AppService } from './app.service.js';
 
-@Module({
-  imports: [],
-  controllers: [AppController],
-  providers: [AppService],
-})
-export class AppModule {}
-`;
+  /** Get a cached value by key */
+  async get<T>(key: string): Promise<T | null> {
+    const value = await redis.get(key);
+    if (!value) return null;
+    try {
+      return JSON.parse(value) as T;
+    } catch {
+      return value as unknown as T;
+    }
   }
-  appController(_config) {
-    return `import { Controller, Get } from '@nestjs/common';
-import { AppService } from './app.service.js';
 
-@Controller()
-export class AppController {
-  constructor(private readonly appService: AppService) {}
+  /** Set a cached value with optional TTL (seconds) */
+  async set<T>(key: string, value: T, ttl?: number): Promise<void> {
+    const serialized = JSON.stringify(value);
+    const expiry = ttl ?? this.defaultTtl;
+    await redis.set(key, serialized, 'EX', expiry);
+  }
 
-  @Get('health')
-  getHealth() {
-    return this.appService.getHealth();
+  /** Delete a cached value */
+  async del(key: string): Promise<void> {
+    await redis.del(key);
   }
 
-  @Get()
-  getInfo() {
-    return this.appService.getInfo();
+  /** Delete all keys matching a pattern */
+  async delPattern(pattern: string): Promise<void> {
+    const keys = await redis.keys(pattern);
+    if (keys.length > 0) {
+      await redis.del(...keys);
+    }
+  }
+
+  /** Check if a key exists */
+  async exists(key: string): Promise<boolean> {
+    return (await redis.exists(key)) === 1;
   }
 }
 `;
-  }
-  appService(config) {
-    return `import { Injectable } from '@nestjs/common';
+}
 
-@Injectable()
-export class AppService {
-  getHealth() {
-    return {
-      status: 'ok',
-      timestamp: new Date().toISOString(),
-      uptime: process.uptime(),
-    };
-  }
+// src/templates/i18n-templates.ts
+function i18nRequest() {
+  return `import { getRequestConfig } from 'next-intl/server';
+import { routing } from './routing';
 
-  getInfo() {
-    return {
-      name: '${config.name}',
-      version: '1.0.0',
-      environment: process.env.NODE_ENV ?? 'development',
-    };
+export default getRequestConfig(async ({ requestLocale }) => {
+  let locale = await requestLocale;
+
+  if (!locale || !routing.locales.includes(locale as any)) {
+    locale = routing.defaultLocale;
   }
+
+  return {
+    locale,
+    messages: (await import(\`../messages/\${locale}.json\`)).default,
+  };
+});
+`;
 }
+function i18nRouting() {
+  return `import { defineRouting } from 'next-intl/routing';
+
+export const routing = defineRouting({
+  locales: ['en', 'ar'],
+  defaultLocale: 'en',
+});
 `;
-  }
-  exceptionFilter() {
-    return `import {
-  ExceptionFilter,
-  Catch,
-  ArgumentsHost,
-  HttpException,
-  HttpStatus,
-} from '@nestjs/common';
-import type { Response } from 'express';
+}
+function i18nNavigation() {
+  return `import { createNavigation } from 'next-intl/navigation';
+import { routing } from './routing';
 
-@Catch()
-export class HttpExceptionFilter implements ExceptionFilter {
-  catch(exception: unknown, host: ArgumentsHost) {
-    const ctx = host.switchToHttp();
-    const response = ctx.getResponse<Response>();
+export const { Link, redirect, usePathname, useRouter, getPathname } =
+  createNavigation(routing);
+`;
+}
+function messagesEn(config) {
+  return JSON.stringify(
+    {
+      common: {
+        appName: config.pascalCase,
+        home: "Home",
+        about: "About",
+        contact: "Contact",
+        getStarted: "Get Started",
+        documentation: "Documentation",
+        language: "Language"
+      },
+      home: {
+        title: config.pascalCase,
+        description: `Production-ready monorepo with Next.js 15 and Turborepo.`,
+        frontend: "Frontend",
+        frontendDesc: "Next.js 15 with App Router",
+        backend: "Backend",
+        backendDesc: "REST API server"
+      },
+      notFound: {
+        title: "Page not found",
+        goHome: "Go Home"
+      }
+    },
+    null,
+    2
+  ) + "\n";
+}
+function messagesAr(config) {
+  return JSON.stringify(
+    {
+      common: {
+        appName: config.pascalCase,
+        home: "\u0627\u0644\u0631\u0626\u064A\u0633\u064A\u0629",
+        about: "\u062D\u0648\u0644",
+        contact: "\u0627\u062A\u0635\u0644 \u0628\u0646\u0627",
+        getStarted: "\u0627\u0628\u062F\u0623 \u0627\u0644\u0622\u0646",
+        documentation: "\u0627\u0644\u062A\u0648\u062B\u064A\u0642",
+        language: "\u0627\u0644\u0644\u063A\u0629"
+      },
+      home: {
+        title: config.pascalCase,
+        description: "\u0645\u0633\u062A\u0648\u062F\u0639 \u0625\u0646\u062A\u0627\u062C\u064A \u0645\u062A\u0643\u0627\u0645\u0644 \u0645\u0639 Next.js 15 \u0648 Turborepo.",
+        frontend: "\u0627\u0644\u0648\u0627\u062C\u0647\u0629 \u0627\u0644\u0623\u0645\u0627\u0645\u064A\u0629",
+        frontendDesc: "Next.js 15 \u0645\u0639 App Router",
+        backend: "\u0627\u0644\u062E\u0627\u062F\u0645",
+        backendDesc: "\u062E\u0627\u062F\u0645 REST API"
+      },
+      notFound: {
+        title: "\u0627\u0644\u0635\u0641\u062D\u0629 \u063A\u064A\u0631 \u0645\u0648\u062C\u0648\u062F\u0629",
+        goHome: "\u0627\u0644\u0639\u0648\u062F\u0629 \u0644\u0644\u0631\u0626\u064A\u0633\u064A\u0629"
+      }
+    },
+    null,
+    2
+  ) + "\n";
+}
+function i18nLayout(config) {
+  return `import type { Metadata } from 'next';
+import { NextIntlClientProvider } from 'next-intl';
+import { getMessages } from 'next-intl/server';
+import { notFound } from 'next/navigation';
+import { routing } from '@/i18n/routing';
+import '../globals.css';
 
-    const status =
-      exception instanceof HttpException
-        ? exception.getStatus()
-        : HttpStatus.INTERNAL_SERVER_ERROR;
+export const metadata: Metadata = {
+  title: '${config.pascalCase}',
+  description: 'Built with Next.js 15 and Turborepo',
+};
 
-    const message =
-      exception instanceof HttpException
-        ? exception.message
-        : 'Internal server error';
+export default async function LocaleLayout({
+  children,
+  params,
+}: {
+  children: React.ReactNode;
+  params: Promise<{ locale: string }>;
+}) {
+  const { locale } = await params;
 
-    response.status(status).json({
-      success: false,
-      error: {
-        code: HttpStatus[status] ?? 'UNKNOWN_ERROR',
-        message,
-      },
-      timestamp: new Date().toISOString(),
-    });
+  if (!routing.locales.includes(locale as any)) {
+    notFound();
   }
+
+  const messages = await getMessages();
+  const dir = locale === 'ar' ? 'rtl' : 'ltr';
+
+  return (
+    <html lang={locale} dir={dir}>
+      <body>
+        <NextIntlClientProvider messages={messages}>
+          {children}
+        </NextIntlClientProvider>
+      </body>
+    </html>
+  );
 }
 `;
-  }
-  loggingInterceptor() {
-    return `import {
-  Injectable,
-  NestInterceptor,
-  ExecutionContext,
-  CallHandler,
-} from '@nestjs/common';
-import { Observable, tap } from 'rxjs';
+}
+function i18nPage(config) {
+  return `import { useTranslations } from 'next-intl';
+import { Button, Card } from '@${config.name}/ui';
 
-@Injectable()
-export class LoggingInterceptor implements NestInterceptor {
-  intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
-    const request = context.switchToHttp().getRequest();
-    const method = request.method;
-    const url = request.url;
-    const startTime = Date.now();
+export default function HomePage() {
+  const t = useTranslations('home');
+  const tc = useTranslations('common');
 
-    return next.handle().pipe(
-      tap(() => {
-        const duration = Date.now() - startTime;
-        console.log(\`\${method} \${url} \u2014 \${duration}ms\`);
-      }),
-    );
-  }
+  return (
+    <main style={{
+      minHeight: '100vh',
+      display: 'flex',
+      flexDirection: 'column',
+      alignItems: 'center',
+      justifyContent: 'center',
+      padding: '2rem',
+    }}>
+      <div style={{ maxWidth: '42rem', textAlign: 'center' }}>
+        <h1 style={{ fontSize: '3rem', fontWeight: 'bold', marginBottom: '1rem' }}>
+          {t('title')}
+        </h1>
+        <p style={{ fontSize: '1.25rem', color: '#64748b', marginBottom: '2rem' }}>
+          {t('description')}
+        </p>
+
+        <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(200px, 1fr))', gap: '1rem', marginBottom: '2rem' }}>
+          <Card title={t('frontend')} description={t('frontendDesc')} />
+          <Card title={t('backend')} description={t('backendDesc')} />
+        </div>
+
+        <div style={{ display: 'flex', gap: '1rem', justifyContent: 'center' }}>
+          <Button variant="primary" size="lg">{tc('getStarted')}</Button>
+          <Button variant="outline" size="lg">{tc('documentation')}</Button>
+        </div>
+      </div>
+    </main>
+  );
 }
 `;
-  }
-  authGuard() {
-    return `import {
-  Injectable,
-  CanActivate,
-  ExecutionContext,
-  UnauthorizedException,
-} from '@nestjs/common';
+}
+function languageSwitcher() {
+  return `'use client';
 
-@Injectable()
-export class AuthGuard implements CanActivate {
-  canActivate(context: ExecutionContext): boolean {
-    const request = context.switchToHttp().getRequest();
-    const authHeader = request.headers.authorization;
+import { useLocale } from 'next-intl';
+import { useRouter, usePathname } from '@/i18n/navigation';
 
-    if (!authHeader?.startsWith('Bearer ')) {
-      throw new UnauthorizedException('Missing or invalid authorization header');
-    }
+const localeLabels: Record<string, string> = {
+  en: 'English',
+  ar: '\u0627\u0644\u0639\u0631\u0628\u064A\u0629',
+};
 
-    // TODO: Validate the token
-    return true;
+export function LanguageSwitcher() {
+  const locale = useLocale();
+  const router = useRouter();
+  const pathname = usePathname();
+
+  function handleChange(newLocale: string) {
+    router.replace(pathname, { locale: newLocale });
   }
+
+  return (
+    <select
+      value={locale}
+      onChange={(e) => handleChange(e.target.value)}
+      style={{
+        padding: '6px 12px',
+        borderRadius: '6px',
+        border: '1px solid #d1d5db',
+        background: 'white',
+        cursor: 'pointer',
+      }}
+    >
+      {Object.entries(localeLabels).map(([code, label]) => (
+        <option key={code} value={code}>
+          {label}
+        </option>
+      ))}
+    </select>
+  );
 }
 `;
-  }
-  validationPipe() {
-    return `import {
-  PipeTransform,
-  Injectable,
-  ArgumentMetadata,
-  BadRequestException,
-} from '@nestjs/common';
-import { ZodSchema, ZodError } from 'zod';
+}
 
-@Injectable()
-export class ZodValidationPipe implements PipeTransform {
-  constructor(private schema: ZodSchema) {}
+// src/templates/storybook-templates.ts
+function storybookMain(_config) {
+  return `import type { StorybookConfig } from '@storybook/react-vite';
 
-  transform(value: unknown, _metadata: ArgumentMetadata) {
-    try {
-      return this.schema.parse(value);
-    } catch (error) {
-      if (error instanceof ZodError) {
-        const details: Record<string, string[]> = {};
-        for (const issue of error.issues) {
-          const path = issue.path.join('.');
-          if (!details[path]) details[path] = [];
-          details[path].push(issue.message);
-        }
-        throw new BadRequestException({
-          message: 'Validation failed',
-          details,
-        });
-      }
-      throw new BadRequestException('Validation failed');
-    }
-  }
+const config: StorybookConfig = {
+  stories: ['../src/**/*.stories.@(ts|tsx)'],
+  addons: ['@storybook/addon-essentials'],
+  framework: {
+    name: '@storybook/react-vite',
+    options: {},
+  },
+};
+
+export default config;
+`;
+}
+function storybookPreview(_config) {
+  return `import type { Preview } from '@storybook/react';
+
+const preview: Preview = {
+  parameters: {
+    controls: {
+      matchers: {
+        color: /(background|color)$/i,
+        date: /Date$/i,
+      },
+    },
+  },
+};
+
+export default preview;
+`;
 }
+function buttonStories(_config) {
+  return `import type { Meta, StoryObj } from '@storybook/react';
+import { Button } from './button';
+
+const meta: Meta<typeof Button> = {
+  title: 'Components/Button',
+  component: Button,
+  tags: ['autodocs'],
+  argTypes: {
+    variant: { control: 'select', options: ['primary', 'secondary', 'outline', 'ghost'] },
+    size: { control: 'select', options: ['sm', 'md', 'lg'] },
+  },
+};
+
+export default meta;
+type Story = StoryObj<typeof Button>;
+
+export const Primary: Story = {
+  args: { variant: 'primary', children: 'Primary Button' },
+};
+
+export const Secondary: Story = {
+  args: { variant: 'secondary', children: 'Secondary Button' },
+};
+
+export const Outline: Story = {
+  args: { variant: 'outline', children: 'Outline Button' },
+};
+
+export const Ghost: Story = {
+  args: { variant: 'ghost', children: 'Ghost Button' },
+};
+
+export const Small: Story = {
+  args: { variant: 'primary', size: 'sm', children: 'Small' },
+};
+
+export const Large: Story = {
+  args: { variant: 'primary', size: 'lg', children: 'Large' },
+};
 `;
-  }
+}
+function cardStories(_config) {
+  return `import type { Meta, StoryObj } from '@storybook/react';
+import { Card } from './card';
+
+const meta: Meta<typeof Card> = {
+  title: 'Components/Card',
+  component: Card,
+  tags: ['autodocs'],
 };
 
-// src/templates/strategies/express-templates.ts
-var ExpressTemplateStrategy = class {
+export default meta;
+type Story = StoryObj<typeof Card>;
+
+export const Default: Story = {
+  args: {
+    title: 'Card Title',
+    description: 'This is a card description with some example text.',
+    children: 'Card content goes here.',
+  },
+};
+
+export const TitleOnly: Story = {
+  args: {
+    title: 'Just a Title',
+  },
+};
+
+export const WithContent: Story = {
+  args: {
+    title: 'Interactive Card',
+    description: 'A card with custom content.',
+    children: 'Custom child content rendered inside the card.',
+  },
+};
+`;
+}
+function inputStories(_config) {
+  return `import type { Meta, StoryObj } from '@storybook/react';
+import { Input } from './input';
+
+const meta: Meta<typeof Input> = {
+  title: 'Components/Input',
+  component: Input,
+  tags: ['autodocs'],
+};
+
+export default meta;
+type Story = StoryObj<typeof Input>;
+
+export const Default: Story = {
+  args: {
+    label: 'Email',
+    placeholder: 'Enter your email',
+  },
+};
+
+export const WithError: Story = {
+  args: {
+    label: 'Email',
+    placeholder: 'Enter your email',
+    error: 'Invalid email address',
+  },
+};
+
+export const NoLabel: Story = {
+  args: {
+    placeholder: 'Search...',
+  },
+};
+`;
+}
+
+// src/templates/strategies/nestjs-templates.ts
+var NestjsTemplateStrategy = class {
   packageJson(config) {
     return `{
   "name": "@${config.name}/api",
   "version": "0.0.0",
   "private": true,
-  "type": "module",
   "scripts": {
-    "build": "tsc",
-    "dev": "tsx watch src/main.ts",
-    "start": "node dist/main.js",
+    "build": "nest build",
+    "dev": "nest start --watch",
+    "start": "nest start",
+    "start:prod": "node dist/main",
     "lint": "eslint src --ext .ts",
     "test": "${config.testing === "vitest" ? "vitest run" : "jest"}"
   },
   "dependencies": {
-    "express": "${config.versions["express"] ?? "^5.1.0"}",
-    "cors": "${config.versions["cors"] ?? "^2.8.5"}",
+    "@nestjs/common": "${config.versions["@nestjs/common"] ?? "^11.0.20"}",
+    "@nestjs/core": "${config.versions["@nestjs/core"] ?? "^11.0.20"}",
+    "@nestjs/platform-express": "${config.versions["@nestjs/platform-express"] ?? "^11.0.20"}",
+    "reflect-metadata": "${config.versions["reflect-metadata"] ?? "^0.2.2"}",
+    "rxjs": "${config.versions["rxjs"] ?? "^7.8.2"}",
     "@${config.name}/lib": "workspace:*"${config.hasDatabase ? `,
     "@${config.name}/database": "workspace:*"` : ""}
   },
   "devDependencies": {
-    "@types/express": "${config.versions["@types/express"] ?? "^5.0.2"}",
-    "@types/cors": "${config.versions["@types/cors"] ?? "^2.8.17"}",
+    "@nestjs/cli": "${config.versions["@nestjs/cli"] ?? "^11.0.5"}",
+    "@nestjs/testing": "${config.versions["@nestjs/testing"] ?? "^11.0.20"}",
     "@types/node": "${config.versions["@types/node"] ?? "^22.15.3"}",
-    "tsx": "^4.19.4",
     "typescript": "${config.versions["typescript"] ?? "^5.8.3"}"
   }
 }
@@ -3456,13 +3921,10 @@ var ExpressTemplateStrategy = class {
   }
   tsConfig(config) {
     return `{
-  "extends": "@${config.name}/config/typescript/base",
+  "extends": "@${config.name}/config/typescript/node",
   "compilerOptions": {
     "outDir": "./dist",
-    "rootDir": "./src",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "verbatimModuleSyntax": false
+    "rootDir": "./src"
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist", "test"]
@@ -3470,52 +3932,308 @@ var ExpressTemplateStrategy = class {
 `;
   }
   mainEntry(config) {
-    return `import { createApp } from './app.js';
+    return `import { NestFactory } from '@nestjs/core';
+import { ValidationPipe } from '@nestjs/common';
+import { AppModule } from './app.module.js';
+import { HttpExceptionFilter } from './common/filters/http-exception.filter.js';
+import { LoggingInterceptor } from './common/interceptors/logging.interceptor.js';
 
-const port = process.env.PORT ?? 3001;
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
 
-const app = createApp();
+  app.enableCors({
+    origin: process.env.CORS_ORIGIN ?? 'http://localhost:3000',
+    credentials: true,
+  });
 
-app.listen(port, () => {
+  app.setGlobalPrefix('api');
+  app.useGlobalPipes(new ValidationPipe({ whitelist: true, transform: true }));
+  app.useGlobalFilters(new HttpExceptionFilter());
+  app.useGlobalInterceptors(new LoggingInterceptor());
+
+  const port = process.env.PORT ?? 3001;
+  await app.listen(port);
   console.log(\`\u{1F680} ${config.pascalCase} API running on http://localhost:\${port}/api\`);
-});
+}
+
+bootstrap();
 `;
   }
   appSetup(_config) {
-    return `import express from 'express';
-import cors from 'cors';
-import { healthRouter } from './routes/health.js';
-import { errorHandler } from './common/filters/error-handler.js';
-import { requestLogger } from './common/interceptors/request-logger.js';
-
-export function createApp() {
-  const app = express();
+    return `import { Module } from '@nestjs/common';
+import { AppController } from './app.controller.js';
+import { AppService } from './app.service.js';
 
-  // Middleware
-  app.use(cors({
-    origin: process.env.CORS_ORIGIN ?? 'http://localhost:3000',
-    credentials: true,
-  }));
-  app.use(express.json());
-  app.use(express.urlencoded({ extended: true }));
-  app.use(requestLogger);
+@Module({
+  imports: [],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}
+`;
+  }
+  appController(_config) {
+    return `import { Controller, Get } from '@nestjs/common';
+import { AppService } from './app.service.js';
 
-  // Routes
-  app.use('/api', healthRouter);
+@Controller()
+export class AppController {
+  constructor(private readonly appService: AppService) {}
 
-  // Error handling (must be last)
-  app.use(errorHandler);
+  @Get('health')
+  getHealth() {
+    return this.appService.getHealth();
+  }
 
-  return app;
+  @Get()
+  getInfo() {
+    return this.appService.getInfo();
+  }
 }
 `;
   }
-  appController(config) {
-    return `import { Router } from 'express';
-import { AppService } from '../services/app.service.js';
+  appService(config) {
+    return `import { Injectable } from '@nestjs/common';
 
-export const healthRouter = Router();
-const appService = new AppService('${config.name}');
+@Injectable()
+export class AppService {
+  getHealth() {
+    return {
+      status: 'ok',
+      timestamp: new Date().toISOString(),
+      uptime: process.uptime(),
+    };
+  }
+
+  getInfo() {
+    return {
+      name: '${config.name}',
+      version: '1.0.0',
+      environment: process.env.NODE_ENV ?? 'development',
+    };
+  }
+}
+`;
+  }
+  exceptionFilter() {
+    return `import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  HttpException,
+  HttpStatus,
+} from '@nestjs/common';
+import type { Response } from 'express';
+
+@Catch()
+export class HttpExceptionFilter implements ExceptionFilter {
+  catch(exception: unknown, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<Response>();
+
+    const status =
+      exception instanceof HttpException
+        ? exception.getStatus()
+        : HttpStatus.INTERNAL_SERVER_ERROR;
+
+    const message =
+      exception instanceof HttpException
+        ? exception.message
+        : 'Internal server error';
+
+    response.status(status).json({
+      success: false,
+      error: {
+        code: HttpStatus[status] ?? 'UNKNOWN_ERROR',
+        message,
+      },
+      timestamp: new Date().toISOString(),
+    });
+  }
+}
+`;
+  }
+  loggingInterceptor() {
+    return `import {
+  Injectable,
+  NestInterceptor,
+  ExecutionContext,
+  CallHandler,
+} from '@nestjs/common';
+import { Observable, tap } from 'rxjs';
+
+@Injectable()
+export class LoggingInterceptor implements NestInterceptor {
+  intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
+    const request = context.switchToHttp().getRequest();
+    const method = request.method;
+    const url = request.url;
+    const startTime = Date.now();
+
+    return next.handle().pipe(
+      tap(() => {
+        const duration = Date.now() - startTime;
+        console.log(\`\${method} \${url} \u2014 \${duration}ms\`);
+      }),
+    );
+  }
+}
+`;
+  }
+  authGuard() {
+    return `import {
+  Injectable,
+  CanActivate,
+  ExecutionContext,
+  UnauthorizedException,
+} from '@nestjs/common';
+
+@Injectable()
+export class AuthGuard implements CanActivate {
+  canActivate(context: ExecutionContext): boolean {
+    const request = context.switchToHttp().getRequest();
+    const authHeader = request.headers.authorization;
+
+    if (!authHeader?.startsWith('Bearer ')) {
+      throw new UnauthorizedException('Missing or invalid authorization header');
+    }
+
+    // TODO: Validate the token
+    return true;
+  }
+}
+`;
+  }
+  validationPipe() {
+    return `import {
+  PipeTransform,
+  Injectable,
+  ArgumentMetadata,
+  BadRequestException,
+} from '@nestjs/common';
+import { ZodSchema, ZodError } from 'zod';
+
+@Injectable()
+export class ZodValidationPipe implements PipeTransform {
+  constructor(private schema: ZodSchema) {}
+
+  transform(value: unknown, _metadata: ArgumentMetadata) {
+    try {
+      return this.schema.parse(value);
+    } catch (error) {
+      if (error instanceof ZodError) {
+        const details: Record<string, string[]> = {};
+        for (const issue of error.issues) {
+          const path = issue.path.join('.');
+          if (!details[path]) details[path] = [];
+          details[path].push(issue.message);
+        }
+        throw new BadRequestException({
+          message: 'Validation failed',
+          details,
+        });
+      }
+      throw new BadRequestException('Validation failed');
+    }
+  }
+}
+`;
+  }
+};
+
+// src/templates/strategies/express-templates.ts
+var ExpressTemplateStrategy = class {
+  packageJson(config) {
+    return `{
+  "name": "@${config.name}/api",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx watch src/main.ts",
+    "start": "node dist/main.js",
+    "lint": "eslint src --ext .ts",
+    "test": "${config.testing === "vitest" ? "vitest run" : "jest"}"
+  },
+  "dependencies": {
+    "express": "${config.versions["express"] ?? "^5.1.0"}",
+    "cors": "${config.versions["cors"] ?? "^2.8.5"}",
+    "@${config.name}/lib": "workspace:*"${config.hasDatabase ? `,
+    "@${config.name}/database": "workspace:*"` : ""}
+  },
+  "devDependencies": {
+    "@types/express": "${config.versions["@types/express"] ?? "^5.0.2"}",
+    "@types/cors": "${config.versions["@types/cors"] ?? "^2.8.17"}",
+    "@types/node": "${config.versions["@types/node"] ?? "^22.15.3"}",
+    "tsx": "^4.19.4",
+    "typescript": "${config.versions["typescript"] ?? "^5.8.3"}"
+  }
+}
+`;
+  }
+  tsConfig(config) {
+    return `{
+  "extends": "@${config.name}/config/typescript/base",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "verbatimModuleSyntax": false
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test"]
+}
+`;
+  }
+  mainEntry(config) {
+    return `import { createApp } from './app.js';
+
+const port = process.env.PORT ?? 3001;
+
+const app = createApp();
+
+app.listen(port, () => {
+  console.log(\`\u{1F680} ${config.pascalCase} API running on http://localhost:\${port}/api\`);
+});
+`;
+  }
+  appSetup(_config) {
+    return `import express from 'express';
+import cors from 'cors';
+import { healthRouter } from './routes/health.js';
+import { errorHandler } from './common/filters/error-handler.js';
+import { requestLogger } from './common/interceptors/request-logger.js';
+
+export function createApp() {
+  const app = express();
+
+  // Middleware
+  app.use(cors({
+    origin: process.env.CORS_ORIGIN ?? 'http://localhost:3000',
+    credentials: true,
+  }));
+  app.use(express.json());
+  app.use(express.urlencoded({ extended: true }));
+  app.use(requestLogger);
+
+  // Routes
+  app.use('/api', healthRouter);
+
+  // Error handling (must be last)
+  app.use(errorHandler);
+
+  return app;
+}
+`;
+  }
+  appController(config) {
+    return `import { Router } from 'express';
+import { AppService } from '../services/app.service.js';
+
+export const healthRouter = Router();
+const appService = new AppService('${config.name}');
 
 healthRouter.get('/health', (_req, res) => {
   res.json(appService.getHealth());
@@ -4309,184 +5027,2173 @@ var JotaiTemplateStrategy = class {
 export { themeAtom } from './theme-atom.js';
 `;
   }
-  exampleStore() {
-    return `import { atom, useAtom } from 'jotai';
-import { atomWithStorage } from 'jotai/utils';
-
-type Theme = 'light' | 'dark' | 'system';
+  exampleStore() {
+    return `import { atom, useAtom } from 'jotai';
+import { atomWithStorage } from 'jotai/utils';
+
+type Theme = 'light' | 'dark' | 'system';
+
+/** Persisted theme atom */
+export const themeAtom = atomWithStorage<Theme>('theme', 'system');
+
+/** Derived atom that resolves 'system' to actual theme */
+export const resolvedThemeAtom = atom((get) => {
+  const theme = get(themeAtom);
+  if (theme !== 'system') return theme;
+
+  if (typeof window === 'undefined') return 'light';
+  return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
+});
+
+/** Convenience hook for theme management */
+export function useTheme() {
+  const [theme, setTheme] = useAtom(themeAtom);
+  return { theme, setTheme };
+}
+`;
+  }
+  /** Jotai works without a provider (uses default store) */
+  providerWrapper() {
+    return "";
+  }
+};
+
+// src/templates/strategies/redux-templates.ts
+var ReduxTemplateStrategy = class {
+  storeSetup() {
+    return `import { configureStore } from '@reduxjs/toolkit';
+import { useDispatch, useSelector } from 'react-redux';
+import type { TypedUseSelectorHook } from 'react-redux';
+import { themeReducer } from './theme-slice.js';
+
+export const store = configureStore({
+  reducer: {
+    theme: themeReducer,
+  },
+});
+
+export type RootState = ReturnType<typeof store.getState>;
+export type AppDispatch = typeof store.dispatch;
+
+/** Typed dispatch hook */
+export const useAppDispatch: () => AppDispatch = useDispatch;
+
+/** Typed selector hook */
+export const useAppSelector: TypedUseSelectorHook<RootState> = useSelector;
+`;
+  }
+  exampleStore() {
+    return `import { createSlice } from '@reduxjs/toolkit';
+import type { PayloadAction } from '@reduxjs/toolkit';
+
+type Theme = 'light' | 'dark' | 'system';
+
+interface ThemeState {
+  theme: Theme;
+}
+
+const initialState: ThemeState = {
+  theme: 'system',
+};
+
+const themeSlice = createSlice({
+  name: 'theme',
+  initialState,
+  reducers: {
+    setTheme(state, action: PayloadAction<Theme>) {
+      state.theme = action.payload;
+    },
+    toggleTheme(state) {
+      state.theme = state.theme === 'dark' ? 'light' : 'dark';
+    },
+  },
+});
+
+export const { setTheme, toggleTheme } = themeSlice.actions;
+export const themeReducer = themeSlice.reducer;
+`;
+  }
+  providerWrapper() {
+    return `'use client';
+
+import { Provider } from 'react-redux';
+import { store } from './store';
+
+export function StoreProvider({ children }: { children: React.ReactNode }) {
+  return <Provider store={store}>{children}</Provider>;
+}
+`;
+  }
+};
+
+// src/templates/strategies/tanstack-query-templates.ts
+var TanstackQueryTemplateStrategy = class {
+  storeSetup() {
+    return `/**
+ * TanStack Query setup and utilities.
+ */
+
+export { queryClient } from './query-client.js';
+export { QueryProvider } from './provider.js';
+`;
+  }
+  exampleStore(_config) {
+    return `import { QueryClient } from '@tanstack/react-query';
+
+export const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      staleTime: 60 * 1000, // 1 minute
+      retry: 1,
+      refetchOnWindowFocus: false,
+    },
+    mutations: {
+      retry: 0,
+    },
+  },
+});
+
+/**
+ * Example query hook \u2014 fetches health status from the API.
+ */
+export function useHealthQuery() {
+  const apiUrl = process.env.NEXT_PUBLIC_API_URL ?? 'http://localhost:3001';
+
+  return {
+    queryKey: ['health'],
+    queryFn: async () => {
+      const response = await fetch(\`\${apiUrl}/api/health\`);
+      if (!response.ok) throw new Error('API health check failed');
+      return response.json();
+    },
+  };
+}
+`;
+  }
+  providerWrapper() {
+    return `'use client';
+
+import { QueryClientProvider } from '@tanstack/react-query';
+import { queryClient } from './query-client';
+
+export function QueryProvider({ children }: { children: React.ReactNode }) {
+  return (
+    <QueryClientProvider client={queryClient}>
+      {children}
+    </QueryClientProvider>
+  );
+}
+`;
+  }
+};
+
+// src/templates/strategies/state-factory.ts
+function createStateStrategy(state) {
+  switch (state) {
+    case "zustand":
+      return new ZustandTemplateStrategy();
+    case "jotai":
+      return new JotaiTemplateStrategy();
+    case "redux":
+      return new ReduxTemplateStrategy();
+    case "tanstack-query":
+      return new TanstackQueryTemplateStrategy();
+    case "none":
+      return null;
+  }
+}
+
+// src/templates/strategies/docker-full-templates.ts
+var DockerFullTemplateStrategy = class {
+  webDockerfile(config) {
+    return `# \u2500\u2500 Stage 1: Dependencies \u2500\u2500
+FROM node:20-alpine AS deps
+RUN apk add --no-cache libc6-compat
+WORKDIR /app
+COPY package.json ${config.packageManager === "pnpm" ? "pnpm-lock.yaml pnpm-workspace.yaml" : "package-lock.json"} ./
+COPY apps/web/package.json ./apps/web/
+COPY packages/ui/package.json ./packages/ui/
+COPY packages/lib/package.json ./packages/lib/
+COPY packages/config/package.json ./packages/config/
+${config.packageManager === "pnpm" ? "RUN corepack enable pnpm && pnpm install --frozen-lockfile" : "RUN npm ci"}
+
+# \u2500\u2500 Stage 2: Build \u2500\u2500
+FROM node:20-alpine AS builder
+WORKDIR /app
+COPY --from=deps /app/node_modules ./node_modules
+COPY . .
+RUN ${config.packageManager === "pnpm" ? "corepack enable pnpm && pnpm" : "npm run"} build --filter=@${config.name}/web
+
+# \u2500\u2500 Stage 3: Runner \u2500\u2500
+FROM node:20-alpine AS runner
+WORKDIR /app
+ENV NODE_ENV=production
+RUN addgroup --system --gid 1001 nodejs && adduser --system --uid 1001 nextjs
+
+COPY --from=builder /app/apps/web/public ./apps/web/public
+COPY --from=builder --chown=nextjs:nodejs /app/apps/web/.next/standalone ./
+COPY --from=builder --chown=nextjs:nodejs /app/apps/web/.next/static ./apps/web/.next/static
+
+USER nextjs
+EXPOSE 3000
+ENV PORT=3000 HOSTNAME="0.0.0.0"
+CMD ["node", "apps/web/server.js"]
+`;
+  }
+  apiDockerfile(config) {
+    return `# \u2500\u2500 Stage 1: Dependencies \u2500\u2500
+FROM node:20-alpine AS deps
+WORKDIR /app
+COPY package.json ${config.packageManager === "pnpm" ? "pnpm-lock.yaml pnpm-workspace.yaml" : "package-lock.json"} ./
+COPY apps/api/package.json ./apps/api/
+COPY packages/lib/package.json ./packages/lib/
+COPY packages/config/package.json ./packages/config/
+${config.hasDatabase ? `COPY packages/database/package.json ./packages/database/` : ""}
+${config.packageManager === "pnpm" ? "RUN corepack enable pnpm && pnpm install --frozen-lockfile" : "RUN npm ci"}
+
+# \u2500\u2500 Stage 2: Build \u2500\u2500
+FROM node:20-alpine AS builder
+WORKDIR /app
+COPY --from=deps /app/node_modules ./node_modules
+COPY . .
+RUN ${config.packageManager === "pnpm" ? "corepack enable pnpm && pnpm" : "npm run"} build --filter=@${config.name}/api
+
+# \u2500\u2500 Stage 3: Runner \u2500\u2500
+FROM node:20-alpine AS runner
+WORKDIR /app
+ENV NODE_ENV=production
+RUN addgroup --system --gid 1001 nodejs && adduser --system --uid 1001 appuser
+
+COPY --from=builder --chown=appuser:nodejs /app/apps/api/dist ./dist
+COPY --from=builder /app/node_modules ./node_modules
+${config.orm === "prisma" ? "COPY --from=builder /app/packages/database/prisma ./prisma" : ""}
+
+USER appuser
+EXPOSE 3001
+ENV PORT=3001
+CMD ["node", "dist/main.js"]
+`;
+  }
+  dockerComposeProd(config) {
+    let services = `  web:
+    build:
+      context: .
+      dockerfile: apps/web/Dockerfile
+    ports:
+      - "3000:3000"
+    environment:
+      - NEXT_PUBLIC_API_URL=http://api:3001
+    depends_on:
+      - api
+    restart: unless-stopped
+
+  api:
+    build:
+      context: .
+      dockerfile: apps/api/Dockerfile
+    ports:
+      - "3001:3001"
+    env_file:
+      - .env
+    restart: unless-stopped
+`;
+    if (config.hasDatabase && config.db !== "sqlite") {
+      services += `    depends_on:
+      - db
+`;
+    }
+    if (config.hasCache) {
+      services += `
+  redis:
+    image: redis:7-alpine
+    container_name: ${config.name}-redis
+    ports:
+      - "6379:6379"
+    restart: unless-stopped
+`;
+    }
+    services += `
+  nginx:
+    build:
+      context: ./nginx
+      dockerfile: Dockerfile
+    ports:
+      - "80:80"
+    depends_on:
+      - web
+      - api
+    restart: unless-stopped
+`;
+    return `services:
+${services}`;
+  }
+  dockerignore(_config) {
+    return `node_modules
+.next
+dist
+.git
+.gitignore
+*.md
+.env*
+!.env.example
+coverage
+.turbo
+`;
+  }
+  extraFiles(_config) {
+    return {
+      "nginx/nginx.conf": `events {
+  worker_connections 1024;
+}
+
+http {
+  upstream web {
+    server web:3000;
+  }
+
+  upstream api {
+    server api:3001;
+  }
+
+  server {
+    listen 80;
+    server_name localhost;
+
+    location / {
+      proxy_pass http://web;
+      proxy_set_header Host $host;
+      proxy_set_header X-Real-IP $remote_addr;
+      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+      proxy_set_header X-Forwarded-Proto $scheme;
+    }
+
+    location /api/ {
+      proxy_pass http://api;
+      proxy_set_header Host $host;
+      proxy_set_header X-Real-IP $remote_addr;
+      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+      proxy_set_header X-Forwarded-Proto $scheme;
+    }
+  }
+}
+`,
+      "nginx/Dockerfile": `FROM nginx:alpine
+COPY nginx.conf /etc/nginx/nginx.conf
+EXPOSE 80
+CMD ["nginx", "-g", "daemon off;"]
+`
+    };
+  }
+};
+
+// src/templates/strategies/docker-minimal-templates.ts
+var DockerMinimalTemplateStrategy = class {
+  webDockerfile(config) {
+    return `FROM node:20-alpine
+WORKDIR /app
+COPY . .
+${config.packageManager === "pnpm" ? "RUN corepack enable pnpm && pnpm install --frozen-lockfile" : "RUN npm ci"}
+RUN ${config.packageManager === "pnpm" ? "pnpm" : "npm run"} build --filter=@${config.name}/web
+EXPOSE 3000
+CMD ["node", "apps/web/.next/standalone/apps/web/server.js"]
+`;
+  }
+  apiDockerfile(config) {
+    return `FROM node:20-alpine
+WORKDIR /app
+COPY . .
+${config.packageManager === "pnpm" ? "RUN corepack enable pnpm && pnpm install --frozen-lockfile" : "RUN npm ci"}
+RUN ${config.packageManager === "pnpm" ? "pnpm" : "npm run"} build --filter=@${config.name}/api
+EXPOSE 3001
+CMD ["node", "apps/api/dist/main.js"]
+`;
+  }
+  dockerComposeProd(_config) {
+    return `services:
+  web:
+    build:
+      context: .
+      dockerfile: apps/web/Dockerfile
+    ports:
+      - "3000:3000"
+    environment:
+      - NEXT_PUBLIC_API_URL=http://api:3001
+    depends_on:
+      - api
+    restart: unless-stopped
+
+  api:
+    build:
+      context: .
+      dockerfile: apps/api/Dockerfile
+    ports:
+      - "3001:3001"
+    env_file:
+      - .env
+    restart: unless-stopped
+`;
+  }
+  dockerignore(_config) {
+    return `node_modules
+.next
+dist
+.git
+*.md
+.env*
+!.env.example
+coverage
+.turbo
+`;
+  }
+  extraFiles(_config) {
+    return {};
+  }
+};
+
+// src/templates/strategies/docker-factory.ts
+function createDockerStrategy(docker) {
+  switch (docker) {
+    case "full":
+      return new DockerFullTemplateStrategy();
+    case "minimal":
+      return new DockerMinimalTemplateStrategy();
+    case "none":
+      return null;
+  }
+}
+
+// src/templates/strategies/playwright-templates.ts
+var PlaywrightTemplateStrategy = class {
+  config(_config) {
+    return `import { defineConfig, devices } from '@playwright/test';
+
+export default defineConfig({
+  testDir: './e2e',
+  fullyParallel: true,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: process.env.CI ? 1 : undefined,
+  reporter: process.env.CI ? 'github' : 'html',
+  use: {
+    baseURL: 'http://localhost:3000',
+    trace: 'on-first-retry',
+    screenshot: 'only-on-failure',
+  },
+  projects: [
+    { name: 'chromium', use: { ...devices['Desktop Chrome'] } },
+    { name: 'firefox', use: { ...devices['Desktop Firefox'] } },
+    { name: 'webkit', use: { ...devices['Desktop Safari'] } },
+  ],
+  webServer: {
+    command: 'pnpm dev',
+    url: 'http://localhost:3000',
+    reuseExistingServer: !process.env.CI,
+    timeout: 120_000,
+  },
+});
+`;
+  }
+  exampleTest(_config) {
+    return `import { test, expect } from '@playwright/test';
+
+test.describe('Home Page', () => {
+  test('should display the heading', async ({ page }) => {
+    await page.goto('/');
+    await expect(page.locator('h1')).toBeVisible();
+  });
+
+  test('should have correct title', async ({ page }) => {
+    await page.goto('/');
+    await expect(page).toHaveTitle(/.*$/);
+  });
+
+  test('should navigate without errors', async ({ page }) => {
+    const response = await page.goto('/');
+    expect(response?.status()).toBeLessThan(400);
+  });
+});
+`;
+  }
+  ciWorkflow(_config) {
+    return `
+  e2e:
+    name: E2E Tests
+    runs-on: ubuntu-latest
+    needs: ci
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Install Playwright browsers
+        run: npx playwright install --with-deps chromium
+
+      - name: Build
+        run: pnpm build
+
+      - name: Run E2E tests
+        run: cd apps/web && npx playwright test --project=chromium
+`;
+  }
+};
+
+// src/templates/strategies/cypress-templates.ts
+var CypressTemplateStrategy = class {
+  config(_config) {
+    return `import { defineConfig } from 'cypress';
+
+export default defineConfig({
+  e2e: {
+    baseUrl: 'http://localhost:3000',
+    supportFile: false,
+    specPattern: 'cypress/e2e/**/*.cy.{ts,tsx}',
+    viewportWidth: 1280,
+    viewportHeight: 720,
+    video: false,
+    screenshotOnRunFailure: true,
+  },
+});
+`;
+  }
+  exampleTest(_config) {
+    return `describe('Home Page', () => {
+  beforeEach(() => {
+    cy.visit('/');
+  });
+
+  it('should display the heading', () => {
+    cy.get('h1').should('be.visible');
+  });
+
+  it('should load without errors', () => {
+    cy.request('/').its('status').should('be.lessThan', 400);
+  });
+
+  it('should have navigation elements', () => {
+    cy.get('button').should('exist');
+  });
+});
+`;
+  }
+  ciWorkflow(_config) {
+    return `
+  e2e:
+    name: E2E Tests
+    runs-on: ubuntu-latest
+    needs: ci
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Build
+        run: pnpm build
+
+      - name: Run Cypress tests
+        uses: cypress-io/github-action@v6
+        with:
+          working-directory: apps/web
+          start: pnpm start
+          wait-on: 'http://localhost:3000'
+`;
+  }
+};
+
+// src/templates/strategies/e2e-factory.ts
+function createE2eStrategy(e2e) {
+  switch (e2e) {
+    case "playwright":
+      return new PlaywrightTemplateStrategy();
+    case "cypress":
+      return new CypressTemplateStrategy();
+    case "none":
+      return null;
+  }
+}
+
+// src/templates/strategies/pino-templates.ts
+var PinoTemplateStrategy = class {
+  loggerSetup(_config) {
+    return `import pino from 'pino';
+
+const isProduction = process.env.NODE_ENV === 'production';
+
+export const logger = pino({
+  level: process.env.LOG_LEVEL ?? (isProduction ? 'info' : 'debug'),
+  ...(isProduction
+    ? {}
+    : {
+        transport: {
+          target: 'pino-pretty',
+          options: {
+            colorize: true,
+            translateTime: 'HH:MM:ss',
+            ignore: 'pid,hostname',
+          },
+        },
+      }),
+});
+
+/** Create a child logger with a context label */
+export function createLogger(context: string) {
+  return logger.child({ context });
+}
+`;
+  }
+  index(_config) {
+    return `export { logger, createLogger } from './logger.js';
+`;
+  }
+};
+
+// src/templates/strategies/winston-templates.ts
+var WinstonTemplateStrategy = class {
+  loggerSetup(_config) {
+    return `import winston from 'winston';
+
+const isProduction = process.env.NODE_ENV === 'production';
+
+export const logger = winston.createLogger({
+  level: process.env.LOG_LEVEL ?? (isProduction ? 'info' : 'debug'),
+  format: isProduction
+    ? winston.format.combine(winston.format.timestamp(), winston.format.json())
+    : winston.format.combine(
+        winston.format.colorize(),
+        winston.format.timestamp({ format: 'HH:mm:ss' }),
+        winston.format.printf(({ timestamp, level, message, context, ...meta }) => {
+          const ctx = context ? \` [\${context}]\` : '';
+          const metaStr = Object.keys(meta).length ? \` \${JSON.stringify(meta)}\` : '';
+          return \`\${timestamp} \${level}\${ctx}: \${message}\${metaStr}\`;
+        }),
+      ),
+  transports: [
+    new winston.transports.Console(),
+  ],
+});
+
+/** Create a child logger with a context label */
+export function createLogger(context: string) {
+  return logger.child({ context });
+}
+`;
+  }
+  index(_config) {
+    return `export { logger, createLogger } from './logger.js';
+`;
+  }
+};
+
+// src/templates/strategies/logging-factory.ts
+function createLoggingStrategy(logging) {
+  switch (logging) {
+    case "pino":
+      return new PinoTemplateStrategy();
+    case "winston":
+      return new WinstonTemplateStrategy();
+    case "default":
+      return null;
+  }
+}
+
+// src/templates/strategies/resend-templates.ts
+var ResendTemplateStrategy = class {
+  packageJson(config) {
+    return `{
+  "name": "@${config.name}/email",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "resend": "${config.versions["resend"] ?? "^4.1.0"}",
+    "@react-email/components": "${config.versions["@react-email/components"] ?? "^0.0.36"}",
+    "react": "${config.versions["react"] ?? "^19.1.0"}"
+  },
+  "devDependencies": {
+    "typescript": "${config.versions["typescript"] ?? "^5.8.3"}"
+  }
+}
+`;
+  }
+  index(_config) {
+    return `export { sendEmail } from './send.js';
+export { resend } from './client.js';
+`;
+  }
+  client(_config) {
+    return `import { Resend } from 'resend';
+
+export const resend = new Resend(process.env.RESEND_API_KEY);
+`;
+  }
+  sendFunction(_config) {
+    return `import { resend } from './client.js';
+
+interface SendEmailOptions {
+  to: string | string[];
+  subject: string;
+  react: React.ReactElement;
+}
+
+export async function sendEmail({ to, subject, react }: SendEmailOptions) {
+  const { data, error } = await resend.emails.send({
+    from: process.env.EMAIL_FROM ?? 'noreply@example.com',
+    to: Array.isArray(to) ? to : [to],
+    subject,
+    react,
+  });
+
+  if (error) {
+    throw new Error(\`Failed to send email: \${error.message}\`);
+  }
+
+  return data;
+}
+`;
+  }
+  welcomeTemplate(config) {
+    return `import { Html, Head, Body, Container, Heading, Text, Button } from '@react-email/components';
+
+interface WelcomeEmailProps {
+  name: string;
+}
+
+export function WelcomeEmail({ name }: WelcomeEmailProps) {
+  return (
+    <Html>
+      <Head />
+      <Body style={{ fontFamily: 'system-ui, sans-serif', background: '#f9fafb' }}>
+        <Container style={{ maxWidth: '600px', margin: '0 auto', padding: '40px 20px' }}>
+          <Heading style={{ fontSize: '24px', color: '#111827' }}>
+            Welcome to ${config.pascalCase}!
+          </Heading>
+          <Text style={{ fontSize: '16px', color: '#4b5563' }}>
+            Hi {name}, thank you for signing up. We're excited to have you on board.
+          </Text>
+          <Button
+            href={process.env.NEXT_PUBLIC_APP_URL ?? 'http://localhost:3000'}
+            style={{ background: '#2563eb', color: 'white', padding: '12px 24px', borderRadius: '8px', textDecoration: 'none' }}
+          >
+            Get Started
+          </Button>
+        </Container>
+      </Body>
+    </Html>
+  );
+}
+`;
+  }
+  resetPasswordTemplate(config) {
+    return `import { Html, Head, Body, Container, Heading, Text, Button } from '@react-email/components';
+
+interface ResetPasswordEmailProps {
+  resetUrl: string;
+}
+
+export function ResetPasswordEmail({ resetUrl }: ResetPasswordEmailProps) {
+  return (
+    <Html>
+      <Head />
+      <Body style={{ fontFamily: 'system-ui, sans-serif', background: '#f9fafb' }}>
+        <Container style={{ maxWidth: '600px', margin: '0 auto', padding: '40px 20px' }}>
+          <Heading style={{ fontSize: '24px', color: '#111827' }}>
+            Reset Your Password
+          </Heading>
+          <Text style={{ fontSize: '16px', color: '#4b5563' }}>
+            Click the button below to reset your ${config.pascalCase} password. This link expires in 1 hour.
+          </Text>
+          <Button
+            href={resetUrl}
+            style={{ background: '#2563eb', color: 'white', padding: '12px 24px', borderRadius: '8px', textDecoration: 'none' }}
+          >
+            Reset Password
+          </Button>
+          <Text style={{ fontSize: '14px', color: '#9ca3af', marginTop: '24px' }}>
+            If you didn't request this, you can safely ignore this email.
+          </Text>
+        </Container>
+      </Body>
+    </Html>
+  );
+}
+`;
+  }
+};
+
+// src/templates/strategies/nodemailer-templates.ts
+var NodemailerTemplateStrategy = class {
+  packageJson(config) {
+    return `{
+  "name": "@${config.name}/email",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "nodemailer": "${config.versions["nodemailer"] ?? "^6.10.0"}"
+  },
+  "devDependencies": {
+    "@types/nodemailer": "${config.versions["@types/nodemailer"] ?? "^6.4.17"}",
+    "typescript": "${config.versions["typescript"] ?? "^5.8.3"}"
+  }
+}
+`;
+  }
+  index(_config) {
+    return `export { sendEmail } from './send.js';
+export { transporter } from './client.js';
+`;
+  }
+  client(_config) {
+    return `import nodemailer from 'nodemailer';
+
+export const transporter = nodemailer.createTransport({
+  host: process.env.SMTP_HOST ?? 'smtp.gmail.com',
+  port: Number(process.env.SMTP_PORT ?? 587),
+  secure: process.env.SMTP_SECURE === 'true',
+  auth: {
+    user: process.env.SMTP_USER,
+    pass: process.env.SMTP_PASS,
+  },
+});
+`;
+  }
+  sendFunction(_config) {
+    return `import { transporter } from './client.js';
+
+interface SendEmailOptions {
+  to: string | string[];
+  subject: string;
+  html: string;
+  text?: string;
+}
+
+export async function sendEmail({ to, subject, html, text }: SendEmailOptions) {
+  const info = await transporter.sendMail({
+    from: process.env.EMAIL_FROM ?? 'noreply@example.com',
+    to: Array.isArray(to) ? to.join(', ') : to,
+    subject,
+    html,
+    text,
+  });
+
+  return { messageId: info.messageId };
+}
+`;
+  }
+  welcomeTemplate(config) {
+    return `/** Generate welcome email HTML */
+export function welcomeEmailHtml(name: string): string {
+  const appUrl = process.env.NEXT_PUBLIC_APP_URL ?? 'http://localhost:3000';
+
+  return \`<!DOCTYPE html>
+<html>
+<body style="font-family: system-ui, sans-serif; background: #f9fafb; padding: 40px 0;">
+  <div style="max-width: 600px; margin: 0 auto; padding: 40px 20px;">
+    <h1 style="font-size: 24px; color: #111827;">Welcome to ${config.pascalCase}!</h1>
+    <p style="font-size: 16px; color: #4b5563;">
+      Hi \${name}, thank you for signing up. We're excited to have you on board.
+    </p>
+    <a href="\${appUrl}" style="display: inline-block; background: #2563eb; color: white; padding: 12px 24px; border-radius: 8px; text-decoration: none;">
+      Get Started
+    </a>
+  </div>
+</body>
+</html>\`;
+}
+`;
+  }
+  resetPasswordTemplate(config) {
+    return `/** Generate password reset email HTML */
+export function resetPasswordEmailHtml(resetUrl: string): string {
+  return \`<!DOCTYPE html>
+<html>
+<body style="font-family: system-ui, sans-serif; background: #f9fafb; padding: 40px 0;">
+  <div style="max-width: 600px; margin: 0 auto; padding: 40px 20px;">
+    <h1 style="font-size: 24px; color: #111827;">Reset Your Password</h1>
+    <p style="font-size: 16px; color: #4b5563;">
+      Click the button below to reset your ${config.pascalCase} password. This link expires in 1 hour.
+    </p>
+    <a href="\${resetUrl}" style="display: inline-block; background: #2563eb; color: white; padding: 12px 24px; border-radius: 8px; text-decoration: none;">
+      Reset Password
+    </a>
+    <p style="font-size: 14px; color: #9ca3af; margin-top: 24px;">
+      If you didn't request this, you can safely ignore this email.
+    </p>
+  </div>
+</body>
+</html>\`;
+}
+`;
+  }
+};
+
+// src/templates/strategies/sendgrid-templates.ts
+var SendGridTemplateStrategy = class {
+  packageJson(config) {
+    return `{
+  "name": "@${config.name}/email",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "@sendgrid/mail": "${config.versions["@sendgrid/mail"] ?? "^8.1.0"}"
+  },
+  "devDependencies": {
+    "typescript": "${config.versions["typescript"] ?? "^5.8.3"}"
+  }
+}
+`;
+  }
+  index(_config) {
+    return `export { sendEmail } from './send.js';
+export { sgMail } from './client.js';
+`;
+  }
+  client(_config) {
+    return `import sgMail from '@sendgrid/mail';
+
+sgMail.setApiKey(process.env.SENDGRID_API_KEY ?? '');
+
+export { sgMail };
+`;
+  }
+  sendFunction(_config) {
+    return `import { sgMail } from './client.js';
+
+interface SendEmailOptions {
+  to: string | string[];
+  subject: string;
+  html: string;
+  text?: string;
+}
+
+export async function sendEmail({ to, subject, html, text }: SendEmailOptions) {
+  const msg = {
+    to,
+    from: process.env.EMAIL_FROM ?? 'noreply@example.com',
+    subject,
+    html,
+    text: text ?? '',
+  };
+
+  const [response] = await sgMail.send(msg);
+  return { statusCode: response.statusCode };
+}
+`;
+  }
+  welcomeTemplate(config) {
+    return `/** Generate welcome email HTML */
+export function welcomeEmailHtml(name: string): string {
+  const appUrl = process.env.NEXT_PUBLIC_APP_URL ?? 'http://localhost:3000';
+
+  return \`<!DOCTYPE html>
+<html>
+<body style="font-family: system-ui, sans-serif; background: #f9fafb; padding: 40px 0;">
+  <div style="max-width: 600px; margin: 0 auto; padding: 40px 20px;">
+    <h1 style="font-size: 24px; color: #111827;">Welcome to ${config.pascalCase}!</h1>
+    <p style="font-size: 16px; color: #4b5563;">Hi \${name}, thank you for signing up.</p>
+    <a href="\${appUrl}" style="display: inline-block; background: #2563eb; color: white; padding: 12px 24px; border-radius: 8px; text-decoration: none;">Get Started</a>
+  </div>
+</body>
+</html>\`;
+}
+`;
+  }
+  resetPasswordTemplate(config) {
+    return `/** Generate password reset email HTML */
+export function resetPasswordEmailHtml(resetUrl: string): string {
+  return \`<!DOCTYPE html>
+<html>
+<body style="font-family: system-ui, sans-serif; background: #f9fafb; padding: 40px 0;">
+  <div style="max-width: 600px; margin: 0 auto; padding: 40px 20px;">
+    <h1 style="font-size: 24px; color: #111827;">Reset Your Password</h1>
+    <p style="font-size: 16px; color: #4b5563;">Click below to reset your ${config.pascalCase} password.</p>
+    <a href="\${resetUrl}" style="display: inline-block; background: #2563eb; color: white; padding: 12px 24px; border-radius: 8px; text-decoration: none;">Reset Password</a>
+  </div>
+</body>
+</html>\`;
+}
+`;
+  }
+};
+
+// src/templates/strategies/email-factory.ts
+function createEmailStrategy(email) {
+  switch (email) {
+    case "resend":
+      return new ResendTemplateStrategy();
+    case "nodemailer":
+      return new NodemailerTemplateStrategy();
+    case "sendgrid":
+      return new SendGridTemplateStrategy();
+    case "none":
+      return null;
+  }
+}
+
+// src/templates/strategies/s3-templates.ts
+var S3TemplateStrategy = class {
+  packageJson(config) {
+    return `{
+  "name": "@${config.name}/storage",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "${config.versions["@aws-sdk/client-s3"] ?? "^3.750.0"}",
+    "@aws-sdk/s3-request-presigner": "${config.versions["@aws-sdk/s3-request-presigner"] ?? "^3.750.0"}"
+  },
+  "devDependencies": {
+    "typescript": "${config.versions["typescript"] ?? "^5.8.3"}"
+  }
+}
+`;
+  }
+  index(_config) {
+    return `export { s3Client } from './client.js';
+export { uploadFile, getUploadUrl } from './upload.js';
+export { getDownloadUrl } from './download.js';
+`;
+  }
+  client(_config) {
+    return `import { S3Client } from '@aws-sdk/client-s3';
+
+export const s3Client = new S3Client({
+  region: process.env.AWS_REGION ?? 'us-east-1',
+  credentials: {
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID ?? '',
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY ?? '',
+  },
+  ...(process.env.S3_ENDPOINT ? { endpoint: process.env.S3_ENDPOINT, forcePathStyle: true } : {}),
+});
+
+export const BUCKET_NAME = process.env.S3_BUCKET ?? 'uploads';
+`;
+  }
+  uploadService(_config) {
+    return `import { PutObjectCommand } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { s3Client, BUCKET_NAME } from './client.js';
+
+/** Upload a file buffer directly to S3 */
+export async function uploadFile(key: string, body: Buffer, contentType: string) {
+  const command = new PutObjectCommand({
+    Bucket: BUCKET_NAME,
+    Key: key,
+    Body: body,
+    ContentType: contentType,
+  });
+
+  await s3Client.send(command);
+  return { key, bucket: BUCKET_NAME };
+}
+
+/** Generate a presigned upload URL (client uploads directly to S3) */
+export async function getUploadUrl(key: string, contentType: string, expiresIn = 3600) {
+  const command = new PutObjectCommand({
+    Bucket: BUCKET_NAME,
+    Key: key,
+    ContentType: contentType,
+  });
+
+  const url = await getSignedUrl(s3Client, command, { expiresIn });
+  return { url, key };
+}
+`;
+  }
+  downloadService(_config) {
+    return `import { GetObjectCommand } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { s3Client, BUCKET_NAME } from './client.js';
+
+/** Generate a presigned download URL */
+export async function getDownloadUrl(key: string, expiresIn = 3600) {
+  const command = new GetObjectCommand({
+    Bucket: BUCKET_NAME,
+    Key: key,
+  });
+
+  return getSignedUrl(s3Client, command, { expiresIn });
+}
+`;
+  }
+  apiRoutes(_config) {
+    return {};
+  }
+};
+
+// src/templates/strategies/uploadthing-templates.ts
+var UploadThingTemplateStrategy = class {
+  packageJson(config) {
+    return `{
+  "name": "@${config.name}/storage",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "uploadthing": "${config.versions["uploadthing"] ?? "^7.6.0"}",
+    "@uploadthing/react": "${config.versions["@uploadthing/react"] ?? "^7.3.0"}"
+  },
+  "devDependencies": {
+    "typescript": "${config.versions["typescript"] ?? "^5.8.3"}"
+  }
+}
+`;
+  }
+  index(_config) {
+    return `export { utapi } from './client.js';
+`;
+  }
+  client(_config) {
+    return `import { UTApi } from 'uploadthing/server';
+
+export const utapi = new UTApi();
+`;
+  }
+  uploadService(_config) {
+    return `// UploadThing handles uploads via file router (see apps/web/app/api/uploadthing/)
+// Use the utapi for server-side file operations
+
+export { utapi } from './client.js';
+`;
+  }
+  downloadService(_config) {
+    return `import { utapi } from './client.js';
+
+/** Get file URLs from UploadThing */
+export async function getFileUrls(fileKeys: string[]) {
+  const response = await utapi.getFileUrls(fileKeys);
+  return response.data;
+}
+
+/** Delete files from UploadThing */
+export async function deleteFiles(fileKeys: string[]) {
+  await utapi.deleteFiles(fileKeys);
+}
+`;
+  }
+  apiRoutes(_config) {
+    return {
+      "apps/web/app/api/uploadthing/core.ts": `import { createUploadthing, type FileRouter } from 'uploadthing/next';
+
+const f = createUploadthing();
+
+export const ourFileRouter = {
+  imageUploader: f({ image: { maxFileSize: '4MB', maxFileCount: 4 } })
+    .onUploadComplete(async ({ file }) => {
+      console.log('Upload complete:', file.url);
+      return { url: file.url };
+    }),
+
+  documentUploader: f({ pdf: { maxFileSize: '16MB' }, text: { maxFileSize: '1MB' } })
+    .onUploadComplete(async ({ file }) => {
+      console.log('Document uploaded:', file.name);
+      return { url: file.url };
+    }),
+} satisfies FileRouter;
+
+export type OurFileRouter = typeof ourFileRouter;
+`,
+      "apps/web/app/api/uploadthing/route.ts": `import { createRouteHandler } from 'uploadthing/next';
+import { ourFileRouter } from './core';
+
+export const { GET, POST } = createRouteHandler({ router: ourFileRouter });
+`
+    };
+  }
+};
+
+// src/templates/strategies/cloudinary-templates.ts
+var CloudinaryTemplateStrategy = class {
+  packageJson(config) {
+    return `{
+  "name": "@${config.name}/storage",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "cloudinary": "${config.versions["cloudinary"] ?? "^2.6.0"}"
+  },
+  "devDependencies": {
+    "typescript": "${config.versions["typescript"] ?? "^5.8.3"}"
+  }
+}
+`;
+  }
+  index(_config) {
+    return `export { cloudinary } from './client.js';
+export { uploadFile } from './upload.js';
+export { getOptimizedUrl, getTransformUrl } from './download.js';
+`;
+  }
+  client(_config) {
+    return `import { v2 as cloudinary } from 'cloudinary';
+
+cloudinary.config({
+  cloud_name: process.env.CLOUDINARY_CLOUD_NAME,
+  api_key: process.env.CLOUDINARY_API_KEY,
+  api_secret: process.env.CLOUDINARY_API_SECRET,
+});
+
+export { cloudinary };
+`;
+  }
+  uploadService(_config) {
+    return `import { cloudinary } from './client.js';
+
+interface UploadOptions {
+  folder?: string;
+  resourceType?: 'image' | 'video' | 'raw' | 'auto';
+  transformation?: Record<string, unknown>;
+}
+
+/** Upload a file to Cloudinary */
+export async function uploadFile(
+  filePath: string,
+  options: UploadOptions = {},
+) {
+  const result = await cloudinary.uploader.upload(filePath, {
+    folder: options.folder ?? 'uploads',
+    resource_type: options.resourceType ?? 'auto',
+    transformation: options.transformation,
+  });
+
+  return {
+    publicId: result.public_id,
+    url: result.secure_url,
+    format: result.format,
+    width: result.width,
+    height: result.height,
+    bytes: result.bytes,
+  };
+}
+
+/** Upload from a buffer */
+export async function uploadBuffer(
+  buffer: Buffer,
+  options: UploadOptions = {},
+): Promise<{ publicId: string; url: string }> {
+  return new Promise((resolve, reject) => {
+    cloudinary.uploader
+      .upload_stream(
+        {
+          folder: options.folder ?? 'uploads',
+          resource_type: options.resourceType ?? 'auto',
+        },
+        (error, result) => {
+          if (error || !result) return reject(error ?? new Error('Upload failed'));
+          resolve({ publicId: result.public_id, url: result.secure_url });
+        },
+      )
+      .end(buffer);
+  });
+}
+`;
+  }
+  downloadService(_config) {
+    return `import { cloudinary } from './client.js';
+
+/** Get an optimized URL for an image */
+export function getOptimizedUrl(publicId: string, options: { width?: number; height?: number; quality?: string } = {}) {
+  return cloudinary.url(publicId, {
+    fetch_format: 'auto',
+    quality: options.quality ?? 'auto',
+    ...(options.width ? { width: options.width, crop: 'scale' } : {}),
+    ...(options.height ? { height: options.height, crop: 'scale' } : {}),
+  });
+}
+
+/** Get a transformed URL */
+export function getTransformUrl(publicId: string, transformation: Record<string, unknown>) {
+  return cloudinary.url(publicId, transformation);
+}
+`;
+  }
+  apiRoutes(_config) {
+    return {};
+  }
+};
+
+// src/templates/strategies/storage-factory.ts
+function createStorageStrategy(storage) {
+  switch (storage) {
+    case "s3":
+      return new S3TemplateStrategy();
+    case "uploadthing":
+      return new UploadThingTemplateStrategy();
+    case "cloudinary":
+      return new CloudinaryTemplateStrategy();
+    case "none":
+      return null;
+  }
+}
+
+// src/templates/strategies/stripe-templates.ts
+var StripeTemplateStrategy = class {
+  packageJson(config) {
+    return `{
+  "name": "@${config.name}/payments",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "stripe": "${config.versions["stripe"] ?? "^17.7.0"}"
+  },
+  "devDependencies": {
+    "typescript": "${config.versions["typescript"] ?? "^5.8.3"}"
+  }
+}
+`;
+  }
+  index(_config) {
+    return `export { stripe } from './client.js';
+export { createCheckoutSession } from './checkout.js';
+export { handleWebhook } from './webhook.js';
+export { getSubscription, cancelSubscription } from './subscription.js';
+`;
+  }
+  client(_config) {
+    return `import Stripe from 'stripe';
+
+export const stripe = new Stripe(process.env.STRIPE_SECRET_KEY ?? '', {
+  apiVersion: '2025-03-31.basil',
+  typescript: true,
+});
+`;
+  }
+  webhookHandler(_config) {
+    return `import type Stripe from 'stripe';
+import { stripe } from './client.js';
+
+/** Verify and handle a Stripe webhook event */
+export async function handleWebhook(body: string | Buffer, signature: string) {
+  const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET ?? '';
+
+  const event = stripe.webhooks.constructEvent(body, signature, webhookSecret);
+
+  switch (event.type) {
+    case 'checkout.session.completed': {
+      const session = event.data.object as Stripe.Checkout.Session;
+      // TODO: Fulfill the order, update database
+      console.log('Checkout completed:', session.id);
+      break;
+    }
+    case 'customer.subscription.updated': {
+      const subscription = event.data.object as Stripe.Subscription;
+      // TODO: Update subscription status in database
+      console.log('Subscription updated:', subscription.id);
+      break;
+    }
+    case 'customer.subscription.deleted': {
+      const subscription = event.data.object as Stripe.Subscription;
+      // TODO: Handle subscription cancellation
+      console.log('Subscription cancelled:', subscription.id);
+      break;
+    }
+    case 'invoice.payment_failed': {
+      const invoice = event.data.object as Stripe.Invoice;
+      // TODO: Notify user of failed payment
+      console.log('Payment failed:', invoice.id);
+      break;
+    }
+    default:
+      console.log('Unhandled event type:', event.type);
+  }
+
+  return { received: true };
+}
+`;
+  }
+  checkout(_config) {
+    return `import { stripe } from './client.js';
+
+interface CreateCheckoutOptions {
+  priceId: string;
+  customerId?: string;
+  customerEmail?: string;
+  mode?: 'payment' | 'subscription';
+  successUrl?: string;
+  cancelUrl?: string;
+}
+
+/** Create a Stripe Checkout session */
+export async function createCheckoutSession({
+  priceId,
+  customerId,
+  customerEmail,
+  mode = 'subscription',
+  successUrl,
+  cancelUrl,
+}: CreateCheckoutOptions) {
+  const appUrl = process.env.NEXT_PUBLIC_APP_URL ?? 'http://localhost:3000';
+
+  const session = await stripe.checkout.sessions.create({
+    mode,
+    payment_method_types: ['card'],
+    line_items: [{ price: priceId, quantity: 1 }],
+    ...(customerId ? { customer: customerId } : {}),
+    ...(customerEmail && !customerId ? { customer_email: customerEmail } : {}),
+    success_url: successUrl ?? \`\${appUrl}/checkout/success?session_id={CHECKOUT_SESSION_ID}\`,
+    cancel_url: cancelUrl ?? \`\${appUrl}/pricing\`,
+  });
+
+  return { sessionId: session.id, url: session.url };
+}
+`;
+  }
+  subscription(_config) {
+    return `import { stripe } from './client.js';
+
+/** Get a customer's active subscription */
+export async function getSubscription(customerId: string) {
+  const subscriptions = await stripe.subscriptions.list({
+    customer: customerId,
+    status: 'active',
+    limit: 1,
+  });
+
+  return subscriptions.data[0] ?? null;
+}
+
+/** Cancel a subscription at period end */
+export async function cancelSubscription(subscriptionId: string) {
+  return stripe.subscriptions.update(subscriptionId, {
+    cancel_at_period_end: true,
+  });
+}
+
+/** Create a customer portal session */
+export async function createPortalSession(customerId: string, returnUrl?: string) {
+  const appUrl = process.env.NEXT_PUBLIC_APP_URL ?? 'http://localhost:3000';
+
+  const session = await stripe.billingPortal.sessions.create({
+    customer: customerId,
+    return_url: returnUrl ?? \`\${appUrl}/dashboard\`,
+  });
+
+  return { url: session.url };
+}
+`;
+  }
+  pricingPage(config) {
+    return `import { Button } from '@${config.name}/ui';
+
+const plans = [
+  {
+    name: 'Free',
+    price: '$0',
+    period: '/month',
+    features: ['1 project', 'Basic support', 'Community access'],
+    priceId: '', // No checkout for free tier
+    highlighted: false,
+  },
+  {
+    name: 'Pro',
+    price: '$19',
+    period: '/month',
+    features: ['Unlimited projects', 'Priority support', 'Advanced features', 'API access'],
+    priceId: process.env.NEXT_PUBLIC_STRIPE_PRO_PRICE_ID ?? '',
+    highlighted: true,
+  },
+  {
+    name: 'Enterprise',
+    price: '$99',
+    period: '/month',
+    features: ['Everything in Pro', 'Dedicated support', 'Custom integrations', 'SLA guarantee'],
+    priceId: process.env.NEXT_PUBLIC_STRIPE_ENTERPRISE_PRICE_ID ?? '',
+    highlighted: false,
+  },
+];
+
+export default function PricingPage() {
+  return (
+    <main style={{ minHeight: '100vh', padding: '4rem 2rem' }}>
+      <div style={{ maxWidth: '1024px', margin: '0 auto', textAlign: 'center' }}>
+        <h1 style={{ fontSize: '2.5rem', fontWeight: 'bold', marginBottom: '1rem' }}>
+          Simple Pricing
+        </h1>
+        <p style={{ fontSize: '1.25rem', color: '#64748b', marginBottom: '3rem' }}>
+          Choose the plan that fits your needs
+        </p>
+
+        <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(280px, 1fr))', gap: '1.5rem' }}>
+          {plans.map((plan) => (
+            <div
+              key={plan.name}
+              style={{
+                border: plan.highlighted ? '2px solid #2563eb' : '1px solid #e2e8f0',
+                borderRadius: '12px',
+                padding: '2rem',
+                background: 'white',
+              }}
+            >
+              <h3 style={{ fontSize: '1.25rem', fontWeight: '600' }}>{plan.name}</h3>
+              <div style={{ margin: '1rem 0' }}>
+                <span style={{ fontSize: '2.5rem', fontWeight: 'bold' }}>{plan.price}</span>
+                <span style={{ color: '#64748b' }}>{plan.period}</span>
+              </div>
+              <ul style={{ listStyle: 'none', padding: 0, margin: '1.5rem 0', textAlign: 'left' }}>
+                {plan.features.map((feature) => (
+                  <li key={feature} style={{ padding: '0.5rem 0', color: '#374151' }}>
+                    \u2713 {feature}
+                  </li>
+                ))}
+              </ul>
+              <Button
+                variant={plan.highlighted ? 'primary' : 'outline'}
+                style={{ width: '100%' }}
+              >
+                {plan.priceId ? 'Get Started' : 'Start Free'}
+              </Button>
+            </div>
+          ))}
+        </div>
+      </div>
+    </main>
+  );
+}
+`;
+  }
+  apiRoute(config) {
+    if (config.backend === "nestjs") {
+      return `import { Controller, Post, Req, Headers, RawBodyRequest } from '@nestjs/common';
+import type { Request } from 'express';
+import { handleWebhook } from '@${config.name}/payments';
+
+@Controller('payments')
+export class PaymentsController {
+  @Post('webhook')
+  async webhook(
+    @Req() req: RawBodyRequest<Request>,
+    @Headers('stripe-signature') signature: string,
+  ) {
+    const rawBody = req.rawBody;
+    if (!rawBody) throw new Error('Missing raw body');
+    return handleWebhook(rawBody, signature);
+  }
+}
+`;
+    }
+    return `import { Router } from 'express';
+import { handleWebhook } from '@${config.name}/payments';
+
+export const paymentsRouter = Router();
+
+paymentsRouter.post('/payments/webhook', async (req, res, next) => {
+  try {
+    const signature = req.headers['stripe-signature'] as string;
+    const result = await handleWebhook(req.body, signature);
+    res.json(result);
+  } catch (error) {
+    next(error);
+  }
+});
+`;
+  }
+};
+
+// src/templates/strategies/lemonsqueezy-templates.ts
+var LemonSqueezyTemplateStrategy = class {
+  packageJson(config) {
+    return `{
+  "name": "@${config.name}/payments",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "dependencies": {
+    "@lemonsqueezy/lemonsqueezy.js": "${config.versions["@lemonsqueezy/lemonsqueezy.js"] ?? "^4.0.0"}"
+  },
+  "devDependencies": {
+    "typescript": "${config.versions["typescript"] ?? "^5.8.3"}"
+  }
+}
+`;
+  }
+  index(_config) {
+    return `export { lemonSqueezySetup } from './client.js';
+export { createCheckout } from './checkout.js';
+export { handleWebhook } from './webhook.js';
+export { getSubscription, cancelSubscription } from './subscription.js';
+`;
+  }
+  client(_config) {
+    return `import { lemonSqueezySetup as setup } from '@lemonsqueezy/lemonsqueezy.js';
+
+export function lemonSqueezySetup() {
+  setup({ apiKey: process.env.LEMONSQUEEZY_API_KEY ?? '', onError: (error) => console.error('LemonSqueezy error:', error) });
+}
+`;
+  }
+  webhookHandler(_config) {
+    return `import crypto from 'node:crypto';
+
+/** Verify LemonSqueezy webhook signature and parse event */
+export async function handleWebhook(body: string, signature: string) {
+  const secret = process.env.LEMONSQUEEZY_WEBHOOK_SECRET ?? '';
+  const hmac = crypto.createHmac('sha256', secret);
+  const digest = hmac.update(body).digest('hex');
+
+  if (digest !== signature) {
+    throw new Error('Invalid webhook signature');
+  }
+
+  const event = JSON.parse(body);
+  const eventName = event.meta?.event_name;
+
+  switch (eventName) {
+    case 'order_created':
+      console.log('Order created:', event.data?.id);
+      break;
+    case 'subscription_created':
+      console.log('Subscription created:', event.data?.id);
+      break;
+    case 'subscription_cancelled':
+      console.log('Subscription cancelled:', event.data?.id);
+      break;
+    case 'subscription_payment_failed':
+      console.log('Payment failed:', event.data?.id);
+      break;
+    default:
+      console.log('Unhandled event:', eventName);
+  }
+
+  return { received: true };
+}
+`;
+  }
+  checkout(_config) {
+    return `import { createCheckout as lsCreateCheckout } from '@lemonsqueezy/lemonsqueezy.js';
+import { lemonSqueezySetup } from './client.js';
+
+interface CreateCheckoutOptions {
+  variantId: number;
+  email?: string;
+  name?: string;
+}
+
+/** Create a LemonSqueezy checkout URL */
+export async function createCheckout({ variantId, email, name }: CreateCheckoutOptions) {
+  lemonSqueezySetup();
+
+  const storeId = process.env.LEMONSQUEEZY_STORE_ID ?? '';
+  const appUrl = process.env.NEXT_PUBLIC_APP_URL ?? 'http://localhost:3000';
+
+  const { data } = await lsCreateCheckout(storeId, variantId, {
+    checkoutData: {
+      email,
+      name,
+    },
+    productOptions: {
+      redirectUrl: \`\${appUrl}/checkout/success\`,
+    },
+  });
+
+  return { url: data?.data?.attributes?.url ?? null };
+}
+`;
+  }
+  subscription(_config) {
+    return `import { getSubscription as lsGetSubscription, cancelSubscription as lsCancelSubscription } from '@lemonsqueezy/lemonsqueezy.js';
+import { lemonSqueezySetup } from './client.js';
+
+/** Get subscription details */
+export async function getSubscription(subscriptionId: string) {
+  lemonSqueezySetup();
+  const { data } = await lsGetSubscription(subscriptionId);
+  return data?.data ?? null;
+}
+
+/** Cancel a subscription */
+export async function cancelSubscription(subscriptionId: string) {
+  lemonSqueezySetup();
+  const { data } = await lsCancelSubscription(subscriptionId);
+  return data?.data ?? null;
+}
+`;
+  }
+  pricingPage(config) {
+    return `import { Button } from '@${config.name}/ui';
+
+const plans = [
+  { name: 'Free', price: '$0', period: '/month', features: ['1 project', 'Basic support'], variantId: 0, highlighted: false },
+  { name: 'Pro', price: '$19', period: '/month', features: ['Unlimited projects', 'Priority support', 'Advanced features'], variantId: Number(process.env.NEXT_PUBLIC_LS_PRO_VARIANT_ID ?? 0), highlighted: true },
+  { name: 'Enterprise', price: '$99', period: '/month', features: ['Everything in Pro', 'Dedicated support', 'SLA'], variantId: Number(process.env.NEXT_PUBLIC_LS_ENTERPRISE_VARIANT_ID ?? 0), highlighted: false },
+];
+
+export default function PricingPage() {
+  return (
+    <main style={{ minHeight: '100vh', padding: '4rem 2rem' }}>
+      <div style={{ maxWidth: '1024px', margin: '0 auto', textAlign: 'center' }}>
+        <h1 style={{ fontSize: '2.5rem', fontWeight: 'bold', marginBottom: '1rem' }}>Pricing</h1>
+        <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(280px, 1fr))', gap: '1.5rem' }}>
+          {plans.map((plan) => (
+            <div key={plan.name} style={{ border: plan.highlighted ? '2px solid #2563eb' : '1px solid #e2e8f0', borderRadius: '12px', padding: '2rem', background: 'white' }}>
+              <h3 style={{ fontSize: '1.25rem', fontWeight: '600' }}>{plan.name}</h3>
+              <div style={{ margin: '1rem 0' }}>
+                <span style={{ fontSize: '2.5rem', fontWeight: 'bold' }}>{plan.price}</span>
+                <span style={{ color: '#64748b' }}>{plan.period}</span>
+              </div>
+              <ul style={{ listStyle: 'none', padding: 0, margin: '1.5rem 0', textAlign: 'left' }}>
+                {plan.features.map((f) => <li key={f} style={{ padding: '0.5rem 0' }}>\u2713 {f}</li>)}
+              </ul>
+              <Button variant={plan.highlighted ? 'primary' : 'outline'} style={{ width: '100%' }}>
+                {plan.variantId ? 'Get Started' : 'Start Free'}
+              </Button>
+            </div>
+          ))}
+        </div>
+      </div>
+    </main>
+  );
+}
+`;
+  }
+  apiRoute(config) {
+    if (config.backend === "nestjs") {
+      return `import { Controller, Post, Req, Headers } from '@nestjs/common';
+import type { Request } from 'express';
+import { handleWebhook } from '@${config.name}/payments';
+
+@Controller('payments')
+export class PaymentsController {
+  @Post('webhook')
+  async webhook(@Req() req: Request, @Headers('x-signature') signature: string) {
+    const body = JSON.stringify(req.body);
+    return handleWebhook(body, signature);
+  }
+}
+`;
+    }
+    return `import { Router } from 'express';
+import { handleWebhook } from '@${config.name}/payments';
+
+export const paymentsRouter = Router();
+
+paymentsRouter.post('/payments/webhook', async (req, res, next) => {
+  try {
+    const signature = req.headers['x-signature'] as string;
+    const result = await handleWebhook(JSON.stringify(req.body), signature);
+    res.json(result);
+  } catch (error) {
+    next(error);
+  }
+});
+`;
+  }
+};
+
+// src/templates/strategies/paddle-templates.ts
+var PaddleTemplateStrategy = class {
+  packageJson(config) {
+    return `{
+  "name": "@${config.name}/payments",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "dependencies": {
+    "@paddle/paddle-node-sdk": "${config.versions["@paddle/paddle-node-sdk"] ?? "^1.7.0"}"
+  },
+  "devDependencies": {
+    "typescript": "${config.versions["typescript"] ?? "^5.8.3"}"
+  }
+}
+`;
+  }
+  index(_config) {
+    return `export { paddle } from './client.js';
+export { createCheckout } from './checkout.js';
+export { handleWebhook } from './webhook.js';
+export { getSubscription, cancelSubscription } from './subscription.js';
+`;
+  }
+  client(_config) {
+    return `import { Paddle, Environment } from '@paddle/paddle-node-sdk';
+
+const isProd = process.env.NODE_ENV === 'production';
+
+export const paddle = new Paddle(process.env.PADDLE_API_KEY ?? '', {
+  environment: isProd ? Environment.production : Environment.sandbox,
+});
+`;
+  }
+  webhookHandler(_config) {
+    return `import { paddle } from './client.js';
+
+/** Verify and handle a Paddle webhook event */
+export async function handleWebhook(body: string, signature: string) {
+  const secretKey = process.env.PADDLE_WEBHOOK_SECRET ?? '';
+
+  const eventData = paddle.webhooks.unmarshal(body, secretKey, signature);
+  if (!eventData) throw new Error('Invalid webhook signature');
+
+  switch (eventData.eventType) {
+    case 'transaction.completed':
+      console.log('Transaction completed:', eventData.data?.id);
+      break;
+    case 'subscription.activated':
+      console.log('Subscription activated:', eventData.data?.id);
+      break;
+    case 'subscription.canceled':
+      console.log('Subscription cancelled:', eventData.data?.id);
+      break;
+    case 'subscription.past_due':
+      console.log('Subscription past due:', eventData.data?.id);
+      break;
+    default:
+      console.log('Unhandled event:', eventData.eventType);
+  }
+
+  return { received: true };
+}
+`;
+  }
+  checkout(_config) {
+    return `import { paddle } from './client.js';
+
+interface CreateCheckoutOptions {
+  priceId: string;
+  customerId?: string;
+  customerEmail?: string;
+}
+
+/** Create a Paddle checkout transaction */
+export async function createCheckout({ priceId, customerId, customerEmail }: CreateCheckoutOptions) {
+  const transaction = await paddle.transactions.create({
+    items: [{ priceId, quantity: 1 }],
+    ...(customerId ? { customerId } : {}),
+    ...(customerEmail ? { customerEmail } : {}),
+  });
+
+  return { transactionId: transaction.id };
+}
+`;
+  }
+  subscription(_config) {
+    return `import { paddle } from './client.js';
 
-/** Persisted theme atom */
-export const themeAtom = atomWithStorage<Theme>('theme', 'system');
+/** Get subscription details */
+export async function getSubscription(subscriptionId: string) {
+  return paddle.subscriptions.get(subscriptionId);
+}
 
-/** Derived atom that resolves 'system' to actual theme */
-export const resolvedThemeAtom = atom((get) => {
-  const theme = get(themeAtom);
-  if (theme !== 'system') return theme;
+/** Cancel a subscription */
+export async function cancelSubscription(subscriptionId: string) {
+  return paddle.subscriptions.cancel(subscriptionId, { effectiveFrom: 'next_billing_period' });
+}
+`;
+  }
+  pricingPage(config) {
+    return `import { Button } from '@${config.name}/ui';
 
-  if (typeof window === 'undefined') return 'light';
-  return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
-});
+const plans = [
+  { name: 'Free', price: '$0', period: '/month', features: ['1 project', 'Basic support'], priceId: '', highlighted: false },
+  { name: 'Pro', price: '$19', period: '/month', features: ['Unlimited projects', 'Priority support', 'Advanced features'], priceId: process.env.NEXT_PUBLIC_PADDLE_PRO_PRICE_ID ?? '', highlighted: true },
+  { name: 'Enterprise', price: '$99', period: '/month', features: ['Everything in Pro', 'Dedicated support', 'SLA'], priceId: process.env.NEXT_PUBLIC_PADDLE_ENTERPRISE_PRICE_ID ?? '', highlighted: false },
+];
 
-/** Convenience hook for theme management */
-export function useTheme() {
-  const [theme, setTheme] = useAtom(themeAtom);
-  return { theme, setTheme };
+export default function PricingPage() {
+  return (
+    <main style={{ minHeight: '100vh', padding: '4rem 2rem' }}>
+      <div style={{ maxWidth: '1024px', margin: '0 auto', textAlign: 'center' }}>
+        <h1 style={{ fontSize: '2.5rem', fontWeight: 'bold', marginBottom: '1rem' }}>Pricing</h1>
+        <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(280px, 1fr))', gap: '1.5rem' }}>
+          {plans.map((plan) => (
+            <div key={plan.name} style={{ border: plan.highlighted ? '2px solid #2563eb' : '1px solid #e2e8f0', borderRadius: '12px', padding: '2rem', background: 'white' }}>
+              <h3 style={{ fontSize: '1.25rem', fontWeight: '600' }}>{plan.name}</h3>
+              <div style={{ margin: '1rem 0' }}>
+                <span style={{ fontSize: '2.5rem', fontWeight: 'bold' }}>{plan.price}</span>
+                <span style={{ color: '#64748b' }}>{plan.period}</span>
+              </div>
+              <ul style={{ listStyle: 'none', padding: 0, margin: '1.5rem 0', textAlign: 'left' }}>
+                {plan.features.map((f) => <li key={f} style={{ padding: '0.5rem 0' }}>\u2713 {f}</li>)}
+              </ul>
+              <Button variant={plan.highlighted ? 'primary' : 'outline'} style={{ width: '100%' }}>
+                {plan.priceId ? 'Get Started' : 'Start Free'}
+              </Button>
+            </div>
+          ))}
+        </div>
+      </div>
+    </main>
+  );
 }
 `;
   }
-  /** Jotai works without a provider (uses default store) */
-  providerWrapper() {
-    return "";
+  apiRoute(config) {
+    if (config.backend === "nestjs") {
+      return `import { Controller, Post, Req, Headers } from '@nestjs/common';
+import type { Request } from 'express';
+import { handleWebhook } from '@${config.name}/payments';
+
+@Controller('payments')
+export class PaymentsController {
+  @Post('webhook')
+  async webhook(@Req() req: Request, @Headers('paddle-signature') signature: string) {
+    const body = JSON.stringify(req.body);
+    return handleWebhook(body, signature);
   }
-};
+}
+`;
+    }
+    return `import { Router } from 'express';
+import { handleWebhook } from '@${config.name}/payments';
 
-// src/templates/strategies/redux-templates.ts
-var ReduxTemplateStrategy = class {
-  storeSetup() {
-    return `import { configureStore } from '@reduxjs/toolkit';
-import { useDispatch, useSelector } from 'react-redux';
-import type { TypedUseSelectorHook } from 'react-redux';
-import { themeReducer } from './theme-slice.js';
+export const paymentsRouter = Router();
 
-export const store = configureStore({
-  reducer: {
-    theme: themeReducer,
-  },
+paymentsRouter.post('/payments/webhook', async (req, res, next) => {
+  try {
+    const signature = req.headers['paddle-signature'] as string;
+    const result = await handleWebhook(JSON.stringify(req.body), signature);
+    res.json(result);
+  } catch (error) {
+    next(error);
+  }
 });
-
-export type RootState = ReturnType<typeof store.getState>;
-export type AppDispatch = typeof store.dispatch;
-
-/** Typed dispatch hook */
-export const useAppDispatch: () => AppDispatch = useDispatch;
-
-/** Typed selector hook */
-export const useAppSelector: TypedUseSelectorHook<RootState> = useSelector;
 `;
   }
-  exampleStore() {
-    return `import { createSlice } from '@reduxjs/toolkit';
-import type { PayloadAction } from '@reduxjs/toolkit';
-
-type Theme = 'light' | 'dark' | 'system';
+};
 
-interface ThemeState {
-  theme: Theme;
+// src/templates/strategies/payment-factory.ts
+function createPaymentStrategy(payments) {
+  switch (payments) {
+    case "stripe":
+      return new StripeTemplateStrategy();
+    case "lemonsqueezy":
+      return new LemonSqueezyTemplateStrategy();
+    case "paddle":
+      return new PaddleTemplateStrategy();
+    case "none":
+      return null;
+  }
 }
 
-const initialState: ThemeState = {
-  theme: 'system',
-};
+// src/templates/strategies/swagger-templates.ts
+var SwaggerTemplateStrategy = class {
+  docsConfig(config) {
+    if (config.backend === "nestjs") {
+      return `import type { INestApplication } from '@nestjs/common';
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
 
-const themeSlice = createSlice({
-  name: 'theme',
-  initialState,
-  reducers: {
-    setTheme(state, action: PayloadAction<Theme>) {
-      state.theme = action.payload;
+export function setupSwagger(app: INestApplication) {
+  const config = new DocumentBuilder()
+    .setTitle('${config.pascalCase} API')
+    .setDescription('${config.pascalCase} REST API documentation')
+    .setVersion('1.0.0')
+    .addBearerAuth()
+    .build();
+
+  const document = SwaggerModule.createDocument(app, config);
+  SwaggerModule.setup('api/docs', app, document, {
+    swaggerOptions: {
+      persistAuthorization: true,
     },
-    toggleTheme(state) {
-      state.theme = state.theme === 'dark' ? 'light' : 'dark';
+  });
+}
+`;
+    }
+    return `import swaggerJsdoc from 'swagger-jsdoc';
+
+const options: swaggerJsdoc.Options = {
+  definition: {
+    openapi: '3.0.0',
+    info: {
+      title: '${config.pascalCase} API',
+      description: '${config.pascalCase} REST API documentation',
+      version: '1.0.0',
+    },
+    servers: [
+      { url: 'http://localhost:3001', description: 'Development' },
+    ],
+    components: {
+      securitySchemes: {
+        bearerAuth: {
+          type: 'http',
+          scheme: 'bearer',
+          bearerFormat: 'JWT',
+        },
+      },
     },
   },
-});
+  apis: ['./src/routes/*.ts'],
+};
 
-export const { setTheme, toggleTheme } = themeSlice.actions;
-export const themeReducer = themeSlice.reducer;
+export const swaggerSpec = swaggerJsdoc(options);
 `;
   }
-  providerWrapper() {
-    return `'use client';
-
-import { Provider } from 'react-redux';
-import { store } from './store';
-
-export function StoreProvider({ children }: { children: React.ReactNode }) {
-  return <Provider store={store}>{children}</Provider>;
+  docsSetup(config) {
+    if (config.backend === "nestjs") {
+      return `// Add to apps/api/src/main.ts:
+// import { setupSwagger } from './docs/swagger-config.js';
+// setupSwagger(app);
+//
+// Swagger UI will be available at: http://localhost:3001/api/docs
+`;
+    }
+    return `import swaggerUi from 'swagger-ui-express';
+import type { Express } from 'express';
+import { swaggerSpec } from './swagger-config.js';
+
+export function setupDocs(app: Express) {
+  app.use('/api/docs', swaggerUi.serve, swaggerUi.setup(swaggerSpec, {
+    swaggerOptions: {
+      persistAuthorization: true,
+    },
+  }));
 }
 `;
   }
 };
 
-// src/templates/strategies/tanstack-query-templates.ts
-var TanstackQueryTemplateStrategy = class {
-  storeSetup() {
-    return `/**
- * TanStack Query setup and utilities.
- */
+// src/templates/strategies/redoc-templates.ts
+var RedocTemplateStrategy = class {
+  docsConfig(config) {
+    if (config.backend === "nestjs") {
+      return `import type { INestApplication } from '@nestjs/common';
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
 
-export { queryClient } from './query-client.js';
-export { QueryProvider } from './provider.js';
-`;
-  }
-  exampleStore(_config) {
-    return `import { QueryClient } from '@tanstack/react-query';
+export function getOpenApiDocument(app: INestApplication) {
+  const config = new DocumentBuilder()
+    .setTitle('${config.pascalCase} API')
+    .setDescription('${config.pascalCase} REST API documentation')
+    .setVersion('1.0.0')
+    .addBearerAuth()
+    .build();
 
-export const queryClient = new QueryClient({
-  defaultOptions: {
-    queries: {
-      staleTime: 60 * 1000, // 1 minute
-      retry: 1,
-      refetchOnWindowFocus: false,
-    },
-    mutations: {
-      retry: 0,
+  return SwaggerModule.createDocument(app, config);
+}
+`;
+    }
+    return `import swaggerJsdoc from 'swagger-jsdoc';
+
+const options: swaggerJsdoc.Options = {
+  definition: {
+    openapi: '3.0.0',
+    info: {
+      title: '${config.pascalCase} API',
+      description: '${config.pascalCase} REST API documentation',
+      version: '1.0.0',
     },
+    servers: [
+      { url: 'http://localhost:3001', description: 'Development' },
+    ],
   },
-});
+  apis: ['./src/routes/*.ts'],
+};
 
-/**
- * Example query hook \u2014 fetches health status from the API.
- */
-export function useHealthQuery() {
-  const apiUrl = process.env.NEXT_PUBLIC_API_URL ?? 'http://localhost:3001';
+export const swaggerSpec = swaggerJsdoc(options);
+`;
+  }
+  docsSetup(config) {
+    if (config.backend === "nestjs") {
+      return `import type { INestApplication } from '@nestjs/common';
+import redoc from 'redoc-express';
+import { getOpenApiDocument } from './swagger-config.js';
 
-  return {
-    queryKey: ['health'],
-    queryFn: async () => {
-      const response = await fetch(\`\${apiUrl}/api/health\`);
-      if (!response.ok) throw new Error('API health check failed');
-      return response.json();
-    },
-  };
+export function setupDocs(app: INestApplication) {
+  const httpAdapter = app.getHttpAdapter();
+  const document = getOpenApiDocument(app);
+
+  httpAdapter.get('/api/docs/openapi.json', (_req: any, res: any) => {
+    res.json(document);
+  });
+
+  httpAdapter.use(
+    '/api/docs',
+    redoc({
+      title: '${config.pascalCase} API',
+      specUrl: '/api/docs/openapi.json',
+    }),
+  );
 }
 `;
-  }
-  providerWrapper() {
-    return `'use client';
+    }
+    return `import redoc from 'redoc-express';
+import type { Express } from 'express';
+import { swaggerSpec } from './swagger-config.js';
 
-import { QueryClientProvider } from '@tanstack/react-query';
-import { queryClient } from './query-client';
+export function setupDocs(app: Express) {
+  app.get('/api/docs/openapi.json', (_req, res) => {
+    res.json(swaggerSpec);
+  });
 
-export function QueryProvider({ children }: { children: React.ReactNode }) {
-  return (
-    <QueryClientProvider client={queryClient}>
-      {children}
-    </QueryClientProvider>
+  app.use(
+    '/api/docs',
+    redoc({
+      title: '${config.pascalCase} API',
+      specUrl: '/api/docs/openapi.json',
+    }),
   );
 }
 `;
   }
 };
 
-// src/templates/strategies/state-factory.ts
-function createStateStrategy(state) {
-  switch (state) {
-    case "zustand":
-      return new ZustandTemplateStrategy();
-    case "jotai":
-      return new JotaiTemplateStrategy();
-    case "redux":
-      return new ReduxTemplateStrategy();
-    case "tanstack-query":
-      return new TanstackQueryTemplateStrategy();
+// src/templates/strategies/api-docs-factory.ts
+function createApiDocsStrategy(apiDocs) {
+  switch (apiDocs) {
+    case "swagger":
+      return new SwaggerTemplateStrategy();
+    case "redoc":
+      return new RedocTemplateStrategy();
     case "none":
       return null;
   }
 }
 
 // src/generator.ts
-var TOTAL_STEPS = 16;
+var TOTAL_STEPS = 26;
 var Generator = class {
   rootPath;
   config;
@@ -4494,7 +7201,7 @@ var Generator = class {
     this.config = config;
     this.rootPath = rootPath;
   }
-  /** Run the full 16-step generation pipeline */
+  /** Run the full 26-step generation pipeline */
   async run() {
     logger.header(`Creating ${this.config.pascalCase} monorepo...`);
     logger.newline();
@@ -4507,9 +7214,19 @@ var Generator = class {
     this.writeLibPackage();
     this.writeUiPackage();
     this.writeDatabasePackage();
+    this.writeCachePackage();
+    this.writeEmailPackage();
+    this.writeStoragePackage();
+    this.writePaymentsPackage();
     this.writeNextjsApp();
+    this.writeI18nLayer();
     this.writeBackendApp();
+    this.writeApiDocs();
+    this.writeLoggingLayer();
     this.writeAuthLayer();
+    this.writeDockerFiles();
+    this.writeStorybookConfig();
+    this.writeE2eTests();
     this.writeSkills();
     await this.installDependencies();
     await this.initializeGit();
@@ -4538,8 +7255,7 @@ var Generator = class {
     logger.step(3, TOTAL_STEPS, "Creating directory structure...");
     const dirs = getExpectedDirectories(this.config);
     for (const dir of dirs) {
-      const fullPath = path.join(this.rootPath, dir);
-      fs.mkdirSync(fullPath, { recursive: true });
+      fs.mkdirSync(path.join(this.rootPath, dir), { recursive: true });
     }
     logger.success(`Created ${dirs.length} directories`);
   }
@@ -4553,9 +7269,7 @@ var Generator = class {
     this.write("CONTRIBUTING.md", contributingMd(this.config));
     this.write("LICENSE", licenseText(this.config));
     const dockerContent = dockerCompose(this.config);
-    if (dockerContent) {
-      this.write("docker-compose.yml", dockerContent);
-    }
+    if (dockerContent) this.write("docker-compose.yml", dockerContent);
     logger.success("Root files written");
   }
   // ── Step 5: Write GitHub files ───────────────────────────────────
@@ -4571,6 +7285,17 @@ var Generator = class {
     this.write(".github/ISSUE_TEMPLATE/feature_request.md", featureRequest());
     this.write(".github/pull_request_template.md", pullRequestTemplate());
     this.write(".github/workflows/ci.yml", ciWorkflow(this.config));
+    if (this.config.hasE2e) {
+      const e2eStrategy = createE2eStrategy(this.config.e2e);
+      if (e2eStrategy) {
+        const ciContent = fs.readFileSync(path.join(this.rootPath, ".github/workflows/ci.yml"), "utf-8");
+        fs.writeFileSync(
+          path.join(this.rootPath, ".github/workflows/ci.yml"),
+          ciContent + e2eStrategy.ciWorkflow(this.config),
+          "utf-8"
+        );
+      }
+    }
     logger.success("GitHub files written");
   }
   // ── Step 6: Write config package ─────────────────────────────────
@@ -4639,9 +7364,114 @@ var Generator = class {
     }
     logger.success("Database package written");
   }
-  // ── Step 10: Write Next.js app ───────────────────────────────────
+  // ── Step 10: Write cache package ─────────────────────────────────
+  writeCachePackage() {
+    if (!this.config.hasCache) {
+      logger.step(10, TOTAL_STEPS, "Skipping cache package (--cache none)");
+      return;
+    }
+    logger.step(10, TOTAL_STEPS, "Writing cache package (Redis)...");
+    this.write("packages/cache/package.json", cachePackageJson(this.config));
+    this.write("packages/cache/tsconfig.json", cacheTsConfig(this.config));
+    this.write("packages/cache/src/index.ts", cacheIndex());
+    this.write("packages/cache/src/client.ts", cacheClient());
+    this.write("packages/cache/src/service.ts", cacheService());
+    logger.success("Cache package written");
+  }
+  // ── Step 11: Write email package ─────────────────────────────────
+  writeEmailPackage() {
+    if (!this.config.hasEmail) {
+      logger.step(11, TOTAL_STEPS, "Skipping email package (--email none)");
+      return;
+    }
+    logger.step(11, TOTAL_STEPS, `Writing email package (${this.config.email})...`);
+    const strategy = createEmailStrategy(this.config.email);
+    if (!strategy) return;
+    this.write("packages/email/package.json", strategy.packageJson(this.config));
+    this.write("packages/email/tsconfig.json", `{
+  "extends": "@${this.config.name}/config/typescript/base",
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "verbatimModuleSyntax": false
+  },
+  "include": ["src/**/*"]
+}
+`);
+    this.write("packages/email/src/index.ts", strategy.index(this.config));
+    this.write("packages/email/src/client.ts", strategy.client(this.config));
+    this.write("packages/email/src/send.ts", strategy.sendFunction(this.config));
+    this.write("packages/email/src/templates/welcome.tsx", strategy.welcomeTemplate(this.config));
+    this.write("packages/email/src/templates/reset-password.tsx", strategy.resetPasswordTemplate(this.config));
+    logger.success("Email package written");
+  }
+  // ── Step 12: Write storage package ───────────────────────────────
+  writeStoragePackage() {
+    if (!this.config.hasStorage) {
+      logger.step(12, TOTAL_STEPS, "Skipping storage package (--storage none)");
+      return;
+    }
+    logger.step(12, TOTAL_STEPS, `Writing storage package (${this.config.storage})...`);
+    const strategy = createStorageStrategy(this.config.storage);
+    if (!strategy) return;
+    this.write("packages/storage/package.json", strategy.packageJson(this.config));
+    this.write("packages/storage/tsconfig.json", `{
+  "extends": "@${this.config.name}/config/typescript/base",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "verbatimModuleSyntax": false
+  },
+  "include": ["src/**/*"]
+}
+`);
+    this.write("packages/storage/src/index.ts", strategy.index(this.config));
+    this.write("packages/storage/src/client.ts", strategy.client(this.config));
+    this.write("packages/storage/src/upload.ts", strategy.uploadService(this.config));
+    this.write("packages/storage/src/download.ts", strategy.downloadService(this.config));
+    const apiRoutes = strategy.apiRoutes(this.config);
+    for (const [routePath, content] of Object.entries(apiRoutes)) {
+      this.write(routePath, content);
+    }
+    logger.success("Storage package written");
+  }
+  // ── Step 13: Write payments package ──────────────────────────────
+  writePaymentsPackage() {
+    if (!this.config.hasPayments) {
+      logger.step(13, TOTAL_STEPS, "Skipping payments package (--payments none)");
+      return;
+    }
+    logger.step(13, TOTAL_STEPS, `Writing payments package (${this.config.payments})...`);
+    const strategy = createPaymentStrategy(this.config.payments);
+    if (!strategy) return;
+    this.write("packages/payments/package.json", strategy.packageJson(this.config));
+    this.write("packages/payments/tsconfig.json", `{
+  "extends": "@${this.config.name}/config/typescript/base",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "verbatimModuleSyntax": false
+  },
+  "include": ["src/**/*"]
+}
+`);
+    this.write("packages/payments/src/index.ts", strategy.index(this.config));
+    this.write("packages/payments/src/client.ts", strategy.client(this.config));
+    this.write("packages/payments/src/webhook.ts", strategy.webhookHandler(this.config));
+    this.write("packages/payments/src/checkout.ts", strategy.checkout(this.config));
+    this.write("packages/payments/src/subscription.ts", strategy.subscription(this.config));
+    if (this.config.backend === "nestjs") {
+      this.write("apps/api/src/payments/payments.controller.ts", strategy.apiRoute(this.config));
+    } else {
+      this.write("apps/api/src/routes/payments.ts", strategy.apiRoute(this.config));
+    }
+    this.write("apps/web/app/pricing/page.tsx", strategy.pricingPage(this.config));
+    logger.success("Payments package written");
+  }
+  // ── Step 14: Write Next.js app ───────────────────────────────────
   writeNextjsApp() {
-    logger.step(10, TOTAL_STEPS, "Writing Next.js 15 app...");
+    logger.step(14, TOTAL_STEPS, "Writing Next.js 15 app...");
     this.write("apps/web/package.json", webPackageJson(this.config));
     this.write("apps/web/tsconfig.json", webTsConfig(this.config));
     this.write("apps/web/next.config.ts", nextConfig(this.config));
@@ -4669,15 +7499,30 @@ var Generator = class {
         this.write(`apps/web/${stateDir}/theme-slice.ts`, stateStrategy.exampleStore(this.config));
       }
       const provider = stateStrategy.providerWrapper(this.config);
-      if (provider) {
-        this.write(`apps/web/${stateDir}/provider.tsx`, provider);
-      }
+      if (provider) this.write(`apps/web/${stateDir}/provider.tsx`, provider);
     }
     logger.success("Next.js app written");
   }
-  // ── Step 11: Write backend app ───────────────────────────────────
+  // ── Step 15: Write i18n layer ────────────────────────────────────
+  writeI18nLayer() {
+    if (!this.config.hasI18n) {
+      logger.step(15, TOTAL_STEPS, "Skipping i18n (--i18n none)");
+      return;
+    }
+    logger.step(15, TOTAL_STEPS, "Writing i18n layer (next-intl)...");
+    this.write("apps/web/i18n/request.ts", i18nRequest());
+    this.write("apps/web/i18n/routing.ts", i18nRouting());
+    this.write("apps/web/i18n/navigation.ts", i18nNavigation());
+    this.write("apps/web/messages/en.json", messagesEn(this.config));
+    this.write("apps/web/messages/ar.json", messagesAr(this.config));
+    this.write("apps/web/app/[locale]/layout.tsx", i18nLayout(this.config));
+    this.write("apps/web/app/[locale]/page.tsx", i18nPage(this.config));
+    this.write("apps/web/components/language-switcher.tsx", languageSwitcher());
+    logger.success("i18n layer written");
+  }
+  // ── Step 16: Write backend app ───────────────────────────────────
   writeBackendApp() {
-    logger.step(11, TOTAL_STEPS, `Writing ${this.config.backend} backend...`);
+    logger.step(16, TOTAL_STEPS, `Writing ${this.config.backend} backend...`);
     const backendStrategy = createBackendStrategy(this.config.backend);
     this.write("apps/api/package.json", backendStrategy.packageJson(this.config));
     this.write("apps/api/tsconfig.json", backendStrategy.tsConfig(this.config));
@@ -4702,13 +7547,39 @@ var Generator = class {
     }
     logger.success(`${this.config.backend === "nestjs" ? "NestJS" : "Express"} backend written`);
   }
-  // ── Step 12: Write auth layer ────────────────────────────────────
+  // ── Step 17: Write API docs ──────────────────────────────────────
+  writeApiDocs() {
+    if (!this.config.hasApiDocs) {
+      logger.step(17, TOTAL_STEPS, "Skipping API docs (--api-docs none)");
+      return;
+    }
+    logger.step(17, TOTAL_STEPS, `Writing API docs (${this.config.apiDocs})...`);
+    const strategy = createApiDocsStrategy(this.config.apiDocs);
+    if (!strategy) return;
+    this.write("apps/api/src/docs/swagger-config.ts", strategy.docsConfig(this.config));
+    this.write("apps/api/src/docs/setup.ts", strategy.docsSetup(this.config));
+    logger.success("API docs written");
+  }
+  // ── Step 18: Write logging layer ─────────────────────────────────
+  writeLoggingLayer() {
+    if (!this.config.hasLogging) {
+      logger.step(18, TOTAL_STEPS, "Skipping logging (--logging default)");
+      return;
+    }
+    logger.step(18, TOTAL_STEPS, `Writing logging layer (${this.config.logging})...`);
+    const strategy = createLoggingStrategy(this.config.logging);
+    if (!strategy) return;
+    this.write("packages/lib/src/logger/index.ts", strategy.index(this.config));
+    this.write("packages/lib/src/logger/logger.ts", strategy.loggerSetup(this.config));
+    logger.success("Logging layer written");
+  }
+  // ── Step 19: Write auth layer ────────────────────────────────────
   writeAuthLayer() {
     if (!this.config.hasAuth) {
-      logger.step(12, TOTAL_STEPS, "Skipping auth layer (--auth none)");
+      logger.step(19, TOTAL_STEPS, "Skipping auth layer (--auth none)");
       return;
     }
-    logger.step(12, TOTAL_STEPS, `Writing ${this.config.auth} auth layer...`);
+    logger.step(19, TOTAL_STEPS, `Writing ${this.config.auth} auth layer...`);
     const authStrategy = createAuthStrategy(this.config.auth);
     if (!authStrategy) return;
     if (this.config.auth === "next-auth") {
@@ -4724,9 +7595,60 @@ var Generator = class {
     }
     logger.success("Auth layer written");
   }
-  // ── Step 13: Write AI skills ─────────────────────────────────────
+  // ── Step 20: Write Docker files ──────────────────────────────────
+  writeDockerFiles() {
+    if (!this.config.hasDocker) {
+      logger.step(20, TOTAL_STEPS, "Skipping Docker files (--docker none)");
+      return;
+    }
+    logger.step(20, TOTAL_STEPS, `Writing Docker files (${this.config.docker})...`);
+    const strategy = createDockerStrategy(this.config.docker);
+    if (!strategy) return;
+    this.write("apps/web/Dockerfile", strategy.webDockerfile(this.config));
+    this.write("apps/api/Dockerfile", strategy.apiDockerfile(this.config));
+    this.write("docker-compose.prod.yml", strategy.dockerComposeProd(this.config));
+    this.write(".dockerignore", strategy.dockerignore(this.config));
+    const extraFiles = strategy.extraFiles(this.config);
+    for (const [filePath, content] of Object.entries(extraFiles)) {
+      this.write(filePath, content);
+    }
+    logger.success("Docker files written");
+  }
+  // ── Step 21: Write Storybook config ──────────────────────────────
+  writeStorybookConfig() {
+    if (!this.config.storybook) {
+      logger.step(21, TOTAL_STEPS, "Skipping Storybook (--no-storybook)");
+      return;
+    }
+    logger.step(21, TOTAL_STEPS, "Writing Storybook config...");
+    this.write("packages/ui/.storybook/main.ts", storybookMain(this.config));
+    this.write("packages/ui/.storybook/preview.ts", storybookPreview(this.config));
+    this.write("packages/ui/src/components/button.stories.tsx", buttonStories(this.config));
+    this.write("packages/ui/src/components/card.stories.tsx", cardStories(this.config));
+    this.write("packages/ui/src/components/input.stories.tsx", inputStories(this.config));
+    logger.success("Storybook config written");
+  }
+  // ── Step 22: Write E2E tests ─────────────────────────────────────
+  writeE2eTests() {
+    if (!this.config.hasE2e) {
+      logger.step(22, TOTAL_STEPS, "Skipping E2E tests (--e2e none)");
+      return;
+    }
+    logger.step(22, TOTAL_STEPS, `Writing E2E tests (${this.config.e2e})...`);
+    const strategy = createE2eStrategy(this.config.e2e);
+    if (!strategy) return;
+    if (this.config.e2e === "playwright") {
+      this.write("apps/web/playwright.config.ts", strategy.config(this.config));
+      this.write("apps/web/e2e/example.spec.ts", strategy.exampleTest(this.config));
+    } else {
+      this.write("apps/web/cypress.config.ts", strategy.config(this.config));
+      this.write("apps/web/cypress/e2e/example.cy.ts", strategy.exampleTest(this.config));
+    }
+    logger.success("E2E tests written");
+  }
+  // ── Step 23: Write AI skills ─────────────────────────────────────
   writeSkills() {
-    logger.step(13, TOTAL_STEPS, "Writing AI agent skills...");
+    logger.step(23, TOTAL_STEPS, "Writing AI agent skills...");
     this.write(".claude/settings.json", claudeSettings(this.config));
     this.write(".claude/skills/component-design/SKILL.md", componentDesignSkill(this.config));
     this.write(".claude/skills/page-design/SKILL.md", pageDesignSkill(this.config));
@@ -4734,42 +7656,35 @@ var Generator = class {
     this.write(".claude/skills/monorepo-doctor/SKILL.md", monrepoDoctorSkill());
     logger.success("AI skills written");
   }
-  // ── Step 14: Install dependencies ────────────────────────────────
+  // ── Step 24: Install dependencies ────────────────────────────────
   async installDependencies() {
-    logger.step(14, TOTAL_STEPS, `Installing dependencies (${this.config.packageManager})...`);
+    logger.step(24, TOTAL_STEPS, `Installing dependencies (${this.config.packageManager})...`);
     try {
-      execSync(this.config.installCommand, {
-        cwd: this.rootPath,
-        stdio: "pipe",
-        timeout: 12e4
-      });
+      execSync(this.config.installCommand, { cwd: this.rootPath, stdio: "pipe", timeout: 12e4 });
       logger.success("Dependencies installed");
     } catch {
       logger.warn("Dependency installation failed \u2014 run manually after setup");
     }
   }
-  // ── Step 15: Initialize git ──────────────────────────────────────
+  // ── Step 25: Initialize git ──────────────────────────────────────
   async initializeGit() {
     if (!this.config.gitInit) {
-      logger.step(15, TOTAL_STEPS, "Skipping git init (--no-git)");
+      logger.step(25, TOTAL_STEPS, "Skipping git init (--no-git)");
       return;
     }
-    logger.step(15, TOTAL_STEPS, "Initializing git repository...");
+    logger.step(25, TOTAL_STEPS, "Initializing git repository...");
     try {
       execSync("git init", { cwd: this.rootPath, stdio: "pipe" });
       execSync("git add .", { cwd: this.rootPath, stdio: "pipe" });
-      execSync(`git commit -m "Initial commit: ${this.config.pascalCase} monorepo"`, {
-        cwd: this.rootPath,
-        stdio: "pipe"
-      });
+      execSync(`git commit -m "Initial commit: ${this.config.pascalCase} monorepo"`, { cwd: this.rootPath, stdio: "pipe" });
       logger.success("Git repository initialized with initial commit");
     } catch {
       logger.warn("Git initialization failed \u2014 run manually");
     }
   }
-  // ── Step 16: Print summary ───────────────────────────────────────
+  // ── Step 26: Print summary ───────────────────────────────────────
   printSummary() {
-    logger.step(16, TOTAL_STEPS, "Done!");
+    logger.step(26, TOTAL_STEPS, "Done!");
     logger.summary([
       `${this.config.pascalCase} monorepo created successfully!`,
       "",
@@ -4784,8 +7699,7 @@ var Generator = class {
   write(relativePath, content) {
     if (!content) return;
     const fullPath = path.join(this.rootPath, relativePath);
-    const dir = path.dirname(fullPath);
-    fs.mkdirSync(dir, { recursive: true });
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
     fs.writeFileSync(fullPath, content, "utf-8");
   }
 };
@@ -4824,7 +7738,17 @@ function detectProjectConfig(rootPath) {
     packageManager,
     gitInit: false,
     githubFiles,
-    license
+    license,
+    docker: detectDocker(rootPath),
+    i18n: detectI18n(rootPath),
+    payments: detectPayments(rootPath),
+    email: detectEmail(rootPath),
+    apiDocs: detectApiDocsOption(rootPath),
+    storage: detectStorage(rootPath),
+    e2e: detectE2e(rootPath),
+    storybook: fs2.existsSync(path2.join(rootPath, "packages/ui/.storybook")),
+    cache: detectCache(rootPath),
+    logging: detectLogging(rootPath)
   });
 }
 function detectBackend(rootPath, _name) {
@@ -4945,6 +7869,72 @@ function detectLicense(rootPath) {
   if (content.includes("proprietary") || content.includes("All rights reserved")) return "proprietary";
   return "MIT";
 }
+function detectDocker(rootPath) {
+  if (fs2.existsSync(path2.join(rootPath, "nginx/nginx.conf"))) return "full";
+  if (fs2.existsSync(path2.join(rootPath, "apps/web/Dockerfile"))) return "minimal";
+  return "none";
+}
+function detectI18n(rootPath) {
+  const webPkg = readJson(path2.join(rootPath, "apps/web/package.json"));
+  const deps = { ...webPkg?.dependencies, ...webPkg?.devDependencies };
+  if (deps["next-intl"]) return "next-intl";
+  return "none";
+}
+function detectPayments(rootPath) {
+  const pkg = readJson(path2.join(rootPath, "packages/payments/package.json"));
+  if (!pkg) return "none";
+  const deps = pkg.dependencies;
+  if (deps?.["stripe"]) return "stripe";
+  if (deps?.["@lemonsqueezy/lemonsqueezy.js"]) return "lemonsqueezy";
+  if (deps?.["@paddle/paddle-node-sdk"]) return "paddle";
+  return "none";
+}
+function detectEmail(rootPath) {
+  const pkg = readJson(path2.join(rootPath, "packages/email/package.json"));
+  if (!pkg) return "none";
+  const deps = pkg.dependencies;
+  if (deps?.["resend"]) return "resend";
+  if (deps?.["nodemailer"]) return "nodemailer";
+  if (deps?.["@sendgrid/mail"]) return "sendgrid";
+  return "none";
+}
+function detectApiDocsOption(rootPath) {
+  if (fs2.existsSync(path2.join(rootPath, "apps/api/src/docs/setup.ts"))) {
+    const content = readFile(path2.join(rootPath, "apps/api/src/docs/setup.ts"));
+    if (content?.includes("redoc")) return "redoc";
+    return "swagger";
+  }
+  return "none";
+}
+function detectStorage(rootPath) {
+  const pkg = readJson(path2.join(rootPath, "packages/storage/package.json"));
+  if (!pkg) return "none";
+  const deps = pkg.dependencies;
+  if (deps?.["@aws-sdk/client-s3"]) return "s3";
+  if (deps?.["uploadthing"]) return "uploadthing";
+  if (deps?.["cloudinary"]) return "cloudinary";
+  return "none";
+}
+function detectE2e(rootPath) {
+  if (fs2.existsSync(path2.join(rootPath, "apps/web/playwright.config.ts"))) return "playwright";
+  if (fs2.existsSync(path2.join(rootPath, "apps/web/cypress.config.ts"))) return "cypress";
+  return "none";
+}
+function detectCache(rootPath) {
+  const pkg = readJson(path2.join(rootPath, "packages/cache/package.json"));
+  if (!pkg) return "none";
+  const deps = pkg.dependencies;
+  if (deps?.["ioredis"]) return "redis";
+  return "none";
+}
+function detectLogging(rootPath) {
+  if (fs2.existsSync(path2.join(rootPath, "packages/lib/src/logger/logger.ts"))) {
+    const content = readFile(path2.join(rootPath, "packages/lib/src/logger/logger.ts"));
+    if (content?.includes("pino")) return "pino";
+    if (content?.includes("winston")) return "winston";
+  }
+  return "default";
+}
 function readJson(filePath) {
   try {
     const content = fs2.readFileSync(filePath, "utf-8");
@@ -5536,16 +8526,25 @@ var Workflow = class {
   }
 };
 export {
+  ApiDocs,
   Auth,
   Backend,
+  Cache,
   Database,
+  Docker,
   Doctor,
+  E2e,
+  Email,
   Generator,
+  I18n,
   LicenseType,
+  Logging,
   ORM,
   PackageManager,
+  Payments,
   ProjectConfig,
   StateManagement,
+  Storage,
   Styling,
   TestFramework,
   VersionResolver,