@alepha/react 0.11.3 → 0.11.4

package/dist/{index.d.ts → index.d.mts}

@@ -1,14 +1,14 @@
-import * as _alepha_core1 from "@alepha/core";
-import { Alepha, Async, Configurable, Descriptor, Hooks, KIND, Service, State, Static, TObject, TSchema } from "@alepha/core";
+import * as _alepha_core10 from "@alepha/core";
+import { Alepha, Async, Configurable, Descriptor, Hook, Hooks, KIND, Service, State, Static, TObject, TSchema } from "@alepha/core";
+import { DateTimeProvider, DurationLike } from "@alepha/datetime";
 import { RequestConfigSchema, ServerHandler, ServerProvider, ServerRequest, ServerRouterProvider, ServerTimingProvider } from "@alepha/server";
 import { ServerRouteCache } from "@alepha/server-cache";
 import { ClientScope, HttpVirtualClient, LinkProvider, VirtualAction } from "@alepha/server-links";
 import * as _alepha_logger0 from "@alepha/logger";
 import * as react0 from "react";
-import React, { AnchorHTMLAttributes, CSSProperties, ErrorInfo, FC, PropsWithChildren, ReactNode } from "react";
+import React, { AnchorHTMLAttributes, CSSProperties, DependencyList, ErrorInfo, FC, PropsWithChildren, ReactNode } from "react";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
 import { ServeDescriptorOptions, ServerStaticProvider } from "@alepha/server-static";
-import { DateTimeProvider } from "@alepha/datetime";
 import { Route, RouterProvider } from "@alepha/router";
 
 //#region src/components/ClientOnly.d.ts
@@ -40,8 +40,8 @@ declare class Redirection extends Error {
 }
 //#endregion
 //#region src/providers/ReactPageProvider.d.ts
