create-fullstack-scaffold 0.4.22 → 0.4.23

package/dist/cli/index.js

@@ -0,0 +1,4063 @@
+#!/usr/bin/env node
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import path, { join } from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { select } from '@inquirer/prompts';
+import fs from 'fs-extra';
+import ora from 'ora';
+
+var tsImportFn;
+async function getTsImport() {
+  if (tsImportFn) return tsImportFn;
+  const { tsImport } = await import('tsx/esm/api');
+  tsImportFn = tsImport;
+  return tsImportFn;
+}
+async function loadManifests(templateDir) {
+  const tsImport = await getTsImport();
+  const serverDir = join(templateDir, "src", "server");
+  const modules = /* @__PURE__ */ new Map();
+  const entries = readdirSync(serverDir);
+  const moduleDirs = entries.filter(
+    (e) => e.startsWith("module-") && statSync(join(serverDir, e)).isDirectory()
+  );
+  const parentURL = pathToFileURL(join(serverDir, "dummy.ts")).href;
+  for (const dir of moduleDirs) {
+    const manifestPath = join(serverDir, dir, "module.ts");
+    if (!existsSync(manifestPath)) continue;
+    try {
+      const mod = await tsImport(manifestPath, { parentURL });
+      const manifest = mod.default;
+      if (!manifest || !manifest.name) {
+        console.error(`\u274C Invalid manifest in ${dir}: missing name`);
+        continue;
+      }
+      modules.set(manifest.name, manifest);
+    } catch (err) {
+      console.error(`\u274C Failed to load manifest from ${dir}:`, err);
+    }
+  }
+  return modules;
+}
+async function loadPresets(templateDir) {
+  const configPath = join(templateDir, "modules.config.ts");
+  if (!existsSync(configPath)) {
+    return [getDefaultPreset()];
+  }
+  try {
+    const tsImport = await getTsImport();
+    const parentURL = pathToFileURL(configPath).href;
+    const mod = await tsImport(configPath, { parentURL });
+    if (mod.TEMPLATE_PRESETS) {
+      return mod.TEMPLATE_PRESETS;
+    }
+  } catch (err) {
+    console.error("\u274C Failed to load presets:", err);
+  }
+  return [getDefaultPreset()];
+}
+function getDefaultPreset() {
+  return {
+    id: "fullstack-admin",
+    name: "Full Admin",
+    description: "All modules included",
+    modules: [
+      "todos",
+      "chat",
+      "notifications",
+      "file",
+      "captcha",
+      "permission",
+      "admin",
+      "order",
+      "ticket",
+      "dispute",
+      "content"
+    ]
+  };
+}
+function resolvePreset(preset, allManifests) {
+  const modules = /* @__PURE__ */ new Map();
+  const toProcess = [...preset.modules];
+  const processed = /* @__PURE__ */ new Set();
+  while (toProcess.length > 0) {
+    const name = toProcess.shift();
+    if (processed.has(name)) continue;
+    processed.add(name);
+    const manifest = allManifests.get(name);
+    if (manifest) {
+      modules.set(name, manifest);
+      for (const dep of manifest.dependsOn) {
+        if (!processed.has(dep)) {
+          toProcess.push(dep);
+        }
+      }
+    }
+  }
+  let hasSSE = false;
+  let hasWebSocket = false;
+  let hasAdmin = false;
+  for (const manifest of modules.values()) {
+    if (manifest.hasSSE) hasSSE = true;
+    if (manifest.hasWebSocket) hasWebSocket = true;
+    if (manifest.adminPages && manifest.adminPages.length > 0) hasAdmin = true;
+    if (manifest.routes.admin && manifest.routes.admin.length > 0) hasAdmin = true;
+  }
+  const isCliOnly = preset.id === "cli-only";
+  return {
+    preset,
+    modules,
+    hasAdmin,
+    hasClient: !isCliOnly,
+    hasCli: true,
+    hasSSE,
+    hasWebSocket,
+    hasPermission: modules.has("permission"),
+    hasCaptcha: modules.has("captcha")
+  };
+}
+function getDbSchemaFiles(resolved) {
+  const files = [];
+  for (const [, manifest] of resolved.modules) {
+    if (manifest.dbSchemas) {
+      files.push(...manifest.dbSchemas.files);
+    }
+  }
+  return files;
+}
+function getClientPages(resolved) {
+  const pages = [];
+  for (const [, manifest] of resolved.modules) {
+    if (manifest.clientPages) {
+      pages.push(...manifest.clientPages);
+    }
+  }
+  return pages;
+}
+function getAdminPages(resolved) {
+  const pages = [];
+  for (const [, manifest] of resolved.modules) {
+    if (manifest.adminPages) {
+      pages.push(...manifest.adminPages);
+    }
+  }
+  return pages;
+}
+
+// src/generators/file-filter.ts
+function getExcludePatterns(resolved, allManifests) {
+  const excludes = [];
+  for (const [name, manifest] of allManifests) {
+    if (resolved.modules.has(name)) continue;
+    excludes.push(`src/server/module-${name}`);
+    if (manifest.sharedSchemas) {
+      excludes.push(`src/shared/modules/${manifest.sharedSchemas.path}`);
+      if (manifest.sharedSchemas.additionalPaths) {
+        for (const extra of manifest.sharedSchemas.additionalPaths) {
+          excludes.push(`src/shared/modules/${extra}`);
+        }
+      }
+    }
+    if (manifest.dbSchemas) {
+      for (const file of manifest.dbSchemas.files) {
+        excludes.push(`src/server/db/schema/${file}.ts`);
+      }
+    }
+    if (manifest.clientPages) {
+      for (const page of manifest.clientPages) {
+        excludes.push(`src/client/pages/${page.name}.tsx`);
+        excludes.push(`src/client/pages/__tests__/${page.name}.test.tsx`);
+      }
+    }
+    if (manifest.clientStores) {
+      for (const store of manifest.clientStores) {
+        excludes.push(`src/client/stores/${store}.ts`);
+        excludes.push(`src/client/stores/__tests__/${store}.test.ts`);
+      }
+    }
+    if (manifest.adminPages) {
+      for (const page of manifest.adminPages) {
+        excludes.push(`src/admin/pages/${page.name}.tsx`);
+        excludes.push(`src/admin/pages/__tests__/${page.name}.test.tsx`);
+      }
+    }
+    if (manifest.providesMiddleware) {
+      for (const mw of manifest.providesMiddleware) {
+        excludes.push(`src/server/middleware/${mw.name}.ts`);
+        excludes.push(`src/server/middleware/__tests__/${mw.name}.test.ts`);
+      }
+    }
+    if (name === "todos") {
+      excludes.push("src/server/__tests__/integration/todos-api.test.ts");
+    }
+    if (manifest.cliModule) {
+      excludes.push(`src/cli/modules/${manifest.cliModule.dir}`);
+    }
+  }
+  if (!resolved.modules.has("admin")) {
+    excludes.push("src/admin");
+    excludes.push("admin.html");
+    excludes.push("auth-inject.html");
+  }
+  if (!resolved.modules.has("tenant")) {
+    excludes.push("src/tenant");
+    excludes.push("tenant.html");
+    excludes.push("src/server/middleware/tenant-isolation.ts");
+    excludes.push("src/server/middleware/__tests__/tenant-isolation.test.ts");
+  }
+  if (!resolved.modules.has("merchant")) {
+    excludes.push("src/merchant");
+    excludes.push("merchant.html");
+  }
+  if (!resolved.hasClient) {
+    excludes.push("src/client");
+    excludes.push("index.html");
+    excludes.push("admin.html");
+    excludes.push("auth-inject.html");
+    excludes.push("src/admin");
+    excludes.push("vite.config.ts");
+    excludes.push("postcss.config.js");
+    excludes.push("tailwind.config.js");
+  }
+  if (!resolved.hasClient) {
+    excludes.push("src/client/components/AuthButton.tsx");
+    excludes.push("src/client/components/__tests__/AuthButton.test.tsx");
+  } else if (!resolved.modules.has("admin") && !resolved.modules.has("auth")) {
+    excludes.push("src/client/components/AuthButton.tsx");
+    excludes.push("src/client/components/__tests__/AuthButton.test.tsx");
+    excludes.push("src/server/utils/auth.ts");
+  }
+  excludes.push("src/client/preset-ui-config.ts");
+  const standaloneSharedModules = {
+    cart: { pages: ["CartPage"] },
+    community: { pages: ["TopicsPage", "ProfilePage"], serverModules: ["content"] },
+    dashboard: { pages: ["DashboardPage"] }
+  };
+  for (const [moduleName, config] of Object.entries(standaloneSharedModules)) {
+    const hasRelevantPage = config.pages && [...resolved.modules.values()].some(
+      (m) => m.clientPages?.some((p) => config.pages.includes(p.name)) ?? false
+    );
+    const hasRelevantServerModule = config.serverModules?.some((sm) => resolved.modules.has(sm)) ?? false;
+    if (!hasRelevantPage && !hasRelevantServerModule) {
+      excludes.push(`src/shared/modules/${moduleName}`);
+    }
+  }
+  if (!resolved.hasPermission && !resolved.modules.has("auth")) {
+    excludes.push("src/server/utils/permission-utils.ts");
+    excludes.push("src/server/utils/__tests__/permission-utils.test.ts");
+    excludes.push("src/server/middleware/__tests__/auth-simple.test.ts");
+    excludes.push("src/server/middleware/__tests__/auth.test.ts");
+    excludes.push("src/server/middleware/__tests__/error-response-format.test.ts");
+    excludes.push("src/server/utils/__tests__/auth.test.ts");
+  } else if (!resolved.hasPermission && resolved.modules.has("auth")) {
+    excludes.push("src/server/utils/permission-utils.ts");
+    excludes.push("src/server/utils/__tests__/permission-utils.test.ts");
+    excludes.push("src/server/middleware/__tests__/auth-simple.test.ts");
+    excludes.push("src/server/middleware/__tests__/auth.test.ts");
+    excludes.push("src/server/middleware/__tests__/error-response-format.test.ts");
+    excludes.push("src/server/utils/__tests__/auth.test.ts");
+    excludes.push("src/server/module-auth/__tests__/auth-service.test.ts");
+  } else if (!resolved.modules.has("admin")) {
+    excludes.push("src/server/middleware/__tests__/error-response-format.test.ts");
+  }
+  if (!resolved.modules.has("captcha")) {
+    excludes.push("src/server/utils/__tests__/captcha.test.ts");
+    excludes.push("src/admin/components/CaptchaModal.tsx");
+    excludes.push("src/admin/stores/captchaStore.ts");
+    excludes.push("src/admin/stores/__tests__/captchaStore.test.ts");
+    excludes.push("src/admin/stores/__tests__/captchaStoreBranches.test.ts");
+  }
+  return excludes;
+}
+function getGeneratedFiles(resolved) {
+  const files = [
+    "src/server/route-registry.ts",
+    "src/server/db/schema/index.ts",
+    "src/shared/modules/index.ts",
+    "src/shared/schemas/index.ts",
+    "src/server/middleware/index.ts",
+    "src/server/app.ts",
+    "src/cli/modules/index.ts"
+  ];
+  if (resolved.hasClient) {
+    files.push(
+      "src/client/App.tsx",
+      "src/client/components/Navigation.tsx",
+      "src/client/components/index.ts",
+      "src/client/Layout.tsx",
+      "src/client/components/__tests__/App.test.tsx",
+      "src/client/components/__tests__/Navigation.test.tsx",
+      "src/client/main.tsx",
+      "src/client/preset-ui-config.ts"
+    );
+  }
+  if (resolved.hasClient && resolved.modules.has("admin")) {
+    files.push("src/admin/App.tsx");
+    files.push("src/admin/components/index.ts");
+    files.push("src/admin/services/apiClient.ts");
+  }
+  if (resolved.hasClient && !resolved.modules.has("admin")) {
+    files.push("vite.config.ts");
+  }
+  if (resolved.hasClient && resolved.modules.has("admin")) {
+    files.push("vite.config.ts");
+  }
+  if (!resolved.hasPermission) {
+    files.push("src/server/middleware/auth.ts");
+    files.push("src/server/utils/auth.ts");
+  }
+  if (!resolved.modules.has("admin") && resolved.hasPermission) {
+    files.push("src/server/utils/auth.ts");
+  }
+  files.push("src/server/db/init.ts");
+  return files;
+}
+
+// src/generators/route-registry.ts
+function generateRouteRegistry(resolved) {
+  const imports = [
+    `import { OpenAPIHono } from '@hono/zod-openapi'`,
+    `import { rateLimitMiddleware } from './middleware/rate-limit'`
+  ];
+  const clientRoutes = [];
+  const adminRoutes = [];
+  const moduleEntries = [...resolved.modules.entries()];
+  const usedNames = /* @__PURE__ */ new Set();
+  for (const [name, manifest] of moduleEntries) {
+    const moduleDir = `module-${name}`;
+    if (manifest.routes.client) {
+      const clientRouteList = Array.isArray(manifest.routes.client) ? manifest.routes.client : [manifest.routes.client];
+      for (const route of clientRouteList) {
+        const { importPath, exportName } = route;
+        const localName = usedNames.has(exportName) ? `${name}${exportName.charAt(0).toUpperCase()}${exportName.slice(1)}` : exportName;
+        usedNames.add(localName);
+        const importStmt = localName === exportName ? `import { ${exportName} } from './${moduleDir}/${importPath.replace(/^\.\//, "")}'` : `import { ${exportName} as ${localName} } from './${moduleDir}/${importPath.replace(
+          /^\.\//,
+          ""
+        )}'`;
+        imports.push(importStmt);
+        clientRoutes.push(`  .route('/api', ${localName})`);
+      }
+    }
+    if (manifest.routes.admin) {
+      for (const route of manifest.routes.admin) {
+        const { importPath, exportName } = route;
+        const localName = usedNames.has(exportName) ? `${name}${exportName.charAt(0).toUpperCase()}${exportName.slice(1)}` : exportName;
+        usedNames.add(localName);
+        const importStmt = localName === exportName ? `import { ${exportName} } from './${moduleDir}/${importPath.replace(/^\.\//, "")}'` : `import { ${exportName} as ${localName} } from './${moduleDir}/${importPath.replace(
+          /^\.\//,
+          ""
+        )}'`;
+        imports.push(importStmt);
+        adminRoutes.push(`  .route('/api', ${localName})`);
+      }
+    }
+  }
+  let content = imports.join("\n") + "\n\n";
+  content += `const apiRateLimit = rateLimitMiddleware({
+`;
+  content += `  windowMs: 60 * 1000,
+`;
+  content += `  max: 100,
+`;
+  content += `})
+
+`;
+  if (clientRoutes.length > 0) {
+    content += `// client API routes
+`;
+    content += `export const clientApiRoutes = new OpenAPIHono()
+`;
+    content += `  .use('*', apiRateLimit)
+`;
+    content += clientRoutes.join("\n") + "\n\n";
+  } else {
+    content += `// No client modules selected
+`;
+    content += `export const clientApiRoutes = new OpenAPIHono()
+
+`;
+  }
+  if (adminRoutes.length > 0) {
+    content += `// admin API routes
+`;
+    content += `export const adminApiRoutes = new OpenAPIHono()
+`;
+    content += adminRoutes.join("\n") + "\n\n";
+  } else {
+    content += `// No admin modules selected
+`;
+    content += `export const adminApiRoutes = new OpenAPIHono()
+
+`;
+  }
+  content += `export type ClientApiRoutes = typeof clientApiRoutes
+`;
+  content += `export type AdminApiRoutes = typeof adminApiRoutes
+`;
+  return content;
+}
+function getStandaloneRoutes(resolved) {
+  const routes = [];
+  const usedNames = /* @__PURE__ */ new Set();
+  for (const [name, manifest] of resolved.modules) {
+    if (manifest.routes.standalone) {
+      const { exportName, mountPath } = manifest.routes.standalone;
+      const localName = usedNames.has(exportName) ? `${name}${exportName.charAt(0).toUpperCase()}${exportName.slice(1)}` : exportName;
+      usedNames.add(localName);
+      routes.push({ localName, mountPath });
+    }
+  }
+  return routes;
+}
+
+// src/generators/client-navigation.ts
+var DEFAULT_ICON = "Circle";
+var ICON_MAP = {
+  TodoPage: "CheckCircle",
+  NotificationPage: "Bell",
+  WebSocketPage: "Plug",
+  ContentListPage: "FileText",
+  PluginsPage: "Package",
+  CategoriesPage: "Grid",
+  SearchPage: "Search",
+  PublishPage: "Upload",
+  DeveloperDashboardPage: "Code",
+  PluginDetailPage: "Package",
+  TopicsPage: "Hash",
+  ProfilePage: "User",
+  DashboardPage: "LayoutDashboard",
+  SettingsPage: "Settings",
+  CartPage: "ShoppingCart",
+  OrdersPage: "Package"
+};
+function generateClientNavigation(resolved) {
+  const pages = getClientPages(resolved).filter((p) => !p.route.includes(":"));
+  const hasAuth = resolved.modules.has("auth");
+  const navItems = [];
+  for (const page of pages) {
+    const icon = ICON_MAP[page.name] || DEFAULT_ICON;
+    const label = page.name === "TodoPage" ? "Todos" : page.name === "NotificationPage" ? "Notifications" : page.name === "WebSocketPage" ? "WebSocket" : page.name === "PluginsPage" ? "Plugins" : page.name === "CategoriesPage" ? "Categories" : page.name === "SearchPage" ? "Search" : page.name === "PublishPage" ? "Publish" : page.name === "DeveloperDashboardPage" ? "Developer" : page.name === "TopicsPage" ? "Topics" : page.name === "ProfilePage" ? "Profile" : page.name === "DashboardPage" ? "Dashboard" : page.name === "SettingsPage" ? "Settings" : page.name === "CartPage" ? "Cart" : page.name === "OrdersPage" ? "Orders" : page.route.replace(/^\//, "").charAt(0).toUpperCase() + page.route.replace(/^\//, "").slice(1);
+    navItems.push(`    { label: '${label}', icon: '${icon}', path: '${page.route}' },`);
+  }
+  const authImport = hasAuth ? `
+import { useAuthStore } from '../stores/authStore'` : "";
+  const authSection = hasAuth ? `
+function AuthSection({ style }: { style: string }) {
+  const isAuthenticated = useAuthStore((state: any) => state.isAuthenticated)
+  const user = useAuthStore((state: any) => state.user)
+  const logout = useAuthStore((state: any) => state.logout)
+
+  if (style === 'none') return null
+
+  if (isAuthenticated) {
+    return (
+      <div className="flex items-center gap-2">
+        <span className="text-sm text-gray-600">{user?.username}</span>
+        <button onClick={logout} className="text-xs text-gray-400 hover:text-red-500">Sign Out</button>
+      </div>
+    )
+  }
+
+  if (style === 'buttons') {
+    return (
+      <div className="flex items-center gap-2">
+        <Link
+          to="/login"
+          className="px-3 py-1 text-sm bg-blue-500 text-white rounded hover:bg-blue-600"
+        >
+          Sign In
+        </Link>
+        <Link
+          to="/register"
+          className="px-3 py-1 text-sm border border-gray-300 text-gray-700 rounded hover:bg-gray-50"
+        >
+          Sign Up
+        </Link>
+      </div>
+    )
+  }
+
+  return (
+    <Link to="/login" className="text-sm text-gray-500 hover:text-gray-900">
+      Login
+    </Link>
+  )
+}
+` : `
+function AuthSection(_style: { style: string }) {
+  return null
+}
+`;
+  return `import { NavLink${hasAuth ? ", Link" : ""} } from 'react-router-dom'
+import { Rocket, Sparkles } from 'lucide-react'${authImport}
+import type { PresetTheme, NavigationConfig, ClientNavItem } from '../preset-ui-config'
+
+interface NavigationProps {
+  preset?: string
+  items?: ClientNavItem[]
+  theme?: PresetTheme
+  navigation?: NavigationConfig
+}
+${authSection}
+export const Navigation: React.FC<NavigationProps> = ({
+  items,
+  theme,
+  navigation,
+}) => {
+  const navItems = navigation?.navItems === 'none' ? [] : (items ?? [])
+  const primaryColor = theme?.primaryColor ?? '#6366f1'
+  const logoText = theme?.logoText ?? 'Biomimic'
+  const showLogo = navigation?.showLogo !== false
+  const authStyle = navigation?.authStyle ?? 'none'
+
+  return (
+    <nav className="hidden md:block bg-white/80 backdrop-blur-md border-b border-gray-200 sticky top-0 z-50" data-testid="app-nav">
+      <div className="max-w-7xl mx-auto px-4 h-16 flex items-center justify-between gap-3">
+        {showLogo && (
+          <NavLink to="/" className="flex items-center gap-2 group shrink-0" data-testid="app-title">
+            <div
+              className="w-8 h-8 rounded-lg flex items-center justify-center shadow-sm group-hover:shadow-md transition-shadow"
+              style={{ backgroundColor: primaryColor }}
+            >
+              <Rocket className="w-4 h-4 text-white" />
+            </div>
+            <span className="text-lg font-semibold text-gray-900 tracking-tight whitespace-nowrap">
+              {logoText}
+            </span>
+            <Sparkles className="w-3.5 h-3.5 shrink-0" style={{ color: primaryColor }} />
+          </NavLink>
+        )}
+
+        <div className="flex items-center gap-0.5 overflow-x-auto flex-1 min-w-0 scrollbar-hide">
+          {navItems.map(item => (
+            <NavLink
+              key={item.path}
+              to={item.path}
+              data-testid={\`nav-\${item.label.toLowerCase().replace(/\\s+/g, '-')}-button\`}
+              className={({ isActive }: { isActive: boolean }) =>
+                \`px-3 py-1.5 rounded-lg text-sm font-medium transition-all duration-200 shrink-0 whitespace-nowrap \${
+                  isActive ? 'text-white' : 'text-gray-500 hover:text-gray-900 hover:bg-gray-50'
+                }\`
+              }
+              style={
+                (({ isActive }: { isActive: boolean }) =>
+                  isActive
+                    ? { backgroundColor: \`\${primaryColor}15\`, color: primaryColor }
+                    : undefined) as never
+              }
+            >
+              {item.label}
+            </NavLink>
+          ))}
+        </div>
+
+        <AuthSection style={authStyle} />
+      </div>
+    </nav>
+  )
+}
+`;
+}
+
+// src/generators/client-app-test.ts
+function generateClientAppTest(resolved) {
+  const pages = getClientPages(resolved);
+  const mocks = pages.map(
+    (p) => `vi.mock('@client/pages/${p.name}', () => ({
+  ${p.name}: () => <div data-testid="${p.name.toLowerCase()}-page">${p.name}</div>,
+}))`
+  ).join("\n\n  ");
+  return `import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { render, screen, cleanup } from '@testing-library/react'
+import '@testing-library/jest-dom'
+import { App } from '@client/App'
+
+  ${mocks}
+
+describe('App Component', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  afterEach(() => {
+    cleanup()
+  })
+
+  describe('Initial Render', () => {
+    it('should render navigation', () => {
+      render(<App />)
+      expect(screen.getByTestId('app-nav')).toBeInTheDocument()
+    })
+
+    it('should render main content area', () => {
+      render(<App />)
+      expect(screen.getByTestId('app-main')).toBeInTheDocument()
+    })
+
+    it('should render container', () => {
+      render(<App />)
+      expect(screen.getByTestId('app-container')).toBeInTheDocument()
+    })
+  })
+
+  describe('Navigation Links', () => {
+    it('should render footer', () => {
+      render(<App />)
+      expect(screen.getByTestId('app-footer')).toBeInTheDocument()
+    })
+  })
+})
+`;
+}
+
+// src/generators/client-navigation-test.ts
+var LABEL_MAP = {
+  TodoPage: "Todos",
+  NotificationPage: "Notifications",
+  WebSocketPage: "WebSocket",
+  PluginsPage: "Plugins",
+  CategoriesPage: "Categories",
+  SearchPage: "Search",
+  PublishPage: "Publish",
+  DeveloperDashboardPage: "Developer",
+  TopicsPage: "Topics",
+  ProfilePage: "Profile",
+  DashboardPage: "Dashboard",
+  SettingsPage: "Settings",
+  CartPage: "Cart",
+  OrdersPage: "Orders"
+};
+function generateClientNavigationTest(resolved) {
+  const pages = getClientPages(resolved).filter((p) => !p.route.includes(":"));
+  const firstPage = pages[0];
+  if (!firstPage) {
+    return `import { describe, it, expect } from 'vitest'
+import { render, screen } from '@testing-library/react'
+import { BrowserRouter } from 'react-router-dom'
+import { Navigation } from '../Navigation'
+
+const renderWithRouter = (component: React.ReactNode) => {
+  return render(<BrowserRouter>{component}</BrowserRouter>)
+}
+
+describe('Navigation', () => {
+  it('should render navigation', () => {
+    renderWithRouter(<Navigation />)
+    expect(screen.getByTestId('app-nav')).toBeInTheDocument()
+  })
+})
+`;
+  }
+  const firstLabel = LABEL_MAP[firstPage.name] || firstPage.name.replace("Page", "");
+  return `import { describe, it, expect } from 'vitest'
+import { render, screen } from '@testing-library/react'
+import { BrowserRouter } from 'react-router-dom'
+import { Navigation } from '../Navigation'
+
+const renderWithRouter = (component: React.ReactNode) => {
+  return render(<BrowserRouter>{component}</BrowserRouter>)
+}
+
+describe('Navigation', () => {
+  it('should render navigation', () => {
+    renderWithRouter(<Navigation />)
+    expect(screen.getByTestId('app-nav')).toBeInTheDocument()
+  })
+
+  it('should render nav items', () => {
+    renderWithRouter(<Navigation />)
+    expect(screen.getByText('${firstLabel}')).toBeInTheDocument()
+  })
+})
+`;
+}
+
+// src/generators/admin-app.ts
+function generateAdminApp(resolved) {
+  if (!resolved.hasAdmin) return null;
+  const pages = getAdminPages(resolved) ?? [];
+  if (pages.length === 0) return null;
+  const publicPages = pages.filter((p) => p.isPublic);
+  const protectedPages = pages.filter((p) => !p.isPublic);
+  const imports = [
+    `import { BrowserRouter, Routes, Route, Navigate } from 'react-router-dom'`,
+    `import { ConfigProvider } from 'antd'`,
+    `import { Layout } from './layouts/Layout'`
+  ];
+  for (const page of pages) {
+    imports.push(`import { ${page.name} } from './pages/${page.name}'`);
+  }
+  const captchaImport = resolved.hasCaptcha ? ", CaptchaModal" : "";
+  imports.push(`import { ProtectedRoute${captchaImport} } from './components'`);
+  const protectedRouteElements = protectedPages.map(
+    (p) => `                    <Route path="${p.route}" element={<${p.name} />} />`
+  );
+  const defaultProtectedRoute = protectedPages.length > 0 ? protectedPages[0].route : "/";
+  const captchaElement = resolved.hasCaptcha ? `
+        <CaptchaModal />` : "";
+  const publicRouteLines = publicPages.map(
+    (p) => `          <Route path="${p.route}" element={<${p.name} />} />`
+  );
+  return `${imports.join("\n")}
+
+export const App: React.FC<{ basePath?: string }> = ({ basePath = '/admin' }) => {
+  return (
+    <ConfigProvider
+      theme={{
+        token: {
+          colorPrimary: '#1890ff',
+        },
+      }}
+    >
+      <BrowserRouter basename={basePath}>
+        <Routes>
+${publicRouteLines.join("\n")}
+          <Route
+            path="/*"
+            element={
+              <ProtectedRoute>
+                <Layout>
+                  <Routes>
+                    <Route path="/" element={<Navigate to="${defaultProtectedRoute}" replace />} />
+${protectedRouteElements.join("\n")}
+                    <Route path="/system/monitor" element={<div className="p-6"><h2 className="text-xl font-semibold">System Monitor</h2><p className="text-gray-500 mt-2">Coming soon...</p></div>} />
+                  </Routes>
+                </Layout>
+              </ProtectedRoute>
+            }
+          />
+        </Routes>${captchaElement}
+      </BrowserRouter>
+    </ConfigProvider>
+  )
+}
+`;
+}
+function generateAdminComponentsIndex(resolved) {
+  if (!resolved.hasAdmin) return null;
+  const lines = [
+    `export { UserTable } from './UserTable'`,
+    `export { StatsCard } from './StatsCard'`,
+    `export { PageHeader } from './PageHeader'`,
+    `export { UserFormModal } from './UserFormModal'`,
+    `export { ProtectedRoute } from './ProtectedRoute'`
+  ];
+  if (resolved.hasCaptcha) {
+    lines.push(`export { CaptchaModal } from './CaptchaModal'`);
+  }
+  lines.push(`export { PermissionGuard, PermissionButton, Can, Cannot } from './PermissionGuard'`);
+  return lines.join("\n") + "\n";
+}
+function generateAdminApiClient(resolved) {
+  if (!resolved.hasAdmin) return null;
+  const captchaImport = resolved.hasCaptcha ? `import { useCaptchaStore } from '../stores/captchaStore'
+` : "";
+  const captchaFetchSetup = resolved.hasCaptcha ? `  const showCaptcha = useCaptchaStore.getState().show
+
+` : "";
+  const captchaHandler = resolved.hasCaptcha ? `    onShowCaptcha: async config => {
+      return showCaptcha({
+        type: config.type,
+        captchaUrl: config.captchaUrl,
+      })
+    },` : `    onShowCaptcha: async () => true,`;
+  return `/**
+ * @framework-baseline ab16e97716a7556e
+ * @framework-modify
+ * @reason Conditional captcha support based on preset modules
+ * @impact Captcha module excluded = no captchaStore import
+ */
+
+import { hc } from 'hono/client'
+import { WSClientImpl } from '@shared/core/ws-client'
+import { SSEClientImpl } from '@shared/core/sse-client'
+import { createRequestInterceptor } from './requestInterceptor'
+${captchaImport}import type { AdminApiType } from '@server/index'
+
+const baseUrl = import.meta.env.API_BASE_URL || window.location.origin
+
+const TOKEN_KEY = 'admin-storage'
+
+function clearAuthAndRedirect(): void {
+  localStorage.removeItem(TOKEN_KEY)
+  if (window.location.pathname !== '/admin/login') {
+    window.location.href = '/admin/login'
+  }
+}
+
+function getAuthToken(): string | null {
+  try {
+    const stored = localStorage.getItem(TOKEN_KEY)
+    if (stored) {
+      const parsed = JSON.parse(stored)
+      return parsed.state?.token || null
+    }
+  } catch {
+    return null
+  }
+  return null
+}
+
+function createCustomFetch() {
+${captchaFetchSetup}  return createRequestInterceptor({
+    onShowLogin: clearAuthAndRedirect,
+${captchaHandler}  })
+}
+
+export const apiClient = hc<AdminApiType>(baseUrl, {
+  fetch: createCustomFetch() as typeof fetch,
+  webSocket: url => new WSClientImpl(url) as unknown as WebSocket,
+  sse: url => {
+    const token = getAuthToken()
+    const headers: Record<string, string> = {}
+    if (token) {
+      headers['Authorization'] = \`Bearer \${token}\`
+    }
+    return new SSEClientImpl(url, headers)
+  },
+})
+
+export { api } from '@shared/core/api-request'
+`;
+}
+
+// src/generators/db-schema-barrel.ts
+function generateDbSchemaBarrel(resolved) {
+  const files = getDbSchemaFiles(resolved);
+  const exports = files.map((f) => `export * from './${f}'`);
+  return exports.join("\n") + "\n";
+}
+
+// src/generators/db-init.ts
+var INITIAL_PERMISSIONS = `const initialPermissions = [
+  {
+    id: 'perm_user_view',
+    code: 'user:view',
+    name: '\u67E5\u770B\u7528\u6237',
+    label: '\u67E5\u770B\u7528\u6237',
+    category: 'user',
+    sortOrder: 1,
+  },
+  {
+    id: 'perm_user_create',
+    code: 'user:create',
+    name: '\u521B\u5EFA\u7528\u6237',
+    label: '\u521B\u5EFA\u7528\u6237',
+    category: 'user',
+    sortOrder: 2,
+  },
+  {
+    id: 'perm_user_edit',
+    code: 'user:edit',
+    name: '\u7F16\u8F91\u7528\u6237',
+    label: '\u7F16\u8F91\u7528\u6237',
+    category: 'user',
+    sortOrder: 3,
+  },
+  {
+    id: 'perm_user_delete',
+    code: 'user:delete',
+    name: '\u5220\u9664\u7528\u6237',
+    label: '\u5220\u9664\u7528\u6237',
+    category: 'user',
+    sortOrder: 4,
+  },
+  {
+    id: 'perm_content_view',
+    code: 'content:view',
+    name: '\u67E5\u770B\u5185\u5BB9',
+    label: '\u67E5\u770B\u5185\u5BB9',
+    category: 'content',
+    sortOrder: 1,
+  },
+  {
+    id: 'perm_content_create',
+    code: 'content:create',
+    name: '\u521B\u5EFA\u5185\u5BB9',
+    label: '\u521B\u5EFA\u5185\u5BB9',
+    category: 'content',
+    sortOrder: 2,
+  },
+  {
+    id: 'perm_content_edit',
+    code: 'content:edit',
+    name: '\u7F16\u8F91\u5185\u5BB9',
+    label: '\u7F16\u8F91\u5185\u5BB9',
+    category: 'content',
+    sortOrder: 3,
+  },
+  {
+    id: 'perm_content_delete',
+    code: 'content:delete',
+    name: '\u5220\u9664\u5185\u5BB9',
+    label: '\u5220\u9664\u5185\u5BB9',
+    category: 'content',
+    sortOrder: 4,
+  },
+  {
+    id: 'perm_system_settings',
+    code: 'system:settings',
+    name: '\u7CFB\u7EDF\u8BBE\u7F6E',
+    label: '\u7CFB\u7EDF\u8BBE\u7F6E',
+    category: 'system',
+    sortOrder: 1,
+  },
+  {
+    id: 'perm_system_logs',
+    code: 'system:logs',
+    name: '\u7CFB\u7EDF\u65E5\u5FD7',
+    label: '\u7CFB\u7EDF\u65E5\u5FD7',
+    category: 'system',
+    sortOrder: 2,
+  },
+  {
+    id: 'perm_system_monitor',
+    code: 'system:monitor',
+    name: '\u7CFB\u7EDF\u76D1\u63A7',
+    label: '\u7CFB\u7EDF\u76D1\u63A7',
+    category: 'system',
+    sortOrder: 3,
+  },
+  {
+    id: 'perm_data_export',
+    code: 'data:export',
+    name: '\u6570\u636E\u5BFC\u51FA',
+    label: '\u6570\u636E\u5BFC\u51FA',
+    category: 'data',
+    sortOrder: 1,
+  },
+  {
+    id: 'perm_data_import',
+    code: 'data:import',
+    name: '\u6570\u636E\u5BFC\u5165',
+    label: '\u6570\u636E\u5BFC\u5165',
+    category: 'data',
+    sortOrder: 2,
+  },
+  {
+    id: 'perm_order_view',
+    code: 'order:view',
+    name: '\u67E5\u770B\u8BA2\u5355',
+    label: '\u67E5\u770B\u8BA2\u5355',
+    category: 'order',
+    sortOrder: 1,
+  },
+  {
+    id: 'perm_order_create',
+    code: 'order:create',
+    name: '\u521B\u5EFA\u8BA2\u5355',
+    label: '\u521B\u5EFA\u8BA2\u5355',
+    category: 'order',
+    sortOrder: 2,
+  },
+  {
+    id: 'perm_order_edit',
+    code: 'order:edit',
+    name: '\u7F16\u8F91\u8BA2\u5355',
+    label: '\u7F16\u8F91\u8BA2\u5355',
+    category: 'order',
+    sortOrder: 3,
+  },
+  {
+    id: 'perm_order_delete',
+    code: 'order:delete',
+    name: '\u5220\u9664\u8BA2\u5355',
+    label: '\u5220\u9664\u8BA2\u5355',
+    category: 'order',
+    sortOrder: 4,
+  },
+  {
+    id: 'perm_order_process',
+    code: 'order:process',
+    name: '\u5904\u7406\u8BA2\u5355',
+    label: '\u5904\u7406\u8BA2\u5355',
+    category: 'order',
+    sortOrder: 5,
+  },
+  {
+    id: 'perm_ticket_view',
+    code: 'ticket:view',
+    name: '\u67E5\u770B\u5DE5\u5355',
+    label: '\u67E5\u770B\u5DE5\u5355',
+    category: 'ticket',
+    sortOrder: 1,
+  },
+  {
+    id: 'perm_ticket_create',
+    code: 'ticket:create',
+    name: '\u521B\u5EFA\u5DE5\u5355',
+    label: '\u521B\u5EFA\u5DE5\u5355',
+    category: 'ticket',
+    sortOrder: 2,
+  },
+  {
+    id: 'perm_ticket_edit',
+    code: 'ticket:edit',
+    name: '\u7F16\u8F91\u5DE5\u5355',
+    label: '\u7F16\u8F91\u5DE5\u5355',
+    category: 'ticket',
+    sortOrder: 3,
+  },
+  {
+    id: 'perm_ticket_delete',
+    code: 'ticket:delete',
+    name: '\u5220\u9664\u5DE5\u5355',
+    label: '\u5220\u9664\u5DE5\u5355',
+    category: 'ticket',
+    sortOrder: 4,
+  },
+  {
+    id: 'perm_ticket_reply',
+    code: 'ticket:reply',
+    name: '\u56DE\u590D\u5DE5\u5355',
+    label: '\u56DE\u590D\u5DE5\u5355',
+    category: 'ticket',
+    sortOrder: 5,
+  },
+  {
+    id: 'perm_ticket_close',
+    code: 'ticket:close',
+    name: '\u5173\u95ED\u5DE5\u5355',
+    label: '\u5173\u95ED\u5DE5\u5355',
+    category: 'ticket',
+    sortOrder: 6,
+  },
+  {
+    id: 'perm_dispute_view',
+    code: 'dispute:view',
+    name: '\u67E5\u770B\u4E89\u8BAE',
+    label: '\u67E5\u770B\u4E89\u8BAE',
+    category: 'dispute',
+    sortOrder: 1,
+  },
+  {
+    id: 'perm_dispute_create',
+    code: 'dispute:create',
+    name: '\u521B\u5EFA\u4E89\u8BAE',
+    label: '\u521B\u5EFA\u4E89\u8BAE',
+    category: 'dispute',
+    sortOrder: 2,
+  },
+  {
+    id: 'perm_dispute_edit',
+    code: 'dispute:edit',
+    name: '\u7F16\u8F91\u4E89\u8BAE',
+    label: '\u7F16\u8F91\u4E89\u8BAE',
+    category: 'dispute',
+    sortOrder: 3,
+  },
+  {
+    id: 'perm_dispute_delete',
+    code: 'dispute:delete',
+    name: '\u5220\u9664\u4E89\u8BAE',
+    label: '\u5220\u9664\u4E89\u8BAE',
+    category: 'dispute',
+    sortOrder: 4,
+  },
+  {
+    id: 'perm_dispute_resolve',
+    code: 'dispute:resolve',
+    name: '\u89E3\u51B3\u4E89\u8BAE',
+    label: '\u89E3\u51B3\u4E89\u8BAE',
+    category: 'dispute',
+    sortOrder: 5,
+  },
+  {
+    id: 'perm_role_view',
+    code: 'role:view',
+    name: '\u67E5\u770B\u89D2\u8272',
+    label: '\u67E5\u770B\u89D2\u8272',
+    category: 'role',
+    sortOrder: 1,
+  },
+  {
+    id: 'perm_role_create',
+    code: 'role:create',
+    name: '\u521B\u5EFA\u89D2\u8272',
+    label: '\u521B\u5EFA\u89D2\u8272',
+    category: 'role',
+    sortOrder: 2,
+  },
+  {
+    id: 'perm_role_edit',
+    code: 'role:edit',
+    name: '\u7F16\u8F91\u89D2\u8272',
+    label: '\u7F16\u8F91\u89D2\u8272',
+    category: 'role',
+    sortOrder: 3,
+  },
+  {
+    id: 'perm_role_delete',
+    code: 'role:delete',
+    name: '\u5220\u9664\u89D2\u8272',
+    label: '\u5220\u9664\u89D2\u8272',
+    category: 'role',
+    sortOrder: 4,
+  },
+]`;
+var INITIAL_ROLES = `const initialRoles = [
+  {
+    id: 'role_super_admin',
+    code: 'super_admin',
+    name: '\u8D85\u7EA7\u7BA1\u7406\u5458',
+    label: '\u8D85\u7EA7\u7BA1\u7406\u5458',
+    isSystem: true,
+    sortOrder: 1,
+  },
+  {
+    id: 'role_customer_service',
+    code: 'customer_service',
+    name: '\u5BA2\u670D\u4EBA\u5458',
+    label: '\u5BA2\u670D\u4EBA\u5458',
+    isSystem: true,
+    sortOrder: 2,
+  },
+  {
+    id: 'role_user',
+    code: 'user',
+    name: '\u666E\u901A\u7528\u6237',
+    label: '\u666E\u901A\u7528\u6237',
+    isSystem: true,
+    sortOrder: 3,
+  },
+]`;
+var INITIAL_ROLE_PERMISSIONS = `const initialRolePermissions = [
+  { roleId: 'role_super_admin', permissionId: 'perm_user_view' },
+  { roleId: 'role_super_admin', permissionId: 'perm_user_create' },
+  { roleId: 'role_super_admin', permissionId: 'perm_user_edit' },
+  { roleId: 'role_super_admin', permissionId: 'perm_user_delete' },
+  { roleId: 'role_super_admin', permissionId: 'perm_content_view' },
+  { roleId: 'role_super_admin', permissionId: 'perm_content_create' },
+  { roleId: 'role_super_admin', permissionId: 'perm_content_edit' },
+  { roleId: 'role_super_admin', permissionId: 'perm_content_delete' },
+  { roleId: 'role_super_admin', permissionId: 'perm_system_settings' },
+  { roleId: 'role_super_admin', permissionId: 'perm_system_logs' },
+  { roleId: 'role_super_admin', permissionId: 'perm_system_monitor' },
+  { roleId: 'role_super_admin', permissionId: 'perm_data_export' },
+  { roleId: 'role_super_admin', permissionId: 'perm_data_import' },
+  { roleId: 'role_super_admin', permissionId: 'perm_order_view' },
+  { roleId: 'role_super_admin', permissionId: 'perm_order_create' },
+  { roleId: 'role_super_admin', permissionId: 'perm_order_edit' },
+  { roleId: 'role_super_admin', permissionId: 'perm_order_delete' },
+  { roleId: 'role_super_admin', permissionId: 'perm_order_process' },
+  { roleId: 'role_super_admin', permissionId: 'perm_ticket_view' },
+  { roleId: 'role_super_admin', permissionId: 'perm_ticket_create' },
+  { roleId: 'role_super_admin', permissionId: 'perm_ticket_edit' },
+  { roleId: 'role_super_admin', permissionId: 'perm_ticket_delete' },
+  { roleId: 'role_super_admin', permissionId: 'perm_ticket_reply' },
+  { roleId: 'role_super_admin', permissionId: 'perm_ticket_close' },
+  { roleId: 'role_super_admin', permissionId: 'perm_dispute_view' },
+  { roleId: 'role_super_admin', permissionId: 'perm_dispute_create' },
+  { roleId: 'role_super_admin', permissionId: 'perm_dispute_edit' },
+  { roleId: 'role_super_admin', permissionId: 'perm_dispute_delete' },
+  { roleId: 'role_super_admin', permissionId: 'perm_dispute_resolve' },
+  { roleId: 'role_customer_service', permissionId: 'perm_content_view' },
+  { roleId: 'role_customer_service', permissionId: 'perm_order_view' },
+  { roleId: 'role_customer_service', permissionId: 'perm_order_create' },
+  { roleId: 'role_customer_service', permissionId: 'perm_order_edit' },
+  { roleId: 'role_customer_service', permissionId: 'perm_order_delete' },
+  { roleId: 'role_customer_service', permissionId: 'perm_order_process' },
+  { roleId: 'role_customer_service', permissionId: 'perm_ticket_view' },
+  { roleId: 'role_customer_service', permissionId: 'perm_ticket_create' },
+  { roleId: 'role_customer_service', permissionId: 'perm_ticket_edit' },
+  { roleId: 'role_customer_service', permissionId: 'perm_ticket_delete' },
+  { roleId: 'role_customer_service', permissionId: 'perm_ticket_reply' },
+  { roleId: 'role_customer_service', permissionId: 'perm_ticket_close' },
+  { roleId: 'role_customer_service', permissionId: 'perm_dispute_view' },
+  { roleId: 'role_customer_service', permissionId: 'perm_dispute_create' },
+  { roleId: 'role_customer_service', permissionId: 'perm_dispute_edit' },
+  { roleId: 'role_customer_service', permissionId: 'perm_dispute_delete' },
+  { roleId: 'role_customer_service', permissionId: 'perm_dispute_resolve' },
+  { roleId: 'role_customer_service', permissionId: 'perm_data_export' },
+  { roleId: 'role_customer_service', permissionId: 'perm_system_logs' },
+  { roleId: 'role_user', permissionId: 'perm_content_view' },
+  { roleId: 'role_user', permissionId: 'perm_order_view' },
+]`;
+function generateDbInit(resolved) {
+  const activeSeeds = [];
+  for (const [name, manifest] of resolved.modules) {
+    if (manifest.dbSchemas?.hasSeed && manifest.dbSchemas.seed) {
+      activeSeeds.push({
+        moduleDir: `module-${name}`,
+        serviceFile: manifest.dbSchemas.seed.serviceFile,
+        functionName: manifest.dbSchemas.seed.functionName
+      });
+    }
+  }
+  if (!resolved.hasPermission) {
+    return generateMinimalDbInit(activeSeeds);
+  }
+  return generateFullDbInit(activeSeeds);
+}
+function generateMinimalDbInit(activeSeeds) {
+  const seedCalls = activeSeeds.map((s) => `    import('../${s.moduleDir}/services/${s.serviceFile}').then(m => m.${s.functionName}()),`).join("\n");
+  const seedBlock = activeSeeds.length > 0 ? `
+  log.info({}, 'Seeding module data...')
+  await Promise.all([
+${seedCalls}
+  ])
+  log.info({}, 'Module data seeding complete!')` : "";
+  return `import { getDb } from './driver'
+import { logger } from '../utils/logger'
+
+const log = logger.db()
+
+export async function initializeDatabase() {
+  await getDb()
+
+  log.info({}, 'Initializing database...')
+
+  log.info({}, 'Database initialization complete!')${seedBlock}
+}
+`;
+}
+function generateFullDbInit(activeSeeds) {
+  const seedCalls = activeSeeds.map((s) => `    import('../${s.moduleDir}/services/${s.serviceFile}').then(m => m.${s.functionName}()),`).join("\n");
+  const seedBlock = activeSeeds.length > 0 ? `
+  log.info({}, 'Seeding module data...')
+  await Promise.all([
+${seedCalls}
+  ])
+  log.info({}, 'Module data seeding complete!')` : "";
+  return `import { getDb } from './driver'
+import { permissions, roles, rolePermissions } from './schema'
+import { logger } from '../utils/logger'
+
+const log = logger.db()
+
+${INITIAL_PERMISSIONS}
+
+${INITIAL_ROLES}
+
+${INITIAL_ROLE_PERMISSIONS}
+
+export async function initializeDatabase() {
+  const db = await getDb()
+
+  log.info({}, 'Initializing database...')
+
+  const existingPermissions = await db.select().from(permissions)
+  if (existingPermissions.length === 0) {
+    log.info({}, 'Inserting initial permissions...')
+    await db.insert(permissions).values(
+      initialPermissions.map(p => ({
+        ...p,
+        description: null,
+        isActive: true,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      }))
+    )
+  }
+
+  const existingRoles = await db.select().from(roles)
+  if (existingRoles.length === 0) {
+    log.info({}, 'Inserting initial roles...')
+    await db.insert(roles).values(
+      initialRoles.map(r => ({
+        ...r,
+        description: null,
+        isActive: true,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      }))
+    )
+  }
+
+  const existingRolePermissions = await db.select().from(rolePermissions)
+  if (existingRolePermissions.length === 0) {
+    log.info({}, 'Inserting initial role permissions...')
+    await db.insert(rolePermissions).values(
+      initialRolePermissions.map(rp => ({
+        ...rp,
+        createdAt: new Date(),
+      }))
+    )
+  }
+
+  log.info({}, 'Database initialization complete!')${seedBlock}
+}
+`;
+}
+
+// src/generators/server-app.ts
+function generateServerApp(resolved) {
+  const useRealtime = resolved.hasSSE || resolved.hasWebSocket;
+  const useAuditLog = resolved.hasPermission;
+  const useCaptcha = resolved.hasCaptcha;
+  const standaloneRoutes = getStandaloneRoutes(resolved);
+  const imports = [
+    `import { OpenAPIHono } from '@hono/zod-openapi'`,
+    ``,
+    `import { HTTPException } from 'hono/http-exception'`,
+    `import type { ContentfulStatusCode } from 'hono/utils/http-status'`,
+    `import { ZodError } from 'zod'`,
+    `import type { AppBindings, CreateAppOptions } from './types/bindings'`,
+    `import { AppError } from './utils/app-error'`,
+    `import { autoRegisterRealtime } from './core/realtime-scanner'`,
+    `import { corsMiddleware, loggerMiddleware, errorHandlerMiddleware } from './middleware'`
+  ];
+  if (useRealtime) {
+    imports.push(`import { realtimeEnvMiddleware } from './middleware/realtime-env'`);
+  }
+  if (useAuditLog) {
+    imports.push(`import { auditLogMiddleware } from './middleware/audit-log'`);
+  }
+  if (useCaptcha) {
+    imports.push(`import { captchaMiddleware } from './middleware/captcha'`);
+  }
+  imports.push(
+    `import { createModuleLoggerSync } from './utils/logger'`,
+    `import { adminApiRoutes, clientApiRoutes } from './route-registry'`
+  );
+  const standaloneImportSet = /* @__PURE__ */ new Set();
+  for (const [name, manifest] of resolved.modules) {
+    if (manifest.routes.standalone) {
+      const { importPath, exportName } = manifest.routes.standalone;
+      const moduleDir = `module-${name}`;
+      const relPath = importPath.replace(/^\.\//, "");
+      const stmt = `import { ${exportName} } from './${moduleDir}/${relPath}'`;
+      if (!standaloneImportSet.has(stmt)) {
+        standaloneImportSet.add(stmt);
+        imports.push(stmt);
+      }
+    }
+  }
+  const middlewareChain = [
+    `.use('*', errorHandlerMiddleware())`,
+    `.use('*', loggerMiddleware())`,
+    `.use('*', corsMiddleware())`
+  ];
+  if (useRealtime) {
+    middlewareChain.push(`.use('*', realtimeEnvMiddleware())`);
+  }
+  if (useAuditLog) {
+    middlewareChain.push(`.use('/api/*', auditLogMiddleware())`);
+  }
+  if (useCaptcha) {
+    middlewareChain.push(
+      `.use(
+      '/api/admin/*',
+      captchaMiddleware({
+        maxRequests: 20,
+        windowMs: 60000,
+      })
+    )`
+    );
+  }
+  const routes = [`.route('/', clientApiRoutes)`, `.route('/', adminApiRoutes)`];
+  for (const sr of standaloneRoutes) {
+    routes.push(`.route('${sr.mountPath}', ${sr.localName})`);
+  }
+  const indent = "    ";
+  const chain = [...middlewareChain, ...routes].join(`
+${indent}`);
+  return `${imports.join("\n")}
+
+export { type AppBindings, type CreateAppOptions } from './types/bindings'
+
+export function createApp<T extends AppBindings = AppBindings>(_options: CreateAppOptions = {}) {
+  const app = new OpenAPIHono<{ Bindings: T }>()
+    ${chain}
+    .get('/health', async c => {
+      try {
+        const { getDb } = await import('./db')
+        await getDb()
+        return c.json({ status: 'ok', timestamp: new Date().toISOString(), db: 'connected' })
+      } catch {
+        return c.json({ status: 'ok', timestamp: new Date().toISOString(), db: 'not configured' })
+      }
+    })
+    .post('/api/__test__/cleanup', async c => {
+      try {
+        const { cleanupTestDatabase } = await import('./db/test-setup')
+        await cleanupTestDatabase()
+        return c.json({ success: true as const, message: 'Database cleaned up' })
+      } catch (error) {
+        console.error('Error during database cleanup:', error)
+        return c.json({ success: false as const, message: 'Failed to cleanup database' }, 500)
+      }
+    })
+
+  autoRegisterRealtime(app as unknown as Parameters<typeof autoRegisterRealtime>[0])
+
+  app.onError((err, c) => {
+    const log = createModuleLoggerSync('api')
+    c.res.headers.set('Content-Type', 'application/json')
+
+    if (AppError.isAppError(err)) {
+      return c.json(
+        {
+          success: false as const,
+          error: err.message,
+          status: err.statusCode,
+          details: err.details,
+        },
+        err.statusCode as ContentfulStatusCode
+      )
+    }
+
+    if (err instanceof HTTPException) {
+      return c.json(
+        { success: false as const, error: err.message, status: err.status },
+        err.status as ContentfulStatusCode
+      )
+    }
+
+    if (err instanceof ZodError) {
+      const details = err.issues.map(issue => ({
+        field: issue.path.join('.'),
+        message: issue.message,
+      }))
+      return c.json(
+        { success: false as const, error: 'Validation failed', status: 400, details },
+        400
+      )
+    }
+
+    log.error({ err, path: c.req.path }, 'Unhandled error')
+    return c.json(
+      { success: false as const, error: err.message || 'Internal server error', status: 500 },
+      500
+    )
+  })
+
+  return app
+}
+export type AdminApiType = typeof adminApiRoutes
+export type ClientApiType = typeof clientApiRoutes
+export type AppType = ReturnType<typeof createApp>
+`;
+}
+
+// src/generators/shared-modules-index.ts
+var MODULE_EXPORTS = {
+  chat: {
+    namedExports: ["ChatProtocolSchema", "type ChatProtocol"]
+  },
+  todos: {
+    namedExports: [
+      "TodoSchema",
+      "TodoStatusSchema",
+      "CreateTodoSchema",
+      "UpdateTodoSchema",
+      "TodoIdSchema",
+      "type Todo",
+      "type TodoStatus",
+      "type CreateTodoInput",
+      "type UpdateTodoInput"
+    ]
+  },
+  files: {
+    namedExports: [
+      "FileDownloadSchema",
+      "PrivateFileQuerySchema",
+      "PublicFileUrlSchema",
+      "PrivateFileUrlSchema",
+      "GenerateUrlRequestSchema",
+      "FileUrlResponseSchema",
+      "EmptySchema"
+    ]
+  },
+  notifications: {
+    namedExports: [
+      "NotificationSchema",
+      "NotificationTypeSchema",
+      "CreateNotificationSchema",
+      "NotificationListQuerySchema",
+      "SSEEventSchema",
+      "AppSSEProtocolSchema",
+      "type AppNotification",
+      "type NotificationType",
+      "type CreateNotificationInput",
+      "type NotificationListQuery",
+      "type SSEEvent",
+      "type AppSSEProtocol"
+    ]
+  },
+  admin: {
+    namedExports: [
+      "SystemStatsSchema",
+      "HealthCheckSchema",
+      "RecentActivityItemSchema",
+      "RecentActivitySchema",
+      "AuthUserSchema",
+      "ClearTodosResultSchema",
+      "type SystemStats",
+      "type HealthCheck",
+      "type RecentActivityItem",
+      "type AuthUserResponse",
+      "type ClearTodosResult"
+    ]
+  },
+  permission: {
+    namedExports: [
+      "RoleEnum",
+      "RoleInfoSchema",
+      "PermissionInfoSchema",
+      "UserPermissionsSchema",
+      "RoleListSchema",
+      "PermissionListSchema",
+      "Role",
+      "Permission",
+      "ROLE_PERMISSIONS",
+      "ROLE_LABELS",
+      "PERMISSION_LABELS",
+      "PERMISSION_CATEGORIES",
+      "getPermissionsByRole",
+      "hasPermission",
+      "hasAnyPermission",
+      "hasAllPermissions",
+      "type PermissionRoleType",
+      "type RoleInfo",
+      "type PermissionInfo",
+      "type UserPermissions"
+    ]
+  },
+  auth: {
+    namedExports: [
+      "DeveloperProfileSchema",
+      "LoginSchema",
+      "RegisterSchema",
+      "TokenResponseSchema",
+      "type DeveloperProfile",
+      "type LoginInput",
+      "type RegisterInput",
+      "type TokenResponse"
+    ]
+  },
+  plugin: {
+    namedExports: [
+      "PluginSchema",
+      "PluginStatusSchema",
+      "CreatePluginSchema",
+      "UpdatePluginSchema",
+      "PluginVersionStatusSchema",
+      "VersionSchema",
+      "CategorySchema",
+      "ReviewSchema",
+      "CreateReviewSchema",
+      "MarketplaceStatsSchema",
+      "PluginListResponseSchema",
+      "AdminPluginSchema",
+      "AdminDashboardStatsSchema",
+      "PluginListQuerySchema",
+      "PluginSlugSchema",
+      "type Plugin",
+      "type PluginStatus",
+      "type CreatePluginInput",
+      "type UpdatePluginInput",
+      "type PluginVersionStatus",
+      "type Version",
+      "type Category",
+      "type Review",
+      "type CreateReviewInput",
+      "type MarketplaceStats",
+      "type PluginListResponse",
+      "type AdminPlugin",
+      "type AdminDashboardStats",
+      "type PluginListQuery"
+    ]
+  },
+  merchant: {
+    namedExports: [
+      "ProductSchema",
+      "CreateProductSchema",
+      "UpdateProductSchema",
+      "ProductListSchema",
+      "type Product",
+      "type CreateProductInput",
+      "type UpdateProductInput"
+    ]
+  },
+  tenant: {
+    namedExports: [
+      "TenantSchema",
+      "TenantStatusSchema",
+      "TenantPlanSchema",
+      "TenantSettingsSchema",
+      "CreateTenantSchema",
+      "UpdateTenantSchema",
+      "TenantIdSchema",
+      "TenantSlugSchema",
+      "TenantListResponseSchema",
+      "TenantQuerySchema",
+      "TenantIdResponseSchema",
+      "type Tenant",
+      "type TenantStatus",
+      "type TenantPlan",
+      "type TenantSettings",
+      "type CreateTenantInput",
+      "type UpdateTenantInput",
+      "type TenantId",
+      "type TenantSlug",
+      "type TenantListResponse",
+      "type TenantQuery",
+      "type TenantIdResponse"
+    ]
+  },
+  order: {
+    namedExports: [
+      "OrderStatusSchema",
+      "OrderSchema",
+      "CreateOrderSchema",
+      "UpdateOrderSchema",
+      "OrderListSchema",
+      "OrderQuerySchema",
+      "OrderDeleteResultSchema",
+      "ProcessOrderSchema",
+      "CancelOrderSchema",
+      "RemoveCartItemResponseSchema",
+      "ECommerceProductSchema",
+      "ECommerceOrderStatusSchema",
+      "ECommerceOrderSchema",
+      "ECommerceOrderListSchema",
+      "type OrderStatus",
+      "type Order",
+      "type CreateOrderInput",
+      "type UpdateOrderInput",
+      "type OrderDeleteResult",
+      "type ProcessOrderInput",
+      "type CancelOrderInput",
+      "type OrderQueryInput",
+      "type RemoveCartItemResponse",
+      "type ECommerceProduct",
+      "type ECommerceOrderStatus",
+      "type ECommerceOrder"
+    ]
+  },
+  ticket: {
+    namedExports: [
+      "TicketStatusSchema",
+      "TicketPrioritySchema",
+      "TicketCategorySchema",
+      "TicketReplySchema",
+      "TicketSchema",
+      "CreateTicketSchema",
+      "UpdateTicketSchema",
+      "ReplyTicketSchema",
+      "TicketListSchema",
+      "TicketDeleteResultSchema",
+      "type TicketStatus",
+      "type TicketPriority",
+      "type TicketCategory",
+      "type TicketReply",
+      "type Ticket",
+      "type CreateTicketInput",
+      "type UpdateTicketInput",
+      "type ReplyTicketInput",
+      "type TicketDeleteResult"
+    ]
+  },
+  dispute: {
+    namedExports: [
+      "DisputeTypeSchema",
+      "DisputeStatusSchema",
+      "DisputeSchema",
+      "CreateDisputeSchema",
+      "UpdateDisputeSchema",
+      "ResolveDisputeSchema",
+      "DisputeListSchema",
+      "DisputeDeleteResultSchema",
+      "type DisputeType",
+      "type DisputeStatus",
+      "type Dispute",
+      "type CreateDisputeInput",
+      "type UpdateDisputeInput",
+      "type ResolveDisputeInput",
+      "type DisputeDeleteResult"
+    ]
+  },
+  content: {
+    namedExports: [
+      "ContentCategorySchema",
+      "ContentStatusSchema",
+      "ContentSchema",
+      "CreateContentSchema",
+      "UpdateContentSchema",
+      "ContentListSchema",
+      "ContentDeleteResultSchema",
+      "type ContentCategory",
+      "type ContentStatus",
+      "type Content",
+      "type CreateContentInput",
+      "type UpdateContentInput",
+      "type ContentDeleteResult"
+    ]
+  },
+  captcha: {
+    namedExports: [
+      "CaptchaResponseSchema",
+      "VerifyCaptchaRequestSchema",
+      "CaptchaVerifyResponseSchema",
+      "type CaptchaResponse",
+      "type VerifyCaptchaRequest",
+      "type CaptchaVerifyResponse"
+    ]
+  },
+  dashboard: {
+    namedExports: [
+      "DashboardStatSchema",
+      "RevenueDataSchema",
+      "ActivityStatusSchema",
+      "ActivitySchema",
+      "DashboardResponseSchema",
+      "type DashboardStat",
+      "type RevenueData",
+      "type ActivityStatus",
+      "type Activity",
+      "type DashboardResponse"
+    ]
+  },
+  cart: {
+    namedExports: [
+      "CartItemSchema",
+      "CartSummarySchema",
+      "CartResponseSchema",
+      "AddCartItemSchema",
+      "CartItemIdSchema",
+      "type CartItem",
+      "type CartSummary",
+      "type CartResponse",
+      "type AddCartItemInput"
+    ]
+  },
+  community: {
+    namedExports: [
+      "TopicStatusSchema",
+      "TopicTagSchema",
+      "TopicAuthorSchema",
+      "TopicSchema",
+      "TopicsResponseSchema",
+      "ProfileStatsSchema",
+      "ActivityTypeSchema",
+      "ProfileActivitySchema",
+      "ProfileResponseSchema",
+      "type TopicStatus",
+      "type TopicTag",
+      "type TopicAuthor",
+      "type Topic",
+      "type ProfileStats",
+      "type ActivityType",
+      "type ProfileActivity",
+      "type ProfileResponse"
+    ]
+  },
+  audit: {
+    namedExports: ["ResourceTypeSchema", "ActionTypeSchema", "AuditLogSchema", "type AuditLogType"]
+  },
+  role: {
+    namedExports: [
+      "RoleSchema",
+      "CreateRoleSchema",
+      "UpdateRoleSchema",
+      "UpdateRolePermissionsSchema",
+      "RoleSuccessSchema",
+      "type RoleDataType",
+      "type CreateRoleType",
+      "type UpdateRoleType"
+    ]
+  }
+};
+function generateSharedModulesIndex(resolved) {
+  const lines = [];
+  const moduleOrder2 = [
+    "chat",
+    "todos",
+    "file",
+    "notifications",
+    "admin",
+    "permission",
+    "auth",
+    "plugin",
+    "merchant",
+    "tenant",
+    "order",
+    "ticket",
+    "dispute",
+    "content",
+    "captcha"
+  ];
+  const STANDALONE_SHARED_MODULES2 = {
+    cart: { pages: ["CartPage.tsx"] },
+    community: { pages: ["TopicsPage.tsx", "ProfilePage.tsx"], serverModules: ["content"] },
+    dashboard: { pages: ["DashboardPage.tsx"] }
+  };
+  for (const moduleName of moduleOrder2) {
+    if (!resolved.modules.has(moduleName)) continue;
+    const manifest = resolved.modules.get(moduleName);
+    const exportKey = manifest.sharedSchemas?.path ?? moduleName;
+    const exports = MODULE_EXPORTS[exportKey];
+    if (!exports) continue;
+    lines.push(`export {
+  ${exports.namedExports.join(",\n  ")},
+} from './${exportKey}'`);
+  }
+  const additionalExported = /* @__PURE__ */ new Set();
+  for (const moduleName of moduleOrder2) {
+    if (!resolved.modules.has(moduleName)) continue;
+    const manifest = resolved.modules.get(moduleName);
+    if (manifest.sharedSchemas?.additionalPaths) {
+      for (const extra of manifest.sharedSchemas.additionalPaths) {
+        if (additionalExported.has(extra)) continue;
+        additionalExported.add(extra);
+        const exports = MODULE_EXPORTS[extra];
+        if (!exports) continue;
+        lines.push(`export {
+  ${exports.namedExports.join(",\n  ")},
+} from './${extra}'`);
+      }
+    }
+  }
+  for (const [moduleName, config] of Object.entries(STANDALONE_SHARED_MODULES2)) {
+    const hasRelevantPage = config.pages && [...resolved.modules.values()].some(
+      (m) => m.clientPages?.some((p) => config.pages.includes(p.name + ".tsx")) ?? false
+    );
+    const hasRelevantServerModule = config.serverModules?.some((sm) => resolved.modules.has(sm)) ?? false;
+    if (!hasRelevantPage && !hasRelevantServerModule) continue;
+    const exports = MODULE_EXPORTS[moduleName];
+    if (!exports) continue;
+    lines.push(`export {
+  ${exports.namedExports.join(",\n  ")},
+} from './${moduleName}'`);
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/generators/shared-schemas-index.ts
+var MODULE_EXPORTS2 = {
+  chat: {
+    namedExports: [
+      "ChatProtocolSchema",
+      "WebSocketStatusSchema",
+      "type ChatProtocol",
+      "type WebSocketStatus"
+    ]
+  },
+  file: {
+    namedExports: [
+      "FileDownloadSchema",
+      "PrivateFileQuerySchema",
+      "PublicFileUrlSchema",
+      "PrivateFileUrlSchema",
+      "GenerateUrlRequestSchema",
+      "FileUrlResponseSchema",
+      "EmptySchema",
+      "UploadResultSchema",
+      "UploadFileBodySchema"
+    ]
+  },
+  todos: {
+    namedExports: [
+      "TodoSchema",
+      "TodoStatusSchema",
+      "CreateTodoSchema",
+      "UpdateTodoSchema",
+      "TodoIdSchema",
+      "TodoIdResponseSchema",
+      "TodoAttachmentSchema",
+      "TodoAttachmentListSchema",
+      "TodoWithAttachmentsSchema",
+      "UploadFileSchema",
+      "AttachmentIdResponseSchema",
+      "type Todo",
+      "type TodoStatus",
+      "type CreateTodoInput",
+      "type UpdateTodoInput",
+      "type TodoIdResponse",
+      "type TodoAttachment",
+      "type TodoWithAttachments"
+    ]
+  },
+  notifications: {
+    namedExports: [
+      "NotificationSchema",
+      "NotificationTypeSchema",
+      "CreateNotificationSchema",
+      "NotificationListQuerySchema",
+      "SSEEventSchema",
+      "AppSSEProtocolSchema",
+      "UnreadCountSchema",
+      "NotificationIdSchema",
+      "UnreadCountEventSchema",
+      "type AppNotification",
+      "type NotificationType",
+      "type CreateNotificationInput",
+      "type NotificationListQuery",
+      "type SSEEvent",
+      "type AppSSEProtocol",
+      "type UnreadCount",
+      "type NotificationId",
+      "type UnreadCountEvent"
+    ]
+  },
+  auth: {
+    namedExports: [
+      "DeveloperProfileSchema",
+      "LoginSchema",
+      "RegisterSchema",
+      "TokenResponseSchema",
+      "ProfileSchema",
+      "type DeveloperProfile",
+      "type LoginInput",
+      "type RegisterInput",
+      "type TokenResponse",
+      "type Profile"
+    ]
+  },
+  plugin: {
+    namedExports: [
+      "PluginSchema",
+      "PluginStatusSchema",
+      "CreatePluginSchema",
+      "UpdatePluginSchema",
+      "PluginVersionStatusSchema",
+      "VersionSchema",
+      "CategorySchema",
+      "ReviewSchema",
+      "CreateReviewSchema",
+      "MarketplaceStatsSchema",
+      "PluginListResponseSchema",
+      "AdminPluginSchema",
+      "AdminDashboardStatsSchema",
+      "PluginListQuerySchema",
+      "PluginSlugSchema",
+      "PluginSearchQuerySchema",
+      "PluginDeleteResponseSchema",
+      "ReviewIdParamsSchema",
+      "ReviewDeleteResponseSchema",
+      "CategorySlugParamsSchema",
+      "CategoryPluginsQuerySchema",
+      "PluginListAdminSchema",
+      "AdminListQuerySchema",
+      "AdminListAllQuerySchema",
+      "RejectPluginBodySchema",
+      "BulkApproveBodySchema",
+      "BulkRejectBodySchema",
+      "BulkResponseSchema",
+      "CreateCategoryBodySchema",
+      "UpdateCategoryBodySchema",
+      "CategoryIdParamsSchema",
+      "CategoryIdResponseSchema",
+      "type Plugin",
+      "type PluginStatus",
+      "type CreatePluginInput",
+      "type UpdatePluginInput",
+      "type PluginVersionStatus",
+      "type Version",
+      "type Category",
+      "type Review",
+      "type CreateReviewInput",
+      "type MarketplaceStats",
+      "type PluginListResponse",
+      "type AdminPlugin",
+      "type AdminDashboardStats",
+      "type PluginListQuery"
+    ]
+  },
+  admin: {
+    namedExports: [
+      "SystemStatsSchema",
+      "HealthCheckSchema",
+      "RecentActivityItemSchema",
+      "RecentActivitySchema",
+      "AuthUserSchema",
+      "LoginRequestSchema",
+      "LoginResponseSchema",
+      "RegisterRequestSchema",
+      "UserSchema",
+      "UserListSchema",
+      "UpdateUserRequestSchema",
+      "CreateUserRequestSchema",
+      "ClearTodosResultSchema",
+      "AdminSuccessSchema",
+      "DownloadTokenSchema",
+      "type SystemStats",
+      "type HealthCheck",
+      "type RecentActivityItem",
+      "type AuthUserResponse",
+      "type CreateUserRequest",
+      "type LoginRequest",
+      "type LoginResponse",
+      "type RegisterRequest",
+      "type User",
+      "type UpdateUserRequest",
+      "type ClearTodosResult"
+    ]
+  },
+  audit: {
+    namedExports: ["ResourceTypeSchema", "ActionTypeSchema", "AuditLogSchema", "type AuditLogType"]
+  },
+  captcha: {
+    namedExports: [
+      "CaptchaResponseSchema",
+      "VerifyCaptchaRequestSchema",
+      "CaptchaVerifyResponseSchema",
+      "type CaptchaResponse",
+      "type VerifyCaptchaRequest",
+      "type CaptchaVerifyResponse"
+    ]
+  },
+  cart: {
+    namedExports: [
+      "CartItemSchema",
+      "CartSummarySchema",
+      "CartResponseSchema",
+      "AddCartItemSchema",
+      "CartItemIdSchema",
+      "type CartItem",
+      "type CartSummary",
+      "type CartResponse",
+      "type AddCartItemInput"
+    ]
+  },
+  community: {
+    namedExports: [
+      "TopicStatusSchema",
+      "TopicTagSchema",
+      "TopicAuthorSchema",
+      "TopicSchema",
+      "TopicsResponseSchema",
+      "ProfileStatsSchema",
+      "ActivityTypeSchema",
+      "ProfileActivitySchema",
+      "ProfileResponseSchema",
+      "type TopicStatus",
+      "type TopicTag",
+      "type TopicAuthor",
+      "type Topic",
+      "type ProfileStats",
+      "type ActivityType",
+      "type ProfileActivity",
+      "type ProfileResponse"
+    ]
+  },
+  content: {
+    namedExports: [
+      "ContentCategorySchema",
+      "ContentStatusSchema",
+      "ContentSchema",
+      "CreateContentSchema",
+      "UpdateContentSchema",
+      "ContentListSchema",
+      "ContentDeleteResultSchema",
+      "type ContentCategory",
+      "type ContentStatus",
+      "type Content",
+      "type CreateContentInput",
+      "type UpdateContentInput",
+      "type ContentDeleteResult"
+    ]
+  },
+  dashboard: {
+    namedExports: [
+      "DashboardStatSchema",
+      "RevenueDataSchema",
+      "ActivityStatusSchema",
+      "ActivitySchema",
+      "DashboardResponseSchema",
+      "type DashboardStat",
+      "type RevenueData",
+      "type ActivityStatus",
+      "type Activity",
+      "type DashboardResponse"
+    ]
+  },
+  merchant: {
+    namedExports: [
+      "MerchantSchema",
+      "MerchantLoginSchema",
+      "MerchantLoginResponseSchema",
+      "MerchantStatsSchema",
+      "ProductSchema",
+      "CreateProductSchema",
+      "UpdateProductSchema",
+      "ProductListSchema",
+      "ProductListResponseSchema",
+      "ProductQuerySchema",
+      "type Merchant",
+      "type MerchantLoginInput",
+      "type MerchantLoginResponse",
+      "type MerchantStats",
+      "type Product",
+      "type CreateProductInput",
+      "type UpdateProductInput",
+      "type ProductListResponse",
+      "type ProductQuery"
+    ]
+  },
+  tenant: {
+    namedExports: [
+      "TenantSchema",
+      "TenantStatusSchema",
+      "TenantPlanSchema",
+      "TenantSettingsSchema",
+      "CreateTenantSchema",
+      "UpdateTenantSchema",
+      "TenantIdSchema",
+      "TenantSlugSchema",
+      "TenantListResponseSchema",
+      "TenantQuerySchema",
+      "TenantIdResponseSchema",
+      "type Tenant",
+      "type TenantStatus",
+      "type TenantPlan",
+      "type TenantSettings",
+      "type CreateTenantInput",
+      "type UpdateTenantInput",
+      "type TenantId",
+      "type TenantSlug",
+      "type TenantListResponse",
+      "type TenantQuery",
+      "type TenantIdResponse"
+    ]
+  },
+  dispute: {
+    namedExports: [
+      "DisputeTypeSchema",
+      "DisputeStatusSchema",
+      "DisputeSchema",
+      "CreateDisputeSchema",
+      "UpdateDisputeSchema",
+      "ResolveDisputeSchema",
+      "DisputeListSchema",
+      "DisputeDeleteResultSchema",
+      "type DisputeType",
+      "type DisputeStatus",
+      "type Dispute",
+      "type CreateDisputeInput",
+      "type UpdateDisputeInput",
+      "type ResolveDisputeInput",
+      "type DisputeDeleteResult"
+    ]
+  },
+  order: {
+    namedExports: [
+      "OrderStatusSchema",
+      "OrderSchema",
+      "CreateOrderSchema",
+      "UpdateOrderSchema",
+      "OrderListSchema",
+      "OrderQuerySchema",
+      "OrderDeleteResultSchema",
+      "ProcessOrderSchema",
+      "CancelOrderSchema",
+      "RemoveCartItemResponseSchema",
+      "ECommerceProductSchema",
+      "ECommerceOrderStatusSchema",
+      "ECommerceOrderSchema",
+      "ECommerceOrderListSchema",
+      "type OrderStatus",
+      "type Order",
+      "type CreateOrderInput",
+      "type UpdateOrderInput",
+      "type OrderDeleteResult",
+      "type ProcessOrderInput",
+      "type CancelOrderInput",
+      "type OrderQueryInput",
+      "type RemoveCartItemResponse",
+      "type ECommerceProduct",
+      "type ECommerceOrderStatus",
+      "type ECommerceOrder"
+    ]
+  },
+  permission: {
+    namedExports: [
+      "RoleEnum",
+      "PermissionEnum",
+      "RoleInfoSchema",
+      "PermissionInfoSchema",
+      "UserPermissionsSchema",
+      "MenuItemSchema",
+      "PageActionSchema",
+      "PagePermissionConfigSchema",
+      "PermissionCategorySchema",
+      "RoleListSchema",
+      "PermissionListSchema",
+      "MenuConfigSchema",
+      "PagePermissionsSchema",
+      "PermissionCategoriesSchema",
+      "RoleLabelsSchema",
+      "PermissionLabelsSchema",
+      "PermissionInitSchema",
+      "type PermissionRoleType",
+      "type PermissionType",
+      "type RoleInfo",
+      "type PermissionInfo",
+      "type UserPermissions",
+      "type MenuItem",
+      "type PageAction",
+      "type PagePermissionConfig",
+      "type PermissionCategory",
+      "type PermissionInit",
+      "Role",
+      "Permission",
+      "ROLE_PERMISSIONS",
+      "ROLE_LABELS",
+      "PERMISSION_LABELS",
+      "PERMISSION_CATEGORIES",
+      "getPermissionsByRole",
+      "hasPermission",
+      "hasAnyPermission",
+      "hasAllPermissions"
+    ]
+  },
+  role: {
+    namedExports: [
+      "RoleSchema",
+      "CreateRoleSchema",
+      "UpdateRoleSchema",
+      "UpdateRolePermissionsSchema",
+      "RoleSuccessSchema",
+      "type RoleDataType",
+      "type CreateRoleType",
+      "type UpdateRoleType"
+    ]
+  },
+  ticket: {
+    namedExports: [
+      "TicketStatusSchema",
+      "TicketPrioritySchema",
+      "TicketCategorySchema",
+      "TicketReplySchema",
+      "TicketSchema",
+      "CreateTicketSchema",
+      "UpdateTicketSchema",
+      "ReplyTicketSchema",
+      "TicketListSchema",
+      "TicketDeleteResultSchema",
+      "type TicketStatus",
+      "type TicketPriority",
+      "type TicketCategory",
+      "type TicketReply",
+      "type Ticket",
+      "type CreateTicketInput",
+      "type UpdateTicketInput",
+      "type ReplyTicketInput",
+      "type TicketDeleteResult"
+    ]
+  }
+};
+var ADDITIONAL_PATHS_MAP = {
+  permission: ["role", "audit"]
+};
+var STANDALONE_SHARED_MODULES = {
+  cart: { pages: ["CartPage.tsx"] },
+  community: { pages: ["TopicsPage.tsx", "ProfilePage.tsx"], serverModules: ["content"] },
+  dashboard: { pages: ["DashboardPage.tsx"] }
+};
+var moduleOrder = [
+  "chat",
+  "file",
+  "todos",
+  "notifications",
+  "auth",
+  "plugin",
+  "admin",
+  "audit",
+  "captcha",
+  "cart",
+  "community",
+  "content",
+  "dashboard",
+  "dispute",
+  "merchant",
+  "order",
+  "permission",
+  "role",
+  "tenant",
+  "ticket"
+];
+function generateSharedSchemasIndex(resolved) {
+  const header = `// Re-export interfaces from implementation files
+export type { WSClient, WSProtocol, WSStatus } from '../core/ws-client'
+export type { SSEClient, SSEProtocol } from '../core/sse-client'
+
+// Re-export core
+export {
+  ApiSuccessSchema,
+  ApiErrorSchema,
+  ApiResponseSchema,
+  type ApiSuccess,
+  type ApiError,
+  type ApiResponse,
+  type RpcMethod,
+  type EventName,
+  type RpcInput,
+  type RpcOutput,
+  type EventPayload,
+  createWSClient,
+  createSSEClient,
+} from '../core'
+
+// Re-export modules
+`;
+  const moduleLines = [];
+  const exportedNames = /* @__PURE__ */ new Set();
+  const firstSeenModule = /* @__PURE__ */ new Map();
+  const droppedExports = [];
+  for (const moduleName of moduleOrder) {
+    const exports = MODULE_EXPORTS2[moduleName];
+    if (!exports) continue;
+    const shouldInclude = shouldIncludeModule(moduleName, resolved);
+    if (!shouldInclude) continue;
+    const uniqueExports = exports.namedExports.filter((name) => {
+      if (exportedNames.has(name)) {
+        const originalModule = firstSeenModule.get(name) ?? "unknown";
+        droppedExports.push({ name, moduleName, originalModule });
+        return false;
+      }
+      exportedNames.add(name);
+      firstSeenModule.set(name, moduleName);
+      return true;
+    });
+    if (uniqueExports.length === 0) continue;
+    const importPath = getImportPath(moduleName, resolved);
+    moduleLines.push(
+      `export {
+  ${uniqueExports.join(",\n  ")},
+} from '../modules/${importPath}'`
+    );
+  }
+  for (const { name, moduleName, originalModule } of droppedExports) {
+    console.warn(
+      `\u26A0\uFE0F  Schema collision: "${name}" defined in both ${originalModule} and ${moduleName}. Using ${originalModule}'s version. Rename to avoid ambiguity.`
+    );
+  }
+  return header + moduleLines.join("\n") + "\n";
+}
+function shouldIncludeModule(moduleName, resolved) {
+  if (resolved.modules.has(moduleName)) return true;
+  const standalone = STANDALONE_SHARED_MODULES[moduleName];
+  if (standalone) {
+    const hasRelevantPage = standalone.pages && [...resolved.modules.values()].some(
+      (m) => m.clientPages?.some((p) => standalone.pages.includes(p.name + ".tsx")) ?? false
+    );
+    const hasRelevantServerModule = standalone.serverModules?.some((sm) => resolved.modules.has(sm)) ?? false;
+    return !!(hasRelevantPage || hasRelevantServerModule);
+  }
+  for (const [parentModule, additionalPaths] of Object.entries(ADDITIONAL_PATHS_MAP)) {
+    if (additionalPaths.includes(moduleName) && resolved.modules.has(parentModule)) {
+      return true;
+    }
+  }
+  return false;
+}
+function getImportPath(moduleName, resolved) {
+  const manifest = resolved.modules.get(moduleName);
+  if (manifest?.sharedSchemas?.path) {
+    return manifest.sharedSchemas.path;
+  }
+  return moduleName;
+}
+
+// src/generators/middleware-index.ts
+function generateMiddlewareIndex(resolved) {
+  const lines = [];
+  const hasAuthOrPermission = resolved.modules.has("auth") || resolved.hasPermission;
+  lines.push(`export { corsMiddleware, createCorsMiddleware, type CorsOptions } from './cors'`);
+  lines.push(
+    `export { loggerMiddleware, createLoggerMiddleware, type LoggerOptions } from './logger'`
+  );
+  lines.push(
+    `export {
+  errorHandlerMiddleware,
+  createErrorHandlerMiddleware,
+  type ErrorHandlerOptions,
+} from './error-handler'`
+  );
+  if (hasAuthOrPermission) {
+    lines.push(
+      `export {
+  authMiddleware,
+  requireSuperAdminMiddleware,
+  requireCustomerServiceMiddleware,
+  requirePermissionsMiddleware,
+  type AuthUser,
+  type AuthMiddlewareOptions,
+} from './auth'`
+    );
+  }
+  if (resolved.hasCaptcha) {
+    lines.push(
+      `export {
+  captchaMiddleware,
+  markCaptchaVerifiedMiddleware,
+  clearCaptchaSessionMiddleware,
+  type CaptchaConfig,
+} from './captcha'`
+    );
+  }
+  if (resolved.hasPermission) {
+    lines.push(`export { permissionMiddleware } from './permission'`);
+  }
+  lines.push(`export { rateLimitMiddleware, type RateLimitOptions } from './rate-limit'`);
+  if (hasAuthOrPermission) {
+    lines.push(`export { getAuthUser } from '../utils/auth'`);
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/generators/auth-middleware.ts
+function generateAuthMiddleware(resolved) {
+  if (resolved.modules.has("auth") && !resolved.hasPermission) {
+    return generateSimplifiedAuthMiddleware();
+  }
+  return generateNoopAuthMiddleware();
+}
+function generateSimplifiedAuthMiddleware() {
+  return `import type { MiddlewareHandler } from 'hono'
+import { createModuleLoggerSync } from '../utils/logger'
+
+export type UserRole = 'user' | 'admin'
+
+export interface AuthUser {
+  id: string
+  username: string
+  email: string
+  role: UserRole
+  avatar?: string
+}
+
+export interface AuthMiddlewareOptions {
+  requiredRole?: UserRole
+}
+
+declare module 'hono' {
+  interface ContextVariableMap {
+    authUser: AuthUser
+  }
+}
+
+function extractToken(authHeader: string | undefined): string | null {
+  if (!authHeader) return null
+  if (!authHeader.startsWith('Bearer ')) return null
+  return authHeader.slice(7)
+}
+
+export function authMiddleware(_options: AuthMiddlewareOptions = {}): MiddlewareHandler {
+  const log = createModuleLoggerSync('auth')
+
+  return async (c, next) => {
+    const token = extractToken(c.req.header('Authorization'))
+
+    if (!token) {
+      log.warn({ path: c.req.path, method: c.req.method }, 'Missing auth token')
+      return c.json({ success: false, error: 'Authentication required', status: 401 }, 401)
+    }
+
+    try {
+      const jwt = await import('jsonwebtoken')
+      const secretKey = process.env.AUTH_SECRET_KEY || 'dev-secret-key-change-in-production'
+      const decoded = jwt.verify(token, secretKey) as {
+        userId: string
+        username: string
+        email: string
+        role: string
+      }
+
+      const user: AuthUser = {
+        id: decoded.userId,
+        username: decoded.username,
+        email: decoded.email,
+        role: decoded.role as UserRole,
+      }
+
+      c.set('authUser', user)
+      log.info({ userId: user.id, path: c.req.path }, 'User authenticated')
+      await next()
+    } catch {
+      log.warn({ path: c.req.path, method: c.req.method }, 'Invalid auth token')
+      return c.json({ success: false, error: 'Invalid or expired token', status: 401 }, 401)
+    }
+  }
+}
+
+export function requireSuperAdminMiddleware(): MiddlewareHandler {
+  return authMiddleware()
+}
+
+export function requireCustomerServiceMiddleware(): MiddlewareHandler {
+  return authMiddleware()
+}
+
+export function requirePermissionsMiddleware(): MiddlewareHandler {
+  return authMiddleware()
+}
+`;
+}
+function generateNoopAuthMiddleware() {
+  return `import type { MiddlewareHandler } from 'hono'
+import { createModuleLoggerSync } from '../utils/logger'
+
+export type UserRole = 'user' | 'admin'
+
+export interface AuthUser {
+  id: string
+  username: string
+  email: string
+  role: UserRole
+  avatar?: string
+}
+
+export interface AuthMiddlewareOptions {
+  requiredRole?: UserRole
+}
+
+declare module 'hono' {
+  interface ContextVariableMap {
+    authUser: AuthUser
+  }
+}
+
+const DEV_USER: AuthUser = {
+  id: 'dev-user-1',
+  username: 'devuser',
+  email: 'dev@example.com',
+  role: 'admin',
+  avatar: 'https://api.dicebear.com/7.x/avataaars/svg?seed=dev',
+}
+
+function extractToken(authHeader: string | undefined): string | null {
+  if (!authHeader) return null
+  if (!authHeader.startsWith('Bearer ')) return null
+  return authHeader.slice(7)
+}
+
+export function authMiddleware(_options: AuthMiddlewareOptions = {}): MiddlewareHandler {
+  const log = createModuleLoggerSync('auth')
+
+  return async (c, next) => {
+    const token = extractToken(c.req.header('Authorization'))
+
+    if (!token) {
+      c.set('authUser', { ...DEV_USER, id: 'anonymous' })
+      log.info({ path: c.req.path }, 'Anonymous access')
+      await next()
+      return
+    }
+
+    c.set('authUser', DEV_USER)
+    log.info({ userId: DEV_USER.id, path: c.req.path }, 'Dev user authenticated')
+    await next()
+  }
+}
+
+export function requireSuperAdminMiddleware(): MiddlewareHandler {
+  return authMiddleware()
+}
+
+export function requireCustomerServiceMiddleware(): MiddlewareHandler {
+  return authMiddleware()
+}
+
+export function requirePermissionsMiddleware(): MiddlewareHandler {
+  return authMiddleware()
+}
+`;
+}
+
+// src/generators/auth-utils.ts
+function generateAuthUtils(resolved) {
+  const hasAuthOrPermission = resolved.modules.has("auth") || resolved.hasPermission;
+  if (!hasAuthOrPermission) {
+    return `import type { Context } from 'hono'
+import type { AuthUser } from '../middleware/auth'
+
+export function getAuthUser(c: Context): AuthUser {
+  return c.get('authUser')
+}
+`;
+  }
+  if (resolved.modules.has("auth") && !resolved.hasPermission) {
+    return `import type { Context } from 'hono'
+import type { AuthUser } from '../middleware/auth'
+
+export function getAuthUser(c: Context): AuthUser {
+  return c.get('authUser')
+}
+
+export function getOptionalAuthUser(c: Context): AuthUser | null {
+  try {
+    return c.get('authUser')
+  } catch {
+    return null
+  }
+}
+`;
+  }
+  return `import type { Context } from 'hono'
+import type { AuthUser } from '../middleware/auth'
+import { Role } from '@shared/modules/permission'
+
+interface MockUser {
+  id: string
+  username: string
+  email: string
+  role: string
+  status: string
+  avatar: string
+  createdAt: string
+  updatedAt: string
+}
+
+const mockUsers: MockUser[] = [
+  {
+    id: '1',
+    username: 'superadmin',
+    email: 'superadmin@example.com',
+    role: Role.SUPER_ADMIN,
+    status: 'active',
+    avatar: 'https://api.dicebear.com/7.x/avataaars/svg?seed=superadmin',
+    createdAt: '2024-01-01T00:00:00Z',
+    updatedAt: '2024-01-01T00:00:00Z',
+  },
+  {
+    id: '2',
+    username: 'customerservice',
+    email: 'customerservice@example.com',
+    role: Role.CUSTOMER_SERVICE,
+    status: 'active',
+    avatar: 'https://api.dicebear.com/7.x/avataaars/svg?seed=customerservice',
+    createdAt: '2024-01-02T00:00:00Z',
+    updatedAt: '2024-01-02T00:00:00Z',
+  },
+  {
+    id: '3',
+    username: 'user1',
+    email: 'user1@example.com',
+    role: Role.USER,
+    status: 'active',
+    avatar: 'https://api.dicebear.com/7.x/avataaars/svg?seed=user1',
+    createdAt: '2024-01-03T00:00:00Z',
+    updatedAt: '2024-01-03T00:00:00Z',
+  },
+]
+
+const mockTokens: Map<string, string> = new Map([
+  ['super-admin-token', '1'],
+  ['customer-service-token', '2'],
+  ['user-token', '3'],
+])
+
+export function getAuthUser(c: Context): AuthUser {
+  return c.get('authUser')
+}
+
+export function verifyToken(token: string): MockUser | null {
+  const userId = mockTokens.get(token)
+
+  if (!userId) {
+    return null
+  }
+
+  return mockUsers.find(u => u.id === userId) || null
+}
+
+export function getMockUsers(): MockUser[] {
+  return mockUsers
+}
+
+export function getMockTokens(): Map<string, string> {
+  return mockTokens
+}
+`;
+}
+
+// src/generators/client-components-index.ts
+function generateClientComponentsIndex(resolved) {
+  const lines = [];
+  lines.push(`export { StatusBadge, type ColorScheme } from './StatusBadge'`);
+  lines.push(`export { LoadingSpinner } from './LoadingSpinner'`);
+  lines.push(`export { EmptyState } from './EmptyState'`);
+  if (resolved.modules.has("chat") || resolved.modules.has("notifications")) {
+    lines.push(`export { ConnectionStatus } from './ConnectionStatus'`);
+  }
+  if (resolved.modules.has("chat")) {
+    lines.push(`export { MessageCard } from './MessageCard'`);
+  }
+  if (resolved.modules.has("admin") || resolved.modules.has("auth")) {
+    lines.push(`export { AuthButton } from './AuthButton'`);
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/generators/cli-modules-index.ts
+var ALWAYS_INCLUDED = {
+  dir: "config",
+  registerFunction: "registerConfigCommands"
+};
+function generateCliModulesIndex(resolved) {
+  const modules = [];
+  const registrations = [];
+  for (const [, manifest] of resolved.modules) {
+    if (manifest.cliModule) {
+      const { dir, registerFunction } = manifest.cliModule;
+      modules.push(`import { ${registerFunction} } from './${dir}'`);
+      registrations.push(`${registerFunction}(site)`);
+    }
+  }
+  modules.push(`import { ${ALWAYS_INCLUDED.registerFunction} } from './${ALWAYS_INCLUDED.dir}'`);
+  registrations.push(`${ALWAYS_INCLUDED.registerFunction}(site)`);
+  const exports = modules.map((m) => {
+    const match = m.match(/\{ (\w+) \}/);
+    return match ? match[1] : "";
+  }).filter(Boolean);
+  return `import type { Core } from '@dyyz1993/xcli-core'
+${modules.join("\n")}
+
+/**
+ * Register all builtin CLI commands to xcli-core.
+ * Each register function receives a SiteInstance for command registration.
+ */
+export function registerBuiltinCommands(app: Core) {
+  const api = app.loader.getAPI()
+
+  const site = api.createSite({
+    name: 'local-server',
+    url: 'http://localhost:3010',
+  })
+
+${registrations.map((r) => `  ${r}`).join("\n")}
+}
+
+export { ${exports.join(", ")} }
+`;
+}
+
+// src/generators/package-json.ts
+var MODULE_PACKAGES = {
+  admin: ["bcryptjs"],
+  auth: ["bcryptjs"]
+};
+var ADMIN_PANEL_PACKAGES = ["antd"];
+var CLI_PACKAGES = ["commander"];
+var UNUSED_PACKAGES = ["lodash-es", "chalk", "mysql2"];
+var CLIENT_PACKAGES = [
+  "react",
+  "react-dom",
+  "react-helmet-async",
+  "react-router-dom",
+  "lucide-react",
+  "zustand"
+];
+var CLIENT_DEV_PACKAGES = [
+  "@vitejs/plugin-react",
+  "@testing-library/react",
+  "@testing-library/jest-dom",
+  "@testing-library/dom",
+  "vite",
+  "jsdom",
+  "tailwindcss",
+  "@tailwindcss/postcss",
+  "postcss",
+  "autoprefixer",
+  "@playwright/test",
+  "playwright",
+  "@prerenderer/renderer-jsdom",
+  "@prerenderer/renderer-puppeteer",
+  "@prerenderer/rollup-plugin",
+  "eventsource"
+];
+var CLIENT_TYPE_PACKAGES = ["@types/react", "@types/react-dom"];
+function filterPackageJson(pkg, resolved) {
+  const result = { ...pkg };
+  const packagesToRemove = new Set(UNUSED_PACKAGES);
+  const packageToModules = {};
+  for (const [module, packages] of Object.entries(MODULE_PACKAGES)) {
+    for (const pkg2 of packages) {
+      if (!packageToModules[pkg2]) packageToModules[pkg2] = [];
+      packageToModules[pkg2].push(module);
+    }
+  }
+  for (const [pkg2, modules] of Object.entries(packageToModules)) {
+    if (!modules.some((m) => resolved.modules.has(m))) {
+      packagesToRemove.add(pkg2);
+    }
+  }
+  const hasAntdConsumer = resolved.modules.has("admin") || resolved.modules.has("tenant") || resolved.modules.has("merchant");
+  if (!hasAntdConsumer) {
+    for (const pkg2 of ADMIN_PANEL_PACKAGES) {
+      packagesToRemove.add(pkg2);
+    }
+  }
+  for (const pkg2 of CLI_PACKAGES) {
+    packagesToRemove.add(pkg2);
+  }
+  if (!resolved.hasClient) {
+    for (const pkg2 of CLIENT_PACKAGES) {
+      packagesToRemove.add(pkg2);
+    }
+  }
+  if (result.dependencies && typeof result.dependencies === "object") {
+    const deps = { ...result.dependencies };
+    for (const pkg2 of packagesToRemove) {
+      delete deps[pkg2];
+    }
+    result.dependencies = deps;
+  }
+  if (result.devDependencies && typeof result.devDependencies === "object") {
+    const devDeps = { ...result.devDependencies };
+    if (!resolved.modules.has("admin")) {
+      delete devDeps["@testing-library/user-event"];
+    }
+    if (!resolved.hasClient) {
+      for (const pkg2 of CLIENT_DEV_PACKAGES) {
+        delete devDeps[pkg2];
+      }
+      for (const pkg2 of CLIENT_TYPE_PACKAGES) {
+        delete devDeps[pkg2];
+      }
+    }
+    result.devDependencies = devDeps;
+  }
+  if (!resolved.hasClient && result.scripts && typeof result.scripts === "object") {
+    const scripts = { ...result.scripts };
+    scripts["dev"] = "NODE_ENV=development node --import tsx src/server/entries/node.ts";
+    scripts["build"] = "npm run build:server && npm run build:cli";
+    scripts["build:all"] = "npm run build:server && npm run build:cli";
+    delete scripts["build:client"];
+    delete scripts["build:cloudflare"];
+    delete scripts["preview"];
+    delete scripts["dev:todo"];
+    delete scripts["dev:plugin"];
+    delete scripts["dev:ecommerce"];
+    delete scripts["dev:community"];
+    delete scripts["dev:forum"];
+    delete scripts["dev:saas"];
+    delete scripts["dev:cf"];
+    delete scripts["deploy:cf"];
+    delete scripts["test:e2e"];
+    delete scripts["test:e2e:ui"];
+    delete scripts["test:e2e:debug"];
+    delete scripts["test:full"];
+    result.scripts = scripts;
+  }
+  return result;
+}
+function generateViteConfig(resolved, templateDir) {
+  const originalPath = join(templateDir, "vite.config.ts");
+  let content = readFileSync(originalPath, "utf-8");
+  const entriesToRemove = [];
+  const aliasesToRemove = [];
+  if (!resolved.modules.has("admin")) {
+    entriesToRemove.push("admin");
+    aliasesToRemove.push("@admin");
+  }
+  if (!resolved.modules.has("tenant")) {
+    entriesToRemove.push("tenant");
+    aliasesToRemove.push("@tenant");
+  }
+  if (!resolved.modules.has("merchant")) {
+    entriesToRemove.push("merchant");
+    aliasesToRemove.push("@merchant");
+  }
+  for (const name of entriesToRemove) {
+    const re = new RegExp(
+      `^\\s*${name}:\\s*path\\.resolve\\(__dirname,\\s*['"]${name}\\.html['"]\\),\\s*$\\n?`,
+      "gm"
+    );
+    content = content.replace(re, "");
+  }
+  for (const alias of aliasesToRemove) {
+    const escapedAlias = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const dirName = alias.replace("@", "");
+    const re = new RegExp(
+      `^\\s*'${escapedAlias}':\\s*path\\.resolve\\(__dirname,\\s*['"]src\\/${dirName}['"]\\),\\s*$\\n?`,
+      "gm"
+    );
+    content = content.replace(re, "");
+  }
+  return content;
+}
+
+// src/generators/client-preset-ui-config.ts
+function getPresetType(presetId) {
+  const map = {
+    "todo-app": "todo",
+    "xbrowser-marketplace": "plugin",
+    ecommerce: "ecommerce",
+    "fullstack-admin": "saas",
+    forum: "community",
+    minimal: "todo"
+  };
+  return map[presetId] || "todo";
+}
+function getThemeForPresetType(presetType) {
+  const themes = {
+    todo: {
+      constName: "TODO_THEME",
+      theme: `{
+  primaryColor: '#6366f1',
+  primaryHover: '#4f46e5',
+  bgColor: '#ffffff',
+  textColor: '#111827',
+  secondaryBg: '#f9fafb',
+  borderColor: '#e5e7eb',
+  borderRadius: '12px',
+  logoText: 'Biomimic',
+  fontFamily: "-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif",
+}`
+    },
+    plugin: {
+      constName: "PLUGIN_MARKET_THEME",
+      theme: `{
+  primaryColor: '#3b82f6',
+  primaryHover: '#2563eb',
+  bgColor: '#ffffff',
+  textColor: '#111827',
+  secondaryBg: '#f0f9ff',
+  borderColor: '#bae6fd',
+  borderRadius: '12px',
+  logoText: 'PluginHub',
+  fontFamily: "-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif",
+}`
+    },
+    ecommerce: {
+      constName: "ECOMMERCE_THEME",
+      theme: `{
+  primaryColor: '#f59e0b',
+  primaryHover: '#d97706',
+  bgColor: '#ffffff',
+  textColor: '#111827',
+  secondaryBg: '#fffbeb',
+  borderColor: '#fde68a',
+  borderRadius: '12px',
+  logoText: 'ShopMart',
+  fontFamily: "-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif",
+}`
+    },
+    saas: {
+      constName: "SAAS_ADMIN_THEME",
+      theme: `{
+  primaryColor: '#1f2937',
+  primaryHover: '#374151',
+  bgColor: '#f9fafb',
+  textColor: '#111827',
+  secondaryBg: '#f3f4f6',
+  borderColor: '#e5e7eb',
+  borderRadius: '8px',
+  logoText: 'AdminPanel',
+  fontFamily: "-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif",
+}`
+    },
+    community: {
+      constName: "COMMUNITY_THEME",
+      theme: `{
+  primaryColor: '#f97316',
+  primaryHover: '#ea580c',
+  bgColor: '#ffffff',
+  textColor: '#111827',
+  secondaryBg: '#fff7ed',
+  borderColor: '#fed7aa',
+  borderRadius: '12px',
+  logoText: 'CommunityHub',
+  fontFamily: "-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif",
+}`
+    }
+  };
+  return themes[presetType] || themes.todo;
+}
+function getRoutesForPreset(presetType, resolved) {
+  const hasModule = (m) => resolved.modules.has(m);
+  const loginRoute = {
+    path: "/login",
+    importPath: "./pages/LoginPage",
+    componentName: "LoginPage",
+    label: "Login"
+  };
+  const registerRoute = {
+    path: "/register",
+    importPath: "./pages/RegisterPage",
+    componentName: "RegisterPage",
+    label: "Register"
+  };
+  const maybeAuthRoutes = hasModule("auth") ? [
+    loginRoute,
+    registerRoute,
+    {
+      path: "/profile",
+      importPath: "./pages/ProfilePage",
+      componentName: "ProfilePage",
+      label: "Profile"
+    }
+  ] : [];
+  switch (presetType) {
+    case "todo": {
+      const routes = [
+        ...maybeAuthRoutes,
+        {
+          path: "/todos",
+          importPath: "./pages/TodoPage",
+          componentName: "TodoPage",
+          label: "Todos"
+        }
+      ];
+      if (hasModule("notifications")) {
+        routes.push({
+          path: "/notifications",
+          importPath: "./pages/NotificationPage",
+          componentName: "NotificationPage",
+          label: "Notifications"
+        });
+      }
+      if (hasModule("chat")) {
+        routes.push({
+          path: "/websocket",
+          importPath: "./pages/WebSocketPage",
+          componentName: "WebSocketPage",
+          label: "WebSocket"
+        });
+      }
+      return routes;
+    }
+    case "plugin": {
+      const routes = [];
+      if (hasModule("plugin")) {
+        routes.push(
+          {
+            path: "/",
+            importPath: "./pages/PluginsPage",
+            componentName: "PluginsPage",
+            label: "Home"
+          },
+          {
+            path: "/plugins",
+            importPath: "./pages/PluginsPage",
+            componentName: "PluginsPage",
+            label: "Plugins"
+          },
+          {
+            path: "/plugins/:slug",
+            importPath: "./pages/PluginDetailPage",
+            componentName: "PluginDetailPage",
+            label: "Plugin Detail"
+          },
+          {
+            path: "/categories",
+            importPath: "./pages/CategoriesPage",
+            componentName: "CategoriesPage",
+            label: "Categories"
+          },
+          {
+            path: "/search",
+            importPath: "./pages/SearchPage",
+            componentName: "SearchPage",
+            label: "Search"
+          },
+          {
+            path: "/publish",
+            importPath: "./pages/PublishPage",
+            componentName: "PublishPage",
+            label: "Publish"
+          },
+          {
+            path: "/developer",
+            importPath: "./pages/DeveloperDashboardPage",
+            componentName: "DeveloperDashboardPage",
+            label: "Developer"
+          }
+        );
+      }
+      routes.push(...maybeAuthRoutes);
+      if (hasModule("notifications")) {
+        routes.push({
+          path: "/notifications",
+          importPath: "./pages/NotificationPage",
+          componentName: "NotificationPage",
+          label: "Notifications"
+        });
+      }
+      return routes;
+    }
+    case "ecommerce": {
+      const routes = [];
+      if (hasModule("content")) {
+        routes.push(
+          {
+            path: "/",
+            importPath: "./pages/ContentListPage",
+            componentName: "ContentListPage",
+            label: "Home"
+          },
+          {
+            path: "/products",
+            importPath: "./pages/ContentListPage",
+            componentName: "ContentListPage",
+            label: "Products"
+          },
+          {
+            path: "/products/:id",
+            importPath: "./pages/ContentDetailPage",
+            componentName: "ContentDetailPage",
+            label: "Product Detail"
+          },
+          {
+            path: "/content",
+            importPath: "./pages/ContentListPage",
+            componentName: "ContentListPage",
+            label: "Content"
+          },
+          {
+            path: "/content/:id",
+            importPath: "./pages/ContentDetailPage",
+            componentName: "ContentDetailPage",
+            label: "Content Detail"
+          }
+        );
+      }
+      if (hasModule("order")) {
+        routes.push(
+          {
+            path: "/cart",
+            importPath: "./pages/CartPage",
+            componentName: "CartPage",
+            label: "Cart"
+          },
+          {
+            path: "/orders",
+            importPath: "./pages/OrdersPage",
+            componentName: "OrdersPage",
+            label: "Orders"
+          }
+        );
+      }
+      routes.push(...maybeAuthRoutes);
+      return routes;
+    }
+    case "saas": {
+      const routes = [];
+      if (hasModule("admin")) {
+        routes.push(
+          {
+            path: "/dashboard",
+            importPath: "./pages/DashboardPage",
+            componentName: "DashboardPage",
+            label: "Dashboard"
+          },
+          {
+            path: "/settings",
+            importPath: "./pages/SettingsPage",
+            componentName: "SettingsPage",
+            label: "Settings"
+          }
+        );
+      }
+      routes.push(...maybeAuthRoutes);
+      return routes;
+    }
+    case "community": {
+      const routes = [];
+      if (hasModule("content")) {
+        routes.push(
+          {
+            path: "/",
+            importPath: "./pages/ContentListPage",
+            componentName: "ContentListPage",
+            label: "Home"
+          },
+          {
+            path: "/topics",
+            importPath: "./pages/ContentListPage",
+            componentName: "ContentListPage",
+            label: "Topics"
+          },
+          {
+            path: "/topics/:id",
+            importPath: "./pages/ContentDetailPage",
+            componentName: "ContentDetailPage",
+            label: "Topic Detail"
+          },
+          {
+            path: "/popular",
+            importPath: "./pages/ContentListPage",
+            componentName: "ContentListPage",
+            label: "Popular"
+          },
+          {
+            path: "/content",
+            importPath: "./pages/ContentListPage",
+            componentName: "ContentListPage",
+            label: "Content"
+          },
+          {
+            path: "/content/:id",
+            importPath: "./pages/ContentDetailPage",
+            componentName: "ContentDetailPage",
+            label: "Content Detail"
+          }
+        );
+      }
+      if (hasModule("chat")) {
+        routes.push({
+          path: "/websocket",
+          importPath: "./pages/WebSocketPage",
+          componentName: "WebSocketPage",
+          label: "WebSocket"
+        });
+      }
+      if (hasModule("notifications")) {
+        routes.push({
+          path: "/notifications",
+          importPath: "./pages/NotificationPage",
+          componentName: "NotificationPage",
+          label: "Notifications"
+        });
+      }
+      routes.push(...maybeAuthRoutes);
+      return routes;
+    }
+    default:
+      return [...maybeAuthRoutes];
+  }
+}
+function getNavConfigForPreset(presetType, hasAuth) {
+  switch (presetType) {
+    case "todo":
+      return {
+        name: "Todo App",
+        appType: "client",
+        layout: "top-nav",
+        navigationObj: hasAuth ? "{ visible: true, showLogo: true, showSearch: false, showCart: false, authStyle: 'buttons', navItems: 'desktop' }" : "{ visible: true, showLogo: true, showSearch: false, showCart: false, authStyle: 'none', navItems: 'desktop' }",
+        desktopNav: [
+          "{ label: 'Todos', icon: 'CheckSquare', path: '/todos' }",
+          "{ label: 'SSE Demo', icon: 'Bell', path: '/notifications' }",
+          "{ label: 'WebSocket', icon: 'Zap', path: '/websocket' }"
+        ],
+        mobileTabs: [
+          "{ label: 'Todos', icon: 'CheckSquare', path: '/todos' }",
+          "{ label: 'SSE', icon: 'Bell', path: '/notifications' }",
+          "{ label: 'WS', icon: 'Zap', path: '/websocket' }"
+        ],
+        defaultRoute: "/todos"
+      };
+    case "plugin":
+      return {
+        name: "Plugin Market",
+        appType: "client",
+        layout: "top-nav",
+        navigationObj: "{ visible: true, showLogo: true, showSearch: true, showCart: false, authStyle: 'text-link', navItems: 'desktop' }",
+        desktopNav: [
+          "{ label: 'Discover', icon: 'Compass', path: '/plugins' }",
+          "{ label: 'Plugins', icon: 'Puzzle', path: '/plugins/list' }",
+          "{ label: 'Categories', icon: 'Tags', path: '/categories' }",
+          "{ label: 'Search', icon: 'Search', path: '/search' }",
+          "{ label: 'Publish', icon: 'PlusCircle', path: '/publish' }",
+          "{ label: 'Developer', icon: 'Code', path: '/developer' }"
+        ],
+        mobileTabs: [
+          "{ label: 'Discover', icon: 'Compass', path: '/plugins' }",
+          "{ label: 'Plugins', icon: 'Puzzle', path: '/plugins/list' }",
+          "{ label: 'Categories', icon: 'Tags', path: '/categories' }",
+          "{ label: 'Search', icon: 'Search', path: '/search' }",
+          "{ label: 'My', icon: 'User', path: '/developer' }"
+        ],
+        defaultRoute: "/plugins"
+      };
+    case "ecommerce":
+      return {
+        name: "E-Commerce",
+        appType: "client",
+        layout: "top-nav",
+        navigationObj: "{ visible: true, showLogo: true, showSearch: true, showCart: true, authStyle: 'icon', navItems: 'desktop' }",
+        desktopNav: [
+          "{ label: 'Home', icon: 'Home', path: '/' }",
+          "{ label: 'Products', icon: 'ShoppingBag', path: '/products' }",
+          "{ label: 'Cart', icon: 'ShoppingCart', path: '/cart' }",
+          "{ label: 'Orders', icon: 'Package', path: '/orders' }",
+          "{ label: 'Account', icon: 'User', path: '/content' }"
+        ],
+        mobileTabs: [
+          "{ label: 'Home', icon: 'Home', path: '/' }",
+          "{ label: 'Products', icon: 'ShoppingBag', path: '/products' }",
+          "{ label: 'Cart', icon: 'ShoppingCart', path: '/cart' }",
+          "{ label: 'Orders', icon: 'Package', path: '/orders' }",
+          "{ label: 'Me', icon: 'User', path: '/content' }"
+        ],
+        defaultRoute: "/"
+      };
+    case "saas":
+      return {
+        name: "SaaS Admin",
+        appType: "admin",
+        layout: "minimal",
+        navigationObj: "{ visible: false, showLogo: false, showSearch: false, showCart: false, authStyle: 'none', navItems: 'none' }",
+        desktopNav: [
+          "{ label: 'Dashboard', icon: 'LayoutDashboard', path: '/dashboard' }",
+          "{ label: 'Settings', icon: 'Settings', path: '/settings' }"
+        ],
+        mobileTabs: [
+          "{ label: 'Dashboard', icon: 'LayoutDashboard', path: '/dashboard' }",
+          "{ label: 'Settings', icon: 'Settings', path: '/settings' }"
+        ],
+        defaultRoute: "/dashboard"
+      };
+    case "community":
+      return {
+        name: "Community Forum",
+        appType: "client",
+        layout: "top-nav",
+        navigationObj: "{ visible: true, showLogo: true, showSearch: true, showCart: false, authStyle: 'text-link', navItems: 'desktop' }",
+        desktopNav: [
+          "{ label: 'Home', icon: 'Home', path: '/' }",
+          "{ label: 'Topics', icon: 'MessageSquare', path: '/topics' }",
+          "{ label: 'Popular', icon: 'Flame', path: '/popular' }",
+          "{ label: 'Profile', icon: 'User', path: '/profile' }",
+          "{ label: 'Chat', icon: 'MessageCircle', path: '/websocket' }"
+        ],
+        mobileTabs: [
+          "{ label: 'Home', icon: 'Home', path: '/' }",
+          "{ label: 'Topics', icon: 'MessageSquare', path: '/topics' }",
+          "{ label: 'Popular', icon: 'Flame', path: '/popular' }",
+          "{ label: 'Profile', icon: 'User', path: '/profile' }",
+          "{ label: 'Chat', icon: 'MessageCircle', path: '/websocket' }"
+        ],
+        defaultRoute: "/"
+      };
+    default:
+      return {
+        name: "App",
+        appType: "client",
+        layout: "top-nav",
+        navigationObj: "{ visible: true, showLogo: true, showSearch: false, showCart: false, authStyle: 'none', navItems: 'desktop' }",
+        desktopNav: ["{ label: 'Home', icon: 'Home', path: '/' }"],
+        mobileTabs: ["{ label: 'Home', icon: 'Home', path: '/' }"],
+        defaultRoute: "/"
+      };
+  }
+}
+function filterNavByModules(navItems, resolved) {
+  const hasModule = (path3) => {
+    if (path3 === "/todos") return resolved.modules.has("todos");
+    if (path3 === "/notifications") return resolved.modules.has("notifications");
+    if (path3 === "/websocket") return resolved.modules.has("chat");
+    if (path3.startsWith("/plugins") || path3 === "/categories" || path3 === "/search" || path3 === "/publish" || path3 === "/developer")
+      return resolved.modules.has("plugin");
+    if (path3 === "/cart" || path3 === "/orders") return resolved.modules.has("order");
+    if (path3.startsWith("/content") || path3 === "/products" || path3 === "/")
+      return resolved.modules.has("content");
+    if (path3 === "/topics" || path3 === "/popular" || path3 === "/profile")
+      return resolved.modules.has("content");
+    if (path3 === "/dashboard" || path3 === "/settings") return resolved.modules.has("admin");
+    return true;
+  };
+  return navItems.filter((item) => {
+    const pathMatch = item.match(/path:\s*'([^']+)'/);
+    if (!pathMatch) return true;
+    return hasModule(pathMatch[1]);
+  });
+}
+function generatePresetUIConfig(resolved, presetId) {
+  const presetType = getPresetType(presetId);
+  const { constName, theme } = getThemeForPresetType(presetType);
+  const hasAuth = resolved.modules.has("auth");
+  const navConfig = getNavConfigForPreset(presetType, hasAuth);
+  const routes = getRoutesForPreset(presetType, resolved);
+  const aliases = {};
+  if (presetId !== presetType) {
+    aliases[presetId] = presetType;
+  }
+  const allAliases = {
+    "todo-app": "todo",
+    "xbrowser-marketplace": "plugin",
+    ecommerce: "ecommerce",
+    "fullstack-admin": "saas",
+    forum: "community",
+    minimal: "todo",
+    saas: "saas"
+  };
+  for (const [alias, type] of Object.entries(allAliases)) {
+    if (type === presetType && alias !== presetType) {
+      aliases[alias] = presetType;
+    }
+  }
+  const desktopNav = filterNavByModules(navConfig.desktopNav, resolved);
+  const mobileTabs = filterNavByModules(navConfig.mobileTabs, resolved);
+  const routeDefs = routes.map((r) => {
+    return `  {
+    path: '${r.path}',
+    component: lazy(() => import('${r.importPath}').then(m => ({ default: m.${r.componentName} }))),
+    label: '${r.label}',
+  }`;
+  });
+  return `import { lazy, type ComponentType } from 'react'
+
+export type PresetType = '${presetType}'
+
+export type AppType = 'client' | 'admin'
+export type LayoutType = 'top-nav' | 'minimal'
+export type AuthStyle = 'buttons' | 'text-link' | 'icon' | 'avatar' | 'none'
+
+// ClientNavItem is intentionally simpler than admin MenuItem (no permissions/children needed for client nav)
+// eslint-disable-next-line local-rules/prefer-shared-types
+export interface ClientNavItem {
+  label: string
+  icon: string
+  path: string
+}
+
+export type TabItem = ClientNavItem
+
+export interface NavigationConfig {
+  visible: boolean
+  showLogo: boolean
+  showSearch: boolean
+  showCart: boolean
+  authStyle: AuthStyle
+  navItems: 'desktop' | 'none'
+}
+
+export interface PresetTheme {
+  primaryColor: string
+  primaryHover: string
+  bgColor: string
+  textColor: string
+  secondaryBg: string
+  borderColor: string
+  borderRadius: string
+  logoText: string
+  fontFamily: string
+}
+
+export interface RouteDef {
+  path: string
+  component: ComponentType<Record<string, unknown>> | null
+  label: string
+}
+
+export interface PresetUIConfig {
+  id: PresetType
+  name: string
+  appType: AppType
+  layout: LayoutType
+  theme: PresetTheme
+  navigation: NavigationConfig
+  desktopNav: ClientNavItem[]
+  mobileTabs: ClientNavItem[]
+  routes: RouteDef[]
+  defaultRoute: string
+}
+
+const ${constName}: PresetTheme = ${theme}
+
+// Preset ID aliases: allows dev:xxx scripts and VITE_PRESET to use config IDs
+const PRESET_ALIASES: Record<string, '${presetType}'> = {
+${Object.entries(aliases).map(([k, v]) => `  '${k}': '${v}',`).join("\n")}
+}
+
+export const PRESET_UI_CONFIGS: Record<PresetType, PresetUIConfig> = {
+  ${presetType}: {
+    id: '${presetType}',
+    name: '${navConfig.name}',
+    appType: '${navConfig.appType}',
+    layout: '${navConfig.layout}',
+    theme: ${constName},
+    navigation: ${navConfig.navigationObj},
+    desktopNav: [
+${desktopNav.map((i) => `      ${i}`).join(",\n")}
+    ],
+    mobileTabs: [
+${mobileTabs.map((i) => `      ${i}`).join(",\n")}
+    ],
+    defaultRoute: '${navConfig.defaultRoute}',
+    routes: [
+${routeDefs.join(",\n")}
+    ],
+  },
+}
+
+export function getPresetUIConfig(id: string): PresetUIConfig {
+  const resolvedId = PRESET_ALIASES[id] ?? (id as PresetType)
+  return PRESET_UI_CONFIGS[resolvedId] ?? PRESET_UI_CONFIGS['${presetType}']
+}
+
+export function getPresetUIConfigs(): Record<PresetType, PresetUIConfig> {
+  return PRESET_UI_CONFIGS
+}
+`;
+}
+
+// src/generators/client-main.ts
+function getPresetType2(presetId) {
+  const map = {
+    "todo-app": "todo",
+    "xbrowser-marketplace": "plugin",
+    ecommerce: "ecommerce",
+    "fullstack-admin": "saas",
+    forum: "community",
+    minimal: "todo"
+  };
+  return map[presetId] || "todo";
+}
+function generateClientMain(resolved, presetId) {
+  const presetType = getPresetType2(presetId);
+  const isSaas = presetType === "saas";
+  const authTokenBlock = isSaas ? "" : `
+if (preset !== 'saas') {
+  try {
+    const raw = localStorage.getItem('auth-token')
+    const parsed = raw ? JSON.parse(raw) : null
+    if (!parsed?.state?.token) {
+      localStorage.setItem('auth-token', JSON.stringify({
+        state: {
+          token: 'user-token',
+          isAuthenticated: true,
+          user: { id: 'user-1', username: 'Demo User', role: 'USER' },
+          loading: false,
+          error: null,
+        },
+        version: 0,
+      }))
+    }
+  } catch {
+    localStorage.setItem('auth-token', JSON.stringify({
+      state: { token: 'user-token', isAuthenticated: true, user: { id: 'user-1', username: 'Demo User', role: 'USER' }, loading: false, error: null },
+      version: 0,
+    }))
+  }
+}
+`;
+  if (isSaas) {
+    return `import React from 'react'
+import ReactDOM from 'react-dom/client'
+import './index.css'
+
+const AdminApp = React.lazy(() => import('@admin/App').then(m => ({ default: m.App })))
+
+const RootApp = () => {
+  return (
+    <React.Suspense fallback={<div className="flex items-center justify-center h-screen text-gray-400">Loading...</div>}>
+      <AdminApp basePath="/" />
+    </React.Suspense>
+  )
+}
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <RootApp />
+  </React.StrictMode>,
+)
+
+if (typeof window !== 'undefined') {
+  requestAnimationFrame(() => {
+    setTimeout(() => {
+      document.dispatchEvent(new CustomEvent('prerender-ready'))
+    }, 100)
+  })
+}
+`;
+  }
+  return `import React from 'react'
+import ReactDOM from 'react-dom/client'
+import { HelmetProvider } from 'react-helmet-async'
+import { App as ClientApp } from './App'
+import './index.css'
+
+const preset = import.meta.env.VITE_PRESET || '${presetType}'
+${authTokenBlock}
+const RootApp = () => {
+  return (
+    <HelmetProvider>
+      <ClientApp presetId={preset} />
+    </HelmetProvider>
+  )
+}
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <RootApp />
+  </React.StrictMode>,
+)
+
+if (typeof window !== 'undefined') {
+  requestAnimationFrame(() => {
+    setTimeout(() => {
+      document.dispatchEvent(new CustomEvent('prerender-ready'))
+    }, 100)
+  })
+}
+`;
+}
+
+// src/commands/create.ts
+var __filename$1 = fileURLToPath(import.meta.url);
+var __dirname$1 = path.dirname(__filename$1);
+var TEMPLATE_PROJECT_NAME = "biomimic-todo-app";
+var TEMPLATE_DB_NAME = "biomimic-todo-db";
+var ScaffoldError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ScaffoldError";
+  }
+};
+function validateProjectName(name) {
+  if (!name || name.trim().length === 0) {
+    throw new ScaffoldError("Project name cannot be empty");
+  }
+  const validNameRegex = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+  if (!validNameRegex.test(name)) {
+    throw new ScaffoldError(
+      `Invalid project name "${name}". Use lowercase letters, numbers, hyphens, and underscores only.`
+    );
+  }
+  if (name.length > 214) {
+    throw new ScaffoldError("Project name must be 214 characters or less");
+  }
+  if (name.includes("..") || name.includes("/") || name.includes("\\")) {
+    throw new ScaffoldError("Project name cannot contain path separators");
+  }
+}
+function parseGitignore(content) {
+  const negatePatterns = [];
+  const includePatterns = content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map((line) => {
+    if (line.startsWith("!")) {
+      negatePatterns.push(line.slice(1));
+      return null;
+    }
+    return line;
+  }).filter((line) => line !== null).map((pattern) => pattern.replace(/\/$/, "")).map((pattern) => pattern.replace(/^\*\./, "")).map((pattern) => pattern.replace(/^\/+/, "")).filter((pattern) => !pattern.includes("*"));
+  return [...includePatterns, ...negatePatterns.map((p) => `!${p}`)];
+}
+function generateDbName(projectName) {
+  const sanitized = projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return `${sanitized}-db`;
+}
+async function updateWranglerToml(targetDir, projectName) {
+  const wranglerPath = path.join(targetDir, "wrangler.toml");
+  if (!await fs.pathExists(wranglerPath)) {
+    return;
+  }
+  let content = await fs.readFile(wranglerPath, "utf-8");
+  const dbName = generateDbName(projectName);
+  content = content.replace(
+    new RegExp(`^name = "${TEMPLATE_PROJECT_NAME}"`, "m"),
+    `name = "${projectName}"`
+  );
+  content = content.replace(
+    new RegExp(`database_name = "${TEMPLATE_DB_NAME}"`, "g"),
+    `database_name = "${dbName}"`
+  );
+  content = content.replace(
+    /database_id = "[^"]+"/,
+    `database_id = ""  # TODO: Run 'wrangler d1 create ${dbName}' and paste the ID here`
+  );
+  await fs.writeFile(wranglerPath, content);
+}
+async function updatePackageJson(targetDir, projectName, resolved) {
+  const pkgJsonPath = path.join(targetDir, "package.json");
+  if (!await fs.pathExists(pkgJsonPath)) {
+    return;
+  }
+  let pkgJson = await fs.readJson(pkgJsonPath);
+  pkgJson = filterPackageJson(pkgJson, resolved);
+  pkgJson.name = projectName;
+  if (pkgJson.bin) {
+    delete pkgJson.bin;
+  }
+  await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
+}
+async function updatePackageLockJson(targetDir, projectName) {
+  const lockFilePath = path.join(targetDir, "package-lock.json");
+  if (!await fs.pathExists(lockFilePath)) {
+    return;
+  }
+  const lockFile = await fs.readJson(lockFilePath);
+  if (lockFile.name === TEMPLATE_PROJECT_NAME) {
+    lockFile.name = projectName;
+  }
+  if (lockFile.packages?.[""]?.name === TEMPLATE_PROJECT_NAME) {
+    lockFile.packages[""].name = projectName;
+  }
+  await fs.writeJson(lockFilePath, lockFile, { spaces: 2 });
+}
+async function updateReadme(targetDir, projectName) {
+  const readmePath = path.join(targetDir, "README.md");
+  if (!await fs.pathExists(readmePath)) {
+    return;
+  }
+  let content = await fs.readFile(readmePath, "utf-8");
+  content = content.replace(/^# (.+)$/m, `# ${projectName}`);
+  await fs.writeFile(readmePath, content);
+}
+async function createProject(projectNameOrOptions, useCurrentDir = false, preset) {
+  let projectName;
+  let currentDir;
+  let presetId;
+  let outputDir;
+  let dryRun;
+  let install;
+  if (typeof projectNameOrOptions === "string") {
+    projectName = projectNameOrOptions;
+    currentDir = useCurrentDir;
+    presetId = preset;
+    dryRun = false;
+    install = true;
+  } else {
+    projectName = projectNameOrOptions.projectName;
+    currentDir = projectNameOrOptions.currentDir;
+    presetId = projectNameOrOptions.preset;
+    outputDir = projectNameOrOptions.outputDir;
+    dryRun = projectNameOrOptions.dryRun ?? false;
+    install = projectNameOrOptions.install ?? true;
+  }
+  if (!currentDir) {
+    validateProjectName(projectName);
+  }
+  const templateDir = path.join(__dirname$1, "../../template");
+  let targetDir;
+  if (currentDir) {
+    targetDir = process.cwd();
+    projectName = path.basename(targetDir);
+  } else if (outputDir) {
+    targetDir = path.resolve(outputDir);
+    if (await fs.pathExists(targetDir)) {
+      throw new ScaffoldError(`Directory ${outputDir} already exists`);
+    }
+  } else {
+    targetDir = path.resolve(process.cwd(), projectName);
+    if (await fs.pathExists(targetDir)) {
+      throw new ScaffoldError(`Directory ${projectName} already exists`);
+    }
+  }
+  try {
+    const manifestSpinner = ora("Loading module manifests...").start();
+    const allManifests = await loadManifests(templateDir);
+    const presets = await loadPresets(templateDir);
+    const selectedPresetId = presetId || "fullstack-admin";
+    const selectedPreset = presets.find((p) => p.id === selectedPresetId);
+    if (!selectedPreset) {
+      throw new ScaffoldError(
+        `Unknown preset: ${selectedPresetId}. Available: ${presets.map((p) => p.id).join(", ")}`
+      );
+    }
+    const resolved = resolvePreset(selectedPreset, allManifests);
+    manifestSpinner.succeed(
+      chalk.green(`Using preset: ${selectedPreset.name} (${resolved.modules.size} modules)`)
+    );
+    if (dryRun) {
+      const resolvedModuleNames = [...resolved.modules.keys()];
+      const generatedFiles2 = getGeneratedFiles(resolved);
+      console.log("");
+      console.log(chalk.blue("\u{1F4CB} Dry Run - Files that would be generated:\n"));
+      for (const file of generatedFiles2) {
+        console.log(`  ${chalk.green("\u2713")} ${file}`);
+      }
+      const gitignorePath2 = path.join(templateDir, ".gitignore");
+      let ignorePatterns2 = [];
+      if (await fs.pathExists(gitignorePath2)) {
+        const gitignoreContent = await fs.readFile(gitignorePath2, "utf-8");
+        ignorePatterns2 = parseGitignore(gitignoreContent);
+      }
+      ignorePatterns2.push("node_modules", ".wrangler");
+      const excludePatterns2 = getExcludePatterns(resolved, allManifests);
+      let templateFileCount = 0;
+      const templateFiles = await fs.readdir(templateDir, { recursive: true });
+      for (const file of templateFiles) {
+        const relative = String(file);
+        if (!relative) continue;
+        const negated = ignorePatterns2.filter((p) => p.startsWith("!"));
+        const gitIgnored = ignorePatterns2.filter(
+          (p) => !p.startsWith("!") && relative.startsWith(p)
+        );
+        if (gitIgnored.length > 0) {
+          const allowed = negated.some((p) => relative === p.slice(1));
+          if (!allowed) continue;
+        }
+        const normalizedRelative = relative.replace(/\\/g, "/");
+        let excluded = false;
+        for (const pattern of excludePatterns2) {
+          const normalizedPattern = pattern.replace(/\\/g, "/");
+          if (normalizedRelative === normalizedPattern || normalizedRelative.startsWith(normalizedPattern + "/")) {
+            excluded = true;
+            break;
+          }
+        }
+        if (!excluded) templateFileCount++;
+      }
+      console.log("");
+      console.log(chalk.blue("\u{1F4C1} Template files that would be copied:\n"));
+      console.log(`  ${chalk.green("\u2713")} ${templateFileCount} template files`);
+      console.log("");
+      console.log(chalk.yellow(`  Total generated files: ${generatedFiles2.length}`));
+      console.log(chalk.yellow(`  Preset: ${selectedPreset.name}`));
+      console.log(chalk.yellow(`  Modules: ${resolvedModuleNames.join(", ")}`));
+      console.log("");
+      return;
+    }
+    if (!currentDir) {
+      const dirSpinner = ora("Creating project directory...").start();
+      await fs.ensureDir(targetDir);
+      dirSpinner.succeed(chalk.green("Project directory created"));
+    }
+    const copySpinner = ora("Copying template files...").start();
+    const gitignorePath = path.join(templateDir, ".gitignore");
+    let ignorePatterns = [];
+    if (await fs.pathExists(gitignorePath)) {
+      const gitignoreContent = await fs.readFile(gitignorePath, "utf-8");
+      ignorePatterns = parseGitignore(gitignoreContent);
+    }
+    ignorePatterns.push("node_modules", ".wrangler");
+    const excludePatterns = getExcludePatterns(resolved, allManifests);
+    await fs.copy(templateDir, targetDir, {
+      filter: (src) => {
+        const relative = path.relative(templateDir, src);
+        if (relative === "") return true;
+        const negated = ignorePatterns.filter((p) => p.startsWith("!"));
+        const gitIgnored = ignorePatterns.filter((p) => !p.startsWith("!") && relative.startsWith(p));
+        if (gitIgnored.length > 0) {
+          const allowed = negated.some((p) => relative === p.slice(1));
+          if (!allowed) return false;
+        }
+        const normalizedRelative = relative.replace(/\\/g, "/");
+        for (const pattern of excludePatterns) {
+          const normalizedPattern = pattern.replace(/\\/g, "/");
+          if (normalizedRelative === normalizedPattern || normalizedRelative.startsWith(normalizedPattern + "/")) {
+            return false;
+          }
+        }
+        return true;
+      },
+      dereference: false
+    });
+    copySpinner.succeed(chalk.green("Template files copied"));
+    const genSpinner = ora("Generating module-specific files...").start();
+    const routeRegistryContent = generateRouteRegistry(resolved);
+    await fs.writeFile(path.join(targetDir, "src/server/route-registry.ts"), routeRegistryContent);
+    const dbSchemaContent = generateDbSchemaBarrel(resolved);
+    await fs.writeFile(path.join(targetDir, "src/server/db/schema/index.ts"), dbSchemaContent);
+    if (resolved.hasClient) {
+      const clientNavContent = generateClientNavigation(resolved);
+      await fs.writeFile(
+        path.join(targetDir, "src/client/components/Navigation.tsx"),
+        clientNavContent
+      );
+      const clientAppTestContent = generateClientAppTest(resolved);
+      await fs.ensureDir(path.join(targetDir, "src/client/components/__tests__"));
+      await fs.writeFile(
+        path.join(targetDir, "src/client/components/__tests__/App.test.tsx"),
+        clientAppTestContent
+      );
+      const clientNavTestContent = generateClientNavigationTest(resolved);
+      await fs.writeFile(
+        path.join(targetDir, "src/client/components/__tests__/Navigation.test.tsx"),
+        clientNavTestContent
+      );
+      const presetUIConfigContent = generatePresetUIConfig(resolved, selectedPreset.id);
+      await fs.writeFile(
+        path.join(targetDir, "src/client/preset-ui-config.ts"),
+        presetUIConfigContent
+      );
+      const clientMainContent = generateClientMain(resolved, selectedPreset.id);
+      await fs.writeFile(path.join(targetDir, "src/client/main.tsx"), clientMainContent);
+    }
+    if (resolved.hasClient && resolved.modules.has("admin")) {
+      const adminAppContent = generateAdminApp(resolved);
+      if (adminAppContent) {
+        await fs.ensureDir(path.join(targetDir, "src/admin"));
+        await fs.writeFile(path.join(targetDir, "src/admin/App.tsx"), adminAppContent);
+      }
+      const adminComponentsIndex = generateAdminComponentsIndex(resolved);
+      if (adminComponentsIndex) {
+        await fs.ensureDir(path.join(targetDir, "src/admin/components"));
+        await fs.writeFile(
+          path.join(targetDir, "src/admin/components/index.ts"),
+          adminComponentsIndex
+        );
+      }
+      const adminApiClient = generateAdminApiClient(resolved);
+      if (adminApiClient) {
+        await fs.ensureDir(path.join(targetDir, "src/admin/services"));
+        await fs.writeFile(path.join(targetDir, "src/admin/services/apiClient.ts"), adminApiClient);
+      }
+    }
+    const serverAppContent = generateServerApp(resolved);
+    await fs.writeFile(path.join(targetDir, "src/server/app.ts"), serverAppContent);
+    const generatedFiles = getGeneratedFiles(resolved);
+    if (generatedFiles.includes("src/server/db/init.ts")) {
+      const dbInitContent = generateDbInit(resolved);
+      await fs.writeFile(path.join(targetDir, "src/server/db/init.ts"), dbInitContent);
+    }
+    const sharedModulesContent = generateSharedModulesIndex(resolved);
+    await fs.writeFile(path.join(targetDir, "src/shared/modules/index.ts"), sharedModulesContent);
+    const sharedSchemasContent = generateSharedSchemasIndex(resolved);
+    await fs.writeFile(path.join(targetDir, "src/shared/schemas/index.ts"), sharedSchemasContent);
+    const middlewareIndexContent = generateMiddlewareIndex(resolved);
+    await fs.writeFile(
+      path.join(targetDir, "src/server/middleware/index.ts"),
+      middlewareIndexContent
+    );
+    if (generatedFiles.includes("src/server/middleware/auth.ts")) {
+      const authMiddlewareContent = generateAuthMiddleware(resolved);
+      await fs.writeFile(
+        path.join(targetDir, "src/server/middleware/auth.ts"),
+        authMiddlewareContent
+      );
+    }
+    if (generatedFiles.includes("src/server/utils/auth.ts")) {
+      const authUtilsContent = generateAuthUtils(resolved);
+      await fs.writeFile(path.join(targetDir, "src/server/utils/auth.ts"), authUtilsContent);
+    }
+    if (resolved.hasClient) {
+      const clientComponentsContent = generateClientComponentsIndex(resolved);
+      await fs.writeFile(
+        path.join(targetDir, "src/client/components/index.ts"),
+        clientComponentsContent
+      );
+    }
+    const cliModulesContent = generateCliModulesIndex(resolved);
+    await fs.writeFile(path.join(targetDir, "src/cli/modules/index.ts"), cliModulesContent);
+    if (resolved.hasClient && generatedFiles.includes("vite.config.ts")) {
+      const viteConfigContent = generateViteConfig(resolved, templateDir);
+      await fs.writeFile(path.join(targetDir, "vite.config.ts"), viteConfigContent);
+    }
+    genSpinner.succeed(chalk.green("Module-specific files generated"));
+    const pkgSpinner = ora("Configuring package.json...").start();
+    await updatePackageJson(targetDir, projectName, resolved);
+    pkgSpinner.succeed(chalk.green("package.json configured"));
+    const lockSpinner = ora("Configuring package-lock.json...").start();
+    await updatePackageLockJson(targetDir, projectName);
+    lockSpinner.succeed(chalk.green("package-lock.json configured"));
+    const wranglerSpinner = ora("Configuring wrangler.toml...").start();
+    await updateWranglerToml(targetDir, projectName);
+    wranglerSpinner.succeed(chalk.green("wrangler.toml configured"));
+    const readmeSpinner = ora("Configuring README.md...").start();
+    await updateReadme(targetDir, projectName);
+    readmeSpinner.succeed(chalk.green("README.md configured"));
+    let installSucceeded = false;
+    if (install && !dryRun) {
+      const installSpinner = ora("Installing dependencies...").start();
+      try {
+        const { execSync } = await import('child_process');
+        execSync("npm install --legacy-peer-deps", {
+          cwd: targetDir,
+          stdio: "pipe",
+          timeout: 3e5
+        });
+        installSpinner.succeed(chalk.green("Dependencies installed"));
+        installSucceeded = true;
+      } catch {
+        installSpinner.warn(
+          chalk.yellow("Dependency installation failed (you can run npm install manually)")
+        );
+      }
+    }
+    if (installSucceeded) {
+      const patchesDir = path.join(targetDir, "patches");
+      if (await fs.pathExists(patchesDir)) {
+        try {
+          const { execSync } = await import('child_process');
+          execSync("npx patch-package", {
+            cwd: targetDir,
+            stdio: "pipe",
+            timeout: 6e4
+          });
+        } catch {
+        }
+      }
+    }
+    console.log("");
+    console.log(chalk.green("  \u2713 Project created successfully!"));
+    console.log(chalk.gray(`   Preset: ${selectedPreset.name}`));
+    console.log(chalk.gray(`   Modules: ${[...resolved.modules.keys()].join(", ")}`));
+    console.log("");
+    console.log(chalk.cyan("  Next steps:"));
+    if (!currentDir && !outputDir) {
+      console.log(chalk.white(`    cd ${projectName}`));
+    }
+    if (!install || !installSucceeded) {
+      console.log(chalk.white("    npm install"));
+    }
+    if (resolved.hasClient) {
+      console.log(chalk.white("    npm run dev"));
+      console.log("");
+      console.log(chalk.yellow("  \u26A0\uFE0F  Cloudflare Setup:"));
+      console.log(
+        chalk.white(`    1. Create D1 database: wrangler d1 create ${generateDbName(projectName)}`)
+      );
+      console.log(chalk.white("    2. Copy the database ID to wrangler.toml"));
+      console.log(chalk.white("    3. Deploy: npm run deploy:cf"));
+    } else {
+      console.log(chalk.white("    npm run build"));
+      console.log(chalk.white("    npm start"));
+      console.log("");
+      console.log(chalk.cyan("  CLI usage:"));
+      console.log(chalk.white("    node dist/cli/index.js config status"));
+      console.log(chalk.white("    node dist/cli/index.js todo list"));
+      console.log(chalk.white("    node dist/cli/index.js --help"));
+    }
+    console.log("");
+    console.log(chalk.gray("  Happy coding! \u{1F41F}"));
+    console.log("");
+  } catch (error) {
+    if (error instanceof ScaffoldError) throw error;
+    throw new ScaffoldError(`Error creating project: ${error}`);
+  }
+}
+
+// src/index.ts
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path.dirname(__filename2);
+var rootDir = __dirname2.endsWith(path.join("src")) ? path.resolve(__dirname2, "..") : __dirname2.endsWith(path.join("dist", "cli")) ? path.resolve(__dirname2, "..", "..") : path.resolve(__dirname2, "..", "..");
+var packageJson = JSON.parse(readFileSync(path.join(rootDir, "package.json"), "utf-8"));
+var program = new Command();
+program.name("create-fullstack-scaffold").description("Create a new full-stack scaffold app with Todo List example").version(packageJson.version).argument("[project-name]", "Name of your project").option("-c, --current-dir", "Create project in current directory").option(
+  "-p, --preset <preset>",
+  "Template preset to use (fullstack-admin, todo-app, ecommerce, xbrowser-marketplace, forum, cli-only, minimal, saas)"
+).option("-o, --output-dir <path>", "Output directory (defaults to project name)").option("--dry-run", "Show what would be generated without creating files").option("--no-install", "Skip automatic dependency installation").action(
+  async (projectName = "my-fullstack-app", options) => {
+    console.log("");
+    console.log(chalk.cyan.bold("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
+    console.log(chalk.cyan.bold("  \u2551   Create Fullstack Scaffold App          \u2551"));
+    console.log(chalk.cyan.bold("  \u2551   React + Hono + Vite + Zustand + TS     \u2551"));
+    console.log(chalk.cyan.bold("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
+    console.log("");
+    let preset = options.preset;
+    if (!preset && process.stdin.isTTY) {
+      const templateDir = path.join(rootDir, "template");
+      const presets = await loadPresets(templateDir);
+      preset = await select({
+        message: "Choose a template preset:",
+        choices: presets.map((p) => ({
+          value: p.id,
+          name: `${p.name} \u2014 ${p.description}`
+        }))
+      });
+    }
+    if (!preset) {
+      preset = "fullstack-admin";
+    }
+    try {
+      await createProject({
+        projectName,
+        currentDir: options.currentDir ?? false,
+        preset,
+        outputDir: options.outputDir,
+        dryRun: options.dryRun ?? false,
+        install: options.install
+      });
+    } catch (error) {
+      if (error instanceof ScaffoldError) {
+        console.error(chalk.red(`  \u2716 ${error.message}`));
+        process.exit(1);
+      }
+      throw error;
+    }
+  }
+);
+program.command("presets").description("List available template presets").action(async () => {
+  const templateDir = path.join(rootDir, "template");
+  const presets = await loadPresets(templateDir);
+  console.log(chalk.cyan("\nAvailable presets:\n"));
+  for (const preset of presets) {
+    console.log(`  ${chalk.green(preset.id.padEnd(20))} ${preset.name}`);
+    console.log(`  ${" ".repeat(20)} ${preset.description}`);
+    console.log(`  ${" ".repeat(20)} Modules: ${preset.modules.join(", ")}`);
+    console.log();
+  }
+});
+program.parse();
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map