@molecule/app-react-native 1.0.2 → 1.0.4

package/README.md

@@ -3,15 +3,11 @@ AUTO-GENERATED — DO NOT EDIT THIS FILE.
 Generated by `mlcl sync-docs` from the package's src/index.ts JSDoc + mlcl/registry.json.
 Edits here are overwritten on the next commit (molecule's pre-commit hook regenerates).
 To change this document, edit the module-level JSDoc in src/index.ts.
-Generated: 2026-09-15T13:40:29.572Z
+Generated: 2026-10-23T14:59:33.332Z
 -->
 
 # @molecule/app-react-native
 
-> **Auto-generated, AI-first package reference** for the [molecule.dev](https://molecule.dev) ecosystem.
-> It is written to be read by coding agents as much as by people, and is generated from this
-> package's source — edit `src/index.ts` JSDoc, not this file.
-
 React Native framework bindings for molecule.dev.
 
 Re-exports every hook and provider from `@molecule/app-react` (they are pure
@@ -19,6 +15,10 @@ React — no DOM dependency) and adds RN-specific hooks: `useAppState`
 (foreground/background), `useBackHandler` (Android back button),
 `useKeyboardHeight`, and `useSafeArea`.
 
+> **Auto-generated, AI-first package reference** for the [molecule.dev](https://molecule.dev) ecosystem.
+> It is written to be read by coding agents as much as by people, and is generated from this
+> package's source — edit `src/index.ts` JSDoc, not this file.
+
 ## Quick Start
 
 ```tsx
@@ -64,140 +64,17 @@ npm install @molecule/app-react-native @molecule/app-keyboard @molecule/app-life
 
 ### Interfaces
 
-#### `AgentIdentity`
-
-Display identity for the AI coding agent and the host product, used to
-interpolate the `{{agentName}}` / `{{productName}}` tokens in shared chat/IDE
-copy. A consuming app sets these to its own agent + product brand names; the
-shared packages fall back to {@link DEFAULT_AGENT_IDENTITY} when it does not.
-
-```typescript
-interface AgentIdentity {
-  /** Display name of the AI coding agent. Defaults to {@link DEFAULT_AGENT_NAME}. */
-  agentName: string
-  /** Display name of the host product / IDE. Defaults to {@link DEFAULT_PRODUCT_NAME}. */
-  productName: string
-}
-```
-
-#### `AuthClient`
-
-Auth client interface that all auth bond packages must implement.
-Provides login/logout/register flows, token management, profile
-updates, and auth state subscription.
-
-```typescript
-interface AuthClient<T = UserProfile> {
-  /**
-   * Returns the current authentication state snapshot.
-   */
-  getState(): AuthState<T>
-  /**
-   * Returns whether the user is currently authenticated.
-   */
-  isAuthenticated(): boolean
-  /**
-   * Gets the current user.
-   */
-  getUser(): T | null
-  /**
-   * Updates the cached user object (state + persistent storage) without
-   * hitting the network. Intended for local refreshes after a per-app
-   * mutation (e.g., the user just PATCHed their own profile and the
-   * server returned the canonical row). Does NOT change tokens.
-   */
-  setUser(user: T | null): void
-  /**
-   * Gets the current access token.
-   */
-  getAccessToken(): string | null
-  /**
-   * Stores the access token in the configured token storage adapter (in-memory
-   * by default). Use this to seed the token after an out-of-band exchange (e.g.
-   * the OAuth code→token redirect) instead of writing to `localStorage` directly,
-   * which would violate the in-memory-default storage contract and make the bearer
-   * token JS-readable (XSS-exfiltratable). Pass `null` to clear it.
-   */
-  setAccessToken(token: string | null): void
-  /**
-   * Gets the refresh token.
-   */
-  getRefreshToken(): string | null
-  /**
-   * Logs in with credentials.
-   */
-  login(credentials: LoginCredentials): Promise<AuthResult<T>>
-  /**
-   * Logs out the current user.
-   */
-  logout(): Promise<void>
-  /**
-   * Registers a new user.
-   */
-  register(data: RegisterData): Promise<AuthResult<T>>
-  /**
-   * Refreshes the access token.
-   */
-  refresh(): Promise<AuthResult<T>>
-  /**
-   * Requests a password reset.
-   */
-  requestPasswordReset(data: PasswordResetRequest): Promise<void>
-  /**
-   * Confirms a password reset.
-   */
-  confirmPasswordReset(data: PasswordResetConfirm): Promise<void>
-  /**
-   * Updates the current user's profile.
-   */
-  updateProfile(data: Partial<T>): Promise<T>
-  /**
-   * Changes the current user's password.
-   */
-  changePassword(oldPassword: string, newPassword: string): Promise<void>
-  /**
-   * Initializes auth state (e.g., from stored tokens).
-   */
-  initialize(): Promise<void>
-  /**
-   * Subscribes to auth state changes.
-   */
-  subscribe(callback: (state: AuthState<T>) => void): () => void
-  /**
-   * Subscribes to auth state changes (alias for subscribe).
-   */
-  onAuthChange(callback: (state: AuthState<T>) => void): () => void
-  /**
-   * Gets the current access token (alias for getAccessToken).
-   */
-  getToken?(): string | null
-  /**
-   * Adds an auth event listener.
-   */
-  addEventListener(listener: AuthEventListener): () => void
-  /**
-   * Destroys the auth client.
-   */
-  destroy(): void
-}
-```
-
-#### `AuthProviderProps`
-
-Props for auth provider component.
-
-```typescript
-interface AuthProviderProps<T = unknown> extends ProviderProps {
-  client: AuthClient<T>
-}
-```
-
 #### `AuthState`
 
 Reactive authentication state snapshot (initialized, authenticated, user, loading, and error).
 
 ```typescript
 interface AuthState<T = UserProfile> {
+  /**
+   * The session's state as one value — render from this instead of combining
+   * `initialized`/`authenticated`/`loading`. See {@link AuthStatus}.
+   */
+  status: AuthStatus
   /**
    * Whether auth state has been initialized.
    */
@@ -221,24 +98,178 @@ interface AuthState<T = UserProfile> {
 }
 ```
 
-#### `ChatProviderProps`
-
-Props for the ChatProvider React component.
-
-```typescript
-interface ChatProviderProps extends ProviderProps {
-  provider: ChatProvider
-}
-```
-
-#### `EditorProviderProps`
+#### `AuthClient`
 
-Props for editor provider component.
+Auth client interface that all auth bond packages must implement.
+Provides login/logout/register flows, token management, profile
+updates, and auth state subscription.
 
 ```typescript
-interface EditorProviderProps extends ProviderProps {
-  provider: EditorProvider
-}
+interface AuthClient<T = UserProfile, TRegister extends RegisterExtraShape<TRegister> = Record<never, never>> {
+    /**
+     * Returns the current authentication state snapshot.
+     *
+     * READING the state starts the client's one session restore when nobody has called
+     * {@link initialize} yet — lazily and exactly once, sharing the promise an explicit
+     * `initialize()` returns. A hook (`useAuth()`), a subscriber, `isAuthenticated()` and
+     * `getUser()` are reads too, so a client whose entry file dropped the template's
+     * `authClient.initialize()` line still restores instead of reporting `'loading'`
+     * forever.
+     */
+    getState(): AuthState<T>;
+    /**
+     * Returns whether the user is currently authenticated.
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Gets the current user.
+     */
+    getUser(): T | null;
+    /**
+     * Optional ownership marker for the current session. Compare values only within
+     * this client: replacing or ending a session changes it, including re-adopting
+     * the same token and user. Profile updates and same-session refreshes keep it.
+     * Consumers can use it to discard stale async work without treating editable
+     * user fields as an immutable account identifier. Providers without this
+     * capability require the consumer's own stable identity check.
+     */
+    getSessionRevision?(): number;
+    /**
+     * Updates the cached user object (state + persistent storage) without
+     * hitting the network. Intended for local refreshes after a per-app
+     * mutation (e.g., the user just PATCHed their own profile and the
+     * server returned the canonical row). Does NOT change tokens.
+     *
+     * This does not sign the client in: `authenticated` and `status` are
+     * unchanged, so an anonymous client stays anonymous. Use
+     * {@link login} / {@link register} for a credential exchange, or
+     * {@link setSession} when the token was issued outside the client.
+     */
+    setUser(user: T | null): void;
+    /**
+     * Gets the current access token.
+     */
+    getAccessToken(): string | null;
+    /**
+     * Stores the access token in the configured token storage adapter (in a
+     * browser, Web Storage; `'memory'` where no browser store exists). Use this
+     * to seed the token after an out-of-band exchange (e.g. the OAuth
+     * code→token redirect) instead of writing to `localStorage` directly,
+     * which would violate the storage contract and make a stored bearer token
+     * JS-readable (XSS-exfiltratable). Pass `null` to clear it.
+     *
+     * This changes token storage only; it does not sign the client in
+     * (`authenticated` and `status` are unchanged). Use {@link login} /
+     * {@link register} for a credential exchange, or call {@link setSession}
+     * with the token and the user to establish an already-issued session.
+     */
+    setAccessToken(token: string | null): void;
+    /**
+     * Adopts a session an out-of-band exchange already established: stores the
+     * access token (and the refresh token when given), caches the user, and
+     * sets the COMPLETE state — `initialized`, `authenticated`, `status:
+     * 'authenticated'`, no error — in one update, with one subscriber
+     * notification. Every hook reading the shared client sees the user as
+     * signed in immediately.
+     *
+     * This is the way to seed an OAuth/custom sign-in. Calling
+     * {@link setAccessToken} and {@link setUser} instead does NOT sign the
+     * client in.
+     */
+    setSession(session: AuthSessionSeed<T>): void;
+    /**
+     * Gets the refresh token.
+     */
+    getRefreshToken(): string | null;
+    /**
+     * Logs in with credentials.
+     */
+    login(credentials: LoginCredentials): Promise<AuthResult<T>>;
+    /**
+     * Logs out the current user.
+     */
+    logout(): Promise<void>;
+    /**
+     * Registers a new user. Accepts the base fields plus the app's own fields
+     * (`TRegister`) at the top level — see {@link RegisterData}.
+     */
+    register(data: RegisterData<TRegister>): Promise<AuthResult<T>>;
+    /**
+     * Refreshes the access token.
+     */
+    refresh(): Promise<AuthResult<T>>;
+    /**
+     * Requests a password reset.
+     */
+    requestPasswordReset(data: PasswordResetRequest): Promise<void>;
+    /**
+     * Confirms a password reset.
+     */
+    confirmPasswordReset(data: PasswordResetConfirm): Promise<void>;
+    /**
+     * Updates the current user's profile.
+     * Returns the saved response. If the session is explicitly replaced or ended
+     * while the request is pending, that response does not replace the current
+     * session's user or persisted cache.
+     */
+    updateProfile(data: Partial<T>): Promise<T>;
+    /**
+     * Changes the current user's password.
+     */
+    changePassword(oldPassword: string, newPassword: string): Promise<void>;
+    /**
+     * Initializes auth state (e.g., from stored tokens).
+     *
+     * LAZY and IDEMPOTENT: the first read of the state ({@link getState},
+     * {@link subscribe}, `useAuth()`) starts this same restore when nobody has called
+     * `initialize()`, and every later call shares the one promise instead of sending a
+     * second request. An app that keeps the template's explicit call behaves exactly as
+     * before; an app that loses that line still restores its session.
+     *
+     * With a stored token AND a stored user it marks the session `'authenticated'`
+     * SYNCHRONOUSLY — before its first `await` — so the first render is the
+     * signed-in UI and no page waits on a verification round trip. Any check
+     * (a refresh, the cookie-restore probe) settles behind that render, and only an
+     * explicit 401/403 ends the session; a network/5xx/404 failure keeps it and
+     * reports `'unavailable'`. With no stored user the client stays `'loading'`
+     * until the cookie restore decides.
+     *
+     * Do not put this call (or a `/me` request of your own) in front of the first
+     * render, and do not render a loading screen over a session it just restored:
+     * `whenRestored()` already resolves as soon as the restore has settled, and the
+     * HTTP gate built on it holds requests for exactly that window.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Re-checks a restored session against the server, in the background — the
+     * boot-time validation an app with a stored token needs when a revoked or
+     * expired token must sign the user out. Call it AFTER the first render
+     * (`initialize()` restores synchronously from storage; this costs one request).
+     *
+     * - The server confirms the user: the session is refreshed and {@link AuthState.status}
+     *   stays `'authenticated'`.
+     * - The server answers 401 or 403: the token is dead — the stored session is
+     *   cleared and the status becomes `'unauthenticated'`.
+     * - The server cannot confirm the session — a network failure, a 5xx, or a 404
+     *   from a misconfigured {@link AuthClientConfig.currentUserEndpoint}: the
+     *   session (token AND user) is KEPT and the status becomes `'unavailable'`, so
+     *   the app can retry instead of signing the user out over a bad connection or a
+     *   route that does not exist. The 404 error names `currentUserEndpoint`.
+     *
+     * Do not hand-write this beside the client: a parallel token/user store for a
+     * "validating"/"unavailable" flag is the race this method removes.
+     *
+     * Optional: a provider with no restorable session has nothing to validate.
+     */
+    validateSession?(): Promise<void>;
+    /**
+     * Resolves when the session restore started by `initialize()` has settled — the point
+     * after which the client knows whether this visitor is signed in.
+     *
+     * Resolves IMMEDIATELY when no restore is in flight: before `initialize()` is ever
+     * called, and after it has finished. A restore that failed resolves too (it settled the
+     * question), so an HTTP client can await this before every request without risking one
+// … truncated — the full declaration is in node_modules/@molecule/app-react-native/dist
 ```
 
 #### `FormController`
@@ -320,7 +351,13 @@ interface FormController<T extends Record<string, unknown> = Record<string, unkn
    */
   validate(): Promise<boolean>
   /**
-   * Resets the form to initial values.
+   * Resets the form and clears errors, touched fields and submission state.
+   *
+   * With no argument it restores the current baseline — the initial
+   * `defaultValues`, or the values a previous `reset(values)` established.
+   * Passing `values` merges them over the current baseline and makes the
+   * result the new baseline, so a form reset to freshly loaded or saved data
+   * reads clean (`isDirty === false`).
    */
   reset(values?: Partial<T>): void
   /**
@@ -352,7 +389,8 @@ Form creation options.
 ```typescript
 interface FormOptions<T extends Record<string, unknown>> {
   /**
-   * Default values.
+   * Default values, captured as the form's clean baseline when the controller
+   * is created. Mutating this object afterwards does not change the baseline.
    */
   defaultValues?: Partial<T>
   /**
@@ -393,7 +431,8 @@ interface HttpClient {
    */
   defaultHeaders: Record<string, string>
   /**
-   * Makes a generic HTTP request.
+   * Makes a generic HTTP request. `data` is a field of THIS config object — the same body
+   * `post(url, data, config)` takes as its second argument.
    */
   request<T = unknown>(config: FullRequestConfig): Promise<HttpResponse<T>>
   /**
@@ -401,15 +440,19 @@ interface HttpClient {
    */
   get<T = unknown>(url: string, config?: RequestConfig): Promise<HttpResponse<T>>
   /**
-   * Makes a POST request.
+   * Makes a POST request. `data` is the request BODY, not a config object: the wire body is
+   * `data` itself, so `post(url, { data: body })` sends `{"data":body}` — pass `body` directly.
+   * A config (headers, params) is the THIRD argument.
    */
   post<T = unknown>(url: string, data?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>
   /**
-   * Makes a PUT request.
+   * Makes a PUT request. `data` is the request BODY (second argument) — never `{ data: body }`,
+   * which sends `{"data":body}`; a config is the THIRD argument.
    */
   put<T = unknown>(url: string, data?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>
   /**
-   * Makes a PATCH request.
+   * Makes a PATCH request. `data` is the request BODY (second argument) — never `{ data: body }`,
+   * which sends `{"data":body}`; a config is the THIRD argument.
    */
   patch<T = unknown>(url: string, data?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>
   /**
@@ -448,77 +491,6 @@ interface HttpClient {
 }
 ```
 
-#### `HttpProviderProps`
-
-Props for http provider component.
-
-```typescript
-interface HttpProviderProps extends ProviderProps {
-  client: HttpClient
-}
-```
-
-#### `I18nProviderProps`
-
-Props for i18n provider component.
-
-```typescript
-interface I18nProviderProps extends ProviderProps {
-  provider: I18nProvider
-}
-```
-
-#### `LoggerProviderProps`
-
-Props for logger provider component.
-
-```typescript
-interface LoggerProviderProps extends ProviderProps {
-  provider: LoggerProvider
-}
-```
-
-#### `MoleculeProviderProps`
-
-Properties for molecule provider.
-
-```typescript
-interface MoleculeProviderProps extends ProviderProps {
-  state?: StateProvider
-  auth?: AuthClient<unknown>
-  theme?: ThemeProvider
-  router?: Router
-  i18n?: I18nProvider
-  http?: HttpClient
-  storage?: StorageProvider
-  logger?: LoggerProvider
-  chat?: ChatProvider
-  workspace?: WorkspaceProvider
-  editor?: EditorProvider
-  preview?: PreviewProvider
-}
-```
-
-#### `PreviewProviderProps`
-
-Props for preview provider component.
-
-```typescript
-interface PreviewProviderProps extends ProviderProps {
-  provider: PreviewProvider
-}
-```
-
-#### `ProviderProps`
-
-Props for provider components.
-
-```typescript
-interface ProviderProps {
-  children: ReactNode
-}
-```
-
 #### `Router`
 
 Client-side router providing navigation, guards, route matching, and history control.
@@ -645,163 +617,124 @@ interface RouterConfig {
 }
 ```
 
-#### `RouterProviderProps`
+#### `StoreConfig`
 
-Props for router provider component.
+Configuration for creating a store (initial state, optional name, and middleware chain).
 
 ```typescript
-interface RouterProviderProps extends ProviderProps {
-  router: Router
+interface StoreConfig<T> {
+  /**
+   * Initial state value.
+   */
+  initialState: T
+  /**
+   * Optional name for debugging.
+   */
+  name?: string
+  /**
+   * Optional middleware functions.
+   */
+  middleware?: StoreMiddleware<T>[]
 }
 ```
 
-#### `SendMessageOptions`
+#### `Store`
 
-Options for {@link UseChatResult.sendMessage}.
+Reactive state container with getState, setState, subscribe, and destroy.
+
+All state management providers must implement this interface.
 
 ```typescript
-interface SendMessageOptions {
-  /**
-   * Skip the optimistic local user-message bubble. The text is still sent to
-   * the server. Used for ask_user responses: the answer is folded into the
-   * ask_user tool card (a checkmark on the chosen option, or the custom text
-   * shown in-card) rather than echoed as a separate message below it.
-   */
-  suppressUserMessage?: boolean
+interface Store<T> {
   /**
-   * Mark this send as issued automatically on the user's behalf (e.g. an
-   * auto-fix prompt). The optimistic local bubble and the persisted message are
-   * flagged `automatic` so the chat renders it in the distinct auto-sent style
-   * (agent avatar + accent border) instead of looking like the user typed it.
+   * Gets the current state.
    */
-  automatic?: boolean
+  getState(): T
   /**
-   * Mark this send as the answer to the pending `ask_user` question. The most
-   * recent unanswered `ask_user` tool call in the store is resolved in place —
-   * its `output` is set to this answer — so the chosen option stays checked
-   * across remounts (e.g. the discovery→IDE transition) instead of relying on
-   * ephemeral component state that the answer's selection would otherwise lose.
-   * Distinct from {@link suppressUserMessage} (which the post-boot kickoff also
-   * sets) so resolving never misfires on a non-ask_user suppressed send.
+   * Sets the state (partial or via updater function).
    */
-  askUserAnswer?: boolean
+  setState(partial: Partial<T> | ((state: T) => Partial<T>)): void
   /**
-   * Mark an {@link automatic} send as directly requested by the user (e.g. the
-   * editor's "Fix with AI" action, the broken-preview overlay's "Fix with AI"
-   * button) rather than dispatched autonomously by the platform. A user Stop
-   * suppresses autonomous automatic sends until the user re-engages; a
-   * user-initiated one IS that re-engagement — it clears the stop and sends.
+   * Subscribes to state changes.
+   * Returns an unsubscribe function.
    */
-  userInitiated?: boolean
+  subscribe(listener: StateListener<T>): () => void
   /**
-   * Send on the SIDE CHANNEL: a human-to-human message (e.g. a team note) the
-   * server intercepts before running any agent turn. When the provider supports
-   * `sendSideMessage`, the send goes out IMMEDIATELY on an independent request —
-   * it never queues behind an active turn, never takes over the streaming
-   * state, and never tears down remote-turn tracking (a viewer's note while
-   * watching a teammate's turn must not stop the watching). Falls back to the
-   * normal send path on providers without side-channel support.
+   * Destroys the store and cleans up subscriptions.
    */
-  sideChannel?: boolean
+  destroy(): void
 }
 ```
 
-#### `StateProviderProps`
+#### `Theme`
 
-Props for state provider component.
+Complete theme definition.
 
 ```typescript
-interface StateProviderProps extends ProviderProps {
-  provider: StateProvider
-}
-```
-
-#### `StorageProviderProps`
-
-Props for storage provider component.
-
-```typescript
-interface StorageProviderProps extends ProviderProps {
-  provider: StorageProvider
+interface Theme {
+  name: string
+  mode: 'light' | 'dark'
+  colors: ThemeColors
+  breakpoints: ThemeBreakpoints
+  spacing: ThemeSpacing
+  typography: ThemeTypography
+  borderRadius: ThemeBorderRadius
+  shadows: ThemeShadows
+  transitions: ThemeTransitions
+  zIndex: ThemeZIndex
 }
 ```
 
-#### `Store`
-
-Reactive state container with getState, setState, subscribe, and destroy.
+#### `UseBackHandlerOptions`
 
-All state management providers must implement this interface.
+Options for the useBackHandler hook.
 
 ```typescript
-interface Store<T> {
-  /**
-   * Gets the current state.
-   */
-  getState(): T
-  /**
-   * Sets the state (partial or via updater function).
-   */
-  setState(partial: Partial<T> | ((state: T) => Partial<T>)): void
-  /**
-   * Subscribes to state changes.
-   * Returns an unsubscribe function.
-   */
-  subscribe(listener: StateListener<T>): () => void
-  /**
-   * Destroys the store and cleans up subscriptions.
-   */
-  destroy(): void
+interface UseBackHandlerOptions {
+  /** Whether the handler is enabled. Defaults to true. */
+  enabled?: boolean
 }
 ```
 
-#### `StoreConfig`
+#### `UseAppStateResult`
 
-Configuration for creating a store (initial state, optional name, and middleware chain).
+Result from the useAppState hook.
 
 ```typescript
-interface StoreConfig<T> {
-  /**
-   * Initial state value.
-   */
-  initialState: T
-  /**
-   * Optional name for debugging.
-   */
-  name?: string
-  /**
-   * Optional middleware functions.
-   */
-  middleware?: StoreMiddleware<T>[]
+interface UseAppStateResult {
+  /** Current app state: 'active' | 'background' | 'inactive' */
+  appState: string
+  /** Whether the app is in the foreground */
+  isActive: boolean
 }
 ```
 
-#### `Theme`
+#### `UseKeyboardHeightResult`
 
-Complete theme definition.
+Result from the useKeyboardHeight hook.
 
 ```typescript
-interface Theme {
-  name: string
-  mode: 'light' | 'dark'
-  colors: ThemeColors
-  breakpoints: ThemeBreakpoints
-  spacing: ThemeSpacing
-  typography: ThemeTypography
-  borderRadius: ThemeBorderRadius
-  shadows: ThemeShadows
-  transitions: ThemeTransitions
-  zIndex: ThemeZIndex
+interface UseKeyboardHeightResult {
+  /** Current keyboard height in points (0 when hidden) */
+  keyboardHeight: number
+  /** Whether the keyboard is currently visible */
+  isKeyboardVisible: boolean
 }
 ```
 
-#### `ThemeProviderProps`
+#### `AgentIdentity`
 
-Props for theme provider component.
+Display identity for the AI coding agent and the host product, used to
+interpolate the `{{agentName}}` / `{{productName}}` tokens in shared chat/IDE
+copy. A consuming app sets these to its own agent + product brand names; the
+shared packages fall back to {@link DEFAULT_AGENT_IDENTITY} when it does not.
 
 ```typescript
-interface ThemeProviderProps extends ProviderProps {
-  provider: ThemeProvider
-  initialTheme?: string
+interface AgentIdentity {
+  /** Display name of the AI coding agent. Defaults to {@link DEFAULT_AGENT_NAME}. */
+  agentName: string
+  /** Display name of the host product / IDE. Defaults to {@link DEFAULT_PRODUCT_NAME}. */
+  productName: string
 }
 ```
 
@@ -827,338 +760,132 @@ interface UseAIModelsResult {
 }
 ```
 
-#### `UseAppStateResult`
+#### `UseChangePasswordReturn`
 
-Result from the useAppState hook.
+Return type for useChangePassword hook.
 
 ```typescript
-interface UseAppStateResult {
-  /** Current app state: 'active' | 'background' | 'inactive' */
-  appState: string
-  /** Whether the app is in the foreground */
-  isActive: boolean
+interface UseChangePasswordReturn {
+  status: UsePromiseState<void>['status']
+  error: UsePromiseState<void>['error']
+  changePassword: (oldPassword: string, newPassword: string) => Promise<void>
+  reset: () => void
 }
 ```
 
-#### `UseAuthOptions`
+#### `UseDeviceResult`
 
-Hook options for useAuth.
+Hook return type.
 
 ```typescript
-interface UseAuthOptions {
-  /**
-   * Whether to automatically refresh the token on mount.
-   */
-  autoRefresh?: boolean
+interface UseDeviceResult {
+  deviceInfo: DeviceInfo
+  screenInfo: ScreenInfo
+  hardwareInfo: HardwareInfo
+  featureSupport: FeatureSupport
+  supports: (feature: keyof FeatureSupport) => boolean
+  isOnline: () => boolean
+  isStandalone: () => boolean
+  language: string
+  languages: string[]
 }
 ```
 
-#### `UseAuthResult`
+#### `UseFormOptions`
 
-Hook result for useAuth.
+Options for useForm hook.
+
+Every `FormOptions` field is supported. `createForm` is only an override —
+omit it and the hook creates the controller through the bonded forms
+provider (`createForm` from `@molecule/app-forms`), which uses the built-in
+native provider until the app bonds its own.
 
 ```typescript
-interface UseAuthResult<T = unknown> {
-  state: AuthState<T>
-  login: AuthClient<T>['login']
-  logout: AuthClient<T>['logout']
-  register: AuthClient<T>['register']
-  refresh: AuthClient<T>['refresh']
-  setUser: AuthClient<T>['setUser']
-  isAuthenticated: boolean
-  isLoading: boolean
-  user: T | null
+interface UseFormOptions<T extends Record<string, unknown>> extends FormOptions<T> {
+  /**
+   * Explicit form factory for this one form. Defaults to the bonded forms
+   * provider; pass it only to pin a specific provider instance.
+   */
+  createForm?: (options: FormOptions<T>) => FormController<T>
 }
 ```
 
-#### `UseBackHandlerOptions`
+#### `UseFormResult`
 
-Options for the useBackHandler hook.
+Result of useForm hook.
 
 ```typescript
-interface UseBackHandlerOptions {
-  /** Whether the handler is enabled. Defaults to true. */
-  enabled?: boolean
+interface UseFormResult<T extends Record<string, unknown>> {
+  formState: FormState<T>
+  isValid: boolean
+  isDirty: boolean
+  isSubmitting: boolean
+  register: (
+    name: keyof T,
+    options?: Omit<RegisterOptions, 'name'> & {
+      name?: string
+    },
+  ) => FieldRegistration
+  getValue: <K extends keyof T>(name: K) => T[K]
+  setValue: <K extends keyof T>(name: K, value: T[K]) => void
+  getError: (name: keyof T) => string | undefined
+  setError: (name: keyof T, error: string | undefined) => void
+  clearErrors: () => void
+  handleSubmit: (onSubmit: (values: T) => void | Promise<void>) => (event?: React.FormEvent) => void
+  reset: (values?: Partial<T>) => void
+  validate: () => Promise<boolean>
 }
 ```
 
-#### `UseChangePasswordReturn`
+#### `UseHttpState`
 
-Return type for useChangePassword hook.
+State for async HTTP operations.
 
 ```typescript
-interface UseChangePasswordReturn {
-  status: UsePromiseState<void>['status']
-  error: UsePromiseState<void>['error']
-  changePassword: (oldPassword: string, newPassword: string) => Promise<void>
-  reset: () => void
+interface UseHttpState<T> {
+  data: T | null
+  loading: boolean
+  error: Error | null
 }
 ```
 
-#### `UseChatOptions`
+#### `UseHttpResult`
 
-Hook options for useChat.
+Result of useHttp hook.
 
 ```typescript
-interface UseChatOptions {
-  /** Chat endpoint (e.g., '/projects/123/chat'). */
-  endpoint: string
-  /** Project ID for context. */
-  projectId?: string
-  /**
-   * Display name of the AI coding agent, interpolated into user-facing chat
-   * copy (e.g. the stalled-stream notice). The host passes its own agent brand
-   * name; defaults to the neutral `DEFAULT_AGENT_NAME` so the shared hook never
-   * names a specific product.
-   */
-  agentName?: string
-  /** Load history on mount. */
-  loadOnMount?: boolean
+interface UseHttpResult<T> extends UseHttpState<T> {
   /**
-   * This client may only WATCH the conversation (e.g. a read-only project
-   * viewer): the hook never issues chat POSTs on its behalf — no resume
-   * request after a reload, no auto-retries. A live turn is followed through
-   * the remote-watch path instead: pushed broadcast frames (applyRemoteEvent)
-   * render it in real time and the history reconcile poll backstops gaps, with
-   * `isRemoteStreaming` driving the activity indicator.
+   * Runs the request and resolves with its data, or `null` on failure.
+   *
+   * This function is IDENTITY-STABLE for as long as `method`, `url` and the HTTP
+   * client do not change, so it is safe in a `useEffect` dependency array. Its
+   * request options are read when it is CALLED, from the latest committed render.
    */
-  readOnly?: boolean
-  /** Called when a file is created or modified by a tool call (path + new content). */
-  onFileChange?: (path: string, content: string) => void
-  /** Called when the AI switches between plan and execute modes. */
-  onModeChange?: (mode: 'plan' | 'execute') => void
-  /** Called when the backend assigns or confirms a conversation ID. */
-  onConversationId?: (id: string) => void
-  /** Called for every streaming event — useful for notifications, sounds, etc. */
-  onStreamEvent?: (event: ChatStreamEvent) => void
+  execute: () => Promise<T | null>
+  reset: () => void
 }
 ```
 
-#### `UseChatResult`
+#### `UseHttpOptions`
 
-Hook result for useChat.
+Options for useHttp hook.
+
+Every request option — headers, params, body `data`, `signal`, `onSuccess`,
+`onError` — is read at the moment `execute` runs, not when the hook rendered,
+so an inline object or callback needs no memoizing. Only `immediate` is read
+on mount.
 
 ```typescript
-interface UseChatResult {
-  messages: ChatMessage[]
-  isLoading: boolean
+interface UseHttpOptions<T> extends RequestConfig {
   /**
-   * True while a backend turn for this conversation streams WITHOUT this client
-   * owning the request — a turn started in another tab, by a teammate, or any
-   * server-side continuation. Detected from pushed (broadcast) chat events and
-   * confirmed/cleared against the server's `streaming` history flag, so the Stop
-   * control can stay visible and functional whenever ANY backend turn is live —
-   * not only for sends this hook instance made.
+   * Whether to execute the request immediately on mount.
    */
-  isRemoteStreaming: boolean
+  immediate?: boolean
   /**
-   * Tell the hook a pushed (broadcast) chat event arrived for this conversation.
-   * The host (ChatPanel) calls this from its push-channel handler; the hook then
-   * confirms against the server's `streaming` flag and, while a remote turn is
-   * live, keeps `isRemoteStreaming` true until the server reports it finished.
+   * Callback when request succeeds.
    */
-  noteRemoteStreamEvent: () => void
-  error: string | null
-  /**
-   * Metadata about a limit-related error, for a contextual call-to-action.
-   * `limitType` names the RULE the backend enforced; `billingAction` names the
-   * REMEDY it resolved (e.g. `add_funds`, `add_payment_method`,
-   * `raise_spend_cap`, `upgrade`, `none`) and is what the button should be
-   * built from — the same limit needs a different button per account.
-   * `upgradeTier` is the plan an upgrade would move to, explicitly `null` when
-   * there is no higher tier. The backend owns these vocabularies, so the
-   * action/tier are plain strings here.
-   */
-  errorMeta: {
-    limitType?: string
-    requiresSignup?: boolean
-    billingAction?: string
-    upgradeTier?: string | null
-  } | null
-  /** Current agent mode — plan (read-only research) or execute (full access). */
-  mode: 'plan' | 'execute'
-  /**
-   * Whether the conversation runs at the provider's fast/priority speed tier
-   * (server-persisted per conversation; hydrated from the history load's
-   * `fastMode` meta field, when the server provides one). Only meaningful for
-   * models that support a fast tier — the server ignores it otherwise.
-   */
-  fastMode: boolean
-  /**
-   * Transient label for a background phase (e.g. the post-response verification
-   * pass — "Type-checking the API", "Linting"), set by `status` stream events.
-   * The UI shows it in place of the spinner's generic rotating messages; `null`
-   * when no such phase is active.
-   */
-  streamingStatus: string | null
-  /**
-   * Active 5XX backoff-retry countdown, or `null` when none is pending. After a
-   * backend server error (HTTP 5XX) the hook does NOT surface a terminal error —
-   * it shows this cancelable countdown and, when it elapses, auto-resumes the
-   * turn where the user left off (`resume:true`). `secondsRemaining` ticks down
-   * once per second; `attempt` is the 1-based retry number (capped at 3). 4XX,
-   * limit/quota, and signup-required errors never auto-retry.
-   */
-  retryCountdown: {
-    secondsRemaining: number
-    attempt: number
-  } | null
-  /** Update the local mode state (for instant mode toggle without an AI turn). */
-  setMode: (mode: 'plan' | 'execute') => void
-  /** Update the local fast-mode state (for instant toggle without an AI turn). */
-  setFastMode: (fastMode: boolean) => void
-  sendMessage: (
-    message: string,
-    attachments?: ChatAttachment[],
-    options?: SendMessageOptions,
-  ) => Promise<void>
-  abort: () => void
-  /**
-   * Cancel a pending 5XX auto-retry. Clears the countdown and surfaces the
-   * original error (via `error`) so the user sees why the turn failed.
-   */
-  cancelRetry: () => void
-  clearHistory: () => Promise<void>
-  /** Edit the content of a queued (not yet sent) message. */
-  editQueuedMessage: (msgId: string, newContent: string) => void
-  /** Remove a queued (not yet sent) message from the queue. */
-  deleteQueuedMessage: (msgId: string) => void
-  /** Remove queued auto-fix messages whose content references the given file path. */
-  clearQueuedForFile: (filePath: string) => void
-  /**
-   * Append an inline transcript card (model / mode / skills / custom notice) as a
-   * `role:'system'` card-message in the ONE message store. Used by the host (ChatPanel)
-   * to render a TEAMMATE's broadcast `card` event live — this client's OWN cards arrive
-   * through the stream and are appended internally. De-duped by the server-assigned id.
-   */
-  appendCardMessage: (
-    id: string,
-    timestamp: number,
-    card: NonNullable<ChatMessage['cardEvent']>,
-  ) => void
-  /**
-   * Append a COMPLETE, non-streaming chat message (a `message` stream event — e.g.
-   * a teammate's human-only team note) to the ONE message store. Used by the host
-   * (ChatPanel) to render a TEAMMATE's broadcast `message` event live — this
-   * client's OWN `message` events arrive through the stream and are appended
-   * internally. De-duped by the server-assigned message id.
-   */
-  appendCompleteMessage: (message: ChatMessage) => void
-  /**
-   * Ingest ONE pushed (broadcast) stream frame from a turn running elsewhere —
-   * a teammate's send, another tab, a server-side continuation — into the ONE
-   * message store, through the same content applier as an own SSE stream: text/
-   * thinking deltas, tool events, verification, cards, complete messages, done.
-   * The host (ChatPanel) calls this from its push-channel handler for every
-   * broadcast frame of the OPEN conversation. Own echoes are dropped while a
-   * local send is in flight (the SSE stream is authoritative for the sender);
-   * complete id-carrying items (cards, team notes) always apply, de-duped.
-   */
-  applyRemoteEvent: (event: ChatStreamEvent) => void
-  /**
-   * Reload history and converge the local view on the server transcript (and
-   * re-enter a still-streaming turn). The page-lifecycle events run this
-   * automatically; the host should ALSO call it whenever its chat push channel
-   * (re)connects — a broadcast sent while that socket was down (a teammate's
-   * team note against a backgrounded tab or a slept laptop) is otherwise lost
-   * until the next lifecycle event happens to fire. Cheap when nothing changed:
-   * an identical transcript is never re-applied.
-   */
-  reconcileHistory: () => Promise<void>
-}
-```
-
-#### `UseDeviceResult`
-
-Hook return type.
-
-```typescript
-interface UseDeviceResult {
-  deviceInfo: DeviceInfo
-  screenInfo: ScreenInfo
-  hardwareInfo: HardwareInfo
-  featureSupport: FeatureSupport
-  supports: (feature: keyof FeatureSupport) => boolean
-  isOnline: () => boolean
-  isStandalone: () => boolean
-  language: string
-  languages: string[]
-}
-```
-
-#### `UseEditorResult`
-
-Hook result for useEditor.
-
-```typescript
-interface UseEditorResult {
-  tabs: EditorTab[]
-  activeFile: string | null
-  openFile: (file: EditorFile) => void
-  closeFile: (path: string) => void
-  getContent: () => string | null
-  setContent: (path: string, content: string) => void
-  setActiveTab: (path: string) => void
-  mount: EditorProvider['mount']
-  dispose: () => void
-  focus: () => void
-  openDiff: (file: DiffFile) => void
-  closeDiff: () => void
-  pinTab: (path: string) => void
-  addExtraLib: (content: string, filePath: string) => void
-  onFixWithAI: (callback: (request: FixWithAIRequest) => void) => () => void
-}
-```
-
-#### `UseFormOptions`
-
-Options for useForm hook.
-
-```typescript
-interface UseFormOptions<T extends Record<string, unknown>> extends FormOptions<T> {
-  /**
-   * Form provider's createForm function.
-   */
-  createForm: (options: FormOptions<T>) => FormController<T>
-}
-```
-
-#### `UseFormResult`
-
-Result of useForm hook.
-
-```typescript
-interface UseFormResult<T extends Record<string, unknown>> {
-  formState: FormState<T>
-  isValid: boolean
-  isDirty: boolean
-  isSubmitting: boolean
-  register: (name: keyof T, options?: RegisterOptions) => FieldRegistration
-  getValue: <K extends keyof T>(name: K) => T[K]
-  setValue: <K extends keyof T>(name: K, value: T[K]) => void
-  getError: (name: keyof T) => string | undefined
-  setError: (name: keyof T, error: string | undefined) => void
-  clearErrors: () => void
-  handleSubmit: (onSubmit: (values: T) => void | Promise<void>) => (event?: React.FormEvent) => void
-  reset: (values?: Partial<T>) => void
-  validate: () => Promise<boolean>
-}
-```
-
-#### `UseHttpOptions`
-
-Options for useHttp hook.
-
-```typescript
-interface UseHttpOptions<T> extends RequestConfig {
-  /**
-   * Whether to execute the request immediately on mount.
-   */
-  immediate?: boolean
-  /**
-   * Callback when request succeeds.
-   */
-  onSuccess?: (data: T) => void
+  onSuccess?: (data: T) => void
   /**
    * Callback when request fails.
    */
@@ -1166,42 +893,6 @@ interface UseHttpOptions<T> extends RequestConfig {
 }
 ```
 
-#### `UseHttpResult`
-
-Result of useHttp hook.
-
-```typescript
-interface UseHttpResult<T> extends UseHttpState<T> {
-  execute: () => Promise<T | null>
-  reset: () => void
-}
-```
-
-#### `UseHttpState`
-
-State for async HTTP operations.
-
-```typescript
-interface UseHttpState<T> {
-  data: T | null
-  loading: boolean
-  error: Error | null
-}
-```
-
-#### `UseKeyboardHeightResult`
-
-Result from the useKeyboardHeight hook.
-
-```typescript
-interface UseKeyboardHeightResult {
-  /** Current keyboard height in points (0 when hidden) */
-  keyboardHeight: number
-  /** Whether the keyboard is currently visible */
-  isKeyboardVisible: boolean
-}
-```
-
 #### `UseLoginReturn`
 
 Return type for useLogin hook.
@@ -1269,56 +960,91 @@ interface UsePlatformResult {
 }
 ```
 
-#### `UsePreviewResult`
+#### `UseProfileFormOptions`
 
-Hook result for usePreview.
+Configuration for a profile form; transport stays in the auth bond.
 
 ```typescript
-interface UsePreviewResult {
-  state: PreviewState
-  setUrl: (url: string) => void
-  refresh: () => void
-  setDevice: (device: DeviceFrame) => void
-  openExternal: () => void
+interface UseProfileFormOptions<TUser, TValues extends Record<string, unknown>> extends Omit<
+  UseFormOptions<TValues>,
+  'defaultValues'
+> {
+  /** Complete controlled-field defaults, including blank write-only fields. */
+  defaultValues: TValues
   /**
-   * Records a navigation the running preview reported via its `molecule:navigate`
-   * message — updates the displayed current location without reloading the iframe.
-   * Pass `isReplace` when the preview REPLACED its current history entry (a
-   * `replaceState` redirect/canonicalization) so the forward stack is preserved
-   * instead of truncated (a `pushState`, the default, truncates forward).
+   * Optional additional account identity check; changing it discards prior edits.
+   * By default ownership follows the auth client's session revision, so editable
+   * fields can change during a save. Providers without getSessionRevision must
+   * supply this callback with an identity that remains stable across profile edits.
    */
-  recordNavigation: (url: string, isReplace?: boolean) => void
-  /** Navigates the preview to the previous navigation-history entry (Back). */
-  back: () => void
-  /** Navigates the preview to the next navigation-history entry (Forward). */
-  forward: () => void
+  getIdentity?: (user: TUser) => string
+  /** Maps the current/saved user into controlled values, e.g. nullable text to ''. */
+  toValues: (user: TUser) => TValues
+  /**
+   * Maps ONLY changed fields into an API patch. Omit blank optional credentials
+   * here; preserve undefined/absent fields rather than turning them into null.
+   * The second argument is the complete value snapshot taken at submit time.
+   */
+  toPatch: (changes: Partial<TValues>, values: Readonly<TValues>) => Partial<TUser>
+  /**
+   * Propagates the server's saved user to other caches, then navigates if needed.
+   * Awaited before submission finishes. The auth client already persists and
+   * publishes the saved user; never seed caches from the submitted patch.
+   */
+  onSaved?: (user: TUser) => void | Promise<void>
 }
 ```
 
-#### `UsePromiseState`
+#### `UseProfileFormResult`
 
-Extended promise state with actions.
+Controlled profile form state and native form bindings.
 
 ```typescript
-interface UsePromiseState<T> {
-  status: PromiseStatus
-  value: T | null
-  error: Error | null
-  cancel: (message?: string) => void
+interface UseProfileFormResult<TUser, TValues extends Record<string, unknown>> extends Omit<
+  UseFormResult<TValues>,
+  'register' | 'handleSubmit' | 'reset'
+> {
+  /** The shared auth user's current profile. */
+  user: TUser | null
+  /** A user has been loaded; disable submission until this is true. */
+  ready: boolean
+  /**
+   * The latest save/propagation failure. Rejected saves retain edits; a failed
+   * onSaved callback can be retried by submit without repeating the mutation.
+   */
+  error: unknown
+  /** Native input/textarea bindings with the field's concrete value type. */
+  register: <K extends keyof TValues>(
+    name: K,
+    options?: Parameters<UseFormResult<TValues>['register']>[1],
+  ) => Omit<FieldRegistration, 'value'> & {
+    value: TValues[K]
+  }
+  /** Bind to the native form, with a type="submit" button inside it. */
+  formProps: {
+    onSubmit: (event: React.FormEvent<HTMLFormElement>) => void
+  }
+  /**
+   * Validates and saves one submit-time snapshot. Concurrent submits share the
+   * same promise. Resolves undefined on validation, save or propagation failure.
+   */
+  submit: () => Promise<TUser | undefined>
+  /** Discards edits and restores the newest loaded/saved profile baseline. */
   reset: () => void
 }
 ```
 
-#### `UsePushOptions`
+#### `UsePromiseState`
 
-Options for the usePush hook (e.g. check permission on mount).
+Extended promise state with actions.
 
 ```typescript
-interface UsePushOptions {
-  /**
-   * Whether to check permission status on mount.
-   */
-  checkOnMount?: boolean
+interface UsePromiseState<T> {
+  status: PromiseStatus
+  value: T | null
+  error: Error | null
+  cancel: (message?: string) => void
+  reset: () => void
 }
 ```
 
@@ -1342,20 +1068,16 @@ interface UsePushResult {
 }
 ```
 
-#### `UseRouterResult`
+#### `UsePushOptions`
 
-Hook result for useRouter.
+Options for the usePush hook (e.g. check permission on mount).
 
 ```typescript
-interface UseRouterResult {
-  location: Router['getLocation'] extends () => infer R ? R : never
-  params: Record<string, string>
-  query: QueryParams
-  navigate: Router['navigate']
-  navigateTo: Router['navigateTo']
-  back: Router['back']
-  forward: Router['forward']
-  isActive: Router['isActive']
+interface UsePushOptions {
+  /**
+   * Whether to check permission status on mount.
+   */
+  checkOnMount?: boolean
 }
 ```
 
@@ -1364,11 +1086,14 @@ interface UseRouterResult {
 Return type for useSignup hook.
 
 ```typescript
-interface UseSignupReturn<T = unknown> {
+interface UseSignupReturn<
+  T = unknown,
+  TRegister extends RegisterExtraShape<TRegister> = Record<never, never>,
+> {
   status: UsePromiseState<AuthResult<T>>['status']
   value: UsePromiseState<AuthResult<T>>['value']
   error: UsePromiseState<AuthResult<T>>['error']
-  signup: (data: RegisterData) => Promise<AuthResult<T>>
+  signup: (data: RegisterData<TRegister>) => Promise<AuthResult<T>>
   reset: () => void
 }
 ```
@@ -1404,47 +1129,6 @@ interface UseStorageValueResult<T> {
 }
 ```
 
-#### `UseStoreOptions`
-
-Hook options for useStore.
-
-```typescript
-interface UseStoreOptions<T, S> {
-  selector?: (state: T) => S
-  equalityFn?: (a: S, b: S) => boolean
-}
-```
-
-#### `UseThemeResult`
-
-Hook result for useTheme.
-
-```typescript
-interface UseThemeResult {
-  theme: Theme
-  themeName: string
-  setTheme: (name: string) => void
-  toggleTheme: () => void
-  mode: 'light' | 'dark'
-}
-```
-
-#### `UseTranslationResult`
-
-Hook result for useTranslation.
-
-```typescript
-interface UseTranslationResult {
-  t: I18nProvider['t']
-  locale: string
-  setLocale: I18nProvider['setLocale']
-  locales: ReturnType<I18nProvider['getLocales']>
-  formatNumber: I18nProvider['formatNumber']
-  formatDate: I18nProvider['formatDate']
-  direction: 'ltr' | 'rtl'
-}
-```
-
 #### `UseVerifyPaymentReturnOptions`
 
 Options for {@link useVerifyPaymentReturn}.
@@ -1482,36 +1166,537 @@ interface UseVerifyPaymentReturnResult {
    * the URL) or auth is still hydrating; `verifying` while the API call is in
    * flight; then `verified` or `failed`.
    */
-  status: VerifyPaymentReturnStatus
-  /** `true` when the URL identifies a purchase to verify. */
-  isReturn: boolean
-  /** The provider named by the URL (or the `provider` option). */
-  provider: string | null
-  /** The provider transaction/session id read from the URL. */
-  transactionId: string | null
-  /** Why verification failed, when it did. */
-  error: Error | null
-  /** Re-run the verification — wire this to a retry button. */
-  retry: () => void
-}
-```
-
-#### `UseVersionResult`
-
-Hook return type.
-
-```typescript
-interface UseVersionResult {
-  state: VersionState
-  isUpdateAvailable: boolean
-  isChecking: boolean
-  isServiceWorkerWaiting: boolean
-  newVersion: string | undefined
-  checkForUpdates: () => Promise<boolean>
-  applyUpdate: (options?: { force?: boolean }) => void
-  dismissUpdate: () => void
-  startPeriodicChecks: (options?: UpdateCheckOptions) => void
-  stopPeriodicChecks: () => void
+  status: VerifyPaymentReturnStatus
+  /** `true` when the URL identifies a purchase to verify. */
+  isReturn: boolean
+  /** The provider named by the URL (or the `provider` option). */
+  provider: string | null
+  /** The provider transaction/session id read from the URL. */
+  transactionId: string | null
+  /** Why verification failed, when it did. */
+  error: Error | null
+  /** Re-run the verification — wire this to a retry button. */
+  retry: () => void
+}
+```
+
+#### `UseVersionResult`
+
+Hook return type.
+
+```typescript
+interface UseVersionResult {
+  state: VersionState
+  isUpdateAvailable: boolean
+  isChecking: boolean
+  isServiceWorkerWaiting: boolean
+  newVersion: string | undefined
+  checkForUpdates: () => Promise<boolean>
+  applyUpdate: (options?: { force?: boolean }) => void
+  dismissUpdate: () => void
+  startPeriodicChecks: (options?: UpdateCheckOptions) => void
+  stopPeriodicChecks: () => void
+}
+```
+
+#### `ProviderProps`
+
+Props for provider components.
+
+```typescript
+interface ProviderProps {
+  children: ReactNode
+}
+```
+
+#### `StateProviderProps`
+
+Props for state provider component.
+
+```typescript
+interface StateProviderProps extends ProviderProps {
+  provider: StateProvider
+}
+```
+
+#### `AuthProviderProps`
+
+Props for auth provider component.
+
+```typescript
+interface AuthProviderProps<T = unknown> extends ProviderProps {
+  client: AuthClient<T>
+}
+```
+
+#### `ThemeProviderProps`
+
+Props for theme provider component.
+
+```typescript
+interface ThemeProviderProps extends ProviderProps {
+  provider: ThemeProvider
+  initialTheme?: string
+}
+```
+
+#### `RouterProviderProps`
+
+Props for router provider component.
+
+```typescript
+interface RouterProviderProps extends ProviderProps {
+  router: Router
+}
+```
+
+#### `I18nProviderProps`
+
+Props for i18n provider component.
+
+```typescript
+interface I18nProviderProps extends ProviderProps {
+  provider: I18nProvider
+}
+```
+
+#### `HttpProviderProps`
+
+Props for http provider component.
+
+```typescript
+interface HttpProviderProps extends ProviderProps {
+  client: HttpClient
+}
+```
+
+#### `StorageProviderProps`
+
+Props for storage provider component.
+
+```typescript
+interface StorageProviderProps extends ProviderProps {
+  provider: StorageProvider
+}
+```
+
+#### `LoggerProviderProps`
+
+Props for logger provider component.
+
+```typescript
+interface LoggerProviderProps extends ProviderProps {
+  provider: LoggerProvider
+}
+```
+
+#### `ChatProviderProps`
+
+Props for the ChatProvider React component.
+
+```typescript
+interface ChatProviderProps extends ProviderProps {
+  provider: ChatProvider
+}
+```
+
+#### `WorkspaceProviderProps`
+
+Props for workspace provider component.
+
+```typescript
+interface WorkspaceProviderProps extends ProviderProps {
+  provider: WorkspaceProvider
+}
+```
+
+#### `EditorProviderProps`
+
+Props for editor provider component.
+
+```typescript
+interface EditorProviderProps extends ProviderProps {
+  provider: EditorProvider
+}
+```
+
+#### `PreviewProviderProps`
+
+Props for preview provider component.
+
+```typescript
+interface PreviewProviderProps extends ProviderProps {
+  provider: PreviewProvider
+}
+```
+
+#### `MoleculeProviderProps`
+
+Properties for molecule provider.
+
+```typescript
+interface MoleculeProviderProps extends ProviderProps {
+  state?: StateProvider
+  auth?: AuthClient<unknown>
+  theme?: ThemeProvider
+  router?: Router
+  i18n?: I18nProvider
+  http?: HttpClient
+  storage?: StorageProvider
+  logger?: LoggerProvider
+  chat?: ChatProvider
+  workspace?: WorkspaceProvider
+  editor?: EditorProvider
+  preview?: PreviewProvider
+}
+```
+
+#### `UseStoreOptions`
+
+Hook options for useStore.
+
+```typescript
+interface UseStoreOptions<T, S> {
+  selector?: (state: T) => S
+  equalityFn?: (a: S, b: S) => boolean
+}
+```
+
+#### `UseAuthOptions`
+
+Hook options for useAuth.
+
+```typescript
+interface UseAuthOptions {
+  /**
+   * Whether to automatically refresh the token on mount.
+   */
+  autoRefresh?: boolean
+}
+```
+
+#### `UseAuthResult`
+
+Hook result for useAuth.
+
+```typescript
+interface UseAuthResult<
+  T = unknown,
+  TRegister extends RegisterExtraShape<TRegister> = Record<never, never>,
+> {
+  /**
+   * The session state as one value — render from this instead of combining
+   * `initialized`/`authenticated`/`loading`. A stored token AND user make it
+   * `'authenticated'` on the first render; only `'loading'` means "no decision
+   * yet", so a route guard waits on that and nothing else.
+   */
+  status: AuthState<T>['status']
+  state: AuthState<T>
+  login: AuthClient<T>['login']
+  logout: AuthClient<T>['logout']
+  register: AuthClient<T, TRegister>['register']
+  refresh: AuthClient<T>['refresh']
+  setUser: AuthClient<T>['setUser']
+  /**
+   * Adopt a session an exchange outside the client already established (an
+   * OAuth code→token redirect, the app's own sign-in endpoint) in ONE update:
+   * the token and user are stored and the hook's consumers see the client as
+   * `authenticated` immediately.
+   *
+   * `setUser` alone does NOT sign the client in, and `setAccessToken` changes
+   * storage only — using those two for a caller-issued session leaves every
+   * `authenticated` read signed out (xr-molecule-flash-m178).
+   */
+  setSession: AuthClient<T>['setSession']
+  isAuthenticated: boolean
+  isLoading: boolean
+  user: T | null
+}
+```
+
+#### `UseThemeResult`
+
+Hook result for useTheme.
+
+```typescript
+interface UseThemeResult {
+  theme: Theme
+  themeName: string
+  setTheme: (name: string) => void
+  toggleTheme: () => void
+  mode: 'light' | 'dark'
+}
+```
+
+#### `UseRouterResult`
+
+Hook result for useRouter.
+
+```typescript
+interface UseRouterResult {
+  location: Router['getLocation'] extends () => infer R ? R : never
+  params: Record<string, string>
+  query: QueryParams
+  navigate: Router['navigate']
+  navigateTo: Router['navigateTo']
+  back: Router['back']
+  forward: Router['forward']
+  isActive: Router['isActive']
+}
+```
+
+#### `UseTranslationResult`
+
+Hook result for useTranslation.
+
+```typescript
+interface UseTranslationResult {
+  t: I18nProvider['t']
+  locale: string
+  setLocale: I18nProvider['setLocale']
+  locales: ReturnType<I18nProvider['getLocales']>
+  formatNumber: I18nProvider['formatNumber']
+  formatDate: I18nProvider['formatDate']
+  direction: 'ltr' | 'rtl'
+}
+```
+
+#### `UseChatOptions`
+
+Hook options for useChat.
+
+```typescript
+interface UseChatOptions {
+  /** Chat endpoint (e.g., '/projects/123/chat'). */
+  endpoint: string
+  /** Project ID for context. */
+  projectId?: string
+  /**
+   * Display name of the AI coding agent, interpolated into user-facing chat
+   * copy (e.g. the stalled-stream notice). The host passes its own agent brand
+   * name; defaults to the neutral `DEFAULT_AGENT_NAME` so the shared hook never
+   * names a specific product.
+   */
+  agentName?: string
+  /** Load history on mount. */
+  loadOnMount?: boolean
+  /**
+   * This client may only WATCH the conversation (e.g. a read-only project
+   * viewer): the hook never issues chat POSTs on its behalf — no resume
+   * request after a reload, no auto-retries. A live turn is followed through
+   * the remote-watch path instead: pushed broadcast frames (applyRemoteEvent)
+   * render it in real time and the history reconcile poll backstops gaps, with
+   * `isRemoteStreaming` driving the activity indicator.
+   */
+  readOnly?: boolean
+  /** Called when a file is created or modified by a tool call (path + new content). */
+  onFileChange?: (path: string, content: string) => void
+  /** Called when the AI switches between plan and execute modes. */
+  onModeChange?: (mode: 'plan' | 'execute') => void
+  /** Called when the backend assigns or confirms a conversation ID. */
+  onConversationId?: (id: string) => void
+  /** Called for every streaming event — useful for notifications, sounds, etc. */
+  onStreamEvent?: (event: ChatStreamEvent) => void
+}
+```
+
+#### `SendMessageOptions`
+
+Options for {@link UseChatResult.sendMessage}.
+
+```typescript
+interface SendMessageOptions {
+  /** Reuse a queued message's UUID when delivering it after reconnecting. */
+  messageId?: string
+  /**
+   * Skip the optimistic local user-message bubble. The text is still sent to
+   * the server. Used for ask_user responses: the answer is folded into the
+   * ask_user tool card (a checkmark on the chosen option, or the custom text
+   * shown in-card) rather than echoed as a separate message below it.
+   */
+  suppressUserMessage?: boolean
+  /**
+   * Mark this send as issued automatically on the user's behalf (e.g. an
+   * auto-fix prompt). The optimistic local bubble and the persisted message are
+   * flagged `automatic` so the chat renders it in the distinct auto-sent style
+   * (agent avatar + accent border) instead of looking like the user typed it.
+   */
+  automatic?: boolean
+  /**
+   * Mark this send as the answer to the pending `ask_user` question. The most
+   * recent unanswered `ask_user` tool call in the store is resolved in place —
+   * its `output` is set to this answer — so the chosen option stays checked
+   * across remounts (e.g. the discovery→IDE transition) instead of relying on
+   * ephemeral component state that the answer's selection would otherwise lose.
+   * Distinct from {@link suppressUserMessage} (which the post-boot kickoff also
+   * sets) so resolving never misfires on a non-ask_user suppressed send.
+   */
+  askUserAnswer?: boolean
+  /**
+   * Mark an {@link automatic} send as directly requested by the user (e.g. the
+   * editor's "Fix with AI" action, the broken-preview overlay's "Fix with AI"
+   * button) rather than dispatched autonomously by the platform. A user Stop
+   * suppresses autonomous automatic sends until the user re-engages; a
+   * user-initiated one IS that re-engagement — it clears the stop and sends.
+   */
+  userInitiated?: boolean
+  /**
+   * Send on the SIDE CHANNEL: a human-to-human message (e.g. a team note) the
+   * server intercepts before running any agent turn. When the provider supports
+   * `sendSideMessage`, the send goes out IMMEDIATELY on an independent request —
+   * it never queues behind an active turn, never takes over the streaming
+   * state, and never tears down remote-turn tracking (a viewer's note while
+   * watching a teammate's turn must not stop the watching). Falls back to the
+   * normal send path on providers without side-channel support.
+   */
+  sideChannel?: boolean
+  /**
+   * Mark this send as composed through voice dictation — the mic button's
+   * transcript was still present in the composer at submit. The optimistic
+   * bubble and the persisted message are flagged `viaDictation` so the chat
+   * renders a mic badge on the message, live and after a reload.
+   */
+  viaDictation?: boolean
+}
+```
+
+#### `UseChatResult`
+
+Hook result for useChat.
+
+```typescript
+interface UseChatResult {
+  messages: ChatMessage[]
+  isLoading: boolean
+  /**
+   * True while a backend turn for this conversation streams WITHOUT this client
+   * owning the request — a turn started in another tab, by a teammate, or any
+   * server-side continuation. Detected from pushed (broadcast) chat events and
+   * confirmed/cleared against the server's `streaming` history flag, so the Stop
+   * control can stay visible and functional whenever ANY backend turn is live —
+   * not only for sends this hook instance made.
+   */
+  isRemoteStreaming: boolean
+  /**
+   * Tell the hook a pushed (broadcast) chat event arrived for this conversation.
+   * The host (ChatPanel) calls this from its push-channel handler; the hook then
+   * confirms against the server's `streaming` flag and, while a remote turn is
+   * live, keeps `isRemoteStreaming` true until the server reports it finished.
+   */
+  noteRemoteStreamEvent: () => void
+  error: string | null
+  /**
+   * Metadata about a limit-related error, for a contextual call-to-action.
+   * `limitType` names the RULE the backend enforced; `billingAction` names the
+   * REMEDY it resolved (e.g. `add_funds`, `add_payment_method`,
+   * `raise_spend_cap`, `upgrade`, `none`) and is what the button should be
+   * built from — the same limit needs a different button per account.
+   * `upgradeTier` is the plan an upgrade would move to, explicitly `null` when
+   * there is no higher tier. The backend owns these vocabularies, so the
+   * action/tier are plain strings here.
+   */
+  errorMeta: {
+    limitType?: string
+    requiresSignup?: boolean
+    billingAction?: string
+    upgradeTier?: string | null
+  } | null
+  /** Current agent mode — plan (read-only research) or execute (full access). */
+  mode: 'plan' | 'execute'
+  /**
+   * Whether the conversation runs at the provider's fast/priority speed tier
+   * (server-persisted per conversation; hydrated from the history load's
+   * `fastMode` meta field, when the server provides one). Only meaningful for
+   * models that support a fast tier — the server ignores it otherwise.
+   */
+  fastMode: boolean
+  /**
+   * Transient label for a background phase (e.g. the post-response verification
+   * pass — "Type-checking the API", "Linting"), set by `status` stream events.
+   * The UI shows it in place of the spinner's generic rotating messages; `null`
+   * when no such phase is active.
+   */
+  streamingStatus: string | null
+  /**
+   * Commands the executor detached with `run_in_background`, newest last. Each
+   * appears here the moment it starts and is replaced in place when it finishes,
+   * so the UI can show work that outlives the tool call that started it.
+   */
+  backgroundTasks: BackgroundTaskState[]
+  /**
+   * Active 5XX backoff-retry countdown, or `null` when none is pending. After a
+   * backend server error (HTTP 5XX) the hook does NOT surface a terminal error —
+   * it shows this cancelable countdown and, when it elapses, auto-resumes the
+   * turn where the user left off (`resume:true`). `secondsRemaining` ticks down
+   * once per second; `attempt` is the 1-based retry number (capped at 3). 4XX,
+   * limit/quota, and signup-required errors never auto-retry.
+   */
+  retryCountdown: {
+    secondsRemaining: number
+    attempt: number
+  } | null
+  /** Update the local mode state (for instant mode toggle without an AI turn). */
+  setMode: (mode: 'plan' | 'execute') => void
+  /** Update the local fast-mode state (for instant toggle without an AI turn). */
+  setFastMode: (fastMode: boolean) => void
+  sendMessage: (
+    message: string,
+    attachments?: ChatAttachment[],
+    options?: SendMessageOptions,
+  ) => Promise<void>
+  abort: () => void
+  /**
+   * Cancel a pending 5XX auto-retry. Clears the countdown and surfaces the
+   * original error (via `error`) so the user sees why the turn failed.
+   */
+  cancelRetry: () => void
+  clearHistory: () => Promise<void>
+  /** Edit the content of a queued (not yet sent) message. */
+  editQueuedMessage: (msgId: string, newContent: string) => void
+  /** Remove a queued (not yet sent) message from the queue. */
+  deleteQueuedMessage: (msgId: string) => void
+  /** Remove queued auto-fix messages whose content references the given file path. */
+  clearQueuedForFile: (filePath: string) => void
+  /**
+   * Append an inline transcript card (model / mode / skills / custom notice) as a
+   * `role:'system'` card-message in the ONE message store. Used by the host (ChatPanel)
+   * to render a TEAMMATE's broadcast `card` event live — this client's OWN cards arrive
+   * through the stream and are appended internally. De-duped by the server-assigned id.
+   */
+  appendCardMessage: (
+    id: string,
+    timestamp: number,
+    card: NonNullable<ChatMessage['cardEvent']>,
+  ) => void
+  /**
+   * Append a COMPLETE, non-streaming chat message (a `message` stream event — e.g.
+   * a teammate's human-only team note) to the ONE message store. Used by the host
+   * (ChatPanel) to render a TEAMMATE's broadcast `message` event live — this
+   * client's OWN `message` events arrive through the stream and are appended
+   * internally. De-duped by the server-assigned message id.
+   */
+  appendCompleteMessage: (message: ChatMessage) => void
+  /**
+   * Ingest ONE pushed (broadcast) stream frame from a turn running elsewhere —
+   * a teammate's send, another tab, a server-side continuation — into the ONE
+   * message store, through the same content applier as an own SSE stream: text/
+   * thinking deltas, tool events, verification, cards, complete messages, done.
+   * The host (ChatPanel) calls this from its push-channel handler for every
+   * broadcast frame of the OPEN conversation. Own echoes are dropped while a
+   * local send is in flight (the SSE stream is authoritative for the sender);
+   * complete id-carrying items (cards, team notes) always apply, de-duped.
+   */
+  applyRemoteEvent: (event: ChatStreamEvent) => void
+  /**
+   * Reload history and converge the local view on the server transcript (and
+   * re-enter a still-streaming turn). The page-lifecycle events run this
+   * automatically; the host should ALSO call it whenever its chat push channel
+   * (re)connects — a broadcast sent while that socket was down (a teammate's
+   * team note against a backgrounded tab or a slept laptop) is otherwise lost
+   * until the next lifecycle event happens to fire. Cheap when nothing changed:
+   * an identical transcript is never re-applied.
+   */
+  reconcileHistory: () => Promise<void>
 }
 ```
 
@@ -1531,28 +1716,58 @@ interface UseWorkspaceResult {
 }
 ```
 
-#### `WorkspaceProviderProps`
+#### `UseEditorResult`
 
-Props for workspace provider component.
+Hook result for useEditor.
 
 ```typescript
-interface WorkspaceProviderProps extends ProviderProps {
-  provider: WorkspaceProvider
+interface UseEditorResult {
+  tabs: EditorTab[]
+  activeFile: string | null
+  openFile: (file: EditorFile) => void
+  closeFile: (path: string) => void
+  getContent: () => string | null
+  setContent: (path: string, content: string) => void
+  setActiveTab: (path: string) => void
+  mount: EditorProvider['mount']
+  dispose: () => void
+  focus: () => void
+  openDiff: (file: DiffFile) => void
+  closeDiff: () => void
+  pinTab: (path: string) => void
+  addExtraLib: (content: string, filePath: string) => void
+  onFixWithAI: (callback: (request: FixWithAIRequest) => void) => () => void
 }
 ```
 
-### Types
-
-#### `AsyncExtendState`
+#### `UsePreviewResult`
 
-Async-capable extendState function for partial updates.
+Hook result for usePreview.
 
 ```typescript
-type AsyncExtendState<T> = (
-  partial: Partial<T> | ((prev: T) => Partial<T>) | Promise<Partial<T> | ((prev: T) => Partial<T>)>,
-) => void
+interface UsePreviewResult {
+  state: PreviewState
+  setUrl: (url: string) => void
+  refresh: () => void
+  setDevice: (device: DeviceFrame) => void
+  openExternal: () => void
+  /**
+   * Records a navigation the running preview reported via its `molecule:navigate`
+   * message — updates the displayed current location without reloading the iframe.
+   * Pass `isReplace` when the preview REPLACED its current history entry (a
+   * `replaceState` redirect/canonicalization) so the forward stack is preserved
+   * instead of truncated (a `pushState`, the default, truncates forward).
+   */
+  recordNavigation: (url: string, isReplace?: boolean) => void
+  /** Navigates the preview to the previous navigation-history entry (Back). */
+  back: () => void
+  /** Navigates the preview to the next navigation-history entry (Forward). */
+  forward: () => void
+}
 ```
 
+### Types
+
 #### `AsyncSetState`
 
 Async-capable setState function.
@@ -1561,6 +1776,18 @@ Async-capable setState function.
 type AsyncSetState<T> = (value: T | ((prev: T) => T) | Promise<T | ((prev: T) => T)>) => void
 ```
 
+- `value` — The new state value, an updater function receiving previous state, or a Promise resolving to either.
+
+#### `AsyncExtendState`
+
+Async-capable extendState function for partial updates.
+
+```typescript
+type AsyncExtendState<T> = (
+  partial: Partial<T> | ((prev: T) => Partial<T>) | Promise<Partial<T> | ((prev: T) => Partial<T>)>,
+) => void
+```
+
 #### `UseCapacitorAppResult`
 
 Hook return type.
@@ -1581,168 +1808,218 @@ type VerifyPaymentReturnStatus = 'idle' | 'verifying' | 'verified' | 'failed'
 
 ### Functions
 
-#### `AuthProvider(props)`
+#### `useAppState()`
 
-Provider for authentication.
+Tracks whether the app is in the foreground, background, or inactive.
+
+Uses React Native's `AppState` API under the hood. Falls back to
+'active' on platforms where AppState is unavailable.
 
 ```typescript
-function AuthProvider({
-  client,
-  children,
-}: AuthProviderProps<T>): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
+function useAppState(): UseAppStateResult
 ```
 
-- `props` — Component props (see {@link AuthProviderProps}).
+**Returns:** Current app state and whether the app is active.
 
-**Returns:** The rendered auth provider element.
+#### `useBackHandler(handler, options)`
 
-#### `ChatProvider(props)`
+Registers a handler for the Android hardware back button.
 
-Provider for AI chat.
+Return `true` from the handler to prevent the default back behavior,
+or `false` to allow it.
 
 ```typescript
-function ChatProvider({
-  provider,
-  children,
-}: ChatProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
+function useBackHandler(handler: () => boolean, options?: UseBackHandlerOptions): void
 ```
 
-- `props` — Component props (see {@link ChatProviderProps}).
+- `handler` — Callback invoked when the hardware back button is pressed.
+- `options` — Optional configuration.
 
-**Returns:** The rendered chat provider element.
+#### `useKeyboardHeight()`
 
-#### `EditorProvider(props)`
+Tracks soft keyboard visibility and height.
 
-Provider for code editor.
+Uses React Native's `Keyboard` API. Falls back to hidden state
+on platforms where Keyboard is unavailable.
 
 ```typescript
-function EditorProvider({
-  provider,
-  children,
-}: EditorProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
+function useKeyboardHeight(): UseKeyboardHeightResult
 ```
 
-- `props` — Component props (see {@link EditorProviderProps}).
+**Returns:** Current keyboard height and visibility state.
 
-**Returns:** The rendered editor provider element.
+#### `useSafeArea()`
 
-#### `HttpProvider(props)`
+Returns the current safe area insets from `react-native-safe-area-context`.
 
-Provider for HTTP client.
+Must be used within a `SafeAreaProvider`. Falls back to zero insets
+if the context is unavailable.
 
 ```typescript
-function HttpProvider({
-  client,
-  children,
-}: HttpProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
+function useSafeArea(): SafeAreaInsets
 ```
 
-- `props` — Component props (see {@link HttpProviderProps}).
+**Returns:** Safe area insets for the current device.
 
-**Returns:** The rendered HTTP provider element.
+#### `resetAIModelsCache()`
 
-#### `I18nProvider(props)`
+Test-only: drops every cached model list so the next `useAIModels` call
+refetches. Exposed for unit tests; do not call from production code.
 
-Provider for internationalization.
+```typescript
+function resetAIModelsCache(): void
+```
+
+#### `useAIModels(projectId)`
+
+Subscribes to the cached AI model catalog. The first mount of a scope
+triggers a single `GET /ai/models` fetch; subsequent mounts return the
+cached result.
 
 ```typescript
-function I18nProvider({
-  provider,
-  children,
-}: I18nProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
+function useAIModels(projectId?: string): UseAIModelsResult
 ```
 
-- `props` — Component props (see {@link I18nProviderProps}).
+- `projectId` — Optional project scope: includes that project's custom ("bring your own AI") models on servers that support them.
 
-**Returns:** The rendered i18n provider element.
+**Returns:** Models, free-tier model, loading flag, and error.
 
-#### `localOnlyMessages(prev, history)`
+#### `useAuthClient()`
 
-The messages only the local store holds, given a server history: optimistic
-bubbles and session-local cards, minus the optimistic ECHO of a send the
-server already persisted. A local user message carries a local id
-(`user-N`), the server's copy a server id, so ids never match — content does.
-Without this, the dashboard's first prompt (auto-sent by the workspace,
-then merged back in from history by the remote-stream poll) rendered as two
-identical user bubbles in every new project (2026-09-08).
+Hook to access the auth client from context.
+
+Pass the same generics the client was created with —
+`useAuthClient<MyUser, { username: string }>()` — so `register()` accepts
+the app's own fields.
 
 ```typescript
-function localOnlyMessages(prev: ChatMessage[], history: ChatMessage[]): ChatMessage[]
+function useAuthClient(): AuthClient<T, TRegister>
 ```
 
-- `prev` — The store's current messages.
-- `history` — The server's history.
+**Returns:** The auth client from context
 
-**Returns:** The local-only messages to keep after the merged history.
+#### `useAuth(options)`
 
-#### `LoggerProvider(props)`
+Hook for authentication state and actions.
 
-Provider for logging.
+Pass the app's user type — the SAME type used for the auth client and its
+config (`createJWTAuthClient<MyUser>`, `AuthClientConfig<MyUser>`) — so
+`user` and `setSession`/`setUser` are typed for the pages:
+`useAuth<MyUser>()`.
+
+For a sign-in the app runs itself (an OAuth redirect, a custom endpoint that
+already issued the token), call `setSession({ accessToken, user })`: it
+adopts the token and profile atomically and every consumer of this hook sees
+`status: 'authenticated'` at once. `setUser` alone does not sign in.
+
+To create an account, use `const { register } = useAuth<MyUser>()` and
+`await register({ email, password, name })`. Registration returns the auth
+client's `AuthResult<MyUser>`; there is no separate `useRegister` hook.
+
+An app whose API takes its OWN registration fields passes the client's
+second generic here too — `useAuth<MyUser, { username: string }>()` — so
+`register({ email, password, username })` is typed exactly like the client
+call (and `requestBody` receives the same payload). Without it, `register`
+accepts only the base fields.
 
 ```typescript
-function LoggerProvider({
-  provider,
-  children,
-}: LoggerProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
+function useAuth(options?: UseAuthOptions): UseAuthResult<T, TRegister>
 ```
 
-- `props` — Component props (see {@link LoggerProviderProps}).
+- `options` — Hook options
 
-**Returns:** The rendered logger provider element.
+**Returns:** Auth state and action methods
 
-#### `MoleculeProvider(props)`
+#### `useUser()`
 
-Combined provider for all molecule services.
+Hook to get just the authenticated user.
 
-Provides a convenient way to wrap your app with all molecule providers at once.
-Only providers that are passed will be included.
+```typescript
+function useUser(): T | null
+```
+
+**Returns:** The authenticated user or null
+
+#### `useIsAuthenticated()`
+
+Hook to check if user is authenticated.
 
 ```typescript
-function MoleculeProvider({
-  children,
-  state,
-  auth,
-  theme,
-  router,
-  i18n,
-  http,
-  storage,
-  logger,
-  chat,
-  workspace,
-  editor,
-  preview,
-}: MoleculeProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
+function useIsAuthenticated(): boolean
+```
+
+**Returns:** Whether the user is authenticated
+
+#### `useCapacitorApp(options)`
+
+Hook for Capacitor app initialization and state management.
+
+Creates a `CapacitorApp` coordinator on mount, subscribes to state changes,
+and auto-initializes. Cleans up listeners on unmount via `destroy()`.
+
+```typescript
+function useCapacitorApp(options?: CapacitorAppOptions): UseCapacitorAppResult
 ```
 
-- `props` — Component props (see {@link MoleculeProviderProps}) — each service is optional, and ONLY the services passed are provided to the tree.
+- `options` — Capacitor app configuration options
 
-**Returns:** The rendered combined provider element.
+**Returns:** Current app state and an `initialize` function for manual re-initialization
 
-#### `PreviewProvider(props)`
+#### `useChangePassword()`
 
-Provider for live preview.
+Hook for changing password with async state tracking.
 
 ```typescript
-function PreviewProvider({
-  provider,
-  children,
-}: PreviewProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
+function useChangePassword(): UseChangePasswordReturn
 ```
 
-- `props` — Component props (see {@link PreviewProviderProps}).
+**Returns:** Change password state and action
 
-**Returns:** The rendered preview provider element.
+#### `convergeHistory(prev, history)`
 
-#### `resetAIModelsCache()`
+Converge a live store on a fresh server history WITHOUT rewinding anything
+already on screen. This is the ONE place a server transcript is applied to a
+local view — the page-lifecycle/push reconcile, the remote-turn poll, the
+dropped-stream reconcile and the resume poll all go through it, because two
+paths that almost agree is how a message came to vanish and come back
+(reported 2026-09-21).
 
-Test-only: drops every cached model list so the next `useAIModels` call
-refetches. Exposed for unit tests; do not call from production code.
+Per message id the further-along copy wins ({@link messageProgress}); a TIE
+keeps the local copy, so an unchanged transcript returns the same object
+references and a poll neither churns React nor rewinds. Messages only the
+server has are added in the server's order (filling gaps a watcher missed);
+messages only the store has ({@link localOnlyMessages} — an answer still
+carrying its local id, a session-local card, a turn the server has not
+persisted yet) are kept after them.
 
 ```typescript
-function resetAIModelsCache(): void
+function convergeHistory(prev: ChatMessage[], history: ChatMessage[]): ChatMessage[]
+```
+
+- `prev` — The store's current messages.
+- `history` — The messages from the server's history endpoint.
+
+**Returns:** The converged message list.
+
+#### `localOnlyMessages(prev, history)`
+
+The messages only the local store holds, given a server history: optimistic
+bubbles and session-local cards, minus the optimistic ECHO of a send the
+server already persisted. A local user message carries a local id
+(`user-N`), the server's copy a server id, so ids never match — content does.
+Without this, the dashboard's first prompt (auto-sent by the workspace,
+then merged back in from history by the remote-stream poll) rendered as two
+identical user bubbles in every new project (2026-09-08).
+
+```typescript
+function localOnlyMessages(prev: ChatMessage[], history: ChatMessage[]): ChatMessage[]
 ```
 
+- `prev` — The store's current messages.
+- `history` — The server's history.
+
+**Returns:** The local-only messages to keep after the merged history.
+
 #### `resetChatStoresForTests()`
 
 Test-only: clear all conversation stores. The store is module-level (it must
@@ -1753,201 +2030,194 @@ outlive component mounts), so it persists across test cases — reset it in a
 function resetChatStoresForTests(): void
 ```
 
-#### `RouterProvider(props)`
+#### `useChatProvider()`
 
-Provider for routing.
+Access the chat provider from context.
 
 ```typescript
-function RouterProvider({
-  router,
-  children,
-}: RouterProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
+function useChatProvider(): ChatProvider
 ```
 
-- `props` — Component props (see {@link RouterProviderProps}).
+**Returns:** The ChatProvider instance from the nearest ChatContext.
 
-**Returns:** The rendered router provider element.
+#### `useChat(options)`
 
-#### `StateProvider(props)`
+Hook for AI chat with streaming support.
 
-Provider for state management.
+Manages message state, sends messages to the backend, and handles
+SSE streaming responses.
 
 ```typescript
-function StateProvider({
-  provider,
-  children,
-}: StateProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
+function useChat(options: UseChatOptions): UseChatResult
 ```
 
-- `props` — Component props (see {@link StateProviderProps}).
-
-**Returns:** The rendered state provider element.
-
-#### `StorageProvider(props)`
-
-Provider for storage.
-
-```typescript
-function StorageProvider({
-  provider,
-  children,
-}: StorageProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
-```
+- `options` — Chat configuration including endpoint URL, project ID, and whether to load history on mount.
 
-- `props` — Component props (see {@link StorageProviderProps}).
+**Returns:** Chat state and controls: messages, isLoading, error, sendMessage, abort, and clearHistory.
 
-**Returns:** The rendered storage provider element.
+#### `useDevice()`
 
-#### `ThemeProvider(props)`
+Hook for device information.
 
-Provider for theming.
+Uses module-level `getProvider()` — device info is a singleton, not context-provided.
+Device info is static and doesn't change at runtime, so this uses `useMemo`.
 
 ```typescript
-function ThemeProvider({
-  provider,
-  children,
-}: ThemeProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
+function useDevice(): UseDeviceResult
 ```
 
-- `props` — Component props (see {@link ThemeProviderProps}).
-
-**Returns:** The rendered theme provider element.
+**Returns:** Device information and utility methods
 
-#### `useAIModels(projectId)`
+#### `useEditorProvider()`
 
-Subscribes to the cached AI model catalog. The first mount of a scope
-triggers a single `GET /ai/models` fetch; subsequent mounts return the
-cached result.
+Access the editor provider from context.
 
 ```typescript
-function useAIModels(projectId?: string): UseAIModelsResult
+function useEditorProvider(): EditorProvider
 ```
 
-- `projectId` — Optional project scope: includes that project's custom ("bring your own AI") models on servers that support them.
-
-**Returns:** Models, free-tier model, loading flag, and error.
-
-#### `useAppState()`
+**Returns:** The EditorProvider instance from the nearest EditorContext.
 
-Tracks whether the app is in the foreground, background, or inactive.
+#### `useEditor()`
 
-Uses React Native's `AppState` API under the hood. Falls back to
-'active' on platforms where AppState is unavailable.
+Hook for code editor management.
 
 ```typescript
-function useAppState(): UseAppStateResult
+function useEditor(): UseEditorResult
 ```
 
-**Returns:** Current app state and whether the app is active.
+**Returns:** Editor state and controls: tabs, activeFile, openFile, closeFile, getContent, setContent, setActiveTab, mount, dispose, and focus.
 
-#### `useAuth(options)`
+#### `useForm(options)`
 
-Hook for authentication state and actions.
+Hook for form state management.
+
+Creates its controller through the bonded forms provider, so a React app
+wires a form library once (`setProvider` from `@molecule/app-forms`) and
+every form picks it up. Passing `createForm` overrides that for one form.
 
 ```typescript
-function useAuth(options?: UseAuthOptions): UseAuthResult<T>
+function useForm(options?: UseFormOptions<T>): UseFormResult<T>
 ```
 
-- `options` — Hook options
+- `options` — Form options. `defaultValues`, `mode` and the form-level `validate` are forwarded to the provider; omit the options entirely for a form whose fields are registered with their own defaults.
 
-**Returns:** Auth state and action methods
+**Returns:** Form state and methods
 
-#### `useAuthClient()`
+#### `useWatch(form, name)`
 
-Hook to access the auth client from context.
+Hook to watch a specific field value.
 
 ```typescript
-function useAuthClient(): AuthClient<T>
+function useWatch(form: FormController<T>, name: K): T[K]
 ```
 
-**Returns:** The auth client from context
+- `form` — Form controller
+- `name` — Field name to watch
 
-#### `useBackHandler(handler, options)`
+**Returns:** Current field value
 
-Registers a handler for the Android hardware back button.
+#### `useFieldState(form, name)`
 
-Return `true` from the handler to prevent the default back behavior,
-or `false` to allow it.
+Hook to get field-level state.
 
 ```typescript
-function useBackHandler(handler: () => boolean, options?: UseBackHandlerOptions): void
+function useFieldState(form: FormController<T>, name: keyof T): FieldState<T[keyof T]>
 ```
 
-- `handler` — Callback invoked when the hardware back button is pressed.
-- `options` — Optional configuration.
+- `form` — Form controller
+- `name` — Field name
 
-#### `useCapacitorApp(options)`
+**Returns:** Field state (value, error, touched, dirty, valid)
 
-Hook for Capacitor app initialization and state management.
+#### `useHttpClient()`
 
-Creates a `CapacitorApp` coordinator on mount, subscribes to state changes,
-and auto-initializes. Cleans up listeners on unmount via `destroy()`.
+Hook to access the HTTP client from context.
 
 ```typescript
-function useCapacitorApp(options?: CapacitorAppOptions): UseCapacitorAppResult
+function useHttpClient(): HttpClient
 ```
 
-- `options` — Capacitor app configuration options
+**Returns:** The HTTP client from context
 
-**Returns:** Current app state and an `initialize` function for manual re-initialization
+#### `useHttp(method, url, options)`
 
-#### `useChangePassword()`
+Hook for making HTTP requests with state management.
 
-Hook for changing password with async state tracking.
+`execute` keeps one identity while `method`, `url` and the HTTP client stay the
+same — across the hook's own loading/data updates, parent rerenders, and inline
+options or callbacks — so `useEffect(() => { void execute() }, [execute])`
+runs once per request target instead of looping. The current headers, body,
+`signal` and callbacks are read when `execute` is called, so a later manual
+call always sends what the latest committed render passed. Changing `method`, `url` or
+the client does replace `execute` (it selects a different request) and
+re-runs such an effect.
 
 ```typescript
-function useChangePassword(): UseChangePasswordReturn
+function useHttp(
+  method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE',
+  url: string,
+  options?: UseHttpOptions<T>,
+): UseHttpResult<T>
 ```
 
-**Returns:** Change password state and action
+- `method` — HTTP method
+- `url` — Request URL
+- `options` — Request options, read at call time
 
-#### `useChat(options)`
+**Returns:** Request state and execute function
 
-Hook for AI chat with streaming support.
+#### `useGet(url, options)`
 
-Manages message state, sends messages to the backend, and handles
-SSE streaming responses.
+Hook for GET requests.
 
 ```typescript
-function useChat(options: UseChatOptions): UseChatResult
+function useGet(url: string, options?: UseHttpOptions<T>): UseHttpResult<T>
 ```
 
-- `options` — Chat configuration including endpoint URL, project ID, and whether to load history on mount.
+- `url` — Request URL to fetch from.
+- `options` — HTTP request options including callbacks and request config.
 
-**Returns:** Chat state and controls: messages, isLoading, error, sendMessage, abort, and clearHistory.
+**Returns:** Request state (data, loading, error) and controls (execute, reset).
 
-#### `useChatProvider()`
+#### `usePost(url, options)`
 
-Access the chat provider from context.
+Hook for POST requests.
 
 ```typescript
-function useChatProvider(): ChatProvider
+function usePost(url: string, options?: UseHttpOptions<T>): UseHttpResult<T>
 ```
 
-**Returns:** The ChatProvider instance from the nearest ChatContext.
+- `url` — Request URL to post to.
+- `options` — HTTP request options including body data and callbacks.
 
-#### `useChildLogger(parentName, context)`
+**Returns:** Request state (data, loading, error) and controls (execute, reset).
 
-Hook to create a child logger with additional context.
+#### `usePut(url, options)`
+
+Hook for PUT requests.
 
 ```typescript
-function useChildLogger(parentName: string, context: Record<string, unknown>): Logger
+function usePut(url: string, options?: UseHttpOptions<T>): UseHttpResult<T>
 ```
 
-- `parentName` — Parent logger name
-- `context` — Additional context to include in logs
+- `url` — Request URL to send the PUT request to.
+- `options` — HTTP request options including body data and callbacks.
 
-**Returns:** Child logger instance
+**Returns:** Request state (data, loading, error) and controls (execute, reset).
 
-#### `useCurrentTheme()`
+#### `usePatch(url, options)`
 
-Hook to get just the current theme object.
+Hook for PATCH requests.
 
 ```typescript
-function useCurrentTheme(): Theme
+function usePatch(url: string, options?: UseHttpOptions<T>): UseHttpResult<T>
 ```
 
-**Returns:** The current theme
+- `url` — Request URL to send the PATCH request to.
+- `options` — HTTP request options including partial body data and callbacks.
+
+**Returns:** Request state (data, loading, error) and controls (execute, reset).
 
 #### `useDelete(url, options)`
 
@@ -1962,189 +2232,198 @@ function useDelete(url: string, options?: UseHttpOptions<T>): UseHttpResult<T>
 
 **Returns:** Request state (data, loading, error) and controls (execute, reset).
 
-#### `useDevice()`
-
-Hook for device information.
+#### `useLoggerProvider()`
 
-Uses module-level `getProvider()` — device info is a singleton, not context-provided.
-Device info is static and doesn't change at runtime, so this uses `useMemo`.
+Hook to access the logger provider from context.
 
 ```typescript
-function useDevice(): UseDeviceResult
+function useLoggerProvider(): LoggerProvider
 ```
 
-**Returns:** Device information and utility methods
+**Returns:** The logger provider from context
 
-#### `useDirection()`
+#### `useLogger(name, config)`
 
-Hook to get the text direction.
+Hook to get a logger instance.
 
 ```typescript
-function useDirection(): 'ltr' | 'rtl'
+function useLogger(name: string, config?: Partial<LoggerConfig>): Logger
 ```
 
-**Returns:** The text direction ('ltr' or 'rtl')
-
-#### `useEditor()`
-
-Hook for code editor management.
-
-```typescript
-function useEditor(): UseEditorResult
-```
+- `name` — Logger name (usually component or module name)
+- `config` — Optional logger configuration
 
-**Returns:** Editor state and controls: tabs, activeFile, openFile, closeFile, getContent, setContent, setActiveTab, mount, dispose, and focus.
+**Returns:** Logger instance
 
-#### `useEditorProvider()`
+#### `useRootLogger()`
 
-Access the editor provider from context.
+Hook to get the root logger.
 
 ```typescript
-function useEditorProvider(): EditorProvider
+function useRootLogger(): Logger
 ```
 
-**Returns:** The EditorProvider instance from the nearest EditorContext.
+**Returns:** Root logger instance
 
-#### `useFieldState(form, name)`
+#### `useChildLogger(parentName, context)`
 
-Hook to get field-level state.
+Hook to create a child logger with additional context.
 
 ```typescript
-function useFieldState(form: FormController<T>, name: keyof T): FieldState<T[keyof T]>
+function useChildLogger(parentName: string, context: Record<string, unknown>): Logger
 ```
 
-- `form` — Form controller
-- `name` — Field name
+- `parentName` — Parent logger name
+- `context` — Additional context to include in logs
 
-**Returns:** Field state (value, error, touched, dirty, valid)
+**Returns:** Child logger instance
 
-#### `useForm(options)`
+#### `useLogin()`
 
-Hook for form state management.
+Hook for login with async state tracking.
+Registration is available through `const { register } = useAuth()`;
+call `register({ email, password, name })` to create an account. There is
+no separate `useRegister` hook. Use `usePromise(register)` when the form
+needs the same pending/error tracking as this login hook.
 
 ```typescript
-function useForm(options: UseFormOptions<T>): UseFormResult<T>
+function useLogin(): UseLoginReturn<T>
 ```
 
-- `options` — Form options including createForm from a forms provider
+**Returns:** Login state and action
 
-**Returns:** Form state and methods
+#### `useOAuth(config)`
 
-#### `useGet(url, options)`
+Hook for OAuth authentication.
 
-Hook for GET requests.
+Reads OAuth configuration from the provided config and provides
+helpers to build OAuth URLs and start a login (full-page or popup).
+Automatically handles OAuth callbacks by detecting `code` and `state`
+URL parameters and exchanging them for a session — and, when the callback is
+running inside a popup we opened, relaying the result to the opener instead.
 
 ```typescript
-function useGet(url: string, options?: UseHttpOptions<T>): UseHttpResult<T>
+function useOAuth(config?: {
+  baseURL?: string
+  oauthProviders?: string[]
+  oauthEndpoint?: string
+  loginEndpoint?: string
+  onSuccess?: () => void
+  onError?: (error: string) => void
+}): UseOAuthReturn
 ```
 
-- `url` — Request URL to fetch from.
-- `options` — HTTP request options including callbacks and request config.
+- `config` — Optional OAuth configuration override.
+- `config.baseURL` — Base URL for the API server (e.g. "https://api.example.com").
+- `config.oauthProviders` — List of supported OAuth provider names (e.g. ["google", "github"]).
+- `config.oauthEndpoint` — Path prefix for OAuth routes (defaults to "/oauth").
+- `config.loginEndpoint` — Path for the OAuth login POST endpoint (defaults to "/users/log-in/oauth").
+- `config.onSuccess` — Callback after successful OAuth login.
+- `config.onError` — Callback on OAuth login failure.
 
-**Returns:** Request state (data, loading, error) and controls (execute, reset).
+**Returns:** OAuth helpers: providers, getOAuthUrl, redirect, and loginViaPopup.
 
-#### `useHttp(method, url, options)`
+#### `usePasswordReset()`
 
-Hook for making HTTP requests with state management.
+Hook for password reset flow with async state tracking.
+
+Provides separate tracking for the request and confirm steps.
 
 ```typescript
-function useHttp(
-  method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE',
-  url: string,
-  options?: UseHttpOptions<T>,
-): UseHttpResult<T>
+function usePasswordReset(): UsePasswordResetReturn
 ```
 
-- `method` — HTTP method
-- `url` — Request URL
-- `options` — Request options
+**Returns:** Password reset state and actions
 
-**Returns:** Request state and execute function
+#### `usePlatform()`
 
-#### `useHttpClient()`
+Hook for platform detection.
 
-Hook to access the HTTP client from context.
+Uses module-level functions — platform is a singleton, not context-provided.
+Platform info is static and doesn't change at runtime, so this uses `useMemo`.
 
 ```typescript
-function useHttpClient(): HttpClient
+function usePlatform(): UsePlatformResult
 ```
 
-**Returns:** The HTTP client from context
-
-#### `useI18nError(error)`
+**Returns:** Platform information and utility methods
 
-Translates an error at render time so the displayed message updates automatically
-when the locale changes.
+#### `usePreviewProvider()`
 
-**Always use this hook to display errors in React components** — accessing
-`error.message` directly bypasses re-translation and leaves stale text after a
-locale switch. If `error` is an `I18nError` (thrown via `throw new I18nError(key)`),
-its key is translated using the current locale. For plain `Error` instances,
-`error.message` is returned unchanged.
+Access the preview provider from context.
 
 ```typescript
-function useI18nError(error: Error | null | undefined): string | null
+function usePreviewProvider(): PreviewProvider
 ```
 
-- `error` — The error to translate, or `null`/`undefined`.
-
-**Returns:** The translated error string, or `null` if no error.
+**Returns:** The PreviewProvider instance from the nearest PreviewContext.
 
-#### `useI18nProvider()`
+#### `usePreview()`
 
-Hook to access the i18n provider from context.
+Hook for live preview management.
 
 ```typescript
-function useI18nProvider(): I18nProvider
+function usePreview(): UsePreviewResult
 ```
 
-**Returns:** The i18n provider from context
+**Returns:** Preview state and controls: state (url, isLoading, device, error, isConnected), setUrl, refresh, setDevice, and openExternal.
 
-#### `useIsActive(path, exact)`
+#### `useProfileForm(options)`
 
-Hook to check if a path is active.
+Owns load → edit → submit → publish for the signed-in user's profile.
+
+Same-account background updates refresh untouched fields but preserve dirty
+controls. Session ownership comes from the auth client, independently of mutable
+profile fields; an explicit getIdentity adds the caller's identity check.
+Submission snapshots the registered values before asynchronous
+validation, sends only changed fields through `toPatch`, and uses the auth
+client's configured updateProfile transport. The saved server response becomes
+the clean baseline; edits made while saving remain dirty. No request is made
+for a patch with no fields. A failed request retains the edits and shared user.
 
 ```typescript
-function useIsActive(path: string, exact?: boolean): boolean
+function useProfileForm(
+  options: UseProfileFormOptions<TUser, TValues>,
+): UseProfileFormResult<TUser, TValues>
 ```
 
-- `path` — The path to check
-- `exact` — Whether to match exactly (default: false)
+- `options` — Controlled defaults, identity and wire adapters, optional cache/navigation callback.
 
-**Returns:** Whether the path is active
+**Returns:** Form state, typed control bindings, native submit binding and save error.
 
-#### `useIsAuthenticated()`
+#### `usePush(options)`
 
-Hook to check if user is authenticated.
+Hook for push notification state and actions.
+
+Uses module-level `getProvider()` — push is a singleton, not context-provided.
 
 ```typescript
-function useIsAuthenticated(): boolean
+function usePush(options?: UsePushOptions): UsePushResult
 ```
 
-**Returns:** Whether the user is authenticated
+- `options` — Hook options
 
-#### `useKeyboardHeight()`
+**Returns:** Push notification state and action methods
 
-Tracks soft keyboard visibility and height.
+#### `useRouterInstance()`
 
-Uses React Native's `Keyboard` API. Falls back to hidden state
-on platforms where Keyboard is unavailable.
+Hook to access the router from context.
 
 ```typescript
-function useKeyboardHeight(): UseKeyboardHeightResult
+function useRouterInstance(): Router
 ```
 
-**Returns:** Current keyboard height and visibility state.
+**Returns:** The router from context
 
-#### `useLocale()`
+#### `useRouter()`
 
-Hook to get the current locale.
+Hook for routing state and actions.
 
 ```typescript
-function useLocale(): string
+function useRouter(): UseRouterResult
 ```
 
-**Returns:** The current locale code
+**Returns:** Router state and navigation methods
 
 #### `useLocation()`
 
@@ -2156,520 +2435,574 @@ function useLocation(): RouteLocation
 
 **Returns:** The current route location
 
-#### `useLogger(name, config)`
+#### `useParams()`
 
-Hook to get a logger instance.
+Hook to get route parameters.
 
 ```typescript
-function useLogger(name: string, config?: Partial<LoggerConfig>): Logger
+function useParams(): T
 ```
 
-- `name` — Logger name (usually component or module name)
-- `config` — Optional logger configuration
-
-**Returns:** Logger instance
+**Returns:** The current route parameters
 
-#### `useLoggerProvider()`
+#### `useQuery()`
 
-Hook to access the logger provider from context.
+Hook to get query parameters.
 
 ```typescript
-function useLoggerProvider(): LoggerProvider
+function useQuery(): T
 ```
 
-**Returns:** The logger provider from context
+**Returns:** The current query parameters
 
-#### `useLogin()`
+#### `useNavigate()`
 
-Hook for login with async state tracking.
+Hook to get the navigate function.
 
 ```typescript
-function useLogin(): UseLoginReturn<T>
+function useNavigate(): (path: string, options?: NavigateOptions) => void
 ```
 
-**Returns:** Login state and action
+**Returns:** The navigate function
 
-#### `useNavigate()`
+#### `useIsActive(path, exact)`
 
-Hook to get the navigate function.
+Hook to check if a path is active.
 
 ```typescript
-function useNavigate(): (path: string, options?: NavigateOptions) => void
+function useIsActive(path: string, exact?: boolean): boolean
 ```
 
-**Returns:** The navigate function
+- `path` — The path to check
+- `exact` — Whether to match exactly (default: false)
 
-#### `useOAuth(config)`
+**Returns:** Whether the path is active
 
-Hook for OAuth authentication.
+#### `useSignup()`
 
-Reads OAuth configuration from the provided config and provides
-helpers to build OAuth URLs and start a login (full-page or popup).
-Automatically handles OAuth callbacks by detecting `code` and `state`
-URL parameters and exchanging them for a session — and, when the callback is
-running inside a popup we opened, relaying the result to the opener instead.
+Hook for user registration with async state tracking.
 
 ```typescript
-function useOAuth(config?: {
-  baseURL?: string
-  oauthProviders?: string[]
-  oauthEndpoint?: string
-  loginEndpoint?: string
-  onSuccess?: () => void
-  onError?: (error: string) => void
-}): UseOAuthReturn
+function useSignup(): UseSignupReturn<T, TRegister>
 ```
 
-- `config` — Optional OAuth configuration override.
-- `config.baseURL` — Base URL for the API server (e.g. "https://api.example.com").
-- `config.oauthProviders` — List of supported OAuth provider names (e.g. ["google", "github"]).
-- `config.oauthEndpoint` — Path prefix for OAuth routes (defaults to "/oauth").
-- `config.loginEndpoint` — Path for the OAuth login POST endpoint (defaults to "/users/log-in/oauth").
-- `config.onSuccess` — Callback after successful OAuth login.
-- `config.onError` — Callback on OAuth login failure.
+**Returns:** Signup state and action
 
-**Returns:** OAuth helpers: providers, getOAuthUrl, redirect, and loginViaPopup.
+#### `useStorageProvider()`
 
-#### `useParams()`
+Hook to access the storage provider from context.
 
-Hook to get route parameters.
+```typescript
+function useStorageProvider(): StorageProvider
+```
+
+**Returns:** The storage provider from context
+
+#### `useStorageValue(key, options)`
+
+Hook to manage a single storage value with React state sync.
 
 ```typescript
-function useParams(): T
+function useStorageValue(key: string, options?: UseStorageValueOptions<T>): UseStorageValueResult<T>
 ```
 
-**Returns:** The current route parameters
+- `key` — Storage key
+- `options` — Hook options
 
-#### `usePasswordReset()`
+**Returns:** Storage value state (value, loading, error) and mutators (setValue, removeValue).
 
-Hook for password reset flow with async state tracking.
+#### `useStorage()`
 
-Provides separate tracking for the request and confirm steps.
+Hook for simple storage operations without React state sync.
 
 ```typescript
-function usePasswordReset(): UsePasswordResetReturn
+function useStorage(): {
+  get: <T>(key: string) => Promise<T | null>
+  set: <T>(key: string, value: T) => Promise<void>
+  remove: (key: string) => Promise<void>
+  clear: () => Promise<void>
+  keys: () => Promise<string[]>
+}
 ```
 
-**Returns:** Password reset state and actions
+**Returns:** Storage operation methods
 
-#### `usePatch(url, options)`
+#### `useStateProvider()`
 
-Hook for PATCH requests.
+Hook to access the state provider from context.
+
+The context comes from `<StateProvider provider={…}>` or from
+`<MoleculeProvider>` — which supplies the provider bonded under
+`@molecule/app-state` by default, so a scaffolded app needs no `state` prop.
+
+Only hooks that read the context call this; `useStore(store)` takes its store
+as an argument and works with no provider at all.
 
 ```typescript
-function usePatch(url: string, options?: UseHttpOptions<T>): UseHttpResult<T>
+function useStateProvider(): StateProvider
 ```
 
-- `url` — Request URL to send the PATCH request to.
-- `options` — HTTP request options including partial body data and callbacks.
+**Returns:** The state provider from context
+
+#### `useStore(store, options)`
+
+Hook to subscribe to a store with optional selector and equality function.
+
+The store is the argument, so this hook needs NO `StateProvider`: it reads
+`store.getState()` and subscribes with `store.subscribe()`, and never touches
+the state context. A store minted outside the `state` bond — the direct
+`createStoreWithActions()` / `createStore()` a provider package exports — is
+therefore as valid here as one `@molecule/app-state`'s `createStore()` made.
+
+```typescript
+function useStore(store: Store<T>, options?: UseStoreOptions<T, S>): S
+```
 
-**Returns:** Request state (data, loading, error) and controls (execute, reset).
+- `store` — The store to subscribe to
+- `options` — Hook options (selector, equalityFn)
 
-#### `usePlatform()`
+**Returns:** The selected state
 
-Hook for platform detection.
+#### `useSetStore(store)`
 
-Uses module-level functions — platform is a singleton, not context-provided.
-Platform info is static and doesn't change at runtime, so this uses `useMemo`.
+Hook to get the store's setState function.
 
 ```typescript
-function usePlatform(): UsePlatformResult
+function useSetStore(store: Store<T>): (partial: Partial<T> | ((state: T) => Partial<T>)) => void
 ```
 
-**Returns:** Platform information and utility methods
+- `store` — The store to get setState from
 
-#### `usePost(url, options)`
+**Returns:** The setState function
 
-Hook for POST requests.
+#### `useStoreAction(store, action)`
+
+Hook to create a bound action for a store.
 
 ```typescript
-function usePost(url: string, options?: UseHttpOptions<T>): UseHttpResult<T>
+function useStoreAction(
+  store: Store<T>,
+  action: (setState: Store<T>['setState'], getState: Store<T>['getState']) => (...args: Args) => R,
+): (...args: Args) => R
 ```
 
-- `url` — Request URL to post to.
-- `options` — HTTP request options including body data and callbacks.
+- `store` — The store to bind to
+- `action` — The action function that receives setState and getState
 
-**Returns:** Request state (data, loading, error) and controls (execute, reset).
+**Returns:** A bound action function
 
-#### `usePreview()`
+#### `useThemeProvider()`
 
-Hook for live preview management.
+Hook to access the theme provider from context.
 
 ```typescript
-function usePreview(): UsePreviewResult
+function useThemeProvider(): ThemeProvider
 ```
 
-**Returns:** Preview state and controls: state (url, isLoading, device, error, isConnected), setUrl, refresh, setDevice, and openExternal.
+**Returns:** The theme provider from context
 
-#### `usePreviewProvider()`
+#### `useTheme()`
 
-Access the preview provider from context.
+Hook for theme state and actions.
 
 ```typescript
-function usePreviewProvider(): PreviewProvider
+function useTheme(): UseThemeResult
 ```
 
-**Returns:** The PreviewProvider instance from the nearest PreviewContext.
-
-#### `usePush(options)`
+**Returns:** Theme state and actions
 
-Hook for push notification state and actions.
+#### `useCurrentTheme()`
 
-Uses module-level `getProvider()` — push is a singleton, not context-provided.
+Hook to get just the current theme object.
 
 ```typescript
-function usePush(options?: UsePushOptions): UsePushResult
+function useCurrentTheme(): Theme
 ```
 
-- `options` — Hook options
-
-**Returns:** Push notification state and action methods
+**Returns:** The current theme
 
-#### `usePut(url, options)`
+#### `useThemeMode()`
 
-Hook for PUT requests.
+Hook to get just the theme mode (light/dark).
 
 ```typescript
-function usePut(url: string, options?: UseHttpOptions<T>): UseHttpResult<T>
+function useThemeMode(): 'light' | 'dark'
 ```
 
-- `url` — Request URL to send the PUT request to.
-- `options` — HTTP request options including body data and callbacks.
-
-**Returns:** Request state (data, loading, error) and controls (execute, reset).
+**Returns:** The current theme mode
 
-#### `useQuery()`
+#### `useThemeColors()`
 
-Hook to get query parameters.
+Hook to get theme colors.
 
 ```typescript
-function useQuery(): T
+function useThemeColors(): ThemeColors
 ```
 
-**Returns:** The current query parameters
+**Returns:** The current theme colors
 
-#### `useRootLogger()`
+#### `useI18nProvider()`
 
-Hook to get the root logger.
+Hook to access the i18n provider from context.
 
 ```typescript
-function useRootLogger(): Logger
+function useI18nProvider(): I18nProvider
 ```
 
-**Returns:** Root logger instance
+**Returns:** The i18n provider from context
 
-#### `useRouter()`
+#### `useTranslation()`
 
-Hook for routing state and actions.
+Hook for internationalization.
 
 ```typescript
-function useRouter(): UseRouterResult
+function useTranslation(): UseTranslationResult
 ```
 
-**Returns:** Router state and navigation methods
+**Returns:** Translation function and locale management
 
-#### `useRouterInstance()`
+#### `useT()`
 
-Hook to access the router from context.
+Hook to get just the translation function.
 
 ```typescript
-function useRouterInstance(): Router
+function useT(): (
+  key: string,
+  values?: InterpolationValues,
+  options?: { defaultValue?: string; count?: number },
+) => string
 ```
 
-**Returns:** The router from context
-
-#### `useSafeArea()`
+**Returns:** The translation function
 
-Returns the current safe area insets from `react-native-safe-area-context`.
+#### `useLocale()`
 
-Must be used within a `SafeAreaProvider`. Falls back to zero insets
-if the context is unavailable.
+Hook to get the current locale.
 
 ```typescript
-function useSafeArea(): SafeAreaInsets
+function useLocale(): string
 ```
 
-**Returns:** Safe area insets for the current device.
+**Returns:** The current locale code
 
-#### `useSetStore(store)`
+#### `useDirection()`
 
-Hook to get the store's setState function.
+Hook to get the text direction.
 
 ```typescript
-function useSetStore(store: Store<T>): (partial: Partial<T> | ((state: T) => Partial<T>)) => void
+function useDirection(): 'ltr' | 'rtl'
 ```
 
-- `store` — The store to get setState from
+**Returns:** The text direction ('ltr' or 'rtl')
 
-**Returns:** The setState function
+#### `useI18nError(error)`
 
-#### `useSignup()`
+Translates an error at render time so the displayed message updates automatically
+when the locale changes.
 
-Hook for user registration with async state tracking.
+**Always use this hook to display errors in React components** — accessing
+`error.message` directly bypasses re-translation and leaves stale text after a
+locale switch. If `error` is an `I18nError` (thrown via `throw new I18nError(key)`),
+its key is translated using the current locale. For plain `Error` instances,
+`error.message` is returned unchanged.
 
 ```typescript
-function useSignup(): UseSignupReturn<T>
+function useI18nError(error: Error | null | undefined): string | null
 ```
 
-**Returns:** Signup state and action
-
-#### `useStateProvider()`
+- `error` — The error to translate, or `null`/`undefined`.
 
-Hook to access the state provider from context.
+**Returns:** The translated error string, or `null` if no error.
 
-```typescript
-function useStateProvider(): StateProvider
-```
+#### `useVerifyPaymentReturn(options)`
 
-**Returns:** The state provider from context
+Reads the payment id a provider put in the return URL and confirms the
+purchase server-side with `POST /users/:id/verify-payment/:provider`.
 
-#### `useStorage()`
+**This is why a hosted checkout returns the buyer to the APP and not the
+API.** Session cookies are host-only on the app's origin, so a top-level
+redirect from the provider straight to an authenticated API callback on a
+different host arrives with NO credentials — it answers 401 and the paid plan
+is never granted. The request this hook makes is a same-origin call from a
+loaded app page, so the credentials apply. It waits for auth to hydrate
+first: after the redirect the page is a cold load, and the session is
+restored from the httpOnly cookie via `GET /users/me`.
 
-Hook for simple storage operations without React state sync.
+Verification is idempotent server-side (first-claim-wins on the transaction),
+and this hook additionally runs at most once per transaction id per page.
+Safe on pages that are also reached normally: with no id in the URL it stays
+`idle` and issues no request.
 
 ```typescript
-function useStorage(): {
-  get: <T>(key: string) => Promise<T | null>
-  set: <T>(key: string, value: T) => Promise<void>
-  remove: (key: string) => Promise<void>
-  clear: () => Promise<void>
-  keys: () => Promise<string[]>
-}
+function useVerifyPaymentReturn(
+  options?: UseVerifyPaymentReturnOptions,
+): UseVerifyPaymentReturnResult
 ```
 
-**Returns:** Storage operation methods
+- `options` — Provider fallback + lifecycle callbacks (see {@link UseVerifyPaymentReturnOptions}).
 
-#### `useStorageProvider()`
+**Returns:** The verification state (see {@link UseVerifyPaymentReturnResult}).
 
-Hook to access the storage provider from context.
+#### `useVersion()`
+
+Hook for version state and update actions.
+
+Uses module-level `getProvider()` — version is a singleton, not context-provided.
 
 ```typescript
-function useStorageProvider(): StorageProvider
+function useVersion(): UseVersionResult
 ```
 
-**Returns:** The storage provider from context
+**Returns:** Version state and action methods
 
-#### `useStorageValue(key, options)`
+#### `useWorkspaceProvider()`
 
-Hook to manage a single storage value with React state sync.
+Access the workspace provider from context.
 
 ```typescript
-function useStorageValue(key: string, options?: UseStorageValueOptions<T>): UseStorageValueResult<T>
+function useWorkspaceProvider(): WorkspaceProvider
 ```
 
-- `key` — Storage key
-- `options` — Hook options
-
-**Returns:** Storage value state (value, loading, error) and mutators (setValue, removeValue).
+**Returns:** The result.
 
-#### `useStore(store, options)`
+#### `useWorkspace()`
 
-Hook to subscribe to a store with optional selector and equality function.
+Hook for IDE workspace layout management.
 
 ```typescript
-function useStore(store: Store<T>, options?: UseStoreOptions<T, S>): S
+function useWorkspace(): UseWorkspaceResult
 ```
 
-- `store` — The store to subscribe to
-- `options` — Hook options (selector, equalityFn)
-
-**Returns:** The selected state
+**Returns:** The workspace state and management methods.
 
-#### `useStoreAction(store, action)`
+#### `StateProvider(props)`
 
-Hook to create a bound action for a store.
+Provider for state management.
 
 ```typescript
-function useStoreAction(
-  store: Store<T>,
-  action: (setState: Store<T>['setState'], getState: Store<T>['getState']) => (...args: Args) => R,
-): (...args: Args) => R
+function StateProvider({
+  provider,
+  children,
+}: StateProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
 ```
 
-- `store` — The store to bind to
-- `action` — The action function that receives setState and getState
+- `props` — Component props (see {@link StateProviderProps}).
 
-**Returns:** A bound action function
+**Returns:** The rendered state provider element.
 
-#### `useT()`
+#### `AuthProvider(props)`
 
-Hook to get just the translation function.
+Provider for authentication.
 
 ```typescript
-function useT(): (
-  key: string,
-  values?: InterpolationValues,
-  options?: { defaultValue?: string; count?: number },
-) => string
+function AuthProvider({
+  client,
+  children,
+}: AuthProviderProps<T>): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
 ```
 
-**Returns:** The translation function
+- `props` — Component props (see {@link AuthProviderProps}).
 
-#### `useTheme()`
+**Returns:** The rendered auth provider element.
 
-Hook for theme state and actions.
+#### `ThemeProvider(props)`
+
+Provider for theming.
 
 ```typescript
-function useTheme(): UseThemeResult
+function ThemeProvider({
+  provider,
+  children,
+}: ThemeProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
 ```
 
-**Returns:** Theme state and actions
+- `props` — Component props (see {@link ThemeProviderProps}).
+
+**Returns:** The rendered theme provider element.
 
-#### `useThemeColors()`
+#### `RouterProvider(props)`
 
-Hook to get theme colors.
+Provider for routing.
 
 ```typescript
-function useThemeColors(): ThemeColors
+function RouterProvider({
+  router,
+  children,
+}: RouterProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
 ```
 
-**Returns:** The current theme colors
+- `props` — Component props (see {@link RouterProviderProps}).
 
-#### `useThemeMode()`
+**Returns:** The rendered router provider element.
 
-Hook to get just the theme mode (light/dark).
+#### `I18nProvider(props)`
+
+Provider for internationalization.
 
 ```typescript
-function useThemeMode(): 'light' | 'dark'
+function I18nProvider({
+  provider,
+  children,
+}: I18nProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
 ```
 
-**Returns:** The current theme mode
+- `props` — Component props (see {@link I18nProviderProps}).
 
-#### `useThemeProvider()`
+**Returns:** The rendered i18n provider element.
 
-Hook to access the theme provider from context.
+#### `HttpProvider(props)`
+
+Provider for HTTP client.
 
 ```typescript
-function useThemeProvider(): ThemeProvider
+function HttpProvider({
+  client,
+  children,
+}: HttpProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
 ```
 
-**Returns:** The theme provider from context
+- `props` — Component props (see {@link HttpProviderProps}).
 
-#### `useTranslation()`
+**Returns:** The rendered HTTP provider element.
 
-Hook for internationalization.
+#### `StorageProvider(props)`
+
+Provider for storage.
 
 ```typescript
-function useTranslation(): UseTranslationResult
+function StorageProvider({
+  provider,
+  children,
+}: StorageProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
 ```
 
-**Returns:** Translation function and locale management
+- `props` — Component props (see {@link StorageProviderProps}).
 
-#### `useUser()`
+**Returns:** The rendered storage provider element.
 
-Hook to get just the authenticated user.
+#### `LoggerProvider(props)`
+
+Provider for logging.
 
 ```typescript
-function useUser(): T | null
+function LoggerProvider({
+  provider,
+  children,
+}: LoggerProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
 ```
 
-**Returns:** The authenticated user or null
-
-#### `useVerifyPaymentReturn(options)`
+- `props` — Component props (see {@link LoggerProviderProps}).
 
-Reads the payment id a provider put in the return URL and confirms the
-purchase server-side with `POST /users/:id/verify-payment/:provider`.
+**Returns:** The rendered logger provider element.
 
-**This is why a hosted checkout returns the buyer to the APP and not the
-API.** Session cookies are host-only on the app's origin, so a top-level
-redirect from the provider straight to an authenticated API callback on a
-different host arrives with NO credentials — it answers 401 and the paid plan
-is never granted. The request this hook makes is a same-origin call from a
-loaded app page, so the credentials apply. It waits for auth to hydrate
-first: after the redirect the page is a cold load, and the session is
-restored from the httpOnly cookie via `GET /users/me`.
+#### `ChatProvider(props)`
 
-Verification is idempotent server-side (first-claim-wins on the transaction),
-and this hook additionally runs at most once per transaction id per page.
-Safe on pages that are also reached normally: with no id in the URL it stays
-`idle` and issues no request.
+Provider for AI chat.
 
 ```typescript
-function useVerifyPaymentReturn(
-  options?: UseVerifyPaymentReturnOptions,
-): UseVerifyPaymentReturnResult
+function ChatProvider({
+  provider,
+  children,
+}: ChatProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
 ```
 
-- `options` — Provider fallback + lifecycle callbacks (see {@link UseVerifyPaymentReturnOptions}).
-
-**Returns:** The verification state (see {@link UseVerifyPaymentReturnResult}).
+- `props` — Component props (see {@link ChatProviderProps}).
 
-#### `useVersion()`
+**Returns:** The rendered chat provider element.
 
-Hook for version state and update actions.
+#### `WorkspaceProvider(props)`
 
-Uses module-level `getProvider()` — version is a singleton, not context-provided.
+Provider for IDE workspace.
 
 ```typescript
-function useVersion(): UseVersionResult
+function WorkspaceProvider({
+  provider,
+  children,
+}: WorkspaceProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
 ```
 
-**Returns:** Version state and action methods
+- `props` — Component props (see {@link WorkspaceProviderProps}).
 
-#### `useWatch(form, name)`
+**Returns:** The rendered workspace provider element.
 
-Hook to watch a specific field value.
+#### `EditorProvider(props)`
+
+Provider for code editor.
 
 ```typescript
-function useWatch(form: FormController<T>, name: K): T[K]
+function EditorProvider({
+  provider,
+  children,
+}: EditorProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
 ```
 
-- `form` — Form controller
-- `name` — Field name to watch
+- `props` — Component props (see {@link EditorProviderProps}).
 
-**Returns:** Current field value
+**Returns:** The rendered editor provider element.
 
-#### `useWorkspace()`
+#### `PreviewProvider(props)`
 
-Hook for IDE workspace layout management.
+Provider for live preview.
 
 ```typescript
-function useWorkspace(): UseWorkspaceResult
+function PreviewProvider({
+  provider,
+  children,
+}: PreviewProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
 ```
 
-**Returns:** The workspace state and management methods.
-
-#### `useWorkspaceProvider()`
-
-Access the workspace provider from context.
+- `props` — Component props (see {@link PreviewProviderProps}).
 
-```typescript
-function useWorkspaceProvider(): WorkspaceProvider
-```
+**Returns:** The rendered preview provider element.
 
-**Returns:** The result.
+#### `MoleculeProvider(props)`
 
-#### `WorkspaceProvider(props)`
+Combined provider for all molecule services.
 
-Provider for IDE workspace.
+Provides a convenient way to wrap your app with all molecule providers at once.
+Only providers that are passed will be included — except `state`, which falls
+back to the state provider bonded under `@molecule/app-state` (set by
+`setupAllDefaultBonds()` or a state bond) so `useStore()` works without a
+`state` prop.
 
 ```typescript
-function WorkspaceProvider({
-  provider,
+function MoleculeProvider({
   children,
-}: WorkspaceProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
+  state,
+  auth,
+  theme,
+  router,
+  i18n,
+  http,
+  storage,
+  logger,
+  chat,
+  workspace,
+  editor,
+  preview,
+}: MoleculeProviderProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>
 ```
 
-- `props` — Component props (see {@link WorkspaceProviderProps}).
+- `props` — Component props (see {@link MoleculeProviderProps}) — each service is optional, and ONLY the services passed are provided to the tree.
 
-**Returns:** The rendered workspace provider element.
+**Returns:** The rendered combined provider element.
 
 ### Constants
 
-#### `AuthContext`
+#### `DEFAULT_AGENT_NAME`
 
-Context for authentication client.
+Neutral, product-agnostic agent name used when the host supplies none.
 
 ```typescript
-const AuthContext: Context<AuthClient<unknown> | null>
+const DEFAULT_AGENT_NAME: 'the assistant'
 ```
 
-#### `ChatContext`
+#### `DEFAULT_PRODUCT_NAME`
 
-Context for AI chat provider.
+Neutral, product-agnostic product/IDE name used when the host supplies none.
 
 ```typescript
-const ChatContext: Context<ChatProvider | null>
+const DEFAULT_PRODUCT_NAME: 'the IDE'
 ```
 
 #### `DEFAULT_AGENT_IDENTITY`
@@ -2682,36 +3015,36 @@ passes its own.
 const DEFAULT_AGENT_IDENTITY: AgentIdentity
 ```
 
-#### `DEFAULT_AGENT_NAME`
+#### `StateContext`
 
-Neutral, product-agnostic agent name used when the host supplies none.
+Context for state management provider.
 
 ```typescript
-const DEFAULT_AGENT_NAME: 'the assistant'
+const StateContext: Context<StateProvider | null>
 ```
 
-#### `DEFAULT_PRODUCT_NAME`
+#### `AuthContext`
 
-Neutral, product-agnostic product/IDE name used when the host supplies none.
+Context for authentication client.
 
 ```typescript
-const DEFAULT_PRODUCT_NAME: 'the IDE'
+const AuthContext: Context<AuthClient<unknown, Record<never, never>> | null>
 ```
 
-#### `EditorContext`
+#### `ThemeContext`
 
-Context for code editor provider.
+Context for theme provider.
 
 ```typescript
-const EditorContext: Context<EditorProvider | null>
+const ThemeContext: Context<ThemeProvider | null>
 ```
 
-#### `HttpContext`
+#### `RouterContext`
 
-Context for HTTP client.
+Context for router.
 
 ```typescript
-const HttpContext: Context<HttpClient | null>
+const RouterContext: Context<Router | null>
 ```
 
 #### `I18nContext`
@@ -2722,52 +3055,60 @@ Context for internationalization provider.
 const I18nContext: Context<I18nProvider | null>
 ```
 
-#### `LoggerContext`
+#### `HttpContext`
 
-Context for logger provider.
+Context for HTTP client.
 
 ```typescript
-const LoggerContext: Context<LoggerProvider | null>
+const HttpContext: Context<HttpClient | null>
 ```
 
-#### `PreviewContext`
+#### `StorageContext`
 
-Context for live preview provider.
+Context for storage provider.
 
 ```typescript
-const PreviewContext: Context<PreviewProvider | null>
+const StorageContext: Context<StorageProvider | null>
 ```
 
-#### `RouterContext`
+#### `LoggerContext`
 
-Context for router.
+Context for logger provider.
 
 ```typescript
-const RouterContext: Context<Router | null>
+const LoggerContext: Context<LoggerProvider | null>
 ```
 
-#### `StateContext`
+#### `ChatContext`
 
-Context for state management provider.
+Context for AI chat provider.
 
 ```typescript
-const StateContext: Context<StateProvider | null>
+const ChatContext: Context<ChatProvider | null>
 ```
 
-#### `StorageContext`
+#### `WorkspaceContext`
 
-Context for storage provider.
+Context for IDE workspace provider.
 
 ```typescript
-const StorageContext: Context<StorageProvider | null>
+const WorkspaceContext: Context<WorkspaceProvider | null>
 ```
 
-#### `ThemeContext`
+#### `EditorContext`
 
-Context for theme provider.
+Context for code editor provider.
 
 ```typescript
-const ThemeContext: Context<ThemeProvider | null>
+const EditorContext: Context<EditorProvider | null>
+```
+
+#### `PreviewContext`
+
+Context for live preview provider.
+
+```typescript
+const PreviewContext: Context<PreviewProvider | null>
 ```
 
 #### `useAsyncState`
@@ -2778,6 +3119,10 @@ Hook like useState but accepts Promises and supports partial state extension.
 const useAsyncState: <T>(initialState: T) => [T, AsyncSetState<T>, AsyncExtendState<T>]
 ```
 
+- `initialState` — Initial state value
+
+**Returns:** Tuple of [state, asyncSetState, asyncExtendState]
+
 #### `usePromise`
 
 Hook that wraps an async function with state tracking.
@@ -2791,13 +3136,9 @@ const usePromise: <T extends (...args: any[]) => Promise<any>>(
 ]
 ```
 
-#### `WorkspaceContext`
-
-Context for IDE workspace provider.
+- `asyncFn` — The async function to wrap
 
-```typescript
-const WorkspaceContext: Context<WorkspaceProvider | null>
-```
+**Returns:** Tuple of [state, wrappedFunction]
 
 ## Injection Notes