@alepha/react 0.9.4 → 0.10.0

package/dist/index.cjs

@@ -33,12 +33,96 @@ const node_path = __toESM(require("node:path"));
 const __alepha_server_static = __toESM(require("@alepha/server-static"));
 const react_dom_server = __toESM(require("react-dom/server"));
 const __alepha_datetime = __toESM(require("@alepha/datetime"));
-const react_dom_client = __toESM(require("react-dom/client"));
 const __alepha_router = __toESM(require("@alepha/router"));
 
 //#region src/descriptors/$page.ts
 /**
 * Main descriptor for defining a React route in the application.
+*
+* The $page descriptor is the core building block for creating type-safe, SSR-enabled React routes.
+* It provides a declarative way to define pages with powerful features:
+*
+* **Routing & Navigation**
+* - URL pattern matching with parameters (e.g., `/users/:id`)
+* - Nested routing with parent-child relationships
+* - Type-safe URL parameter and query string validation
+*
+* **Data Loading**
+* - Server-side data fetching with the `resolve` function
+* - Automatic serialization and hydration for SSR
+* - Access to request context, URL params, and parent data
+*
+* **Component Loading**
+* - Direct component rendering or lazy loading for code splitting
+* - Client-only rendering when browser APIs are needed
+* - Automatic fallback handling during hydration
+*
+* **Performance Optimization**
+* - Static generation for pre-rendered pages at build time
+* - Server-side caching with configurable TTL and providers
+* - Code splitting through lazy component loading
+*
+* **Error Handling**
+* - Custom error handlers with support for redirects
+* - Hierarchical error handling (child → parent)
+* - HTTP status code handling (404, 401, etc.)
+*
+* **Page Animations**
+* - CSS-based enter/exit animations
+* - Dynamic animations based on page state
+* - Custom timing and easing functions
+*
+* **Lifecycle Management**
+* - Server response hooks for headers and status codes
+* - Page leave handlers for cleanup (browser only)
+* - Permission-based access control
+*
+* @example Simple page with data fetching
+* ```typescript
+* const userProfile = $page({
+*   path: "/users/:id",
+*   schema: {
+*     params: t.object({ id: t.int() }),
+*     query: t.object({ tab: t.optional(t.string()) })
+*   },
+*   resolve: async ({ params }) => {
+*     const user = await userApi.getUser(params.id);
+*     return { user };
+*   },
+*   lazy: () => import("./UserProfile.tsx")
+* });
+* ```
+*
+* @example Nested routing with error handling
+* ```typescript
+* const projectSection = $page({
+*   path: "/projects/:id",
+*   children: () => [projectBoard, projectSettings],
+*   resolve: async ({ params }) => {
+*     const project = await projectApi.get(params.id);
+*     return { project };
+*   },
+*   errorHandler: (error) => {
+*     if (HttpError.is(error, 404)) {
+*       return <ProjectNotFound />;
+*     }
+*   }
+* });
+* ```
+*
+* @example Static generation with caching
+* ```typescript
+* const blogPost = $page({
+*   path: "/blog/:slug",
+*   static: {
+*     entries: posts.map(p => ({ params: { slug: p.slug } }))
+*   },
+*   resolve: async ({ params }) => {
+*     const post = await loadPost(params.slug);
+*     return { post };
+*   }
+* });
+* ```
 */
 const $page = (options) => {
 	return (0, __alepha_core.createDescriptor)(PageDescriptor, options);
@@ -58,7 +142,10 @@ var PageDescriptor = class extends __alepha_core.Descriptor {
 	* Only valid for server-side rendering, it will throw an error if called on the client-side.
 	*/
 	async render(options) {
-		throw new Error("render method is not implemented in this environment");
+		throw new __alepha_core.AlephaError("render() method is not implemented in this environment");
+	}
+	async fetch(options) {
+		throw new __alepha_core.AlephaError("fetch() method is not implemented in this environment");
 	}
 	match(url) {
 		return false;
@@ -87,7 +174,6 @@ const ClientOnly = (props) => {
 	if (props.disabled) return props.children;
 	return mounted ? props.children : props.fallback;
 };
-var ClientOnly_default = ClientOnly;
 
 //#endregion
 //#region src/components/ErrorViewer.tsx
@@ -195,7 +281,6 @@ const ErrorViewer = ({ error, alepha }) => {
 		})] })]
 	});
 };
