@molecule/app-angular 1.0.2 → 1.0.3

package/README.md

@@ -3,21 +3,21 @@ 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-15T19:11:41.538Z
+Generated: 2026-10-21T17:02:30.648Z
 -->
 
 # @molecule/app-angular
 
-> **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.
-
 Angular framework bindings for molecule.dev.
 
 Provides Angular-specific services and providers for all molecule
 core interfaces. This package enables the use of molecule's framework-agnostic
 interfaces with Angular's idioms (services, DI, RxJS observables, etc.).
 
+> **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
 
 ```typescript
@@ -86,131 +86,17 @@ npm install @molecule/app-angular @angular/core @molecule/app-auth @molecule/app
 
 ### Interfaces
 
-#### `AsyncStateManager`
-
-Async state manager.
-
-```typescript
-interface AsyncStateManager<T> {
-  state$: Observable<T>
-  getState: () => T
-  setState: (value: T | ((prev: T) => T) | Promise<T | ((prev: T) => T)>) => void
-  extendState: (
-    partial:
-      Partial<T> | ((prev: T) => Partial<T>) | Promise<Partial<T> | ((prev: T) => Partial<T>)>,
-  ) => void
-  destroy: () => void
-}
-```
-
-#### `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
-}
-```
-
 #### `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.
    */
@@ -234,49 +120,176 @@ interface AuthState<T = UserProfile> {
 }
 ```
 
-#### `CapacitorAppManager`
-
-Capacitor app manager interface.
-
-```typescript
-interface CapacitorAppManager {
-  state$: Observable<CapacitorAppState>
-  ready$: Observable<boolean>
-  initialize: () => Promise<void>
-  destroy: () => void
-}
-```
-
-#### `ChangePasswordStateManager`
-
-Change password state manager.
-
-```typescript
-interface ChangePasswordStateManager {
-  state$: Observable<PromiseState<void>>
-  getState: () => PromiseState<void>
-  changePassword: (oldPassword: string, newPassword: string) => Promise<void>
-  reset: () => void
-  destroy: () => void
-}
-```
-
-#### `DeviceService`
+#### `AuthClient`
 
-Device service interface.
+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 DeviceService {
-  deviceInfo: DeviceInfo
-  screenInfo: ScreenInfo
-  hardwareInfo: HardwareInfo
-  featureSupport: FeatureSupport
-  supports: (feature: keyof FeatureSupport) => boolean
-  isOnline: () => boolean
-  isStandalone: () => boolean
-  language: string
-  languages: string[]
-}
+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;
+    /**
+     * 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.
+     */
+    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
+     * held forever. That is what makes the fetch-before-restore race impossible: a page that
+     * fetches viewer-dependent data on mount waits here instead of going out anonymously
+     * (see `setAuthGate` in `@molecule/app-http`).
+     *
+     * Optional: a provider that restores no session has nothing to wait for. Without it, an
+     * HTTP client bonded to that provider sends first-paint requests unauthenticated.
+     *
+     * A provider whose restore sends a request THROUGH the gated HTTP client must send that
+     * request with `skipAuthGate: true` (`RequestConfig` in `@molecule/app-http`): the gate
+     * waits on this promise, so holding the restore's own request makes the gate wait on
+// … truncated — the full declaration is in node_modules/@molecule/app-angular/dist
 ```
 
 #### `FormController`
@@ -431,7 +444,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>>
   /**
@@ -439,15 +453,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>>
   /**
@@ -486,18 +504,6 @@ interface HttpClient {
 }
 ```
 
-#### `HttpState`
-
-State for HTTP requests.
-
-```typescript
-interface HttpState<T> {
-  data: T | null
-  loading: boolean
-  error: Error | null
-}
-```
-
 #### `I18nProvider`
 
 i18n provider interface.
@@ -756,244 +762,55 @@ interface LoggerProvider {
 }
 ```
 
-#### `LoginStateManager`
-
-Login state manager.
-
-```typescript
-interface LoginStateManager<T = unknown> {
-  state$: Observable<PromiseState<AuthResult<T>>>
-  getState: () => PromiseState<AuthResult<T>>
-  login: (credentials: LoginCredentials) => Promise<AuthResult<T>>
-  reset: () => void
-  destroy: () => void
-}
-```
-
-#### `MoleculeModuleConfig`
+#### `RouteLocation`
 
-Configuration for molecule Angular module.
+Current URL decomposed into pathname, search string, hash, navigation state, and unique key.
 
 ```typescript
-interface MoleculeModuleConfig {
-  state?: StateProvider
-  auth?: AuthClient<unknown>
-  theme?: ThemeProvider
-  router?: Router
-  i18n?: I18nProvider
-  http?: HttpClient
-  storage?: StorageProvider
-  logger?: LoggerProvider
+interface RouteLocation {
+  /**
+   * Current pathname.
+   */
+  pathname: string
+  /**
+   * Query string (including leading ?).
+   */
+  search: string
+  /**
+   * Hash (including leading #).
+   */
+  hash: string
+  /**
+   * State data passed with navigation.
+   */
+  state?: unknown
+  /**
+   * Unique key for this location.
+   */
+  key?: string
 }
 ```
 
-#### `MoleculeTokens`
-
-Injection tokens for molecule services.
-
-```typescript
-interface MoleculeTokens {
-  STATE_PROVIDER: symbol
-  AUTH_CLIENT: symbol
-  THEME_PROVIDER: symbol
-  ROUTER: symbol
-  I18N_PROVIDER: symbol
-  HTTP_CLIENT: symbol
-  STORAGE_PROVIDER: symbol
-  LOGGER_PROVIDER: symbol
-}
-```
+#### `Router`
 
-#### `OAuthOptions`
+Client-side router providing navigation, guards, route matching, and history control.
 
-OAuth configuration options.
+All routing providers must implement this interface.
 
 ```typescript
