alepha 0.22.0 → 0.24.0

package/dist/react/core/index.js

@@ -1,5 +1,5 @@
 import { $module, Alepha, AlephaError, Atom } from "alepha";
-import React, { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+import React, { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import { jsx } from "react/jsx-runtime";
 import { DateTimeProvider } from "alepha/datetime";
 import { LinkProvider } from "alepha/server/links";
@@ -59,6 +59,18 @@ var ErrorBoundary = class extends React.Component {
 	componentDidCatch(error, info) {
 		if (this.props.onError) this.props.onError(error, info);
 	}
+	/**
+	* Recover once the caller signals the failing input is gone.
+	*/
+	componentDidUpdate(prevProps) {
+		if (!this.state.error) return;
+		if (this.hasResetKeyChanged(prevProps.resetKeys, this.props.resetKeys)) this.setState({ error: void 0 });
+	}
+	hasResetKeyChanged(previous, next) {
+		if (previous === next) return false;
+		if (!previous || !next || previous.length !== next.length) return true;
+		return previous.some((value, i) => !Object.is(value, next[i]));
+	}
 	render() {
 		if (this.state.error) {
 			const reset = () => {
@@ -242,6 +254,7 @@ function useAction(options, deps) {
 	const abortControllerRef = useRef(void 0);
 	const isMountedRef = useRef(true);
 	const intervalRef = useRef(void 0);
+	const runIdRef = useRef(0);
 	useEffect(() => {
 		isMountedRef.current = true;
 		return () => {
@@ -261,11 +274,13 @@ function useAction(options, deps) {
 			isExecutingRef.current = false;
 		};
 	}, []);
-	const executeAction = useCallback(async (...args) => {
-		if (isExecutingRef.current) return;
+	const executeAction = useCallback(async (args, { supersede = false } = {}) => {
+		if (isExecutingRef.current && !supersede) return;
 		if (abortControllerRef.current) abortControllerRef.current.abort();
 		const abortController = new AbortController();
 		abortControllerRef.current = abortController;
+		const runId = ++runIdRef.current;
+		const isLatestRun = () => runIdRef.current === runId;
 		isExecutingRef.current = true;
 		setLoading(true);
 		setError(void 0);
@@ -275,7 +290,7 @@ function useAction(options, deps) {
 				id: options.id
 			});
 			const result = await options.handler(...args, { signal: abortController.signal });
-			if (!isMountedRef.current || abortController.signal.aborted) return;
+			if (!isMountedRef.current || abortController.signal.aborted || !isLatestRun()) return;
 			setResult(result);
 			await alepha.events.emit("react:action:success", {
 				type: "custom",
@@ -285,7 +300,7 @@ function useAction(options, deps) {
 			return result;
 		} catch (err) {
 			if (err instanceof Error && err.name === "AbortError") return;
-			if (!isMountedRef.current) return;
+			if (!isMountedRef.current || !isLatestRun()) return;
 			const error = err;
 			setError(error);
 			await alepha.events.emit("react:action:error", {
@@ -295,8 +310,10 @@ function useAction(options, deps) {
 			});
 			if (options.onError) await options.onError(error);
 		} finally {
-			isExecutingRef.current = false;
-			if (isMountedRef.current) setLoading(false);
+			if (isLatestRun()) {
+				isExecutingRef.current = false;
+				if (isMountedRef.current) setLoading(false);
+			}
 			await alepha.events.emit("react:action:end", {
 				type: "custom",
 				id: options.id
@@ -309,17 +326,22 @@ function useAction(options, deps) {
 		options.onError,
 		options.onSuccess
 	]);
-	const handler = useCallback(async (...args) => {
+	const runAction = useCallback(async (args, options_ = {}) => {
 		if (options.debounce) {
 			if (debounceTimerRef.current) dateTimeProvider.clearTimeout(debounceTimerRef.current);
 			return new Promise((resolve) => {
 				debounceTimerRef.current = dateTimeProvider.createTimeout(async () => {
-					resolve(await executeAction(...args));
+					resolve(await executeAction(args, options_));
 				}, options.debounce ?? 0);
 			});
 		}
-		return executeAction(...args);
+		return executeAction(args, options_);
 	}, [executeAction, options.debounce]);
+	/**
+	* Public `run()` — a user-initiated call. Deduped while one is in flight so a
+	* double-clicked mutation submits once.
+	*/
+	const handler = useCallback((...args) => runAction(args), [runAction]);
 	const cancel = useCallback(() => {
 		if (debounceTimerRef.current) {
 			dateTimeProvider.clearTimeout(debounceTimerRef.current);
@@ -335,18 +357,18 @@ function useAction(options, deps) {
 		}
 	}, []);
 	useEffect(() => {
-		if (options.runOnInit) handler(...[]);
+		if (options.runOnInit) runAction([], { supersede: true });
 	}, deps);
 	useEffect(() => {
 		if (!options.runEvery) return;
-		intervalRef.current = dateTimeProvider.createInterval(() => handler(...[]), options.runEvery, true);
+		intervalRef.current = dateTimeProvider.createInterval(() => runAction([], { supersede: true }), options.runEvery, true);
 		return () => {
 			if (intervalRef.current) {
 				dateTimeProvider.clearInterval(intervalRef.current);
 				intervalRef.current = void 0;
 			}
 		};
-	}, [handler, options.runEvery]);
+	}, [runAction, options.runEvery]);
 	return {
 		run: handler,
 		loading,
@@ -369,6 +391,66 @@ const useClient = (scope) => {
 	}, [scope]);
 };
 //#endregion
+//#region ../../src/react/core/hooks/useComputed.ts
+/**
+* Subscribes to a `$computed` value.
+*
+* `getSnapshot` always reads the dependency atoms **live** off the store —
+* never through a subscription-set dirty flag. A dirty flag is only ever
+* flipped by the `state:mutate` listener registered in `subscribe`, which
+* React wires up in a passive effect (after commit); `EventManager.emit` is
+* async on top of that. A mutation dispatched between the initial render and
+* that effect committing would be invisible to the flag, so `getSnapshot`
+* (including React's own post-subscribe consistency re-check) would keep
+* returning the stale pre-mutation value. See `useStore.ts` and
+* `useSelector.ts` for the same rationale.
+*
+* Referential stability for `useSyncExternalStore` comes from comparing the
+* *inputs* (the resolved values of the computed's transitive atom
+* dependencies) by identity, not from caching on a mount-time ref: when none
+* of the inputs changed since the last snapshot, the previous output
+* reference is returned as-is; when any input changed (or `target` itself
+* was swapped for a different `Computed`), the value is recomputed and a new
+* reference is cached.
+*
+* A `Computed` passed here should be declared at module scope, like an
+* atom — constructing one inline in a component body creates a new
+* instance every render, which (because `subscribe`/`getSnapshot` are keyed
+* on `target.key`, matching `useStore`/`useSelector`) is tolerated for
+* resubscription purposes, but any closures captured by that instance's
+* `get()` will be locked to whichever render first created the subscription
+* until `target.key` itself changes.
+*
+* ```tsx
+* const total = useComputed(cartTotal);
+* ```
+*/
+function useComputed(target) {
+	const alepha = useAlepha();
+	const key = target.key;
+	const cache = useRef(null);
+	const subscribe = useCallback((onStoreChange) => {
+		if (!alepha.isBrowser()) return () => {};
+		const keys = new Set(target.keys());
+		return alepha.events.on("state:mutate", (ev) => {
+			if (keys.has(ev.key)) onStoreChange();
+		});
+	}, [alepha, key]);
+	const getSnapshot = useCallback(() => {
+		const inputs = target.keys().map((depKey) => alepha.store.get(depKey));
+		const prev = cache.current;
+		if (prev && prev.target === target && prev.inputs.length === inputs.length && prev.inputs.every((value, index) => Object.is(value, inputs[index]))) return prev.value;
+		const value = alepha.store.get(target);
+		cache.current = {
+			target,
+			inputs,
+			value
+		};
+		return value;
+	}, [alepha, key]);
+	return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+//#endregion
 //#region ../../src/react/core/hooks/useEvents.ts
 /**
 * Allow subscribing to multiple Alepha events. See {@link Hooks} for available events.
@@ -472,25 +554,90 @@ function useQuery(options, deps) {
 	};
 }
 //#endregion
+//#region ../../src/react/core/hooks/useSelector.ts
+/**
+* Subscribes to a slice of an atom's state.
+*
+* Unlike {@link useStore}, which re-renders on every mutation of the atom,
+* `useSelector` re-renders only when the selected slice actually changes
+* according to `equality` (default: `Object.is`). Pass {@link shallowEqual}
+* when the selector builds a fresh object on each call.
+*
+* ```tsx
+* const theme = useSelector(uiAtom, (s) => s.theme);
+* ```
+*/
+function useSelector(target, select, equality = Object.is) {
+	const alepha = useAlepha();
+	const key = target.key;
+	const cache = useRef(null);
+	const selectRef = useRef(select);
+	selectRef.current = select;
+	const equalityRef = useRef(equality);
+	equalityRef.current = equality;
+	const subscribe = useCallback((onStoreChange) => {
+		if (!alepha.isBrowser()) return () => {};
+		return alepha.events.on("state:mutate", (ev) => {
+			if (ev.key === key) onStoreChange();
+		});
+	}, [alepha, key]);
+	const getSnapshot = useCallback(() => {
+		const input = alepha.store.get(target);
+		const prev = cache.current;
+		if (prev && Object.is(prev.input, input)) return prev.selected;
+		const selected = selectRef.current(input);
+		if (prev && equalityRef.current(prev.selected, selected)) {
+			cache.current = {
+				input,
+				selected: prev.selected
+			};
+			return prev.selected;
+		}
+		cache.current = {
+			input,
+			selected
+		};
+		return selected;
+	}, [alepha, key]);
+	return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+//#endregion
 //#region ../../src/react/core/hooks/useStore.ts
 function useStore(target, defaultValue) {
 	const alepha = useAlepha();
+	const key = target instanceof Atom ? target.key : target;
 	useMemo(() => {
 		if (defaultValue != null && alepha.store.get(target) == null) alepha.store.set(target, defaultValue);
-	}, [defaultValue]);
-	const [state, setState] = useState(alepha.store.get(target));
-	useEffect(() => {
-		if (!alepha.isBrowser()) return;
-		const key = target instanceof Atom ? target.key : target;
+	}, [defaultValue, key]);
+	const subscribe = useCallback((onStoreChange) => {
+		if (!alepha.isBrowser()) return () => {};
 		return alepha.events.on("state:mutate", (ev) => {
-			if (ev.key === key) setState(ev.value);
+			if (ev.key === key) onStoreChange();
 		});
-	}, []);
-	return [state, (value) => {
+	}, [alepha, key]);
+	const getSnapshot = useCallback(() => alepha.store.get(target), [alepha, key]);
+	return [useSyncExternalStore(subscribe, getSnapshot, getSnapshot), useCallback((value) => {
 		alepha.store.set(target, value);
-	}];
+	}, [alepha, key])];
 }
 //#endregion
+//#region ../../src/react/core/utils/shallowEqual.ts
+/**
+* Shallow structural equality over own enumerable keys.
+*
+* Intended as the `equality` argument of `useSelector` when the selector
+* builds a fresh object/array on every call (e.g. `(s) => ({ a: s.a })`).
+*/
+const shallowEqual = (a, b) => {
+	if (Object.is(a, b)) return true;
+	if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) return false;
+	const keysA = Object.keys(a);
+	const keysB = Object.keys(b);
+	if (keysA.length !== keysB.length) return false;
+	for (const key of keysA) if (!Object.hasOwn(b, key) || !Object.is(a[key], b[key])) return false;
+	return true;
+};
+//#endregion
 //#region ../../src/react/core/index.ts
 /**
 * Full-stack React framework with server-side rendering.
@@ -518,6 +665,6 @@ function useStore(target, defaultValue) {
 */
 const AlephaReact = $module({ name: "alepha.react.core" });
 //#endregion
-export { AlephaContext, AlephaProvider, AlephaReact, ClientOnly, ErrorBoundary, useAction, useAlepha, useClient, useEvents, useInject, useQuery, useStore };
+export { AlephaContext, AlephaProvider, AlephaReact, ClientOnly, ErrorBoundary, shallowEqual, useAction, useAlepha, useClient, useComputed, useEvents, useInject, useQuery, useSelector, useStore };
 
 //# sourceMappingURL=index.js.map

package/dist/react/core/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../src/react/core/components/ClientOnly.tsx","../../../src/react/core/components/ErrorBoundary.tsx","../../../src/react/core/contexts/AlephaContext.ts","../../../src/react/core/contexts/AlephaProvider.tsx","../../../src/react/core/hooks/useAlepha.ts","../../../src/react/core/hooks/useInject.ts","../../../src/react/core/hooks/useAction.ts","../../../src/react/core/hooks/useClient.ts","../../../src/react/core/hooks/useEvents.ts","../../../src/react/core/hooks/useQuery.ts","../../../src/react/core/hooks/useStore.ts","../../../src/react/core/index.ts"],"sourcesContent":["import {\n  type PropsWithChildren,\n  type ReactNode,\n  useEffect,\n  useState,\n} from \"react\";\n\nexport interface ClientOnlyProps {\n  fallback?: ReactNode;\n  disabled?: boolean;\n}\n\n/**\n * A small utility component that renders its children only on the client side.\n *\n * Optionally, you can provide a fallback React node that will be rendered.\n *\n * You should use this component when\n * - you have code that relies on browser-specific APIs\n * - you want to avoid server-side rendering for a specific part of your application\n * - you want to prevent pre-rendering of a component\n *\n * @example\n * ```tsx\n * import { ClientOnly } from \"alepha/react\";\n *\n * const MyComponent = () => {\n *   // Avoids SSR issues with Date API\n *   return (\n *     <ClientOnly>\n *       {new Date().toLocaleTimeString()}\n *     </ClientOnly>\n *   );\n * }\n * ```\n */\nconst ClientOnly = (props: PropsWithChildren<ClientOnlyProps>) => {\n  const [mounted, setMounted] = useState(false);\n\n  useEffect(() => setMounted(true), []);\n\n  if (props.disabled) {\n    return props.children;\n  }\n\n  return mounted ? props.children : props.fallback;\n};\n\nexport default ClientOnly;\n","import React, {\n  type ErrorInfo,\n  type PropsWithChildren,\n  type ReactNode,\n} from \"react\";\n\n/**\n * Props for the ErrorBoundary component.\n */\nexport interface ErrorBoundaryProps {\n  /**\n   * Fallback React node to render when an error is caught.\n   * If not provided, a default error message will be shown.\n   */\n  fallback: (error: Error, reset: () => void) => ReactNode;\n\n  /**\n   * Optional callback that receives the error and error info.\n   * Use this to log errors to a monitoring service.\n   */\n  onError?: (error: Error, info: ErrorInfo) => void;\n}\n\n/**\n * State of the ErrorBoundary component.\n */\ninterface ErrorBoundaryState {\n  error?: Error;\n}\n\n/**\n * A reusable error boundary for catching rendering errors in any part of the React component tree.\n *\n * It's already included in the Alepha React framework when using page or layout components.\n */\nexport class ErrorBoundary extends React.Component<\n  PropsWithChildren<ErrorBoundaryProps>,\n  ErrorBoundaryState\n> {\n  constructor(props: ErrorBoundaryProps) {\n    super(props);\n    this.state = {};\n  }\n\n  /**\n   * Update state so the next render shows the fallback UI.\n   */\n  static getDerivedStateFromError(error: Error): ErrorBoundaryState {\n    return {\n      error,\n    };\n  }\n\n  /**\n   * Lifecycle method called when an error is caught.\n   * You can log the error or perform side effects here.\n   */\n  componentDidCatch(error: Error, info: ErrorInfo): void {\n    if (this.props.onError) {\n      this.props.onError(error, info);\n    }\n  }\n\n  render(): ReactNode {\n    if (this.state.error) {\n      const reset = () => {\n        this.setState({ error: undefined });\n      };\n      return this.props.fallback(this.state.error, reset);\n    }\n\n    return this.props.children;\n  }\n}\n\nexport default ErrorBoundary;\n","import type { Alepha } from \"alepha\";\nimport { createContext } from \"react\";\n\n/**\n * React context to provide the Alepha instance throughout the component tree.\n */\nexport const AlephaContext = createContext<Alepha | undefined>(undefined);\n","import { Alepha } from \"alepha\";\nimport { type ReactNode, useEffect, useMemo, useState } from \"react\";\nimport { AlephaContext } from \"./AlephaContext.ts\";\n\nexport interface AlephaProviderProps {\n  children: ReactNode;\n  onError: (error: Error) => ReactNode;\n  onLoading: () => ReactNode;\n}\n\n/**\n * AlephaProvider component to initialize and provide Alepha instance to the app.\n *\n * This isn't recommended for apps using `alepha/react/router`, as Router will handle this for you.\n */\nexport const AlephaProvider = (props: AlephaProviderProps) => {\n  const alepha = useMemo(() => Alepha.create(), []);\n\n  const [started, setStarted] = useState(false);\n  const [error, setError] = useState<Error | undefined>();\n\n  useEffect(() => {\n    alepha\n      .start()\n      .then(() => setStarted(true))\n      .catch((err) => setError(err));\n  }, [alepha]);\n\n  if (error) {\n    return props.onError(error);\n  }\n\n  if (!started) {\n    return props.onLoading();\n  }\n\n  return (\n    <AlephaContext.Provider value={alepha}>\n      {props.children}\n    </AlephaContext.Provider>\n  );\n};\n","import { type Alepha, AlephaError } from \"alepha\";\nimport { useContext } from \"react\";\nimport { AlephaContext } from \"../contexts/AlephaContext.ts\";\n\n/**\n * Main Alepha hook.\n *\n * It provides access to the Alepha instance within a React component.\n *\n * With Alepha, you can access the core functionalities of the framework:\n *\n * - alepha.state() for state management\n * - alepha.inject() for dependency injection\n * - alepha.events.emit() for event handling\n * etc...\n */\nexport const useAlepha = (): Alepha => {\n  const alepha = useContext(AlephaContext);\n  if (!alepha) {\n    throw new AlephaError(\n      \"Hook 'useAlepha()' must be used within an AlephaContext.Provider\",\n    );\n  }\n\n  return alepha;\n};\n","import type { Service } from \"alepha\";\nimport { useMemo } from \"react\";\nimport { useAlepha } from \"./useAlepha.ts\";\n\n/**\n * Hook to inject a service instance.\n * It's a wrapper of `useAlepha().inject(service)` with a memoization.\n */\nexport const useInject = <T extends object>(service: Service<T>): T => {\n  const alepha = useAlepha();\n  return useMemo(() => alepha.inject(service), []);\n};\n","import type { Async } from \"alepha\";\nimport {\n  DateTimeProvider,\n  type DurationLike,\n  type Interval,\n  type Timeout,\n} from \"alepha/datetime\";\nimport {\n  type DependencyList,\n  useCallback,\n  useEffect,\n  useRef,\n  useState,\n} from \"react\";\nimport { useAlepha } from \"./useAlepha.ts\";\nimport { useInject } from \"./useInject.ts\";\n\n/**\n * Hook for handling async actions with automatic error handling and event emission.\n *\n * By default, prevents concurrent executions - if an action is running and you call it again,\n * the second call will be ignored. Use `debounce` option to delay execution instead.\n *\n * Emits lifecycle events:\n * - `react:action:begin` - When action starts\n * - `react:action:success` - When action completes successfully\n * - `react:action:error` - When action throws an error\n * - `react:action:end` - Always emitted at the end\n *\n * @example Basic usage\n * ```tsx\n * const action = useAction({\n *   handler: async (data) => {\n *     await api.save(data);\n *   }\n * }, []);\n *\n * <button onClick={() => action.run(data)} disabled={action.loading}>\n *   Save\n * </button>\n * ```\n *\n * @example With debounce (search input)\n * ```tsx\n * const search = useAction({\n *   handler: async (query: string) => {\n *     await api.search(query);\n *   },\n *   debounce: 300 // Wait 300ms after last call\n * }, []);\n *\n * <input onChange={(e) => search.run(e.target.value)} />\n * ```\n *\n * @example Run on component mount\n * ```tsx\n * const fetchData = useAction({\n *   handler: async () => {\n *     const data = await api.getData();\n *     return data;\n *   },\n *   runOnInit: true // Runs once when component mounts\n * }, []);\n * ```\n *\n * @example Run periodically (polling)\n * ```tsx\n * const pollStatus = useAction({\n *   handler: async () => {\n *     const status = await api.getStatus();\n *     return status;\n *   },\n *   runEvery: 5000 // Run every 5 seconds\n * }, []);\n *\n * // Or with duration tuple\n * const pollStatus = useAction({\n *   handler: async () => {\n *     const status = await api.getStatus();\n *     return status;\n *   },\n *   runEvery: [30, 'seconds'] // Run every 30 seconds\n * }, []);\n * ```\n *\n * @example With AbortController\n * ```tsx\n * const fetch = useAction({\n *   handler: async (url, { signal }) => {\n *     const response = await fetch(url, { signal });\n *     return response.json();\n *   }\n * }, []);\n * // Automatically cancelled on unmount or when new request starts\n * ```\n *\n * @example With error handling\n * ```tsx\n * const deleteAction = useAction({\n *   handler: async (id: string) => {\n *     await api.delete(id);\n *   },\n *   onError: (error) => {\n *     if (error.code === 'NOT_FOUND') {\n *       // Custom error handling\n *     }\n *   }\n * }, []);\n *\n * {deleteAction.error && <div>Error: {deleteAction.error.message}</div>}\n * ```\n *\n * @example Global error handling\n * ```tsx\n * // In your root app setup\n * alepha.events.on(\"react:action:error\", ({ error }) => {\n *   toast.danger(error.message);\n *   Sentry.captureException(error);\n * });\n * ```\n */\nexport function useAction<Args extends any[], Result = void>(\n  options: UseActionOptions<Args, Result>,\n  deps: DependencyList,\n): UseActionReturn<Args, Result> {\n  const alepha = useAlepha();\n  const dateTimeProvider = useInject(DateTimeProvider);\n  const [loading, setLoading] = useState(false);\n  const [error, setError] = useState<Error | undefined>();\n  const [result, setResult] = useState<Result | undefined>();\n  const isExecutingRef = useRef(false);\n  const debounceTimerRef = useRef<Timeout | undefined>(undefined);\n  const abortControllerRef = useRef<AbortController | undefined>(undefined);\n  const isMountedRef = useRef(true);\n  const intervalRef = useRef<Interval | undefined>(undefined);\n\n  // Track mount state — must set true in body for React StrictMode double-invoke\n  useEffect(() => {\n    isMountedRef.current = true;\n\n    return () => {\n      isMountedRef.current = false;\n\n      // clear debounce timer\n      if (debounceTimerRef.current) {\n        dateTimeProvider.clearTimeout(debounceTimerRef.current);\n        debounceTimerRef.current = undefined;\n      }\n\n      // clear interval\n      if (intervalRef.current) {\n        dateTimeProvider.clearInterval(intervalRef.current);\n        intervalRef.current = undefined;\n      }\n\n      // abort in-flight request\n      if (abortControllerRef.current) {\n        abortControllerRef.current.abort();\n        abortControllerRef.current = undefined;\n      }\n\n      // Release the concurrency guard: we've just abandoned the in-flight run\n      // (its result is discarded by the aborted-signal check), so the *next*\n      // lifecycle must be free to start. Without this, a remount that reuses\n      // the same refs — React StrictMode's double-invoke, or a Suspense/router\n      // remount on client-side navigation — would hit `if (isExecutingRef\n      // .current) return` and never re-run, leaving a `useQuery` stuck on its\n      // loading skeleton forever (the original request 200s but is dropped).\n      isExecutingRef.current = false;\n    };\n  }, []);\n\n  const executeAction = useCallback(\n    async (...args: Args): Promise<Result | undefined> => {\n      // Prevent concurrent executions\n      if (isExecutingRef.current) {\n        return;\n      }\n\n      // Abort previous request if still running\n      if (abortControllerRef.current) {\n        abortControllerRef.current.abort();\n      }\n\n      // Create new AbortController for this request\n      const abortController = new AbortController();\n      abortControllerRef.current = abortController;\n\n      isExecutingRef.current = true;\n      setLoading(true);\n      setError(undefined);\n\n      try {\n        await alepha.events.emit(\"react:action:begin\", {\n          type: \"custom\",\n          id: options.id,\n        });\n        // Pass abort signal as last argument to handler\n        const result = await options.handler(...args, {\n          signal: abortController.signal,\n        } as any);\n\n        // Only update state if still mounted and not aborted\n        if (!isMountedRef.current || abortController.signal.aborted) {\n          return;\n        }\n\n        setResult(result as Result);\n\n        await alepha.events.emit(\"react:action:success\", {\n          type: \"custom\",\n          id: options.id,\n        });\n\n        if (options.onSuccess) {\n          await options.onSuccess(result);\n        }\n\n        return result;\n      } catch (err) {\n        // Ignore abort errors\n        if (err instanceof Error && err.name === \"AbortError\") {\n          return;\n        }\n\n        // Only update state if still mounted\n        if (!isMountedRef.current) {\n          return;\n        }\n\n        const error = err as Error;\n        setError(error);\n\n        await alepha.events.emit(\"react:action:error\", {\n          type: \"custom\",\n          id: options.id,\n          error,\n        });\n\n        if (options.onError) {\n          await options.onError(error);\n        }\n        // Without a custom `onError`, the error is NOT re-thrown: it is captured\n        // in `error` state and emitted as `react:action:error` (a mounted\n        // <ActionErrorToaster /> surfaces it as a toast). This keeps\n        // fire-and-forget `action.run()` calls from producing unhandled\n        // promise rejections.\n      } finally {\n        isExecutingRef.current = false;\n        if (isMountedRef.current) {\n          setLoading(false);\n        }\n\n        await alepha.events.emit(\"react:action:end\", {\n          type: \"custom\",\n          id: options.id,\n        });\n\n        // Clean up abort controller\n        if (abortControllerRef.current === abortController) {\n          abortControllerRef.current = undefined;\n        }\n      }\n    },\n    [...deps, options.id, options.onError, options.onSuccess],\n  );\n\n  const handler = useCallback(\n    async (...args: Args): Promise<Result | undefined> => {\n      if (options.debounce) {\n        // clear existing timer\n        if (debounceTimerRef.current) {\n          dateTimeProvider.clearTimeout(debounceTimerRef.current);\n        }\n\n        // Set new timer\n        return new Promise((resolve) => {\n          debounceTimerRef.current = dateTimeProvider.createTimeout(\n            async () => {\n              const result = await executeAction(...args);\n              resolve(result);\n            },\n            options.debounce ?? 0,\n          );\n        });\n      }\n\n      return executeAction(...args);\n    },\n    [executeAction, options.debounce],\n  );\n\n  const cancel = useCallback(() => {\n    // clear debounce timer\n    if (debounceTimerRef.current) {\n      dateTimeProvider.clearTimeout(debounceTimerRef.current);\n      debounceTimerRef.current = undefined;\n    }\n\n    // abort in-flight request\n    if (abortControllerRef.current) {\n      abortControllerRef.current.abort();\n      abortControllerRef.current = undefined;\n    }\n\n    // reset state\n    if (isMountedRef.current) {\n      isExecutingRef.current = false;\n      setLoading(false);\n    }\n  }, []);\n\n  // Run action on mount if runOnInit is true\n  useEffect(() => {\n    if (options.runOnInit) {\n      handler(...([] as any));\n    }\n  }, deps);\n\n  // Run action periodically if runEvery is specified\n  useEffect(() => {\n    if (!options.runEvery) {\n      return;\n    }\n\n    // Set up interval\n    intervalRef.current = dateTimeProvider.createInterval(\n      () => handler(...([] as any)),\n      options.runEvery,\n      true,\n    );\n\n    // cleanup on unmount or when runEvery changes\n    return () => {\n      if (intervalRef.current) {\n        dateTimeProvider.clearInterval(intervalRef.current);\n        intervalRef.current = undefined;\n      }\n    };\n  }, [handler, options.runEvery]);\n\n  return {\n    run: handler,\n    loading,\n    error,\n    cancel,\n    result,\n  };\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Context object passed as the last argument to action handlers.\n * Contains an AbortSignal that can be used to cancel the request.\n */\nexport interface ActionContext {\n  /**\n   * AbortSignal that can be passed to fetch or other async operations.\n   * The signal will be aborted when:\n   * - The component unmounts\n   * - A new action is triggered (cancels previous)\n   * - The cancel() method is called\n   *\n   * @example\n   * ```tsx\n   * const action = useAction({\n   *   handler: async (url, { signal }) => {\n   *     const response = await fetch(url, { signal });\n   *     return response.json();\n   *   }\n   * }, []);\n   * ```\n   */\n  signal: AbortSignal;\n}\n\nexport interface UseActionOptions<Args extends any[] = any[], Result = any> {\n  /**\n   * The async action handler function.\n   * Receives the action arguments plus an ActionContext as the last parameter.\n   */\n  handler: (...args: [...Args, ActionContext]) => Async<Result>;\n\n  /**\n   * Custom error handler. If provided, prevents default error re-throw.\n   */\n  onError?: (error: Error) => void | Promise<void>;\n\n  /**\n   * Custom success handler.\n   */\n  onSuccess?: (result: Result) => void | Promise<void>;\n\n  /**\n   * Optional identifier for this action (useful for debugging/analytics)\n   */\n  id?: string;\n\n  name?: string;\n\n  /**\n   * Debounce delay in milliseconds. If specified, the action will only execute\n   * after the specified delay has passed since the last call. Useful for search inputs\n   * or other high-frequency events.\n   *\n   * @example\n   * ```tsx\n   * // Execute search 300ms after user stops typing\n   * const search = useAction({ handler: search, debounce: 300 }, [])\n   * ```\n   */\n  debounce?: number;\n\n  /**\n   * If true, the action will be executed once when the component mounts.\n   *\n   * @example\n   * ```tsx\n   * const fetchData = useAction({\n   *   handler: async () => await api.getData(),\n   *   runOnInit: true\n   * }, []);\n   * ```\n   */\n  runOnInit?: boolean;\n\n  /**\n   * If specified, the action will be executed periodically at the given interval.\n   * The interval is specified as a DurationLike value (number in ms, Duration object, or [number, unit] tuple).\n   *\n   * @example\n   * ```tsx\n   * // Run every 5 seconds\n   * const poll = useAction({\n   *   handler: async () => await api.poll(),\n   *   runEvery: 5000\n   * }, []);\n   * ```\n   *\n   * @example\n   * ```tsx\n   * // Run every 1 minute\n   * const poll = useAction({\n   *   handler: async () => await api.poll(),\n   *   runEvery: [1, 'minute']\n   * }, []);\n   * ```\n   */\n  runEvery?: DurationLike;\n}\n\nexport interface UseActionReturn<Args extends any[], Result> {\n  /**\n   * Execute the action with the provided arguments.\n   *\n   * @example\n   * ```tsx\n   * const action = useAction({ handler: async (data) => { ... } }, []);\n   * action.run(data);\n   * ```\n   */\n  run: (...args: Args) => Promise<Result | undefined>;\n\n  /**\n   * Loading state - true when action is executing.\n   */\n  loading: boolean;\n\n  /**\n   * Error state - contains error if action failed, undefined otherwise.\n   */\n  error?: Error;\n\n  /**\n   * Cancel any pending debounced action or abort the current in-flight request.\n   *\n   * @example\n   * ```tsx\n   * const action = useAction({ ... }, []);\n   *\n   * <button onClick={action.cancel} disabled={!action.loading}>\n   *   Cancel\n   * </button>\n   * ```\n   */\n  cancel: () => void;\n\n  /**\n   * The result data from the last successful action execution.\n   */\n  result?: Result;\n}\n","import {\n  type ClientScope,\n  type HttpVirtualClient,\n  LinkProvider,\n} from \"alepha/server/links\";\nimport { useMemo } from \"react\";\nimport { useInject } from \"./useInject.ts\";\n\n/**\n * Hook to get a virtual client for the specified scope.\n *\n * It's the React-hook version of `$client()`, from `AlephaServerLinks` module.\n */\nexport const useClient = <T extends object>(\n  scope?: ClientScope,\n): HttpVirtualClient<T> => {\n  const linkProvider = useInject(LinkProvider);\n\n  return useMemo(() => {\n    return linkProvider.client<T>(scope);\n  }, [scope]);\n};\n","import type { Async, Hook, Hooks } from \"alepha\";\nimport { type DependencyList, useEffect } from \"react\";\nimport { useAlepha } from \"./useAlepha.ts\";\n\n/**\n * Allow subscribing to multiple Alepha events. See {@link Hooks} for available events.\n *\n * useEvents is fully typed to ensure correct event callback signatures.\n *\n * @example\n * ```tsx\n * useEvents(\n *   {\n *     \"react:transition:begin\": (ev) => {\n *       console.log(\"Transition began to:\", ev.to);\n *     },\n *     \"react:transition:error\": {\n *       priority: \"first\",\n *       callback: (ev) => {\n *         console.error(\"Transition error:\", ev.error);\n *       },\n *     },\n *   },\n *   [],\n * );\n * ```\n */\nexport const useEvents = (opts: UseEvents, deps: DependencyList) => {\n  const alepha = useAlepha();\n\n  useEffect(() => {\n    if (!alepha.isBrowser()) {\n      return;\n    }\n\n    const subs: Function[] = [];\n    for (const [name, hook] of Object.entries(opts)) {\n      subs.push(alepha.events.on(name as any, hook as any));\n    }\n\n    return () => {\n      for (const clear of subs) {\n        clear();\n      }\n    };\n  }, deps);\n};\n\ntype UseEvents = {\n  [T in keyof Hooks]?: Hook<T> | ((payload: Hooks[T]) => Async<void>);\n};\n","import type { Async } from \"alepha\";\nimport type { DurationLike } from \"alepha/datetime\";\nimport { type DependencyList, useCallback, useRef, useState } from \"react\";\nimport type { ActionContext } from \"./useAction.ts\";\nimport { useAction } from \"./useAction.ts\";\n\n/**\n * Hook for declarative data fetching with automatic execution and refetch.\n *\n * Thin wrapper over {@link useAction}: it pre-applies `runOnInit: true`,\n * exposes the last result as `data`, and provides a stable `refetch()` to\n * re-run the query on demand. For optimistic mutations and side-effects,\n * use {@link useAction} directly — `useQuery` is for the read path.\n *\n * Caching, request deduplication, and AbortSignal cancellation come from\n * `useAction` + `HttpClient`. There is no separate cache layer — pass\n * `localCache` to your `HttpClient.fetch()`/`fetchAction()` call inside\n * the query handler if you want per-call caching.\n *\n * @example Basic\n * ```tsx\n * const client = useInject(HttpClient);\n * const { data, loading, error, refetch } = useQuery({\n *   handler: async ({ signal }) => {\n *     const res = await client.fetch(\"/api/users\", { request: { signal } });\n *     return res.data;\n *   },\n * }, []);\n * ```\n *\n * @example Re-fetch when a dep changes\n * ```tsx\n * const { data } = useQuery({\n *   handler: async () => api.getUser(userId),\n * }, [userId]);\n * ```\n *\n * @example Polling\n * ```tsx\n * const { data } = useQuery({\n *   handler: async () => api.getStatus(),\n *   runEvery: [5, \"seconds\"],\n * }, []);\n * ```\n */\nexport function useQuery<Result>(\n  options: UseQueryOptions<Result>,\n  deps: DependencyList,\n): UseQueryReturn<Result> {\n  const enabled = options.enabled !== false;\n  const [data, setData] = useState<Result | undefined>(options.initialData);\n  // Tracks whether the auto-run has completed at least once, so we can keep\n  // `loading` true on the very first render — before `runOnInit`'s effect\n  // fires — instead of briefly reporting `loading: false` with no data.\n  const settledRef = useRef(false);\n\n  const action = useAction<[], Result>(\n    {\n      id: options.id,\n      handler: options.handler,\n      runOnInit: enabled,\n      runEvery: options.runEvery,\n      debounce: options.debounce,\n      onError: options.onError,\n      onSuccess: async (result) => {\n        settledRef.current = true;\n        setData(result);\n        if (options.onSuccess) {\n          await options.onSuccess(result);\n        }\n      },\n    },\n    deps,\n  );\n\n  const refetch = useCallback(() => action.run(), [action.run]);\n\n  // `loading` is true while a fetch is in flight, AND during the initial gap\n  // between first render and the auto-run effect — so consumers can render a\n  // skeleton immediately instead of flashing an empty/not-found state. Only\n  // applies to enabled queries with no `initialData` seed; an error settles\n  // it (the error path keeps the caller's `onError` re-throw semantics).\n  const loading =\n    action.loading ||\n    (enabled &&\n      options.initialData === undefined &&\n      !settledRef.current &&\n      action.error === undefined);\n\n  return {\n    data,\n    loading,\n    error: action.error,\n    refetch,\n    cancel: action.cancel,\n  };\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport interface UseQueryOptions<Result> {\n  /**\n   * Async query handler. Receives an {@link ActionContext} with an\n   * AbortSignal that fires on unmount, dependency change, or `cancel()`.\n   */\n  handler: (context: ActionContext) => Async<Result>;\n\n  /**\n   * Optional identifier (used in lifecycle events for debugging/analytics).\n   */\n  id?: string;\n\n  /**\n   * If `false`, skip automatic execution on mount and dep change. Use\n   * `refetch()` to trigger manually. Defaults to `true`.\n   */\n  enabled?: boolean;\n\n  /**\n   * Initial value for `data` before the first successful fetch.\n   */\n  initialData?: Result;\n\n  /**\n   * Re-run periodically. See {@link useAction} `runEvery`.\n   */\n  runEvery?: DurationLike;\n\n  /**\n   * Debounce delay in milliseconds. See {@link useAction} `debounce`.\n   */\n  debounce?: number;\n\n  /**\n   * Called on success with the resolved value.\n   */\n  onSuccess?: (result: Result) => void | Promise<void>;\n\n  /**\n   * Custom error handler. If provided, prevents default error re-throw.\n   */\n  onError?: (error: Error) => void | Promise<void>;\n}\n\nexport interface UseQueryReturn<Result> {\n  /**\n   * The last successful result. `undefined` until the first fetch resolves\n   * (or the value of `initialData` if provided).\n   */\n  data: Result | undefined;\n\n  /**\n   * Loading state — `true` while a fetch is in flight, and also from the\n   * first render until the initial auto-run settles (for enabled queries\n   * with no `initialData`), so a skeleton can render without a flash.\n   */\n  loading: boolean;\n\n  /**\n   * Error from the last failed fetch, if any.\n   */\n  error?: Error;\n\n  /**\n   * Re-run the query. The previous in-flight request, if any, is aborted.\n   */\n  refetch: () => Promise<Result | undefined>;\n\n  /**\n   * Abort the in-flight request without scheduling another.\n   */\n  cancel: () => void;\n}\n","import type { State, Static, TAtomObject } from \"alepha\";\nimport { Atom } from \"alepha\";\nimport { useEffect, useMemo, useState } from \"react\";\nimport { useAlepha } from \"./useAlepha.ts\";\n\n/**\n * Hook to access and mutate the Alepha state.\n */\nfunction useStore<T extends TAtomObject>(\n  target: Atom<T>,\n  defaultValue?: Static<T>,\n): UseStoreReturn<Static<T>>;\nfunction useStore<Key extends keyof State>(\n  target: Key,\n  defaultValue?: State[Key],\n): UseStoreReturn<State[Key]>;\nfunction useStore(target: any, defaultValue?: any): any {\n  const alepha = useAlepha();\n\n  useMemo(() => {\n    if (defaultValue != null && alepha.store.get(target) == null) {\n      alepha.store.set(target, defaultValue);\n    }\n  }, [defaultValue]);\n\n  const [state, setState] = useState(alepha.store.get(target));\n\n  useEffect(() => {\n    if (!alepha.isBrowser()) {\n      return;\n    }\n\n    const key = target instanceof Atom ? target.key : target;\n\n    return alepha.events.on(\"state:mutate\", (ev) => {\n      if (ev.key === key) {\n        setState(ev.value);\n      }\n    });\n  }, []);\n\n  return [\n    state,\n    (value: any) => {\n      alepha.store.set(target, value);\n    },\n  ] as const;\n}\n\nexport type UseStoreReturn<T> = [T, (value: T) => void];\n\nexport { useStore };\n","import { $module } from \"alepha\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport type * from \"./components/ClientOnly.tsx\";\nexport { default as ClientOnly } from \"./components/ClientOnly.tsx\";\nexport type * from \"./components/ErrorBoundary.tsx\";\nexport { default as ErrorBoundary } from \"./components/ErrorBoundary.tsx\";\nexport * from \"./contexts/AlephaContext.ts\";\nexport * from \"./contexts/AlephaProvider.tsx\";\nexport * from \"./hooks/useAction.ts\";\nexport * from \"./hooks/useAlepha.ts\";\nexport * from \"./hooks/useClient.ts\";\nexport * from \"./hooks/useEvents.ts\";\nexport * from \"./hooks/useInject.ts\";\nexport * from \"./hooks/useQuery.ts\";\nexport * from \"./hooks/useStore.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\ndeclare module \"alepha\" {\n  interface Hooks {\n    /**\n     * Fires when a user action is starting.\n     * Action can be a form submission, a route transition, or a custom action.\n     */\n    \"react:action:begin\": {\n      type: string;\n      id?: string;\n    };\n    /**\n     * Fires when a user action has succeeded.\n     * Action can be a form submission, a route transition, or a custom action.\n     */\n    \"react:action:success\": {\n      type: string;\n      id?: string;\n    };\n    /**\n     * Fires when a user action has failed.\n     * Action can be a form submission, a route transition, or a custom action.\n     */\n    \"react:action:error\": {\n      type: string;\n      id?: string;\n      error: Error;\n    };\n    /**\n     * Fires when a user action has completed, regardless of success or failure.\n     * Action can be a form submission, a route transition, or a custom action.\n     */\n    \"react:action:end\": {\n      type: string;\n      id?: string;\n    };\n  }\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Full-stack React framework with server-side rendering.\n *\n * **Features:**\n * - React page routes with type-safe params\n * - Async action handler with loading/error/cancel states\n * - Type-safe HTTP client access\n * - Dependency injection in components\n * - Global state management\n * - Router navigation methods\n * - Current route state access\n * - Check if path is active\n * - URL query parameters\n * - Access route schema\n * - Subscribe to Alepha events\n * - Type-safe form handling with validation\n * - Error handling wrapper component\n * - Client-side only rendering component\n * - Server-side rendering with hydration\n * - Automatic code splitting\n * - Event system for action tracking\n *\n * @module alepha.react\n */\nexport const AlephaReact = $module({\n  name: \"alepha.react.core\",\n});\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/react/core/components/ClientOnly.tsx","../../../src/react/core/components/ErrorBoundary.tsx","../../../src/react/core/contexts/AlephaContext.ts","../../../src/react/core/contexts/AlephaProvider.tsx","../../../src/react/core/hooks/useAlepha.ts","../../../src/react/core/hooks/useInject.ts","../../../src/react/core/hooks/useAction.ts","../../../src/react/core/hooks/useClient.ts","../../../src/react/core/hooks/useComputed.ts","../../../src/react/core/hooks/useEvents.ts","../../../src/react/core/hooks/useQuery.ts","../../../src/react/core/hooks/useSelector.ts","../../../src/react/core/hooks/useStore.ts","../../../src/react/core/utils/shallowEqual.ts","../../../src/react/core/index.ts"],"sourcesContent":["import {\n  type PropsWithChildren,\n  type ReactNode,\n  useEffect,\n  useState,\n} from \"react\";\n\nexport interface ClientOnlyProps {\n  fallback?: ReactNode;\n  disabled?: boolean;\n}\n\n/**\n * A small utility component that renders its children only on the client side.\n *\n * Optionally, you can provide a fallback React node that will be rendered.\n *\n * You should use this component when\n * - you have code that relies on browser-specific APIs\n * - you want to avoid server-side rendering for a specific part of your application\n * - you want to prevent pre-rendering of a component\n *\n * @example\n * ```tsx\n * import { ClientOnly } from \"alepha/react\";\n *\n * const MyComponent = () => {\n *   // Avoids SSR issues with Date API\n *   return (\n *     <ClientOnly>\n *       {new Date().toLocaleTimeString()}\n *     </ClientOnly>\n *   );\n * }\n * ```\n */\nconst ClientOnly = (props: PropsWithChildren<ClientOnlyProps>) => {\n  const [mounted, setMounted] = useState(false);\n\n  useEffect(() => setMounted(true), []);\n\n  if (props.disabled) {\n    return props.children;\n  }\n\n  return mounted ? props.children : props.fallback;\n};\n\nexport default ClientOnly;\n","import React, {\n  type ErrorInfo,\n  type PropsWithChildren,\n  type ReactNode,\n} from \"react\";\n\n/**\n * Props for the ErrorBoundary component.\n */\nexport interface ErrorBoundaryProps {\n  /**\n   * Fallback React node to render when an error is caught.\n   * If not provided, a default error message will be shown.\n   */\n  fallback: (error: Error, reset: () => void) => ReactNode;\n\n  /**\n   * Optional callback that receives the error and error info.\n   * Use this to log errors to a monitoring service.\n   */\n  onError?: (error: Error, info: ErrorInfo) => void;\n\n  /**\n   * Clear a caught error whenever any of these values changes (compared with\n   * `Object.is`, positionally).\n   *\n   * A boundary that catches has to be told when the reason to fail is gone —\n   * otherwise the fallback latches and every later render keeps showing the\n   * stale error. The router passes the current path, so navigating away from a\n   * page that threw recovers on its own.\n   *\n   * Unlike remounting via `key`, this clears the error WITHOUT tearing down the\n   * children, so unrelated component state survives an ordinary navigation.\n   */\n  resetKeys?: readonly unknown[];\n}\n\n/**\n * State of the ErrorBoundary component.\n */\ninterface ErrorBoundaryState {\n  error?: Error;\n}\n\n/**\n * A reusable error boundary for catching rendering errors in any part of the React component tree.\n *\n * It's already included in the Alepha React framework when using page or layout components.\n */\nexport class ErrorBoundary extends React.Component<\n  PropsWithChildren<ErrorBoundaryProps>,\n  ErrorBoundaryState\n> {\n  constructor(props: ErrorBoundaryProps) {\n    super(props);\n    this.state = {};\n  }\n\n  /**\n   * Update state so the next render shows the fallback UI.\n   */\n  static getDerivedStateFromError(error: Error): ErrorBoundaryState {\n    return {\n      error,\n    };\n  }\n\n  /**\n   * Lifecycle method called when an error is caught.\n   * You can log the error or perform side effects here.\n   */\n  componentDidCatch(error: Error, info: ErrorInfo): void {\n    if (this.props.onError) {\n      this.props.onError(error, info);\n    }\n  }\n\n  /**\n   * Recover once the caller signals the failing input is gone.\n   */\n  componentDidUpdate(prevProps: PropsWithChildren<ErrorBoundaryProps>): void {\n    if (!this.state.error) {\n      return;\n    }\n\n    if (this.hasResetKeyChanged(prevProps.resetKeys, this.props.resetKeys)) {\n      this.setState({ error: undefined });\n    }\n  }\n\n  protected hasResetKeyChanged(\n    previous: readonly unknown[] | undefined,\n    next: readonly unknown[] | undefined,\n  ): boolean {\n    if (previous === next) {\n      return false;\n    }\n\n    if (!previous || !next || previous.length !== next.length) {\n      return true;\n    }\n\n    return previous.some((value, i) => !Object.is(value, next[i]));\n  }\n\n  render(): ReactNode {\n    if (this.state.error) {\n      const reset = () => {\n        this.setState({ error: undefined });\n      };\n      return this.props.fallback(this.state.error, reset);\n    }\n\n    return this.props.children;\n  }\n}\n\nexport default ErrorBoundary;\n","import type { Alepha } from \"alepha\";\nimport { createContext } from \"react\";\n\n/**\n * React context to provide the Alepha instance throughout the component tree.\n */\nexport const AlephaContext = createContext<Alepha | undefined>(undefined);\n","import { Alepha } from \"alepha\";\nimport { type ReactNode, useEffect, useMemo, useState } from \"react\";\nimport { AlephaContext } from \"./AlephaContext.ts\";\n\nexport interface AlephaProviderProps {\n  children: ReactNode;\n  onError: (error: Error) => ReactNode;\n  onLoading: () => ReactNode;\n}\n\n/**\n * AlephaProvider component to initialize and provide Alepha instance to the app.\n *\n * This isn't recommended for apps using `alepha/react/router`, as Router will handle this for you.\n */\nexport const AlephaProvider = (props: AlephaProviderProps) => {\n  const alepha = useMemo(() => Alepha.create(), []);\n\n  const [started, setStarted] = useState(false);\n  const [error, setError] = useState<Error | undefined>();\n\n  useEffect(() => {\n    alepha\n      .start()\n      .then(() => setStarted(true))\n      .catch((err) => setError(err));\n  }, [alepha]);\n\n  if (error) {\n    return props.onError(error);\n  }\n\n  if (!started) {\n    return props.onLoading();\n  }\n\n  return (\n    <AlephaContext.Provider value={alepha}>\n      {props.children}\n    </AlephaContext.Provider>\n  );\n};\n","import { type Alepha, AlephaError } from \"alepha\";\nimport { useContext } from \"react\";\nimport { AlephaContext } from \"../contexts/AlephaContext.ts\";\n\n/**\n * Main Alepha hook.\n *\n * It provides access to the Alepha instance within a React component.\n *\n * With Alepha, you can access the core functionalities of the framework:\n *\n * - alepha.state() for state management\n * - alepha.inject() for dependency injection\n * - alepha.events.emit() for event handling\n * etc...\n */\nexport const useAlepha = (): Alepha => {\n  const alepha = useContext(AlephaContext);\n  if (!alepha) {\n    throw new AlephaError(\n      \"Hook 'useAlepha()' must be used within an AlephaContext.Provider\",\n    );\n  }\n\n  return alepha;\n};\n","import type { Service } from \"alepha\";\nimport { useMemo } from \"react\";\nimport { useAlepha } from \"./useAlepha.ts\";\n\n/**\n * Hook to inject a service instance.\n * It's a wrapper of `useAlepha().inject(service)` with a memoization.\n */\nexport const useInject = <T extends object>(service: Service<T>): T => {\n  const alepha = useAlepha();\n  return useMemo(() => alepha.inject(service), []);\n};\n","import type { Async } from \"alepha\";\nimport {\n  DateTimeProvider,\n  type DurationLike,\n  type Interval,\n  type Timeout,\n} from \"alepha/datetime\";\nimport {\n  type DependencyList,\n  useCallback,\n  useEffect,\n  useRef,\n  useState,\n} from \"react\";\nimport { useAlepha } from \"./useAlepha.ts\";\nimport { useInject } from \"./useInject.ts\";\n\n/**\n * Hook for handling async actions with automatic error handling and event emission.\n *\n * By default, prevents concurrent executions - if an action is running and you call it again,\n * the second call will be ignored. Use `debounce` option to delay execution instead.\n *\n * Emits lifecycle events:\n * - `react:action:begin` - When action starts\n * - `react:action:success` - When action completes successfully\n * - `react:action:error` - When action throws an error\n * - `react:action:end` - Always emitted at the end\n *\n * @example Basic usage\n * ```tsx\n * const action = useAction({\n *   handler: async (data) => {\n *     await api.save(data);\n *   }\n * }, []);\n *\n * <button onClick={() => action.run(data)} disabled={action.loading}>\n *   Save\n * </button>\n * ```\n *\n * @example With debounce (search input)\n * ```tsx\n * const search = useAction({\n *   handler: async (query: string) => {\n *     await api.search(query);\n *   },\n *   debounce: 300 // Wait 300ms after last call\n * }, []);\n *\n * <input onChange={(e) => search.run(e.target.value)} />\n * ```\n *\n * @example Run on component mount\n * ```tsx\n * const fetchData = useAction({\n *   handler: async () => {\n *     const data = await api.getData();\n *     return data;\n *   },\n *   runOnInit: true // Runs once when component mounts\n * }, []);\n * ```\n *\n * @example Run periodically (polling)\n * ```tsx\n * const pollStatus = useAction({\n *   handler: async () => {\n *     const status = await api.getStatus();\n *     return status;\n *   },\n *   runEvery: 5000 // Run every 5 seconds\n * }, []);\n *\n * // Or with duration tuple\n * const pollStatus = useAction({\n *   handler: async () => {\n *     const status = await api.getStatus();\n *     return status;\n *   },\n *   runEvery: [30, 'seconds'] // Run every 30 seconds\n * }, []);\n * ```\n *\n * @example With AbortController\n * ```tsx\n * const fetch = useAction({\n *   handler: async (url, { signal }) => {\n *     const response = await fetch(url, { signal });\n *     return response.json();\n *   }\n * }, []);\n * // Automatically cancelled on unmount or when new request starts\n * ```\n *\n * @example With error handling\n * ```tsx\n * const deleteAction = useAction({\n *   handler: async (id: string) => {\n *     await api.delete(id);\n *   },\n *   onError: (error) => {\n *     if (error.code === 'NOT_FOUND') {\n *       // Custom error handling\n *     }\n *   }\n * }, []);\n *\n * {deleteAction.error && <div>Error: {deleteAction.error.message}</div>}\n * ```\n *\n * @example Global error handling\n * ```tsx\n * // In your root app setup\n * alepha.events.on(\"react:action:error\", ({ error }) => {\n *   toast.danger(error.message);\n *   Sentry.captureException(error);\n * });\n * ```\n */\nexport function useAction<Args extends any[], Result = void>(\n  options: UseActionOptions<Args, Result>,\n  deps: DependencyList,\n): UseActionReturn<Args, Result> {\n  const alepha = useAlepha();\n  const dateTimeProvider = useInject(DateTimeProvider);\n  const [loading, setLoading] = useState(false);\n  const [error, setError] = useState<Error | undefined>();\n  const [result, setResult] = useState<Result | undefined>();\n  const isExecutingRef = useRef(false);\n  const debounceTimerRef = useRef<Timeout | undefined>(undefined);\n  const abortControllerRef = useRef<AbortController | undefined>(undefined);\n  const isMountedRef = useRef(true);\n  const intervalRef = useRef<Interval | undefined>(undefined);\n  // Monotonic id of the latest run. A superseded run keeps executing until its\n  // abort lands, so every state write is gated on \"am I still the latest?\" —\n  // otherwise the stale run's `finally` would clear the newer run's `loading`.\n  const runIdRef = useRef(0);\n\n  // Track mount state — must set true in body for React StrictMode double-invoke\n  useEffect(() => {\n    isMountedRef.current = true;\n\n    return () => {\n      isMountedRef.current = false;\n\n      // clear debounce timer\n      if (debounceTimerRef.current) {\n        dateTimeProvider.clearTimeout(debounceTimerRef.current);\n        debounceTimerRef.current = undefined;\n      }\n\n      // clear interval\n      if (intervalRef.current) {\n        dateTimeProvider.clearInterval(intervalRef.current);\n        intervalRef.current = undefined;\n      }\n\n      // abort in-flight request\n      if (abortControllerRef.current) {\n        abortControllerRef.current.abort();\n        abortControllerRef.current = undefined;\n      }\n\n      // Release the concurrency guard: we've just abandoned the in-flight run\n      // (its result is discarded by the aborted-signal check), so the *next*\n      // lifecycle must be free to start. Without this, a remount that reuses\n      // the same refs — React StrictMode's double-invoke, or a Suspense/router\n      // remount on client-side navigation — would hit `if (isExecutingRef\n      // .current) return` and never re-run, leaving a `useQuery` stuck on its\n      // loading skeleton forever (the original request 200s but is dropped).\n      isExecutingRef.current = false;\n    };\n  }, []);\n\n  const executeAction = useCallback(\n    async (\n      args: Args,\n      { supersede = false }: { supersede?: boolean } = {},\n    ): Promise<Result | undefined> => {\n      if (isExecutingRef.current && !supersede) {\n        // A manual `run()` must not fire twice — this is what stops a\n        // double-clicked mutation from being submitted twice.\n        return;\n      }\n\n      // A dep-change or interval run supersedes: the in-flight request was\n      // issued for inputs that are now stale, so its result must never win.\n      // (This is why the guard above is skipped rather than short-circuiting —\n      // otherwise `useQuery([userId])` whose `userId` changes mid-flight would\n      // never refetch, and the old user's data would stay on screen.)\n      if (abortControllerRef.current) {\n        abortControllerRef.current.abort();\n      }\n\n      // Create new AbortController for this request\n      const abortController = new AbortController();\n      abortControllerRef.current = abortController;\n\n      const runId = ++runIdRef.current;\n      const isLatestRun = () => runIdRef.current === runId;\n\n      isExecutingRef.current = true;\n      setLoading(true);\n      setError(undefined);\n\n      try {\n        await alepha.events.emit(\"react:action:begin\", {\n          type: \"custom\",\n          id: options.id,\n        });\n        // Pass abort signal as last argument to handler\n        const result = await options.handler(...args, {\n          signal: abortController.signal,\n        } as any);\n\n        // Only update state if still mounted, not aborted, and not superseded\n        if (\n          !isMountedRef.current ||\n          abortController.signal.aborted ||\n          !isLatestRun()\n        ) {\n          return;\n        }\n\n        setResult(result as Result);\n\n        await alepha.events.emit(\"react:action:success\", {\n          type: \"custom\",\n          id: options.id,\n        });\n\n        if (options.onSuccess) {\n          await options.onSuccess(result);\n        }\n\n        return result;\n      } catch (err) {\n        // Ignore abort errors\n        if (err instanceof Error && err.name === \"AbortError\") {\n          return;\n        }\n\n        // Only update state if still mounted and not superseded\n        if (!isMountedRef.current || !isLatestRun()) {\n          return;\n        }\n\n        const error = err as Error;\n        setError(error);\n\n        await alepha.events.emit(\"react:action:error\", {\n          type: \"custom\",\n          id: options.id,\n          error,\n        });\n\n        if (options.onError) {\n          await options.onError(error);\n        }\n        // Without a custom `onError`, the error is NOT re-thrown: it is captured\n        // in `error` state and emitted as `react:action:error` (a mounted\n        // <ActionErrorToaster /> surfaces it as a toast). This keeps\n        // fire-and-forget `action.run()` calls from producing unhandled\n        // promise rejections.\n      } finally {\n        // A superseded run must not release the guard or drop `loading` — the\n        // run that replaced it is still in flight.\n        if (isLatestRun()) {\n          isExecutingRef.current = false;\n          if (isMountedRef.current) {\n            setLoading(false);\n          }\n        }\n\n        await alepha.events.emit(\"react:action:end\", {\n          type: \"custom\",\n          id: options.id,\n        });\n\n        // Clean up abort controller\n        if (abortControllerRef.current === abortController) {\n          abortControllerRef.current = undefined;\n        }\n      }\n    },\n    [...deps, options.id, options.onError, options.onSuccess],\n  );\n\n  const runAction = useCallback(\n    async (\n      args: Args,\n      options_: { supersede?: boolean } = {},\n    ): Promise<Result | undefined> => {\n      if (options.debounce) {\n        // clear existing timer\n        if (debounceTimerRef.current) {\n          dateTimeProvider.clearTimeout(debounceTimerRef.current);\n        }\n\n        // Set new timer\n        return new Promise((resolve) => {\n          debounceTimerRef.current = dateTimeProvider.createTimeout(\n            async () => {\n              const result = await executeAction(args, options_);\n              resolve(result);\n            },\n            options.debounce ?? 0,\n          );\n        });\n      }\n\n      return executeAction(args, options_);\n    },\n    [executeAction, options.debounce],\n  );\n\n  /**\n   * Public `run()` — a user-initiated call. Deduped while one is in flight so a\n   * double-clicked mutation submits once.\n   */\n  const handler = useCallback(\n    (...args: Args): Promise<Result | undefined> => runAction(args),\n    [runAction],\n  );\n\n  const cancel = useCallback(() => {\n    // clear debounce timer\n    if (debounceTimerRef.current) {\n      dateTimeProvider.clearTimeout(debounceTimerRef.current);\n      debounceTimerRef.current = undefined;\n    }\n\n    // abort in-flight request\n    if (abortControllerRef.current) {\n      abortControllerRef.current.abort();\n      abortControllerRef.current = undefined;\n    }\n\n    // reset state\n    if (isMountedRef.current) {\n      isExecutingRef.current = false;\n      setLoading(false);\n    }\n  }, []);\n\n  // Run action on mount, and again whenever `deps` change. These runs supersede\n  // an in-flight request: it was issued for the previous deps, so its result is\n  // already stale.\n  useEffect(() => {\n    if (options.runOnInit) {\n      runAction([] as any, { supersede: true });\n    }\n  }, deps);\n\n  // Run action periodically if runEvery is specified\n  useEffect(() => {\n    if (!options.runEvery) {\n      return;\n    }\n\n    // Set up interval\n    intervalRef.current = dateTimeProvider.createInterval(\n      () => runAction([] as any, { supersede: true }),\n      options.runEvery,\n      true,\n    );\n\n    // cleanup on unmount or when runEvery changes\n    return () => {\n      if (intervalRef.current) {\n        dateTimeProvider.clearInterval(intervalRef.current);\n        intervalRef.current = undefined;\n      }\n    };\n  }, [runAction, options.runEvery]);\n\n  return {\n    run: handler,\n    loading,\n    error,\n    cancel,\n    result,\n  };\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Context object passed as the last argument to action handlers.\n * Contains an AbortSignal that can be used to cancel the request.\n */\nexport interface ActionContext {\n  /**\n   * AbortSignal that can be passed to fetch or other async operations.\n   * The signal will be aborted when:\n   * - The component unmounts\n   * - A new action is triggered (cancels previous)\n   * - The cancel() method is called\n   *\n   * @example\n   * ```tsx\n   * const action = useAction({\n   *   handler: async (url, { signal }) => {\n   *     const response = await fetch(url, { signal });\n   *     return response.json();\n   *   }\n   * }, []);\n   * ```\n   */\n  signal: AbortSignal;\n}\n\nexport interface UseActionOptions<Args extends any[] = any[], Result = any> {\n  /**\n   * The async action handler function.\n   * Receives the action arguments plus an ActionContext as the last parameter.\n   */\n  handler: (...args: [...Args, ActionContext]) => Async<Result>;\n\n  /**\n   * Custom error handler. If provided, prevents default error re-throw.\n   */\n  onError?: (error: Error) => void | Promise<void>;\n\n  /**\n   * Custom success handler.\n   */\n  onSuccess?: (result: Result) => void | Promise<void>;\n\n  /**\n   * Optional identifier for this action (useful for debugging/analytics)\n   */\n  id?: string;\n\n  name?: string;\n\n  /**\n   * Debounce delay in milliseconds. If specified, the action will only execute\n   * after the specified delay has passed since the last call. Useful for search inputs\n   * or other high-frequency events.\n   *\n   * @example\n   * ```tsx\n   * // Execute search 300ms after user stops typing\n   * const search = useAction({ handler: search, debounce: 300 }, [])\n   * ```\n   */\n  debounce?: number;\n\n  /**\n   * If true, the action will be executed once when the component mounts.\n   *\n   * @example\n   * ```tsx\n   * const fetchData = useAction({\n   *   handler: async () => await api.getData(),\n   *   runOnInit: true\n   * }, []);\n   * ```\n   */\n  runOnInit?: boolean;\n\n  /**\n   * If specified, the action will be executed periodically at the given interval.\n   * The interval is specified as a DurationLike value (number in ms, Duration object, or [number, unit] tuple).\n   *\n   * @example\n   * ```tsx\n   * // Run every 5 seconds\n   * const poll = useAction({\n   *   handler: async () => await api.poll(),\n   *   runEvery: 5000\n   * }, []);\n   * ```\n   *\n   * @example\n   * ```tsx\n   * // Run every 1 minute\n   * const poll = useAction({\n   *   handler: async () => await api.poll(),\n   *   runEvery: [1, 'minute']\n   * }, []);\n   * ```\n   */\n  runEvery?: DurationLike;\n}\n\nexport interface UseActionReturn<Args extends any[], Result> {\n  /**\n   * Execute the action with the provided arguments.\n   *\n   * @example\n   * ```tsx\n   * const action = useAction({ handler: async (data) => { ... } }, []);\n   * action.run(data);\n   * ```\n   */\n  run: (...args: Args) => Promise<Result | undefined>;\n\n  /**\n   * Loading state - true when action is executing.\n   */\n  loading: boolean;\n\n  /**\n   * Error state - contains error if action failed, undefined otherwise.\n   */\n  error?: Error;\n\n  /**\n   * Cancel any pending debounced action or abort the current in-flight request.\n   *\n   * @example\n   * ```tsx\n   * const action = useAction({ ... }, []);\n   *\n   * <button onClick={action.cancel} disabled={!action.loading}>\n   *   Cancel\n   * </button>\n   * ```\n   */\n  cancel: () => void;\n\n  /**\n   * The result data from the last successful action execution.\n   */\n  result?: Result;\n}\n","import {\n  type ClientScope,\n  type HttpVirtualClient,\n  LinkProvider,\n} from \"alepha/server/links\";\nimport { useMemo } from \"react\";\nimport { useInject } from \"./useInject.ts\";\n\n/**\n * Hook to get a virtual client for the specified scope.\n *\n * It's the React-hook version of `$client()`, from `AlephaServerLinks` module.\n */\nexport const useClient = <T extends object>(\n  scope?: ClientScope,\n): HttpVirtualClient<T> => {\n  const linkProvider = useInject(LinkProvider);\n\n  return useMemo(() => {\n    return linkProvider.client<T>(scope);\n  }, [scope]);\n};\n","import type { Computed } from \"alepha\";\nimport { useCallback, useRef, useSyncExternalStore } from \"react\";\nimport { useAlepha } from \"./useAlepha.ts\";\n\n/**\n * Subscribes to a `$computed` value.\n *\n * `getSnapshot` always reads the dependency atoms **live** off the store —\n * never through a subscription-set dirty flag. A dirty flag is only ever\n * flipped by the `state:mutate` listener registered in `subscribe`, which\n * React wires up in a passive effect (after commit); `EventManager.emit` is\n * async on top of that. A mutation dispatched between the initial render and\n * that effect committing would be invisible to the flag, so `getSnapshot`\n * (including React's own post-subscribe consistency re-check) would keep\n * returning the stale pre-mutation value. See `useStore.ts` and\n * `useSelector.ts` for the same rationale.\n *\n * Referential stability for `useSyncExternalStore` comes from comparing the\n * *inputs* (the resolved values of the computed's transitive atom\n * dependencies) by identity, not from caching on a mount-time ref: when none\n * of the inputs changed since the last snapshot, the previous output\n * reference is returned as-is; when any input changed (or `target` itself\n * was swapped for a different `Computed`), the value is recomputed and a new\n * reference is cached.\n *\n * A `Computed` passed here should be declared at module scope, like an\n * atom — constructing one inline in a component body creates a new\n * instance every render, which (because `subscribe`/`getSnapshot` are keyed\n * on `target.key`, matching `useStore`/`useSelector`) is tolerated for\n * resubscription purposes, but any closures captured by that instance's\n * `get()` will be locked to whichever render first created the subscription\n * until `target.key` itself changes.\n *\n * ```tsx\n * const total = useComputed(cartTotal);\n * ```\n */\nfunction useComputed<R>(target: Computed<R>): R {\n  const alepha = useAlepha();\n  const key = target.key;\n\n  // A ref, not state: the cached snapshot must survive re-renders without\n  // scheduling them. It exists purely to give `useSyncExternalStore` a\n  // stable reference when the resolved dependency values haven't changed —\n  // it is never the source of truth for staleness (see rationale above).\n  const cache = useRef<{\n    target: Computed<R>;\n    inputs: unknown[];\n    value: R;\n  } | null>(null);\n\n  const subscribe = useCallback(\n    (onStoreChange: () => void) => {\n      if (!alepha.isBrowser()) {\n        return () => {};\n      }\n\n      const keys = new Set(target.keys());\n      return alepha.events.on(\"state:mutate\", (ev) => {\n        if (keys.has(ev.key as string)) {\n          onStoreChange();\n        }\n      });\n    },\n    [alepha, key],\n  );\n\n  const getSnapshot = useCallback((): R => {\n    const inputs = target\n      .keys()\n      .map((depKey) => alepha.store.get(depKey as any));\n\n    const prev = cache.current;\n    if (\n      prev &&\n      prev.target === target &&\n      prev.inputs.length === inputs.length &&\n      prev.inputs.every((value, index) => Object.is(value, inputs[index]))\n    ) {\n      return prev.value;\n    }\n\n    const value = alepha.store.get(target);\n    cache.current = { target, inputs, value };\n    return value;\n  }, [alepha, key]);\n\n  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n}\n\nexport { useComputed };\n","import type { Async, Hook, Hooks } from \"alepha\";\nimport { type DependencyList, useEffect } from \"react\";\nimport { useAlepha } from \"./useAlepha.ts\";\n\n/**\n * Allow subscribing to multiple Alepha events. See {@link Hooks} for available events.\n *\n * useEvents is fully typed to ensure correct event callback signatures.\n *\n * @example\n * ```tsx\n * useEvents(\n *   {\n *     \"react:transition:begin\": (ev) => {\n *       console.log(\"Transition began to:\", ev.to);\n *     },\n *     \"react:transition:error\": {\n *       priority: \"first\",\n *       callback: (ev) => {\n *         console.error(\"Transition error:\", ev.error);\n *       },\n *     },\n *   },\n *   [],\n * );\n * ```\n */\nexport const useEvents = (opts: UseEvents, deps: DependencyList) => {\n  const alepha = useAlepha();\n\n  useEffect(() => {\n    if (!alepha.isBrowser()) {\n      return;\n    }\n\n    const subs: Function[] = [];\n    for (const [name, hook] of Object.entries(opts)) {\n      subs.push(alepha.events.on(name as any, hook as any));\n    }\n\n    return () => {\n      for (const clear of subs) {\n        clear();\n      }\n    };\n  }, deps);\n};\n\ntype UseEvents = {\n  [T in keyof Hooks]?: Hook<T> | ((payload: Hooks[T]) => Async<void>);\n};\n","import type { Async } from \"alepha\";\nimport type { DurationLike } from \"alepha/datetime\";\nimport { type DependencyList, useCallback, useRef, useState } from \"react\";\nimport type { ActionContext } from \"./useAction.ts\";\nimport { useAction } from \"./useAction.ts\";\n\n/**\n * Hook for declarative data fetching with automatic execution and refetch.\n *\n * Thin wrapper over {@link useAction}: it pre-applies `runOnInit: true`,\n * exposes the last result as `data`, and provides a stable `refetch()` to\n * re-run the query on demand. For optimistic mutations and side-effects,\n * use {@link useAction} directly — `useQuery` is for the read path.\n *\n * Caching, request deduplication, and AbortSignal cancellation come from\n * `useAction` + `HttpClient`. There is no separate cache layer — pass\n * `localCache` to your `HttpClient.fetch()`/`fetchAction()` call inside\n * the query handler if you want per-call caching.\n *\n * @example Basic\n * ```tsx\n * const client = useInject(HttpClient);\n * const { data, loading, error, refetch } = useQuery({\n *   handler: async ({ signal }) => {\n *     const res = await client.fetch(\"/api/users\", { request: { signal } });\n *     return res.data;\n *   },\n * }, []);\n * ```\n *\n * @example Re-fetch when a dep changes\n * ```tsx\n * const { data } = useQuery({\n *   handler: async () => api.getUser(userId),\n * }, [userId]);\n * ```\n *\n * @example Polling\n * ```tsx\n * const { data } = useQuery({\n *   handler: async () => api.getStatus(),\n *   runEvery: [5, \"seconds\"],\n * }, []);\n * ```\n */\nexport function useQuery<Result>(\n  options: UseQueryOptions<Result>,\n  deps: DependencyList,\n): UseQueryReturn<Result> {\n  const enabled = options.enabled !== false;\n  const [data, setData] = useState<Result | undefined>(options.initialData);\n  // Tracks whether the auto-run has completed at least once, so we can keep\n  // `loading` true on the very first render — before `runOnInit`'s effect\n  // fires — instead of briefly reporting `loading: false` with no data.\n  const settledRef = useRef(false);\n\n  const action = useAction<[], Result>(\n    {\n      id: options.id,\n      handler: options.handler,\n      runOnInit: enabled,\n      runEvery: options.runEvery,\n      debounce: options.debounce,\n      onError: options.onError,\n      onSuccess: async (result) => {\n        settledRef.current = true;\n        setData(result);\n        if (options.onSuccess) {\n          await options.onSuccess(result);\n        }\n      },\n    },\n    deps,\n  );\n\n  const refetch = useCallback(() => action.run(), [action.run]);\n\n  // `loading` is true while a fetch is in flight, AND during the initial gap\n  // between first render and the auto-run effect — so consumers can render a\n  // skeleton immediately instead of flashing an empty/not-found state. Only\n  // applies to enabled queries with no `initialData` seed; an error settles\n  // it (the error path keeps the caller's `onError` re-throw semantics).\n  const loading =\n    action.loading ||\n    (enabled &&\n      options.initialData === undefined &&\n      !settledRef.current &&\n      action.error === undefined);\n\n  return {\n    data,\n    loading,\n    error: action.error,\n    refetch,\n    cancel: action.cancel,\n  };\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport interface UseQueryOptions<Result> {\n  /**\n   * Async query handler. Receives an {@link ActionContext} with an\n   * AbortSignal that fires on unmount, dependency change, or `cancel()`.\n   */\n  handler: (context: ActionContext) => Async<Result>;\n\n  /**\n   * Optional identifier (used in lifecycle events for debugging/analytics).\n   */\n  id?: string;\n\n  /**\n   * If `false`, skip automatic execution on mount and dep change. Use\n   * `refetch()` to trigger manually. Defaults to `true`.\n   */\n  enabled?: boolean;\n\n  /**\n   * Initial value for `data` before the first successful fetch.\n   */\n  initialData?: Result;\n\n  /**\n   * Re-run periodically. See {@link useAction} `runEvery`.\n   */\n  runEvery?: DurationLike;\n\n  /**\n   * Debounce delay in milliseconds. See {@link useAction} `debounce`.\n   */\n  debounce?: number;\n\n  /**\n   * Called on success with the resolved value.\n   */\n  onSuccess?: (result: Result) => void | Promise<void>;\n\n  /**\n   * Custom error handler. If provided, prevents default error re-throw.\n   */\n  onError?: (error: Error) => void | Promise<void>;\n}\n\nexport interface UseQueryReturn<Result> {\n  /**\n   * The last successful result. `undefined` until the first fetch resolves\n   * (or the value of `initialData` if provided).\n   */\n  data: Result | undefined;\n\n  /**\n   * Loading state — `true` while a fetch is in flight, and also from the\n   * first render until the initial auto-run settles (for enabled queries\n   * with no `initialData`), so a skeleton can render without a flash.\n   */\n  loading: boolean;\n\n  /**\n   * Error from the last failed fetch, if any.\n   */\n  error?: Error;\n\n  /**\n   * Re-run the query. The previous in-flight request, if any, is aborted.\n   */\n  refetch: () => Promise<Result | undefined>;\n\n  /**\n   * Abort the in-flight request without scheduling another.\n   */\n  cancel: () => void;\n}\n","import type { Atom, Static, TAtomObject } from \"alepha\";\nimport { useCallback, useRef, useSyncExternalStore } from \"react\";\nimport { useAlepha } from \"./useAlepha.ts\";\n\n/**\n * Subscribes to a slice of an atom's state.\n *\n * Unlike {@link useStore}, which re-renders on every mutation of the atom,\n * `useSelector` re-renders only when the selected slice actually changes\n * according to `equality` (default: `Object.is`). Pass {@link shallowEqual}\n * when the selector builds a fresh object on each call.\n *\n * ```tsx\n * const theme = useSelector(uiAtom, (s) => s.theme);\n * ```\n */\nfunction useSelector<T extends TAtomObject, R>(\n  target: Atom<T>,\n  select: (state: Static<T>) => R,\n  equality: (a: R, b: R) => boolean = Object.is,\n): R {\n  const alepha = useAlepha();\n  const key = target.key;\n\n  // Refs, not state: the memoized snapshot must survive re-renders without\n  // scheduling them, and `getSnapshot` must return a referentially stable\n  // value for unchanged slices or `useSyncExternalStore` re-renders forever.\n  const cache = useRef<{ input: unknown; selected: R } | null>(null);\n  const selectRef = useRef(select);\n  selectRef.current = select;\n  const equalityRef = useRef(equality);\n  equalityRef.current = equality;\n\n  const subscribe = useCallback(\n    (onStoreChange: () => void) => {\n      if (!alepha.isBrowser()) {\n        return () => {};\n      }\n\n      return alepha.events.on(\"state:mutate\", (ev) => {\n        if (ev.key === key) {\n          onStoreChange();\n        }\n      });\n    },\n    [alepha, key],\n  );\n\n  const getSnapshot = useCallback(() => {\n    const input = alepha.store.get(target);\n    const prev = cache.current;\n    if (prev && Object.is(prev.input, input)) {\n      return prev.selected;\n    }\n    const selected = selectRef.current(input);\n    if (prev && equalityRef.current(prev.selected, selected)) {\n      cache.current = { input, selected: prev.selected };\n      return prev.selected;\n    }\n    cache.current = { input, selected };\n    return selected;\n  }, [alepha, key]);\n\n  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n}\n\nexport { useSelector };\n","import type { State, Static, TAtomObject } from \"alepha\";\nimport { Atom } from \"alepha\";\nimport { useCallback, useMemo, useSyncExternalStore } from \"react\";\nimport { useAlepha } from \"./useAlepha.ts\";\n\n/**\n * Hook to access and mutate the Alepha state.\n *\n * Reads through `useSyncExternalStore`, so the store — not a `useState` copy of\n * it — is the single source of truth. That is what keeps the value correct when\n * a mutation lands between render and effect-commit, when the component swaps\n * which `target` it watches, and when React renders concurrently (no tearing).\n */\nfunction useStore<T extends TAtomObject>(\n  target: Atom<T>,\n  defaultValue?: Static<T>,\n): UseStoreReturn<Static<T>>;\nfunction useStore<Key extends keyof State>(\n  target: Key,\n  defaultValue?: State[Key],\n): UseStoreReturn<State[Key]>;\nfunction useStore(target: any, defaultValue?: any): any {\n  const alepha = useAlepha();\n  const key: string = target instanceof Atom ? target.key : target;\n\n  // Seed during render (not in an effect) on purpose: effects don't run during\n  // SSR, and the default has to be in the store before `exportAtoms` serializes\n  // the hydration payload. Idempotent — only fills an empty slot.\n  useMemo(() => {\n    if (defaultValue != null && alepha.store.get(target) == null) {\n      alepha.store.set(target, defaultValue);\n    }\n  }, [defaultValue, key]);\n\n  const subscribe = useCallback(\n    (onStoreChange: () => void) => {\n      if (!alepha.isBrowser()) {\n        return () => {};\n      }\n\n      return alepha.events.on(\"state:mutate\", (ev) => {\n        if (ev.key === key) {\n          onStoreChange();\n        }\n      });\n    },\n    [alepha, key],\n  );\n\n  // Read straight from the store rather than caching the event payload, so the\n  // snapshot stays correct no matter who mutated the key or when.\n  const getSnapshot = useCallback(\n    () => alepha.store.get(target),\n    [alepha, key],\n  );\n\n  const state = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n\n  const setState = useCallback(\n    (value: any) => {\n      alepha.store.set(target, value);\n    },\n    [alepha, key],\n  );\n\n  return [state, setState] as const;\n}\n\nexport type UseStoreReturn<T> = [T, (value: T) => void];\n\nexport { useStore };\n","/**\n * Shallow structural equality over own enumerable keys.\n *\n * Intended as the `equality` argument of `useSelector` when the selector\n * builds a fresh object/array on every call (e.g. `(s) => ({ a: s.a })`).\n */\nexport const shallowEqual = (a: unknown, b: unknown): boolean => {\n  if (Object.is(a, b)) {\n    return true;\n  }\n  if (\n    typeof a !== \"object\" ||\n    a === null ||\n    typeof b !== \"object\" ||\n    b === null\n  ) {\n    return false;\n  }\n  const keysA = Object.keys(a);\n  const keysB = Object.keys(b);\n  if (keysA.length !== keysB.length) {\n    return false;\n  }\n  for (const key of keysA) {\n    if (\n      !Object.hasOwn(b, key) ||\n      !Object.is(\n        (a as Record<string, unknown>)[key],\n        (b as Record<string, unknown>)[key],\n      )\n    ) {\n      return false;\n    }\n  }\n  return true;\n};\n","import { $module } from \"alepha\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport type * from \"./components/ClientOnly.tsx\";\nexport { default as ClientOnly } from \"./components/ClientOnly.tsx\";\nexport type * from \"./components/ErrorBoundary.tsx\";\nexport { default as ErrorBoundary } from \"./components/ErrorBoundary.tsx\";\nexport * from \"./contexts/AlephaContext.ts\";\nexport * from \"./contexts/AlephaProvider.tsx\";\nexport * from \"./hooks/useAction.ts\";\nexport * from \"./hooks/useAlepha.ts\";\nexport * from \"./hooks/useClient.ts\";\nexport * from \"./hooks/useComputed.ts\";\nexport * from \"./hooks/useEvents.ts\";\nexport * from \"./hooks/useInject.ts\";\nexport * from \"./hooks/useQuery.ts\";\nexport * from \"./hooks/useSelector.ts\";\nexport * from \"./hooks/useStore.ts\";\nexport * from \"./utils/shallowEqual.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\ndeclare module \"alepha\" {\n  interface Hooks {\n    /**\n     * Fires when a user action is starting.\n     * Action can be a form submission, a route transition, or a custom action.\n     */\n    \"react:action:begin\": {\n      type: string;\n      id?: string;\n    };\n    /**\n     * Fires when a user action has succeeded.\n     * Action can be a form submission, a route transition, or a custom action.\n     */\n    \"react:action:success\": {\n      type: string;\n      id?: string;\n    };\n    /**\n     * Fires when a user action has failed.\n     * Action can be a form submission, a route transition, or a custom action.\n     */\n    \"react:action:error\": {\n      type: string;\n      id?: string;\n      error: Error;\n    };\n    /**\n     * Fires when a user action has completed, regardless of success or failure.\n     * Action can be a form submission, a route transition, or a custom action.\n     */\n    \"react:action:end\": {\n      type: string;\n      id?: string;\n    };\n  }\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Full-stack React framework with server-side rendering.\n *\n * **Features:**\n * - React page routes with type-safe params\n * - Async action handler with loading/error/cancel states\n * - Type-safe HTTP client access\n * - Dependency injection in components\n * - Global state management\n * - Router navigation methods\n * - Current route state access\n * - Check if path is active\n * - URL query parameters\n * - Access route schema\n * - Subscribe to Alepha events\n * - Type-safe form handling with validation\n * - Error handling wrapper component\n * - Client-side only rendering component\n * - Server-side rendering with hydration\n * - Automatic code splitting\n * - Event system for action tracking\n *\n * @module alepha.react\n */\nexport const AlephaReact = $module({\n  name: \"alepha.react.core\",\n});\n"],"mappings":"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"}

package/dist/react/form/index.d.ts

@@ -1,6 +1,5 @@
 import { Alepha, Static, TArray, TObject, TSchema, TypeBoxError } from "alepha";
 import { InputHTMLAttributes, ReactNode } from "react";
-
 //#region ../../src/react/form/services/FormModel.d.ts
 /**
  * FormModel is a dynamic form handler that generates form inputs based on a provided TypeBox schema.
@@ -19,11 +18,10 @@ declare class FormModel<T extends TObject> {
   protected readonly initialValues: Record<string, any>;
   protected submitInProgress: boolean;
   input: SchemaToInput<T>;
-  get submitting(): boolean;
   constructor(id: string, options: FormCtrlOptions<T>);
   /**
-   * Extract default values from a TypeBox schema.
-   * Recursively handles nested objects.
+   * Extract default values from a zod object schema.
+   * Recursively handles nested objects, unwrapping optional/nullable/default.
    */
   protected extractSchemaDefaults(schema: TObject, prefix?: string): Record<string, any>;
   get currentValues(): Record<string, any>;
@@ -60,7 +58,7 @@ declare class FormModel<T extends TObject> {
    */
   protected getValueFromInput(input: any, schema: TSchema): any;
 }
-type SchemaToInput<T extends TObject> = { [K in keyof T["properties"]]: InputField<T["properties"][K]> };
+type SchemaToInput<T extends TObject> = { [K in keyof T["properties"]]: InputField<T["properties"][K]>; };
 interface FormEventLike {
   preventDefault?: () => void;
   stopPropagation?: () => void;
@@ -179,7 +177,7 @@ interface UseFormQuerySyncOptions<TKey extends string> {
  * navigable via back/forward.
  *
  * @example
- * const form = useForm({ schema: t.object({ status: t.string(), q: t.string() }) });
+ * const form = useForm({ schema: z.object({ status: z.string(), q: z.string() }) });
  * useFormQuerySync(form, { keys: ["status", "q"] });
  */
 declare const useFormQuerySync: <T extends TObject, TKey extends string>(form: FormModel<T>, options: UseFormQuerySyncOptions<TKey>) => void;

package/dist/react/form/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/react/form/services/FormModel.ts","../../../src/react/form/components/FormState.tsx","../../../src/react/form/errors/FormValidationError.ts","../../../src/react/form/hooks/useFieldValue.ts","../../../src/react/form/hooks/useForm.ts","../../../src/react/form/hooks/useFormQuerySync.ts","../../../src/react/form/hooks/useFormState.ts","../../../src/react/form/hooks/useFormValues.ts","../../../src/react/form/services/parseField.ts","../../../src/react/form/services/prettyName.ts","../../../src/react/form/index.ts"],"mappings":";;;;;AAoBA;;;;;;;cAAa,SAAA,WAAoB,OAAA;EAAA,SAcb,EAAA;EAAA,SACA,OAAA,EAAS,eAAA,CAAgB,CAAA;EAAA,mBAdxB,GAAA,0BAAG,MAAA;EAAA,mBACH,MAAA,EAAM,MAAA;EAAA,mBACN,MAAA,EAAQ,MAAA;EAAA,mBACR,aAAA,EAAe,MAAA;EAAA,UACxB,gBAAA;EAEH,KAAA,EAAO,aAAA,CAAc,CAAA;EAAA,IAEjB,UAAA;cAKO,EAAA,UACA,OAAA,EAAS,eAAA,CAAgB,CAAA;EAmFC;;;;EAAA,UAjDlC,qBAAA,CACR,MAAA,EAAQ,OAAA,EACR,MAAA,YACC,MAAA;EAAA,IA8BQ,aAAA,IAAiB,MAAA;EAAA,IAIjB,KAAA;;;oBAIS,aAAA;qBAIC,aAAA;EAAA;EAAA,SAIL,gBAAA,GAAoB,MAAA,EAAQ,MAAA;EAAA,SAmC5B,KAAA,GAAS,KAAA,GAAQ,aAAA;EAAA,SA0BjB,MAAA,QAAM,OAAA;EA4JR;;;;EAAA,UApFJ,iBAAA,CAAkB,KAAA,EAAO,MAAA,gBAAsB,MAAA;EA4FtD;;;;EAAA,UAxEO,sBAAA,CACR,MAAA,EAAQ,MAAA,eACR,GAAA,UACA,KAAA;EAAA,UAoBQ,qBAAA,WAAgC,OAAA,EACxC,OAAA,EAAS,eAAA,CAAgB,CAAA,GACzB,MAAA,EAAQ,OAAA,EACR,OAAA;IACE,MAAA;IACA,KAAA,EAAO,MAAA;EAAA,IAER,aAAA,CAAc,CAAA;EAAA,UAiCP,qBAAA,WAAgC,OAAA,EACxC,IAAA,QAAY,MAAA,CAAO,CAAA,YACnB,OAAA,EAAS,eAAA,CAAgB,CAAA,GACzB,MAAA,EAAQ,OAAA,EACR,QAAA,WACA,OAAA;IACE,MAAA;IACA,KAAA,EAAO,MAAA;EAAA,IAER,cAAA;EAjUsB;;;;EAAA,UAwcf,iBAAA,CAAkB,KAAA,OAAY,MAAA,EAAQ,OAAA;AAAA;AAAA,KAmDtC,aAAA,WAAwB,OAAA,kBACtB,CAAA,iBAAkB,UAAA,CAAW,CAAA,eAAgB,CAAA;AAAA,UAG1C,aAAA;EACf,cAAA;EACA,eAAe;AAAA;AAAA,KAGL,UAAA,WAAqB,OAAA,IAAW,CAAA,SAAU,OAAA,GAClD,gBAAA,CAAiB,CAAA,IACjB,CAAA,SAAU,MAAA,YACR,eAAA,CAAgB,CAAA,IAChB,cAAA;AAAA,UAEW,cAAA;EACf,IAAA;EACA,QAAA;EACA,YAAA;EACA,KAAA,EAAO,uBAAA;EACP,MAAA,EAAQ,OAAA;EACR,GAAA,GAAM,KAAA;EACN,IAAA,EAAM,SAAA;EACN,KAAA;AAAA;AAAA,UAGe,gBAAA,WAA2B,OAAA,UAAiB,cAAA;EAC3D,KAAA,EAAO,aAAA,CAAc,CAAA;AAAA;AAAA,UAGN,eAAA,WAA0B,OAAA,UAAiB,cAAA;EAC1D,KAAA,EAAO,KAAA,CAAM,UAAA,CAAW,CAAA;AAAA;AAAA,KAGd,uBAAA,GAA0B,IAAI,CACxC,mBAAA;EAUA,KAAA;AAAA;AAAA,KAGU,eAAA,WAA0B,OAAA;EAxapB;;;;EA6ahB,MAAA,EAAQ,CAAA;EA3UE;;;;EAiVV,OAAA,GAAU,MAAA,EAAQ,MAAA,CAAO,CAAA;EA5Tf;;;;EAkUV,aAAA,GAAgB,OAAA,CAAQ,MAAA,CAAO,CAAA;EA5SC;;;;EAkThC,aAAA,IACE,IAAA,QAAY,MAAA,CAAO,CAAA,YACnB,MAAA,EAAQ,OAAA,KACL,mBAAA;EAnTK;;;;;;;EA4TV,EAAA;EAEA,OAAA,IAAW,KAAA,EAAO,KAAA;EAElB,QAAA,IAAY,GAAA,UAAa,KAAA,OAAY,KAAA,EAAO,MAAA;EAE5C,OAAA;AAAA;;;cCrmBI,SAAA,aAAuB,OAAA,EAAS,KAAA;EACpC,IAAA,EAAM,SAAA,CAAU,CAAA;EAChB,QAAA,GAAW,KAAA;IAAS,OAAA;IAAkB,KAAA;EAAA,MAAqB,SAAA;AAAA,MAC5D,SAAA;;;cCNY,mBAAA,SAA4B,YAAY;EAAA,SAC1C,IAAA;cAEG,OAAA;IACV,OAAA;IACA,IAAA;EAAA;AAAA;;;;;;AFaJ;;;cGVa,aAAA,GACX,KAAA,EAAO,cAAc,YACb,KAAA;;;cCqCG,OAAA,aAAqB,OAAA,EAChC,OAAA,EAAS,eAAA,CAAgB,CAAA,GACzB,IAAA,aACC,SAAA,CAAU,CAAA;;;UC9CI,uBAAA;;ALcjB;;;EKTE,IAAA,WAAe,IAAI;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;cA4BR,gBAAA,aAA8B,OAAA,uBACzC,IAAA,EAAM,SAAA,CAAU,CAAA,GAChB,OAAA,EAAS,uBAAA,CAAwB,IAAA;;;UCpClB,kBAAA;EACf,OAAA;EACA,KAAA;EACA,MAAA,GAAS,MAAA;EACT,KAAA,GAAQ,KAAK;AAAA;AAAA,cAGF,YAAA,aACD,OAAA,qBACS,kBAAA,EAEnB,MAAA,EAAQ,SAAA,CAAU,CAAA;EAAO,IAAA,EAAM,SAAA,CAAU,CAAA;EAAI,IAAA;AAAA,GAC7C,OAAA,GAAS,IAAA,OACR,IAAA,CAAK,kBAAA,EAAoB,IAAA;;;;;ANE5B;;cOXa,aAAA,aAA2B,OAAA,EACtC,IAAA,EAAM,SAAA,CAAU,CAAA,MACf,MAAA;;;;;APSH;;KQZY,QAAA;AAAA,UAcK,gBAAA;EACf,SAAA;EACA,SAAA;EACA,OAAA;EACA,OAAA;EACA,OAAA;AAAA;AAAA,UAGe,SAAA;EACf,EAAA;EACA,KAAA;EACA,WAAA;EACA,KAAA;EACA,QAAA;EACA,IAAA;EACA,MAAA;EACA,MAAA;EACA,OAAA;EACA,QAAA;EACA,gBAAA;EACA,IAAA;EACA,QAAA,GAAW,QAAA;EACX,WAAA,EAAa,gBAAA;EACb,MAAA;EACA,MAAA,EAAQ,OAAA;ER0PE;;;;;EQpPV,OAAA;AAAA;AAAA,UAGe,iBAAA;EACf,KAAA;EACA,WAAA;EACA,KAAA,GAAQ,KAAK;AAAA;;;;;;;;cAUF,UAAA,GACX,KAAA,EAAO,cAAA,EACP,OAAA,GAAS,iBAAA,KACR,SAAA;;;;;;;ARnDH;;;;;;;cSTa,UAAA,GAAc,IAAY;;;;YCO3B,KAAA;IACR,aAAA;MACE,EAAA;MACA,IAAA;MACA,KAAA;MVauB;;;;MURvB,OAAA;IAAA;IAEF,mBAAA;MAAuB,EAAA;IAAA;IACvB,qBAAA;MAAyB,EAAA;MAAY,MAAA,EAAQ,MAAA;IAAA;IAC7C,mBAAA;MAAuB,EAAA;MAAY,KAAA,EAAO,KAAK;IAAA;IAC/C,iBAAA;MAAqB,EAAA;IAAA;IACrB,YAAA;MAAgB,EAAA;IAAA;EAAA;AAAA;;;;;;;;;;;;;cAkBP,eAAA,mBAAe,OAAA,kBAAA,MAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/react/form/services/FormModel.ts","../../../src/react/form/components/FormState.tsx","../../../src/react/form/errors/FormValidationError.ts","../../../src/react/form/hooks/useFieldValue.ts","../../../src/react/form/hooks/useForm.ts","../../../src/react/form/hooks/useFormQuerySync.ts","../../../src/react/form/hooks/useFormState.ts","../../../src/react/form/hooks/useFormValues.ts","../../../src/react/form/services/parseField.ts","../../../src/react/form/services/prettyName.ts","../../../src/react/form/index.ts"],"mappings":";;;;;;;;;;;cAqBa,UAAU,UAAU;WAUb;WACA,SAAS,gBAAgB;qBAVxB,6BAAG;qBACH,QAAM;qBACN,QAAQ;qBACR,eAAe;YACxB;EAEH,OAAO,cAAc;EAE5B,YACkB,YACA,SAAS,gBAAgB;;;;;YAkCjC,sBACR,QAAQ,SACR,kBACC;MA0CQ,iBAAiB;MAIjB;IAEP;IACA;IACA,WAAQ,KAAQ;IAIhB,UAAO,OAAU;;WAIL,mBAAgB,QAAY;WAmC5B,QAAK,QAAY;WA0BjB,cAAM;;;;;YAiGZ,kBAAkB,OAAO,sBAAsB;;;;;YAoB/C,uBACR,QAAQ,qBACR,aACA;YAoBQ,sBAAsB,UAAU,SACxC,SAAS,gBAAgB,IACzB,QAAQ,SACR;IACE;IACA,OAAO;MAER,cAAc;YAiCP,sBAAsB,UAAU,SACxC,YAAY,OAAO,aACnB,SAAS,gBAAgB,IACzB,QAAQ,SACR,mBACA;IACE;IACA,OAAO;MAER;;;;;YA2IO,kBAAkB,YAAY,QAAQ;;KAmDtC,cAAc,UAAU,cACjC,WAAW,kBAAkB,WAAW,gBAAgB;UAG1C;EACf;EACA;;KAGU,WAAW,UAAU,WAAW,UAAU,UAClD,iBAAiB,KACjB,UAAU,aAAa,KACrB,gBAAgB,KAChB;UAEW;EACf;EACA;EACA;EACA,OAAO;EACP,QAAQ;EACR,MAAM;EACN,MAAM;EACN;;UAGe,iBAAiB,UAAU,iBAAiB;EAC3D,OAAO,cAAc;;UAGN,gBAAgB,UAAU,iBAAiB;EAC1D,OAAO,MAAM,WAAW;;KAGd,0BAA0B,KACpC;EAUA;;KAGU,gBAAgB,UAAU;;;;;EAKpC,QAAQ;;;;;EAMR,UAAU,QAAQ,OAAO;;;;;EAMzB,gBAAgB,QAAQ,OAAO;;;;;EAM/B,iBACE,YAAY,OAAO,aACnB,QAAQ,YACL;;;;;;;;EASL;EAEA,WAAW,OAAO;EAElB,YAAY,aAAa,YAAY,OAAO;EAE5C;;;;cC3oBI,YAAa,UAAU,SAAO;EAClC,MAAM,UAAU;EAChB,WAAW;IAAS;IAAkB;QAAqB;MAC5D;;;cCNY,4BAA4B;WAC9B;EAET,YAAY;IACV;IACA;;;;;;;;;;;cCGS,gBAAa,OACjB,0BACC;;;cCqCG,UAAW,UAAU,SAAO,SAC9B,gBAAgB,IAAE,iBAE1B,UAAU;;;UC9CI,wBAAwB;;;;;EAKvC,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4BJ,mBAAoB,UAAU,SAAS,qBAAmB,MAC/D,UAAU,IAAE,SACT,wBAAwB;;;UCpClB;EACf;EACA;EACA,SAAS;EACT,QAAQ;;cAGG,eACX,UAAU,SACV,mBAAmB,oBAAkB,QAE7B,UAAU;EAAO,MAAM,UAAU;EAAI;GAAc,UAClD,WACR,KAAK,oBAAoB;;;;;;;cCTf,gBAAiB,UAAU,SAAO,MACvC,UAAU,OACf;;;;;;;KCHS;UAcK;EACf;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,WAAW;EACX,aAAa;EACb;EACA,QAAQ;;;;;;EAMR;;UAGe;EACf;EACA;EACA,QAAQ;;;;;;;;;cAUG,aAAU,OACd,gBAAc,UACZ,sBACR;;;;;;;;;;;;;;cC5DU,aAAU;;;;YCOX;IACR;MACE;MACA;MACA;;;;;MAKA;;IAEF;MAAuB;;IACvB;MAAyB;MAAY,QAAQ;;IAC7C;MAAuB;MAAY,OAAO;;IAC1C;MAAqB;;IACrB;MAAgB;;;;;;;;;;;;;;;;cAkBP,kCAAe,yBAAA"}