@alepha/react 0.9.3 → 0.9.5

package/dist/index.cjs

@@ -25,13 +25,15 @@ const __alepha_core = __toESM(require("@alepha/core"));
 const __alepha_server = __toESM(require("@alepha/server"));
 const __alepha_server_cache = __toESM(require("@alepha/server-cache"));
 const __alepha_server_links = __toESM(require("@alepha/server-links"));
+const __alepha_logger = __toESM(require("@alepha/logger"));
 const react = __toESM(require("react"));
 const react_jsx_runtime = __toESM(require("react/jsx-runtime"));
-const __alepha_router = __toESM(require("@alepha/router"));
 const node_fs = __toESM(require("node:fs"));
 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 __alepha_router = __toESM(require("@alepha/router"));
 
 //#region src/descriptors/$page.ts
 /**
@@ -55,7 +57,16 @@ 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;
+	}
+	pathname(config) {
+		return this.options.path || "";
 	}
 };
 $page[__alepha_core.KIND] = PageDescriptor;
@@ -78,7 +89,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
@@ -186,7 +196,6 @@ const ErrorViewer = ({ error, alepha }) => {
 		})] })]
 	});
 };
-var ErrorViewer_default = ErrorViewer;
 const ErrorViewerProduction = () => {
 	const styles = {
 		container: {
@@ -228,45 +237,107 @@ const ErrorViewerProduction = () => {
 	});
 };
 
-//#endregion
-//#region src/contexts/RouterContext.ts
-const RouterContext = (0, react.createContext)(void 0);
-
 //#endregion
 //#region src/contexts/RouterLayerContext.ts
 const RouterLayerContext = (0, react.createContext)(void 0);
 
+//#endregion
+//#region src/errors/Redirection.ts
+/**
+* Used for Redirection during the page loading.
+*
+* Depends on the context, it can be thrown or just returned.
+*/
+var Redirection = class extends Error {
+	redirect;
+	constructor(redirect) {
+		super("Redirection");
+		this.redirect = redirect;
+	}
+};
+
 //#endregion
 //#region src/contexts/AlephaContext.ts
 const AlephaContext = (0, react.createContext)(void 0);
 
 //#endregion
 //#region src/hooks/useAlepha.ts
+/**
+* Main Alepha hook.
+*
+* It provides access to the Alepha instance within a React component.
+*
+* With Alepha, you can access the core functionalities of the framework:
+*
+* - alepha.state() for state management
+* - alepha.inject() for dependency injection
+* - alepha.emit() for event handling
+* etc...
+*/
 const useAlepha = () => {
 	const alepha = (0, react.useContext)(AlephaContext);
-	if (!alepha) throw new Error("useAlepha must be used within an AlephaContext.Provider");
+	if (!alepha) throw new __alepha_core.AlephaError("Hook 'useAlepha()' must be used within an AlephaContext.Provider");
 	return alepha;
 };
 
 //#endregion
 //#region src/hooks/useRouterEvents.ts
+/**
+* Subscribe to various router events.
+*/
 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.on("react:transition:begin", cb(onBegin)));
+		if (onEnd) subs.push(alepha.on("react:transition:end", cb(onEnd)));
+		if (onError) subs.push(alepha.on("react:transition:error", cb(onError)));
+		if (onSuccess) subs.push(alepha.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(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/components/ErrorBoundary.tsx
 /**
@@ -296,7 +367,6 @@ var ErrorBoundary = class extends react.default.Component {
 		return this.props.children;
 	}
 };
-var ErrorBoundary_default = ErrorBoundary;
 
 //#endregion
 //#region src/components/NestedView.tsx
@@ -307,7 +377,7 @@ var ErrorBoundary_default = ErrorBoundary;
 *
 * @example
 * ```tsx
-* import { NestedView } from "@alepha/react";
+* import { NestedView } from "alepha/react";
 *
 * class App {
 *   parent = $page({
@@ -322,24 +392,108 @@ var ErrorBoundary_default = ErrorBoundary;
 * ```
 */
 const NestedView = (props) => {
-	const app = (0, react.useContext)(RouterContext);
-	const layer = (0, react.useContext)(RouterLayerContext);
-	const index = layer?.index ?? 0;
-	const [view, setView] = (0, react.useState)(app?.state.layers[index]?.element);
-	useRouterEvents({ onEnd: ({ state, context }) => {
-		if (app) app.context = context;
-		if (!state.layers[index]?.cache) setView(state.layers[index]?.element);
-	} }, [app]);
-	if (!app) throw new Error("NestedView must be used within a RouterContext.");
-	const element = view ?? props.children ?? null;
-	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ErrorBoundary_default, {
+	const index = (0, react.use)(RouterLayerContext)?.index ?? 0;
+	const state = useRouterState();
+	const [view, setView] = (0, react.useState)(state.layers[index]?.element);
+	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) => {
-			return app.context.onError?.(error, app.context);
+			const result = state.onError(error, state);
+			if (result instanceof Redirection) return "Redirection inside ErrorBoundary is not allowed.";
+			return result;
 		},
 		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
@@ -361,27 +515,17 @@ function NotFoundPage(props) {
 				fontSize: "1rem",
 				marginBottom: "0.5rem"
 			},
-			children: "This page does not exist"
+			children: "404 - This page does not exist"
 		})
 	});
 }
 
 //#endregion