-var ErrorViewer_default = ErrorViewer;
 const ErrorViewerProduction = () => {
 	const styles = {
 		container: {
@@ -271,7 +356,7 @@ const AlephaContext = (0, react.createContext)(void 0);
 *
 * - alepha.state() for state management
 * - alepha.inject() for dependency injection
-* - alepha.emit() for event handling
+* - alepha.events.emit() for event handling
 * etc...
 */
 const useAlepha = () => {
@@ -289,19 +374,55 @@ const useRouterEvents = (opts = {}, deps = []) => {
 	const alepha = useAlepha();
 	(0, react.useEffect)(() => {
 		if (!alepha.isBrowser()) return;
+		const cb = (callback) => {
+			if (typeof callback === "function") return { callback };
+			return callback;
+		};
 		const subs = [];
 		const onBegin = opts.onBegin;
 		const onEnd = opts.onEnd;
 		const onError = opts.onError;
-		if (onBegin) subs.push(alepha.on("react:transition:begin", { callback: onBegin }));
-		if (onEnd) subs.push(alepha.on("react:transition:end", { callback: onEnd }));
-		if (onError) subs.push(alepha.on("react:transition:error", { callback: onError }));
+		const onSuccess = opts.onSuccess;
+		if (onBegin) subs.push(alepha.events.on("react:transition:begin", cb(onBegin)));
+		if (onEnd) subs.push(alepha.events.on("react:transition:end", cb(onEnd)));
+		if (onError) subs.push(alepha.events.on("react:transition:error", cb(onError)));
+		if (onSuccess) subs.push(alepha.events.on("react:transition:success", cb(onSuccess)));
 		return () => {
 			for (const sub of subs) sub();
 		};
 	}, deps);
 };
 
+//#endregion
+//#region src/hooks/useStore.ts
+/**
+* Hook to access and mutate the Alepha state.
+*/
+const useStore = (key, defaultValue) => {
+	const alepha = useAlepha();
+	(0, react.useMemo)(() => {
+		if (defaultValue != null && alepha.state.get(key) == null) alepha.state.set(key, defaultValue);
+	}, [defaultValue]);
+	const [state, setState] = (0, react.useState)(alepha.state.get(key));
+	(0, react.useEffect)(() => {
+		if (!alepha.isBrowser()) return;
+		return alepha.events.on("state:mutate", (ev) => {
+			if (ev.key === key) setState(ev.value);
+		});
+	}, []);
+	return [state, (value) => {
+		alepha.state.set(key, value);
+	}];
+};
+
+//#endregion
+//#region src/hooks/useRouterState.ts
+const useRouterState = () => {
+	const [state] = useStore("react.router.state");
+	if (!state) throw new __alepha_core.AlephaError("Missing react router state");
+	return state;
+};
+
 //#endregion
 //#region src/components/ErrorBoundary.tsx
 /**
@@ -331,7 +452,6 @@ var ErrorBoundary = class extends react.default.Component {
 		return this.props.children;
 	}
 };
-var ErrorBoundary_default = ErrorBoundary;
 
 //#endregion
 //#region src/components/NestedView.tsx
@@ -342,7 +462,7 @@ var ErrorBoundary_default = ErrorBoundary;
 *
 * @example
 * ```tsx
-* import { NestedView } from "@alepha/react";
+* import { NestedView } from "alepha/react";
 *
 * class App {
 *   parent = $page({
@@ -357,17 +477,69 @@ var ErrorBoundary_default = ErrorBoundary;
 * ```
 */
 const NestedView = (props) => {
-	const layer = (0, react.useContext)(RouterLayerContext);
-	const index = layer?.index ?? 0;
-	const alepha = useAlepha();
-	const state = alepha.state("react.router.state");
-	if (!state) throw new Error("<NestedView/> must be used inside a RouterLayerContext.");
+	const index = (0, react.use)(RouterLayerContext)?.index ?? 0;
+	const state = useRouterState();
 	const [view, setView] = (0, react.useState)(state.layers[index]?.element);
-	useRouterEvents({ onEnd: ({ state: state$1 }) => {
-		if (!state$1.layers[index]?.cache) setView(state$1.layers[index]?.element);
-	} }, []);
-	const element = view ?? props.children ?? null;
-	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ErrorBoundary_default, {
+	const [animation, setAnimation] = (0, react.useState)("");
+	const animationExitDuration = (0, react.useRef)(0);
+	const animationExitNow = (0, react.useRef)(0);
+	useRouterEvents({
+		onBegin: async ({ previous, state: state$1 }) => {
+			const layer = previous.layers[index];
+			if (`${state$1.url.pathname}/`.startsWith(`${layer?.path}/`)) return;
+			const animationExit = parseAnimation(layer.route?.animation, state$1, "exit");
+			if (animationExit) {
+				const duration = animationExit.duration || 200;
+				animationExitNow.current = Date.now();
+				animationExitDuration.current = duration;
+				setAnimation(animationExit.animation);
+			} else {
+				animationExitNow.current = 0;
+				animationExitDuration.current = 0;
+				setAnimation("");
+			}
+		},
+		onEnd: async ({ state: state$1 }) => {
+			const layer = state$1.layers[index];
+			if (animationExitNow.current) {
+				const duration = animationExitDuration.current;
+				const diff = Date.now() - animationExitNow.current;
+				if (diff < duration) await new Promise((resolve) => setTimeout(resolve, duration - diff));
+			}
+			if (!layer?.cache) {
+				setView(layer?.element);
+				const animationEnter = parseAnimation(layer?.route?.animation, state$1, "enter");
+				if (animationEnter) setAnimation(animationEnter.animation);
+				else setAnimation("");
+			}
+		}
+	}, []);
+	let element = view ?? props.children ?? null;
+	if (animation) element = /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		style: {
+			display: "flex",
+			flex: 1,
+			height: "100%",
+			width: "100%",
+			position: "relative",
+			overflow: "hidden"
+		},
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+			style: {
+				height: "100%",
+				width: "100%",
+				display: "flex",
+				animation
+			},
+			children: element
+		})
+	});
+	if (props.errorBoundary === false) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: element });
+	if (props.errorBoundary) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ErrorBoundary, {
+		fallback: props.errorBoundary,
+		children: element
+	});
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ErrorBoundary, {
 		fallback: (error) => {
 			const result = state.onError(error, state);
 			if (result instanceof Redirection) return "Redirection inside ErrorBoundary is not allowed.";
@@ -376,7 +548,37 @@ const NestedView = (props) => {
 		children: element
 	});
 };
