blumenjs 0.2.0 → 0.2.2

package/dist/templates/scripts/generate-routes.ts

@@ -15,19 +15,22 @@
  *   - index.tsx       → "/"  (index route for folders)
  *   - NotFound.tsx    → skipped (reserved 404)
  *   - _app.tsx        → skipped (reserved prefix)
+ *   - _layout.tsx     → layout metadata (not a route, metadata cascades to children)
  *
  * Usage:  npx tsx scripts/generate-routes.ts
  */
 
 import * as fs from "fs";
 import * as path from "path";
+import * as ts from "typescript";
+import { generateAPIRoutes } from "./generate-api-routes";
 
 const PAGES_DIR = path.resolve("app/pages");
 const SSR_OUTPUT = path.resolve("node-ssr/generated-routes.ts");
 const CLIENT_OUTPUT = path.resolve("app/client/generated-routes.ts");
 
 // Reserved filenames that should not become routes
-const RESERVED = new Set(["NotFound", "NotFound.tsx"]);
+const RESERVED = new Set(["NotFound", "NotFound.tsx", "loading.tsx"]);
 
 interface RouteEntry {
 	/** The URL path, e.g. "/" or "/users/[id]" */
@@ -42,6 +45,81 @@ interface RouteEntry {
 	keys: string[];
 	/** Whether this page exports a getServerProps function */
 	hasGetServerProps: boolean;
+	/** Whether this page exports a static metadata object */
+	hasMetadata: boolean;
+	/** Whether this page exports a generateMetadata function */
+	hasGenerateMetadata: boolean;
+	/** Whether a loading.tsx file exists in the same directory */
+	hasLoading: boolean;
+	/** Import path for the loading component (if hasLoading) */
+	loadingImportPath?: string;
+	/** Whether this page exports dynamic = 'force-static' for SSG */
+	isStatic: boolean;
+	/** Whether this page exports a getStaticProps function */
+	hasGetStaticProps: boolean;
+	/** Whether this page exports a getStaticPaths function */
+	hasGetStaticPaths: boolean;
+	/** Whether this page starts with 'use client' directive */
+	isClientComponent: boolean;
+	/** Whether this page exports runtime = 'edge' */
+	isEdge: boolean;
+}
+
+interface LayoutEntry {
+	/** Directory path relative to PAGES_DIR, e.g. "" (root) or "docs" */
+	dirPath: string;
+	/** The URL prefix this layout applies to, e.g. "/" or "/docs" */
+	routePrefix: string;
+	/** Import path for the layout file (without extension) */
+	importPath: string;
+	/** Safe identifier for imports */
+	layoutId: string;
+	/** Whether this layout exports a static metadata object */
+	hasMetadata: boolean;
+	/** Whether this layout exports a generateMetadata function */
+	hasGenerateMetadata: boolean;
+}
+
+/**
+ * Check if a file exports a named identifier at the top level.
+ * Uses TypeScript AST to avoid false positives from strings/comments.
+ */
+function hasNamedExport(filePath: string, content: string, exportName: string): boolean {
+	const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+	let found = false;
+	
+	ts.forEachChild(sourceFile, (node) => {
+		// 1. Function declaration: export [async] function name() {}
+		if (ts.isFunctionDeclaration(node)) {
+			const isExported = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+			if (isExported && node.name?.text === exportName) {
+				found = true;
+			}
+		} 
+		// 2. Variable declaration: export const name = ...
+		else if (ts.isVariableStatement(node)) {
+			const isExported = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+			if (isExported) {
+				for (const decl of node.declarationList.declarations) {
+					if (ts.isIdentifier(decl.name) && decl.name.text === exportName) {
+						found = true;
+					}
+				}
+			}
+		} 
+		// 3. Export declaration: export { name } or export { x as name }
+		else if (ts.isExportDeclaration(node)) {
+			if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+				for (const element of node.exportClause.elements) {
+					if (element.name.text === exportName) {
+						found = true;
+					}
+				}
+			}
+		}
+	});
+	
+	return found;
 }
 
 function scanDir(dir: string, baseDir: string = dir): RouteEntry[] {
@@ -89,9 +167,31 @@ function scanDir(dir: string, baseDir: string = dir): RouteEntry[] {
 				patternStr = `^${patternStr}$`;
 			}
 
-			// Check if the page exports getServerProps
+			// Check if the page exports getServerProps, metadata, or generateMetadata
 			const fileContent = fs.readFileSync(fullPath, "utf-8");
-			const hasGetServerProps = /export\s+(async\s+)?function\s+getServerProps/.test(fileContent);
+			const hasGetServerProps = hasNamedExport(fullPath, fileContent, "getServerProps");
+			const hasGetStaticProps = hasNamedExport(fullPath, fileContent, "getStaticProps");
+			const hasGetStaticPaths = hasNamedExport(fullPath, fileContent, "getStaticPaths");
+			const hasMetadata = hasNamedExport(fullPath, fileContent, "metadata");
+			const hasGenerateMetadata = hasNamedExport(fullPath, fileContent, "generateMetadata");
+			const hasDynamic = hasNamedExport(fullPath, fileContent, "dynamic");
+			// Pages with getStaticProps are automatically static
+			const isStatic = hasGetStaticProps || (hasDynamic && fileContent.includes("force-static"));
+
+			// Detect 'use client' directive at the top of the file
+			const isClientComponent = /^\s*['"]use client['"]/.test(fileContent);
+
+			// Detect runtime = 'edge' for edge functions
+			const hasRuntime = hasNamedExport(fullPath, fileContent, "runtime");
+			const isEdge = hasRuntime && fileContent.includes("edge");
+
+			// Check for a loading.tsx file in the same directory
+			const pageDir = path.dirname(fullPath);
+			const loadingFile = path.join(pageDir, "loading.tsx");
+			const hasLoading = fs.existsSync(loadingFile);
+			const loadingImportPath = hasLoading
+				? path.relative(baseDir, loadingFile).replace(".tsx", "").replace(/\\/g, "/")
+				: undefined;
 
 			results.push({
 				route: routePath,
@@ -99,11 +199,65 @@ function scanDir(dir: string, baseDir: string = dir): RouteEntry[] {
 				importPath: relPath.replace(".tsx", "").replace(/\\/g, "/"),
 				patternStr,
 				keys,
-				hasGetServerProps
+				hasGetServerProps,
+				hasMetadata,
+				hasGenerateMetadata,
+				hasLoading,
+				loadingImportPath,
+				isStatic,
+				hasGetStaticProps,
+				hasGetStaticPaths,
+				isClientComponent,
+				isEdge,
+			});
+		}
+	}
+
+	return results;
+}
+
+/**
+ * Scan for _layout.tsx files in the pages directory tree.
+ * These files can export metadata/generateMetadata that cascades to child pages.
+ */
+function scanLayouts(dir: string, baseDir: string = dir): LayoutEntry[] {
+	let results: LayoutEntry[] = [];
+	const items = fs.readdirSync(dir, { withFileTypes: true });
+
+	// Check for _layout.tsx in this directory
+	const layoutFile = path.join(dir, "_layout.tsx");
+	if (fs.existsSync(layoutFile)) {
+		const relDir = path.relative(baseDir, dir).replace(/\\/g, "/");
+		const routePrefix = relDir === "" ? "/" : "/" + relDir.toLowerCase();
+		const layoutId = relDir === "" ? "Layout_root" : "Layout_" + relDir.replace(/[^a-zA-Z0-9]/g, "_");
+		const importPath = relDir === "" ? "_layout" : relDir + "/_layout";
+
+		const content = fs.readFileSync(layoutFile, "utf-8");
+		const hasMetadata = hasNamedExport(layoutFile, content, "metadata");
+		const hasGenerateMetadata = hasNamedExport(layoutFile, content, "generateMetadata");
+
+		if (hasMetadata || hasGenerateMetadata) {
+			results.push({
+				dirPath: relDir,
+				routePrefix,
+				importPath,
+				layoutId,
+				hasMetadata,
+				hasGenerateMetadata,
 			});
 		}
 	}
 
+	// Recurse into subdirectories
+	for (const item of items) {
+		if (item.isDirectory() && !item.name.startsWith("_")) {
+			results = results.concat(scanLayouts(path.join(dir, item.name), baseDir));
+		}
+	}
+
+	// Sort by depth (root first, then deeper segments)
+	results.sort((a, b) => a.dirPath.split("/").length - b.dirPath.split("/").length);
+
 	return results;
 }
 
