@sigx/ssg 0.3.2 → 0.4.1

package/dist/cli.js

@@ -1,2357 +0,0 @@
-#!/usr/bin/env node
-
-// src/build.ts
-import path6 from "node:path";
-import fs5 from "node:fs/promises";
-import fsSync from "node:fs";
-import { pathToFileURL } from "node:url";
-
-// src/config.ts
-import path from "node:path";
-function defineSSGConfig(config) {
-  return {
-    // Defaults
-    pages: "src/pages",
-    layouts: "src/layouts",
-    content: "src/content",
-    defaultLayout: "default",
-    outDir: "dist",
-    base: "/",
-    // Zero-config defaults
-    autoEntries: true,
-    prefetch: true,
-    // User overrides
-    ...config,
-    // Merge nested objects
-    site: {
-      lang: "en",
-      ...config.site
-    },
-    markdown: {
-      shiki: true,
-      ...config.markdown
-    },
-    toc: {
-      minLevel: 2,
-      maxLevel: 3,
-      ...config.toc
-    }
-  };
-}
-async function loadConfig(configPath2) {
-  const fsPath = await import("node:path");
-  const fs8 = await import("node:fs");
-  const { pathToFileURL: pathToFileURL2 } = await import("node:url");
-  const os = await import("node:os");
-  const cwd = process.cwd();
-  const possiblePaths = configPath2 ? [fsPath.resolve(cwd, configPath2)] : [
-    fsPath.resolve(cwd, "ssg.config.ts"),
-    fsPath.resolve(cwd, "ssg.config.js"),
-    fsPath.resolve(cwd, "ssg.config.mjs")
-  ];
-  let foundPath = null;
-  for (const p of possiblePaths) {
-    if (fs8.existsSync(p)) {
-      foundPath = p;
-      break;
-    }
-  }
-  if (!foundPath) {
-    console.warn("No ssg.config found, using defaults");
-    return defineSSGConfig({});
-  }
-  try {
-    if (foundPath.endsWith(".ts")) {
-      const esbuild = await import("esbuild");
-      const tempDir = os.tmpdir();
-      const tempFile = fsPath.join(tempDir, `ssg-config-${Date.now()}.mjs`);
-      const source = fs8.readFileSync(foundPath, "utf-8");
-      const result = await esbuild.transform(source, {
-        loader: "ts",
-        format: "esm"
-      });
-      const configDir = fsPath.dirname(foundPath);
-      const localTempFile = fsPath.join(configDir, `.ssg-config-temp-${Date.now()}.mjs`);
-      fs8.writeFileSync(localTempFile, result.code);
-      try {
-        const configModule2 = await import(pathToFileURL2(localTempFile).href);
-        return defineSSGConfig(configModule2.default || configModule2);
-      } finally {
-        try {
-          fs8.unlinkSync(localTempFile);
-        } catch {
-        }
-      }
-    }
-    const configModule = await import(pathToFileURL2(foundPath).href);
-    return defineSSGConfig(configModule.default || configModule);
-  } catch (err) {
-    console.error(`Failed to load config from ${foundPath}:`, err);
-    return defineSSGConfig({});
-  }
-}
-function resolveConfigPaths(config, root) {
-  return {
-    ...config,
-    pages: path.resolve(root, config.pages || "src/pages"),
-    layouts: path.resolve(root, config.layouts || "src/layouts"),
-    content: path.resolve(root, config.content || "src/content"),
-    outDir: path.resolve(root, config.outDir || "dist")
-  };
-}
-
-// src/routing/scanner.ts
-import fg from "fast-glob";
-import path2 from "node:path";
-import fs from "node:fs";
-
-// src/mdx/frontmatter.ts
-import matter from "gray-matter";
-function parseFrontmatter(source) {
-  const { data, content, matter: raw } = matter(source);
-  return {
-    data: normalizeFrontmatter(data),
-    content,
-    raw: raw || "",
-    hasFrontmatter: !!raw
-  };
-}
-function normalizeFrontmatter(data) {
-  const meta = {};
-  if (typeof data.title === "string") meta.title = data.title;
-  if (typeof data.description === "string") meta.description = data.description;
-  if (typeof data.layout === "string") meta.layout = data.layout;
-  if (typeof data.draft === "boolean") meta.draft = data.draft;
-  if (data.date) {
-    if (data.date instanceof Date) {
-      meta.date = data.date;
-    } else if (typeof data.date === "string") {
-      meta.date = new Date(data.date);
-    }
-  }
-  if (Array.isArray(data.tags)) {
-    meta.tags = data.tags.filter((t) => typeof t === "string");
-  }
-  if (typeof data.ssr === "boolean") meta.ssr = data.ssr;
-  for (const [key, value] of Object.entries(data)) {
-    if (!(key in meta)) {
-      meta[key] = value;
-    }
-  }
-  return meta;
-}
-function extractTitleFromContent(content) {
-  const h1Match = content.match(/^#\s+(.+)$/m);
-  return h1Match ? h1Match[1].trim() : null;
-}
-
-// src/routing/scanner.ts
-var PAGE_EXTENSIONS = [".tsx", ".jsx", ".mdx", ".md"];
-var EXCLUDED_PATTERNS = [
-  "components/**",
-  // Root-level components folder only
-  "hooks/**",
-  // Root-level hooks folder only
-  "utils/**",
-  // Root-level utils folder only
-  "lib/**",
-  // Root-level lib folder only
-  "**/_*",
-  // Files/folders starting with underscore (at any level)
-  "**/*.test.*",
-  "**/*.spec.*"
-];
-async function scanPages(config, root) {
-  const pagesDir = path2.resolve(root, config.pages || "src/pages");
-  const patterns = PAGE_EXTENSIONS.map((ext) => `**/*${ext}`);
-  const files = await fg(patterns, {
-    cwd: pagesDir,
-    ignore: EXCLUDED_PATTERNS,
-    onlyFiles: true,
-    absolute: false
-  });
-  const routes = [];
-  for (const file of files) {
-    const route = await fileToRouteWithMeta(file, pagesDir);
-    if (route) {
-      routes.push(route);
-    }
-  }
-  return sortRoutes(routes);
-}
-async function fileToRouteWithMeta(filePath, pagesDir) {
-  const route = fileToRoute(filePath, pagesDir);
-  if (!route) return null;
-  const ext = path2.extname(filePath).toLowerCase();
-  if (ext === ".mdx" || ext === ".md") {
-    try {
-      const content = fs.readFileSync(route.file, "utf-8");
-      const { data } = parseFrontmatter(content);
-      route.meta = data;
-    } catch (err) {
-    }
-  }
-  return route;
-}
-function fileToRoute(filePath, pagesDir) {
-  const ext = path2.extname(filePath);
-  let routePath = filePath.slice(0, -ext.length);
-  if (routePath.endsWith("/index") || routePath === "index") {
-    routePath = routePath.replace(/\/?index$/, "") || "/";
-  }
-  routePath = filePathToRoutePath(routePath);
-  const name = pathToRouteName(routePath);
-  return {
-    path: routePath.startsWith("/") ? routePath : `/${routePath}`,
-    file: path2.join(pagesDir, filePath),
-    name
-  };
-}
-function filePathToRoutePath(filePath) {
-  return filePath.split("/").map((segment) => {
-    if (segment.startsWith("[...") && segment.endsWith("]")) {
-      const param = segment.slice(4, -1);
-      return `*${param}`;
-    }
-    if (segment.startsWith("[[...") && segment.endsWith("]]")) {
-      const param = segment.slice(5, -2);
-      return `*${param}`;
-    }
-    if (segment.startsWith("[") && segment.endsWith("]")) {
-      const param = segment.slice(1, -1);
-      return `:${param}`;
-    }
-    if (segment.startsWith("[[") && segment.endsWith("]]")) {
-      const param = segment.slice(2, -2);
-      return `:${param}?`;
-    }
-    return segment;
-  }).join("/");
-}
-function pathToRouteName(routePath) {
-  if (routePath === "/" || routePath === "") {
-    return "index";
-  }
-  return routePath.replace(/^\//, "").replace(/\//g, "-").replace(/:/g, "").replace(/\*/g, "").replace(/\?/g, "").replace(/-+/g, "-").replace(/-$/, "");
-}
-function sortRoutes(routes) {
-  return routes.sort((a, b) => {
-    const scoreA = getRouteScore(a.path);
-    const scoreB = getRouteScore(b.path);
-    if (scoreA !== scoreB) {
-      return scoreB - scoreA;
-    }
-    return b.path.length - a.path.length;
-  });
-}
-function getRouteScore(routePath) {
-  const segments = routePath.split("/").filter(Boolean);
-  let score = 0;
-  for (const segment of segments) {
-    if (segment.startsWith("*")) {
-      score += 1;
-    } else if (segment.startsWith(":")) {
-      score += 10;
-    } else {
-      score += 100;
-    }
-  }
-  return score;
-}
-function isDynamicRoute(route) {
-  return route.path.includes(":") || route.path.includes("*");
-}
-function extractParams(routePath) {
-  const params = [];
-  const segments = routePath.split("/");
-  for (const segment of segments) {
-    if (segment.startsWith(":")) {
-      params.push(segment.slice(1).replace("?", ""));
-    } else if (segment.startsWith("*")) {
-      params.push(segment.slice(1));
-    }
-  }
-  return params;
-}
-function expandDynamicRoute(route, staticPaths) {
-  const paths = [];
-  for (const { params } of staticPaths) {
-    let expandedPath = route.path;
-    for (const [key, value] of Object.entries(params)) {
-      expandedPath = expandedPath.replace(`:${key}`, value);
-      expandedPath = expandedPath.replace(`*${key}`, value);
-    }
-    paths.push(expandedPath);
-  }
-  return paths;
-}
-
-// src/routing/virtual.ts
-var VIRTUAL_ROUTES_ID = "virtual:ssg-routes";
-var RESOLVED_VIRTUAL_ROUTES_ID = "\0" + VIRTUAL_ROUTES_ID;
-function normalizePath(filePath) {
-  return filePath.replace(/\\/g, "/");
-}
-function generateRoutesModule(routes, config) {
-  const imports = [];
-  const routeDefinitions = [];
-  for (let i = 0; i < routes.length; i++) {
-    const route = routes[i];
-    const componentName = `Page${i}`;
-    const metaName = `meta${i}`;
-    const normalizedFile = normalizePath(route.file);
-    imports.push(`import * as ${componentName}Module from '${normalizedFile}';`);
-    imports.push(
-      `const ${metaName} = { ...('meta' in ${componentName}Module ? ${componentName}Module.meta : ${componentName}Module.default?.frontmatter || ${JSON.stringify(route.meta || {})}), headings: 'headings' in ${componentName}Module ? ${componentName}Module.headings : [] };`
-    );
-    imports.push(
-      `const ${componentName} = ${componentName}Module.default || ${componentName}Module;`
-    );
-    routeDefinitions.push(`
-    {
-        path: '${route.path}',
-        name: '${route.name}',
-        file: '${normalizedFile}',
-        component: ${componentName},
-        meta: ${metaName},
-        layout: ${metaName}.layout || '${config.defaultLayout || "default"}',
-    }`);
-  }
-  return `
-${imports.join("\n")}
-
-const routes = [${routeDefinitions.join(",")}
-];
-
-export default routes;
-`;
-}
-function generateLazyRoutesModule(routes, config) {
-  const imports = [];
-  const routeDefinitions = [];
-  for (let i = 0; i < routes.length; i++) {
-    const route = routes[i];
-    const componentName = `Page${i}`;
-    const metaName = `meta${i}`;
-    const normalizedFile = normalizePath(route.file);
-    imports.push(`import * as ${componentName}Module from '${normalizedFile}';`);
-    imports.push(
-      `const ${metaName} = { ...('meta' in ${componentName}Module ? ${componentName}Module.meta : ${componentName}Module.default?.frontmatter || ${JSON.stringify(route.meta || {})}), headings: 'headings' in ${componentName}Module ? ${componentName}Module.headings : [] };`
-    );
-    routeDefinitions.push(`
-    {
-        path: '${route.path}',
-        name: '${route.name}',
-        file: '${normalizedFile}',
-        component: () => import('${normalizedFile}'),
-        meta: ${metaName},
-        layout: ${metaName}.layout || '${config.defaultLayout || "default"}',
-    }`);
-  }
-  return `
-${imports.join("\n")}
-
-const routes = [${routeDefinitions.join(",")}
-];
-
-export default routes;
-`;
-}
-
-// src/routing/navigation.ts
-function generateNavigation(routes, collectionPath, showDrafts, isDev) {
-  const navRoutes = routes.filter((route) => {
-    if (!route.path.startsWith(collectionPath)) {
-      return false;
-    }
-    const meta = route.meta || {};
-    if (meta.sidebar === false) {
-      return false;
-    }
-    if (meta.draft) {
-      if (showDrafts === "never") {
-        return false;
-      }
-      if (showDrafts === "dev" && !isDev) {
-        return false;
-      }
-    }
-    return true;
-  });
-  const context = {
-    categories: /* @__PURE__ */ new Map(),
-    uncategorized: []
-  };
-  for (const route of navRoutes) {
-    const meta = route.meta || {};
-    const title = meta.title || routeToTitle(route.path);
-    const order = typeof meta.order === "number" ? meta.order : 999;
-    const category = meta.category;
-    const item = {
-      title,
-      href: route.path,
-      order
-    };
-    if (!category) {
-      context.uncategorized.push(item);
-    } else if (typeof category === "string") {
-      addToCategory(context.categories, [category], item);
-    } else if (Array.isArray(category)) {
-      addToCategory(context.categories, category, item);
-    }
-  }
-  const sidebar = buildSections(context);
-  return { sidebar };
-}
-function addToCategory(categories, path9, item) {
-  if (path9.length === 0) {
-    return;
-  }
-  const [first, ...rest] = path9;
-  let category = categories.get(first);
-  if (!category) {
-    category = {
-      title: first,
-      order: void 0,
-      items: [],
-      children: /* @__PURE__ */ new Map()
-    };
-    categories.set(first, category);
-  }
-  if (rest.length === 0) {
-    category.items.push(item);
-  } else {
-    addToCategory(category.children, rest, item);
-  }
-}
-var SECTION_ORDER = {
-  "Getting Started": 10,
-  "Core Concepts": 20,
-  "Core": 20,
-  "Built-in Components": 30,
-  "Components": 30,
-  "Guides": 40,
-  "Advanced": 50,
-  "Ecosystem": 60,
-  "API Reference": 70,
-  "API": 70,
-  "Reference": 80,
-  // DaisyUI component categories (matching DaisyUI website)
-  "Actions": 100,
-  "Data Display": 110,
-  "Navigation": 120,
-  "Feedback": 130,
-  "Data Input": 140,
-  "Layout": 150,
-  "Mockup": 160,
-  "Other": 999
-};
-function getSectionOrder(title, explicitOrder) {
-  if (explicitOrder !== void 0) {
-    return explicitOrder;
-  }
-  return SECTION_ORDER[title] ?? 50;
-}
-function buildSections(context) {
-  const sections = [];
-  for (const [, category] of context.categories) {
-    sections.push(buildSection(category));
-  }
-  if (context.uncategorized.length > 0) {
-    sections.push({
-      title: "Other",
-      items: context.uncategorized.sort((a, b) => a.order - b.order || a.title.localeCompare(b.title)).map((item) => ({
-        title: item.title,
-        href: item.href,
-        order: item.order
-      })),
-      order: 999
-    });
-  }
-  sections.sort((a, b) => {
-    const orderA = getSectionOrder(a.title, a.order);
-    const orderB = getSectionOrder(b.title, b.order);
-    return orderA - orderB;
-  });
-  return sections;
-}
-function buildSection(category) {
-  const sortedItems = category.items.sort((a, b) => a.order - b.order || a.title.localeCompare(b.title)).map((item) => ({
-    title: item.title,
-    href: item.href,
-    order: item.order
-  }));
-  const childSections = [];
-  for (const [, child] of category.children) {
-    childSections.push(buildNestedSection(child));
-  }
-  const items = [...sortedItems];
-  for (const nested of childSections.sort((a, b) => {
-    const orderA = getSectionOrder(a.title, a.order);
-    const orderB = getSectionOrder(b.title, b.order);
-    return orderA - orderB;
-  })) {
-    items.push(nested);
-  }
-  return {
-    title: category.title,
-    items,
-    order: category.order
-  };
-}
-function buildNestedSection(category) {
-  const sortedItems = category.items.sort((a, b) => a.order - b.order || a.title.localeCompare(b.title)).map((item) => ({
-    title: item.title,
-    href: item.href,
-    order: item.order
-  }));
-  const childItems = [];
-  for (const [, child] of category.children) {
-    childItems.push(buildNestedSection(child));
-  }
-  return {
-    title: category.title,
-    items: [...sortedItems, ...childItems.sort((a, b) => (a.order ?? 0) - (b.order ?? 0))],
-    order: category.order
-  };
-}
-function routeToTitle(routePath) {
-  const segments = routePath.split("/").filter(Boolean);
-  const lastSegment = segments[segments.length - 1] || "Home";
-  return lastSegment.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
-}
-function generateAllCollections(routes, config, isDev) {
-  const collections = config.collections || {};
-  const result = {};
-  for (const [name, collectionConfig] of Object.entries(collections)) {
-    const showDrafts = collectionConfig.showDrafts ?? config.navigation?.showDrafts ?? "dev";
-    result[name] = generateNavigation(routes, collectionConfig.path, showDrafts, isDev);
-  }
-  return result;
-}
-
-// src/routing/virtual-navigation.ts
-var VIRTUAL_NAVIGATION_ID = "virtual:ssg-navigation";
-var RESOLVED_VIRTUAL_NAVIGATION_ID = "\0" + VIRTUAL_NAVIGATION_ID;
-function generateNavigationModule(routes, config, isDev) {
-  const navigation = generateAllCollections(routes, config, isDev);
-  const collections = config.collections || {};
-  const navJson = JSON.stringify(navigation, null, 2);
-  const collectionsJson = JSON.stringify(collections, null, 2);
-  return `
-/**
- * Auto-generated navigation module
- * 
- * @generated by @sigx/ssg
- */
-
-/**
- * Navigation for all collections, keyed by collection name
- */
-export const navigation = ${navJson};
-
-/**
- * Collections configuration
- */
-const collections = ${collectionsJson};
-
-/**
- * Get navigation for a specific collection
- * @param name - Collection name (e.g., 'docs', 'examples')
- * @returns The collection's navigation or undefined if not found
- */
-export function getCollectionNav(name) {
-    return navigation[name];
-}
-
-/**
- * Detect which collection a route path belongs to
- * @param path - Current route path
- * @returns The collection name if found, undefined otherwise
- */
-export function detectCollection(path) {
-    // Sort by path length descending to match most specific path first
-    const sorted = Object.entries(collections).sort(
-        ([, a], [, b]) => b.path.length - a.path.length
-    );
-
-    for (const [name, config] of sorted) {
-        if (path.startsWith(config.path)) {
-            return name;
-        }
-    }
-
-    return undefined;
-}
-
-/**
- * Get sidebar for a specific collection
- * @param name - Collection name
- * @returns The sidebar array or empty array if not found
- */
-export function getSidebar(name) {
-    return navigation[name]?.sidebar || [];
-}
-
-export default { navigation, collections, getCollectionNav, detectCollection, getSidebar };
-`;
-}
-
-// src/layouts/resolver.ts
-import fg2 from "fast-glob";
-import path3 from "node:path";
-import fs2 from "node:fs";
-var LAYOUT_EXTENSIONS = [".tsx", ".jsx"];
-async function scanLocalLayouts(config, root) {
-  const layoutsDir = path3.resolve(root, config.layouts || "src/layouts");
-  if (!fs2.existsSync(layoutsDir)) {
-    return [];
-  }
-  const patterns = LAYOUT_EXTENSIONS.map((ext) => `*${ext}`);
-  const files = await fg2(patterns, {
-    cwd: layoutsDir,
-    onlyFiles: true,
-    absolute: false
-  });
-  return files.map((file) => {
-    const ext = path3.extname(file);
-    const name = file.slice(0, -ext.length);
-    return {
-      name,
-      file: path3.join(layoutsDir, file),
-      source: "local"
-    };
-  });
-}
-async function loadThemeLayouts(themeName, root) {
-  try {
-    const { createRequire } = await import("node:module");
-    const { pathToFileURL: pathToFileURL2 } = await import("node:url");
-    const require2 = createRequire(path3.join(root, "package.json"));
-    const themePackageJson = require2.resolve(`${themeName}/package.json`);
-    const themeDir = path3.dirname(themePackageJson);
-    const packageJson = JSON.parse(fs2.readFileSync(themePackageJson, "utf-8"));
-    const mainFile = packageJson.exports?.["."]?.import || packageJson.main || "./dist/index.js";
-    const themePath = path3.resolve(themeDir, mainFile);
-    const themeModule = await import(pathToFileURL2(themePath).href);
-    if (!themeModule.layouts) {
-      return [];
-    }
-    return Object.keys(themeModule.layouts).map((name) => ({
-      name,
-      file: `${themeName}/layouts/${name}`,
-      source: themeName
-    }));
-  } catch (err) {
-    console.warn(`Failed to load theme ${themeName}:`, err);
-    return [];
-  }
-}
-async function discoverLayouts(config, root) {
-  const layouts = /* @__PURE__ */ new Map();
-  if (config.theme) {
-    const themeLayouts = await loadThemeLayouts(config.theme, root);
-    for (const layout of themeLayouts) {
-      layouts.set(layout.name, layout);
-    }
-  }
-  const localLayouts = await scanLocalLayouts(config, root);
-  for (const layout of localLayouts) {
-    layouts.set(layout.name, layout);
-  }
-  return Array.from(layouts.values());
-}
-
-// src/layouts/virtual.ts
-var VIRTUAL_LAYOUTS_ID = "virtual:generated-layouts";
-var RESOLVED_VIRTUAL_LAYOUTS_ID = "\0virtual:generated-layouts";
-function normalizePath2(filePath) {
-  return filePath.replace(/\\/g, "/");
-}
-function generateLayoutsModule(layouts, config) {
-  const imports = [];
-  const layoutEntries = [];
-  for (let i = 0; i < layouts.length; i++) {
-    const layout = layouts[i];
-    const importName = `Layout${i}`;
-    if (layout.source === "local") {
-      const normalizedFile = normalizePath2(layout.file);
-      imports.push(`import ${importName} from '${normalizedFile}';`);
-    } else {
-      imports.push(`import { layouts as themeLayouts${i} } from '${layout.source}';`);
-      imports.push(`const ${importName} = themeLayouts${i}['${layout.name}'];`);
-    }
-    layoutEntries.push(`    '${layout.name}': ${importName}.default || ${importName}`);
-  }
-  return `
-import { component, signal, jsx } from 'sigx';
-import { useRoute } from '@sigx/router';
-${imports.join("\n")}
-
-/**
- * All available layouts
- */
-export const layouts = {
-${layoutEntries.join(",\n")}
-};
-
-/**
- * Default layout name
- */
-export const defaultLayout = '${config.defaultLayout || "default"}';
-
-/**
- * Check if a component is marked as lazy (created by lazy())
- */
-function isMarkedLazy(component) {
-    return component && component.__lazy === true;
-}
-
-/**
- * Check if a value is a Promise/thenable
- */
-function isPromise(value) {
-    return value && typeof value.then === 'function';
-}
-
-/**
- * Track hydration state - we're hydrating if the app container has SSR content
- */
-let isHydrating = typeof window !== 'undefined' && 
-    document.getElementById('app')?.innerHTML?.trim().length > 0;
-
-// After first render, we're no longer hydrating
-if (typeof window !== 'undefined') {
-    const markHydrationComplete = () => { isHydrating = false; };
-    if ('requestIdleCallback' in window) {
-        window.requestIdleCallback(markHydrationComplete);
-    } else {
-        setTimeout(markHydrationComplete, 0);
-    }
-}
-
-/**
- * Placeholder component that preserves existing DOM during hydration.
- */
-const HydrationPlaceholder = component(() => {
-    return () => null;
-}, { name: 'HydrationPlaceholder' });
-
-/**
- * Layout router component that preserves layouts across navigation.
- * 
- * This component renders the current route's layout and page content reactively.
- * When navigating between routes with the same layout, only the page content
- * updates - the layout (Navbar, Sidebar, Footer) persists without re-rendering.
- */
-export const LayoutRouter = component((ctx) => {
-    const route = useRoute();
-    
-    // Track loaded lazy components to avoid reloading
-    const loadedComponents = {};
-    
-    // Track if this is the initial hydration render
-    let initialRender = true;
-    
-    // HMR support: Listen for MDX updates and clear the component cache
-    if (typeof window !== 'undefined' && import.meta.hot) {
-        // Listen for sigx:mdx-hmr events dispatched by MDX files after they accept HMR
-        const handleMdxHmr = (event) => {
-            const { moduleId, newModule } = event.detail || {};
-            
-            // Clear all cached components to force reload with new module
-            for (const key in loadedComponents) {
-                delete loadedComponents[key];
-            }
-            
-            // If we have the new module directly from HMR, cache it for the matching route
-            if (newModule?.default) {
-                const currentPath = route.path;
-                loadedComponents[currentPath] = newModule.default;
-            }
-            
-            // Force re-render
-            ctx.update();
-        };
-        
-        window.addEventListener('sigx:mdx-hmr', handleMdxHmr);
-        
-        ctx.onUnmounted(() => {
-            window.removeEventListener('sigx:mdx-hmr', handleMdxHmr);
-        });
-    }
-    
-    return () => {
-        const matched = route.matched;
-        if (!matched || matched.length === 0) return null;
-        
-        const match = matched[0];
-        if (!match) return null;
-        
-        // Get layout name from route meta or use default
-        const layoutName = match.layout || match.meta?.layout || defaultLayout;
-        const Layout = layouts[layoutName];
-        
-        if (!Layout) {
-            console.warn(\`Layout "\${layoutName}" not found for route \${route.path}\`);
-            return null;
-        }
-        
-        // Get the original (unwrapped) component
-        const rawComponent = match.originalComponent || match.component;
-        const routePath = route.path;
-        
-        // Handle lazy/dynamic import components
-        if (isMarkedLazy(rawComponent) || (typeof rawComponent === 'function' && !rawComponent.__setup)) {
-            // Check if already loaded
-            if (loadedComponents[routePath]) {
-                const PageComponent = loadedComponents[routePath];
-                initialRender = false;
-                return jsx(Layout, { 
-                    meta: match.meta, 
-                    path: routePath, 
-                    key: layoutName,  // Key by layout to preserve layout across pages
-                    children: PageComponent({}) 
-                });
-            }
-            
-            // Load the component
-            const loadState = signal({ value: null, loading: true, error: null });
-            
-            try {
-                const result = rawComponent();
-                if (isPromise(result)) {
-                    result.then(module => {
-                        const Component = module.default || module;
-                        loadedComponents[routePath] = Component;
-                        loadState.value = Component;
-                        loadState.loading = false;
-                    }).catch(err => {
-                        console.error('Failed to load component for route:', routePath, err);
-                        loadState.error = err;
-                        loadState.loading = false;
-                    });
-                } else {
-                    // Not a promise, use directly
-                    loadedComponents[routePath] = rawComponent;
-                    loadState.value = rawComponent;
-                    loadState.loading = false;
-                }
-            } catch (err) {
-                loadState.error = err;
-                loadState.loading = false;
-            }
-            
-            // During hydration, preserve existing SSR content instead of showing loading state
-            if (loadState.loading) {
-                if (isHydrating && initialRender) {
-                    return jsx(Layout, { 
-                        meta: match.meta, 
-                        path: routePath, 
-                        key: layoutName,
-                        children: jsx(HydrationPlaceholder, {})
-                    });
-                }
-                return jsx(Layout, { 
-                    meta: match.meta, 
-                    path: routePath, 
-                    key: layoutName,
-                    children: null 
-                });
-            }
-            
-            if (loadState.error || !loadState.value) {
-                return jsx(Layout, { 
-                    meta: match.meta, 
-                    path: routePath, 
-                    key: layoutName,
-                    children: null 
-                });
-            }
-            
-            const PageComponent = loadState.value;
-            initialRender = false;
-            return jsx(Layout, { 
-                meta: match.meta, 
-                path: routePath, 
-                key: layoutName,
-                children: PageComponent({}) 
-            });
-        }
-        
-        // Eager component (has __setup)
-        // Check cache first for HMR-updated components
-        if (loadedComponents[routePath]) {
-            const PageComponent = loadedComponents[routePath];
-            initialRender = false;
-            return jsx(Layout, { 
-                meta: match.meta, 
-                path: routePath, 
-                key: layoutName,
-                children: PageComponent({}) 
-            });
-        }
-        
-        initialRender = false;
-        return jsx(Layout, { 
-            meta: match.meta, 
-            path: routePath, 
-            key: layoutName,
-            children: rawComponent({}) 
-        });
-    };
-}, { name: 'LayoutRouter' });
-
-/**
- * Setup layouts for routes
- *
- * This function now simply annotates routes with their layout information.
- * The actual layout wrapping is handled by LayoutRouter, which preserves
- * layouts across navigation.
- */
-export function setupLayouts(routes) {
-    const availableLayoutNames = Object.keys(layouts);
-    
-    return routes.map(route => {
-        const layoutName = route.layout || route.meta?.layout || defaultLayout;
-        const Layout = layouts[layoutName];
-
-        if (!Layout) {
-            console.error(
-                \`\u274C SSG103: Layout "\${layoutName}" not found for route \${route.path}\\n\` +
-                \`   \u{1F4C1} \${route.file || 'unknown'}\\n\` +
-                \`   \u{1F4A1} Available layouts: \${availableLayoutNames.join(', ') || 'none'}\\n\` +
-                \`      Create src/layouts/\${layoutName}.tsx or set a valid layout in frontmatter.\`
-            );
-            return route;
-        }
-
-        // Store layout info on the route, but don't wrap the component
-        // LayoutRouter will handle layout rendering
-        return {
-            ...route,
-            layout: layoutName,
-            originalComponent: route.component,
-            meta: {
-                ...route.meta,
-                layout: layoutName,
-            },
-        };
-    });
-}
-
-export default layouts;
-`;
-}
-
-// src/sitemap.ts
-import fs3 from "node:fs/promises";
-import path4 from "node:path";
-function generateSitemap(entries, config) {
-  const siteUrl = config.site?.url?.replace(/\/$/, "") || "";
-  const base = config.base?.replace(/\/$/, "") || "";
-  const urlEntries = entries.map((entry) => {
-    const loc = `${siteUrl}${base}${entry.path}`;
-    const lastmod = entry.lastmod ? typeof entry.lastmod === "string" ? entry.lastmod : entry.lastmod.toISOString().split("T")[0] : void 0;
-    return `  <url>
-    <loc>${escapeXml(loc)}</loc>${lastmod ? `
-    <lastmod>${lastmod}</lastmod>` : ""}${entry.changefreq ? `
-    <changefreq>${entry.changefreq}</changefreq>` : ""}${entry.priority !== void 0 ? `
-    <priority>${entry.priority.toFixed(1)}</priority>` : ""}
-  </url>`;
-  });
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-${urlEntries.join("\n")}
-</urlset>`;
-}
-function generateRobotsTxt(config, sitemapPath = "/sitemap.xml") {
-  const siteUrl = config.site?.url?.replace(/\/$/, "") || "";
-  const base = config.base?.replace(/\/$/, "") || "";
-  return `User-agent: *
-Allow: /
-
-Sitemap: ${siteUrl}${base}${sitemapPath}
-`;
-}
-function pagesToSitemapEntries(pages, options = {}) {
-  const {
-    exclude = [],
-    defaultChangefreq = "weekly",
-    defaultPriority = 0.5
-  } = options;
-  return pages.filter((page) => {
-    for (const pattern of exclude) {
-      if (pattern.includes("*")) {
-        const regex = new RegExp(
-          "^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$"
-        );
-        if (regex.test(page.path)) return false;
-      } else if (page.path === pattern) {
-        return false;
-      }
-    }
-    return true;
-  }).map((page) => {
-    const depth = page.path.split("/").filter(Boolean).length;
-    let priority = defaultPriority;
-    if (page.path === "/") {
-      priority = 1;
-    } else if (depth === 1) {
-      priority = 0.8;
-    } else if (depth === 2) {
-      priority = 0.6;
-    }
-    return {
-      path: page.path,
-      changefreq: defaultChangefreq,
-      priority
-    };
-  });
-}
-async function writeSitemap(pages, config, outDir, options = {}) {
-  const entries = pagesToSitemapEntries(pages, options);
-  if (options.additionalUrls) {
-    entries.push(...options.additionalUrls);
-  }
-  const sitemapContent = generateSitemap(entries, config);
-  const sitemapPath = path4.join(outDir, "sitemap.xml");
-  await fs3.writeFile(sitemapPath, sitemapContent, "utf-8");
-  const robotsContent = generateRobotsTxt(config);
-  const robotsPath = path4.join(outDir, "robots.txt");
-  await fs3.writeFile(robotsPath, robotsContent, "utf-8");
-  return { sitemapPath, robotsPath };
-}
-function escapeXml(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-}
-
-// src/vite/virtual-entries.ts
-import fs4 from "node:fs";
-import path5 from "node:path";
-var VIRTUAL_CLIENT_ID = "virtual:ssg-client";
-var RESOLVED_VIRTUAL_CLIENT_ID = "\0" + VIRTUAL_CLIENT_ID + ".tsx";
-var SSG_CLIENT_ENTRY_PATH = "/@ssg/client.tsx";
-var VIRTUAL_SERVER_ID = "virtual:ssg-server";
-var RESOLVED_VIRTUAL_SERVER_ID = "\0" + VIRTUAL_SERVER_ID + ".tsx";
-var VIRTUAL_HTML_ID = "virtual:ssg-html";
-var RESOLVED_VIRTUAL_HTML_ID = "\0" + VIRTUAL_HTML_ID;
-function detectCustomEntries(root, config) {
-  const clientPaths = [
-    "src/main.tsx",
-    "src/main.ts",
-    "src/entry-client.tsx",
-    "src/entry-client.ts",
-    "src/entry.tsx",
-    "src/entry.ts"
-  ];
-  const serverPaths = [
-    "src/entry-server.tsx",
-    "src/entry-server.ts"
-  ];
-  const htmlPaths = [
-    "index.html"
-  ];
-  const cssPaths = [
-    "src/styles/global.css",
-    "src/styles/main.css",
-    "src/styles/index.css",
-    "src/style.css",
-    "src/global.css",
-    "src/index.css"
-  ];
-  let customClientPath;
-  let customServerPath;
-  let customHtmlPath;
-  let globalCssPath;
-  for (const p of clientPaths) {
-    const fullPath = path5.join(root, p);
-    if (fs4.existsSync(fullPath)) {
-      customClientPath = fullPath;
-      break;
-    }
-  }
-  for (const p of serverPaths) {
-    const fullPath = path5.join(root, p);
-    if (fs4.existsSync(fullPath)) {
-      customServerPath = fullPath;
-      break;
-    }
-  }
-  for (const p of htmlPaths) {
-    const fullPath = path5.join(root, p);
-    if (fs4.existsSync(fullPath)) {
-      customHtmlPath = fullPath;
-      break;
-    }
-  }
-  for (const p of cssPaths) {
-    const fullPath = path5.join(root, p);
-    if (fs4.existsSync(fullPath)) {
-      globalCssPath = "/" + p.replace(/\\/g, "/");
-      break;
-    }
-  }
-  return {
-    useVirtualClient: !customClientPath,
-    useVirtualServer: !customServerPath,
-    useVirtualHtml: !customHtmlPath,
-    customClientPath,
-    customServerPath,
-    customHtmlPath,
-    globalCssPath
-  };
-}
-function generateClientEntry(config, detection) {
-  const cssImport = detection.globalCssPath ? `import '${detection.globalCssPath}';
-` : "";
-  const additionalImports = (config.clientImports ?? []).map((imp) => `import '${imp}';`).join("\n");
-  const additionalImportsBlock = additionalImports ? `
-${additionalImports}
-` : "";
-  const prefetchDelay = typeof config.prefetch === "object" ? config.prefetch.delay ?? 100 : 100;
-  const prefetchEnabled = config.prefetch !== false;
-  return `/**
- * Auto-generated client entry point
- * This file is generated by @sigx/ssg when no custom entry is detected.
- * To customize, create src/main.tsx or src/entry-client.tsx
- */
-${cssImport}${additionalImportsBlock}
-import { defineApp, component } from 'sigx';
-import { createRouter, createWebHistory } from '@sigx/router';
-import { ssrClientPlugin } from '@sigx/ssg/client';
-import routes from 'virtual:ssg-routes';
-import { setupLayouts, LayoutRouter } from 'virtual:generated-layouts';
-${prefetchEnabled ? `import { setupPrefetch } from '@sigx/ssg/client';` : ""}
-
-// Apply layouts to routes (annotates routes with layout info)
-const layoutRoutes = setupLayouts(routes);
-
-// Create router with browser history
-const router = createRouter({
-    history: createWebHistory('${config.base || "/"}'),
-    routes: layoutRoutes,
-    scrollBehavior(to, from, savedPosition) {
-        if (savedPosition) return savedPosition;
-        if (to.hash) return { el: to.hash };
-        return { top: 0 };
-    },
-});
-
-// Root app component - uses LayoutRouter which preserves layouts across navigation
-const App = component(() => {
-    return () => <LayoutRouter />;
-});
-
-// Hydrate the server-rendered HTML
-defineApp(<App />)
-    .use(router)
-    .use(ssrClientPlugin)
-    .hydrate('#app');
-
-${prefetchEnabled ? `// Enable link prefetching for faster navigation
-setupPrefetch({ delay: ${prefetchDelay} });` : ""}
-`;
-}
-function generateServerEntry(config) {
-  return `/**
- * Auto-generated server entry point
- * This file is generated by @sigx/ssg when no custom entry is detected.
- * To customize, create src/entry-server.tsx
- */
-import { renderToString } from '@sigx/server-renderer/server';
-import { defineApp } from 'sigx';
-import { createRouter, createMemoryHistory } from '@sigx/router';
-import routes from 'virtual:ssg-routes';
-import { setupLayouts, LayoutRouter } from 'virtual:generated-layouts';
-
-// Pre-process routes with layouts once at module load time (not per-render)
-const routesWithLayouts = setupLayouts(routes);
-
-/**
- * Render the app to HTML string for a given URL
- */
-export async function render(url, context) {
-    // Create router with memory history for SSR
-    // Note: We must create a new router per render because history is URL-specific
-    const router = createRouter({
-        routes: routesWithLayouts,
-        history: createMemoryHistory({ initialLocation: url || '/' }),
-    });
-
-    // Create app with router - router's install() sets up DI via app.defineProvide()
-    const app = defineApp(<LayoutRouter />).use(router);
-    
-    const html = await renderToString(app);
-    return html;
-}
-`;
-}
-function generateHtmlTemplate(config) {
-  const site = config.site || {};
-  const lang = site.lang || "en";
-  const title = site.title || "SignalX App";
-  const description = site.description || "";
-  const favicon = site.favicon || "/favicon.ico";
-  const themeColor = site.themeColor || "#000000";
-  const ogImage = site.ogImage || "";
-  const url = site.url || "";
-  const twitter = site.twitter || "";
-  const fonts = site.fonts || [];
-  let fontLinks = "";
-  if (fonts.length > 0) {
-    fontLinks = `
-    <link rel="preconnect" href="https://fonts.googleapis.com" />
-    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
-    <link href="https://fonts.googleapis.com/css2?family=${fonts.join("&family=")}&display=swap" rel="stylesheet" />`;
-  }
-  let ogTags = "";
-  if (url || ogImage) {
-    ogTags = `
-    <!-- Open Graph -->
-    <meta property="og:type" content="website" />
-    <meta property="og:title" content="${title}" />
-    <meta property="og:description" content="${description}" />${url ? `
-    <meta property="og:url" content="${url}" />` : ""}${ogImage ? `
-    <meta property="og:image" content="${ogImage}" />` : ""}`;
-  }
-  let twitterTags = "";
-  if (twitter || ogImage) {
-    twitterTags = `
-    <!-- Twitter Card -->
-    <meta name="twitter:card" content="${ogImage ? "summary_large_image" : "summary"}" />${twitter ? `
-    <meta name="twitter:site" content="@${twitter}" />` : ""}
-    <meta name="twitter:title" content="${title}" />
-    <meta name="twitter:description" content="${description}" />${ogImage ? `
-    <meta name="twitter:image" content="${ogImage}" />` : ""}`;
-  }
-  return `<!DOCTYPE html>
-<html lang="${lang}">
-<head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <meta name="description" content="${description}" />
-    <meta name="theme-color" content="${themeColor}" />
-    <link rel="icon" type="image/x-icon" href="${favicon}" />${fontLinks}${ogTags}${twitterTags}
-    <title>${title}</title>
-    <!--head-tags-->
-</head>
-<body>
-    <div id="app"><!--app-html--></div>
-    <script type="module" src="/@ssg/client.tsx"></script>
-</body>
-</html>
-`;
-}
-function generateProductionHtmlTemplate(config, clientEntryPath) {
-  const site = config.site || {};
-  const lang = site.lang || "en";
-  const title = site.title || "SignalX App";
-  const description = site.description || "";
-  const favicon = site.favicon || "/favicon.ico";
-  const themeColor = site.themeColor || "#000000";
-  const ogImage = site.ogImage || "";
-  const url = site.url || "";
-  const twitter = site.twitter || "";
-  const fonts = site.fonts || [];
-  let fontLinks = "";
-  if (fonts.length > 0) {
-    fontLinks = `
-    <link rel="preconnect" href="https://fonts.googleapis.com" />
-    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
-    <link href="https://fonts.googleapis.com/css2?family=${fonts.join("&family=")}&display=swap" rel="stylesheet" />`;
-  }
-  let ogTags = "";
-  if (url || ogImage) {
-    ogTags = `
-    <!-- Open Graph -->
-    <meta property="og:type" content="website" />
-    <meta property="og:title" content="${title}" />
-    <meta property="og:description" content="${description}" />${url ? `
-    <meta property="og:url" content="${url}" />` : ""}${ogImage ? `
-    <meta property="og:image" content="${ogImage}" />` : ""}`;
-  }
-  let twitterTags = "";
-  if (twitter || ogImage) {
-    twitterTags = `
-    <!-- Twitter Card -->
-    <meta name="twitter:card" content="${ogImage ? "summary_large_image" : "summary"}" />${twitter ? `
-    <meta name="twitter:site" content="@${twitter}" />` : ""}
-    <meta name="twitter:title" content="${title}" />
-    <meta name="twitter:description" content="${description}" />${ogImage ? `
-    <meta name="twitter:image" content="${ogImage}" />` : ""}`;
-  }
-  return `<!DOCTYPE html>
-<html lang="${lang}">
-<head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <meta name="description" content="${description}" />
-    <meta name="theme-color" content="${themeColor}" />
-    <link rel="icon" type="image/x-icon" href="${favicon}" />${fontLinks}${ogTags}${twitterTags}
-    <title>${title}</title>
-    <!--head-tags-->
-</head>
-<body>
-    <div id="app"><!--app-html--></div>
-    <script type="module" src="${clientEntryPath}"></script>
-</body>
-</html>
-`;
-}
-
-// src/build.ts
-async function build(options = {}) {
-  const startTime = Date.now();
-  const root = process.cwd();
-  const warnings = [];
-  const pages = [];
-  console.log("\n\u{1F680} @sigx/ssg - Building static site...\n");
-  console.log("\u{1F4E6} Loading configuration...");
-  const config = await loadConfig(options.configPath);
-  const resolvedConfig = resolveConfigPaths(config, root);
-  console.log("\u{1F50D} Scanning pages...");
-  const routes = await scanPages(resolvedConfig, root);
-  console.log(`   Found ${routes.length} page(s)`);
-  console.log("\u{1F4D0} Discovering layouts...");
-  const layouts = await discoverLayouts(resolvedConfig, root);
-  console.log(`   Found ${layouts.length} layout(s)`);
-  const entryDetection = detectCustomEntries(root, resolvedConfig);
-  if (entryDetection.useVirtualClient || entryDetection.useVirtualServer) {
-    console.log("\u{1F4E6} Using zero-config mode");
-    if (entryDetection.useVirtualClient) console.log("   \u2192 Virtual client entry");
-    if (entryDetection.useVirtualServer) console.log("   \u2192 Virtual server entry");
-    if (entryDetection.useVirtualHtml) console.log("   \u2192 Virtual HTML template");
-  }
-  const clientEntry = await getClientEntryPoint(resolvedConfig, root);
-  const ssrEntry = await getSSREntryPoint(resolvedConfig, root);
-  const htmlTemplatePath = path6.join(root, "index.html");
-  let cleanupHtml = false;
-  let originalHtmlContent = null;
-  if (!entryDetection.useVirtualHtml && fsSync.existsSync(htmlTemplatePath)) {
-    originalHtmlContent = fsSync.readFileSync(htmlTemplatePath, "utf-8");
-  }
-  const htmlContent = await getHtmlTemplate(resolvedConfig, root, clientEntry);
-  fsSync.writeFileSync(htmlTemplatePath, htmlContent, "utf-8");
-  cleanupHtml = entryDetection.useVirtualHtml;
-  console.log("\u{1F528} Building with Vite...");
-  const vite = await import("vite");
-  try {
-    const clientInput = htmlTemplatePath;
-    await vite.build({
-      root,
-      mode: "production",
-      build: {
-        outDir: resolvedConfig.outDir,
-        emptyOutDir: false,
-        ssrManifest: true,
-        rollupOptions: {
-          input: clientInput
-        }
-      },
-      logLevel: options.verbose ? "info" : "warn"
-    });
-    const ssrOutDir = path6.join(resolvedConfig.outDir, ".ssg");
-    await vite.build({
-      root,
-      mode: "production",
-      build: {
-        outDir: ssrOutDir,
-        ssr: true,
-        rollupOptions: {
-          input: ssrEntry
-        }
-      },
-      logLevel: options.verbose ? "info" : "warn"
-    });
-    console.log("\u{1F4DD} Collecting paths to render...");
-    const pathsToRender = await collectPaths(routes, root, warnings);
-    console.log(`   ${pathsToRender.length} path(s) to render`);
-    const outputDirs = /* @__PURE__ */ new Set();
-    for (const pathInfo of pathsToRender) {
-      const outputPath = getOutputPath(pathInfo.path, resolvedConfig.outDir);
-      outputDirs.add(path6.dirname(outputPath));
-    }
-    await Promise.all(
-      Array.from(outputDirs).map((dir) => fs5.mkdir(dir, { recursive: true }))
-    );
-    console.log("\u{1F3A8} Rendering pages...");
-    const ssrEntryBasename = path6.basename(ssrEntry, path6.extname(ssrEntry));
-    const ssrEntryName = ssrEntryBasename + ".js";
-    const entryPath = path6.join(ssrOutDir, ssrEntryName);
-    const entryModule = await import(pathToFileURL(entryPath).href);
-    const templatePath = path6.join(resolvedConfig.outDir, "index.html");
-    const template = await fs5.readFile(templatePath, "utf-8");
-    const CONCURRENCY = options.concurrency ?? 20;
-    const verbose2 = options.verbose ?? false;
-    async function renderPage(pathInfo) {
-      const renderStart = Date.now();
-      try {
-        const appHtml = await entryModule.render(pathInfo.path, {
-          params: pathInfo.params,
-          props: pathInfo.props
-        });
-        let html = template.replace("<!--app-html-->", appHtml);
-        const headTags = generateHeadTags(pathInfo, resolvedConfig);
-        html = html.replace("<!--head-tags-->", headTags);
-        const outputPath = getOutputPath(pathInfo.path, resolvedConfig.outDir);
-        const renderTime = Date.now() - renderStart;
-        return { pathInfo, html, outputPath, renderTime };
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        console.error(`   \u274C ${pathInfo.path}: ${errorMessage}`);
-        warnings.push(`Failed to render ${pathInfo.path}: ${errorMessage}`);
-        return null;
-      }
-    }
-    console.log("   Phase 1: Rendering...");
-    const renderPhaseStart = Date.now();
-    const renderResults = [];
-    for (let i = 0; i < pathsToRender.length; i += CONCURRENCY) {
-      const batch = pathsToRender.slice(i, i + CONCURRENCY);
-      const results = await Promise.all(batch.map(renderPage));
-      for (const result of results) {
-        if (result) {
-          renderResults.push(result);
-        }
-      }
-    }
-    const renderPhaseDuration = Date.now() - renderPhaseStart;
-    console.log(`   Phase 1 complete: ${renderResults.length} pages in ${renderPhaseDuration}ms (${Math.round(renderPhaseDuration / renderResults.length)}ms avg)`);
-    console.log("   Phase 2: Writing files...");
-    const writePhaseStart = Date.now();
-    const WRITE_CONCURRENCY = 10;
-    for (let i = 0; i < renderResults.length; i += WRITE_CONCURRENCY) {
-      const batch = renderResults.slice(i, i + WRITE_CONCURRENCY);
-      await Promise.all(batch.map(async (result) => {
-        await fs5.writeFile(result.outputPath, result.html, "utf-8");
-        const size = Buffer.byteLength(result.html, "utf-8");
-        pages.push({
-          path: result.pathInfo.path,
-          file: result.outputPath,
-          time: result.renderTime,
-          size
-        });
-        if (verbose2) {
-          console.log(`   \u2713 ${result.pathInfo.path} (${result.renderTime}ms, ${formatBytes(size)})`);
-        }
-      }));
-    }
-    const writePhaseDuration = Date.now() - writePhaseStart;
-    console.log(`   Phase 2 complete: ${renderResults.length} files in ${writePhaseDuration}ms`);
-    if (!verbose2) {
-      console.log(`   \u2713 Rendered ${renderResults.length} pages`);
-    }
-    await fs5.rm(ssrOutDir, { recursive: true, force: true });
-    if (pages.length > 0) {
-      console.log("\u{1F5FA}\uFE0F  Generating sitemap...");
-      await writeSitemap(pages, resolvedConfig, resolvedConfig.outDir);
-      console.log("   \u2713 sitemap.xml");
-      console.log("   \u2713 robots.txt");
-    }
-  } finally {
-    await cleanupTempEntries(root);
-    if (cleanupHtml) {
-      try {
-        await fs5.unlink(htmlTemplatePath);
-      } catch {
-      }
-    } else if (originalHtmlContent !== null) {
-      try {
-        await fs5.writeFile(htmlTemplatePath, originalHtmlContent, "utf-8");
-      } catch {
-      }
-    }
-  }
-  const totalTime = Date.now() - startTime;
-  console.log(`
-\u2705 Built ${pages.length} page(s) in ${totalTime}ms`);
-  if (warnings.length > 0) {
-    console.log(`
-\u26A0\uFE0F  ${warnings.length} warning(s):`);
-    for (const warning of warnings) {
-      console.log(`   - ${warning}`);
-    }
-  }
-  console.log(`
-\u{1F4C1} Output: ${resolvedConfig.outDir}
-`);
-  return {
-    pages,
-    totalTime,
-    warnings
-  };
-}
-async function collectPaths(routes, root, warnings) {
-  const paths = [];
-  for (const route of routes) {
-    if (isDynamicRoute(route)) {
-      try {
-        const moduleUrl = pathToFileURL(route.file).href;
-        const pageModule = await import(moduleUrl);
-        if (!pageModule.getStaticPaths) {
-          const params = extractParams(route.path).join(", ");
-          console.warn(
-            `
-\u26A0\uFE0F  SSG102: Dynamic route missing getStaticPaths()
-   \u{1F4C1} ${route.file}
-   Route: ${route.path} (params: ${params})
-   \u{1F4A1} Export getStaticPaths() to generate static pages:
-
-      export async function getStaticPaths() {
-          return [{ params: { ${params.split(", ")[0]}: 'value' } }];
-      }
-`
-          );
-          warnings.push(
-            `Route ${route.path} has dynamic segments [${params}] but no getStaticPaths() export. Skipping.`
-          );
-          continue;
-        }
-        const staticPaths = await pageModule.getStaticPaths();
-        for (const staticPath of staticPaths) {
-          const expandedPaths = expandDynamicRoute(route, [staticPath]);
-          for (const expandedPath of expandedPaths) {
-            paths.push({
-              path: expandedPath,
-              route,
-              params: staticPath.params,
-              props: staticPath.props
-            });
-          }
-        }
-      } catch (err) {
-        warnings.push(`Failed to load ${route.file}: ${err}`);
-      }
-    } else {
-      paths.push({
-        path: route.path,
-        route,
-        params: {}
-      });
-    }
-  }
-  return paths;
-}
-function generateHeadTags(pathInfo, config) {
-  const tags = [];
-  const meta = pathInfo.route.meta || {};
-  const title = meta.title || config.site?.title;
-  if (title) {
-    tags.push(`<title>${escapeHtml(title)}</title>`);
-  }
-  const description = meta.description || config.site?.description;
-  if (description) {
-    tags.push(`<meta name="description" content="${escapeHtml(description)}">`);
-  }
-  if (config.site?.url) {
-    const canonical = new URL(pathInfo.path, config.site.url).href;
-    tags.push(`<link rel="canonical" href="${canonical}">`);
-  }
-  return tags.join("\n    ");
-}
-function getOutputPath(urlPath, outDir) {
-  let normalized = urlPath.replace(/^\//, "").replace(/\/$/, "");
-  if (!normalized) {
-    normalized = "index";
-  }
-  if (!normalized.endsWith(".html")) {
-    normalized = path6.join(normalized, "index.html");
-  }
-  return path6.join(outDir, normalized);
-}
-async function getSSREntryPoint(config, root) {
-  const detection = detectCustomEntries(root, config);
-  if (!detection.useVirtualServer && detection.customServerPath) {
-    return detection.customServerPath;
-  }
-  const virtualServerCode = generateServerEntry(config);
-  const tempServerPath = path6.join(root, ".ssg-temp-entry-server.tsx");
-  fsSync.writeFileSync(tempServerPath, virtualServerCode, "utf-8");
-  return tempServerPath;
-}
-async function getClientEntryPoint(config, root) {
-  const detection = detectCustomEntries(root, config);
-  if (!detection.useVirtualClient && detection.customClientPath) {
-    return detection.customClientPath;
-  }
-  const virtualClientCode = generateClientEntry(config, detection);
-  const tempClientPath = path6.join(root, ".ssg-temp-entry-client.tsx");
-  fsSync.writeFileSync(tempClientPath, virtualClientCode, "utf-8");
-  return tempClientPath;
-}
-async function cleanupTempEntries(root) {
-  const tempFiles = [
-    path6.join(root, ".ssg-temp-entry-server.tsx"),
-    path6.join(root, ".ssg-temp-entry-client.tsx")
-  ];
-  for (const file of tempFiles) {
-    try {
-      await fs5.unlink(file);
-    } catch {
-    }
-  }
-}
-async function getHtmlTemplate(config, root, clientEntryPath) {
-  const detection = detectCustomEntries(root, config);
-  if (!detection.useVirtualHtml && detection.customHtmlPath) {
-    let html = await fs5.readFile(detection.customHtmlPath, "utf-8");
-    const relativePath = "./" + path6.relative(root, clientEntryPath).replace(/\\/g, "/");
-    html = html.replace(
-      /<script([^>]*)\s+src=["']?\/@ssg\/client\.tsx["']?/g,
-      `<script$1 src="${relativePath}"`
-    );
-    return html;
-  }
-  return generateProductionHtmlTemplate(config, clientEntryPath);
-}
-function formatBytes(bytes) {
-  if (bytes < 1024) return `${bytes}B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-}
-function escapeHtml(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
-}
-
-// src/dev.ts
-import path8 from "node:path";
-import fs7 from "node:fs";
-
-// src/vite/plugin.ts
-import path7 from "node:path";
-import fs6 from "node:fs";
-
-// src/mdx/shiki.ts
-import { createHighlighter } from "shiki";
-var highlighterPromise = null;
-var DEFAULT_CONFIG = {
-  light: "github-light",
-  dark: "github-dark",
-  langs: ["javascript", "typescript", "jsx", "tsx", "json", "css", "html", "markdown", "bash", "shell"]
-};
-async function getHighlighter(config) {
-  if (!highlighterPromise) {
-    const mergedConfig = { ...DEFAULT_CONFIG, ...config };
-    highlighterPromise = createHighlighter({
-      themes: [mergedConfig.light, mergedConfig.dark],
-      langs: mergedConfig.langs
-    });
-  }
-  return highlighterPromise;
-}
-async function highlightCode(code, lang, config, meta) {
-  const highlighter = await getHighlighter(config);
-  const mergedConfig = { ...DEFAULT_CONFIG, ...config };
-  const loadedLangs = highlighter.getLoadedLanguages();
-  const effectiveLang = loadedLangs.includes(lang) ? lang : "text";
-  const codeHtml = highlighter.codeToHtml(code, {
-    lang: effectiveLang,
-    themes: {
-      light: mergedConfig.light,
-      dark: mergedConfig.dark
-    }
-  });
-  const filename = meta?.filename ?? "";
-  const isLive = meta?.live ?? false;
-  const tabs = meta?.tabs;
-  const hasTabs = tabs && tabs.length > 0;
-  const filenameHtml = filename ? `<span class="code-window-filename">${escapeHtml2(filename)}</span>` : `<span class="code-window-lang">${getLanguageLabel(effectiveLang)}</span>`;
-  if (hasTabs) {
-    const base64Code = encodeBase64(code);
-    const firstTab = tabs[0];
-    const tabButtonsHtml = tabs.map((tab, i) => {
-      const label = tab.charAt(0).toUpperCase() + tab.slice(1);
-      const isActive = i === 0;
-      return `<button class="code-window-tab${isActive ? " code-window-tab-active" : ""}">${label}</button>`;
-    }).join("\n                ");
-    const html2 = `<div 
-    class="live-preview-island" 
-    data-island="LivePreview" 
-    data-island-strategy="visible"
-    data-island-props="${escapeHtml2(JSON.stringify({
-      code: base64Code,
-      highlightedCode: codeHtml,
-      language: effectiveLang,
-      filename,
-      tabs,
-      live: isLive
-    }))}"
->
-    <div class="code-window code-window-live code-window-preview">
-        <div class="code-window-header">
-            <div class="code-window-header-left">
-                <div class="code-window-dots">
-                    <span class="code-window-dot dot-red"></span>
-                    <span class="code-window-dot dot-yellow"></span>
-                    <span class="code-window-dot dot-green"></span>
-                </div>
-                ${filenameHtml}
-            </div>
-            <div class="code-window-tabs">
-                ${tabButtonsHtml}
-            </div>
-            <button class="code-window-try-live" disabled>\u26A1 Try Live</button>
-        </div>
-        <div class="code-window-preview-pane"${firstTab !== "preview" ? ' style="display:none;"' : ""}>
-            <div class="code-window-preview-loading">
-                <span class="code-window-spinner"></span>
-                Loading preview...
-            </div>
-        </div>
-        <div class="code-window-console-pane"${firstTab !== "console" ? ' style="display:none;"' : ""}>
-            <div class="code-window-console-empty">No console output</div>
-        </div>
-        <div class="code-window-content"${firstTab !== "code" ? ' style="display:none;"' : ""}>
-            ${codeHtml}
-        </div>
-    </div>
-</div>`;
-    return html2;
-  }
-  const tryLiveButton = isLive ? `<button class="code-window-try-live" data-live-code="${escapeHtml2(encodeBase64(code))}" data-lang="${effectiveLang}" data-filename="${escapeHtml2(filename)}" title="Open in Live Playground">\u26A1 Try Live</button>` : "";
-  const html = `<div class="code-window${isLive ? " code-window-live" : ""}">
-        <div class="code-window-header">
-            <div class="code-window-header-left">
-                <div class="code-window-dots">
-                    <span class="code-window-dot dot-red"></span>
-                    <span class="code-window-dot dot-yellow"></span>
-                    <span class="code-window-dot dot-green"></span>
-                </div>
-                ${filenameHtml}
-            </div>
-            ${tryLiveButton}
-        </div>
-        <div class="code-window-content">
-            ${codeHtml}
-        </div>
-    </div>`;
-  return html;
-}
-function encodeBase64(str) {
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(str, "utf-8").toString("base64");
-  }
-  return btoa(unescape(encodeURIComponent(str)));
-}
-function getLanguageLabel(lang) {
-  const labels = {
-    "tsx": "TSX",
-    "jsx": "JSX",
-    "ts": "TypeScript",
-    "typescript": "TypeScript",
-    "js": "JavaScript",
-    "javascript": "JavaScript",
-    "css": "CSS",
-    "html": "HTML",
-    "json": "JSON",
-    "bash": "Terminal",
-    "shell": "Terminal",
-    "sh": "Terminal",
-    "md": "Markdown",
-    "markdown": "Markdown",
-    "python": "Python",
-    "py": "Python",
-    "rust": "Rust",
-    "go": "Go",
-    "text": ""
-  };
-  return labels[lang.toLowerCase()] ?? lang.toUpperCase();
-}
-function escapeHtml2(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
-}
-function rehypeShiki(config) {
-  return async (tree) => {
-    const { visit: visit2 } = await import("unist-util-visit");
-    const { fromHtml } = await import("hast-util-from-html");
-    const nodesToProcess = [];
-    visit2(tree, "element", (node, index, parent) => {
-      if (node.tagName === "pre" && node.children?.[0]?.tagName === "code") {
-        nodesToProcess.push({ node, parent, index: index ?? 0 });
-      }
-    });
-    await Promise.all(
-      nodesToProcess.map(async ({ node, parent, index }) => {
-        const codeNode = node.children[0];
-        const className = codeNode.properties?.className?.[0] || "";
-        const lang = className.replace(/^language-/, "") || "text";
-        const metaString = codeNode.data?.meta || codeNode.properties?.metastring || "";
-        const filename = extractMeta(metaString, "filename") || extractMeta(metaString, "title") || "";
-        const isLive = /\blive\b/i.test(metaString);
-        const tabKeywords = ["preview", "code", "console"];
-        const tabs = [];
-        const tabPositions = [];
-        for (const keyword of tabKeywords) {
-          const regex = new RegExp(`\\b${keyword}\\b`, "i");
-          const match = metaString.match(regex);
-          if (match && match.index !== void 0) {
-            tabPositions.push({ tab: keyword, index: match.index });
-          }
-        }
-        tabPositions.sort((a, b) => a.index - b.index);
-        for (const { tab } of tabPositions) {
-          tabs.push(tab);
-        }
-        const code = getTextContent(codeNode);
-        const html = await highlightCode(code.trim(), lang, config, {
-          filename,
-          live: isLive,
-          tabs: tabs.length > 0 ? tabs : void 0
-        });
-        const fragment = fromHtml(html, { fragment: true });
-        if (parent && typeof index === "number" && fragment.children.length > 0) {
-          parent.children[index] = fragment.children[0];
-        }
-      })
-    );
-  };
-}
-function extractMeta(metaString, key) {
-  if (!metaString) return null;
-  const regex = new RegExp(`${key}=["']?([^"'\\s]+)["']?`, "i");
-  const match = metaString.match(regex);
-  return match ? match[1] : null;
-}
-function getTextContent(node) {
-  if (node.type === "text") {
-    return node.value;
-  }
-  if (node.children) {
-    return node.children.map(getTextContent).join("");
-  }
-  return "";
-}
-
-// src/mdx/rehype-headings.ts
-import { visit } from "unist-util-visit";
-import { toString } from "hast-util-to-string";
-function rehypeExtractHeadings(options = {}) {
-  const { minLevel = 2, maxLevel = 3 } = options;
-  return (tree, file) => {
-    const headings = [];
-    visit(tree, "element", (node) => {
-      const match = /^h([1-6])$/.exec(node.tagName);
-      if (!match) return;
-      const level = parseInt(match[1], 10);
-      if (level < minLevel || level > maxLevel) return;
-      const id = node.properties?.id;
-      if (!id) return;
-      const text = toString(node).trim();
-      if (!text) return;
-      headings.push({ id, text, level });
-    });
-    file.data = file.data || {};
-    file.data.headings = headings;
-  };
-}
-
-// src/mdx/plugin.ts
-function mdxPlugin(options = {}) {
-  const { markdown = {} } = options;
-  let mdxRollup;
-  let viteConfig;
-  return {
-    name: "sigx-ssg-mdx",
-    enforce: "pre",
-    async configResolved(config) {
-      viteConfig = config;
-      const mdxModule = await import("@mdx-js/rollup");
-      const remarkFrontmatter = (await import("remark-frontmatter")).default;
-      const remarkMdxFrontmatter = (await import("remark-mdx-frontmatter")).default;
-      const remarkGfm = (await import("remark-gfm")).default;
-      const rehypeSlug = (await import("rehype-slug")).default;
-      const rehypeAutolinkHeadings = (await import("rehype-autolink-headings")).default;
-      const tocConfig = options.ssgConfig?.toc || { minLevel: 2, maxLevel: 3 };
-      const rehypePlugins = [];
-      rehypePlugins.push(rehypeSlug);
-      rehypePlugins.push([rehypeAutolinkHeadings, {
-        behavior: "append",
-        properties: {
-          class: "heading-anchor",
-          ariaHidden: true,
-          tabIndex: -1
-        },
-        content: {
-          type: "element",
-          tagName: "span",
-          properties: { class: "heading-anchor-icon" },
-          children: [{ type: "text", value: "#" }]
-        }
-      }]);
-      rehypePlugins.push([rehypeExtractHeadings, tocConfig]);
-      if (markdown.shiki !== false) {
-        const shikiConfig = typeof markdown.shiki === "object" ? markdown.shiki : void 0;
-        rehypePlugins.push([rehypeShiki, shikiConfig]);
-      }
-      if (markdown.rehypePlugins) {
-        rehypePlugins.push(...markdown.rehypePlugins);
-      }
-      const remarkPlugins = [
-        remarkFrontmatter,
-        [remarkMdxFrontmatter, { name: "frontmatter" }],
-        remarkGfm
-      ];
-      if (markdown.remarkPlugins) {
-        remarkPlugins.push(...markdown.remarkPlugins);
-      }
-      mdxRollup = mdxModule.default({
-        jsx: false,
-        jsxImportSource: "sigx",
-        remarkPlugins,
-        rehypePlugins,
-        providerImportSource: void 0
-      });
-    },
-    async transform(code, id) {
-      if (!/\.mdx?$/.test(id)) {
-        return null;
-      }
-      const { data: frontmatter, content } = parseFrontmatter(code);
-      if (!frontmatter.title) {
-        const extractedTitle = extractTitleFromContent(content);
-        if (extractedTitle) {
-          frontmatter.title = extractedTitle;
-        }
-      }
-      if (!mdxRollup?.transform) {
-        throw new Error("MDX plugin not initialized");
-      }
-      const result = await mdxRollup.transform(code, id);
-      if (!result) {
-        return null;
-      }
-      const headings = await extractHeadingsFromContent(content, options);
-      const moduleId = id.replace(/\\/g, "/");
-      const transformedCode = wrapMDXComponent(
-        result.code,
-        frontmatter,
-        headings,
-        moduleId,
-        viteConfig.command === "serve"
-      );
-      return {
-        code: transformedCode,
-        map: result.map
-      };
-    }
-  };
-}
-function wrapMDXComponent(code, frontmatter, headings, moduleId, isDev) {
-  if (isDev) {
-    const fileName = moduleId.split("/").pop()?.replace(/\.mdx?$/, "") || "MDXPage";
-    const componentName = fileName.charAt(0).toUpperCase() + fileName.slice(1).replace(/[^a-zA-Z0-9]/g, "") + "Page";
-    const modifiedCode = code.replace(/export\s+default\s+function\s+MDXContent/g, "function _MDXContent").replace(/export\s+{\s*MDXContent\s+as\s+default\s*}/g, "");
-    return `
-import { registerHMRModule } from '@sigx/vite/hmr';
-import { component as __component } from 'sigx';
-registerHMRModule('${moduleId}');
-
-${modifiedCode}
-
-// Export layout from frontmatter for SSG routing
-export const layout = ${frontmatter.layout ? JSON.stringify(frontmatter.layout) : "undefined"};
-
-// Export headings for table of contents
-export const headings = ${JSON.stringify(headings)};
-
-// Wrap MDXContent in a sigx component for HMR support
-const MDXPage = __component(() => {
-    return () => _MDXContent({});
-}, { name: '${componentName}' });
-
-export default MDXPage;
-
-if (import.meta.hot) {
-    // Accept HMR updates with a callback to trigger re-render after module is updated
-    import.meta.hot.accept((newModule) => {
-        if (newModule) {
-            // Notify LayoutRouter to clear its cache and re-render with new module
-            window.dispatchEvent(new CustomEvent('sigx:mdx-hmr', { 
-                detail: { moduleId: '${moduleId}', newModule } 
-            }));
-        }
-    });
-}
-`;
-  }
-  return `
-${code}
-
-// Export layout from frontmatter for SSG routing
-export const layout = ${frontmatter.layout ? JSON.stringify(frontmatter.layout) : "undefined"};
-
-// Export headings for table of contents
-export const headings = ${JSON.stringify(headings)};
-`;
-}
-async function extractHeadingsFromContent(content, options) {
-  const { unified } = await import("unified");
-  const remarkParse = (await import("remark-parse")).default;
-  const remarkRehype = (await import("remark-rehype")).default;
-  const rehypeSlug = (await import("rehype-slug")).default;
-  const rehypeStringify = (await import("rehype-stringify")).default;
-  const tocConfig = options.ssgConfig?.toc || { minLevel: 2, maxLevel: 3 };
-  const processor = unified().use(remarkParse).use(remarkRehype).use(rehypeSlug).use(rehypeExtractHeadings, tocConfig).use(rehypeStringify);
-  const file = await processor.process(content);
-  return file.data.headings || [];
-}
-
-// src/vite/plugin.ts
-var VIRTUAL_CONFIG_ID = "virtual:ssg-config";
-var RESOLVED_VIRTUAL_CONFIG_ID = "\0" + VIRTUAL_CONFIG_ID;
-function ssgPlugin(options = {}) {
-  let config;
-  let ssgConfig;
-  let root;
-  let server;
-  let entryDetection;
-  let routesCache = null;
-  let layoutsCache = null;
-  let navigationCache = null;
-  const frontmatterHashCache = /* @__PURE__ */ new Map();
-  const mainPlugin = {
-    name: "sigx-ssg",
-    enforce: "pre",
-    async configResolved(resolvedConfig) {
-      config = resolvedConfig;
-      root = resolvedConfig.root;
-      const fileConfig = await loadConfig(options.configPath);
-      ssgConfig = defineSSGConfig({
-        ...fileConfig,
-        ...options
-      });
-      entryDetection = detectCustomEntries(root, ssgConfig);
-      if (entryDetection.useVirtualClient || entryDetection.useVirtualServer) {
-        console.log("\u{1F4E6} @sigx/ssg: Using zero-config mode");
-        if (entryDetection.useVirtualClient) {
-          console.log("   \u2192 Virtual client entry");
-        }
-        if (entryDetection.useVirtualServer) {
-          console.log("   \u2192 Virtual server entry");
-        }
-        if (entryDetection.globalCssPath) {
-          console.log(`   \u2192 Auto-importing ${entryDetection.globalCssPath}`);
-        }
-      }
-    },
-    configureServer(devServer) {
-      server = devServer;
-      const pagesDir = path7.resolve(root, ssgConfig.pages || "src/pages");
-      const layoutsDir = path7.resolve(root, ssgConfig.layouts || "src/layouts");
-      const contentDir = path7.resolve(root, ssgConfig.content || "src/content");
-      devServer.watcher.on("add", (file) => {
-        if (file.startsWith(pagesDir)) {
-          routesCache = null;
-          navigationCache = null;
-          invalidateModule(RESOLVED_VIRTUAL_ROUTES_ID);
-          invalidateModule(RESOLVED_VIRTUAL_NAVIGATION_ID);
-        } else if (file.startsWith(layoutsDir)) {
-          layoutsCache = null;
-          invalidateModule(RESOLVED_VIRTUAL_LAYOUTS_ID);
-        }
-      });
-      devServer.watcher.on("unlink", (file) => {
-        if (file.startsWith(pagesDir)) {
-          routesCache = null;
-          navigationCache = null;
-          frontmatterHashCache.delete(file);
-          invalidateModule(RESOLVED_VIRTUAL_ROUTES_ID);
-          invalidateModule(RESOLVED_VIRTUAL_NAVIGATION_ID);
-        } else if (file.startsWith(layoutsDir)) {
-          layoutsCache = null;
-          invalidateModule(RESOLVED_VIRTUAL_LAYOUTS_ID);
-        }
-      });
-      devServer.watcher.on("change", async (file) => {
-        if (!file.startsWith(pagesDir)) return;
-        if (!/\.mdx?$/.test(file)) return;
-        try {
-          const content = await fs6.promises.readFile(file, "utf-8");
-          const { data: newFrontmatter } = parseFrontmatter(content);
-          const newHash = JSON.stringify(newFrontmatter);
-          const oldHash = frontmatterHashCache.get(file);
-          frontmatterHashCache.set(file, newHash);
-          if (oldHash !== void 0 && oldHash !== newHash) {
-            navigationCache = null;
-            routesCache = null;
-            const navMod = devServer.moduleGraph.getModuleById(RESOLVED_VIRTUAL_NAVIGATION_ID);
-            if (navMod) {
-              devServer.moduleGraph.invalidateModule(navMod);
-            }
-            const routesMod = devServer.moduleGraph.getModuleById(RESOLVED_VIRTUAL_ROUTES_ID);
-            if (routesMod) {
-              devServer.moduleGraph.invalidateModule(routesMod);
-            }
-            devServer.ws.send({ type: "full-reload" });
-          }
-        } catch (err) {
-        }
-      });
-      function invalidateModule(id) {
-        const mod = devServer.moduleGraph.getModuleById(id);
-        if (mod) {
-          devServer.moduleGraph.invalidateModule(mod);
-          devServer.ws.send({ type: "full-reload" });
-        }
-      }
-      if (entryDetection.useVirtualHtml) {
-        devServer.middlewares.use((req, res, next) => {
-          if (req.url?.startsWith("/@") || req.url?.startsWith("/__") || req.url?.includes("virtual:") || req.url?.includes("node_modules") || req.url?.startsWith("/@vite") || req.url?.startsWith("/@fs")) {
-            return next();
-          }
-          if (req.url && (req.url === "/" || !req.url.includes("."))) {
-            const html = generateHtmlTemplate(ssgConfig);
-            devServer.transformIndexHtml(req.url, html).then((transformedHtml) => {
-              res.setHeader("Content-Type", "text/html");
-              res.end(transformedHtml);
-            }).catch(next);
-            return;
-          }
-          next();
-        });
-      }
-    },
-    resolveId(id) {
-      if (id === VIRTUAL_ROUTES_ID) {
-        return RESOLVED_VIRTUAL_ROUTES_ID;
-      }
-      if (id === VIRTUAL_LAYOUTS_ID) {
-        return RESOLVED_VIRTUAL_LAYOUTS_ID;
-      }
-      if (id === VIRTUAL_CONFIG_ID) {
-        return RESOLVED_VIRTUAL_CONFIG_ID;
-      }
-      if (id === VIRTUAL_NAVIGATION_ID) {
-        return RESOLVED_VIRTUAL_NAVIGATION_ID;
-      }
-      if (id === VIRTUAL_CLIENT_ID || id === SSG_CLIENT_ENTRY_PATH) {
-        return RESOLVED_VIRTUAL_CLIENT_ID;
-      }
-      if (id === VIRTUAL_SERVER_ID) {
-        return RESOLVED_VIRTUAL_SERVER_ID;
-      }
-      return null;
-    },
-    async load(id) {
-      if (id === RESOLVED_VIRTUAL_ROUTES_ID) {
-        if (!routesCache) {
-          const routes = await scanPages(ssgConfig, root);
-          const code = config.command === "serve" ? generateLazyRoutesModule(routes, ssgConfig) : generateRoutesModule(routes, ssgConfig);
-          routesCache = { routes, code };
-        }
-        return routesCache.code;
-      }
-      if (id === RESOLVED_VIRTUAL_LAYOUTS_ID) {
-        if (!layoutsCache) {
-          const layouts = await discoverLayouts(ssgConfig, root);
-          const code = generateLayoutsModule(layouts, ssgConfig);
-          layoutsCache = { layouts, code };
-        }
-        return layoutsCache.code;
-      }
-      if (id === RESOLVED_VIRTUAL_NAVIGATION_ID) {
-        if (!navigationCache) {
-          if (!routesCache) {
-            const routes = await scanPages(ssgConfig, root);
-            const routesCode = config.command === "serve" ? generateLazyRoutesModule(routes, ssgConfig) : generateRoutesModule(routes, ssgConfig);
-            routesCache = { routes, code: routesCode };
-          }
-          const isDev = config.command === "serve";
-          const code = generateNavigationModule(routesCache.routes, ssgConfig, isDev);
-          navigationCache = { code };
-        }
-        return navigationCache.code;
-      }
-      if (id === RESOLVED_VIRTUAL_CONFIG_ID) {
-        return `export default ${JSON.stringify(ssgConfig)};`;
-      }
-      if (id === RESOLVED_VIRTUAL_CLIENT_ID) {
-        const code = generateClientEntry(ssgConfig, entryDetection);
-        const esbuild = await import("esbuild");
-        const result = await esbuild.transform(code, {
-          loader: "tsx",
-          jsx: "automatic",
-          jsxImportSource: "sigx"
-        });
-        return result.code;
-      }
-      if (id === RESOLVED_VIRTUAL_SERVER_ID) {
-        const code = generateServerEntry(ssgConfig);
-        const esbuild = await import("esbuild");
-        const result = await esbuild.transform(code, {
-          loader: "tsx",
-          jsx: "automatic",
-          jsxImportSource: "sigx"
-        });
-        return result.code;
-      }
-      return null;
-    },
-    // Handle HMR for layouts and pages
-    async handleHotUpdate({ file, server: server2 }) {
-      const layoutsDir = path7.resolve(root, ssgConfig.layouts || "src/layouts");
-      const pagesDir = path7.resolve(root, ssgConfig.pages || "src/pages");
-      if (file.startsWith(layoutsDir)) {
-        layoutsCache = null;
-        const mod = server2.moduleGraph.getModuleById(RESOLVED_VIRTUAL_LAYOUTS_ID);
-        if (mod) {
-          server2.moduleGraph.invalidateModule(mod);
-        }
-        return [];
-      }
-      if (file.startsWith(pagesDir) && /\.mdx?$/.test(file)) {
-        return void 0;
-      }
-      return void 0;
-    }
-  };
-  const enableMdx = options.enableMdx !== false;
-  if (enableMdx) {
-    const mdx = mdxPlugin({
-      markdown: options.markdown,
-      ssgConfig: void 0
-      // Will be set by configResolved
-    });
-    return [mainPlugin, mdx];
-  }
-  return [mainPlugin];
-}
-
-// src/dev.ts
-async function dev(options = {}) {
-  const root = process.cwd();
-  console.log("\n\u{1F680} @sigx/ssg - Starting development server...\n");
-  const ssgConfig = await loadConfig(options.configPath);
-  const hasViteConfig = fs7.existsSync(path8.join(root, "vite.config.ts")) || fs7.existsSync(path8.join(root, "vite.config.js")) || fs7.existsSync(path8.join(root, "vite.config.mjs"));
-  const vite = await import("vite");
-  if (hasViteConfig) {
-    console.log("\u{1F4E6} Using existing vite.config\n");
-    const server = await vite.createServer({
-      root,
-      server: {
-        port: options.port,
-        host: options.host,
-        open: options.open
-      }
-    });
-    await server.listen();
-    server.printUrls();
-  } else {
-    console.log("\u{1F4E6} Zero-config mode enabled\n");
-    let sigxPlugin;
-    try {
-      const sigxVite = await import("@sigx/vite");
-      sigxPlugin = sigxVite.sigxPlugin;
-    } catch {
-      console.warn("\u26A0\uFE0F  @sigx/vite not found, JSX transform may not work");
-      console.warn("   Install with: npm install @sigx/vite\n");
-    }
-    const plugins = [];
-    try {
-      const tailwind = await import("@tailwindcss/vite");
-      plugins.push(tailwind.default());
-    } catch {
-    }
-    if (sigxPlugin) {
-      plugins.push(sigxPlugin());
-    }
-    plugins.push(...ssgPlugin({ configPath: options.configPath }));
-    const server = await vite.createServer({
-      root,
-      plugins,
-      // Vite 8 uses oxc instead of esbuild for JSX transforms
-      oxc: {
-        jsx: {
-          runtime: "automatic",
-          importSource: "sigx"
-        }
-      },
-      server: {
-        port: options.port ?? 5173,
-        host: options.host,
-        open: options.open
-      }
-    });
-    await server.listen();
-    server.printUrls();
-  }
-}
-async function preview(options = {}) {
-  const root = process.cwd();
-  console.log("\n\u{1F440} @sigx/ssg - Preview server...\n");
-  const vite = await import("vite");
-  const server = await vite.preview({
-    root,
-    preview: {
-      port: options.port ?? 4173,
-      host: options.host,
-      open: options.open
-    }
-  });
-  server.printUrls();
-  console.log("\n");
-}
-
-// src/cli.ts
-var __cli__ = true;
-var args = process.argv.slice(2);
-var command = args[0];
-var configPath = args.find((a) => a.startsWith("--config="))?.split("=")[1];
-var port = parseInt(args.find((a) => a.startsWith("--port="))?.split("=")[1] || "");
-var host = args.includes("--host") ? true : args.find((a) => a.startsWith("--host="))?.split("=")[1];
-var open = args.includes("--open");
-var verbose = args.includes("--verbose") || args.includes("-v");
-if (command === "dev") {
-  dev({
-    configPath,
-    port: isNaN(port) ? void 0 : port,
-    host,
-    open,
-    verbose
-  }).catch((err) => {
-    console.error("Dev server failed:", err);
-    process.exit(1);
-  });
-} else if (command === "build") {
-  build({ configPath, verbose }).catch((err) => {
-    console.error("Build failed:", err);
-    process.exit(1);
-  });
-} else if (command === "preview") {
-  preview({
-    configPath,
-    port: isNaN(port) ? void 0 : port,
-    host,
-    open
-  }).catch((err) => {
-    console.error("Preview server failed:", err);
-    process.exit(1);
-  });
-} else {
-  console.log(`
-@sigx/ssg - Static Site Generator for SignalX
-
-Usage:
-  ssg dev [options]            Start development server
-  ssg build [options]          Build static site for production
-  ssg preview [options]        Preview production build locally
-
-Options:
-  --config=path    Path to ssg.config.ts (default: ./ssg.config.ts)
-  --port=number    Port for dev/preview server (default: 5173/4173)
-  --host           Expose to network (or --host=0.0.0.0)
-  --open           Open browser automatically
-  --verbose, -v    Enable verbose logging
-
-Examples:
-  ssg dev                      Start dev server on localhost:5173
-  ssg dev --port=3000 --open   Start on port 3000 and open browser
-  ssg build                    Build static site to ./dist
-  ssg preview                  Preview built site on localhost:4173
-`);
-}
-export {
-  __cli__
-};
-//# sourceMappingURL=cli.js.map