-declare const envSchema$2: _alepha_core1.TObject<{
-  REACT_STRICT_MODE: _alepha_core1.TBoolean;
+declare const envSchema$2: _alepha_core10.TObject<{
+  REACT_STRICT_MODE: _alepha_core10.TBoolean;
 }>;
 declare module "@alepha/core" {
   interface Env extends Partial<Static<typeof envSchema$2>> {}
@@ -54,6 +54,7 @@ declare class ReactPageProvider {
   protected readonly alepha: Alepha;
   protected readonly pages: PageRoute[];
   getPages(): PageRoute[];
+  getConcretePages(): PageRoute[];
   page(name: string): PageRoute;
   pathname(name: string, options?: {
     params?: Record<string, string>;
@@ -83,7 +84,7 @@ declare class ReactPageProvider {
   }, params?: Record<string, any>): string;
   compile(path: string, params?: Record<string, string>): string;
   protected renderView(index: number, path: string, view: ReactNode | undefined, page: PageRoute): ReactNode;
-  protected readonly configure: _alepha_core1.HookDescriptor<"configure">;
+  protected readonly configure: _alepha_core10.HookDescriptor<"configure">;
   protected map(pages: Array<PageDescriptor>, target: PageDescriptor): PageRouteEntry;
   add(entry: PageRouteEntry): void;
   protected createMatch(page: PageRoute): string;
@@ -162,6 +163,15 @@ interface CreateLayersResult {
   state?: ReactRouterState;
 }
 //#endregion
+//#region src/services/ReactPageService.d.ts
+declare class ReactPageService {
+  fetch(pathname: string, options?: PageDescriptorRenderOptions): Promise<{
+    html: string;
+    response: Response;
+  }>;
+  render(name: string, options?: PageDescriptorRenderOptions): Promise<PageDescriptorRenderResult>;
+}
+//#endregion
 //#region src/descriptors/$page.d.ts
 /**
  * Main descriptor for defining a React route in the application.
@@ -257,15 +267,11 @@ declare const $page: {
 };
 interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
   /**
-   * Name your page.
+   * Identifier name for the page. Must be unique.
    *
    * @default Descriptor key
    */
   name?: string;
-  /**
-   * Optional description of the page.
-   */
-  description?: string;
   /**
    * Add a pathname to the page.
    *
@@ -312,14 +318,14 @@ interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSch
     default: FC<TProps & TPropsParent>;
   }>;
   /**
-   * Set some children pages and make the page a parent page.
-   *
-   * /!\ Parent page can't be rendered directly. /!\
-   *
-   * If you still want to render at this pathname, add a child page with an empty path.
+   * Attach child pages to create nested routes.
+   * This will make the page a parent route.
    */
   children?: Array<PageDescriptor> | (() => Array<PageDescriptor>);
-  parent?: PageDescriptor<PageConfigSchema, TPropsParent>;
+  /**
+   * Define a parent page for nested routing.
+   */
+  parent?: PageDescriptor<PageConfigSchema, TPropsParent, any>;
   can?: () => boolean;
   /**
    * Catch any error from the `resolve` function or during `rendering`.
@@ -363,23 +369,23 @@ interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSch
    * If true, the page will be considered as a static page, immutable and cacheable.
    * Replace boolean by an object to define static entries. (e.g. list of params/query)
    *
-   * For now, it only works with `@alepha/vite` which can pre-render the page at build time.
+   * Browser-side: it only works with `@alepha/vite`, which can pre-render the page at build time.
    *
-   * It will act as timeless cached page server-side. You can use `cache` to configure the cache behavior.
+   * Server-side: It will act as timeless cached page. You can use `cache` to configure the cache behavior.
    */
   static?: boolean | {
     entries?: Array<Partial<PageRequestConfig<TConfig>>>;
   };
   cache?: ServerRouteCache;
   /**
-   * If true, force the page to be rendered only on the client-side.
+   * If true, force the page to be rendered only on the client-side (browser).
    * It uses the `<ClientOnly/>` component to render the page.
    */
   client?: boolean | ClientOnlyProps;
   /**
-   * Called before the server response is sent to the client.
+   * Called before the server response is sent to the client. (server only)
    */
-  onServerResponse?: (request: ServerRequest) => any;
+  onServerResponse?: (request: ServerRequest) => unknown;
   /**
    * Called when user leaves the page. (browser only)
    */
@@ -430,10 +436,13 @@ interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSch
 }
 type ErrorHandler = (error: Error, state: ReactRouterState) => ReactNode | Redirection | undefined;
 declare class PageDescriptor<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> extends Descriptor<PageDescriptorOptions<TConfig, TProps, TPropsParent>> {
+  protected readonly reactPageService: ReactPageService;
   protected onInit(): void;
   get name(): string;
   /**
-   * For testing or build purposes, this will render the page (with or without the HTML layout) and return the HTML and context.
+   * For testing or build purposes.
+   *
+   * This will render the page (HTML layout included or not) and return the HTML + context.
    * Only valid for server-side rendering, it will throw an error if called on the client-side.
    */
   render(options?: PageDescriptorRenderOptions): Promise<PageDescriptorRenderResult>;
@@ -493,14 +502,14 @@ declare class ReactBrowserRouterProvider extends RouterProvider<BrowserRoute> {
   protected readonly alepha: Alepha;
   protected readonly pageApi: ReactPageProvider;
   add(entry: PageRouteEntry): void;
-  protected readonly configure: _alepha_core1.HookDescriptor<"configure">;
+  protected readonly configure: _alepha_core10.HookDescriptor<"configure">;
   transition(url: URL, previous?: PreviousLayerData[], meta?: {}): Promise<string | void>;
   root(state: ReactRouterState): ReactNode;
 }
 //#endregion
 //#region src/providers/ReactBrowserProvider.d.ts
-declare const envSchema$1: _alepha_core1.TObject<{
-  REACT_ROOT_ID: _alepha_core1.TString;
+declare const envSchema$1: _alepha_core10.TObject<{
+  REACT_ROOT_ID: _alepha_core10.TString;
 }>;
 declare module "@alepha/core" {
   interface Env extends Partial<Static<typeof envSchema$1>> {}
@@ -546,8 +555,8 @@ declare class ReactBrowserProvider {
    * Get embedded layers from the server.
    */
   protected getHydrationState(): ReactHydrationState | undefined;
-  protected readonly onTransitionEnd: _alepha_core1.HookDescriptor<"react:transition:end">;
-  readonly ready: _alepha_core1.HookDescriptor<"ready">;
+  protected readonly onTransitionEnd: _alepha_core10.HookDescriptor<"react:transition:end">;
+  readonly ready: _alepha_core10.HookDescriptor<"ready">;
 }
 interface RouterGoOptions {
   replace?: boolean;
@@ -649,6 +658,236 @@ interface RouterLayerContextValue {
 }
 declare const RouterLayerContext: react0.Context<RouterLayerContextValue | undefined>;
 //#endregion
+//#region src/hooks/useAction.d.ts
+/**
+ * Hook for handling async actions with automatic error handling and event emission.
+ *
+ * By default, prevents concurrent executions - if an action is running and you call it again,
+ * the second call will be ignored. Use `debounce` option to delay execution instead.
+ *
+ * Emits lifecycle events:
+ * - `react:action:begin` - When action starts
+ * - `react:action:success` - When action completes successfully
+ * - `react:action:error` - When action throws an error
+ * - `react:action:end` - Always emitted at the end
+ *
+ * @example Basic usage
+ * ```tsx
+ * const action = useAction({
+ *   handler: async (data) => {
+ *     await api.save(data);
+ *   }
+ * }, []);
+ *
+ * <button onClick={() => action.run(data)} disabled={action.loading}>
+ *   Save
+ * </button>
+ * ```
+ *
+ * @example With debounce (search input)
+ * ```tsx
+ * const search = useAction({
+ *   handler: async (query: string) => {
+ *     await api.search(query);
+ *   },
+ *   debounce: 300 // Wait 300ms after last call
+ * }, []);
+ *
+ * <input onChange={(e) => search.run(e.target.value)} />
+ * ```
+ *
+ * @example Run on component mount
+ * ```tsx
+ * const fetchData = useAction({
+ *   handler: async () => {
+ *     const data = await api.getData();
+ *     return data;
+ *   },
+ *   runOnInit: true // Runs once when component mounts
+ * }, []);
+ * ```
+ *
+ * @example Run periodically (polling)
+ * ```tsx
+ * const pollStatus = useAction({
+ *   handler: async () => {
+ *     const status = await api.getStatus();
+ *     return status;
+ *   },
+ *   runEvery: 5000 // Run every 5 seconds
+ * }, []);
+ *
+ * // Or with duration tuple
+ * const pollStatus = useAction({
+ *   handler: async () => {
+ *     const status = await api.getStatus();
+ *     return status;
+ *   },
+ *   runEvery: [30, 'seconds'] // Run every 30 seconds
+ * }, []);
+ * ```
+ *
+ * @example With AbortController
+ * ```tsx
+ * const fetch = useAction({
+ *   handler: async (url, { signal }) => {
+ *     const response = await fetch(url, { signal });
+ *     return response.json();
+ *   }
+ * }, []);
+ * // Automatically cancelled on unmount or when new request starts
+ * ```
+ *
+ * @example With error handling
+ * ```tsx
+ * const deleteAction = useAction({
+ *   handler: async (id: string) => {
+ *     await api.delete(id);
+ *   },
+ *   onError: (error) => {
+ *     if (error.code === 'NOT_FOUND') {
+ *       // Custom error handling
+ *     }
+ *   }
+ * }, []);
+ *
+ * {deleteAction.error && <div>Error: {deleteAction.error.message}</div>}
+ * ```
+ *
+ * @example Global error handling
+ * ```tsx
+ * // In your root app setup
+ * alepha.events.on("react:action:error", ({ error }) => {
+ *   toast.danger(error.message);
+ *   Sentry.captureException(error);
+ * });
+ * ```
+ */
+declare function useAction<Args extends any[], Result = void>(options: UseActionOptions<Args, Result>, deps: DependencyList): UseActionReturn<Args, Result>;
+/**
+ * Context object passed as the last argument to action handlers.
+ * Contains an AbortSignal that can be used to cancel the request.
+ */
+interface ActionContext {
+  /**
+   * AbortSignal that can be passed to fetch or other async operations.
+   * The signal will be aborted when:
+   * - The component unmounts
+   * - A new action is triggered (cancels previous)
+   * - The cancel() method is called
+   *
+   * @example
+   * ```tsx
+   * const action = useAction({
+   *   handler: async (url, { signal }) => {
+   *     const response = await fetch(url, { signal });
+   *     return response.json();
+   *   }
+   * }, []);
+   * ```
+   */
+  signal: AbortSignal;
+}
+interface UseActionOptions<Args extends any[] = any[], Result = any> {
+  /**
+   * The async action handler function.
+   * Receives the action arguments plus an ActionContext as the last parameter.
+   */
+  handler: (...args: [...Args, ActionContext]) => Promise<Result>;
+  /**
+   * Custom error handler. If provided, prevents default error re-throw.
+   */
+  onError?: (error: Error) => void | Promise<void>;
+  /**
+   * Custom success handler.
+   */
+  onSuccess?: (result: Result) => void | Promise<void>;
+  /**
+   * Optional identifier for this action (useful for debugging/analytics)
+   */
+  id?: string;
+  /**
+   * Debounce delay in milliseconds. If specified, the action will only execute
+   * after the specified delay has passed since the last call. Useful for search inputs
+   * or other high-frequency events.
+   *
+   * @example
+   * ```tsx
+   * // Execute search 300ms after user stops typing
+   * const search = useAction({ handler: search, debounce: 300 }, [])
+   * ```
+   */
+  debounce?: number;
+  /**
+   * If true, the action will be executed once when the component mounts.
+   *
+   * @example
+   * ```tsx
+   * const fetchData = useAction({
+   *   handler: async () => await api.getData(),
+   *   runOnInit: true
+   * }, []);
+   * ```
+   */
+  runOnInit?: boolean;
+  /**
+   * If specified, the action will be executed periodically at the given interval.
+   * The interval is specified as a DurationLike value (number in ms, Duration object, or [number, unit] tuple).
+   *
+   * @example
+   * ```tsx
+   * // Run every 5 seconds
+   * const poll = useAction({
+   *   handler: async () => await api.poll(),
+   *   runEvery: 5000
+   * }, []);
+   * ```
+   *
+   * @example
+   * ```tsx
+   * // Run every 1 minute
+   * const poll = useAction({
+   *   handler: async () => await api.poll(),
+   *   runEvery: [1, 'minute']
+   * }, []);
+   * ```
+   */
+  runEvery?: DurationLike;
+}
+interface UseActionReturn<Args extends any[], Result> {
+  /**
+   * Execute the action with the provided arguments.
+   *
+   * @example
+   * ```tsx
+   * const action = useAction({ handler: async (data) => { ... } }, []);
+   * action.run(data);
+   * ```
+   */
+  run: (...args: Args) => Promise<Result | undefined>;
+  /**
+   * Loading state - true when action is executing.
+   */
+  loading: boolean;
+  /**
+   * Error state - contains error if action failed, undefined otherwise.
+   */
+  error?: Error;
+  /**
+   * Cancel any pending debounced action or abort the current in-flight request.
+   *
+   * @example
+   * ```tsx
+   * const action = useAction({ ... }, []);
+   *
+   * <button onClick={action.cancel} disabled={!action.loading}>
+   *   Cancel
+   * </button>
+   * ```
+   */
+  cancel: () => void;
+}
+//#endregion
 //#region src/hooks/useActive.d.ts
 interface UseActiveOptions {
   href: string;
@@ -682,20 +921,47 @@ declare const useAlepha: () => Alepha;
  *
  * It's the React-hook version of `$client()`, from `AlephaServerLinks` module.
  */
-declare const useClient: <T extends object>(scope?: ClientScope) => HttpVirtualClient<T>;
+declare const useClient: <T$1 extends object>(scope?: ClientScope) => HttpVirtualClient<T$1>;
+//#endregion
+//#region src/hooks/useEvents.d.ts
+/**
+ * Allow subscribing to multiple Alepha events. See {@link Hooks} for available events.
+ *
+ * useEvents is fully typed to ensure correct event callback signatures.
+ *
+ * @example
+ * ```tsx
+ * useEvents(
+ *   {
+ *     "react:transition:begin": (ev) => {
+ *       console.log("Transition began to:", ev.to);
+ *     },
+ *     "react:transition:error": {
+ *       priority: "first",
+ *       callback: (ev) => {
+ *         console.error("Transition error:", ev.error);
+ *       },
+ *     },
+ *   },
+ *   [],
+ * );
+ * ```
+ */
+declare const useEvents: (opts: UseEvents, deps: DependencyList) => void;
+type UseEvents = { [T in keyof Hooks]?: Hook<T> | ((payload: Hooks[T]) => Async<void>) };
 //#endregion
 //#region src/hooks/useInject.d.ts
 /**
  * Hook to inject a service instance.
  * It's a wrapper of `useAlepha().inject(service)` with a memoization.
  */
-declare const useInject: <T extends object>(service: Service<T>) => T;
+declare const useInject: <T$1 extends object>(service: Service<T$1>) => T$1;
 //#endregion
 //#region src/hooks/useQueryParams.d.ts
 /**
  * Not well tested. Use with caution.
  */
-declare const useQueryParams: <T extends TObject>(schema: T, options?: UseQueryParamsHookOptions) => [Partial<Static<T>>, (data: Static<T>) => void];
+declare const useQueryParams: <T$1 extends TObject>(schema: T$1, options?: UseQueryParamsHookOptions) => [Partial<Static<T$1>>, (data: Static<T$1>) => void];
 interface UseQueryParamsHookOptions {
   format?: "base64" | "querystring";
   key?: string;
@@ -703,13 +969,17 @@ interface UseQueryParamsHookOptions {
 }
 //#endregion
 //#region src/services/ReactRouter.d.ts
-declare class ReactRouter<T extends object> {
+declare class ReactRouter<T$1 extends object> {
   protected readonly alepha: Alepha;
   protected readonly pageApi: ReactPageProvider;
   get state(): ReactRouterState;
   get pages(): PageRoute[];
+  get concretePages(): PageRoute[];
   get browser(): ReactBrowserProvider | undefined;
-  path(name: keyof VirtualRouter<T>, config?: {
+  isActive(href: string, options?: {
+    startWith?: boolean;
+  }): boolean;
+  path(name: keyof VirtualRouter<T$1>, config?: {
     params?: Record<string, any>;
     query?: Record<string, any>;
   }): string;
@@ -727,9 +997,9 @@ declare class ReactRouter<T extends object> {
   forward(): Promise<void>;
   invalidate(props?: Record<string, any>): Promise<void>;
   go(path: string, options?: RouterGoOptions): Promise<void>;
-  go(path: keyof VirtualRouter<T>, options?: RouterGoOptions): Promise<void>;
+  go(path: keyof VirtualRouter<T$1>, options?: RouterGoOptions): Promise<void>;
   anchor(path: string, options?: RouterGoOptions): AnchorProps;
-  anchor(path: keyof VirtualRouter<T>, options?: RouterGoOptions): AnchorProps;
+  anchor(path: keyof VirtualRouter<T$1>, options?: RouterGoOptions): AnchorProps;
   base(path: string): string;
   /**
    * Set query params.
@@ -744,7 +1014,7 @@ declare class ReactRouter<T extends object> {
     push?: boolean;
   }): void;
 }
-type VirtualRouter<T> = { [K in keyof T as T[K] extends PageDescriptor ? K : never]: T[K] };
+type VirtualRouter<T$1> = { [K in keyof T$1 as T$1[K] extends PageDescriptor ? K : never]: T$1[K] };
 //#endregion
 //#region src/hooks/useRouter.d.ts
 /**
@@ -761,22 +1031,7 @@ type VirtualRouter<T> = { [K in keyof T as T[K] extends PageDescriptor ? K : nev
  * const router = useRouter<App>();
  * router.go("home"); // typesafe
  */
-declare const useRouter: <T extends object = any>() => ReactRouter<T>;
-//#endregion
-//#region src/hooks/useRouterEvents.d.ts
-type Hook<T extends keyof Hooks> = ((ev: Hooks[T]) => void) | {
-  priority?: "first" | "last";
-  callback: (ev: Hooks[T]) => void;
-};
-/**
- * Subscribe to various router events.
- */
-declare const useRouterEvents: (opts?: {
-  onBegin?: Hook<"react:transition:begin">;
-  onError?: Hook<"react:transition:error">;
-  onEnd?: Hook<"react:transition:end">;
-  onSuccess?: Hook<"react:transition:success">;
-}, deps?: any[]) => void;
+declare const useRouter: <T$1 extends object = any>() => ReactRouter<T$1>;
 //#endregion
 //#region src/hooks/useRouterState.d.ts
 declare const useRouterState: () => ReactRouterState;
@@ -800,12 +1055,12 @@ declare const ssrSchemaLoading: (alepha: Alepha, name: string) => RequestConfigS
 declare const useStore: <Key extends keyof State>(key: Key, defaultValue?: State[Key]) => [State[Key], (value: State[Key]) => void];
 //#endregion
 //#region src/providers/ReactServerProvider.d.ts
-declare const envSchema: _alepha_core1.TObject<{
-  REACT_SERVER_DIST: _alepha_core1.TString;
-  REACT_SERVER_PREFIX: _alepha_core1.TString;
-  REACT_SSR_ENABLED: _alepha_core1.TOptional<_alepha_core1.TBoolean>;
-  REACT_ROOT_ID: _alepha_core1.TString;
-  REACT_SERVER_TEMPLATE: _alepha_core1.TOptional<_alepha_core1.TString>;
+declare const envSchema: _alepha_core10.TObject<{
+  REACT_SERVER_DIST: _alepha_core10.TString;
+  REACT_SERVER_PREFIX: _alepha_core10.TString;
+  REACT_SSR_ENABLED: _alepha_core10.TOptional<_alepha_core10.TBoolean>;
+  REACT_ROOT_ID: _alepha_core10.TString;
+  REACT_SERVER_TEMPLATE: _alepha_core10.TOptional<_alepha_core10.TString>;
 }>;
 declare module "@alepha/core" {
   interface Env extends Partial<Static<typeof envSchema>> {}
@@ -835,13 +1090,13 @@ declare class ReactServerProvider implements Configurable {
   protected readonly serverStaticProvider: ServerStaticProvider;
   protected readonly serverRouterProvider: ServerRouterProvider;
   protected readonly serverTimingProvider: ServerTimingProvider;
-  protected readonly ROOT_DIV_REGEX: RegExp;
+  readonly ROOT_DIV_REGEX: RegExp;
   protected preprocessedTemplate: PreprocessedTemplate | null;
   options: ReactServerProviderOptions;
   /**
    * Configure the React server provider.
    */
-  readonly onConfigure: _alepha_core1.HookDescriptor<"configure">;
+  readonly onConfigure: _alepha_core10.HookDescriptor<"configure">;
   get template(): string;
   protected registerPages(templateLoader: TemplateLoader): Promise<void>;
   /**
@@ -859,7 +1114,7 @@ declare class ReactServerProvider implements Configurable {
   /**
    * For testing purposes, creates a render function that can be used.
    */
-  protected createRenderFunction(name: string, withIndex?: boolean): (options?: PageDescriptorRenderOptions) => Promise<PageDescriptorRenderResult>;
+  render(name: string, options?: PageDescriptorRenderOptions): Promise<PageDescriptorRenderResult>;
   protected createHandler(route: PageRoute, templateLoader: TemplateLoader): ServerHandler;
   renderToHtml(template: string, state: ReactRouterState, hydration?: boolean): string | Redirection;
   protected preprocessTemplate(template: string): PreprocessedTemplate;
@@ -881,33 +1136,87 @@ declare module "@alepha/core" {
     "react.router.state"?: ReactRouterState;
   }
   interface Hooks {
+    /**
+     * Fires when the React application is starting to be rendered on the server.
+     */
     "react:server:render:begin": {
       request?: ServerRequest;
       state: ReactRouterState;
     };
+    /**
+     * Fires when the React application has been rendered on the server.
+     */
     "react:server:render:end": {
       request?: ServerRequest;
       state: ReactRouterState;
       html: string;
     };
+    /**
+     * Fires when the React application is being rendered on the browser.
+     */
     "react:browser:render": {
       root: HTMLElement;
       element: ReactNode;
       state: ReactRouterState;
       hydration?: ReactHydrationState;
     };
+    /**
+     * Fires when a user action is starting.
+     * Action can be a form submission, a route transition, or a custom action.
+     */
+    "react:action:begin": {
+      type: string;
+      id?: string;
+    };
+    /**
+     * Fires when a user action has succeeded.
+     * Action can be a form submission, a route transition, or a custom action.
+     */
+    "react:action:success": {
+      type: string;
+      id?: string;
+    };
+    /**
+     * Fires when a user action has failed.
+     * Action can be a form submission, a route transition, or a custom action.
+     */
+    "react:action:error": {
+      type: string;
+      id?: string;
+      error: Error;
+    };
+    /**
+     * Fires when a user action has completed, regardless of success or failure.
+     * Action can be a form submission, a route transition, or a custom action.
+     */
+    "react:action:end": {
+      type: string;
+      id?: string;
+    };
+    /**
+     * Fires when a route transition is starting.
+     */
     "react:transition:begin": {
       previous: ReactRouterState;
       state: ReactRouterState;
       animation?: PageAnimation;
     };
+    /**
+     * Fires when a route transition has succeeded.
+     */
     "react:transition:success": {
       state: ReactRouterState;
     };
+    /**
+     * Fires when a route transition has failed.
+     */
     "react:transition:error": {
       state: ReactRouterState;
       error: Error;
     };
+    /**
+     * Fires when a route transition has completed, regardless of success or failure.
+     */
     "react:transition:end": {
       state: ReactRouterState;
     };
@@ -923,7 +1232,7 @@ declare module "@alepha/core" {
  * @see {@link $page}
  * @module alepha.react
  */
-declare const AlephaReact: _alepha_core1.Service<_alepha_core1.Module<{}>>;
+declare const AlephaReact: _alepha_core10.Service<_alepha_core10.Module<{}>>;
 //#endregion
-export { $page, AlephaContext, AlephaReact, AnchorProps, ClientOnly, CreateLayersResult, ErrorBoundary, ErrorHandler, ErrorViewer, Layer, Link, LinkProps, _default as NestedView, NotFoundPage as NotFound, PageAnimation, PageConfigSchema, PageDescriptor, PageDescriptorOptions, PageDescriptorRenderOptions, PageDescriptorRenderResult, PageRequestConfig, PageResolve, PageRoute, PageRouteEntry, PreviousLayerData, ReactBrowserProvider, ReactBrowserRendererOptions, ReactHydrationState, ReactPageProvider, ReactRouter, ReactRouterState, ReactServerProvider, ReactServerProviderOptions, Redirection, RouterGoOptions, RouterLayerContext, RouterLayerContextValue, RouterRenderOptions, RouterStackItem, TPropsDefault, TPropsParentDefault, TransitionOptions, UseActiveHook, UseActiveOptions, UseQueryParamsHookOptions, UseSchemaReturn, VirtualRouter, isPageRoute, ssrSchemaLoading, useActive, useAlepha, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState, useSchema, useStore };
-//# sourceMappingURL=index.d.ts.map
+export { $page, ActionContext, AlephaContext, AlephaReact, AnchorProps, ClientOnly, CreateLayersResult, ErrorBoundary, ErrorHandler, ErrorViewer, Layer, Link, type LinkProps, _default as NestedView, NotFoundPage as NotFound, PageAnimation, PageConfigSchema, PageDescriptor, PageDescriptorOptions, PageDescriptorRenderOptions, PageDescriptorRenderResult, PageRequestConfig, PageResolve, PageRoute, PageRouteEntry, PreviousLayerData, ReactBrowserProvider, ReactBrowserRendererOptions, ReactHydrationState, ReactPageProvider, ReactRouter, ReactRouterState, ReactServerProvider, ReactServerProviderOptions, Redirection, RouterGoOptions, RouterLayerContext, RouterLayerContextValue, RouterRenderOptions, RouterStackItem, TPropsDefault, TPropsParentDefault, TransitionOptions, UseActionOptions, UseActionReturn, UseActiveHook, UseActiveOptions, UseQueryParamsHookOptions, UseSchemaReturn, VirtualRouter, isPageRoute, ssrSchemaLoading, useAction, useActive, useAlepha, useClient, useEvents, useInject, useQueryParams, useRouter, useRouterState, useSchema, useStore };
+//# sourceMappingURL=index.d.mts.map