@@ -125,8 +279,21 @@ function discoverPages(): RouteEntry[] {
 	return routes;
 }
 
+/**
+ * Generate a webpack chunk name for a route entry.
+ * Produces clean names like "page-home", "page-docs", "page-users-id".
+ */
+function getChunkName(r: RouteEntry): string {
+	return "page-" + r.importPath
+		.replace(/\/index$/, "")           // "docs/index" → "docs"
+		.replace(/\[([^\]]+)\]/g, "$1")    // "[id]" → "id"
+		.replace(/\//g, "-")               // "dashboard/settings" → "dashboard-settings"
+		.toLowerCase();
+}
+
 function generateRouteFile(
 	routes: RouteEntry[],
+	layouts: LayoutEntry[],
 	importPathPrefix: string,
 	isServer: boolean,
 ): string {
@@ -140,11 +307,18 @@ function generateRouteFile(
 		"",
 	];
 
-	// Import default exports!
-	const imports = routes.map(
-		(r) =>
-			`import ${r.componentId} from "${importPathPrefix}/${r.importPath}";`,
-	);
+	// Import page components
+	// Server: static imports (SSR needs all components loaded)
+	// Client: React.lazy() dynamic imports for code splitting
+	const imports = isServer
+		? routes.map(
+				(r) =>
+					`import ${r.componentId} from "${importPathPrefix}/${r.importPath}";`,
+			)
+		: routes.map((r) => {
+				const chunkName = getChunkName(r);
+				return `const ${r.componentId} = React.lazy(() => import(/* webpackChunkName: "${chunkName}" */ "${importPathPrefix}/${r.importPath}"));`;
+			});
 
 	// For SSR: import getServerProps from pages that export it
 	const gspImports: string[] = [];
@@ -158,6 +332,69 @@ function generateRouteFile(
 		}
 	}
 