-var NestedView_default = NestedView;
+var NestedView_default = (0, react.memo)(NestedView);
+function parseAnimation(animationLike, state, type = "enter") {
+	if (!animationLike) return void 0;
+	const DEFAULT_DURATION = 300;
+	const animation = typeof animationLike === "function" ? animationLike(state) : animationLike;
+	if (typeof animation === "string") {
+		if (type === "exit") return;
+		return {
+			duration: DEFAULT_DURATION,
+			animation: `${DEFAULT_DURATION}ms ${animation}`
+		};
+	}
+	if (typeof animation === "object") {
+		const anim = animation[type];
+		const duration = typeof anim === "object" ? anim.duration ?? DEFAULT_DURATION : DEFAULT_DURATION;
+		const name = typeof anim === "object" ? anim.name : anim;
+		if (type === "exit") {
+			const timing$1 = typeof anim === "object" ? anim.timing ?? "" : "";
+			return {
+				duration,
+				animation: `${duration}ms ${timing$1} ${name}`
+			};
+		}
+		const timing = typeof anim === "object" ? anim.timing ?? "" : "";
+		return {
+			duration,
+			animation: `${duration}ms ${timing} ${name}`
+		};
+	}
+	return void 0;
+}
 
 //#endregion
 //#region src/components/NotFound.tsx
