alepha 0.14.4 → 0.15.1

package/dist/vite/index.js

@@ -1,86 +1,13 @@
 import m, { createRequire } from "node:module";
-import { access, cp, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
-import path, { basename, dirname, join, relative, resolve } from "node:path";
-import { AlephaError } from "alepha";
-import { pathToFileURL } from "node:url";
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, promises, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
 import { promisify } from "node:util";
 import { brotliCompress, gzip } from "node:zlib";
 import { analyzer } from "vite-bundle-analyzer";
+import { access, cp, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { AlephaError } from "alepha";
 
-//#region ../../src/vite/helpers/boot.ts
-/**
-* Remember:
-* At first, functions was inside alepha/vite package, but it's now used in alepha too.
-* For avoiding cli -> vite, all code moved here.
-*/
-/**
-* Find browser/client entry file path.
-*/
-const getClientEntry = async (root = process.cwd()) => {
-	const indexPath = join(root, "index.html");
-	try {
-		return extractFirstModuleScriptSrc(await readFile(indexPath, "utf8")).replace(/\\/g, "/");
-	} catch {
-		return;
-	}
-};
-/**
-* Find server entry file path.
-*/
-const getServerEntry = async (root = process.cwd(), explicitEntry) => {
-	if (explicitEntry) {
-		const explicitPath = join(root, explicitEntry);
-		try {
-			await access(explicitPath);
-			return explicitPath;
-		} catch {
-			throw new AlephaError(`Explicit server entry file "${explicitEntry}" not found.`);
-		}
-	}
-	const maybeEntry = [
-		"src/main.server.ts",
-		"src/server-entry.ts",
-		"src/main.server.tsx",
-		"src/server-entry.tsx",
-		"src/main.ts",
-		"src/main.tsx"
-	];
-	for (const entry of maybeEntry) try {
-		const path$1 = join(root, entry).replace(/\\/g, "/");
-		await access(path$1);
-		return path$1;
-	} catch {}
-	const clientEntry = await getClientEntry(root);
-	if (clientEntry) return clientEntry;
-	throw new AlephaError(`Could not find a server entry file. List of supported entry file: ${maybeEntry.join(", ")}`);
-};
-/**
-* Extract first module script src from HTML.
-*/
-function extractFirstModuleScriptSrc(html) {
-	const scriptRegex = /<script\b[^>]*>[\s\S]*?<\/script>/gi;
-	let match = scriptRegex.exec(html);
-	while (match) {
-		const tag = match[0];
-		if (/type=["']module["']/i.test(tag)) {
-			const entry = tag.match(/\bsrc=["']([^"']+)["']/i)?.[1];
-			if (entry) {
-				if (entry.startsWith("/")) return entry.substring(1);
-				return entry;
-			}
-		}
-		match = scriptRegex.exec(html);
-	}
-	throw new AlephaError(`No module script found in the provided HTML.`);
-}
-const boot = {
-	getClientEntry,
-	getServerEntry
-};
-
-//#endregion
 //#region ../../src/vite/helpers/createBufferedLogger.ts
 /**
 * Creates a Vite logger that buffers all messages instead of printing them.
@@ -168,281 +95,20 @@ const importVite = async () => {
 	} catch (_error) {
 		try {
 			return createRequire(import.meta.url)("vite");
-		} catch (_error$1) {
+		} catch (_error) {
 			throw new Error("Vite is not installed. Please install it with `npm install vite`.");
 		}
 	}
 };
 
 //#endregion
-//#region ../../src/vite/tasks/runAlepha.ts
-/**
-* Create an Alepha runner for development.
-*
-* The runner manages the lifecycle of an Alepha application during
-* Vite dev server operation, handling start/stop/restart and HMR.
-*/
-function createAlephaRunner(opts) {
-	return new AlephaRunner({
-		root: process.cwd().replace(/\\/g, "/"),
-		started: false,
-		log: opts.debug ? (...msg) => console.log(...msg) : () => {},
-		entry: opts.entry,
-		onReload: () => {}
-	});
-}
-var AlephaRunner = class {
-	state;
-	constructor(state) {
-		this.state = state;
-	}
-	/**
-	* Set resolved Vite config.
-	*/
-	setConfig(config) {
-		this.state.config = config;
-	}
-	/**
-	* Check if SSR is enabled for the running app.
-	*/
-	isSsrEnabled() {
-		if (!this.state.app) return false;
-		return this.state.app.store.get("alepha.react.server.ssr") ?? false;
-	}
-	/**
-	* Check if app is started.
-	*/
-	get isStarted() {
-		return this.state.started;
-	}
-	/**
-	* Get the running Alepha app instance.
-	*/
-	get app() {
-		return this.state.app;
-	}
-	/**
-	* Start the Alepha application.
-	*/
-	async start(server) {
-		const { loadEnv } = await importVite();
-		global.ssrFixStacktrace = (e) => {
-			server.ssrFixStacktrace(e);
-			let it = e;
-			do {
-				server.ssrFixStacktrace(it);
-				it = it.cause;
-			} while (it instanceof Error);
-		};
-		if (this.state.started) {
-			await this.restart(server, true);
-			return;
-		}
-		if (!this.state.config) {
-			this.state.log("[DEBUG] No config - skip starting");
-			return;
-		}
-		this.state.onReload?.();
-		this.state.log("[DEBUG] Starting Alepha app...");
-		this.state.started = false;
-		this.state.app = void 0;
-		const fileUrl = pathToFileURL(`${path.resolve(this.state.config.root, this.state.entry)}`).href;
-		const env = loadEnv("development", this.state.config.root, "");
-		const before = { ...process.env };
-		for (const key in env) process.env[key] = env[key];
-		let port = 5173;
-		const address = server.httpServer?.address();
-		if (typeof address === "object" && address?.port) port = address.port;
-		process.env.NODE_ENV ??= "development";
-		process.env.VITE_ALEPHA_DEV = "true";
-		process.env.SERVER_HOST ??= typeof server.config.server.host === "string" ? server.config.server.host : "localhost";
-		process.env.SERVER_PORT ??= String(port);
-		try {
-			const now = Date.now();
-			await server.ssrLoadModule(fileUrl, { fixStacktrace: true });
-			this.state.log(`[DEBUG] Alepha app loaded in ${Date.now() - now}ms`);
-			await new Promise((r) => setTimeout(r, 10));
-			this.state.app = globalThis.__alepha;
-			if (!this.state.app) {
-				this.state.log("[DEBUG] No app found - skip starting");
-				return;
-			}
-			this.state.app.store.set("alepha.node.server", server.httpServer);
-			console.log("");
-			await this.state.app.start();
-			this.state.started = true;
-			process.env = { ...before };
-			this.state.log("[DEBUG] Starting Done!");
-		} catch (e) {
-			if (e instanceof Error) {
-				let it = e;
-				do {
-					server.ssrFixStacktrace(it);
-					it = it.cause;
-				} while (it instanceof Error);
-				server.ssrFixStacktrace(e);
-				if (e.cause instanceof Error) server.ssrFixStacktrace(e.cause);
-				this.state.app?.log?.error("App failed to start:", e);
-				this.state.app?.log?.info("Waiting for changes to restart...");
-			}
-			this.state.log("[DEBUG] Alepha app start error");
-			this.state.started = false;
-		}
-	}
-	/**
-	* Stop the Alepha application.
-	*/
-	async stop() {
-		if (this.state.app?.stop && this.state.started) {
-			this.state.log("[DEBUG] Stopping Alepha app...");
-			await this.state.app.stop();
-			this.state.started = false;
-			this.state.log("[DEBUG] Stopping Done!");
-		} else this.state.log("[DEBUG] Alepha app not started - skip stop");
-	}
-	/**
-	* Restart the Alepha application.
-	*
-	* @returns true if the restart was skipped due to locking
-	*/
-	async restart(server, invalidate) {
-		if (this.state.lock) {
-			this.state.log("[DEBUG] STILL LOCKING");
-			return true;
-		}
-		this.state.log("[DEBUG] LOCK RESTART");
-		this.state.lock = Promise.withResolvers();
-		const now = Date.now();
-		this.state.log("[DEBUG] RESTART");
-		await this.stop();
-		this.state.log(`[DEBUG] RESTART (stop) in ${Date.now() - now}ms`);
-		if (invalidate) server.moduleGraph.invalidateAll();
-		await this.start(server);
-		this.state.log(`[DEBUG] RESTART OK in ${Date.now() - now}ms`);
-		setTimeout(() => {
-			this.state.log("[DEBUG] UNLOCK RESTART");
-			this.state.lock?.resolve();
-			this.state.lock = void 0;
-		}, 500);
-		return false;
-	}
-	/**
-	* Send reload event to client.
-	*/
-	sendReload(server) {
-		server.ws.send({
-			type: "custom",
-			event: "alepha:reload",
-			data: {}
-		});
-	}
+//#region ../../src/vite/helpers/importViteReact.ts
+const importViteReact = async () => {
+	try {
+		const { default: viteReact } = createRequire(import.meta.url)("@vitejs/plugin-react");
+		return viteReact;
+	} catch {}
 };
-/**
-* Check if a URL path is a Vite internal file.
-*/
-function isViteInternalPath(pathname) {
-	const [path$1] = pathname.split("?");
-	if (path$1.startsWith("/@") || path$1.startsWith("/src") || path$1.includes("/node_modules/")) return true;
-	return false;
-}
-
-//#endregion
-//#region ../../src/vite/plugins/viteAlephaDev.ts
-/**
-* Plug Alepha into Vite development server.
-*
-* This plugin manages the Alepha application lifecycle during development,
-* handling hot module replacement and request forwarding.
-*/
-async function viteAlephaDev(options = {}) {
-	let entry = options.serverEntry;
-	if (!entry) {
-		entry = await boot.getServerEntry();
-		if (!entry) return {
-			name: "alepha-dev",
-			apply: "serve",
-			config() {}
-		};
-	}
-	const runner = createAlephaRunner({
-		entry,
-		debug: options.debug
-	});
-	const { loadEnv } = await importVite();
-	const env = loadEnv("development", process.cwd(), "SERVER");
-	const config = {};
-	if (env.SERVER_PORT) config.server = { port: parseInt(env.SERVER_PORT, 10) };
-	return {
-		name: "alepha-dev",
-		apply: "serve",
-		config: () => config,
-		configResolved(resolvedConfig) {
-			runner.setConfig(resolvedConfig);
-		},
-		async handleHotUpdate(ctx) {
-			if (options.debug) console.log("[DEBUG] HMR", ctx.file);
-			if (ctx.file.includes("/.idea/")) return [];
-			const isServerOnly = !ctx.modules[0]?._clientModule;
-			const isBrowserOnly = !ctx.modules[0]?._ssrModule;
-			const isSsrEnabled = runner.isSsrEnabled();
-			if (isBrowserOnly) {
-				if (options.debug) console.log("[DEBUG] HMR - browser only - no reason to reload server");
-				return;
-			}
-			const root = process.cwd().replace(/\\/g, "/");
-			const invalidate = !ctx.file.startsWith(root);
-			if (invalidate && options.debug) console.log("[DEBUG] HMR - outside root - invalidate all");
-			if (!isSsrEnabled && isServerOnly) {
-				await runner.restart(ctx.server, invalidate);
-				return [];
-			}
-			if (isSsrEnabled && ctx.modules[0]) {
-				if (await runner.restart(ctx.server, invalidate)) return [];
-				if (!runner.isStarted) {
-					if (options.debug) console.log("[DEBUG] HMR - abort due to app not started");
-					return [];
-				}
-				if (isServerOnly && runner.isStarted) {
-					runner.sendReload(ctx.server);
-					return [];
-				}
-			}
-		},
-		async configureServer(server) {
-			if (env.SERVER_PORT) server.config.server.port = parseInt(env.SERVER_PORT, 10);
-			const middleware = (req, res, next) => {
-				if (runner.isStarted && runner.app && req.url && !isViteInternalPath(req.url)) {
-					let ended = false;
-					const writeHead = res.writeHead.bind(res);
-					res.writeHead = (...args) => {
-						ended = true;
-						return writeHead(args[0], args[1], args[2]);
-					};
-					return runner.app.events.emit("node:request", {
-						req,
-						res
-					}).then(() => {
-						if (!ended) next();
-					});
-				}
-				next();
-			};
-			server.middlewares.use((req, res, next) => {
-				middleware(req, res, next);
-			});
-			server.config.logger.info = (msg) => {
-				console.log(msg);
-			};
-			server.config.logger.clearScreen = () => {};
-			return () => {
-				server.httpServer?.once("listening", () => {
-					runner.start(server);
-				});
-			};
-		},
-		async closeBundle() {}
-	};
-}
 
 //#endregion
 //#region ../../src/vite/plugins/viteAlephaSsrPreload.ts
@@ -605,11 +271,11 @@ function viteCompress(options = {}) {
 	};
 }
 async function compressFile(options = {}, filePath) {
-	const { brotli = true, gzip: gzip$1 = true } = options;
+	const { brotli = true, gzip = true } = options;
 	const compressionTasks = [];
 	const fileContentPromise = promises.readFile(filePath);
-	if (gzip$1) {
-		const gzipOptions = typeof gzip$1 === "object" ? gzip$1 : { level: 9 };
+	if (gzip) {
+		const gzipOptions = typeof gzip === "object" ? gzip : { level: 9 };
 		compressionTasks.push(fileContentPromise.then(async (content) => {
 			const compressed = await gzipCompress(content, gzipOptions);
 			await promises.writeFile(`${filePath}.gz`, compressed);
@@ -625,15 +291,6 @@ async function compressFile(options = {}, filePath) {
 	await Promise.all(compressionTasks);
 }
 
-//#endregion
-//#region ../../src/vite/helpers/importViteReact.ts
-const importViteReact = async () => {
-	try {
-		const { default: viteReact } = createRequire(import.meta.url)("@vitejs/plugin-react");
-		return viteReact;
-	} catch {}
-};
-
 //#endregion
 //#region ../../src/vite/tasks/buildClient.ts
 /**
@@ -661,7 +318,6 @@ async function buildClient(opts) {
 			chunkSizeWarningLimit: 1e3,
 			outDir: opts.dist,
 			manifest: true,
-			ssrManifest: true,
 			rollupOptions: { output: {
 				entryFileNames: "entry.[hash].js",
 				chunkFileNames: "chunk.[hash].js",
@@ -717,19 +373,29 @@ async function generateExternals(opts) {
 * the dist/index.js entry wrapper.
 */
 async function buildServer(opts) {
-	const { build: viteBuild, mergeConfig } = await importVite();
+	const { build: viteBuild, resolveConfig } = await importVite();
 	const plugins = [];
 	const viteReact = await importViteReact();
 	if (viteReact && opts.clientDir) plugins.push(viteReact());
 	plugins.push(viteAlephaSsrPreload());
 	if (opts.stats) plugins.push(analyzer({ analyzerMode: "static" }));
 	const logger = opts.silent ? createBufferedLogger() : void 0;
+	const conditions = [
+		"node",
+		"import",
+		"module",
+		"default"
+	];
+	if (opts.conditions) conditions.unshift(...opts.conditions);
 	const viteBuildServerConfig = {
 		mode: "production",
 		logLevel: opts.silent ? "silent" : void 0,
 		define: { "process.env.NODE_ENV": "\"production\"" },
 		publicDir: false,
-		ssr: { noExternal: true },
+		ssr: {
+			noExternal: true,
+			resolve: { conditions }
+		},
 		build: {
 			sourcemap: true,
 			ssr: opts.entry,
@@ -737,7 +403,7 @@ async function buildServer(opts) {
 			minify: true,
 			chunkSizeWarningLimit: 1e4,
 			rollupOptions: {
-				external: ["bun"],
+				external: [/^bun(:|$)/, /^cloudflare:/],
 				output: {
 					entryFileNames: "[hash].js",
 					chunkFileNames: "[hash].js",
@@ -755,12 +421,14 @@ async function buildServer(opts) {
 	};
 	let result;
 	try {
-		result = await viteBuild(mergeConfig(viteBuildServerConfig, opts.config || {}));
+		result = await viteBuild(viteBuildServerConfig);
 	} catch (error) {
 		logger?.flush();
 		throw error;
 	}
-	const externals = result.resolvedConfig?.ssr?.external ?? [];
+	const resolvedConfig = await resolveConfig(viteBuildServerConfig, "build");
+	const externals = [];
+	if (Array.isArray(resolvedConfig?.ssr?.external)) externals.push(...resolvedConfig.ssr.external);
 	await generateExternals({
 		distDir: opts.distDir,
 		externals
@@ -769,14 +437,17 @@ async function buildServer(opts) {
 	let template = "";
 	if (opts.clientDir) template = `__alepha.set("alepha.react.server.template", \`${(await readFile(`${opts.distDir}/${opts.clientDir}/index.html`, "utf-8")).replace(/>\s*</g, "><").trim()}\`);\n`;
 	let manifest = "";
+	let manifestData;
 	if (opts.clientDir) {
 		const viteDir = `${opts.distDir}/${opts.clientDir}/.vite`;
-		const combined = {
-			ssr: await loadJsonFile(`${viteDir}/ssr-manifest.json`),
-			client: await loadJsonFile(`${viteDir}/manifest.json`),
-			preload: await loadJsonFile(`${viteDir}/preload-manifest.json`)
+		const clientManifest = await loadJsonFile(`${viteDir}/manifest.json`);
+		const preloadManifest = await loadJsonFile(`${viteDir}/preload-manifest.json`);
+		manifestData = {
+			client: stripClientManifest(clientManifest),
+			preload: preloadManifest
 		};
-		manifest = `__alepha.set("alepha.react.ssr.manifest", ${JSON.stringify(combined)});\n`;
+		manifest = `__alepha.set("alepha.react.ssr.manifest", ${JSON.stringify(manifestData)});\n`;
+		opts.alepha.store.set("alepha.react.ssr.manifest", manifestData);
 		await rm(viteDir, {
 			recursive: true,
 			force: true
@@ -785,20 +456,38 @@ async function buildServer(opts) {
 	await writeFile(`${opts.distDir}/index.js`, `// This file was automatically generated. DO NOT MODIFY.
 // Changes to this file will be lost when the code is regenerated.
 \n${template}${manifest}import './server/${entryFile}';\n`.trim());
-	return { entryFile };
+	return {
+		entryFile,
+		manifest: manifestData
+	};
 }
 /**
 * Load a JSON file, returning undefined if it doesn't exist.
 */
-async function loadJsonFile(path$1) {
+async function loadJsonFile(path) {
 	try {
-		const content = await readFile(path$1, "utf-8");
+		const content = await readFile(path, "utf-8");
 		return JSON.parse(content);
 	} catch {
 		return;
 	}
 }
 /**
+* Strip unused fields from client manifest to reduce bundle size.
+* Only keeps: file, isEntry, imports, css
+*/
+function stripClientManifest(manifest) {
+	if (!manifest) return void 0;
+	const stripped = {};
+	for (const [key, entry] of Object.entries(manifest)) stripped[key] = {
+		file: entry.file,
+		...entry.isEntry && { isEntry: entry.isEntry },
+		...entry.imports?.length && { imports: entry.imports },
+		...entry.css?.length && { css: entry.css }
+	};
+	return stripped;
+}
+/**
 * Extract entry filename from Vite build result.
 */
 function extractEntryFromBundle(entry, result) {
@@ -808,28 +497,6 @@ function extractEntryFromBundle(entry, result) {
 	return entryFile;
 }
 
-//#endregion
-//#region ../../src/vite/helpers/importAlepha.ts
-/**
-* Import Alepha instance from a transpiled server entry file.
-*/
-const importAlepha = async (entry, options) => {
-	if (global.__cli_alepha) return global.__cli_alepha;
-	const { loadEnv } = await importVite();
-	const env = loadEnv("development", process.cwd(), "");
-	for (const key in env) process.env[key] = env[key];
-	if (options?.env) for (const key in options.env) process.env[key] = options.env[key];
-	process.env.ALEPHA_CLI_IMPORT = "true";
-	process.env.LOG_LEVEL = "error";
-	process.env.LOG_FORMAT = "pretty";
-	process.env.NODE_ENV = "production";
-	const mod = await import(pathToFileURL(join(process.cwd(), entry)).href);
-	if (mod.default) return mod.default;
-	const alepha = global.__cli_alepha;
-	if (!alepha) throw new AlephaError("Alepha instance not found. Ensure Alepha is initialized.");
-	return alepha;
-};
-
 //#endregion
 //#region ../../src/vite/tasks/copyAssets.ts
 /**
@@ -842,8 +509,8 @@ const importAlepha = async (entry, options) => {
 * Used by modules like AlephaServerSwagger to distribute UI files.
 */
 async function copyAssets(opts) {
-	const root = opts.root ?? process.cwd();
-	const assets = (await importAlepha(opts.entry)).store.get("alepha.build.assets");
+	const root = opts.root;
+	const assets = opts.alepha.store.get("alepha.build.assets");
 	if (!assets || assets.length === 0) return;
 	const fn = async () => {
 		const require = createRequire(join(root, opts.entry));
@@ -858,35 +525,6 @@ async function copyAssets(opts) {
 	else await fn();
 }
 
-//#endregion
-//#region ../../src/vite/tasks/devServer.ts
-/**
-* Start Vite development server with Alepha plugins.
-*
-* This task starts the Vite dev server with all required plugins:
-* - @vitejs/plugin-react (JSX/TSX compilation)
-* - viteAlephaDev (Alepha server integration)
-* - viteAlephaSsrPreload (SSR module preloading)
-*/
-async function devServer(opts = {}) {
-	const { createServer, mergeConfig } = await importVite();
-	const plugins = [];
-	const viteReact = await importViteReact();
-	if (viteReact) plugins.push(viteReact());
-	plugins.push(viteAlephaSsrPreload());
-	plugins.push(await viteAlephaDev({
-		serverEntry: opts.entry,
-		debug: opts.debug
-	}));
-	await (await createServer(mergeConfig({
-		plugins,
-		server: {
-			port: opts.port,
-			host: opts.host
-		}
-	}, {}))).listen();
-}
-
 //#endregion
 //#region ../../src/vite/tasks/generateCloudflare.ts
 const WARNING_COMMENT$1 = "// This file was automatically generated. DO NOT MODIFY.\n// Changes to this file will be lost when the code is regenerated.\n";
@@ -907,6 +545,11 @@ async function generateCloudflare(opts = {}) {
 		main: "./main.cloudflare.js",
 		compatibility_flags: ["nodejs_compat"],
 		compatibility_date: "2025-11-17",
+		no_bundle: true,
+		rules: [{
+			type: "ESModule",
+			globs: ["index.js", "server/*.js"]
+		}],
 		...opts.config
 	};
 	if (hasAssets) wrangler.assets ??= {
@@ -915,15 +558,15 @@ async function generateCloudflare(opts = {}) {
 	};
 	const url = process.env.DATABASE_URL;
 	if (url?.startsWith("cloudflare-d1:")) {
-		const [name$1, id] = url.replace("cloudflare-d1://", "").replace("cloudflare-d1:", "").split(":");
+		const [name, id] = url.replace("cloudflare-d1://", "").replace("cloudflare-d1:", "").split(":");
 		wrangler.d1_databases = wrangler.d1_databases || [];
 		wrangler.d1_databases.push({
-			binding: name$1,
-			database_name: name$1,
+			binding: name,
+			database_name: name,
 			database_id: id
 		});
 		wrangler.vars ??= {};
-		wrangler.vars.DATABASE_URL = `cloudflare-d1://${name$1}:${id}`;
+		wrangler.vars.DATABASE_URL = `cloudflare-d1://${name}:${id}`;
 	}
 	await writeFile(join(root, distDir, "wrangler.jsonc"), JSON.stringify(wrangler, null, 2));
 	await writeWorkerEntryPoint(root, distDir);
@@ -953,8 +596,8 @@ export default {
 
 //#endregion
 //#region ../../src/vite/helpers/fileExists.ts
-const fileExists = async (path$1) => {
-	return await access(join(process.cwd(), path$1)).then(() => true).catch(() => false);
+const fileExists = async (path) => {
+	return await access(join(process.cwd(), path)).then(() => true).catch(() => false);
 };
 
 //#endregion
@@ -1000,41 +643,56 @@ CMD ["${command}", "index.js"]
 /**
 * Generate sitemap.xml from Alepha page primitives.
 *
-* This task loads the built Alepha application,
-* queries all page primitives, and generates a sitemap.xml
+* Queries all page primitives and generates a sitemap.xml
 * containing URLs for all accessible pages.
 */
 async function generateSitemap(opts) {
-	const alepha = await importAlepha(opts.entry);
-	if (opts.template) alepha.set("alepha.react.server.template", opts.template);
-	if (!alepha.isConfigured()) {
-		await alepha.events.emit("configure", alepha);
-		alepha.configured = true;
-	}
-	return generateSitemapFromAlepha(alepha, opts.baseUrl);
+	const pages = getSitemapPages(opts.alepha);
+	if (pages.length === 0) return "";
+	let result = "";
+	const fn = async () => {
+		result = generateSitemapFromPages(pages, opts.baseUrl);
+		if (opts.output) await writeFile(opts.output, result);
+	};
+	if (opts.run) await opts.run({
+		name: "generate sitemap",
+		handler: fn
+	});
+	else await fn();
+	return result;
+}
+/**
+* Get all pages that should be included in the sitemap.
+*/
+function getSitemapPages(alepha) {
+	return alepha.primitives("page").filter((page) => {
+		const options = page.options;
+		if (options.children) return false;
+		if (!options.schema?.params) return true;
+		if (options.static && typeof options.static === "object" && options.static.entries) return true;
+		return false;
+	});
 }
-function generateSitemapFromAlepha(alepha, baseUrl) {
-	const pages = alepha.primitives("page");
+function generateSitemapFromPages(pages, baseUrl) {
 	const urls = [];
+	const normalizedBaseUrl = baseUrl.replace(/\/$/, "");
 	for (const page of pages) {
 		const options = page.options;
-		if (options.children) continue;
 		if (!options.schema?.params) {
-			const path$1 = options.path || "";
-			const url = `${baseUrl.replace(/\/$/, "")}${path$1 === "" ? "/" : path$1}`;
+			const path = options.path || "";
+			const url = `${normalizedBaseUrl}${path === "" ? "/" : path}`;
 			urls.push(url);
 		} else if (options.static && typeof options.static === "object" && options.static.entries) for (const entry of options.static.entries) {
-			const path$1 = buildPathFromParams(options.path || "", entry.params || {});
-			const url = `${baseUrl.replace(/\/$/, "")}${path$1}`;
+			const url = `${normalizedBaseUrl}${buildPathFromParams(options.path || "", entry.params || {})}`;
 			urls.push(url);
 		}
 	}
 	return buildSitemapXml(urls);
 }
 function buildPathFromParams(pathPattern, params) {
-	let path$1 = pathPattern;
-	for (const [key, value] of Object.entries(params)) path$1 = path$1.replace(`:${key}`, String(value));
-	return path$1 || "/";
+	let path = pathPattern;
+	for (const [key, value] of Object.entries(params)) path = path.replace(`:${key}`, String(value));
+	return path || "/";
 }
 function buildSitemapXml(urls) {
 	const lastMod = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -1074,8 +732,8 @@ async function generateVercel(opts = {}) {
 /**
 * Check if a file or directory exists at the given path
 */
-async function exists(path$1) {
-	return stat(path$1).then(() => true).catch(() => false);
+async function exists(path) {
+	return stat(path).then(() => true).catch(() => false);
 }
 /**
 * Create the serverless function entry point that bootstraps Alepha and handles requests
@@ -1121,10 +779,10 @@ async function writeProjectConfig(distDir, projectId, projectName, orgId) {
 * Create the client directory with a .keep file if it doesn't exist to avoid Vercel errors
 */
 async function ensureClientDir(distDir, clientDir) {
-	const path$1 = `${distDir}/${clientDir}`;
-	if (!await exists(path$1)) {
-		await mkdir(path$1, { recursive: true });
-		await writeFile(`${path$1}/.keep`, "");
+	const path = `${distDir}/${clientDir}`;
+	if (!await exists(path)) {
+		await mkdir(path, { recursive: true });
+		await writeFile(`${path}/.keep`, "");
 	}
 }
 
@@ -1133,26 +791,39 @@ async function ensureClientDir(distDir, clientDir) {
 /**
 * Pre-render static pages defined in the Alepha application.
 *
-* This task loads the built Alepha application, queries all page
-* primitives with `static: true`, and generates static HTML files
-* for each page. Supports pages with parameterized routes via
-* `static.entries` configuration.
+* Queries all page primitives with `static: true` and generates
+* static HTML files for each page. Supports pages with parameterized
+* routes via `static.entries` configuration.
 */
 async function prerenderPages(opts) {
-	const alepha = await importAlepha(opts.entry);
-	if (!alepha.isConfigured()) {
-		await alepha.events.emit("configure", alepha);
-		alepha.configured = true;
-	}
-	return await prerenderFromAlepha(alepha, opts.dist, opts.compress);
+	const alepha = opts.alepha;
+	const pages = getStaticPages(alepha);
+	if (pages.length === 0) return { count: 0 };
+	let result = { count: 0 };
+	const fn = async () => {
+		if (!alepha.isConfigured()) await alepha.events.emit("configure", alepha);
+		result = await prerenderFromAlepha(pages, opts.dist, opts.compress);
+	};
+	if (opts.run) await opts.run({
+		name: "pre-render pages",
+		handler: fn
+	});
+	else await fn();
+	return result;
+}
+/**
+* Get all static pages from the Alepha instance.
+*/
+function getStaticPages(alepha) {
+	return alepha.primitives("page").filter((page) => {
+		const options = page.options;
+		return options.static && !options.children;
+	});
 }
-async function prerenderFromAlepha(alepha, dist, compress) {
+async function prerenderFromAlepha(pages, dist, compress) {
 	let count = 0;
-	const pages = alepha.primitives("page");
 	for (const page of pages) {
 		const options = page.options;
-		if (options.children) continue;
-		if (!options.static) continue;
 		const config = typeof options.static === "object" ? options.static : {};
 		if (!options.schema?.params) {
 			count += 1;
@@ -1179,5 +850,5 @@ async function renderFile(page, options, dist, compress) {
 }
 
 //#endregion
-export { AlephaRunner, boot, buildClient, buildServer, compressFile, copyAssets, createAlephaRunner, createBufferedLogger, devServer, generateCloudflare, generateDocker, generateExternals, generateSitemap, generateVercel, isViteInternalPath, prerenderPages, viteAlephaDev, viteAlephaSsrPreload, viteCompress };
+export { buildClient, buildServer, compressFile, copyAssets, createBufferedLogger, generateCloudflare, generateDocker, generateExternals, generateSitemap, generateVercel, importVite, importViteReact, prerenderPages, viteAlephaSsrPreload, viteCompress };
 //# sourceMappingURL=index.js.map