+	// For SSR: import getStaticProps from pages that export it
+	// getStaticProps works like getServerProps but the page is pre-rendered at build time
+	const staticPropsImports: string[] = [];
+	const staticPropsRoutes = routes.filter(r => r.hasGetStaticProps);
+	if (isServer && staticPropsRoutes.length > 0) {
+		for (const r of staticPropsRoutes) {
+			const spId = "staticProps_" + r.componentId.replace("Page_", "");
+			staticPropsImports.push(
+				`import { getStaticProps as ${spId} } from "${importPathPrefix}/${r.importPath}";`,
+			);
+		}
+	}
+
+	// For SSR: import getStaticPaths from pages that export it (dynamic SSG)
+	const staticPathsImports: string[] = [];
+	const staticPathsRoutes = routes.filter(r => r.hasGetStaticPaths);
+	if (isServer && staticPathsRoutes.length > 0) {
+		for (const r of staticPathsRoutes) {
+			const pathsId = "staticPaths_" + r.componentId.replace("Page_", "");
+			staticPathsImports.push(
+				`import { getStaticPaths as ${pathsId} } from "${importPathPrefix}/${r.importPath}";`,
+			);
+		}
+	}
+
+	// For SSR: import metadata and generateMetadata from pages that export them
+	const metaImports: string[] = [];
+	const metaRoutes = routes.filter(r => r.hasMetadata);
+	const genMetaRoutes = routes.filter(r => r.hasGenerateMetadata);
+	if (isServer) {
+		for (const r of metaRoutes) {
+			const metaId = "meta_" + r.componentId.replace("Page_", "");
+			metaImports.push(
+				`import { metadata as ${metaId} } from "${importPathPrefix}/${r.importPath}";`,
+			);
+		}
+		for (const r of genMetaRoutes) {
+			const genMetaId = "genMeta_" + r.componentId.replace("Page_", "");
+			metaImports.push(
+				`import { generateMetadata as ${genMetaId} } from "${importPathPrefix}/${r.importPath}";`,
+			);
+		}
+	}
+
+	// For SSR: import metadata and generateMetadata from layout files
+	const layoutImports: string[] = [];
+	if (isServer) {
+		for (const l of layouts) {
+			if (l.hasMetadata) {
+				const metaId = "layoutMeta_" + l.layoutId;
+				layoutImports.push(
+					`import { metadata as ${metaId} } from "${importPathPrefix}/${l.importPath}";`,
+				);
+			}
+			if (l.hasGenerateMetadata) {
+				const genMetaId = "layoutGenMeta_" + l.layoutId;
+				layoutImports.push(
+					`import { generateMetadata as ${genMetaId} } from "${importPathPrefix}/${l.importPath}";`,
+				);
+			}
+		}
+	}
+
 	const hasApp = fs.existsSync(path.join(PAGES_DIR, "_app.tsx"));
 	const hasDoc = fs.existsSync(path.join(PAGES_DIR, "_document.tsx"));
 