@@ -442,6 +644,14 @@ var ReactPageProvider = class {
 		if (this.env.REACT_STRICT_MODE) return (0, react.createElement)(react.StrictMode, {}, root);
 		return root;
 	}
+	convertStringObjectToObject = (schema, value) => {
+		if (__alepha_core.t.schema.isObject(schema) && typeof value === "object") {
+			for (const key in schema.properties) if (__alepha_core.t.schema.isObject(schema.properties[key]) && typeof value[key] === "string") try {
+				value[key] = this.alepha.parse(schema.properties[key], decodeURIComponent(value[key]));
+			} catch (e) {}
+		}
+		return value;
+	};
 	/**
 	* Create a new RouterState based on a given route and request.
 	* This method resolves the layers for the route, applying any query and params schemas defined in the route.
@@ -461,6 +671,7 @@ var ReactPageProvider = class {
 			const route$1 = it.route;
 			const config = {};
 			try {
+				this.convertStringObjectToObject(route$1.schema?.query, state.query);
 				config.query = route$1.schema?.query ? this.alepha.parse(route$1.schema.query, state.query) : {};
 			} catch (e) {
 				it.error = e;
@@ -587,6 +798,7 @@ var ReactPageProvider = class {
 		}
 	}
 	async createElement(page, props) {
+		if (page.lazy && page.component) this.log.warn(`Page ${page.name} has both lazy and component options, lazy will be used`);
 		if (page.lazy) {
 			const component = await page.lazy();
 			return (0, react.createElement)(component.default, props);
@@ -595,7 +807,7 @@ var ReactPageProvider = class {
 		return void 0;
 	}
 	renderError(error) {
-		return (0, react.createElement)(ErrorViewer_default, {
+		return (0, react.createElement)(ErrorViewer, {
 			error,
 			alepha: this.alepha
 		});
@@ -621,7 +833,7 @@ var ReactPageProvider = class {
 	}
 	renderView(index, path, view, page) {
 		view ??= this.renderEmptyView();
-		const element = page.client ? (0, react.createElement)(ClientOnly_default, typeof page.client === "object" ? page.client : {}, view) : view;
+		const element = page.client ? (0, react.createElement)(ClientOnly, typeof page.client === "object" ? page.client : {}, view) : view;
 		return (0, react.createElement)(RouterLayerContext.Provider, { value: {
 			index,
 			path
@@ -715,18 +927,36 @@ var ReactServerProvider = class {
 	log = (0, __alepha_logger.$logger)();
 	alepha = (0, __alepha_core.$inject)(__alepha_core.Alepha);
 	pageApi = (0, __alepha_core.$inject)(ReactPageProvider);
+	serverProvider = (0, __alepha_core.$inject)(__alepha_server.ServerProvider);
 	serverStaticProvider = (0, __alepha_core.$inject)(__alepha_server_static.ServerStaticProvider);
 	serverRouterProvider = (0, __alepha_core.$inject)(__alepha_server.ServerRouterProvider);
 	serverTimingProvider = (0, __alepha_core.$inject)(__alepha_server.ServerTimingProvider);
 	env = (0, __alepha_core.$env)(envSchema$1);
 	ROOT_DIV_REGEX = new RegExp(`<div([^>]*)\\s+id=["']${this.env.REACT_ROOT_ID}["']([^>]*)>(.*?)<\\/div>`, "is");
+	preprocessedTemplate = null;
 	onConfigure = (0, __alepha_core.$hook)({
 		on: "configure",
 		handler: async () => {
 			const pages = this.alepha.descriptors($page);
 			const ssrEnabled = pages.length > 0 && this.env.REACT_SSR_ENABLED !== false;
-			this.alepha.state("react.server.ssr", ssrEnabled);
-			for (const page of pages) page.render = this.createRenderFunction(page.name);
+			this.alepha.state.set("react.server.ssr", ssrEnabled);
+			for (const page of pages) {
+				page.render = this.createRenderFunction(page.name);
+				page.fetch = async (options) => {
+					const response = await fetch(`${this.serverProvider.hostname}/${page.pathname(options)}`);
+					const html = await response.text();
+					if (options?.html) return {
+						html,
+						response
+					};
+					const match = html.match(this.ROOT_DIV_REGEX);
+					if (match) return {
+						html: match[3],
+						response
+					};
+					throw new __alepha_core.AlephaError("Invalid HTML response");
+				};
+			}
 			if (this.alepha.isServerless() === "vite") {
 				await this.configureVite(ssrEnabled);
 				return;
@@ -765,6 +995,8 @@ var ReactServerProvider = class {
 		return this.alepha.env.REACT_SERVER_TEMPLATE ?? "<!DOCTYPE html><html lang='en'><head></head><body></body></html>";
 	}
 	async registerPages(templateLoader) {
+		const template = await templateLoader();
+		if (template) this.preprocessedTemplate = this.preprocessTemplate(template);
 		for (const page of this.pageApi.getPages()) {
 			if (page.children?.length) continue;
 			this.log.debug(`+ ${page.match} -> ${page.name}`);
@@ -806,27 +1038,37 @@ var ReactServerProvider = class {
 				params: options.params ?? {},
 				query: options.query ?? {},
 				onError: () => null,
-				layers: []
+				layers: [],
+				meta: {}
 			};
 			const state = entry;
 			this.log.trace("Rendering", { url });
-			await this.alepha.emit("react:server:render:begin", { state });
+			await this.alepha.events.emit("react:server:render:begin", { state });
 			const { redirect } = await this.pageApi.createLayers(page, state);
-			if (redirect) throw new __alepha_core.AlephaError("Redirection is not supported in this context");
+			if (redirect) return {
+				state,
+				html: "",
+				redirect
+			};
 			if (!withIndex && !options.html) {
-				this.alepha.state("react.router.state", state);
+				this.alepha.state.set("react.router.state", state);
 				return {
 					state,
 					html: (0, react_dom_server.renderToString)(this.pageApi.root(state))
 				};
 			}
-			const html = this.renderToHtml(this.template ?? "", state, options.hydration);
-			if (html instanceof Redirection) throw new Error("Redirection is not supported in this context");
+			const template = this.template ?? "";
+			const html = this.renderToHtml(template, state, options.hydration);
+			if (html instanceof Redirection) return {
+				state,
+				html: "",
+				redirect
+			};
 			const result = {
 				state,
 				html
 			};
-			await this.alepha.emit("react:server:render:end", result);
+			await this.alepha.events.emit("react:server:render:end", result);
 			return result;
 		};
 	}
@@ -844,7 +1086,7 @@ var ReactServerProvider = class {
 				layers: []
 			};
 			const state = entry;
-			if (this.alepha.has(__alepha_server_links.ServerLinksProvider)) this.alepha.state("api", await this.alepha.inject(__alepha_server_links.ServerLinksProvider).getUserApiLinks({
+			if (this.alepha.has(__alepha_server_links.ServerLinksProvider)) this.alepha.state.set("api", await this.alepha.inject(__alepha_server_links.ServerLinksProvider).getUserApiLinks({
 				user: serverRequest.user,
 				authorization: serverRequest.headers.authorization
 			}));
@@ -857,7 +1099,7 @@ var ReactServerProvider = class {
 				}
 				target = target.parent;
 			}
-			await this.alepha.emit("react:server:render:begin", {
+			await this.alepha.events.emit("react:server:render:begin", {
 				request: serverRequest,
 				state
 			});
@@ -879,7 +1121,7 @@ var ReactServerProvider = class {
 				state,
 				html
 			};
-			await this.alepha.emit("react:server:render:end", event);
+			await this.alepha.events.emit("react:server:render:end", event);
 			route.onServerResponse?.(serverRequest);
 			this.log.trace("Page rendered", { name: route.name });
 			return event.html;
@@ -887,7 +1129,7 @@ var ReactServerProvider = class {
 	}
 	renderToHtml(template, state, hydration = true) {
 		const element = this.pageApi.root(state);
-		this.alepha.state("react.router.state", state);
+		this.alepha.state.set("react.router.state", state);
 		this.serverTimingProvider.beginTiming("renderToString");
 		let app = "";
 		try {
@@ -925,18 +1167,48 @@ var ReactServerProvider = class {
 		}
 		return response.html;
 	}
-	fillTemplate(response, app, script) {
-		if (this.ROOT_DIV_REGEX.test(response.html)) response.html = response.html.replace(this.ROOT_DIV_REGEX, (_match, beforeId, afterId) => {
-			return `<div${beforeId} id="${this.env.REACT_ROOT_ID}"${afterId}>${app}</div>`;
-		});
-		else {
-			const bodyOpenTag = /<body([^>]*)>/i;
-			if (bodyOpenTag.test(response.html)) response.html = response.html.replace(bodyOpenTag, (match) => {
-				return `${match}<div id="${this.env.REACT_ROOT_ID}">${app}</div>`;
-			});
+	preprocessTemplate(template) {
+		const bodyCloseMatch = template.match(/<\/body>/i);
+		const bodyCloseIndex = bodyCloseMatch?.index ?? template.length;
+		const beforeScript = template.substring(0, bodyCloseIndex);
+		const afterScript = template.substring(bodyCloseIndex);
+		const rootDivMatch = beforeScript.match(this.ROOT_DIV_REGEX);
+		if (rootDivMatch) {
+			const beforeDiv = beforeScript.substring(0, rootDivMatch.index);
+			const afterDivStart = rootDivMatch.index + rootDivMatch[0].length;
+			const afterDiv = beforeScript.substring(afterDivStart);
+			const beforeApp = `${beforeDiv}<div${rootDivMatch[1]} id="${this.env.REACT_ROOT_ID}"${rootDivMatch[2]}>`;
+			const afterApp = `</div>${afterDiv}`;
+			return {
+				beforeApp,
+				afterApp,
+				beforeScript: "",
+				afterScript
+			};
+		}
+		const bodyMatch = beforeScript.match(/<body([^>]*)>/i);
+		if (bodyMatch) {
+			const beforeBody = beforeScript.substring(0, bodyMatch.index + bodyMatch[0].length);
+			const afterBody = beforeScript.substring(bodyMatch.index + bodyMatch[0].length);
+			const beforeApp = `${beforeBody}<div id="${this.env.REACT_ROOT_ID}">`;
+			const afterApp = `</div>${afterBody}`;
+			return {
+				beforeApp,
+				afterApp,
+				beforeScript: "",
+				afterScript
+			};
 		}
-		const bodyCloseTagRegex = /<\/body>/i;
-		if (bodyCloseTagRegex.test(response.html)) response.html = response.html.replace(bodyCloseTagRegex, `${script}</body>`);
+		return {
+			beforeApp: `<div id="${this.env.REACT_ROOT_ID}">`,
+			afterApp: `</div>`,
+			beforeScript,
+			afterScript
+		};
+	}
+	fillTemplate(response, app, script) {
+		if (!this.preprocessedTemplate) this.preprocessedTemplate = this.preprocessTemplate(response.html);
+		response.html = this.preprocessedTemplate.beforeApp + app + this.preprocessedTemplate.afterApp + script + this.preprocessedTemplate.afterScript;
 	}
 };
 
@@ -958,17 +1230,21 @@ var ReactBrowserRouterProvider = class extends __alepha_router.RouterProvider {
 			});
 		}
 	});
-	async transition(url, previous = []) {
+	async transition(url, previous = [], meta = {}) {
 		const { pathname, search } = url;
 		const entry = {
 			url,
 			query: {},
 			params: {},
 			layers: [],
-			onError: () => null
+			onError: () => null,
+			meta
 		};
 		const state = entry;
-		await this.alepha.emit("react:transition:begin", { state });
+		await this.alepha.events.emit("react:transition:begin", {
+			previous: this.alepha.state.get("react.router.state"),
+			state
+		});
 		try {
 			const { route, params } = this.match(pathname);
 			const query = {};
@@ -985,7 +1261,7 @@ var ReactBrowserRouterProvider = class extends __alepha_router.RouterProvider {
 				index: 0,
 				path: "/"
 			});
-			await this.alepha.emit("react:transition:success", { state });
+			await this.alepha.events.emit("react:transition:success", { state });
 		} catch (e) {
 			this.log.error("Transition has failed", e);
 			state.layers = [{
@@ -994,7 +1270,7 @@ var ReactBrowserRouterProvider = class extends __alepha_router.RouterProvider {
 				index: 0,
 				path: "/"
 			}];
-			await this.alepha.emit("react:transition:error", {
+			await this.alepha.events.emit("react:transition:error", {
 				error: e,
 				state
 			});
@@ -1003,8 +1279,8 @@ var ReactBrowserRouterProvider = class extends __alepha_router.RouterProvider {
 			const layer = previous[i];
 			if (state.layers[i]?.name !== layer.name) this.pageApi.page(layer.name)?.onLeave?.();
 		}
-		await this.alepha.emit("react:transition:end", { state });
-		this.alepha.state("react.router.state", state);
+		this.alepha.state.set("react.router.state", state);
+		await this.alepha.events.emit("react:transition:end", { state });
 	}
 	root(state) {
 		return this.pageApi.root(state);
@@ -1021,7 +1297,6 @@ var ReactBrowserProvider = class {
 	alepha = (0, __alepha_core.$inject)(__alepha_core.Alepha);
 	router = (0, __alepha_core.$inject)(ReactBrowserRouterProvider);
 	dateTimeProvider = (0, __alepha_core.$inject)(__alepha_datetime.DateTimeProvider);
-	root;
 	options = { scrollRestoration: "top" };
 	getRootElement() {
 		const root = this.document.getElementById(this.env.REACT_ROOT_ID);
@@ -1033,7 +1308,7 @@ var ReactBrowserProvider = class {
 	}
 	transitioning;
 	get state() {
-		return this.alepha.state("react.router.state");
+		return this.alepha.state.get("react.router.state");
 	}
 	/**
 	* Accessor for Document DOM API.
@@ -1097,7 +1372,8 @@ var ReactBrowserProvider = class {
 		});
 		await this.render({
 			url,
-			previous: options.force ? [] : this.state.layers
+			previous: options.force ? [] : this.state.layers,
+			meta: options.meta
 		});
 		if (this.state.url.pathname + this.state.url.search !== url) {
 			this.pushState(this.state.url.pathname + this.state.url.search);
@@ -1114,7 +1390,7 @@ var ReactBrowserProvider = class {
 			from: this.state?.url.pathname
 		};
 		this.log.debug("Transitioning...", { to: url });
-		const redirect = await this.router.transition(new URL(`http://localhost${url}`), previous);
+		const redirect = await this.router.transition(new URL(`http://localhost${url}`), previous, options.meta);
 		if (redirect) {
 			this.log.info("Redirecting to", { redirect });
 			return await this.render({ url: redirect });
@@ -1136,7 +1412,7 @@ var ReactBrowserProvider = class {
 	onTransitionEnd = (0, __alepha_core.$hook)({
 		on: "react:transition:end",
 		handler: () => {
-			if (this.options.scrollRestoration === "top" && typeof window !== "undefined") {
+			if (this.options.scrollRestoration === "top" && typeof window !== "undefined" && !this.alepha.isTest()) {
 				this.log.trace("Restoring scroll position to top");
 				window.scrollTo(0, 0);
 			}
@@ -1148,18 +1424,16 @@ var ReactBrowserProvider = class {
 			const hydration = this.getHydrationState();
 			const previous = hydration?.layers ?? [];
 			if (hydration) {
-				for (const [key, value] of Object.entries(hydration)) if (key !== "layers") this.alepha.state(key, value);
+				for (const [key, value] of Object.entries(hydration)) if (key !== "layers") this.alepha.state.set(key, value);
 			}
 			await this.render({ previous });
 			const element = this.router.root(this.state);
-			if (hydration?.layers) {
-				this.root = (0, react_dom_client.hydrateRoot)(this.getRootElement(), element);
-				this.log.info("Hydrated root element");
-			} else {
-				this.root ??= (0, react_dom_client.createRoot)(this.getRootElement());
-				this.root.render(element);
-				this.log.info("Created root element");
-			}
+			await this.alepha.events.emit("react:browser:render", {
+				element,
+				root: this.getRootElement(),
+				hydration,
+				state: this.state
+			});
 			window.addEventListener("popstate", () => {
 				if (this.base + this.state.url.pathname === this.location.pathname) return;
 				this.log.debug("Popstate event triggered - rendering new state", { url: this.location.pathname + this.location.search });
@@ -1175,7 +1449,7 @@ var ReactRouter = class {
 	alepha = (0, __alepha_core.$inject)(__alepha_core.Alepha);
 	pageApi = (0, __alepha_core.$inject)(ReactPageProvider);
 	get state() {
-		return this.alepha.state("react.router.state");
+		return this.alepha.state.get("react.router.state");
 	}
 	get pages() {
 		return this.pageApi.getPages();
@@ -1298,44 +1572,12 @@ const useRouter = () => {
 //#region src/components/Link.tsx
 const Link = (props) => {
 	const router = useRouter();
-	const { to,...anchorProps } = props;
 	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("a", {
-		...router.anchor(to),
-		...anchorProps,
+		...props,
+		...router.anchor(props.href),
 		children: props.children
 	});
 };
-var Link_default = Link;
-
-//#endregion
-//#region src/hooks/useStore.ts
-/**
-* Hook to access and mutate the Alepha state.
-*/
-const useStore = (key, defaultValue) => {
-	const alepha = useAlepha();
-	(0, react.useMemo)(() => {
-		if (defaultValue != null && alepha.state(key) == null) alepha.state(key, defaultValue);
-	}, [defaultValue]);
-	const [state, setState] = (0, react.useState)(alepha.state(key));
-	(0, react.useEffect)(() => {
-		if (!alepha.isBrowser()) return;
-		return alepha.on("state:mutate", (ev) => {
-			if (ev.key === key) setState(ev.value);
-		});
-	}, []);
-	return [state, (value) => {
-		alepha.state(key, value);
-	}];
-};
-
-//#endregion
-//#region src/hooks/useRouterState.ts
-const useRouterState = () => {
-	const [state] = useStore("react.router.state");
-	if (!state) throw new __alepha_core.AlephaError("Missing react router state");
-	return state;
-};
 
 //#endregion
 //#region src/hooks/useActive.ts
