@sigx/ssg 0.1.6

package/dist/virtual-entries-Bz97SKQ0.js

@@ -0,0 +1,1053 @@
+import path from "node:path";
+import fs from "node:fs";
+import fg from "fast-glob";
+import matter from "gray-matter";
+function defineSSGConfig(config) {
+	return {
+		pages: "src/pages",
+		layouts: "src/layouts",
+		content: "src/content",
+		defaultLayout: "default",
+		outDir: "dist",
+		base: "/",
+		autoEntries: true,
+		prefetch: true,
+		...config,
+		site: {
+			lang: "en",
+			...config.site
+		},
+		markdown: {
+			shiki: true,
+			...config.markdown
+		},
+		toc: {
+			minLevel: 2,
+			maxLevel: 3,
+			...config.toc
+		}
+	};
+}
+async function loadConfig(configPath) {
+	const fsPath = await import("node:path");
+	const fs = await import("node:fs");
+	const { pathToFileURL } = await import("node:url");
+	const os = await import("node:os");
+	const cwd = process.cwd();
+	const possiblePaths = configPath ? [fsPath.resolve(cwd, configPath)] : [
+		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 (fs.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();
+			fsPath.join(tempDir, `ssg-config-${Date.now()}.mjs`);
+			const source = fs.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`);
+			fs.writeFileSync(localTempFile, result.code);
+			try {
+				const configModule = await import(pathToFileURL(localTempFile).href);
+				return defineSSGConfig(configModule.default || configModule);
+			} finally {
+				try {
+					fs.unlinkSync(localTempFile);
+				} catch {}
+			}
+		}
+		const configModule = await import(pathToFileURL(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")
+	};
+}
+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;
+}
+var PAGE_EXTENSIONS = [
+	".tsx",
+	".jsx",
+	".mdx",
+	".md"
+];
+var EXCLUDED_PATTERNS = [
+	"components/**",
+	"hooks/**",
+	"utils/**",
+	"lib/**",
+	"**/_*",
+	"**/*.test.*",
+	"**/*.spec.*"
+];
+async function scanPages(config, root) {
+	const pagesDir = path.resolve(root, config.pages || "src/pages");
+	const files = await fg(PAGE_EXTENSIONS.map((ext) => `**/*${ext}`), {
+		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 = path.extname(filePath).toLowerCase();
+	if (ext === ".mdx" || ext === ".md") try {
+		const { data } = parseFrontmatter(fs.readFileSync(route.file, "utf-8"));
+		route.meta = data;
+	} catch (err) {}
+	return route;
+}
+function fileToRoute(filePath, pagesDir) {
+	const ext = path.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: path.join(pagesDir, filePath),
+		name
+	};
+}
+function filePathToRoutePath(filePath) {
+	return filePath.split("/").map((segment) => {
+		if (segment.startsWith("[...") && segment.endsWith("]")) return `*${segment.slice(4, -1)}`;
+		if (segment.startsWith("[[...") && segment.endsWith("]]")) return `*${segment.slice(5, -2)}`;
+		if (segment.startsWith("[") && segment.endsWith("]")) return `:${segment.slice(1, -1)}`;
+		if (segment.startsWith("[[") && segment.endsWith("]]")) return `:${segment.slice(2, -2)}?`;
+		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;
+}
+const VIRTUAL_ROUTES_ID = "virtual:ssg-routes";
+const RESOLVED_VIRTUAL_ROUTES_ID = "\0" + VIRTUAL_ROUTES_ID;
+function normalizePath$1(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$1(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$1(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;
+`;
+}
+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);
+	}
+	return { sidebar: buildSections(context) };
+}
+function addToCategory(categories, path, item) {
+	if (path.length === 0) return;
+	const [first, ...rest] = path;
+	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,
+	"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) => {
+		return getSectionOrder(a.title, a.order) - getSectionOrder(b.title, b.order);
+	});
+	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) => {
+		return getSectionOrder(a.title, a.order) - getSectionOrder(b.title, b.order);
+	})) 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);
+	return (segments[segments.length - 1] || "Home").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;
+}
+const VIRTUAL_NAVIGATION_ID = "virtual:ssg-navigation";
+const RESOLVED_VIRTUAL_NAVIGATION_ID = "\0" + VIRTUAL_NAVIGATION_ID;
+function generateNavigationModule(routes, config, isDev) {
+	const navigation = generateAllCollections(routes, config, isDev);
+	const collections = config.collections || {};
+	return `
+/**
+ * Auto-generated navigation module
+ * 
+ * @generated by @sigx/ssg
+ */
+
+/**
+ * Navigation for all collections, keyed by collection name
+ */
+export const navigation = ${JSON.stringify(navigation, null, 2)};
+
+/**
+ * Collections configuration
+ */
+const collections = ${JSON.stringify(collections, null, 2)};
+
+/**
+ * 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 };
+`;
+}
+var LAYOUT_EXTENSIONS = [".tsx", ".jsx"];
+async function scanLocalLayouts(config, root) {
+	const layoutsDir = path.resolve(root, config.layouts || "src/layouts");
+	if (!fs.existsSync(layoutsDir)) return [];
+	return (await fg(LAYOUT_EXTENSIONS.map((ext) => `*${ext}`), {
+		cwd: layoutsDir,
+		onlyFiles: true,
+		absolute: false
+	})).map((file) => {
+		const ext = path.extname(file);
+		return {
+			name: file.slice(0, -ext.length),
+			file: path.join(layoutsDir, file),
+			source: "local"
+		};
+	});
+}
+async function loadThemeLayouts(themeName, root) {
+	try {
+		const { createRequire } = await import("node:module");
+		const { pathToFileURL } = await import("node:url");
+		const themePackageJson = createRequire(path.join(root, "package.json")).resolve(`${themeName}/package.json`);
+		const themeDir = path.dirname(themePackageJson);
+		const packageJson = JSON.parse(fs.readFileSync(themePackageJson, "utf-8"));
+		const mainFile = packageJson.exports?.["."]?.import || packageJson.main || "./dist/index.js";
+		const themeModule = await import(pathToFileURL(path.resolve(themeDir, mainFile)).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());
+}
+const VIRTUAL_LAYOUTS_ID = "virtual:generated-layouts";
+const RESOLVED_VIRTUAL_LAYOUTS_ID = "\0virtual:generated-layouts";
+function normalizePath(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 = normalizePath(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(
+                \`❌ SSG103: Layout "\${layoutName}" not found for route \${route.path}\\n\` +
+                \`   📁 \${route.file || 'unknown'}\\n\` +
+                \`   💡 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;
+`;
+}
+const VIRTUAL_CLIENT_ID = "virtual:ssg-client";
+const RESOLVED_VIRTUAL_CLIENT_ID = "\0" + VIRTUAL_CLIENT_ID + ".tsx";
+const SSG_CLIENT_ENTRY_PATH = "/@ssg/client.tsx";
+const VIRTUAL_SERVER_ID = "virtual:ssg-server";
+const RESOLVED_VIRTUAL_SERVER_ID = "\0" + VIRTUAL_SERVER_ID + ".tsx";
+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 = path.join(root, p);
+		if (fs.existsSync(fullPath)) {
+			customClientPath = fullPath;
+			break;
+		}
+	}
+	for (const p of serverPaths) {
+		const fullPath = path.join(root, p);
+		if (fs.existsSync(fullPath)) {
+			customServerPath = fullPath;
+			break;
+		}
+	}
+	for (const p of htmlPaths) {
+		const fullPath = path.join(root, p);
+		if (fs.existsSync(fullPath)) {
+			customHtmlPath = fullPath;
+			break;
+		}
+	}
+	for (const p of cssPaths) {
+		const fullPath = path.join(root, p);
+		if (fs.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}';\n` : "";
+	const additionalImports = (config.clientImports ?? []).map((imp) => `import '${imp}';`).join("\n");
+	const additionalImportsBlock = additionalImports ? `\n${additionalImports}\n` : "";
+	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,
+});
+
+// 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>
+`;
+}
+export { resolveConfigPaths as A, extractParams as C, parseFrontmatter as D, extractTitleFromContent as E, defineSSGConfig as O, expandDynamicRoute as S, scanPages as T, generateNavigationModule as _, VIRTUAL_SERVER_ID as a, generateLazyRoutesModule as b, generateHtmlTemplate as c, RESOLVED_VIRTUAL_LAYOUTS_ID as d, VIRTUAL_LAYOUTS_ID as f, VIRTUAL_NAVIGATION_ID as g, RESOLVED_VIRTUAL_NAVIGATION_ID as h, VIRTUAL_CLIENT_ID as i, loadConfig as k, generateProductionHtmlTemplate as l, discoverLayouts as m, RESOLVED_VIRTUAL_SERVER_ID as n, detectCustomEntries as o, generateLayoutsModule as p, SSG_CLIENT_ENTRY_PATH as r, generateClientEntry as s, RESOLVED_VIRTUAL_CLIENT_ID as t, generateServerEntry as u, RESOLVED_VIRTUAL_ROUTES_ID as v, isDynamicRoute as w, generateRoutesModule as x, VIRTUAL_ROUTES_ID as y };
+
+//# sourceMappingURL=virtual-entries-Bz97SKQ0.js.map