@@ -172,35 +409,182 @@ function generateRouteFile(
 			: `import { DefaultDocument } from "${importPathPrefix}/../shared/DefaultDocument";\nexport const Document = DefaultDocument;`;
 	}
 
+	// Import loading components (client-side only)
+	const loadingImports: string[] = [];
+	const loadingRoutes = routes.filter(r => r.hasLoading);
+	if (!isServer && loadingRoutes.length > 0) {
+		for (const r of loadingRoutes) {
+			const loadingId = "Loading_" + r.componentId.replace("Page_", "");
+			loadingImports.push(
+				`import ${loadingId} from "${importPathPrefix}/${r.loadingImportPath}";`,
+			);
+		}
+	}
+
 	const routeObjects = routes.map(r => {
 		const keysArray = r.keys.length > 0 ? `["${r.keys.join('", "')}"]` : "[]";
+		const loadingId = r.hasLoading ? "Loading_" + r.componentId.replace("Page_", "") : null;
+		const loadingLine = !isServer && loadingId ? `,\n\t\tloading: ${loadingId}` : "";
 		return `\t{
 \t\tpath: "${r.route}",
 \t\tpattern: new RegExp("${r.patternStr.replace(/\\/g, '\\\\')}"),
 \t\tkeys: ${keysArray},
-\t\tcomponent: ${r.componentId}
+\t\tcomponent: ${r.componentId}${loadingLine}
 \t}`;
 	});
 
 	// Generate serverPropsMap for SSR routes
 	let serverPropsMapStr = "";