@@ -1393,7 +1635,7 @@ const useQueryParams = (schema, options = {}) => {
 	const key = options.key ?? "q";
 	const router = useRouter();
 	const querystring = router.query[key];
-	const [queryParams, setQueryParams] = (0, react.useState)(decode(alepha, schema, router.query[key]));
+	const [queryParams = {}, setQueryParams] = (0, react.useState)(decode(alepha, schema, router.query[key]));
 	(0, react.useEffect)(() => {
 		setQueryParams(decode(alepha, schema, querystring));
 	}, [querystring]);
@@ -1413,8 +1655,8 @@ const encode = (alepha, schema, data) => {
 const decode = (alepha, schema, data) => {
 	try {
 		return alepha.parse(schema, JSON.parse(atob(decodeURIComponent(data))));
-	} catch (_error) {
-		return {};
+	} catch {
+		return;
 	}
 };
 
@@ -1480,10 +1722,10 @@ const AlephaReact = (0, __alepha_core.$module)({
 exports.$page = $page;
 exports.AlephaContext = AlephaContext;
 exports.AlephaReact = AlephaReact;
-exports.ClientOnly = ClientOnly_default;
-exports.ErrorBoundary = ErrorBoundary_default;
-exports.ErrorViewer = ErrorViewer_default;
-exports.Link = Link_default;
+exports.ClientOnly = ClientOnly;
+exports.ErrorBoundary = ErrorBoundary;
+exports.ErrorViewer = ErrorViewer;
+exports.Link = Link;
 exports.NestedView = NestedView_default;
 exports.NotFound = NotFoundPage;
 exports.PageDescriptor = PageDescriptor;