-interface OAuthOptions {
-  /** Base URL for the API server (e.g. `https://api.example.com`). */
-  baseURL?: string
-  /** List of supported OAuth provider names (e.g. `['github', 'google']`). */
-  oauthProviders?: string[]
-  /** Path prefix for OAuth initiation routes. Defaults to `/oauth`. */
-  oauthEndpoint?: string
-  /** Path for the OAuth login POST endpoint. Defaults to `/users/log-in/oauth`. */
-  loginEndpoint?: string
-  /** Called after a successful OAuth login (session established). */
-  onSuccess?: () => void
+interface Router {
   /**
-   * Called with a failure message when the OAuth login fails. Failures are
-   * also emitted on {@link OAuthStateManager.error$}.
+   * Returns the current route location (pathname, search, hash, state).
    */
-  onError?: (error: string) => void
+  getLocation(): RouteLocation
   /**
-   * Auth client used to establish the session after the code exchange. This
-   * is THE way to wire session establishment in Angular: inject the
-   * `AUTH_CLIENT` token and pass the client here. When omitted, the helper
-   * falls back to the server-established httpOnly-cookie session (see
-   * {@link OAuthStateManager.handleCallback}).
+   * Gets the current route params.
    */
-  authClient?: AuthClient<unknown>
-}
-```
-
-#### `OAuthStateManager`
-
-OAuth state manager.
-
-```typescript
-interface OAuthStateManager {
-  /** Observable of the configured OAuth provider names. */
-  providers$: Observable<string[]>
+  getParams<T extends RouteParams = RouteParams>(): T
   /**
-   * Observable of OAuth failure messages (from the callback code exchange).
-   * Completed by {@link OAuthStateManager.destroy}.
+   * Gets the current query params.
    */
-  error$: Observable<string>
-  /** Returns the configured OAuth provider names. */
-  getProviders: () => string[]
-  /** Builds the OAuth initiation URL for a provider. */
-  getOAuthUrl: (provider: string) => string
-  /** Starts the full-page redirect flow for a provider. */
-  redirect: (provider: string) => void
-  /**
-   * Handles the OAuth callback: exchanges the `code` URL parameter for a
-   * session. Invoked automatically at creation (see {@link createOAuthState});
-   * exposed for callers that need to re-run it manually. No-ops unless
-   * running in a browser with a `code` URL parameter and a stashed provider.
-   *
-   * When an auth client was provided, the session is established locally
-   * (`setAccessToken` + `setUser` + `initialize`). When no client is
-   * available, the server has already established the httpOnly-cookie
-   * session during the exchange, so a user-carrying response still counts
-   * as success.
-   */
-  handleCallback: () => Promise<void>
-  /** Completes the `providers$` and `error$` observables. */
-  destroy: () => void
-}
-```
-
-#### `PasswordResetStateManager`
-
-Password reset state manager.
-
-```typescript
-interface PasswordResetStateManager {
-  requestState$: Observable<PromiseState<void>>
-  confirmState$: Observable<PromiseState<void>>
-  getRequestState: () => PromiseState<void>
-  getConfirmState: () => PromiseState<void>
-  requestReset: (data: PasswordResetRequest) => Promise<void>
-  confirmReset: (data: PasswordResetConfirm) => Promise<void>
-  reset: () => void
-  destroy: () => void
-}
-```
-
-#### `PlatformService`
-
-Platform service interface.
-
-```typescript
-interface PlatformService {
-  platform: Platform
-  isNative: boolean
-  isMobile: boolean
-  isDesktop: boolean
-  isWeb: boolean
-  isDevelopment: boolean
-  isProduction: boolean
-  isPlatform: (...platforms: Platform[]) => boolean
-}
-```
-
-#### `PromiseStateManager`
-
-Promise state manager.
-
-```typescript
-interface PromiseStateManager<T> {
-  state$: Observable<PromiseState<T>>
-  getState: () => PromiseState<T>
-  call: (...args: any[]) => Promise<T>
-  cancel: (message?: string) => void
-  reset: () => void
-  destroy: () => void
-}
-```
-
-#### `PushService`
-
-Push service interface.
-
-```typescript
-interface PushService {
-  permission$: Observable<PermissionStatus | null>
-  token$: Observable<PushToken | null>
-  getPermission: () => PermissionStatus | null
-  getToken: () => PushToken | null
-  checkPermission: () => Promise<PermissionStatus>
-  requestPermission: () => Promise<PermissionStatus>
-  register: (options?: PushRegisterOptions) => Promise<PushToken>
-  unregister: () => Promise<void>
-  onNotificationReceived: (listener: NotificationReceivedListener) => () => void
-  onNotificationAction: (listener: NotificationActionListener) => () => void
-  onTokenChange: (listener: TokenChangeListener) => () => void
-  setBadge: (count: number) => Promise<void>
-  clearBadge: () => Promise<void>
-  destroy: () => void
-}
-```
-
-#### `RouteLocation`
-
-Current URL decomposed into pathname, search string, hash, navigation state, and unique key.
-
-```typescript
-interface RouteLocation {
-  /**
-   * Current pathname.
-   */
-  pathname: string
-  /**
-   * Query string (including leading ?).
-   */
-  search: string
-  /**
-   * Hash (including leading #).
-   */
-  hash: string
-  /**
-   * State data passed with navigation.
-   */
-  state?: unknown
-  /**
-   * Unique key for this location.
-   */
-  key?: string
-}
-```
-
-#### `Router`
-
-Client-side router providing navigation, guards, route matching, and history control.
-
-All routing providers must implement this interface.
-
-```typescript
-interface Router {
-  /**
-   * Returns the current route location (pathname, search, hash, state).
-   */
-  getLocation(): RouteLocation
-  /**
-   * Gets the current route params.
-   */
-  getParams<T extends RouteParams = RouteParams>(): T
-  /**
-   * Gets the current query params.
-   */
-  getQuery(): QueryParams
+  getQuery(): QueryParams
   /**
    * Gets a specific query parameter.
    */
@@ -1079,17 +896,52 @@ interface Router {
 }
 ```
 
-#### `SignupStateManager`
+#### `StoreConfig`
 
-Signup state manager.
+Configuration for creating a store (initial state, optional name, and middleware chain).
 
 ```typescript
-interface SignupStateManager<T = unknown> {
-  state$: Observable<PromiseState<AuthResult<T>>>
-  getState: () => PromiseState<AuthResult<T>>
-  signup: (data: RegisterData) => Promise<AuthResult<T>>
-  reset: () => void
-  destroy: () => void
+interface StoreConfig<T> {
+  /**
+   * Initial state value.
+   */
+  initialState: T
+  /**
+   * Optional name for debugging.
+   */
+  name?: string
+  /**
+   * Optional middleware functions.
+   */
+  middleware?: StoreMiddleware<T>[]
+}
+```
+
+#### `Store`
+
+Reactive state container with getState, setState, subscribe, and destroy.
+
+All state management providers must implement this interface.
+
+```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
 }
 ```
 
@@ -1150,246 +1002,1748 @@ interface StorageProvider {
 }
 ```
 
-#### `StorageValueState`
-
-State for a storage value.
-
-```typescript
-interface StorageValueState<T> {
-  value: T | undefined
-  loading: boolean
-  error: Error | null
-}
-```
-
-#### `Store`
-
-Reactive state container with getState, setState, subscribe, and destroy.
+#### `ThemeProvider`
 
-All state management providers must implement this interface.
+Manages theme state including the active theme, mode toggling,
+and change subscriptions.
 
 ```typescript
-interface Store<T> {
+interface ThemeProvider {
   /**
-   * Gets the current state.
+   * Returns the currently active theme.
    */
-  getState(): T
+  getTheme(): Theme
   /**
-   * Sets the state (partial or via updater function).
+   * Sets the active theme by reference or by name.
+   *
+   * @param theme - A `Theme` object or a theme name string to activate.
    */
-  setState(partial: Partial<T> | ((state: T) => Partial<T>)): void
+  setTheme(theme: Theme | string): void
   /**
-   * Subscribes to state changes.
-   * Returns an unsubscribe function.
+   * Toggles between light and dark mode for the active theme.
    */
-  subscribe(listener: StateListener<T>): () => void
+  toggleMode(): void
   /**
-   * Destroys the store and cleans up subscriptions.
+   * Subscribes to theme changes. The callback fires whenever
+   * `setTheme()` or `toggleMode()` is called.
+   *
+   * @param callback - Invoked with the new theme after each change.
+   * @returns An unsubscribe function.
    */
-  destroy(): void
+  subscribe(callback: (theme: Theme) => void): () => void
+  /**
+   * Returns all registered themes. Optional — not all providers
+   * support multiple themes.
+   */
+  getThemes?(): Theme[]
+  /**
+   * Returns the theme a render WITHOUT a browser produces — a server or
+   * build-time render, which has no storage and no `prefers-color-scheme`
+   * to read. A hydrating client renders this theme first, so its markup
+   * matches what the server sent, and switches to `getTheme()` right
+   * after. Optional — a provider whose theme cannot differ between the two
+   * need not implement it.
+   */
+  getServerTheme?(): Theme
 }
 ```
 
-#### `StoreConfig`
+#### `Theme`
 
-Configuration for creating a store (initial state, optional name, and middleware chain).
+Complete theme definition.
 
 ```typescript
-interface StoreConfig<T> {
-  /**
-   * Initial state value.
-   */
-  initialState: T
-  /**
-   * Optional name for debugging.
-   */
-  name?: string
+interface Theme {
+  name: string
+  mode: 'light' | 'dark'
+  colors: ThemeColors
+  breakpoints: ThemeBreakpoints
+  spacing: ThemeSpacing
+  typography: ThemeTypography
+  borderRadius: ThemeBorderRadius
+  shadows: ThemeShadows
+  transitions: ThemeTransitions
+  zIndex: ThemeZIndex
+}
+```
+
+#### `AsyncStateManager`
+
+Async state manager.
+
+```typescript
+interface AsyncStateManager<T> {
+  state$: Observable<T>
+  getState: () => T
+  setState: (value: T | ((prev: T) => T) | Promise<T | ((prev: T) => T)>) => void
+  extendState: (
+    partial:
+      Partial<T> | ((prev: T) => Partial<T>) | Promise<Partial<T> | ((prev: T) => Partial<T>)>,
+  ) => void
+  destroy: () => void
+}
+```
+
+#### `CapacitorAppManager`
+
+Capacitor app manager interface.
+
+```typescript
+interface CapacitorAppManager {
+  state$: Observable<CapacitorAppState>
+  ready$: Observable<boolean>
+  initialize: () => Promise<void>
+  destroy: () => void
+}
+```
+
+#### `ChangePasswordStateManager`
+
+Change password state manager.
+
+```typescript
+interface ChangePasswordStateManager {
+  state$: Observable<PromiseState<void>>
+  getState: () => PromiseState<void>
+  changePassword: (oldPassword: string, newPassword: string) => Promise<void>
+  reset: () => void
+  destroy: () => void
+}
+```
+
+#### `DeviceService`
+
+Device service interface.
+
+```typescript
+interface DeviceService {
+  deviceInfo: DeviceInfo
+  screenInfo: ScreenInfo
+  hardwareInfo: HardwareInfo
+  featureSupport: FeatureSupport
+  supports: (feature: keyof FeatureSupport) => boolean
+  isOnline: () => boolean
+  isStandalone: () => boolean
+  language: string
+  languages: string[]
+}
+```
+
+#### `HttpState`
+
+State for HTTP requests.
+
+```typescript
+interface HttpState<T> {
+  data: T | null
+  loading: boolean
+  error: Error | null
+}
+```
+
+#### `LoginStateManager`
+
+Login state manager.
+
+```typescript
+interface LoginStateManager<T = unknown> {
+  state$: Observable<PromiseState<AuthResult<T>>>
+  getState: () => PromiseState<AuthResult<T>>
+  login: (credentials: LoginCredentials) => Promise<AuthResult<T>>
+  reset: () => void
+  destroy: () => void
+}
+```
+
+#### `OAuthOptions`
+
+OAuth configuration options.
+
+```typescript
+interface OAuthOptions {
+  /** Base URL for the API server (e.g. `https://api.example.com`). */
+  baseURL?: string
+  /** List of supported OAuth provider names (e.g. `['github', 'google']`). */
+  oauthProviders?: string[]
+  /** Path prefix for OAuth initiation routes. Defaults to `/oauth`. */
+  oauthEndpoint?: string
+  /** Path for the OAuth login POST endpoint. Defaults to `/users/log-in/oauth`. */
+  loginEndpoint?: string
+  /** Called after a successful OAuth login (session established). */
+  onSuccess?: () => void
+  /**
+   * Called with a failure message when the OAuth login fails. Failures are
+   * also emitted on {@link OAuthStateManager.error$}.
+   */
+  onError?: (error: string) => void
+  /**
+   * Auth client used to establish the session after the code exchange. This
+   * is THE way to wire session establishment in Angular: inject the
+   * `AUTH_CLIENT` token and pass the client here. When omitted, the helper
+   * falls back to the server-established httpOnly-cookie session (see
+   * {@link OAuthStateManager.handleCallback}).
+   */
+  authClient?: AuthClient<unknown>
+}
+```
+
+#### `OAuthStateManager`
+
+OAuth state manager.
+
+```typescript
+interface OAuthStateManager {
+  /** Observable of the configured OAuth provider names. */
+  providers$: Observable<string[]>
+  /**
+   * Observable of OAuth failure messages (from the callback code exchange).
+   * Completed by {@link OAuthStateManager.destroy}.
+   */
+  error$: Observable<string>
+  /** Returns the configured OAuth provider names. */
+  getProviders: () => string[]
+  /** Builds the OAuth initiation URL for a provider. */
+  getOAuthUrl: (provider: string) => string
+  /** Starts the full-page redirect flow for a provider. */
+  redirect: (provider: string) => void
+  /**
+   * Handles the OAuth callback: exchanges the `code` URL parameter for a
+   * session. Invoked automatically at creation (see {@link createOAuthState});
+   * exposed for callers that need to re-run it manually. No-ops unless
+   * running in a browser with a `code` URL parameter and a stashed provider.
+   *
+   * When an auth client was provided, the session is established locally
+   * (`setAccessToken` + `setUser` + `initialize`). When no client is
+   * available, the server has already established the httpOnly-cookie
+   * session during the exchange, so a user-carrying response still counts
+   * as success.
+   */
+  handleCallback: () => Promise<void>
+  /** Completes the `providers$` and `error$` observables. */
+  destroy: () => void
+}
+```
+
+#### `PasswordResetStateManager`
+
+Password reset state manager.
+
+```typescript
+interface PasswordResetStateManager {
+  requestState$: Observable<PromiseState<void>>
+  confirmState$: Observable<PromiseState<void>>
+  getRequestState: () => PromiseState<void>
+  getConfirmState: () => PromiseState<void>
+  requestReset: (data: PasswordResetRequest) => Promise<void>
+  confirmReset: (data: PasswordResetConfirm) => Promise<void>
+  reset: () => void
+  destroy: () => void
+}
+```
+
+#### `PlatformService`
+
+Platform service interface.
+
+```typescript
+interface PlatformService {
+  platform: Platform
+  isNative: boolean
+  isMobile: boolean
+  isDesktop: boolean
+  isWeb: boolean
+  isDevelopment: boolean
+  isProduction: boolean
+  isPlatform: (...platforms: Platform[]) => boolean
+}
+```
+
+#### `PromiseStateManager`
+
+Promise state manager.
+
+```typescript
+interface PromiseStateManager<T> {
+  state$: Observable<PromiseState<T>>
+  getState: () => PromiseState<T>
+  call: (...args: any[]) => Promise<T>
+  cancel: (message?: string) => void
+  reset: () => void
+  destroy: () => void
+}
+```
+
+**Returns:** The result.
+
+#### `PushService`
+
+Push service interface.
+
+```typescript
+interface PushService {
+  permission$: Observable<PermissionStatus | null>
+  token$: Observable<PushToken | null>
+  getPermission: () => PermissionStatus | null
+  getToken: () => PushToken | null
+  checkPermission: () => Promise<PermissionStatus>
+  requestPermission: () => Promise<PermissionStatus>
+  register: (options?: PushRegisterOptions) => Promise<PushToken>
+  unregister: () => Promise<void>
+  onNotificationReceived: (listener: NotificationReceivedListener) => () => void
+  onNotificationAction: (listener: NotificationActionListener) => () => void
+  onTokenChange: (listener: TokenChangeListener) => () => void
+  setBadge: (count: number) => Promise<void>
+  clearBadge: () => Promise<void>
+  destroy: () => void
+}
+```
+
+#### `SignupStateManager`
+
+Signup state manager.
+
+```typescript
+interface SignupStateManager<T = unknown> {
+  state$: Observable<PromiseState<AuthResult<T>>>
+  getState: () => PromiseState<AuthResult<T>>
+  signup: (data: RegisterData) => Promise<AuthResult<T>>
+  reset: () => void
+  destroy: () => void
+}
+```
+
+#### `StorageValueState`
+
+State for a storage value.
+
+```typescript
+interface StorageValueState<T> {
+  value: T | undefined
+  loading: boolean
+  error: Error | null
+}
+```
+
+#### `VersionService`
+
+Version service interface.
+
+```typescript
+interface VersionService {
+  state$: Observable<VersionState>
+  isUpdateAvailable$: Observable<boolean>
+  isChecking$: Observable<boolean>
+  isServiceWorkerWaiting$: Observable<boolean>
+  newVersion$: Observable<string | undefined>
+  getState: () => VersionState
+  checkForUpdates: () => Promise<boolean>
+  applyUpdate: (options?: { force?: boolean }) => void
+  dismissUpdate: () => void
+  startPeriodicChecks: (options?: UpdateCheckOptions) => void
+  stopPeriodicChecks: () => void
+  destroy: () => void
+}
+```
+
+#### `MoleculeModuleConfig`
+
+Configuration for molecule Angular module.
+
+```typescript
+interface MoleculeModuleConfig {
+  state?: StateProvider
+  auth?: AuthClient<unknown>
+  theme?: ThemeProvider
+  router?: Router
+  i18n?: I18nProvider
+  http?: HttpClient
+  storage?: StorageProvider
+  logger?: LoggerProvider
+}
+```
+
+#### `MoleculeTokens`
+
+Injection tokens for molecule services.
+
+```typescript
+interface MoleculeTokens {
+  STATE_PROVIDER: symbol
+  AUTH_CLIENT: symbol
+  THEME_PROVIDER: symbol
+  ROUTER: symbol
+  I18N_PROVIDER: symbol
+  HTTP_CLIENT: symbol
+  STORAGE_PROVIDER: symbol
+  LOGGER_PROVIDER: symbol
+}
+```
+
+### Types
+
+#### `RouteParams`
+
+URL path parameter key-value map extracted from dynamic route segments (e.g. `{ id: '123' }`).
+
+```typescript
+type RouteParams = Record<string, string>
+```
+
+#### `QueryParams`
+
+URL query string parameter map (single values or arrays for repeated keys).
+
+```typescript
+type QueryParams = Record<string, string | string[] | undefined>
+```
+
+### Classes
+
+#### `MoleculeAuthService`
+
+Angular service for authentication.
+
+Wraps molecule auth client and exposes state as RxJS observables.
+
+```typescript
+@Injectable({
+  providedIn: 'root',
+})
+export class MoleculeAuthService<
+  T = unknown,
+  TRegister extends RegisterExtraShape<TRegister> = Record<never, never>,
+> implements OnDestroy {
+  private stateSubject: BehaviorSubject<AuthState<T>>
+  private unsubscribe: (() => void) | null = null
+
+  /**
+   * Observable of the full auth state.
+   */
+  state$: Observable<AuthState<T>>
+
+  /**
+   * Observable of the authenticated user.
+   */
+  user$: Observable<T | null>
+
+  /**
+   * Observable of authentication status.
+   */
+  isAuthenticated$: Observable<boolean>
+
+  /**
+   * Observable of loading status.
+   */
+  isLoading$: Observable<boolean>
+
+  constructor(@Inject(AUTH_CLIENT) private client: AuthClient<T, TRegister>) {
+    this.stateSubject = new BehaviorSubject<AuthState<T>>(client.getState())
+
+    this.unsubscribe = client.onAuthChange(() => {
+      this.stateSubject.next(client.getState())
+    })
+
+    this.state$ = this.stateSubject.asObservable()
+
+    this.user$ = this.state$.pipe(
+      map((state) => state.user),
+      distinctUntilChanged(),
+    )
+
+    this.isAuthenticated$ = this.state$.pipe(
+      map((state) => state.authenticated),
+      distinctUntilChanged(),
+    )
+
+    this.isLoading$ = this.state$.pipe(
+      map((state) => state.loading),
+      distinctUntilChanged(),
+    )
+  }
+
+  /**
+   * Get the current auth state snapshot.
+   * @returns The current authentication state including user, loading, and authenticated flags.
+   */
+  get state(): AuthState<T> {
+    return this.client.getState()
+  }
+
+  /**
+   * Get the current user snapshot.
+   * @returns The authenticated user object, or `null` if not authenticated.
+   */
+  get user(): T | null {
+    return this.state.user
+  }
+
+  /**
+   * Check if user is currently authenticated.
+   * @returns `true` if the user is authenticated, `false` otherwise.
+   */
+  get isAuthenticated(): boolean {
+    return this.state.authenticated
+  }
+
+  /**
+   * Login with credentials.
+   *
+   * @param credentials - The email/password or provider-specific login credentials.
+   * @returns A promise that resolves to the authentication result with user data and tokens.
+   */
+  login(credentials: LoginCredentials): Promise<AuthResult<T>> {
+    return this.client.login(credentials)
+  }
+
+  /**
+   * Logout the current user.
+   * @returns A promise that resolves when the user has been logged out.
+   */
+  logout(): Promise<void> {
+    return this.client.logout()
+  }
+
+  /**
+   * Register a new user.
+   *
+   * @param data - The registration payload including email, password, and profile fields.
+   * @returns A promise that resolves to the authentication result for the newly registered user.
+   */
+  register(data: RegisterData<TRegister>): Promise<AuthResult<T>> {
+    return this.client.register(data)
+  }
+
+  /**
+   * Refresh the authentication token.
+   * @returns A promise that resolves to the authentication result with refreshed tokens.
+   */
+  refresh(): Promise<AuthResult<T>> {
+    return this.client.refresh()
+  }
+
+  /**
+   * Clean up auth state subscription on service destruction.
+   */
+  ngOnDestroy(): void {
+    this.unsubscribe?.()
+    this.stateSubject.complete()
+  }
+}
+```
+
+#### `MoleculeFormInstance`
+
+Wrapper around a FormController that provides RxJS observables and
+synchronous accessors for use in Angular components.
+
+```typescript
+class MoleculeFormInstance<T extends Record<string, unknown>> {
+  private stateSubject: BehaviorSubject<FormState<T>>
+  private unsubscribe: (() => void) | null = null
+
+  /**
+   * Observable of the full form state.
+   */
+  state$: Observable<FormState<T>>
+
+  /**
+   * Observable of form validity.
+   */
+  isValid$: Observable<boolean>
+
+  /**
+   * Observable of form dirty state.
+   */
+  isDirty$: Observable<boolean>
+
+  /**
+   * Observable of form submitting state.
+   */
+  isSubmitting$: Observable<boolean>
+
+  /**
+   * Observable of field errors.
+   */
+  errors$: Observable<Partial<Record<keyof T, string>>>
+
+  constructor(private controller: FormController<T>) {
+    this.stateSubject = new BehaviorSubject<FormState<T>>(controller.getState())
+
+    this.unsubscribe = controller.subscribe((state: FormState<T>) => {
+      this.stateSubject.next(state)
+    })
+
+    this.state$ = this.stateSubject.asObservable()
+
+    this.isValid$ = this.state$.pipe(
+      map((state) => state.isValid),
+      distinctUntilChanged(),
+    )
+
+    this.isDirty$ = this.state$.pipe(
+      map((state) => state.isDirty),
+      distinctUntilChanged(),
+    )
+
+    this.isSubmitting$ = this.state$.pipe(
+      map((state) => state.isSubmitting),
+      distinctUntilChanged(),
+    )
+
+    this.errors$ = this.state$.pipe(
+      map((state) => state.errors),
+      distinctUntilChanged(),
+    )
+  }
+
+  /**
+   * Get the current form state snapshot.
+   * @returns The current form state including values, errors, validity, and submission status.
+   */
+  get state(): FormState<T> {
+    return this.controller.getState()
+  }
+
+  /**
+   * Get the current form validity snapshot.
+   * @returns `true` if all fields pass validation, `false` otherwise.
+   */
+  get isValid(): boolean {
+    return this.controller.getState().isValid
+  }
+
+  /**
+   * Get the current form dirty state snapshot.
+   * @returns `true` if any field has been modified from its default value, `false` otherwise.
+   */
+  get isDirty(): boolean {
+    return this.controller.getState().isDirty
+  }
+
+  /**
+   * Get the current form submitting state snapshot.
+   * @returns `true` if the form is currently being submitted, `false` otherwise.
+   */
+  get isSubmitting(): boolean {
+    return this.controller.getState().isSubmitting
+  }
+
+  /**
+   * Register a field for form management.
+   *
+   * @param name - The field name corresponding to a key in the form values type.
+   * @param options - Registration options including validation rules and default value.
+   * @returns The field registration with value, onChange, onBlur, and ref bindings.
+   */
+  register(name: keyof T, options?: Omit<RegisterOptions, 'name'>): FieldRegistration {
+    return this.controller.register({ ...options, name: name as string } as RegisterOptions)
+  }
+
+  /**
+   * Get the value of a specific field.
+   *
+   * @param name - The field name corresponding to a key in the form values type.
+   * @returns The current value of the specified field.
+   */
+  getValue<K extends keyof T>(name: K): T[K] {
+    return this.controller.getValue(name)
+  }
+
+  /**
+   * Set the value of a specific field.
+   *
+   * @param name - The field name corresponding to a key in the form values type.
+   * @param value - The new value to set for the field.
+   */
+  setValue<K extends keyof T>(name: K, value: T[K]): void {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this.controller.setValue(name as any, value as any)
+  }
+
+  /**
+   * Get the error for a specific field.
+   *
+   * @param name - The field name to retrieve the error for.
+   * @returns The error message for the field, or `undefined` if the field has no error.
+   */
+  getError(name: keyof T): string | undefined {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return this.controller.getError(name as any)
+  }
+
+  /**
+   * Set the error for a specific field.
+   *
+   * @param name - The field name to set or clear the error for.
+   * @param error - The error message to set, or `undefined` to clear the error.
+   */
+  setError(name: keyof T, error: string | undefined): void {
+    if (error !== undefined) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      this.controller.setError(name as any, error)
+    } else {
+      this.controller.clearError(name)
+    }
+  }
+
+  /**
+   * Clear all field errors.
+   */
+  clearErrors(): void {
+    this.controller.clearErrors()
+  }
+
+  /**
+   * Create a submit handler function.
+   *
+   * @param onSubmit - Callback invoked with validated form values on successful submission.
+   * @param onError - Optional callback invoked with field errors when validation fails.
+   * @returns A submit handler function that can be called from form submit events.
+   */
+  handleSubmit(
+    onSubmit: (values: T) => void | Promise<void>,
+    onError?: (errors: Partial<Record<keyof T, string>>) => void,
+  ): (event?: { preventDefault?: () => void }) => Promise<void> {
+    return this.controller.handleSubmit(onSubmit, onError)
+  }
+
+  /**
+   * Reset the form to initial values.
+   *
+   * @param values - Optional partial values to use as the new initial state.
+   */
+  reset(values?: Partial<T>): void {
+    this.controller.reset(values)
+  }
+
+  /**
+   * Validate all fields.
+   *
+   * @returns A promise that resolves to `true` if all fields are valid, `false` otherwise.
+   */
+  validate(): Promise<boolean> {
+    return this.controller.validate()
+  }
+
+  /**
+   * Destroy the form instance and clean up subscriptions.
+   */
+  destroy(): void {
+    this.unsubscribe?.()
+    this.unsubscribe = null
+    this.stateSubject.complete()
+    this.controller.destroy()
+  }
+}
+```
+
+#### `MoleculeFormsService`
+
+Angular service for form handling.
+
+Wraps molecule form providers and creates form instances that expose
+state as RxJS observables.
+
+```typescript
+@Injectable({
+  providedIn: 'root',
+})
+export class MoleculeFormsService implements OnDestroy {
+  private instances: MoleculeFormInstance<Record<string, unknown>>[] = []
+
+  /**
+   * Create a form instance from a provider.
+   *
+   * @param provider - The form provider that creates form controllers.
+   * @param options - Form configuration including default values and validation mode.
+   * @returns A new form instance with RxJS observables for reactive state tracking.
+   */
+  createForm<T extends Record<string, unknown>>(
+    provider: FormProvider,
+    options: FormOptions<T>,
+  ): MoleculeFormInstance<T> {
+    const controller = provider.createForm(options)
+    const instance = new MoleculeFormInstance<T>(controller)
+    this.instances.push(instance as MoleculeFormInstance<Record<string, unknown>>)
+    return instance
+  }
+
+  /**
+   * Destroy all managed form instances on service destruction.
+   */
+  ngOnDestroy(): void {
+    for (const instance of this.instances) {
+      instance.destroy()
+    }
+    this.instances = []
+  }
+}
+```
+
+#### `MoleculeHttpService`
+
+Angular service for HTTP requests.
+
+Wraps molecule HTTP client and returns RxJS observables.
+
+```typescript
+@Injectable({
+  providedIn: 'root',
+})
+/**
+ * Molecule Http Service class.
+ */
+export class MoleculeHttpService {
+  constructor(@Inject(HTTP_CLIENT) private client: HttpClient) {}
+
+  /**
+   * Make a GET request.
+   *
+   * @param url - Request URL
+   * @param config - Request configuration
+   * @returns Observable of response data
+   */
+  get<T>(url: string, config?: RequestConfig): Observable<T> {
+    return from(this.client.get<T>(url, config)).pipe(map((res) => res.data))
+  }
+
+  /**
+   * Make a POST request.
+   *
+   * @param url - Request URL
+   * @param data - Request body
+   * @param config - Request configuration
+   * @returns Observable of response data
+   */
+  post<T>(url: string, data?: unknown, config?: RequestConfig): Observable<T> {
+    return from(this.client.post<T>(url, data, config)).pipe(map((res) => res.data))
+  }
+
+  /**
+   * Make a PUT request.
+   *
+   * @param url - Request URL
+   * @param data - Request body
+   * @param config - Request configuration
+   * @returns Observable of response data
+   */
+  put<T>(url: string, data?: unknown, config?: RequestConfig): Observable<T> {
+    return from(this.client.put<T>(url, data, config)).pipe(map((res) => res.data))
+  }
+
+  /**
+   * Make a PATCH request.
+   *
+   * @param url - Request URL
+   * @param data - Request body
+   * @param config - Request configuration
+   * @returns Observable of response data
+   */
+  patch<T>(url: string, data?: unknown, config?: RequestConfig): Observable<T> {
+    return from(this.client.patch<T>(url, data, config)).pipe(map((res) => res.data))
+  }
+
+  /**
+   * Make a DELETE request.
+   *
+   * @param url - Request URL
+   * @param config - Request configuration
+   * @returns Observable of response data
+   */
+  delete<T>(url: string, config?: RequestConfig): Observable<T> {
+    return from(this.client.delete<T>(url, config)).pipe(map((res) => res.data))
+  }
+
+  /**
+   * Get the full response (including headers, status, etc.).
+   *
+   * @param method - HTTP method
+   * @param url - Request URL
+   * @param config - Request configuration
+   * @returns Observable of full response
+   */
+  request<T>(
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE',
+    url: string,
+    config?: RequestConfig,
+  ): Observable<HttpResponse<T>> {
+    const promise = (async () => {
+      switch (method) {
+        case 'GET':
+          return this.client.get<T>(url, config)
+        case 'POST':
+          return this.client.post<T>(
+            url,
+            (config as RequestConfig & { data?: unknown })?.data,
+            config,
+          )
+        case 'PUT':
+          return this.client.put<T>(
+            url,
+            (config as RequestConfig & { data?: unknown })?.data,
+            config,
+          )
+        case 'PATCH':
+          return this.client.patch<T>(
+            url,
+            (config as RequestConfig & { data?: unknown })?.data,
+            config,
+          )
+        case 'DELETE':
+          return this.client.delete<T>(url, config)
+      }
+    })()
+
+    return from(promise)
+  }
+
+  /**
+   * Create a state subject for managing request state.
+   *
+   * @returns The created instance.
+   */
+  createState<T>(): BehaviorSubject<HttpState<T>> {
+    return new BehaviorSubject<HttpState<T>>({
+      data: null,
+      loading: false,
+      error: null,
+    })
+  }
+
+  /**
+   * Make a GET request with state management.
+   *
+   * @param url - Request URL
+   * @param state - State subject to update
+   * @param config - Request configuration
+   */
+  getWithState<T>(url: string, state: BehaviorSubject<HttpState<T>>, config?: RequestConfig): void {
+    state.next({ ...state.value, loading: true, error: null })
+
+    this.get<T>(url, config)
+      .pipe(
+        tap((data) => state.next({ data, loading: false, error: null })),
+        catchError((error) => {
+          state.next({ data: null, loading: false, error })
+          throw error
+        }),
+      )
+      .subscribe()
+  }
+}
+```
+
+#### `MoleculeI18nService`
+
+Angular service for internationalization.
+
+Wraps molecule i18n provider and exposes state as RxJS observables.
+
+```typescript
+@Injectable({
+  providedIn: 'root',
+})
+export class MoleculeI18nService implements OnDestroy {
+  private localeSubject: BehaviorSubject<string>
+  private directionSubject: BehaviorSubject<'ltr' | 'rtl'>
+  private localesSubject: BehaviorSubject<LocaleConfig[]>
+  private unsubscribe: (() => void) | null = null
+
+  /**
+   * Observable of the current locale code.
+   */
+  locale$: Observable<string>
+
+  /**
+   * Observable of the text direction.
+   */
+  direction$: Observable<'ltr' | 'rtl'>
+
+  /**
+   * Observable of available locales.
+   */
+  locales$: Observable<LocaleConfig[]>
+
+  constructor(@Inject(I18N_PROVIDER) private provider: I18nProvider) {
+    this.localeSubject = new BehaviorSubject<string>(provider.getLocale())
+    this.directionSubject = new BehaviorSubject<'ltr' | 'rtl'>(provider.getDirection())
+    this.localesSubject = new BehaviorSubject<LocaleConfig[]>(provider.getLocales())
+
+    this.unsubscribe = provider.onLocaleChange(() => {
+      this.localeSubject.next(provider.getLocale())
+      this.directionSubject.next(provider.getDirection())
+      this.localesSubject.next(provider.getLocales())
+    })
+
+    this.locale$ = this.localeSubject.asObservable()
+    this.direction$ = this.directionSubject.asObservable()
+    this.locales$ = this.localesSubject.asObservable()
+  }
+
+  /**
+   * Get the current locale code snapshot.
+   * @returns The active locale code (e.g. `'en'`, `'fr'`).
+   */
+  get locale(): string {
+    return this.provider.getLocale()
+  }
+
+  /**
+   * Get the current text direction snapshot.
+   * @returns The text direction for the active locale, either `'ltr'` or `'rtl'`.
+   */
+  get direction(): 'ltr' | 'rtl' {
+    return this.provider.getDirection()
+  }
+
+  /**
+   * Translate a key.
+   *
+   * @param key - The dot-notation translation key to look up.
+   * @param values - Optional interpolation values to substitute into the translated string.
+   * @returns The translated and interpolated string for the current locale.
+   */
+  t(key: string, values?: InterpolationValues): string {
+    return this.provider.t(key, values)
+  }
+
+  /**
+   * Set the current locale.
+   *
+   * @param code - The locale code to switch to (e.g. `'en'`, `'fr'`).
+   */
+  setLocale(code: string): void {
+    this.provider.setLocale(code)
+  }
+
+  /**
+   * Format a number.
+   *
+   * @param value - The number to format.
+   * @param options - Locale-aware formatting options such as style, currency, and precision.
+   * @returns The locale-formatted number string.
+   */
+  formatNumber(value: number, options?: NumberFormatOptions): string {
+    return this.provider.formatNumber(value, options)
+  }
+
+  /**
+   * Format a date.
+   *
+   * @param value - The date to format, as a Date object, timestamp, or ISO string.
+   * @param options - Locale-aware formatting options such as date style and time zone.
+   * @returns The locale-formatted date string.
+   */
+  formatDate(value: Date | number | string, options?: DateFormatOptions): string {
+    return this.provider.formatDate(value, options)
+  }
+
+  /**
+   * Clean up locale change subscription and complete all subjects on service destruction.
+   */
+  ngOnDestroy(): void {
+    this.unsubscribe?.()
+    this.localeSubject.complete()
+    this.directionSubject.complete()
+    this.localesSubject.complete()
+  }
+}
+```
+
+#### `MoleculeLoggerService`
+
+Angular service for logging.
+
+Wraps molecule logger provider.
+
+```typescript
+@Injectable({
+  providedIn: 'root',
+})
+export class MoleculeLoggerService {
+  constructor(@Inject(LOGGER_PROVIDER) private provider: LoggerProvider) {}
+
+  /**
+   * Get a logger instance.
+   *
+   * @param name - Logger name (usually component/service name)
+   * @returns The result.
+   */
+  getLogger(name?: string): Logger {
+    return this.provider.getLogger(name)
+  }
+
+  /**
+   * Create a logger with custom configuration.
+   *
+   * @param config - Logger configuration
+   * @returns The created instance.
+   */
+  createLogger(config: LoggerConfig): Logger {
+    return this.provider.createLogger(config)
+  }
+
+  /**
+   * Set the global log level.
+   *
+   * @param level - Log level
+   */
+  setLevel(level: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'silent'): void {
+    this.provider.setLevel(level)
+  }
+
+  /**
+   * Get the current global log level.
+   *
+   * @returns The result.
+   */
+  getLevel(): string {
+    return this.provider.getLevel()
+  }
+
+  /**
+   * Enable logging.
+   */
+  enable(): void {
+    this.provider.enable()
+  }
+
+  /**
+   * Disable logging.
+   */
+  disable(): void {
+    this.provider.disable()
+  }
+
+  /**
+   * Check if logging is enabled.
+   *
+   * @returns Whether logging is enabled
+   */
+  isEnabled(): boolean {
+    return this.provider.isEnabled()
+  }
+}
+```
+
+#### `MoleculeRouterService`
+
+Angular service for routing.
+
+Wraps molecule router and exposes state as RxJS observables.
+
+```typescript
+@Injectable({
+  providedIn: 'root',
+})
+/**
+ * Molecule Router Service class.
+ */
+export class MoleculeRouterService implements OnDestroy {
+  private locationSubject: BehaviorSubject<RouteLocation>
+  private paramsSubject: BehaviorSubject<RouteParams>
+  private querySubject: BehaviorSubject<QueryParams>
+  private unsubscribe: (() => void) | null = null
+
+  /**
+   * Observable of the current location.
+   */
+  location$: Observable<RouteLocation>
+
+  /**
+   * Observable of route parameters.
+   */
+  params$: Observable<RouteParams>
+
+  /**
+   * Observable of query parameters.
+   */
+  query$: Observable<QueryParams>
+
+  /**
+   * Observable of the current pathname.
+   */
+  pathname$: Observable<string>
+
+  constructor(@Inject(ROUTER) private router: Router) {
+    this.locationSubject = new BehaviorSubject<RouteLocation>(router.getLocation())
+    this.paramsSubject = new BehaviorSubject<RouteParams>(router.getParams())
+    this.querySubject = new BehaviorSubject<QueryParams>(router.getQuery())
+
+    this.unsubscribe = router.subscribe(() => {
+      this.locationSubject.next(router.getLocation())
+      this.paramsSubject.next(router.getParams())
+      this.querySubject.next(router.getQuery())
+    })
+
+    this.location$ = this.locationSubject.asObservable()
+    this.params$ = this.paramsSubject.asObservable()
+    this.query$ = this.querySubject.asObservable()
+
+    this.pathname$ = this.location$.pipe(
+      map((loc) => loc.pathname),
+      distinctUntilChanged(),
+    )
+  }
+
+  /**
+   * Get the current location snapshot.
+   * @returns The result.
+   */
+  get location(): RouteLocation {
+    return this.router.getLocation()
+  }
+
   /**
-   * Optional middleware functions.
+   * Get the current params snapshot.
+   * @returns The result.
    */
-  middleware?: StoreMiddleware<T>[]
+  get params(): RouteParams {
+    return this.router.getParams()
+  }
+
+  /**
+   * Get the current query snapshot.
+   * @returns The result.
+   */
+  get query(): QueryParams {
+    return this.router.getQuery()
+  }
+
+  /**
+   * Navigate to a path.
+   *
+   * @param path - Target path
+   * @param options - Navigation options
+   */
+  navigate(path: string, options?: NavigateOptions): void {
+    this.router.navigate(path, options)
+  }
+
+  /**
+   * Navigate to a named route.
+   *
+   * @param name - Route name
+   * @param params - Route parameters
+   * @param query - Query parameters
+   * @param options - Navigation options
+   */
+  navigateTo(
+    name: string,
+    params?: RouteParams,
+    query?: QueryParams,
+    options?: NavigateOptions,
+  ): void {
+    this.router.navigateTo(name, params, query, options)
+  }
+
+  /**
+   * Go back in history.
+   */
+  back(): void {
+    this.router.back()
+  }
+
+  /**
+   * Go forward in history.
+   */
+  forward(): void {
+    this.router.forward()
+  }
+
+  /**
+   * Check if a path is currently active.
+   *
+   * @param path - Path to check
+   * @param exact - Whether to match exactly
+   * @returns The result.
+   */
+  isActive(path: string, exact = false): boolean {
+    return this.router.isActive(path, exact)
+  }
+
+  /**
+   * Cleans up subscriptions and completes subjects on service destruction.
+   */
+  ngOnDestroy(): void {
+    this.unsubscribe?.()
+    this.locationSubject.complete()
+    this.paramsSubject.complete()
+    this.querySubject.complete()
+  }
 }
 ```
 
-#### `Theme`
+#### `MoleculeStateService`
 
-Complete theme definition.
+Angular service for state management.
+
+Wraps molecule state stores and exposes them as RxJS observables.
 
 ```typescript