-	if (isServer && gspRoutes.length > 0) {
+	if (isServer && (gspRoutes.length > 0 || staticPropsRoutes.length > 0)) {
+		// Merge getServerProps + getStaticProps into one map
+		// getStaticProps pages are treated identically at render time
 		const entries = gspRoutes.map(r => {
 			const gspId = "gsp_" + r.componentId.replace("Page_", "");
 			return `\t"${r.route}": ${gspId},`;
 		});
+		const staticEntries = staticPropsRoutes.map(r => {
+			const spId = "staticProps_" + r.componentId.replace("Page_", "");
+			return `\t"${r.route}": ${spId},`;
+		});
 		serverPropsMapStr = [
 			"",
-			"// Map of routes that export getServerProps",
+			"// Map of routes that export getServerProps or getStaticProps",
 			"// Used by the SSR server to run data fetching before rendering",
 			"export const serverPropsMap: Record<string, Function> = {",
 			...entries,
+			...staticEntries,
 			"};",
 		].join("\n");
 	} else if (isServer) {
 		serverPropsMapStr = "\nexport const serverPropsMap: Record<string, Function> = {};";
 	}
 
+	// Generate staticPropsMap (for ISR — tracks which pages use getStaticProps)
+	let staticMapsStr = "";
+	if (isServer) {
+		if (staticPropsRoutes.length > 0) {
+			const entries = staticPropsRoutes.map(r => {
+				const spId = "staticProps_" + r.componentId.replace("Page_", "");
+				return `\t"${r.route}": ${spId},`;
+			});
+			staticMapsStr += [
+				"",
+				"// Map of routes with getStaticProps (for ISR revalidation)",
+				"export const staticPropsMap: Record<string, Function> = {",
+				...entries,
+				"};",
+			].join("\n");
+		} else {
+			staticMapsStr += "\nexport const staticPropsMap: Record<string, Function> = {};";
+		}
+
+		if (staticPathsRoutes.length > 0) {
+			const entries = staticPathsRoutes.map(r => {
+				const pathsId = "staticPaths_" + r.componentId.replace("Page_", "");
+				return `\t"${r.route}": ${pathsId},`;
+			});
+			staticMapsStr += [
+				"",
+				"// Map of routes with getStaticPaths (for dynamic SSG)",
+				"export const staticPathsMap: Record<string, Function> = {",
+				...entries,
+				"};",
+			].join("\n");
+		} else {
+			staticMapsStr += "\nexport const staticPathsMap: Record<string, Function> = {};";
+		}
+	}
+
+	// Generate metadataMap and generateMetadataMap for SSR routes
+	let metadataMapStr = "";
+	if (isServer) {
+		// Static metadata map
+		if (metaRoutes.length > 0) {
+			const entries = metaRoutes.map(r => {
+				const metaId = "meta_" + r.componentId.replace("Page_", "");
+				return `\t"${r.route}": ${metaId},`;
+			});
+			metadataMapStr += [
+				"",
+				"// Map of routes with static metadata exports",
+				"export const metadataMap: Record<string, any> = {",
+				...entries,
+				"};",
+			].join("\n");
+		} else {
+			metadataMapStr += "\nexport const metadataMap: Record<string, any> = {};";
+		}
+
+		// Dynamic generateMetadata map
+		if (genMetaRoutes.length > 0) {
+			const entries = genMetaRoutes.map(r => {
+				const genMetaId = "genMeta_" + r.componentId.replace("Page_", "");
+				return `\t"${r.route}": ${genMetaId},`;
+			});
+			metadataMapStr += [
+				"",
+				"// Map of routes with dynamic generateMetadata exports",
+				"export const generateMetadataMap: Record<string, Function> = {",
+				...entries,
+				"};",
+			].join("\n");
+		} else {
+			metadataMapStr += "\nexport const generateMetadataMap: Record<string, Function> = {};";
+		}
+
+		// Layout static metadata map
+		const layoutMetaEntries = layouts.filter(l => l.hasMetadata);
+		if (layoutMetaEntries.length > 0) {
+			const entries = layoutMetaEntries.map(l => {
+				const metaId = "layoutMeta_" + l.layoutId;
+				return `\t"${l.routePrefix}": ${metaId},`;
+			});
+			metadataMapStr += [
+				"",
+				"// Layout metadata — cascades to all child pages in the directory",
+				"export const layoutMetadataMap: Record<string, any> = {",
+				...entries,
+				"};",
+			].join("\n");
+		} else {
+			metadataMapStr += "\nexport const layoutMetadataMap: Record<string, any> = {};";
+		}
+
+		// Layout dynamic generateMetadata map
+		const layoutGenMetaEntries = layouts.filter(l => l.hasGenerateMetadata);
+		if (layoutGenMetaEntries.length > 0) {
+			const entries = layoutGenMetaEntries.map(l => {
+				const genMetaId = "layoutGenMeta_" + l.layoutId;
+				return `\t"${l.routePrefix}": ${genMetaId},`;
+			});
+			metadataMapStr += [
+				"",
+				"// Layout dynamic metadata — cascades to all child pages",
+				"export const layoutGenerateMetadataMap: Record<string, Function> = {",
+				...entries,
+				"};",
+			].join("\n");
+		} else {
+			metadataMapStr += "\nexport const layoutGenerateMetadataMap: Record<string, Function> = {};";
+		}
+	}
+
+	// Generate route-to-chunk name map (client-side only, for prefetching)
+	let routeChunkMapStr = "";
+	if (!isServer) {
+		const entries = routes.map(r => {
+			const chunkName = getChunkName(r);
+			return `\t"${r.route}": "${chunkName}",`;
+		});
+		routeChunkMapStr = [
+			"",
+			"// Map of route paths to their webpack chunk names (for prefetching)",
+			"export const routeChunkMap: Record<string, string> = {",
+			...entries,
+			"};",
+		].join("\n");
+	}
+
 	const map = [
 		"",
 		"export interface RouteDef {",
@@ -208,6 +592,7 @@ function generateRouteFile(
 		"\tpattern: RegExp;",
 		"\tkeys: string[];",
 		"\tcomponent: React.ComponentType<any>;",
+		"\tloading?: React.ComponentType<any>;",
 		"}",
 		"",
 		"export const routes: RouteDef[] = [",
@@ -217,10 +602,13 @@ function generateRouteFile(
 		appImport,
 		docImport,
 		serverPropsMapStr,
+		staticMapsStr,
+		metadataMapStr,
+		routeChunkMapStr,
 		"",
 	];
 
-	return [...header, ...imports, ...gspImports, ...map].join("\n");
+	return [...header, ...imports, ...gspImports, ...staticPropsImports, ...staticPathsImports, ...metaImports, ...layoutImports, ...loadingImports, ...map].join("\n");
 }
 
 function main() {
@@ -228,32 +616,84 @@ function main() {
 	console.log(`   Scanning: ${PAGES_DIR}`);
 
 	const routes = discoverPages();
+	const layouts = scanLayouts(PAGES_DIR);
 
 	if (routes.length === 0) {
 		console.error("   ❌ No pages found!");
 		process.exit(1);
 	}
 
+	// Print detected layouts
+	if (layouts.length > 0) {
+		console.log(`   Found ${layouts.length} layout(s) with metadata:`);
+		for (const l of layouts) {
+			const tags: string[] = [];
+			if (l.hasMetadata) tags.push("metadata");
+			if (l.hasGenerateMetadata) tags.push("generateMetadata");
+			const scope = l.routePrefix === "/" ? "(all pages)" : `(${l.routePrefix}/*)` ;
+			console.log(`     📐 ${l.importPath}.tsx [${tags.join(", ")}] ${scope}`);
+		}
+	}
+
 	console.log(`   Found ${routes.length} route(s):`);
 	for (const r of routes) {
-		const gspTag = r.hasGetServerProps ? " [getServerProps]" : "";
-		console.log(`     ${r.route.padEnd(25)} → ${r.importPath}.tsx${gspTag}`);
+		const tags: string[] = [];
+		if (r.hasGetServerProps) tags.push("getServerProps");
+		if (r.hasGetStaticProps) tags.push("getStaticProps");
+		if (r.hasMetadata) tags.push("metadata");
+		if (r.hasGenerateMetadata) tags.push("generateMetadata");
+		if (r.hasLoading) tags.push("loading");
+		if (r.isStatic) tags.push("ssg");
+		if (r.isClientComponent) tags.push("use client");
+		if (r.isEdge) tags.push("edge");
+		const tagStr = tags.length > 0 ? ` [${tags.join(", ")}]` : "";
+		console.log(`     ${r.route.padEnd(25)} → ${r.importPath}.tsx${tagStr}`);
 	}
 
 	// Generate SSR routes (node-ssr/ → ../app/pages)
-	const ssrContent = generateRouteFile(routes, "../app/pages", true);
+	const ssrContent = generateRouteFile(routes, layouts, "../app/pages", true);
 	fs.mkdirSync(path.dirname(SSR_OUTPUT), { recursive: true });
 	fs.writeFileSync(SSR_OUTPUT, ssrContent, "utf-8");
 	console.log(`   ✅ Written: ${path.relative(process.cwd(), SSR_OUTPUT)}`);
 
 	// Generate Client routes (app/client/ → ../pages)
-	const clientContent = generateRouteFile(routes, "../pages", false);
+	const clientContent = generateRouteFile(routes, layouts, "../pages", false);
 	fs.mkdirSync(path.dirname(CLIENT_OUTPUT), { recursive: true });
 	fs.writeFileSync(CLIENT_OUTPUT, clientContent, "utf-8");
 	console.log(
 		`   ✅ Written: ${path.relative(process.cwd(), CLIENT_OUTPUT)}`,
 	);
 
+	// Generate API routes (app/api/ → node-ssr/generated-api-routes.ts)
+	console.log("   →  Scanning API routes...");
+	const apiRoutes = generateAPIRoutes();
+	if (apiRoutes.length > 0) {
+		console.log(`   Found ${apiRoutes.length} API route(s):`);
+		for (const r of apiRoutes) {
+			console.log(`     ${r.methods.join("|").padEnd(20)} ${r.route}`);
+		}
+		console.log(`   ✅ Written: node-ssr/generated-api-routes.ts`);
+	} else {
+		console.log("   No API routes found (app/api/ is empty or missing)");
+	}
+
+	// Write SSG manifest for the build step
+	const ssgRoutes = routes.filter(r => r.isStatic);
+	if (ssgRoutes.length > 0) {
+		const ssgManifest = {
+			pages: ssgRoutes.map(r => ({
+				route: r.route,
+				componentId: r.componentId,
+				hasGetServerProps: r.hasGetServerProps,
+				hasGetStaticProps: r.hasGetStaticProps,
+				hasGetStaticPaths: r.hasGetStaticPaths,
+			}))
+		};
+		fs.mkdirSync("dist", { recursive: true });
+		fs.writeFileSync("dist/ssg-manifest.json", JSON.stringify(ssgManifest, null, 2));
+		console.log(`   📄 SSG: ${ssgRoutes.length} page(s) will be pre-rendered at build time`);
+	}
+
 	console.log("   🎉 Routes generated successfully!");
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "blumenjs",
-	"version": "0.2.0",
+	"version": "0.2.2",
 	"description": "The React framework powered by Go. Lightning-fast SSR with the DX you deserve.",
 	"type": "module",
 	"bin": {
@@ -29,7 +29,10 @@
 		"dev:go": "go run go-server/main.go go-server/image.go go-server/cache.go",
 		"build:client": "webpack --mode production",
 		"build:ssr": "esbuild node-ssr/server.ts --bundle --platform=node --format=esm --outfile=dist/ssr-server.js --packages=external",
-		"clean": "rm -rf dist static/js/bundle.js"
+		"clean": "rm -rf dist static/js/bundle.js",
+		"test": "tsx cli/blumen.ts test",
+		"test:coverage": "tsx cli/blumen.ts test --coverage",
+		"bench": "tsx cli/blumen.ts bench"
 	},
 	"keywords": [
 		"react",
@@ -49,9 +52,11 @@
 	},
 	"homepage": "",
 	"dependencies": {
-		"lucide-react": "^1.14.0",
-		"react": "^18.2.0",
-		"react-dom": "^18.2.0"
+		"lucide-react": "^1.14.0"
+	},
+	"peerDependencies": {
+		"react": "^18.2.0 || ^19.0.0",
+		"react-dom": "^18.2.0 || ^19.0.0"
 	},
 	"devDependencies": {
 		"@babel/core": "^7.29.0",
@@ -59,19 +64,28 @@
 		"@babel/preset-react": "^7.28.5",
 		"@babel/preset-typescript": "^7.28.5",
 		"@pmmmwh/react-refresh-webpack-plugin": "^0.6.2",
+		"@testing-library/dom": "^10.4.1",
+		"@testing-library/jest-dom": "^6.9.1",
+		"@testing-library/react": "^16.3.2",
 		"@types/node": "^20.10.0",
-		"@types/react": "^18.2.0",
-		"@types/react-dom": "^18.2.0",
+		"@types/react": "^18.3.29",
+		"@types/react-dom": "^18.3.7",
+		"@vitejs/plugin-react": "^6.0.2",
+		"@vitest/coverage-v8": "^4.1.7",
 		"babel-loader": "^10.1.1",
 		"concurrently": "^8.2.2",
 		"css-loader": "^7.1.4",
 		"esbuild": "^0.19.0",
+		"jsdom": "^29.1.1",
 		"mini-css-extract-plugin": "^2.10.2",
+		"react": "^19.2.6",
+		"react-dom": "^19.2.6",
 		"react-refresh": "^0.18.0",
 		"style-loader": "^4.0.0",
 		"ts-loader": "^9.5.1",
 		"tsx": "^4.6.0",
 		"typescript": "^5.3.0",
+		"vitest": "^4.1.7",
 		"webpack": "^5.89.0",
 		"webpack-bundle-analyzer": "^5.3.0",
 		"webpack-cli": "^5.1.4",