alepha 0.15.2 → 0.15.4

package/dist/react/router/index.js

@@ -156,12 +156,6 @@ var PagePrimitive = class extends Primitive {
 	async fetch(options) {
 		return this.reactPageService.fetch(this.options.path || "", options);
 	}
-	match(url) {
-		return false;
-	}
-	pathname(config) {
-		return this.options.path || "";
-	}
 };
 $page[KIND] = PagePrimitive;
 
@@ -1165,7 +1159,7 @@ var ReactPageProvider = class {
 	}
 	pathname(name, options = {}) {
 		const page = this.page(name);
-		if (!page) throw new Error(`Page ${name} not found`);
+		if (!page) throw new AlephaError(`Page ${name} not found`);
 		let url = page.path ?? "";
 		let parent = page.parent;
 		while (parent) {
@@ -1446,164 +1440,461 @@ const isPageRoute = (it) => {
 };
 
 //#endregion
-//#region ../../src/system/providers/FileSystemProvider.ts
+//#region ../../src/react/router/atoms/ssrManifestAtom.ts
 /**
-* FileSystem interface providing utilities for working with files.
+* Schema for the SSR manifest atom.
 */
-var FileSystemProvider = class {};
-
-//#endregion
-//#region ../../src/system/providers/MemoryFileSystemProvider.ts
+const ssrManifestAtomSchema = t.object({
+	base: t.optional(t.string()),
+	preload: t.optional(t.record(t.string(), t.string())),
+	client: t.optional(t.record(t.string(), t.object({
+		file: t.string(),
+		isEntry: t.optional(t.boolean()),
+		imports: t.optional(t.array(t.string())),
+		css: t.optional(t.array(t.string()))
+	}))),
+	devHead: t.optional(t.string())
+});
 /**
-* In-memory implementation of FileSystemProvider for testing.
+* SSR Manifest atom containing all manifest data for SSR module preloading.
 *
-* This provider stores all files and directories in memory, making it ideal for
-* unit tests that need to verify file operations without touching the real file system.
+* This atom is populated at build time by embedding manifest data into the
+* generated index.js. This approach is optimal for serverless deployments
+* as it eliminates filesystem reads at runtime.
 *
-* @example
-* ```typescript
-* // In tests, substitute the real FileSystemProvider with MemoryFileSystemProvider
-* const alepha = Alepha.create().with({
-*   provide: FileSystemProvider,
-*   use: MemoryFileSystemProvider,
-* });
+* The manifest includes:
+* - preload: Maps short hash keys to source paths (from viteAlephaSsrPreload)
+* - client: Maps source files to their output info (file, imports, css)
+*/
+const ssrManifestAtom = $atom({
+	name: "alepha.react.ssr.manifest",
+	description: "SSR manifest for module preloading",
+	schema: ssrManifestAtomSchema,
+	default: {}
+});
+
+//#endregion
+//#region ../../src/react/router/providers/SSRManifestProvider.ts
+/**
+* Provider for SSR manifest data used for module preloading.
 *
-* // Run code that uses FileSystemProvider
-* const service = alepha.inject(MyService);
-* await service.saveFile("test.txt", "Hello World");
+* The manifest is populated at build time by embedding data into the
+* generated index.js via the ssrManifestAtom. This eliminates filesystem
+* reads at runtime, making it optimal for serverless deployments.
 *
-* // Verify the file was written
-* const memoryFs = alepha.inject(MemoryFileSystemProvider);
-* expect(memoryFs.files.get("test.txt")?.toString()).toBe("Hello World");
-* ```
+* Manifest files are generated during `vite build`:
+* - manifest.json (client manifest)
+* - preload-manifest.json (from viteAlephaSsrPreload plugin)
 */
-var MemoryFileSystemProvider = class {
-	json = $inject(Json);
-	/**
-	* In-memory storage for files (path -> content)
-	*/
-	files = /* @__PURE__ */ new Map();
-	/**
-	* In-memory storage for directories
-	*/
-	directories = /* @__PURE__ */ new Set();
+var SSRManifestProvider = class {
+	alepha = $inject(Alepha);
 	/**
-	* Track mkdir calls for test assertions
+	* Get the manifest from the store at runtime.
+	* This ensures the manifest is available even when set after module load.
 	*/
-	mkdirCalls = [];
+	get manifest() {
+		return this.alepha.store.get(ssrManifestAtom) ?? {};
+	}
 	/**
-	* Track writeFile calls for test assertions
+	* Get the full manifest object.
 	*/
-	writeFileCalls = [];
+	getManifest() {
+		return this.manifest;
+	}
 	/**
-	* Track readFile calls for test assertions
+	* Get the base path for assets (from Vite's base config).
+	* Returns empty string if base is "/" (default), otherwise returns the base path.
 	*/
-	readFileCalls = [];
+	get base() {
+		return this.manifest.base ?? "";
+	}
 	/**
-	* Track rm calls for test assertions
+	* Get the preload manifest.
 	*/
-	rmCalls = [];
+	get preloadManifest() {
+		return this.manifest.preload;
+	}
 	/**
-	* Track join calls for test assertions
+	* Get the client manifest.
 	*/
-	joinCalls = [];
+	get clientManifest() {
+		return this.manifest.client;
+	}
 	/**
-	* Error to throw on mkdir (for testing error handling)
+	* Resolve a preload key to its source path.
+	*
+	* The key is a short hash injected by viteAlephaSsrPreload plugin,
+	* which maps to the full source path in the preload manifest.
+	*
+	* @param key - Short hash key (e.g., "a1b2c3d4")
+	* @returns Source path (e.g., "src/pages/UserDetail.tsx") or undefined
 	*/
-	mkdirError = null;
+	resolvePreloadKey(key) {
+		return this.preloadManifest?.[key];
+	}
 	/**
-	* Error to throw on writeFile (for testing error handling)
+	* Get all chunks required for a source file, including transitive dependencies.
+	*
+	* Uses the client manifest to recursively resolve all imported chunks.
+	*
+	* @param sourcePath - Source file path (e.g., "src/pages/Home.tsx")
+	* @returns Array of chunk URLs to preload, or empty array if not found
 	*/
-	writeFileError = null;
+	getChunks(sourcePath) {
+		if (!this.clientManifest) return [];
+		if (!this.findManifestEntry(sourcePath)) return [];
+		const chunks = /* @__PURE__ */ new Set();
+		const visited = /* @__PURE__ */ new Set();
+		this.collectChunksRecursive(sourcePath, chunks, visited);
+		return Array.from(chunks);
+	}
 	/**
-	* Error to throw on readFile (for testing error handling)
+	* Find manifest entry for a source path, trying different extensions.
 	*/
-	readFileError = null;
-	constructor(options = {}) {
-		this.mkdirError = options.mkdirError ?? null;
-		this.writeFileError = options.writeFileError ?? null;
-		this.readFileError = options.readFileError ?? null;
+	findManifestEntry(sourcePath) {
+		if (!this.clientManifest) return void 0;
+		if (this.clientManifest[sourcePath]) return this.clientManifest[sourcePath];
+		const basePath = sourcePath.replace(/\.[^.]+$/, "");
+		for (const ext of [
+			".tsx",
+			".ts",
+			".jsx",
+			".js"
+		]) {
+			const pathWithExt = basePath + ext;
+			if (this.clientManifest[pathWithExt]) return this.clientManifest[pathWithExt];
+		}
 	}
 	/**
-	* Join path segments using forward slashes.
-	* Uses Node's path.join for proper normalization (handles .. and .)
+	* Recursively collect all chunk URLs for a manifest entry.
 	*/
-	join(...paths) {
-		this.joinCalls.push(paths);
-		return join(...paths);
+	collectChunksRecursive(key, chunks, visited) {
+		if (visited.has(key)) return;
+		visited.add(key);
+		if (!this.clientManifest) return;
+		const entry = this.clientManifest[key];
+		if (!entry) return;
+		const base = this.base;
+		if (entry.file) chunks.add(`${base}/${entry.file}`);
+		if (entry.css) for (const css of entry.css) chunks.add(`${base}/${css}`);
+		if (entry.imports) for (const imp of entry.imports) {
+			if (imp === "index.html" || imp.endsWith(".html")) continue;
+			this.collectChunksRecursive(imp, chunks, visited);
+		}
 	}
 	/**
-	* Create a FileLike object from various sources.
+	* Collect modulepreload links for a route and its parent chain.
 	*/
-	createFile(options) {
-		if ("path" in options) {
-			const filePath = options.path;
-			const buffer = this.files.get(filePath);
-			if (buffer === void 0) throw new Error(`ENOENT: no such file or directory, open '${filePath}'`);
-			return {
-				name: options.name ?? filePath.split("/").pop() ?? "file",
-				type: options.type ?? "application/octet-stream",
-				size: buffer.byteLength,
-				lastModified: Date.now(),
-				stream: () => {
-					throw new Error("Stream not implemented in MemoryFileSystemProvider");
-				},
-				arrayBuffer: async () => buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength),
-				text: async () => buffer.toString("utf-8")
-			};
+	collectPreloadLinks(route) {
+		if (!this.isAvailable()) return [];
+		const preloadPaths = [];
+		let current = route;
+		while (current) {
+			const preloadKey = current[PAGE_PRELOAD_KEY];
+			if (preloadKey) {
+				const sourcePath = this.resolvePreloadKey(preloadKey);
+				if (sourcePath) preloadPaths.push(sourcePath);
+			}
+			current = current.parent;
 		}
-		if ("buffer" in options) {
-			const buffer = options.buffer;
-			return {
-				name: options.name ?? "file",
-				type: options.type ?? "application/octet-stream",
-				size: buffer.byteLength,
-				lastModified: Date.now(),
-				stream: () => {
-					throw new Error("Stream not implemented in MemoryFileSystemProvider");
-				},
-				arrayBuffer: async () => buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength),
-				text: async () => buffer.toString("utf-8")
+		if (preloadPaths.length === 0) return [];
+		return this.getChunksForMultiple(preloadPaths).map((href) => {
+			if (href.endsWith(".css")) return {
+				rel: "preload",
+				href,
+				as: "style",
+				crossorigin: ""
 			};
-		}
-		if ("text" in options) {
-			const buffer = Buffer.from(options.text, "utf-8");
 			return {
-				name: options.name ?? "file.txt",
-				type: options.type ?? "text/plain",
-				size: buffer.byteLength,
-				lastModified: Date.now(),
-				stream: () => {
-					throw new Error("Stream not implemented in MemoryFileSystemProvider");
-				},
-				arrayBuffer: async () => buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength),
-				text: async () => options.text
+				rel: "modulepreload",
+				href
 			};
-		}
-		throw new Error("MemoryFileSystemProvider.createFile: unsupported options. Only buffer and text are supported.");
-	}
-	/**
-	* Remove a file or directory from memory.
-	*/
-	async rm(path, options) {
-		this.rmCalls.push({
-			path,
-			options
 		});
-		if (!(this.files.has(path) || this.directories.has(path)) && !options?.force) throw new Error(`ENOENT: no such file or directory, rm '${path}'`);
-		if (this.directories.has(path)) if (options?.recursive) {
-			this.directories.delete(path);
-			for (const filePath of this.files.keys()) if (filePath.startsWith(`${path}/`)) this.files.delete(filePath);
-			for (const dirPath of this.directories) if (dirPath.startsWith(`${path}/`)) this.directories.delete(dirPath);
-		} else throw new Error(`EISDIR: illegal operation on a directory, rm '${path}'`);
-		else this.files.delete(path);
 	}
 	/**
-	* Copy a file or directory in memory.
+	* Get all chunks for multiple source files.
+	*
+	* @param sourcePaths - Array of source file paths
+	* @returns Deduplicated array of chunk URLs
 	*/
-	async cp(src, dest, options) {
-		if (this.directories.has(src)) {
-			if (!options?.recursive) throw new Error(`Cannot copy directory without recursive option: ${src}`);
+	getChunksForMultiple(sourcePaths) {
+		const allChunks = /* @__PURE__ */ new Set();
+		for (const path of sourcePaths) {
+			const chunks = this.getChunks(path);
+			for (const chunk of chunks) allChunks.add(chunk);
+		}
+		return Array.from(allChunks);
+	}
+	/**
+	* Check if manifest is loaded and available.
+	*/
+	isAvailable() {
+		return this.clientManifest !== void 0;
+	}
+	/**
+	* Cached entry assets - computed once at first access.
+	*/
+	cachedEntryAssets = null;
+	/**
+	* Get the entry point assets (main entry.js and associated CSS files).
+	*
+	* These assets are always required for all pages and can be preloaded
+	* before page-specific loaders run.
+	*
+	* @returns Entry assets with js and css paths, or null if manifest unavailable
+	*/
+	getEntryAssets() {
+		if (this.cachedEntryAssets) return this.cachedEntryAssets;
+		if (!this.clientManifest) return null;
+		const base = this.base;
+		for (const [key, entry] of Object.entries(this.clientManifest)) if (entry.isEntry) {
+			this.cachedEntryAssets = {
+				js: `${base}/${entry.file}`,
+				css: entry.css?.map((css) => `${base}/${css}`) ?? []
+			};
+			return this.cachedEntryAssets;
+		}
+		return null;
+	}
+	/**
+	* Build preload link tags for entry assets.
+	*
+	* @returns Array of link objects ready to be rendered
+	*/
+	getEntryPreloadLinks() {
+		const assets = this.getEntryAssets();
+		if (!assets) return [];
+		const links = [];
+		for (const css of assets.css) links.push({
+			rel: "stylesheet",
+			href: css,
+			crossorigin: ""
+		});
+		if (assets.js) links.push({
+			rel: "modulepreload",
+			href: assets.js
+		});
+		return links;
+	}
+};
+
+//#endregion
+//#region ../../src/react/router/providers/ReactPreloadProvider.ts
+/**
+* Adds HTTP Link headers for preloading entry assets.
+*
+* Benefits:
+* - Early Hints (103): Servers can send preload hints before the full response
+* - CDN optimization: Many CDNs use Link headers to optimize asset delivery
+* - Browser prefetching: Browsers can start fetching resources earlier
+*
+* The Link header is computed once at first request and cached for reuse.
+*/
+var ReactPreloadProvider = class {
+	alepha = $inject(Alepha);
+	ssrManifest = $inject(SSRManifestProvider);
+	/**
+	* Cached Link header value - computed once, reused for all requests.
+	*/
+	cachedLinkHeader;
+	/**
+	* Build the Link header string from entry assets.
+	*
+	* Format: <url>; rel=preload; as=type, <url>; rel=modulepreload
+	*
+	* @returns Link header string or null if no assets
+	*/
+	buildLinkHeader() {
+		const assets = this.ssrManifest.getEntryAssets();
+		if (!assets) return null;
+		const links = [];
+		for (const css of assets.css) links.push(`<${css}>; rel=preload; as=style`);
+		if (assets.js) links.push(`<${assets.js}>; rel=modulepreload`);
+		return links.length > 0 ? links.join(", ") : null;
+	}
+	/**
+	* Get the cached Link header, computing it on first access.
+	*/
+	getLinkHeader() {
+		if (this.cachedLinkHeader === void 0) this.cachedLinkHeader = this.buildLinkHeader();
+		return this.cachedLinkHeader;
+	}
+	/**
+	* Add Link header to HTML responses for asset preloading.
+	*/
+	onResponse = $hook({
+		on: "server:onResponse",
+		priority: "first",
+		handler: ({ response }) => {
+			const contentType = response.headers["content-type"];
+			if (!contentType || !contentType.includes("text/html")) return;
+			const linkHeader = this.getLinkHeader();
+			if (!linkHeader) return;
+			if (response.headers.link) response.headers.link = `${response.headers.link}, ${linkHeader}`;
+			else response.headers.link = linkHeader;
+		}
+	});
+};
+
+//#endregion
+//#region ../../src/system/providers/FileSystemProvider.ts
+/**
+* FileSystem interface providing utilities for working with files.
+*/
+var FileSystemProvider = class {};
+
+//#endregion
+//#region ../../src/system/providers/MemoryFileSystemProvider.ts
+/**
+* In-memory implementation of FileSystemProvider for testing.
+*
+* This provider stores all files and directories in memory, making it ideal for
+* unit tests that need to verify file operations without touching the real file system.
+*
+* @example
+* ```typescript
+* // In tests, substitute the real FileSystemProvider with MemoryFileSystemProvider
+* const alepha = Alepha.create().with({
+*   provide: FileSystemProvider,
+*   use: MemoryFileSystemProvider,
+* });
+*
+* // Run code that uses FileSystemProvider
+* const service = alepha.inject(MyService);
+* await service.saveFile("test.txt", "Hello World");
+*
+* // Verify the file was written
+* const memoryFs = alepha.inject(MemoryFileSystemProvider);
+* expect(memoryFs.files.get("test.txt")?.toString()).toBe("Hello World");
+* ```
+*/
+var MemoryFileSystemProvider = class {
+	json = $inject(Json);
+	/**
+	* In-memory storage for files (path -> content)
+	*/
+	files = /* @__PURE__ */ new Map();
+	/**
+	* In-memory storage for directories
+	*/
+	directories = /* @__PURE__ */ new Set();
+	/**
+	* Track mkdir calls for test assertions
+	*/
+	mkdirCalls = [];
+	/**
+	* Track writeFile calls for test assertions
+	*/
+	writeFileCalls = [];
+	/**
+	* Track readFile calls for test assertions
+	*/
+	readFileCalls = [];
+	/**
+	* Track rm calls for test assertions
+	*/
+	rmCalls = [];
+	/**
+	* Track join calls for test assertions
+	*/
+	joinCalls = [];
+	/**
+	* Error to throw on mkdir (for testing error handling)
+	*/
+	mkdirError = null;
+	/**
+	* Error to throw on writeFile (for testing error handling)
+	*/
+	writeFileError = null;
+	/**
+	* Error to throw on readFile (for testing error handling)
+	*/
+	readFileError = null;
+	constructor(options = {}) {
+		this.mkdirError = options.mkdirError ?? null;
+		this.writeFileError = options.writeFileError ?? null;
+		this.readFileError = options.readFileError ?? null;
+	}
+	/**
+	* Join path segments using forward slashes.
+	* Uses Node's path.join for proper normalization (handles .. and .)
+	*/
+	join(...paths) {
+		this.joinCalls.push(paths);
+		return join(...paths);
+	}
+	/**
+	* Create a FileLike object from various sources.
+	*/
+	createFile(options) {
+		if ("path" in options) {
+			const filePath = options.path;
+			const buffer = this.files.get(filePath);
+			if (buffer === void 0) throw new Error(`ENOENT: no such file or directory, open '${filePath}'`);
+			return {
+				name: options.name ?? filePath.split("/").pop() ?? "file",
+				type: options.type ?? "application/octet-stream",
+				size: buffer.byteLength,
+				lastModified: Date.now(),
+				stream: () => {
+					throw new Error("Stream not implemented in MemoryFileSystemProvider");
+				},
+				arrayBuffer: async () => buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength),
+				text: async () => buffer.toString("utf-8")
+			};
+		}
+		if ("buffer" in options) {
+			const buffer = options.buffer;
+			return {
+				name: options.name ?? "file",
+				type: options.type ?? "application/octet-stream",
+				size: buffer.byteLength,
+				lastModified: Date.now(),
+				stream: () => {
+					throw new Error("Stream not implemented in MemoryFileSystemProvider");
+				},
+				arrayBuffer: async () => buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength),
+				text: async () => buffer.toString("utf-8")
+			};
+		}
+		if ("text" in options) {
+			const buffer = Buffer.from(options.text, "utf-8");
+			return {
+				name: options.name ?? "file.txt",
+				type: options.type ?? "text/plain",
+				size: buffer.byteLength,
+				lastModified: Date.now(),
+				stream: () => {
+					throw new Error("Stream not implemented in MemoryFileSystemProvider");
+				},
+				arrayBuffer: async () => buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength),
+				text: async () => options.text
+			};
+		}
+		throw new Error("MemoryFileSystemProvider.createFile: unsupported options. Only buffer and text are supported.");
+	}
+	/**
+	* Remove a file or directory from memory.
+	*/
+	async rm(path, options) {
+		this.rmCalls.push({
+			path,
+			options
+		});
+		if (!(this.files.has(path) || this.directories.has(path)) && !options?.force) throw new Error(`ENOENT: no such file or directory, rm '${path}'`);
+		if (this.directories.has(path)) if (options?.recursive) {
+			this.directories.delete(path);
+			for (const filePath of this.files.keys()) if (filePath.startsWith(`${path}/`)) this.files.delete(filePath);
+			for (const dirPath of this.directories) if (dirPath.startsWith(`${path}/`)) this.directories.delete(dirPath);
+		} else throw new Error(`EISDIR: illegal operation on a directory, rm '${path}'`);
+		else this.files.delete(path);
+	}
+	/**
+	* Copy a file or directory in memory.
+	*/
+	async cp(src, dest, options) {
+		if (this.directories.has(src)) {
+			if (!options?.recursive) throw new Error(`Cannot copy directory without recursive option: ${src}`);
 			this.directories.add(dest);
 			for (const [filePath, content] of this.files) if (filePath.startsWith(`${src}/`)) {
 				const newPath = filePath.replace(src, dest);
@@ -2804,8 +3095,13 @@ var NodeFileSystemProvider = class {
 	* await fs.mkdir("/tmp/mydir", { mode: 0o755 });
 	* ```
 	*/
-	async mkdir(path, options) {
-		await mkdir(path, options);
+	async mkdir(path, options = {}) {
+		const p = mkdir(path, {
+			recursive: options.recursive ?? true,
+			mode: options.mode
+		});
+		if (options.force === false) await p;
+		else await p.catch(() => {});
 	}
 	/**
 	* Lists files in a directory.
@@ -3283,235 +3579,99 @@ const AlephaSystem = $module({
 //#endregion
 //#region ../../src/react/router/providers/ReactServerTemplateProvider.ts
 /**
-* Handles HTML template parsing, preprocessing, and streaming for SSR.
-*
-* Responsibilities:
-* - Parse template once at startup into logical slots
-* - Pre-encode static parts as Uint8Array for zero-copy streaming
-* - Render dynamic parts (attributes, head content) efficiently
-* - Build hydration data for client-side rehydration
+* Handles HTML streaming for SSR.
 *
-* This provider is injected into ReactServerProvider to handle all
-* template-related operations, keeping ReactServerProvider focused
-* on request handling and React rendering coordination.
+* Uses hardcoded HTML structure - all customization via $head primitive.
+* Pre-encodes static parts as Uint8Array for zero-copy streaming.
 */
 var ReactServerTemplateProvider = class {
 	log = $logger();
 	alepha = $inject(Alepha);
 	/**
-	* Shared TextEncoder instance - reused across all requests.
+	* Shared TextEncoder - reused across all requests.
 	*/
 	encoder = new TextEncoder();
 	/**
-	* Pre-encoded common strings for streaming.
-	*/
-	ENCODED = {
+	* Pre-encoded static HTML parts for zero-copy streaming.
+	*/
+	SLOTS = {
+		DOCTYPE: this.encoder.encode("<!DOCTYPE html>\n"),
+		HTML_OPEN: this.encoder.encode("<html"),
+		HTML_CLOSE: this.encoder.encode(">\n"),
+		HEAD_OPEN: this.encoder.encode("<head>"),
+		HEAD_CLOSE: this.encoder.encode("</head>\n"),
+		BODY_OPEN: this.encoder.encode("<body"),
+		BODY_CLOSE: this.encoder.encode(">\n"),
+		ROOT_OPEN: this.encoder.encode("<div id=\"root\">"),
+		ROOT_CLOSE: this.encoder.encode("</div>\n"),
+		BODY_HTML_CLOSE: this.encoder.encode("</body>\n</html>"),
 		HYDRATION_PREFIX: this.encoder.encode("<script>window.__ssr="),
-		HYDRATION_SUFFIX: this.encoder.encode("<\/script>"),
-		EMPTY: this.encoder.encode("")
+		HYDRATION_SUFFIX: this.encoder.encode("<\/script>")
 	};
 	/**
-	* Cached template slots - parsed once, reused for all requests.
+	* Early head content (charset, viewport, entry assets).
+	* Set once during configuration, reused for all requests.
 	*/
-	slots = null;
+	earlyHeadContent = "";
 	/**
 	* Root element ID for React mounting.
 	*/
-	get rootId() {
-		return "root";
-	}
+	rootId = "root";
 	/**
-	* Regex pattern for matching the root div and extracting its content.
+	* Regex for extracting root div content from HTML.
 	*/
-	get rootDivRegex() {
-		return new RegExp(`<div([^>]*)\\s+id=["']${this.rootId}["']([^>]*)>([\\s\\S]*?)<\\/div>`, "i");
-	}
+	rootDivRegex = new RegExp(`<div[^>]*\\s+id=["']${this.rootId}["'][^>]*>([\\s\\S]*?)<\\/div>`, "i");
 	/**
-	* Extract the content inside the root div from HTML.
-	*
-	* @param html - Full HTML string
-	* @returns The content inside the root div, or undefined if not found
+	* Extract content inside the root div from HTML.
 	*/
 	extractRootContent(html) {
-		return html.match(this.rootDivRegex)?.[3];
+		return html.match(this.rootDivRegex)?.[1];
 	}
 	/**
-	* Check if template has been parsed and slots are available.
+	* Set early head content (charset, viewport, entry assets).
+	* Called once during server configuration.
 	*/
-	isReady() {
-		return this.slots !== null;
+	setEarlyHeadContent(entryAssets, globalHead) {
+		const charset = globalHead?.charset ?? "UTF-8";
+		const viewport = globalHead?.viewport ?? "width=device-width, initial-scale=1";
+		this.earlyHeadContent = `<meta charset="${this.escapeHtml(charset)}">\n<meta name="viewport" content="${this.escapeHtml(viewport)}">\n` + entryAssets;
 	}
 	/**
-	* Get the parsed template slots.
-	* Throws if template hasn't been parsed yet.
-	*/
-	getSlots() {
-		if (!this.slots) throw new AlephaError("Template not parsed. Call parseTemplate() during configuration.");
-		return this.slots;
-	}
-	/**
-	* Parse an HTML template into logical slots for efficient streaming.
-	*
-	* This should be called once during server startup/configuration.
-	* The parsed slots are cached and reused for all requests.
-	*/
-	parseTemplate(template) {
-		this.log.debug("Parsing template into slots");
-		const rootId = this.rootId;
-		const doctypeMatch = template.match(/<!DOCTYPE[^>]*>/i);
-		const doctype = doctypeMatch?.[0] ?? "<!DOCTYPE html>";
-		let remaining = doctypeMatch ? template.slice(doctypeMatch.index + doctypeMatch[0].length) : template;
-		const htmlMatch = remaining.match(/<html([^>]*)>/i);
-		const htmlAttrsStr = htmlMatch?.[1]?.trim() ?? "";
-		const htmlOriginalAttrs = this.parseAttributes(htmlAttrsStr);
-		remaining = htmlMatch ? remaining.slice(htmlMatch.index + htmlMatch[0].length) : remaining;
-		const headMatch = remaining.match(/<head([^>]*)>([\s\S]*?)<\/head>/i);
-		const headOriginalContent = headMatch?.[2]?.trim() ?? "";
-		remaining = headMatch ? remaining.slice(headMatch.index + headMatch[0].length) : remaining;
-		const bodyMatch = remaining.match(/<body([^>]*)>/i);
-		const bodyAttrsStr = bodyMatch?.[1]?.trim() ?? "";
-		const bodyOriginalAttrs = this.parseAttributes(bodyAttrsStr);
-		const bodyStartIndex = bodyMatch ? bodyMatch.index + bodyMatch[0].length : 0;
-		remaining = remaining.slice(bodyStartIndex);
-		const rootDivRegex = new RegExp(`<div([^>]*)\\s+id=["']${rootId}["']([^>]*)>([\\s\\S]*?)<\\/div>`, "i");
-		const rootMatch = remaining.match(rootDivRegex);
-		let beforeRoot = "";
-		let afterRoot = "";
-		let rootAttrs = "";
-		if (rootMatch) {
-			beforeRoot = remaining.slice(0, rootMatch.index).trim();
-			const rootEndIndex = rootMatch.index + rootMatch[0].length;
-			const bodyCloseIndex = remaining.indexOf("</body>");
-			afterRoot = bodyCloseIndex > rootEndIndex ? remaining.slice(rootEndIndex, bodyCloseIndex).trim() : "";
-			rootAttrs = `${rootMatch[1] ?? ""}${rootMatch[2] ?? ""}`.trim();
-		} else {
-			const bodyCloseIndex = remaining.indexOf("</body>");
-			if (bodyCloseIndex > 0) beforeRoot = remaining.slice(0, bodyCloseIndex).trim();
-		}
-		const rootOpenTag = rootAttrs ? `<div ${rootAttrs} id="${rootId}">` : `<div id="${rootId}">`;
-		this.slots = {
-			doctype: this.encoder.encode(`${doctype}\n`),
-			htmlOpen: this.encoder.encode("<html"),
-			htmlClose: this.encoder.encode(">\n"),
-			headOpen: this.encoder.encode("<head>"),
-			headClose: this.encoder.encode("</head>\n"),
-			bodyOpen: this.encoder.encode("<body"),
-			bodyClose: this.encoder.encode(">\n"),
-			rootOpen: this.encoder.encode(rootOpenTag),
-			rootClose: this.encoder.encode("</div>\n"),
-			scriptClose: this.encoder.encode("</body>\n</html>"),
-			htmlOriginalAttrs,
-			bodyOriginalAttrs,
-			headOriginalContent,
-			beforeRoot,
-			afterRoot
-		};
-		this.log.debug("Template parsed successfully", {
-			hasHtmlAttrs: Object.keys(htmlOriginalAttrs).length > 0,
-			hasBodyAttrs: Object.keys(bodyOriginalAttrs).length > 0,
-			hasHeadContent: headOriginalContent.length > 0,
-			hasBeforeRoot: beforeRoot.length > 0,
-			hasAfterRoot: afterRoot.length > 0
-		});
-		return this.slots;
-	}
-	/**
-	* Parse HTML attributes string into a record.
-	*
-	* Handles: key="value", key='value', key=value, and boolean key
-	*/
-	parseAttributes(attrStr) {
-		const attrs = {};
-		if (!attrStr) return attrs;
-		for (const match of attrStr.matchAll(/([^\s=]+)(?:=(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g)) {
-			const key = match[1];
-			attrs[key] = match[2] ?? match[3] ?? match[4] ?? "";
-		}
-		return attrs;
-	}
-	/**
-	* Render attributes record to HTML string.
-	*
-	* @param attrs - Attributes to render
-	* @returns HTML attribute string like ` lang="en" class="dark"`
+	* Render attributes record to HTML string.
 	*/
 	renderAttributes(attrs) {
+		if (!attrs) return "";
 		const entries = Object.entries(attrs);
 		if (entries.length === 0) return "";
 		return entries.map(([key, value]) => ` ${key}="${this.escapeHtml(value)}"`).join("");
 	}
 	/**
-	* Render merged HTML attributes (original + dynamic).
-	*/
-	renderMergedHtmlAttrs(dynamicAttrs) {
-		const merged = {
-			...this.getSlots().htmlOriginalAttrs,
-			...dynamicAttrs
-		};
-		return this.renderAttributes(merged);
-	}
-	/**
-	* Render merged body attributes (original + dynamic).
-	*/
-	renderMergedBodyAttrs(dynamicAttrs) {
-		const merged = {
-			...this.getSlots().bodyOriginalAttrs,
-			...dynamicAttrs
-		};
-		return this.renderAttributes(merged);
-	}
-	/**
 	* Render head content (title, meta, link, script tags).
-	*
-	* @param head - Head data to render
-	* @param includeOriginal - Whether to include original head content
-	* @returns HTML string with head content
 	*/
-	renderHeadContent(head, includeOriginal = true) {
-		const slots = this.getSlots();
+	renderHeadContent(head) {
+		if (!head) return "";
 		let content = "";
-		if (includeOriginal && slots.headOriginalContent) content += slots.headOriginalContent;
-		if (!head) return content;
-		if (head.title) if (content.includes("<title>")) content = content.replace(/<title>.*?<\/title>/i, `<title>${this.escapeHtml(head.title)}</title>`);
-		else content += `<title>${this.escapeHtml(head.title)}</title>\n`;
-		if (head.meta) for (const meta of head.meta) content += this.renderMetaTag(meta);
-		if (head.link) for (const link of head.link) content += this.renderLinkTag(link);
-		if (head.script) for (const script of head.script) content += this.renderScriptTag(script);
+		if (head.title) content += `<title>${this.escapeHtml(head.title)}</title>\n`;
+		if (head.meta) {
+			for (const meta of head.meta) if (meta.property) content += `<meta property="${this.escapeHtml(meta.property)}" content="${this.escapeHtml(meta.content)}">\n`;
+			else if (meta.name) content += `<meta name="${this.escapeHtml(meta.name)}" content="${this.escapeHtml(meta.content)}">\n`;
+		}
+		if (head.link) for (const link of head.link) {
+			content += `<link rel="${this.escapeHtml(link.rel)}" href="${this.escapeHtml(link.href)}"`;
+			if (link.type) content += ` type="${this.escapeHtml(link.type)}"`;
+			if (link.as) content += ` as="${this.escapeHtml(link.as)}"`;
+			if (link.crossorigin != null) content += " crossorigin=\"\"";
+			content += ">\n";
+		}
+		if (head.script) for (const script of head.script) if (typeof script === "string") content += `<script>${script}<\/script>\n`;
+		else {
+			const { content: scriptContent, ...rest } = script;
+			const attrs = Object.entries(rest).filter(([, v]) => v !== false && v !== void 0).map(([k, v]) => v === true ? k : `${k}="${this.escapeHtml(String(v))}"`).join(" ");
+			content += scriptContent ? `<script ${attrs}>${scriptContent}<\/script>\n` : `<script ${attrs}><\/script>\n`;
+		}
 		return content;
 	}
 	/**
-	* Render a meta tag.
-	*/
-	renderMetaTag(meta) {
-		if (meta.property) return `<meta property="${this.escapeHtml(meta.property)}" content="${this.escapeHtml(meta.content)}">\n`;
-		if (meta.name) return `<meta name="${this.escapeHtml(meta.name)}" content="${this.escapeHtml(meta.content)}">\n`;
-		return "";
-	}
-	/**
-	* Render a link tag.
-	*/
-	renderLinkTag(link) {
-		let tag = `<link rel="${this.escapeHtml(link.rel)}" href="${this.escapeHtml(link.href)}"`;
-		if (link.type) tag += ` type="${this.escapeHtml(link.type)}"`;
-		if (link.as) tag += ` as="${this.escapeHtml(link.as)}"`;
-		if (link.crossorigin != null) tag += " crossorigin=\"\"";
-		tag += ">\n";
-		return tag;
-	}
-	/**
-	* Render a script tag.
-	*/
-	renderScriptTag(script) {
-		if (typeof script === "string") return `<script>${script}<\/script>\n`;
-		const { content, ...rest } = script;
-		const attrs = Object.entries(rest).filter(([, value]) => value !== false && value !== void 0).map(([key, value]) => {
-			if (value === true) return key;
-			return `${key}="${this.escapeHtml(String(value))}"`;
-		}).join(" ");
-		if (content) return attrs ? `<script ${attrs}>${content}<\/script>\n` : `<script>${content}<\/script>\n`;
-		return `<script ${attrs}><\/script>\n`;
-	}
-	/**
 	* Escape HTML special characters.
 	*/
 	escapeHtml(str) {
@@ -3519,16 +3679,12 @@ var ReactServerTemplateProvider = class {
 	}
 	/**
 	* Safely serialize data to JSON for embedding in HTML.
-	* Escapes characters that could break out of script tags.
 	*/
 	safeJsonSerialize(data) {
 		return JSON.stringify(data).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
 	}
 	/**
 	* Build hydration data from router state.
-	*
-	* This creates the data structure that will be serialized to window.__ssr
-	* for client-side rehydration.
 	*/
 	buildHydrationData(state) {
 		const { request, context, ...store } = this.alepha.context.als?.getStore() ?? {};
@@ -3548,169 +3704,75 @@ var ReactServerTemplateProvider = class {
 		return hydrationData;
 	}
 	/**
-	* Stream the body content: body tag, root div, React content, hydration, and closing tags.
-	*
-	* If an error occurs during React streaming, it injects error HTML instead of aborting,
-	* ensuring users see an error message rather than a white screen.
-	*/
-	async streamBodyContent(controller, reactStream, state, hydration) {
-		const slots = this.getSlots();
-		const encoder = this.encoder;
-		const head = state.head;
-		controller.enqueue(slots.bodyOpen);
-		controller.enqueue(encoder.encode(this.renderMergedBodyAttrs(head?.bodyAttributes)));
-		controller.enqueue(slots.bodyClose);
-		if (slots.beforeRoot) controller.enqueue(encoder.encode(slots.beforeRoot));
-		controller.enqueue(slots.rootOpen);
+	* Pipe React stream to controller with backpressure handling.
+	* Returns true if stream completed successfully, false if error occurred.
+	*/
+	async pipeReactStream(controller, reactStream, state) {
 		const reader = reactStream.getReader();
-		let streamError = null;
 		try {
 			while (true) {
+				if (controller.desiredSize !== null && controller.desiredSize <= 0) await new Promise((resolve) => queueMicrotask(resolve));
 				const { done, value } = await reader.read();
 				if (done) break;
 				controller.enqueue(value);
 			}
+			return true;
 		} catch (error) {
-			streamError = error;
-			this.log.error("Error during React stream reading", error);
+			this.log.error("React stream error", error);
+			controller.enqueue(this.encoder.encode(this.renderErrorToString(error instanceof Error ? error : new Error(String(error)), state)));
+			return false;
 		} finally {
 			reader.releaseLock();
 		}
-		if (streamError) {
-			this.injectErrorHtml(controller, encoder, slots, streamError, state, {
-				headClosed: true,
-				bodyStarted: true
-			});
-			return;
-		}
-		controller.enqueue(slots.rootClose);
-		if (slots.afterRoot) controller.enqueue(encoder.encode(slots.afterRoot));
-		if (hydration) {
-			const hydrationData = this.buildHydrationData(state);
-			controller.enqueue(this.ENCODED.HYDRATION_PREFIX);
-			controller.enqueue(encoder.encode(this.safeJsonSerialize(hydrationData)));
-			controller.enqueue(this.ENCODED.HYDRATION_SUFFIX);
-		}
-		controller.enqueue(slots.scriptClose);
-	}
-	/**
-	* Create a ReadableStream that streams the HTML template with React content.
-	*
-	* This is the main entry point for SSR streaming. It:
-	* 1. Sends <head> immediately (browser starts downloading assets)
-	* 2. Streams React content as it renders
-	* 3. Appends hydration script and closing tags
-	*
-	* @param reactStream - ReadableStream from renderToReadableStream
-	* @param state - Router state with head data
-	* @param options - Streaming options
-	*/
-	createHtmlStream(reactStream, state, options = {}) {
-		const { hydration = true, onError } = options;
-		const slots = this.getSlots();
-		const head = state.head;
-		const encoder = this.encoder;
-		return new ReadableStream({ start: async (controller) => {
-			try {
-				controller.enqueue(slots.doctype);
-				controller.enqueue(slots.htmlOpen);
-				controller.enqueue(encoder.encode(this.renderMergedHtmlAttrs(head?.htmlAttributes)));
-				controller.enqueue(slots.htmlClose);
-				controller.enqueue(slots.headOpen);
-				if (this.earlyHeadContent) controller.enqueue(encoder.encode(this.earlyHeadContent));
-				controller.enqueue(encoder.encode(this.renderHeadContent(head)));
-				controller.enqueue(slots.headClose);
-				await this.streamBodyContent(controller, reactStream, state, hydration);
-				controller.close();
-			} catch (error) {
-				onError?.(error);
-				controller.error(error);
-			}
-		} });
 	}
 	/**
-	* Early head content for preloading.
-	*
-	* Contains entry assets (JS + CSS) that are always required and can be
-	* sent before page loaders run.
+	* Stream complete HTML document (head already closed).
+	* Used by both createHtmlStream and late phase of createEarlyHtmlStream.
 	*/
-	earlyHeadContent = "";
-	/**
-	* Set the early head content (entry script + CSS).
-	*
-	* Also strips these assets from the original head content to avoid duplicates,
-	* since we're moving them to the early phase.
-	*
-	* Automatically prepends critical meta tags (charset, viewport) if not present
-	* in $head configuration, ensuring they're sent as early as possible.
-	*
-	* @param content - HTML string with entry assets
-	* @param globalHead - Global head configuration from $head primitives
-	* @param entryAssets - Entry asset paths to strip from original head
-	*/
-	setEarlyHeadContent(content, globalHead, entryAssets) {
-		const criticalMeta = [];
-		const charset = globalHead?.charset ?? "UTF-8";
-		criticalMeta.push(`<meta charset="${this.escapeHtml(charset)}">`);
-		const viewport = globalHead?.viewport ?? "width=device-width, initial-scale=1";
-		criticalMeta.push(`<meta name="viewport" content="${this.escapeHtml(viewport)}">`);
-		this.earlyHeadContent = criticalMeta.length > 0 ? `${criticalMeta.join("\n")}\n${content}` : content;
-		if (entryAssets && this.slots) {
-			let headContent = this.slots.headOriginalContent;
-			if (entryAssets.js) {
-				const scriptPattern = new RegExp(`<script[^>]*\\ssrc=["']${this.escapeRegExp(entryAssets.js)}["'][^>]*>\\s*<\/script>\\s*`, "gi");
-				headContent = headContent.replace(scriptPattern, "");
-			}
-			for (const css of entryAssets.css) {
-				const linkPattern = new RegExp(`<link[^>]*\\shref=["']${this.escapeRegExp(css)}["'][^>]*>\\s*`, "gi");
-				headContent = headContent.replace(linkPattern, "");
-			}
-			this.slots.headOriginalContent = headContent.trim();
+	async streamBodyAndClose(controller, reactStream, state, hydration) {
+		const { encoder, SLOTS: slots } = this;
+		controller.enqueue(slots.BODY_OPEN);
+		controller.enqueue(encoder.encode(this.renderAttributes(state.head?.bodyAttributes)));
+		controller.enqueue(slots.BODY_CLOSE);
+		controller.enqueue(slots.ROOT_OPEN);
+		await this.pipeReactStream(controller, reactStream, state);
+		controller.enqueue(slots.ROOT_CLOSE);
+		if (hydration) {
+			controller.enqueue(slots.HYDRATION_PREFIX);
+			controller.enqueue(encoder.encode(this.safeJsonSerialize(this.buildHydrationData(state))));
+			controller.enqueue(slots.HYDRATION_SUFFIX);
 		}
+		controller.enqueue(slots.BODY_HTML_CLOSE);
 	}
 	/**
-	* Escape special regex characters in a string.
-	*/
-	escapeRegExp(str) {
-		return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-	}
-	/**
-	* Create an optimized HTML stream with early head streaming.
-	*
-	* This version sends critical assets (entry.js, CSS) BEFORE page loaders run,
-	* allowing the browser to start downloading them immediately.
+	* Create HTML stream with early head optimization.
 	*
 	* Flow:
 	* 1. Send DOCTYPE, <html>, <head> open, entry preloads (IMMEDIATE)
-	* 2. Run async work (createLayers, etc.)
+	* 2. Run async work (page loaders)
 	* 3. Send rest of head, body, React content, hydration
-	*
-	* @param globalHead - Global head with htmlAttributes (from $head primitives)
-	* @param asyncWork - Async function to run between early head and rest of stream
-	* @param options - Streaming options
 	*/
 	createEarlyHtmlStream(globalHead, asyncWork, options = {}) {
 		const { hydration = true, onError } = options;
-		const slots = this.getSlots();
-		const encoder = this.encoder;
+		const { encoder, SLOTS: slots } = this;
 		let headClosed = false;
 		let bodyStarted = false;
 		let routerState;
 		return new ReadableStream({ start: async (controller) => {
 			try {
-				controller.enqueue(slots.doctype);
-				controller.enqueue(slots.htmlOpen);
-				controller.enqueue(encoder.encode(this.renderMergedHtmlAttrs(globalHead?.htmlAttributes)));
-				controller.enqueue(slots.htmlClose);
-				controller.enqueue(slots.headOpen);
+				controller.enqueue(slots.DOCTYPE);
+				controller.enqueue(slots.HTML_OPEN);
+				controller.enqueue(encoder.encode(this.renderAttributes(globalHead?.htmlAttributes)));
+				controller.enqueue(slots.HTML_CLOSE);
+				controller.enqueue(slots.HEAD_OPEN);
 				if (this.earlyHeadContent) controller.enqueue(encoder.encode(this.earlyHeadContent));
 				const result = await asyncWork();
 				if (!result || "redirect" in result) {
 					if (result && "redirect" in result) {
-						this.log.debug("Loader redirect detected after streaming started, using meta refresh", { redirect: result.redirect });
+						this.log.debug("Loader redirect, using meta refresh", { redirect: result.redirect });
 						controller.enqueue(encoder.encode(`<meta http-equiv="refresh" content="0; url=${this.escapeHtml(result.redirect)}">\n`));
 					}
-					controller.enqueue(slots.headClose);
+					controller.enqueue(slots.HEAD_CLOSE);
 					controller.enqueue(encoder.encode("<body></body></html>"));
 					controller.close();
 					return;
@@ -3718,15 +3780,15 @@ var ReactServerTemplateProvider = class {
 				const { state, reactStream } = result;
 				routerState = state;
 				controller.enqueue(encoder.encode(this.renderHeadContent(state.head)));
-				controller.enqueue(slots.headClose);
+				controller.enqueue(slots.HEAD_CLOSE);
 				headClosed = true;
 				bodyStarted = true;
-				await this.streamBodyContent(controller, reactStream, state, hydration);
+				await this.streamBodyAndClose(controller, reactStream, state, hydration);
 				controller.close();
 			} catch (error) {
 				onError?.(error);
 				try {
-					this.injectErrorHtml(controller, encoder, slots, error, routerState, {
+					this.injectErrorHtml(controller, error, routerState, {
 						headClosed,
 						bodyStarted
 					});
@@ -3738,56 +3800,60 @@ var ReactServerTemplateProvider = class {
 		} });
 	}
 	/**
-	* Inject error HTML into the stream when an error occurs during streaming.
-	*
-	* Uses the router state's onError handler to render the error component,
-	* falling back to ErrorViewer if no custom handler is defined.
-	* Renders using renderToString to produce static HTML.
-	*
-	* Since we may have already sent partial HTML (DOCTYPE, <html>, <head>),
-	* we need to complete the document with an error message instead of aborting.
-	*
-	* Handles different states:
-	* - headClosed=false, bodyStarted=false: Need to add head content, close head, open body, add error, close all
-	* - headClosed=true, bodyStarted=false: Need to open body, add error, close all
-	* - headClosed=true, bodyStarted=true: Already inside root div, add error, close all
+	* Create HTML stream (non-early version, for testing/prerender).
 	*/
-	injectErrorHtml(controller, encoder, slots, error, routerState, streamState) {
+	createHtmlStream(reactStream, state, options = {}) {
+		const { hydration = true, onError } = options;
+		const { encoder, SLOTS: slots } = this;
+		return new ReadableStream({ start: async (controller) => {
+			try {
+				controller.enqueue(slots.DOCTYPE);
+				controller.enqueue(slots.HTML_OPEN);
+				controller.enqueue(encoder.encode(this.renderAttributes(state.head?.htmlAttributes)));
+				controller.enqueue(slots.HTML_CLOSE);
+				controller.enqueue(slots.HEAD_OPEN);
+				if (this.earlyHeadContent) controller.enqueue(encoder.encode(this.earlyHeadContent));
+				controller.enqueue(encoder.encode(this.renderHeadContent(state.head)));
+				controller.enqueue(slots.HEAD_CLOSE);
+				await this.streamBodyAndClose(controller, reactStream, state, hydration);
+				controller.close();
+			} catch (error) {
+				onError?.(error);
+				controller.error(error);
+			}
+		} });
+	}
+	/**
+	* Inject error HTML when streaming fails.
+	*/
+	injectErrorHtml(controller, error, routerState, streamState) {
+		const { encoder, SLOTS: slots } = this;
 		if (!streamState.headClosed) {
-			const headContent = this.renderHeadContent(routerState?.head);
-			if (headContent) controller.enqueue(encoder.encode(headContent));
-			controller.enqueue(slots.headClose);
+			controller.enqueue(encoder.encode(this.renderHeadContent(routerState?.head)));
+			controller.enqueue(slots.HEAD_CLOSE);
 		}
 		if (!streamState.bodyStarted) {
-			controller.enqueue(slots.bodyOpen);
-			controller.enqueue(encoder.encode(this.renderMergedBodyAttrs(routerState?.head?.bodyAttributes)));
-			controller.enqueue(slots.bodyClose);
-			if (slots.beforeRoot) controller.enqueue(encoder.encode(slots.beforeRoot));
-			controller.enqueue(slots.rootOpen);
+			controller.enqueue(slots.BODY_OPEN);
+			controller.enqueue(encoder.encode(this.renderAttributes(routerState?.head?.bodyAttributes)));
+			controller.enqueue(slots.BODY_CLOSE);
+			controller.enqueue(slots.ROOT_OPEN);
 		}
-		const errorHtml = this.renderErrorToString(error instanceof Error ? error : new Error(String(error)), routerState);
-		controller.enqueue(encoder.encode(errorHtml));
-		controller.enqueue(slots.rootClose);
-		if (!streamState.bodyStarted && slots.afterRoot) controller.enqueue(encoder.encode(slots.afterRoot));
-		controller.enqueue(slots.scriptClose);
+		controller.enqueue(encoder.encode(this.renderErrorToString(error instanceof Error ? error : new Error(String(error)), routerState)));
+		controller.enqueue(slots.ROOT_CLOSE);
+		controller.enqueue(slots.BODY_HTML_CLOSE);
 	}
 	/**
-	* Render an error to HTML string using the router's error handler.
-	*
-	* Falls back to ErrorViewer if:
-	* - No router state is available
-	* - The error handler returns null/undefined
-	* - The error handler itself throws
+	* Render error to HTML string.
 	*/
 	renderErrorToString(error, routerState) {
 		this.log.error("SSR rendering error", error);
 		let errorElement;
 		if (routerState?.onError) try {
 			const result = routerState.onError(error, routerState);
-			if (result instanceof Redirection) this.log.warn("Error handler returned Redirection but headers already sent", { redirect: result.redirect });
-			else if (result !== null && result !== void 0) errorElement = result;
+			if (result instanceof Redirection) this.log.warn("Error handler returned Redirection but headers sent", { redirect: result.redirect });
+			else if (result != null) errorElement = result;
 		} catch (handlerError) {
-			this.log.error("Error handler threw an exception", handlerError);
+			this.log.error("Error handler threw", handlerError);
 		}
 		if (!errorElement) errorElement = createElement(ErrorViewer_default, {
 			error,
@@ -3803,238 +3869,6 @@ var ReactServerTemplateProvider = class {
 	}
 };
 
-//#endregion
-//#region ../../src/react/router/atoms/ssrManifestAtom.ts
-/**
-* Schema for the SSR manifest atom.
-*/
-const ssrManifestAtomSchema = t.object({
-	base: t.optional(t.string()),
-	preload: t.optional(t.record(t.string(), t.string())),
-	client: t.optional(t.record(t.string(), t.object({
-		file: t.string(),
-		isEntry: t.optional(t.boolean()),
-		imports: t.optional(t.array(t.string())),
-		css: t.optional(t.array(t.string()))
-	})))
-});
-/**
-* SSR Manifest atom containing all manifest data for SSR module preloading.
-*
-* This atom is populated at build time by embedding manifest data into the
-* generated index.js. This approach is optimal for serverless deployments
-* as it eliminates filesystem reads at runtime.
-*
-* The manifest includes:
-* - preload: Maps short hash keys to source paths (from viteAlephaSsrPreload)
-* - client: Maps source files to their output info (file, imports, css)
-*/
-const ssrManifestAtom = $atom({
-	name: "alepha.react.ssr.manifest",
-	description: "SSR manifest for module preloading",
-	schema: ssrManifestAtomSchema,
-	default: {}
-});
-
-//#endregion
-//#region ../../src/react/router/providers/SSRManifestProvider.ts
-/**
-* Provider for SSR manifest data used for module preloading.
-*
-* The manifest is populated at build time by embedding data into the
-* generated index.js via the ssrManifestAtom. This eliminates filesystem
-* reads at runtime, making it optimal for serverless deployments.
-*
-* Manifest files are generated during `vite build`:
-* - manifest.json (client manifest)
-* - preload-manifest.json (from viteAlephaSsrPreload plugin)
-*/
-var SSRManifestProvider = class {
-	alepha = $inject(Alepha);
-	/**
-	* Get the manifest from the store at runtime.
-	* This ensures the manifest is available even when set after module load.
-	*/
-	get manifest() {
-		return this.alepha.store.get(ssrManifestAtom) ?? {};
-	}
-	/**
-	* Get the base path for assets (from Vite's base config).
-	* Returns empty string if base is "/" (default), otherwise returns the base path.
-	*/
-	get base() {
-		return this.manifest.base ?? "";
-	}
-	/**
-	* Get the preload manifest.
-	*/
-	get preloadManifest() {
-		return this.manifest.preload;
-	}
-	/**
-	* Get the client manifest.
-	*/
-	get clientManifest() {
-		return this.manifest.client;
-	}
-	/**
-	* Resolve a preload key to its source path.
-	*
-	* The key is a short hash injected by viteAlephaSsrPreload plugin,
-	* which maps to the full source path in the preload manifest.
-	*
-	* @param key - Short hash key (e.g., "a1b2c3d4")
-	* @returns Source path (e.g., "src/pages/UserDetail.tsx") or undefined
-	*/
-	resolvePreloadKey(key) {
-		return this.preloadManifest?.[key];
-	}
-	/**
-	* Get all chunks required for a source file, including transitive dependencies.
-	*
-	* Uses the client manifest to recursively resolve all imported chunks.
-	*
-	* @param sourcePath - Source file path (e.g., "src/pages/Home.tsx")
-	* @returns Array of chunk URLs to preload, or empty array if not found
-	*/
-	getChunks(sourcePath) {
-		if (!this.clientManifest) return [];
-		if (!this.findManifestEntry(sourcePath)) return [];
-		const chunks = /* @__PURE__ */ new Set();
-		const visited = /* @__PURE__ */ new Set();
-		this.collectChunksRecursive(sourcePath, chunks, visited);
-		return Array.from(chunks);
-	}
-	/**
-	* Find manifest entry for a source path, trying different extensions.
-	*/
-	findManifestEntry(sourcePath) {
-		if (!this.clientManifest) return void 0;
-		if (this.clientManifest[sourcePath]) return this.clientManifest[sourcePath];
-		const basePath = sourcePath.replace(/\.[^.]+$/, "");
-		for (const ext of [
-			".tsx",
-			".ts",
-			".jsx",
-			".js"
-		]) {
-			const pathWithExt = basePath + ext;
-			if (this.clientManifest[pathWithExt]) return this.clientManifest[pathWithExt];
-		}
-	}
-	/**
-	* Recursively collect all chunk URLs for a manifest entry.
-	*/
-	collectChunksRecursive(key, chunks, visited) {
-		if (visited.has(key)) return;
-		visited.add(key);
-		if (!this.clientManifest) return;
-		const entry = this.clientManifest[key];
-		if (!entry) return;
-		const base = this.base;
-		if (entry.file) chunks.add(`${base}/${entry.file}`);
-		if (entry.css) for (const css of entry.css) chunks.add(`${base}/${css}`);
-		if (entry.imports) for (const imp of entry.imports) {
-			if (imp === "index.html" || imp.endsWith(".html")) continue;
-			this.collectChunksRecursive(imp, chunks, visited);
-		}
-	}
-	/**
-	* Collect modulepreload links for a route and its parent chain.
-	*/
-	collectPreloadLinks(route) {
-		if (!this.isAvailable()) return [];
-		const preloadPaths = [];
-		let current = route;
-		while (current) {
-			const preloadKey = current[PAGE_PRELOAD_KEY];
-			if (preloadKey) {
-				const sourcePath = this.resolvePreloadKey(preloadKey);
-				if (sourcePath) preloadPaths.push(sourcePath);
-			}
-			current = current.parent;
-		}
-		if (preloadPaths.length === 0) return [];
-		return this.getChunksForMultiple(preloadPaths).map((href) => {
-			if (href.endsWith(".css")) return {
-				rel: "preload",
-				href,
-				as: "style",
-				crossorigin: ""
-			};
-			return {
-				rel: "modulepreload",
-				href
-			};
-		});
-	}
-	/**
-	* Get all chunks for multiple source files.
-	*
-	* @param sourcePaths - Array of source file paths
-	* @returns Deduplicated array of chunk URLs
-	*/
-	getChunksForMultiple(sourcePaths) {
-		const allChunks = /* @__PURE__ */ new Set();
-		for (const path of sourcePaths) {
-			const chunks = this.getChunks(path);
-			for (const chunk of chunks) allChunks.add(chunk);
-		}
-		return Array.from(allChunks);
-	}
-	/**
-	* Check if manifest is loaded and available.
-	*/
-	isAvailable() {
-		return this.clientManifest !== void 0;
-	}
-	/**
-	* Cached entry assets - computed once at first access.
-	*/
-	cachedEntryAssets = null;
-	/**
-	* Get the entry point assets (main entry.js and associated CSS files).
-	*
-	* These assets are always required for all pages and can be preloaded
-	* before page-specific loaders run.
-	*
-	* @returns Entry assets with js and css paths, or null if manifest unavailable
-	*/
-	getEntryAssets() {
-		if (this.cachedEntryAssets) return this.cachedEntryAssets;
-		if (!this.clientManifest) return null;
-		const base = this.base;
-		for (const [key, entry] of Object.entries(this.clientManifest)) if (entry.isEntry) {
-			this.cachedEntryAssets = {
-				js: `${base}/${entry.file}`,
-				css: entry.css?.map((css) => `${base}/${css}`) ?? []
-			};
-			return this.cachedEntryAssets;
-		}
-		return null;
-	}
-	/**
-	* Build preload link tags for entry assets.
-	*
-	* @returns Array of link objects ready to be rendered
-	*/
-	getEntryPreloadLinks() {
-		const assets = this.getEntryAssets();
-		if (!assets) return [];
-		const links = [];
-		for (const css of assets.css) links.push({
-			rel: "stylesheet",
-			href: css,
-			crossorigin: ""
-		});
-		if (assets.js) links.push({
-			rel: "modulepreload",
-			href: assets.js
-		});
-		return links;
-	}
-};
-
 //#endregion
 //#region ../../src/react/router/providers/ReactServerProvider.ts
 /**
@@ -4091,38 +3925,17 @@ var ReactServerProvider = class {
 				}
 			}
 			if (ssrEnabled) {
-				await this.registerPages(async () => this.template);
+				this.registerPages();
 				this.log.info("SSR OK");
 				return;
 			}
-			this.log.info("SSR is disabled, use History API fallback");
-			this.serverRouterProvider.createRoute({
-				path: "*",
-				handler: async ({ url, reply }) => {
-					if (url.pathname.includes(".")) {
-						reply.headers["content-type"] = "text/plain";
-						reply.body = "Not Found";
-						reply.status = 404;
-						return;
-					}
-					reply.headers["content-type"] = "text/html";
-					return this.template;
-				}
-			});
+			this.log.info("SSR is disabled");
 		}
 	});
 	/**
-	* Get the current HTML template.
-	*/
-	get template() {
-		return this.alepha.store.get("alepha.react.server.template") ?? "<!DOCTYPE html><html lang='en'><head></head><body><div id='root'></div></body></html>";
-	}
-	/**
 	* Register all pages as server routes.
 	*/
-	async registerPages(templateLoader) {
-		const template = await templateLoader();
-		if (template) this.templateProvider.parseTemplate(template);
+	registerPages() {
 		this.setupEarlyHeadContent();
 		this.hasServerLinksProvider = this.alepha.has(ServerLinksProvider);
 		for (const page of this.pageApi.getPages()) if (page.component || page.lazy) {
@@ -4132,7 +3945,7 @@ var ReactServerProvider = class {
 				schema: void 0,
 				method: "GET",
 				path: page.match,
-				handler: this.createHandler(page, templateLoader)
+				handler: this.createHandler(page)
 			});
 		}
 	}
@@ -4141,27 +3954,23 @@ var ReactServerProvider = class {
 	*
 	* This content is sent immediately when streaming starts, before page loaders run,
 	* allowing the browser to start downloading entry.js and CSS files early.
-	*
-	* Uses <script type="module"> instead of <link rel="modulepreload"> for JS
-	* because the script needs to execute anyway - this way the browser starts
-	* downloading, parsing, AND will execute as soon as ready.
-	*
-	* Also injects critical meta tags (charset, viewport) if not specified in $head,
-	* and strips these assets from the original template head to avoid duplicates.
 	*/
 	setupEarlyHeadContent() {
-		const assets = this.ssrManifestProvider.getEntryAssets();
 		const globalHead = this.serverHeadProvider.resolveGlobalHead();
+		const manifest = this.ssrManifestProvider.getManifest();
+		if (manifest.devHead) {
+			this.templateProvider.setEarlyHeadContent(`${manifest.devHead}\n`, globalHead);
+			this.log.debug("Early head content set (dev mode)");
+			return;
+		}
 		const parts = [];
+		const assets = this.ssrManifestProvider.getEntryAssets();
 		if (assets) {
 			for (const css of assets.css) parts.push(`<link rel="stylesheet" href="${css}" crossorigin="">`);
 			if (assets.js) parts.push(`<script type="module" crossorigin="" src="${assets.js}"><\/script>`);
 		}
-		this.templateProvider.setEarlyHeadContent(parts.length > 0 ? `${parts.join("\n")}\n` : "", globalHead, assets ?? void 0);
-		this.log.debug("Early head content set", {
-			css: assets?.css.length ?? 0,
-			js: assets?.js ? 1 : 0
-		});
+		this.templateProvider.setEarlyHeadContent(parts.length > 0 ? `${parts.join("\n")}\n` : "", globalHead);
+		this.log.debug("Early head content set", { parts: parts.length });
 	}
 	/**
 	* Get the public directory path where static files are located.
@@ -4187,15 +3996,9 @@ var ReactServerProvider = class {
 	/**
 	* Create the request handler for a page route.
 	*/
-	createHandler(route, templateLoader) {
+	createHandler(route) {
 		return async (serverRequest) => {
 			const { url, reply, query, params } = serverRequest;
-			if (!this.templateProvider.isReady()) {
-				const template = await templateLoader();
-				if (!template) throw new AlephaError("Missing template for SSR rendering");
-				this.templateProvider.parseTemplate(template);
-				this.setupEarlyHeadContent();
-			}
 			this.log.trace("Rendering page", { name: route.name });
 			const state = {
 				url,
@@ -4298,10 +4101,6 @@ var ReactServerProvider = class {
 		};
 		this.log.trace("Rendering", { url });
 		await this.alepha.events.emit("react:server:render:begin", { state });
-		if (!this.templateProvider.isReady()) {
-			this.templateProvider.parseTemplate(this.template);
-			this.setupEarlyHeadContent();
-		}
 		const result = await this.renderPage(page, state);
 		if (result.redirect) return {
 			state,
@@ -4573,7 +4372,7 @@ var ReactBrowserProvider = class {
 		}
 		await this.render({ previous });
 	}
-	async go(url, options = {}) {
+	async push(url, options = {}) {
 		this.log.trace(`Going to ${url}`, {
 			url,
 			options
@@ -4710,7 +4509,7 @@ var ReactRouter = class {
 	*/
 	async reload() {
 		if (!this.browser) return;
-		await this.go(this.location.pathname + this.location.search, {
+		await this.push(this.location.pathname + this.location.search, {
 			replace: true,
 			force: true
 		});
@@ -4743,12 +4542,12 @@ var ReactRouter = class {
 	async invalidate(props) {
 		await this.browser?.invalidate(props);
 	}
-	async go(path, options) {
+	async push(path, options) {
 		for (const page of this.pages) if (page.name === path) {
-			await this.browser?.go(this.path(path, options), options);
+			await this.browser?.push(this.path(path, options), options);
 			return;
 		}
-		await this.browser?.go(path, options);
+		await this.browser?.push(path, options);
 	}
 	anchor(path, options = {}) {
 		let href = path;
@@ -4761,7 +4560,7 @@ var ReactRouter = class {
 			onClick: (ev) => {
 				ev.stopPropagation();
 				ev.preventDefault();
-				this.go(href, options).catch(console.error);
+				this.push(href, options).catch(console.error);
 			}
 		};
 	}
@@ -4799,7 +4598,7 @@ var ReactRouter = class {
 * }
 *
 * const router = useRouter<App>();
-* router.go("home"); // typesafe
+* router.push("home"); // typesafe
 */
 const useRouter = () => {
 	return useInject(ReactRouter);
@@ -4849,7 +4648,7 @@ const useActive = (args) => {
 				if (isPending) return;
 				setPending(true);
 				try {
-					await router.go(href);
+					await router.push(href);
 				} finally {
 					setPending(false);
 				}
@@ -4915,6 +4714,7 @@ const AlephaReactRouter = $module({
 	services: [
 		ReactPageProvider,
 		ReactPageService,
+		ReactPreloadProvider,
 		ReactRouter,
 		ReactServerProvider,
 		ReactServerTemplateProvider,
@@ -4924,9 +4724,9 @@ const AlephaReactRouter = $module({
 	register: (alepha) => alepha.with(AlephaReact).with(AlephaDateTime).with(AlephaServer).with(AlephaServerCache).with(AlephaServerLinks).with({
 		provide: ReactPageService,
 		use: ReactPageServerService
-	}).with(SSRManifestProvider).with(ReactServerTemplateProvider).with(ReactServerProvider).with(ReactPageProvider).with(ReactRouter)
+	}).with(SSRManifestProvider).with(ReactServerTemplateProvider).with(ReactPreloadProvider).with(ReactServerProvider).with(ReactPageProvider).with(ReactRouter)
 });
 
 //#endregion
-export { $page, AlephaReactRouter, ErrorViewer_default as ErrorViewer, Link_default as Link, NestedView_default as NestedView, NotFound_default as NotFound, PAGE_PRELOAD_KEY, PagePrimitive, ReactBrowserProvider, ReactPageProvider, ReactPageService, ReactRouter, ReactServerProvider, ReactServerTemplateProvider, Redirection, RouterLayerContext, SSRManifestProvider, isPageRoute, reactBrowserOptions, reactServerOptions, useActive, useQueryParams, useRouter, useRouterState };
+export { $page, AlephaReactRouter, ErrorViewer_default as ErrorViewer, Link_default as Link, NestedView_default as NestedView, NotFound_default as NotFound, PAGE_PRELOAD_KEY, PagePrimitive, ReactBrowserProvider, ReactPageProvider, ReactPageService, ReactPreloadProvider, ReactRouter, ReactServerProvider, ReactServerTemplateProvider, Redirection, RouterLayerContext, SSRManifestProvider, isPageRoute, reactBrowserOptions, reactServerOptions, useActive, useQueryParams, useRouter, useRouterState };
 //# sourceMappingURL=index.js.map