-//#region src/errors/Redirection.ts
-var Redirection = class extends Error {
-	page;
-	constructor(page) {
-		super("Redirection");
-		this.page = page;
-	}
-};
-
-//#endregion
-//#region src/providers/PageDescriptorProvider.ts
-const envSchema$1 = __alepha_core.t.object({ REACT_STRICT_MODE: __alepha_core.t.boolean({ default: true }) });
-var PageDescriptorProvider = class {
-	log = (0, __alepha_core.$logger)();
-	env = (0, __alepha_core.$env)(envSchema$1);
+//#region src/providers/ReactPageProvider.ts
+const envSchema$2 = __alepha_core.t.object({ REACT_STRICT_MODE: __alepha_core.t.boolean({ default: true }) });
+var ReactPageProvider = class {
+	log = (0, __alepha_logger.$logger)();
+	env = (0, __alepha_core.$env)(envSchema$2);
 	alepha = (0, __alepha_core.$inject)(__alepha_core.Alepha);
 	pages = [];
 	getPages() {
@@ -408,22 +552,29 @@ var PageDescriptorProvider = class {
 		return url.replace(/\/\/+/g, "/") || "/";
 	}
 	url(name, options = {}) {
-		return new URL(this.pathname(name, options), options.base ?? `http://localhost`);
+		return new URL(this.pathname(name, options), options.host ?? `http://localhost`);
 	}
-	root(state, context) {
-		const root = (0, react.createElement)(AlephaContext.Provider, { value: this.alepha }, (0, react.createElement)(RouterContext.Provider, { value: {
-			state,
-			context
-		} }, (0, react.createElement)(NestedView_default, {}, state.layers[0]?.element)));
+	root(state) {
+		const root = (0, react.createElement)(AlephaContext.Provider, { value: this.alepha }, (0, react.createElement)(NestedView_default, {}, state.layers[0]?.element));
 		if (this.env.REACT_STRICT_MODE) return (0, react.createElement)(react.StrictMode, {}, root);
 		return root;
 	}
-	async createLayers(route, request) {
-		const { pathname, search } = request.url;
-		const layers = [];
+	convertStringObjectToObject = (schema, value) => {
+		if (__alepha_core.TypeGuard.IsObject(schema) && typeof value === "object") {
+			for (const key in schema.properties) if (__alepha_core.TypeGuard.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.
+	* It also handles errors and redirects.
+	*/
+	async createLayers(route, state, previous = []) {
 		let context = {};
 		const stack = [{ route }];
-		request.onError = (error) => this.renderError(error);
 		let parent = route.parent;
 		while (parent) {
 			stack.unshift({ route: parent });
@@ -435,19 +586,19 @@ var PageDescriptorProvider = class {
 			const route$1 = it.route;
 			const config = {};
 			try {
-				config.query = route$1.schema?.query ? this.alepha.parse(route$1.schema.query, request.query) : {};
+				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;
 				break;
 			}
 			try {
-				config.params = route$1.schema?.params ? this.alepha.parse(route$1.schema.params, request.params) : {};
+				config.params = route$1.schema?.params ? this.alepha.parse(route$1.schema.params, state.params) : {};
 			} catch (e) {
 				it.error = e;
 				break;
 			}
 			it.config = { ...config };
-			const previous = request.previous;
 			if (previous?.[i] && !forceRefresh && previous[i].name === route$1.name) {
 				const url = (str) => str ? str.replace(/\/\/+/g, "/") : "/";
 				const prev = JSON.stringify({
@@ -473,7 +624,7 @@ var PageDescriptorProvider = class {
 			if (!route$1.resolve) continue;
 			try {
 				const props = await route$1.resolve?.({
-					...request,
+					...state,
 					...config,
 					...context
 				}) ?? {};
@@ -483,11 +634,8 @@ var PageDescriptorProvider = class {
 					...props
 				};
 			} catch (e) {
-				if (e instanceof Redirection) return this.createRedirectionLayer(e.page, {
-					pathname,
-					search
-				});
-				this.log.error(e);
+				if (e instanceof Redirection) return { redirect: e.redirect };
+				this.log.error("Page resolver has failed", e);
 				it.error = e;
 				break;
 			}
@@ -503,69 +651,58 @@ var PageDescriptorProvider = class {
 			const path = acc.replace(/\/+/, "/");
 			const localErrorHandler = this.getErrorHandler(it.route);
 			if (localErrorHandler) {
-				const onErrorParent = request.onError;
-				request.onError = (error, context$1) => {
+				const onErrorParent = state.onError;
+				state.onError = (error, context$1) => {
 					const result = localErrorHandler(error, context$1);
 					if (result === void 0) return onErrorParent(error, context$1);
 					return result;
 				};
 			}
-			if (it.error) try {
-				let element$1 = await request.onError(it.error, request);
-				if (element$1 === void 0) throw it.error;
-				if (element$1 instanceof Redirection) return this.createRedirectionLayer(element$1.page, {
-					pathname,
-					search
+			if (!it.error) try {
+				const element = await this.createElement(it.route, {
+					...props,
+					...context
 				});
-				if (element$1 === null) element$1 = this.renderError(it.error);
-				layers.push({
+				state.layers.push({
+					name: it.route.name,
+					props,
+					part: it.route.path,
+					config: it.config,
+					element: this.renderView(i + 1, path, element, it.route),
+					index: i + 1,
+					path,
+					route: it.route,
+					cache: it.cache
+				});
+			} catch (e) {
+				it.error = e;
+			}
+			if (it.error) try {
+				let element = await state.onError(it.error, state);
+				if (element === void 0) throw it.error;
+				if (element instanceof Redirection) return { redirect: element.redirect };
+				if (element === null) element = this.renderError(it.error);
+				state.layers.push({
 					props,
 					error: it.error,
 					name: it.route.name,
 					part: it.route.path,
 					config: it.config,
-					element: this.renderView(i + 1, path, element$1, it.route),
+					element: this.renderView(i + 1, path, element, it.route),
 					index: i + 1,
 					path,
 					route: it.route
 				});
 				break;
 			} catch (e) {
-				if (e instanceof Redirection) return this.createRedirectionLayer(e.page, {
-					pathname,
-					search
-				});
+				if (e instanceof Redirection) return { redirect: e.redirect };
 				throw e;
 			}
-			const element = await this.createElement(it.route, {
-				...props,
-				...context
-			});
-			layers.push({
-				name: it.route.name,
-				props,
-				part: it.route.path,
-				config: it.config,
-				element: this.renderView(i + 1, path, element, it.route),
-				index: i + 1,
-				path,
-				route: it.route,
-				cache: it.cache
-			});
 		}
-		return {
-			layers,
-			pathname,
-			search
-		};
+		return { state };
 	}
-	createRedirectionLayer(href, context) {
-		return {
-			layers: [],
-			redirect: typeof href === "string" ? href : this.href(href),
-			pathname: context.pathname,
-			search: context.search
-		};
+	createRedirectionLayer(redirect) {
+		return { redirect };
 	}
 	getErrorHandler(route) {
 		if (route.errorHandler) return route.errorHandler;
@@ -576,6 +713,7 @@ var PageDescriptorProvider = 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);
@@ -584,7 +722,7 @@ var PageDescriptorProvider = class {
 		return void 0;
 	}
 	renderError(error) {
-		return (0, react.createElement)(ErrorViewer_default, {
+		return (0, react.createElement)(ErrorViewer, {
 			error,
 			alepha: this.alepha
 		});
@@ -610,7 +748,7 @@ var PageDescriptorProvider = 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
@@ -691,218 +829,9 @@ const isPageRoute = (it) => {
 	return it && typeof it === "object" && typeof it.path === "string" && typeof it.page === "object";
 };
 
-//#endregion
-//#region src/providers/BrowserRouterProvider.ts
-var BrowserRouterProvider = class extends __alepha_router.RouterProvider {
-	log = (0, __alepha_core.$logger)();
-	alepha = (0, __alepha_core.$inject)(__alepha_core.Alepha);
-	pageDescriptorProvider = (0, __alepha_core.$inject)(PageDescriptorProvider);
-	add(entry) {
-		this.pageDescriptorProvider.add(entry);
-	}
-	configure = (0, __alepha_core.$hook)({
-		on: "configure",
-		handler: async () => {
-			for (const page of this.pageDescriptorProvider.getPages()) if (page.component || page.lazy) this.push({
-				path: page.match,
-				page
-			});
-		}
-	});
-	async transition(url, options = {}) {
-		const { pathname, search } = url;
-		const state = {
-			pathname,
-			search,
-			layers: []
-		};
-		const context = {
-			url,
-			query: {},
-			params: {},
-			onError: () => null,
-			...options.context ?? {}
-		};
-		await this.alepha.emit("react:transition:begin", {
-			state,
-			context
-		});
-		try {
-			const previous = options.previous;
-			const { route, params } = this.match(pathname);
-			const query = {};
-			if (search) for (const [key, value] of new URLSearchParams(search).entries()) query[key] = String(value);
-			context.query = query;
-			context.params = params ?? {};
-			context.previous = previous;
-			if (isPageRoute(route)) {
-				const result = await this.pageDescriptorProvider.createLayers(route.page, context);
-				if (result.redirect) return {
-					redirect: result.redirect,
-					state,
-					context
-				};
-				state.layers = result.layers;
-			}
-			if (state.layers.length === 0) state.layers.push({
-				name: "not-found",
-				element: (0, react.createElement)(NotFoundPage),
-				index: 0,
-				path: "/"
-			});
-			await this.alepha.emit("react:transition:success", {
-				state,
-				context
-			});
-		} catch (e) {
-			this.log.error(e);
-			state.layers = [{
-				name: "error",
-				element: this.pageDescriptorProvider.renderError(e),
-				index: 0,
-				path: "/"
-			}];
-			await this.alepha.emit("react:transition:error", {
-				error: e,
-				state,
-				context
-			});
-		}
-		if (options.state) {
-			options.state.layers = state.layers;
-			options.state.pathname = state.pathname;
-			options.state.search = state.search;
-		}
-		if (options.previous) for (let i = 0; i < options.previous.length; i++) {
-			const layer = options.previous[i];
-			if (state.layers[i]?.name !== layer.name) this.pageDescriptorProvider.page(layer.name)?.onLeave?.();
-		}
-		await this.alepha.emit("react:transition:end", {
-			state: options.state,
-			context
-		});
-		return {
-			context,
-			state
-		};
-	}
-	root(state, context) {
-		return this.pageDescriptorProvider.root(state, context);
-	}
-};
-
-//#endregion
-//#region src/providers/ReactBrowserProvider.ts
-var ReactBrowserProvider = class {
-	log = (0, __alepha_core.$logger)();
-	client = (0, __alepha_core.$inject)(__alepha_server_links.LinkProvider);
-	alepha = (0, __alepha_core.$inject)(__alepha_core.Alepha);
-	router = (0, __alepha_core.$inject)(BrowserRouterProvider);
-	root;
-	transitioning;
-	state = {
-		layers: [],
-		pathname: "",
-		search: ""
-	};
-	get document() {
-		return window.document;
-	}
-	get history() {
-		return window.history;
-	}
-	get location() {
-		return window.location;
-	}
-	get url() {
-		let url = this.location.pathname + this.location.search;
-		return url;
-	}
-	pushState(url, replace) {
-		let path = url;
-		if (replace) this.history.replaceState({}, "", path);
-		else this.history.pushState({}, "", path);
-	}
-	async invalidate(props) {
-		const previous = [];
-		if (props) {
-			const [key] = Object.keys(props);
-			const value = props[key];
-			for (const layer of this.state.layers) {
-				if (layer.props?.[key]) {
-					previous.push({
-						...layer,
-						props: {
-							...layer.props,
-							[key]: value
-						}
-					});
-					break;
-				}
-				previous.push(layer);
-			}
-		}
-		await this.render({ previous });
-	}
-	async go(url, options = {}) {
-		const result = await this.render({ url });
-		if (result.context.url.pathname + result.context.url.search !== url) {
-			this.pushState(result.context.url.pathname + result.context.url.search);
-			return;
-		}
-		this.pushState(url, options.replace);
-	}
-	async render(options = {}) {
-		const previous = options.previous ?? this.state.layers;
-		const url = options.url ?? this.url;
-		this.transitioning = { to: url };
-		const result = await this.router.transition(new URL(`http://localhost${url}`), {
-			previous,
-			state: this.state
-		});
-		if (result.redirect) return await this.render({ url: result.redirect });
-		this.transitioning = void 0;
-		return result;
-	}
-	/**
-	* Get embedded layers from the server.
-	*/
-	getHydrationState() {
-		try {
-			if ("__ssr" in window && typeof window.__ssr === "object") return window.__ssr;
-		} catch (error) {
-			console.error(error);
-		}
-	}
-	ready = (0, __alepha_core.$hook)({
-		on: "ready",
-		handler: async () => {
-			const hydration = this.getHydrationState();
-			const previous = hydration?.layers ?? [];
-			if (hydration) {
-				for (const [key, value] of Object.entries(hydration)) if (key !== "layers" && key !== "links") this.alepha.state(key, value);
-			}
-			if (hydration?.links) for (const link of hydration.links.links) this.client.pushLink({
-				...link,
-				prefix: hydration.links.prefix
-			});
-			const { context } = await this.render({ previous });
-			await this.alepha.emit("react:browser:render", {
-				state: this.state,
-				context,
-				hydration
-			});
-			window.addEventListener("popstate", () => {
-				if (this.state.pathname === this.url) return;
-				this.render();
-			});
-		}
-	});
-};
-
 //#endregion
 //#region src/providers/ReactServerProvider.ts
-const envSchema = __alepha_core.t.object({
+const envSchema$1 = __alepha_core.t.object({
 	REACT_SERVER_DIST: __alepha_core.t.string({ default: "public" }),
 	REACT_SERVER_PREFIX: __alepha_core.t.string({ default: "" }),
 	REACT_SSR_ENABLED: __alepha_core.t.optional(__alepha_core.t.boolean()),
@@ -910,13 +839,14 @@ const envSchema = __alepha_core.t.object({
 	REACT_SERVER_TEMPLATE: __alepha_core.t.optional(__alepha_core.t.string({ size: "rich" }))
 });
 var ReactServerProvider = class {
-	log = (0, __alepha_core.$logger)();
+	log = (0, __alepha_logger.$logger)();
 	alepha = (0, __alepha_core.$inject)(__alepha_core.Alepha);
-	pageDescriptorProvider = (0, __alepha_core.$inject)(PageDescriptorProvider);
+	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);
+	env = (0, __alepha_core.$env)(envSchema$1);
 	ROOT_DIV_REGEX = new RegExp(`<div([^>]*)\\s+id=["']${this.env.REACT_ROOT_ID}["']([^>]*)>(.*?)<\\/div>`, "is");
 	onConfigure = (0, __alepha_core.$hook)({
 		on: "configure",
@@ -924,7 +854,23 @@ var ReactServerProvider = class {
 			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);
+			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;
@@ -963,7 +909,7 @@ var ReactServerProvider = class {
 		return this.alepha.env.REACT_SERVER_TEMPLATE ?? "<!DOCTYPE html><html lang='en'><head></head><body></body></html>";
 	}
 	async registerPages(templateLoader) {
-		for (const page of this.pageDescriptorProvider.getPages()) {
+		for (const page of this.pageApi.getPages()) {
 			if (page.children?.length) continue;
 			this.log.debug(`+ ${page.match} -> ${page.name}`);
 			this.serverRouterProvider.createRoute({
@@ -997,25 +943,39 @@ var ReactServerProvider = class {
 	*/
 	createRenderFunction(name, withIndex = false) {
 		return async (options = {}) => {
-			const page = this.pageDescriptorProvider.page(name);
-			const url = new URL(this.pageDescriptorProvider.url(name, options));
-			const context = {
+			const page = this.pageApi.page(name);
+			const url = new URL(this.pageApi.url(name, options));
+			const entry = {
 				url,
 				params: options.params ?? {},
 				query: options.query ?? {},
-				head: {},
-				onError: () => null
+				onError: () => null,
+				layers: [],
+				meta: {}
 			};
-			await this.alepha.emit("react:server:render:begin", { context });
-			const state = await this.pageDescriptorProvider.createLayers(page, context);
-			if (!withIndex && !options.html) return {
-				context,
-				html: (0, react_dom_server.renderToString)(this.pageDescriptorProvider.root(state, context))
+			const state = entry;
+			this.log.trace("Rendering", { url });
+			await this.alepha.emit("react:server:render:begin", { state });
+			const { redirect } = await this.pageApi.createLayers(page, state);
+			if (redirect) return {
+				state,
+				html: "",
+				redirect
+			};
+			if (!withIndex && !options.html) {
+				this.alepha.state("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) return {
+				state,
+				html: "",
+				redirect
 			};
-			const html = this.renderToHtml(this.template ?? "", state, context, options.hydration);
-			if (html instanceof Redirection) throw new Error("Redirection is not supported in this context");
 			const result = {
-				context,
 				state,
 				html
 			};
@@ -1023,89 +983,82 @@ var ReactServerProvider = class {
 			return result;
 		};
 	}
-	createHandler(page, templateLoader) {
+	createHandler(route, templateLoader) {
 		return async (serverRequest) => {
 			const { url, reply, query, params } = serverRequest;
 			const template = await templateLoader();
 			if (!template) throw new Error("Template not found");
-			this.log.trace("Rendering page", { name: page.name });
-			const context = {
+			this.log.trace("Rendering page", { name: route.name });
+			const entry = {
 				url,
 				params,
 				query,
-				head: {},
-				onError: () => null
+				onError: () => null,
+				layers: []
 			};
-			if (this.alepha.has(__alepha_server_links.ServerLinksProvider)) {
-				const srv = this.alepha.inject(__alepha_server_links.ServerLinksProvider);
-				const schema = __alepha_server.apiLinksResponseSchema;
-				context.links = this.alepha.parse(schema, await srv.getLinks({
-					user: serverRequest.user,
-					authorization: serverRequest.headers.authorization
-				}));
-				this.alepha.context.set("links", context.links);
-			}
-			let target = page;
+			const state = entry;
+			if (this.alepha.has(__alepha_server_links.ServerLinksProvider)) this.alepha.state("api", await this.alepha.inject(__alepha_server_links.ServerLinksProvider).getUserApiLinks({
+				user: serverRequest.user,
+				authorization: serverRequest.headers.authorization
+			}));
+			let target = route;
 			while (target) {
-				if (page.can && !page.can()) {
+				if (route.can && !route.can()) {
 					reply.status = 403;
 					reply.headers["content-type"] = "text/plain";
 					return "Forbidden";
 				}
 				target = target.parent;
 			}
-			await this.alepha.emit("react:transition:begin", {
-				request: serverRequest,
-				context
-			});
 			await this.alepha.emit("react:server:render:begin", {
 				request: serverRequest,
-				context
+				state
 			});
 			this.serverTimingProvider.beginTiming("createLayers");
-			const state = await this.pageDescriptorProvider.createLayers(page, context);
+			const { redirect } = await this.pageApi.createLayers(route, state);
 			this.serverTimingProvider.endTiming("createLayers");
-			if (state.redirect) return reply.redirect(state.redirect);
+			if (redirect) return reply.redirect(redirect);
 			reply.headers["content-type"] = "text/html";
 			reply.headers["cache-control"] = "no-store, no-cache, must-revalidate, proxy-revalidate";
 			reply.headers.pragma = "no-cache";
 			reply.headers.expires = "0";
-			if (page.cache && serverRequest.user) delete context.links;
-			const html = this.renderToHtml(template, state, context);
+			const html = this.renderToHtml(template, state);
 			if (html instanceof Redirection) {
-				reply.redirect(typeof html.page === "string" ? html.page : this.pageDescriptorProvider.href(html.page));
+				reply.redirect(typeof html.redirect === "string" ? html.redirect : this.pageApi.href(html.redirect));
 				return;
 			}
 			const event = {
 				request: serverRequest,
-				context,
 				state,
 				html
 			};
 			await this.alepha.emit("react:server:render:end", event);
-			page.onServerResponse?.(serverRequest);
-			this.log.trace("Page rendered", { name: page.name });
+			route.onServerResponse?.(serverRequest);
+			this.log.trace("Page rendered", { name: route.name });
 			return event.html;
 		};
 	}
-	renderToHtml(template, state, context, hydration = true) {
-		const element = this.pageDescriptorProvider.root(state, context);
+	renderToHtml(template, state, hydration = true) {
+		const element = this.pageApi.root(state);
+		this.alepha.state("react.router.state", state);
 		this.serverTimingProvider.beginTiming("renderToString");
 		let app = "";
 		try {
 			app = (0, react_dom_server.renderToString)(element);
 		} catch (error) {
-			this.log.error("Error during SSR", error);
-			const element$1 = context.onError(error, context);
+			this.log.error("renderToString has failed, fallback to error handler", error);
+			const element$1 = state.onError(error, state);
 			if (element$1 instanceof Redirection) return element$1;
 			app = (0, react_dom_server.renderToString)(element$1);
+			this.log.debug("Error handled successfully with fallback");
 		}
 		this.serverTimingProvider.endTiming("renderToString");
 		const response = { html: template };
 		if (hydration) {
-			const { request, context: context$1,...rest } = this.alepha.context.als?.getStore() ?? {};
+			const { request, context,...store } = this.alepha.context.als?.getStore() ?? {};
 			const hydrationData = {
-				...rest,
+				...store,
+				"react.router.state": void 0,
 				layers: state.layers.map((it) => ({
 					...it,
 					error: it.error ? {
@@ -1120,7 +1073,7 @@ var ReactServerProvider = class {
 					route: void 0
 				}))
 			};
-			const script = `<script>window.__ssr=${JSON.stringify(hydrationData)}</script>`;
+			const script = `<script>window.__ssr=${JSON.stringify(hydrationData)}<\/script>`;
 			this.fillTemplate(response, app, script);
 		}
 		return response.html;
@@ -1141,27 +1094,262 @@ var ReactServerProvider = class {
 };
 
 //#endregion
-//#region src/hooks/RouterHookApi.ts
-var RouterHookApi = class {
-	constructor(pages, context, state, layer, pageApi, browser) {
-		this.pages = pages;
-		this.context = context;
-		this.state = state;
-		this.layer = layer;
-		this.pageApi = pageApi;
-		this.browser = browser;
+//#region src/providers/ReactBrowserRouterProvider.ts
+var ReactBrowserRouterProvider = class extends __alepha_router.RouterProvider {
+	log = (0, __alepha_logger.$logger)();
+	alepha = (0, __alepha_core.$inject)(__alepha_core.Alepha);
+	pageApi = (0, __alepha_core.$inject)(ReactPageProvider);
+	add(entry) {
+		this.pageApi.add(entry);
+	}
+	configure = (0, __alepha_core.$hook)({
+		on: "configure",
+		handler: async () => {
+			for (const page of this.pageApi.getPages()) if (page.component || page.lazy) this.push({
+				path: page.match,
+				page
+			});
+		}
+	});
+	async transition(url, previous = [], meta = {}) {
+		const { pathname, search } = url;
+		const entry = {
+			url,
+			query: {},
+			params: {},
+			layers: [],
+			onError: () => null,
+			meta
+		};
+		const state = entry;
+		await this.alepha.emit("react:transition:begin", {
+			previous: this.alepha.state("react.router.state"),
+			state
+		});
+		try {
+			const { route, params } = this.match(pathname);
+			const query = {};
+			if (search) for (const [key, value] of new URLSearchParams(search).entries()) query[key] = String(value);
+			state.query = query;
+			state.params = params ?? {};
+			if (isPageRoute(route)) {
+				const { redirect } = await this.pageApi.createLayers(route.page, state, previous);
+				if (redirect) return redirect;
+			}
+			if (state.layers.length === 0) state.layers.push({
+				name: "not-found",
+				element: (0, react.createElement)(NotFoundPage),
+				index: 0,
+				path: "/"
+			});
+			await this.alepha.emit("react:transition:success", { state });
+		} catch (e) {
+			this.log.error("Transition has failed", e);
+			state.layers = [{
+				name: "error",
+				element: this.pageApi.renderError(e),
+				index: 0,
+				path: "/"
+			}];
+			await this.alepha.emit("react:transition:error", {
+				error: e,
+				state
+			});
+		}
+		if (previous) for (let i = 0; i < previous.length; i++) {
+			const layer = previous[i];
+			if (state.layers[i]?.name !== layer.name) this.pageApi.page(layer.name)?.onLeave?.();
+		}
+		this.alepha.state("react.router.state", state);
+		await this.alepha.emit("react:transition:end", { state });
+	}
+	root(state) {
+		return this.pageApi.root(state);
+	}
+};
+
+//#endregion
+//#region src/providers/ReactBrowserProvider.ts
+const envSchema = __alepha_core.t.object({ REACT_ROOT_ID: __alepha_core.t.string({ default: "root" }) });
+var ReactBrowserProvider = class {
+	env = (0, __alepha_core.$env)(envSchema);
+	log = (0, __alepha_logger.$logger)();
+	client = (0, __alepha_core.$inject)(__alepha_server_links.LinkProvider);
+	alepha = (0, __alepha_core.$inject)(__alepha_core.Alepha);
+	router = (0, __alepha_core.$inject)(ReactBrowserRouterProvider);
+	dateTimeProvider = (0, __alepha_core.$inject)(__alepha_datetime.DateTimeProvider);
+	options = { scrollRestoration: "top" };
+	getRootElement() {
+		const root = this.document.getElementById(this.env.REACT_ROOT_ID);
+		if (root) return root;
+		const div = this.document.createElement("div");
+		div.id = this.env.REACT_ROOT_ID;
+		this.document.body.prepend(div);
+		return div;
+	}
+	transitioning;
+	get state() {
+		return this.alepha.state("react.router.state");
+	}
+	/**
+	* Accessor for Document DOM API.
+	*/
+	get document() {
+		return window.document;
+	}
+	/**
+	* Accessor for History DOM API.
+	*/
+	get history() {
+		return window.history;
+	}
+	/**
+	* Accessor for Location DOM API.
+	*/
+	get location() {
+		return window.location;
+	}
+	get base() {
+		const base = {}.env?.BASE_URL;
+		if (!base || base === "/") return "";
+		return base;
+	}
+	get url() {
+		const url = this.location.pathname + this.location.search;
+		if (this.base) return url.replace(this.base, "");
+		return url;
+	}
+	pushState(path, replace) {
+		const url = this.base + path;
+		if (replace) this.history.replaceState({}, "", url);
+		else this.history.pushState({}, "", url);
+	}
+	async invalidate(props) {
+		const previous = [];
+		this.log.trace("Invalidating layers");
+		if (props) {
+			const [key] = Object.keys(props);
+			const value = props[key];
+			for (const layer of this.state.layers) {
+				if (layer.props?.[key]) {
+					previous.push({
+						...layer,
+						props: {
+							...layer.props,
+							[key]: value
+						}
+					});
+					break;
+				}
+				previous.push(layer);
+			}
+		}
+		await this.render({ previous });
+	}
+	async go(url, options = {}) {
+		this.log.trace(`Going to ${url}`, {
+			url,
+			options
+		});
+		await this.render({
+			url,
+			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);
+			return;
+		}
+		this.pushState(url, options.replace);
+	}
+	async render(options = {}) {
+		const previous = options.previous ?? this.state.layers;
+		const url = options.url ?? this.url;
+		const start = this.dateTimeProvider.now();
+		this.transitioning = {
+			to: url,
+			from: this.state?.url.pathname
+		};
+		this.log.debug("Transitioning...", { to: url });
+		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 });
+		}
+		const ms = this.dateTimeProvider.now().diff(start);
+		this.log.info(`Transition OK [${ms}ms]`, this.transitioning);
+		this.transitioning = void 0;
+	}
+	/**
+	* Get embedded layers from the server.
+	*/
+	getHydrationState() {
+		try {
+			if ("__ssr" in window && typeof window.__ssr === "object") return window.__ssr;
+		} catch (error) {
+			console.error(error);
+		}
+	}
+	onTransitionEnd = (0, __alepha_core.$hook)({
+		on: "react:transition:end",
+		handler: () => {
+			if (this.options.scrollRestoration === "top" && typeof window !== "undefined" && !this.alepha.isTest()) {
+				this.log.trace("Restoring scroll position to top");
+				window.scrollTo(0, 0);
+			}
+		}
+	});
+	ready = (0, __alepha_core.$hook)({
+		on: "ready",
+		handler: async () => {
+			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);
+			}
+			await this.render({ previous });
+			const element = this.router.root(this.state);
+			await this.alepha.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 });
+				this.render();
+			});
+		}
+	});
+};
+
+//#endregion
+//#region src/services/ReactRouter.ts
+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");
+	}
+	get pages() {
+		return this.pageApi.getPages();
+	}
+	get browser() {
+		if (this.alepha.isBrowser()) return this.alepha.inject(ReactBrowserProvider);
+		return void 0;
 	}
 	path(name, config = {}) {
 		return this.pageApi.pathname(name, {
 			params: {
-				...this.context.params,
+				...this.state.params,
 				...config.params
 			},
 			query: config.query
 		});
 	}
 	getURL() {
-		if (!this.browser) return this.context.url;
+		if (!this.browser) return this.state.url;
 		return new URL(this.location.href);
 	}
 	get location() {
@@ -1172,11 +1360,11 @@ var RouterHookApi = class {
 		return this.state;
 	}
 	get pathname() {
-		return this.state.pathname;
+		return this.state.url.pathname;
 	}
 	get query() {
 		const query = {};
-		for (const [key, value] of new URLSearchParams(this.state.search).entries()) query[key] = String(value);
+		for (const [key, value] of new URLSearchParams(this.state.url.search).entries()) query[key] = String(value);
 		return query;
 	}
 	async back() {
@@ -1188,17 +1376,6 @@ var RouterHookApi = class {
 	async invalidate(props) {
 		await this.browser?.invalidate(props);
 	}
-	/**
-	* Create a valid href for the given pathname.
-	*
-	* @param pathname
-	* @param layer
-	*/
-	createHref(pathname, layer = this.layer, options = {}) {
-		if (typeof pathname === "object") pathname = pathname.options.path ?? "";
-		if (options.params) for (const [key, value] of Object.entries(options.params)) pathname = pathname.replace(`:${key}`, String(value));
-		return pathname.startsWith("/") ? pathname : `${layer.path}/${pathname}`.replace(/\/\/+/g, "/");
-	}
 	async go(path, options) {
 		for (const page of this.pages) if (page.name === path) {
 			await this.browser?.go(this.path(path, options), options);
@@ -1213,7 +1390,7 @@ var RouterHookApi = class {
 			break;
 		}
 		return {
-			href,
+			href: this.base(href),
 			onClick: (ev) => {
 				ev.stopPropagation();
 				ev.preventDefault();
@@ -1221,6 +1398,11 @@ var RouterHookApi = class {
 			}
 		};
 	}
+	base(path) {
+		const base = {}.env?.BASE_URL;
+		if (!base || base === "/") return path;
+		return base + path;
+	}
 	/**
 	* Set query params.
 	*
@@ -1236,107 +1418,99 @@ var RouterHookApi = class {
 	}
 };
 
+//#endregion
+//#region src/hooks/useInject.ts
+/**
+* Hook to inject a service instance.
+* It's a wrapper of `useAlepha().inject(service)` with a memoization.
+*/
+const useInject = (service) => {
+	const alepha = useAlepha();
+	return (0, react.useMemo)(() => alepha.inject(service), []);
+};
+
 //#endregion
 //#region src/hooks/useRouter.ts
+/**
+* Use this hook to access the React Router instance.
+*
+* You can add a type parameter to specify the type of your application.
+* This will allow you to use the router in a typesafe way.
+*
+* @example
+* class App {
+*   home = $page();
+* }
+*
+* const router = useRouter<App>();
+* router.go("home"); // typesafe
+*/
 const useRouter = () => {
-	const alepha = useAlepha();
-	const ctx = (0, react.useContext)(RouterContext);
-	const layer = (0, react.useContext)(RouterLayerContext);
-	if (!ctx || !layer) throw new Error("useRouter must be used within a RouterProvider");
-	const pages = (0, react.useMemo)(() => {
-		return alepha.inject(PageDescriptorProvider).getPages();
-	}, []);
-	return (0, react.useMemo)(() => new RouterHookApi(pages, ctx.context, ctx.state, layer, alepha.inject(PageDescriptorProvider), alepha.isBrowser() ? alepha.inject(ReactBrowserProvider) : void 0), [layer]);
+	return useInject(ReactRouter);
 };
 
 //#endregion
 //#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/useActive.ts
-const useActive = (path) => {
+const useActive = (args) => {
 	const router = useRouter();
-	const ctx = (0, react.useContext)(RouterContext);
-	const layer = (0, react.useContext)(RouterLayerContext);
-	if (!ctx || !layer) throw new Error("useRouter must be used within a RouterProvider");
-	const [current, setCurrent] = (0, react.useState)(ctx.state.pathname);
-	const href = (0, react.useMemo)(() => router.createHref(path ?? "", layer), [path, layer]);
 	const [isPending, setPending] = (0, react.useState)(false);
-	const isActive = current === href || current === `${href}/` || `${current}/` === href;
-	useRouterEvents({ onEnd: ({ state }) => {
-		path && setCurrent(state.pathname);
-	} }, [path]);
+	const state = useRouterState();
+	const current = state.url.pathname;
+	const options = typeof args === "string" ? { href: args } : {
+		...args,
+		href: args.href
+	};
+	const href = options.href;
+	let isActive = current === href || current === `${href}/` || `${current}/` === href;
+	if (options.startWith && !isActive) isActive = current.startsWith(href);
 	return {
 		isPending,
 		isActive,
 		anchorProps: {
-			href,
-			onClick: (ev) => {
+			href: router.base(href),
+			onClick: async (ev) => {
 				ev?.stopPropagation();
 				ev?.preventDefault();
 				if (isActive) return;
 				if (isPending) return;
 				setPending(true);
-				router.go(href).then(() => {
+				try {
+					await router.go(href);
+				} finally {
 					setPending(false);
-				});
+				}
 			}
 		}
 	};
 };
 
 //#endregion
-//#region src/hooks/useInject.ts
-const useInject = (service) => {
-	const alepha = useAlepha();
-	return (0, react.useMemo)(() => alepha.inject(service), []);
-};
-
-//#endregion
-//#region src/hooks/useStore.ts
+//#region src/hooks/useClient.ts
 /**
-* Hook to access and mutate the Alepha state.
+* Hook to get a virtual client for the specified scope.
+*
+* It's the React-hook version of `$client()`, from `AlephaServerLinks` module.
 */
-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);
-		});
-	}, []);
-	if (!alepha.isBrowser()) {
-		const value = alepha.context.get(key);
-		if (value !== null) return [value, (_) => {}];
-	}
-	return [state, (value) => {
-		alepha.state(key, value);
-	}];
-};
-
-//#endregion
-//#region src/hooks/useClient.ts
-const useClient = (_scope) => {
-	useStore("user");
-	return useInject(__alepha_server_links.LinkProvider).client();
+const useClient = (scope) => {
+	return useInject(__alepha_server_links.LinkProvider).client(scope);
 };
 
 //#endregion
 //#region src/hooks/useQueryParams.ts
+/**
+* Not well tested. Use with caution.
+*/
 const useQueryParams = (schema, options = {}) => {
 	const alepha = useAlepha();
 	const key = options.key ?? "q";
@@ -1367,29 +1541,17 @@ const decode = (alepha, schema, data) => {
 	}
 };
 
-//#endregion
-//#region src/hooks/useRouterState.ts
-const useRouterState = () => {
-	const router = (0, react.useContext)(RouterContext);
-	const layer = (0, react.useContext)(RouterLayerContext);
-	if (!router || !layer) throw new Error("useRouterState must be used within a RouterContext.Provider");
-	const [state, setState] = (0, react.useState)(router.state);
-	useRouterEvents({ onEnd: ({ state: state$1 }) => setState({ ...state$1 }) });
-	return state;
-};
-
 //#endregion
 //#region src/hooks/useSchema.ts
 const useSchema = (action) => {
 	const name = action.name;
 	const alepha = useAlepha();
 	const httpClient = useInject(__alepha_server.HttpClient);
-	const linkProvider = useInject(__alepha_server_links.LinkProvider);
 	const [schema, setSchema] = (0, react.useState)(ssrSchemaLoading(alepha, name));
 	(0, react.useEffect)(() => {
 		if (!schema.loading) return;
 		const opts = { cache: true };
-		httpClient.fetch(`${linkProvider.URL_LINKS}/${name}/schema`, {}, opts).then((it) => setSchema(it.data));
+		httpClient.fetch(`${__alepha_server_links.LinkProvider.path.apiLinks}/${name}/schema`, {}, opts).then((it) => setSchema(it.data));
 	}, [name]);
 	return schema;
 };
@@ -1398,10 +1560,10 @@ const useSchema = (action) => {
 */
 const ssrSchemaLoading = (alepha, name) => {
 	if (!alepha.isBrowser()) {
-		const links = alepha.context.get("links")?.links ?? [];
-		const can = links.find((it) => it.name === name);
+		const linkProvider = alepha.inject(__alepha_server_links.LinkProvider);
+		const can = linkProvider.getServerLinks().find((link) => link.name === name);
 		if (can) {
-			const schema$1 = alepha.inject(__alepha_server_links.LinkProvider).links?.find((it) => it.name === name)?.schema;
+			const schema$1 = linkProvider.links.find((it) => it.name === name)?.schema;
 			if (schema$1) {
 				can.schema = schema$1;
 				return schema$1;
@@ -1409,7 +1571,7 @@ const ssrSchemaLoading = (alepha, name) => {
 		}
 		return { loading: true };
 	}
-	const schema = alepha.inject(__alepha_server_links.LinkProvider).links?.find((it) => it.name === name)?.schema;
+	const schema = alepha.inject(__alepha_server_links.LinkProvider).links.find((it) => it.name === name)?.schema;
 	if (schema) return schema;
 	return { loading: true };
 };
@@ -1431,28 +1593,28 @@ const AlephaReact = (0, __alepha_core.$module)({
 	descriptors: [$page],
 	services: [
 		ReactServerProvider,
-		PageDescriptorProvider,
-		ReactBrowserProvider
+		ReactPageProvider,
+		ReactRouter
 	],
-	register: (alepha) => alepha.with(__alepha_server.AlephaServer).with(__alepha_server_cache.AlephaServerCache).with(__alepha_server_links.AlephaServerLinks).with(ReactServerProvider).with(PageDescriptorProvider)
+	register: (alepha) => alepha.with(__alepha_server.AlephaServer).with(__alepha_server_cache.AlephaServerCache).with(__alepha_server_links.AlephaServerLinks).with(ReactServerProvider).with(ReactPageProvider).with(ReactRouter)
 });
 
 //#endregion
 exports.$page = $page;
 exports.AlephaContext = AlephaContext;
 exports.AlephaReact = AlephaReact;
-exports.ClientOnly = ClientOnly_default;
-exports.ErrorBoundary = ErrorBoundary_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;
-exports.PageDescriptorProvider = PageDescriptorProvider;
 exports.ReactBrowserProvider = ReactBrowserProvider;
+exports.ReactPageProvider = ReactPageProvider;
+exports.ReactRouter = ReactRouter;
 exports.ReactServerProvider = ReactServerProvider;
 exports.Redirection = Redirection;
-exports.RouterContext = RouterContext;
-exports.RouterHookApi = RouterHookApi;
 exports.RouterLayerContext = RouterLayerContext;
 exports.isPageRoute = isPageRoute;
 exports.ssrSchemaLoading = ssrSchemaLoading;