-interface Theme {
-  name: string
-  mode: 'light' | 'dark'
-  colors: ThemeColors
-  breakpoints: ThemeBreakpoints
-  spacing: ThemeSpacing
-  typography: ThemeTypography
-  borderRadius: ThemeBorderRadius
-  shadows: ThemeShadows
-  transitions: ThemeTransitions
-  zIndex: ThemeZIndex
+@Injectable({
+  providedIn: 'root',
+})
+/**
+ * Molecule State Service class.
+ */
+export class MoleculeStateService implements OnDestroy {
+  private subscriptions = new Map<Store<unknown>, () => void>()
+  private subjects = new Map<Store<unknown>, BehaviorSubject<unknown>>()
+
+  constructor(@Inject(STATE_PROVIDER) private provider: StateProvider) {}
+
+  /**
+   * Get an observable of the full store state.
+   *
+   * @param store - The store to observe
+   * @returns Observable of the store state
+   */
+  observe<T>(store: Store<T>): Observable<T> {
+    return this.getOrCreateSubject(store).asObservable() as Observable<T>
+  }
+
+  /**
+   * Select a piece of state from a store.
+   *
+   * @param store - The store to select from
+   * @param selector - Selector function
+   * @returns Observable of the selected state
+   */
+  select<T, S>(store: Store<T>, selector: (state: T) => S): Observable<S> {
+    return this.observe(store).pipe(map(selector), distinctUntilChanged())
+  }
+
+  /**
+   * Get the current snapshot of a store's state.
+   *
+   * @param store - The store
+   * @returns The result.
+   */
+  snapshot<T>(store: Store<T>): T {
+    return store.getState()
+  }
+
+  /**
+   * Update a store's state.
+   *
+   * @param store - The store to update
+   * @param partial - Partial state or updater function
+   */
+  update<T>(store: Store<T>, partial: Partial<T> | ((state: T) => Partial<T>)): void {
+    store.setState(partial)
+  }
+
+  /**
+   * Gets or creates a BehaviorSubject for the given store.
+   * @param store - The data store to observe.
+   * @returns The BehaviorSubject tracking the store state.
+   */
+  private getOrCreateSubject<T>(store: Store<T>): BehaviorSubject<T> {
+    let subject = this.subjects.get(store as Store<unknown>) as BehaviorSubject<T> | undefined
+
+    if (!subject) {
+      subject = new BehaviorSubject<T>(store.getState())
+      this.subjects.set(store as Store<unknown>, subject as BehaviorSubject<unknown>)
+
+      const unsubscribe = store.subscribe(() => {
+        subject!.next(store.getState())
+      })
+      this.subscriptions.set(store as Store<unknown>, unsubscribe)
+    }
+
+    return subject
+  }
+
+  /**
+   * Cleans up all store subscriptions and completes subjects on service destruction.
+   */
+  ngOnDestroy(): void {
+    // Clean up all subscriptions
+    this.subscriptions.forEach((unsubscribe) => unsubscribe())
+    this.subscriptions.clear()
+
+    // Complete all subjects
+    this.subjects.forEach((subject) => subject.complete())
+    this.subjects.clear()
+  }
 }
 ```
 
-#### `ThemeProvider`
+#### `MoleculeStorageService`
 
-Manages theme state including the active theme, mode toggling,
-and change subscriptions.
+Angular service for storage.
+
+Wraps molecule storage provider and returns RxJS observables.
 
 ```typescript
-interface ThemeProvider {
+@Injectable({
+  providedIn: 'root',
+})
+/**
+ * Molecule Storage Service class.
+ */
+export class MoleculeStorageService {
+  constructor(@Inject(STORAGE_PROVIDER) private provider: StorageProvider) {}
+
   /**
-   * Returns the currently active theme.
+   * Get a value from storage.
+   *
+   * @param key - Storage key
+   * @returns Observable of the value
    */
-  getTheme(): Theme
+  get<T>(key: string): Observable<T | null> {
+    return from(this.provider.get<T>(key))
+  }
+
   /**
-   * Sets the active theme by reference or by name.
+   * Set a value in storage.
    *
-   * @param theme - A `Theme` object or a theme name string to activate.
+   * @param key - Storage key
+   * @param value - Value to store
+   * @returns Observable that completes when done
    */
-  setTheme(theme: Theme | string): void
+  set<T>(key: string, value: T): Observable<void> {
+    return from(this.provider.set(key, value))
+  }
+
   /**
-   * Toggles between light and dark mode for the active theme.
+   * Remove a value from storage.
+   *
+   * @param key - Storage key
+   * @returns Observable that completes when done
    */
-  toggleMode(): void
+  remove(key: string): Observable<void> {
+    return from(this.provider.remove(key))
+  }
+
   /**
-   * Subscribes to theme changes. The callback fires whenever
-   * `setTheme()` or `toggleMode()` is called.
+   * Clear all values from storage.
    *
-   * @param callback - Invoked with the new theme after each change.
-   * @returns An unsubscribe function.
+   * @returns Observable that completes when done
    */
-  subscribe(callback: (theme: Theme) => void): () => void
+  clear(): Observable<void> {
+    return from(this.provider.clear())
+  }
+
   /**
-   * Returns all registered themes. Optional — not all providers
-   * support multiple themes.
+   * Get all keys in storage.
+   *
+   * @returns Observable of key array
    */
-  getThemes?(): Theme[]
+  keys(): Observable<string[]> {
+    return from(this.provider.keys())
+  }
+
   /**
-   * Returns the theme a render WITHOUT a browser produces — a server or
-   * build-time render, which has no storage and no `prefers-color-scheme`
-   * to read. A hydrating client renders this theme first, so its markup
-   * matches what the server sent, and switches to `getTheme()` right
-   * after. Optional — a provider whose theme cannot differ between the two
-   * need not implement it.
-   */
-  getServerTheme?(): Theme
+   * Create a reactive storage value with auto-loading.
+   *
+   * @param key - Storage key
+   * @param defaultValue - Default value if not found
+   * @returns BehaviorSubject that syncs with storage
+   */
+  createValue<T>(key: string, defaultValue: T): BehaviorSubject<StorageValueState<T>> {
+    const state = new BehaviorSubject<StorageValueState<T>>({
+      value: defaultValue,
+      loading: true,
+      error: null,
+    })
+
+    // Load initial value
+    this.get<T>(key).subscribe({
+      next: (value) => {
+        state.next({
+          value: value ?? defaultValue,
+          loading: false,
+          error: null,
+        })
+      },
+      error: (error) => {
+        state.next({
+          value: defaultValue,
+          loading: false,
+          error,
+        })
+      },
+    })
+
+    return state
+  }
+
+  /**
+   * Update a reactive storage value.
+   *
+   * @param key - Storage key
+   * @param value - New value
+   * @param state - State subject to update
+   */
+  updateValue<T>(key: string, value: T, state: BehaviorSubject<StorageValueState<T>>): void {
+    state.next({ ...state.value, loading: true })
+
+    this.set(key, value).subscribe({
+      next: () => {
+        state.next({ value, loading: false, error: null })
+      },
+      error: (error) => {
+        state.next({ ...state.value, loading: false, error })
+      },
+    })
+  }
 }
 ```
 
-#### `VersionService`
+#### `MoleculeThemeService`
 
-Version service interface.
+Angular service for theming.
+
+Wraps molecule theme provider and exposes state as RxJS observables.
 
 ```typescript
-interface VersionService {
-  state$: Observable<VersionState>
-  isUpdateAvailable$: Observable<boolean>
-  isChecking$: Observable<boolean>
-  isServiceWorkerWaiting$: Observable<boolean>
-  newVersion$: Observable<string | undefined>
-  getState: () => VersionState
-  checkForUpdates: () => Promise<boolean>
-  applyUpdate: (options?: { force?: boolean }) => void
-  dismissUpdate: () => void
-  startPeriodicChecks: (options?: UpdateCheckOptions) => void
-  stopPeriodicChecks: () => void
-  destroy: () => void
+@Injectable({
+  providedIn: 'root',
+})
+/**
+ * Molecule Theme Service class.
+ */
+export class MoleculeThemeService implements OnDestroy {
+  private themeSubject: BehaviorSubject<Theme>
+  private themeNameSubject: BehaviorSubject<string>
+  private unsubscribe: (() => void) | null = null
+
+  /**
+   * Observable of the current theme.
+   */
+  theme$: Observable<Theme>
+
+  /**
+   * Observable of the current theme name.
+   */
+  themeName$: Observable<string>
+
+  /**
+   * Observable of the theme mode (light/dark).
+   */
+  mode$: Observable<'light' | 'dark'>
+
+  constructor(@Inject(THEME_PROVIDER) private provider: ThemeProvider) {
+    this.themeSubject = new BehaviorSubject<Theme>(provider.getTheme())
+    this.themeNameSubject = new BehaviorSubject<string>(provider.getTheme().name)
+
+    this.unsubscribe = provider.subscribe(() => {
+      this.themeSubject.next(provider.getTheme())
+      this.themeNameSubject.next(provider.getTheme().name)
+    })
+
+    this.theme$ = this.themeSubject.asObservable()
+    this.themeName$ = this.themeNameSubject.asObservable()
+
+    this.mode$ = this.theme$.pipe(
+      map((theme: Theme) => theme.mode),
+      distinctUntilChanged(),
+    )
+  }
+
+  /**
+   * Get the current theme snapshot.
+   * @returns The result.
+   */
+  get theme(): Theme {
+    return this.provider.getTheme()
+  }
+
+  /**
+   * Get the current theme name snapshot.
+   * @returns The result.
+   */
+  get themeName(): string {
+    return this.provider.getTheme().name
+  }
+
+  /**
+   * Get available themes.
+   * @returns The result.
+   */
+  get themes(): Theme[] {
+    return this.provider.getThemes?.() ?? []
+  }
+
+  /**
+   * Set the current theme.
+   *
+   * @param name - Theme name
+   */
+  setTheme(name: string): void {
+    this.provider.setTheme(name)
+  }
+
+  /**
+   * Toggle to the next theme.
+   */
+  toggleTheme(): void {
+    const themes = this.themes
+    const currentName = this.themeName
+    const currentIndex = themes.findIndex((t: Theme) => t.name === currentName)
+    const nextIndex = (currentIndex + 1) % themes.length
+    this.provider.setTheme(themes[nextIndex])
+  }
+
+  /**
+   * Cleans up subscriptions and completes subjects on service destruction.
+   */
+  ngOnDestroy(): void {
+    this.unsubscribe?.()
+    this.themeSubject.complete()
+    this.themeNameSubject.complete()
+  }
 }
 ```
 
-### Types
+### Functions
 
-#### `QueryParams`
+#### `bumpLocaleVersion()`
 
-URL query string parameter map (single values or arrays for repeated keys).
+Bump the locale version signal, causing all template bindings that use
+the reactive `t()` to re-evaluate on the next change detection cycle.
+
+Called automatically by the `ENVIRONMENT_INITIALIZER` in `provideMolecule`.
 
 ```typescript
-type QueryParams = Record<string, string | string[] | undefined>
+function bumpLocaleVersion(): void
 ```
 
-#### `RouteParams`
+#### `t(key, values, options)`
 
-URL path parameter key-value map extracted from dynamic route segments (e.g. `{ id: '123' }`).
+Translate a key using the current locale.
+
+This is a signal-aware wrapper around `@molecule/app-i18n`'s `t()`.
+Reading the internal locale signal establishes an Angular reactivity
+dependency, so template bindings that call this function will be
+re-evaluated when the locale changes.
 
 ```typescript
-type RouteParams = Record<string, string>
+function t(
+  key: string,
+  values?: InterpolationValues,
+  options?: { defaultValue?: string; count?: number },
+): string
 ```
 
-### Classes
+- `key` — Translation key
+- `values` — Interpolation values
+- `options` — Options (defaultValue, count).
+- `options.defaultValue` — Fallback string when no translation is found.
+- `options.count` — Pluralization count.
+
+**Returns:** Translated string
+
+#### `provideState(provider)`
+
+Provide state management.
+
+```typescript
+function provideState(provider: StateProvider): EnvironmentProviders
+```
+
+- `provider` — State provider
+
+**Returns:** Environment providers
+
+#### `provideAuth(client)`
+
+Registers an AuthClient as an Angular environment provider for dependency injection.
+
+```typescript
+function provideAuth(client: AuthClient<T, Record<never, never>>): EnvironmentProviders
+```
+
+- `client` — Auth client
 
-#### `MoleculeAuthService`
+**Returns:** Environment providers
 
-Angular service for authentication.
+#### `provideTheme(provider)`
 
-Wraps molecule auth client and exposes state as RxJS observables.
+Registers a ThemeProvider as an Angular environment provider for dependency injection.
 
-#### `MoleculeFormInstance`
+```typescript
+function provideTheme(provider: ThemeProvider): EnvironmentProviders
+```
 
-Wrapper around a FormController that provides RxJS observables and
-synchronous accessors for use in Angular components.
+- `provider` — Theme provider
 
-#### `MoleculeFormsService`
+**Returns:** Environment providers
 
-Angular service for form handling.
+#### `provideRouter(router)`
 
-Wraps molecule form providers and creates form instances that expose
-state as RxJS observables.
+Registers a Router as an Angular environment provider for dependency injection.
 
-#### `MoleculeHttpService`
+```typescript
+function provideRouter(router: Router): EnvironmentProviders
+```
 
-Angular service for HTTP requests.
+- `router` — Router instance
 
-Wraps molecule HTTP client and returns RxJS observables.
+**Returns:** Environment providers
 
-#### `MoleculeI18nService`
+#### `provideI18n(provider)`
 
-Angular service for internationalization.
+Registers an I18nProvider as an Angular environment provider for dependency injection.
 
-Wraps molecule i18n provider and exposes state as RxJS observables.
+```typescript
+function provideI18n(provider: I18nProvider): EnvironmentProviders
+```
 
-#### `MoleculeLoggerService`
+- `provider` — I18n provider
 
-Angular service for logging.
+**Returns:** Environment providers
 
-Wraps molecule logger provider.
+#### `provideHttp(client)`
 
-#### `MoleculeRouterService`
+Provide HTTP client.
 
-Angular service for routing.
+```typescript
+function provideHttp(client: HttpClient): EnvironmentProviders
+```
 
-Wraps molecule router and exposes state as RxJS observables.
+- `client` — HTTP client
 
-#### `MoleculeStateService`
+**Returns:** Environment providers
 
-Angular service for state management.
+#### `provideStorage(provider)`
 
-Wraps molecule state stores and exposes them as RxJS observables.
+Registers a StorageProvider as an Angular environment provider for dependency injection.
 
-#### `MoleculeStorageService`
+```typescript
+function provideStorage(provider: StorageProvider): EnvironmentProviders
+```
 
-Angular service for storage.
+- `provider` — Storage provider
 
-Wraps molecule storage provider and returns RxJS observables.
+**Returns:** Environment providers
 
-#### `MoleculeThemeService`
+#### `provideLogger(provider)`
 
-Angular service for theming.
+Registers a LoggerProvider as an Angular environment provider for dependency injection.
 
-Wraps molecule theme provider and exposes state as RxJS observables.
+```typescript
+function provideLogger(provider: LoggerProvider): EnvironmentProviders
+```
 
-### Functions
+- `provider` — Logger provider
 
-#### `bumpLocaleVersion()`
+**Returns:** Environment providers
 
-Bump the locale version signal, causing all template bindings that use
-the reactive `t()` to re-evaluate on the next change detection cycle.
+#### `provideMolecule(config)`
 
-Called automatically by the `ENVIRONMENT_INITIALIZER` in `provideMolecule`.
+Provide all molecule services at once.
 
 ```typescript
-function bumpLocaleVersion(): void
+function provideMolecule(config: MoleculeModuleConfig): EnvironmentProviders
 ```
 
+- `config` — Configuration with all providers
+
+**Returns:** Environment providers
+
 #### `createAsyncState(initialState)`
 
 Creates an async-capable state manager.
@@ -1422,7 +2776,9 @@ function createCapacitorAppState(options?: CapacitorAppOptions): CapacitorAppMan
 Creates a change password state manager with async state tracking.
 
 ```typescript
-function createChangePasswordState(client: AuthClient<UserProfile>): ChangePasswordStateManager
+function createChangePasswordState(
+  client: AuthClient<UserProfile, Record<never, never>>,
+): ChangePasswordStateManager
 ```
 
 - `client` — Auth client
@@ -1444,7 +2800,7 @@ function createDeviceService(): DeviceService
 Creates a login state manager with async state tracking.
 
 ```typescript
-function createLoginState(client: AuthClient<T>): LoginStateManager<T>
+function createLoginState(client: AuthClient<T, Record<never, never>>): LoginStateManager<T>
 ```
 
 - `client` — Auth client
@@ -1472,7 +2828,9 @@ function createOAuthState(options?: OAuthOptions): OAuthStateManager
 Creates a password reset state manager with async state tracking.
 
 ```typescript
-function createPasswordResetState(client: AuthClient<UserProfile>): PasswordResetStateManager
+function createPasswordResetState(
+  client: AuthClient<UserProfile, Record<never, never>>,
+): PasswordResetStateManager
 ```
 
 - `client` — Auth client
@@ -1516,7 +2874,7 @@ function createPushService(): PushService
 Creates a signup state manager with async state tracking.
 
 ```typescript
-function createSignupState(client: AuthClient<T>): SignupStateManager<T>
+function createSignupState(client: AuthClient<T, Record<never, never>>): SignupStateManager<T>
 ```
 
 - `client` — Auth client
@@ -1533,155 +2891,38 @@ function createVersionService(): VersionService
 
 **Returns:** The created instance.
 
-#### `provideAuth(client)`
-
-Registers an AuthClient as an Angular environment provider for dependency injection.
-
-```typescript
-function provideAuth(client: AuthClient<T>): EnvironmentProviders
-```
-
-- `client` — Auth client
-
-**Returns:** Environment providers
-
-#### `provideHttp(client)`
-
-Provide HTTP client.
-
-```typescript
-function provideHttp(client: HttpClient): EnvironmentProviders
-```
-
-- `client` — HTTP client
-
-**Returns:** Environment providers
-
-#### `provideI18n(provider)`
-
-Registers an I18nProvider as an Angular environment provider for dependency injection.
-
-```typescript
-function provideI18n(provider: I18nProvider): EnvironmentProviders
-```
-
-- `provider` — I18n provider
-
-**Returns:** Environment providers
-
-#### `provideLogger(provider)`
-
-Registers a LoggerProvider as an Angular environment provider for dependency injection.
-
-```typescript
-function provideLogger(provider: LoggerProvider): EnvironmentProviders
-```
-
-- `provider` — Logger provider
-
-**Returns:** Environment providers
-
-#### `provideMolecule(config)`
-
-Provide all molecule services at once.
-
-```typescript
-function provideMolecule(config: MoleculeModuleConfig): EnvironmentProviders
-```
-
-- `config` — Configuration with all providers
-
-**Returns:** Environment providers
-
-#### `provideRouter(router)`
-
-Registers a Router as an Angular environment provider for dependency injection.
-
-```typescript
-function provideRouter(router: Router): EnvironmentProviders
-```
-
-- `router` — Router instance
-
-**Returns:** Environment providers
-
-#### `provideState(provider)`
-
-Provide state management.
-
-```typescript
-function provideState(provider: StateProvider): EnvironmentProviders
-```
-
-- `provider` — State provider
-
-**Returns:** Environment providers
-
-#### `provideStorage(provider)`
-
-Registers a StorageProvider as an Angular environment provider for dependency injection.
-
-```typescript
-function provideStorage(provider: StorageProvider): EnvironmentProviders
-```
-
-- `provider` — Storage provider
-
-**Returns:** Environment providers
+### Constants
 
-#### `provideTheme(provider)`
+#### `STATE_PROVIDER`
 
-Registers a ThemeProvider as an Angular environment provider for dependency injection.
+Injection token for state provider.
 
 ```typescript
-function provideTheme(provider: ThemeProvider): EnvironmentProviders
+const STATE_PROVIDER: InjectionToken<StateProvider>
 ```
 
-- `provider` — Theme provider
-
-**Returns:** Environment providers
-
-#### `t(key, values, options)`
-
-Translate a key using the current locale.
+#### `AUTH_CLIENT`
 
-This is a signal-aware wrapper around `@molecule/app-i18n`'s `t()`.
-Reading the internal locale signal establishes an Angular reactivity
-dependency, so template bindings that call this function will be
-re-evaluated when the locale changes.
+Injection token for auth client.
 
 ```typescript
-function t(
-  key: string,
-  values?: InterpolationValues,
-  options?: { defaultValue?: string; count?: number },
-): string
+const AUTH_CLIENT: InjectionToken<AuthClient<unknown, Record<never, never>>>
 ```
 
-- `key` — Translation key
-- `values` — Interpolation values
-- `options` — Options (defaultValue, count).
-- `options.defaultValue` — Fallback string when no translation is found.
-- `options.count` — Pluralization count.
-
-**Returns:** Translated string
-
-### Constants
-
-#### `AUTH_CLIENT`
+#### `THEME_PROVIDER`
 
-Injection token for auth client.
+Injection token for theme provider.
 
 ```typescript
-const AUTH_CLIENT: InjectionToken<AuthClient<unknown>>
+const THEME_PROVIDER: InjectionToken<ThemeProvider>
 ```
 
-#### `HTTP_CLIENT`
+#### `ROUTER`
 
-Injection token for HTTP client.
+Injection token for router.
 
 ```typescript
-const HTTP_CLIENT: InjectionToken<HttpClient>
+const ROUTER: InjectionToken<Router>
 ```
 
 #### `I18N_PROVIDER`
@@ -1692,28 +2933,12 @@ Injection token for i18n provider.
 const I18N_PROVIDER: InjectionToken<I18nProvider>
 ```
 
-#### `LOGGER_PROVIDER`
-
-Injection token for logger provider.
-
-```typescript
-const LOGGER_PROVIDER: InjectionToken<LoggerProvider>
-```
-
-#### `ROUTER`
-
-Injection token for router.
-
-```typescript
-const ROUTER: InjectionToken<Router>
-```
-
-#### `STATE_PROVIDER`
+#### `HTTP_CLIENT`
 
-Injection token for state provider.
+Injection token for HTTP client.
 
 ```typescript
-const STATE_PROVIDER: InjectionToken<StateProvider>
+const HTTP_CLIENT: InjectionToken<HttpClient>
 ```
 
 #### `STORAGE_PROVIDER`
@@ -1724,12 +2949,12 @@ Injection token for storage provider.
 const STORAGE_PROVIDER: InjectionToken<StorageProvider>
 ```
 
-#### `THEME_PROVIDER`
+#### `LOGGER_PROVIDER`
 
-Injection token for theme provider.
+Injection token for logger provider.
 
 ```typescript
-const THEME_PROVIDER: InjectionToken<ThemeProvider>
+const LOGGER_PROVIDER: InjectionToken<LoggerProvider>
 ```
 
 ## Injection Notes