@molecule/app-solid 1.0.1 → 1.0.3

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-08-04T01:52:41.099Z
+Generated: 2026-10-21T09:43:19.112Z
 -->
 
 # @molecule/app-solid
 
-> **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.
-
 Solid.js framework bindings for molecule.dev.
 
 Provides Solid-specific implementations of molecule.dev core interfaces
@@ -20,6 +16,10 @@ app in `MoleculeProvider` with a `config` of providers, then consume them
 through `createAuth`, `createTheme`, `createRouter`, `createI18n`, and the
 other primitives.
 
+> **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
@@ -69,893 +69,1179 @@ npm install @molecule/app-solid @molecule/app-auth @molecule/app-device @molecul
 
 ### Interfaces
 
-#### `AuthClient`
+#### `AuthState`
 
-Auth client interface that all auth bond packages must implement.
-Provides login/logout/register flows, token management, profile
-updates, and auth state subscription.
+Reactive authentication state snapshot (initialized, authenticated, user, loading, and error).
 
 ```typescript
-interface AuthClient<T = UserProfile> {
+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.
+   */
+  initialized: boolean
+  /**
+   * Whether the user is authenticated.
+   */
+  authenticated: boolean
+  /**
+   * Current user (if authenticated).
+   */
+  user: T | null
   /**
-   * Returns the current authentication state snapshot.
+   * Whether an auth operation is in progress.
    */
-  getState(): AuthState<T>
+  loading: boolean
   /**
-   * Returns whether the user is currently authenticated.
+   * Last auth error (if any).
    */
-  isAuthenticated(): boolean
+  error: string | null
+}
+```
+
+#### `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, TRegister extends Record<string, unknown> = 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-solid/dist
+```
+
+#### `FormController`
+
+Form controller interface.
+
+All form providers must implement this interface.
+
+```typescript
+interface FormController<T extends Record<string, unknown> = Record<string, unknown>> {
   /**
-   * Gets the current user.
+   * Gets the current form state.
    */
-  getUser(): T | null
+  getState(): FormState<T>
   /**
-   * 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.
+   * Gets the value of a specific field.
    */
-  setUser(user: T | null): void
+  getValue(name: string): unknown
+  getValue<K extends keyof T>(name: K): T[K]
   /**
-   * Gets the current access token.
+   * Gets all form values.
    */
-  getAccessToken(): string | null
+  getValues(): T
   /**
-   * 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.
+   * Sets the value of a specific field.
    */
-  setAccessToken(token: string | null): void
+  setValue(
+    name: string,
+    value: unknown,
+    options?: {
+      shouldValidate?: boolean
+      shouldDirty?: boolean
+      shouldTouch?: boolean
+    },
+  ): void
   /**
-   * Gets the refresh token.
+   * Sets multiple values at once.
    */
-  getRefreshToken(): string | null
+  setValues(
+    values: Partial<T>,
+    options?: {
+      shouldValidate?: boolean
+    },
+  ): void
   /**
-   * Logs in with credentials.
+   * Gets the error for a specific field.
    */
-  login(credentials: LoginCredentials): Promise<AuthResult<T>>
+  getError(name: string): string | undefined
   /**
-   * Logs out the current user.
+   * Sets the error for a specific field.
    */
-  logout(): Promise<void>
+  setError(name: string, error: string | undefined): void
   /**
-   * Registers a new user.
+   * Clears the error for a specific field.
    */
-  register(data: RegisterData): Promise<AuthResult<T>>
+  clearError<K extends keyof T>(name: K): void
   /**
-   * Refreshes the access token.
+   * Clears all errors.
    */
-  refresh(): Promise<AuthResult<T>>
+  clearErrors(): void
   /**
-   * Requests a password reset.
+   * Gets the field state for a specific field.
    */
-  requestPasswordReset(data: PasswordResetRequest): Promise<void>
+  getFieldState<K extends keyof T>(name: K): FieldState<T[K]>
   /**
-   * Confirms a password reset.
+   * Registers a field for form management.
    */
-  confirmPasswordReset(data: PasswordResetConfirm): Promise<void>
+  register(nameOrOptions: string | RegisterOptions, options?: RegisterOptions): FieldRegistration
   /**
-   * Updates the current user's profile.
+   * Unregisters a field.
    */
-  updateProfile(data: Partial<T>): Promise<T>
+  unregister(name: string): void
   /**
-   * Changes the current user's password.
+   * Validates a specific field.
    */
-  changePassword(oldPassword: string, newPassword: string): Promise<void>
+  validateField<K extends keyof T>(name: K): Promise<boolean>
   /**
-   * Initializes auth state (e.g., from stored tokens).
+   * Validates all fields.
    */
-  initialize(): Promise<void>
+  validate(): Promise<boolean>
   /**
-   * Subscribes to auth state changes.
+   * Resets the form to initial values.
    */
-  subscribe(callback: (state: AuthState<T>) => void): () => void
+  reset(values?: Partial<T>): void
   /**
-   * Subscribes to auth state changes (alias for subscribe).
+   * Handles form submission.
    */
-  onAuthChange(callback: (state: AuthState<T>) => void): () => void
+  handleSubmit(
+    onSubmit: (values: T) => void | Promise<void>,
+    onError?: (errors: Partial<Record<keyof T, string>>) => void,
+  ): (event?: { preventDefault?: () => void }) => Promise<void>
   /**
-   * Gets the current access token (alias for getAccessToken).
+   * Sets focus to a field.
    */
-  getToken?(): string | null
+  setFocus(name: keyof T): void
   /**
-   * Adds an auth event listener.
+   * Subscribes to form state changes.
    */
-  addEventListener(listener: AuthEventListener): () => void
+  subscribe(callback: (state: FormState<T>) => void): () => void
   /**
-   * Destroys the auth client.
+   * Destroys the form controller.
    */
   destroy(): void
 }
 ```
 
-#### `AuthPrimitives`
-
-Auth primitives return type.
-
-```typescript
-interface AuthPrimitives<T = unknown> {
-  state: Accessor<AuthState<T>>
-  user: Accessor<T | null>
-  isAuthenticated: Accessor<boolean>
-  isLoading: Accessor<boolean>
-  login: AuthClient<T>['login']
-  logout: AuthClient<T>['logout']
-  register: AuthClient<T>['register']
-  refresh: AuthClient<T>['refresh']
-}
-```
-
-#### `AuthState`
+#### `FormOptions`
 
-Reactive authentication state snapshot (initialized, authenticated, user, loading, and error).
+Form creation options.
 
 ```typescript
-interface AuthState<T = UserProfile> {
+interface FormOptions<T extends Record<string, unknown>> {
   /**
-   * Whether auth state has been initialized.
+   * Default values.
    */
-  initialized: boolean
+  defaultValues?: Partial<T>
   /**
-   * Whether the user is authenticated.
+   * Validation mode.
    */
-  authenticated: boolean
+  mode?: 'onSubmit' | 'onChange' | 'onBlur' | 'all'
   /**
-   * Current user (if authenticated).
+   * Revalidation mode.
    */
-  user: T | null
+  reValidateMode?: 'onChange' | 'onBlur' | 'onSubmit'
   /**
-   * Whether an auth operation is in progress.
+   * Whether to focus the first error field on submit.
    */
-  loading: boolean
+  shouldFocusError?: boolean
   /**
-   * Last auth error (if any).
+   * Form-level validation function.
    */
-  error: string | null
+  validate?: (
+    values: T,
+  ) => Partial<Record<keyof T, string>> | Promise<Partial<Record<keyof T, string>>>
 }
 ```
 
-#### `CapacitorAppPrimitives`
-
-Capacitor app primitives return type.
-
-```typescript
-interface CapacitorAppPrimitives {
-  state: Accessor<CapacitorAppState>
-  ready: Accessor<boolean>
-  initialize: () => Promise<void>
-}
-```
+#### `HttpClient`
 
-#### `CreateAsyncStateReturn`
+HTTP client interface.
 
-Return type for createAsyncState.
+All HTTP providers must implement this interface.
 
 ```typescript
-interface CreateAsyncStateReturn<T> {
-  state: () => 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
+interface HttpClient {
+  /**
+   * Base URL for all requests.
+   */
+  baseURL: string
+  /**
+   * Default headers for all requests.
+   */
+  defaultHeaders: Record<string, string>
+  /**
+   * 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>>
+  /**
+   * Makes a GET request.
+   */
+  get<T = unknown>(url: string, config?: RequestConfig): Promise<HttpResponse<T>>
+  /**
+   * 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. `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. `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>>
+  /**
+   * Makes a DELETE request.
+   */
+  delete<T = unknown>(url: string, config?: RequestConfig): Promise<HttpResponse<T>>
+  /**
+   * Adds a request interceptor.
+   * Returns a function to remove the interceptor.
+   */
+  addRequestInterceptor(interceptor: RequestInterceptor): () => void
+  /**
+   * Adds a response interceptor.
+   * Returns a function to remove the interceptor.
+   */
+  addResponseInterceptor(interceptor: ResponseInterceptor): () => void
+  /**
+   * Adds an error interceptor.
+   * Returns a function to remove the interceptor.
+   */
+  addErrorInterceptor(interceptor: ErrorInterceptor): () => void
+  /**
+   * Sets the authorization token.
+   */
+  setAuthToken(token: string | null): void
+  /**
+   * Returns the current authorization token, or `null` if not set.
+   */
+  getAuthToken(): string | null
+  /**
+   * Registers a handler for authentication errors (401).
+   *
+   * @returns An unsubscribe function.
+   */
+  onAuthError(handler: () => void): () => void
 }
 ```
 
-#### `CreateChangePasswordReturn`
-
-Return type for createChangePassword primitive.
-
-```typescript
-interface CreateChangePasswordReturn {
-  state: Accessor<PromiseState<void>>
-  changePassword: (oldPassword: string, newPassword: string) => Promise<void>
-  reset: () => void
-}
-```
+#### `I18nProvider`
 
-#### `CreateFormResult`
+i18n provider interface.
 
-Result of createForm primitive.
+All i18n providers must implement this interface.
 
 ```typescript
-interface CreateFormResult<T extends Record<string, unknown>> {
-  /** Reactive form state accessor. */
-  formState: Accessor<FormState<T>>
-
-  /** Whether the form is currently valid. */
-  isValid: Accessor<boolean>
-
-  /** Whether any field has been modified. */
-  isDirty: Accessor<boolean>
-
-  /** Whether the form is currently submitting. */
-  isSubmitting: Accessor<boolean>
-
-  /** Current field errors. */
-  errors: Accessor<Partial<Record<keyof T, string>>>
-
-  /** Register a field for form management. */
-  register: (name: keyof T, options?: RegisterOptions) => FieldRegistration
-
-  /** Get the current value of a field. */
-  getValue: <K extends keyof T>(name: K) => T[K]
-
-  /** Set the value of a field. */
-  setValue: <K extends keyof T>(name: K, value: T[K]) => void
-
-  /** Get the error message for a field. */
-  getError: (name: keyof T) => string | undefined
-
-  /** Set an error message for a field. */
-  setError: (name: keyof T, error: string | undefined) => void
-
-  /** Clear all field errors. */
-  clearErrors: () => void
-
-  /** Create a submit handler function. */
-  handleSubmit: (
-    onSubmit: (values: T) => void | Promise<void>,
-  ) => (event?: { preventDefault?: () => void }) => Promise<void>
-
-  /** Reset the form to initial or provided values. */
-  reset: (values?: Partial<T>) => void
-
-  /** Validate all fields. */
-  validate: () => Promise<boolean>
-
-  /** The raw FormController instance for advanced use. */
-  controller: FormController<T>
-}
-```
-
-#### `CreateLoginReturn`
-
-Return type for createLogin primitive.
-
-```typescript
-interface CreateLoginReturn<T = unknown> {
-  state: Accessor<PromiseState<AuthResult<T>>>
-  login: (credentials: LoginCredentials) => Promise<AuthResult<T>>
-  reset: () => void
-}
-```
-
-#### `CreateOAuthOptions`
-
-OAuth configuration options.
-
-```typescript
-interface CreateOAuthOptions {
-  /** 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. */
-  onError?: (error: string) => void
+interface I18nProvider {
   /**
-   * Auth client used to establish the session after the code exchange.
-   * Overrides context resolution — when omitted, the client is resolved from
-   * the surrounding `MoleculeProvider` (tolerated when absent; see the
-   * cookie-session fallback documented on
-   * {@link CreateOAuthReturn.handleCallback}).
+   * Gets the current locale.
    */
-  authClient?: AuthClient<unknown>
-}
-```
-
-#### `CreateOAuthReturn`
-
-Return type for createOAuth primitive.
-
-```typescript
-interface CreateOAuthReturn {
-  /** Accessor for the configured OAuth provider names. */
-  providers: Accessor<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
+  getLocale(): string
   /**
-   * Handles the OAuth callback: exchanges the `code` URL parameter for a
-   * session. Invoked automatically at creation (see {@link createOAuth});
-   * 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.
+   * Sets the current locale.
    *
-   * When an auth client is available (explicit option or context), 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.
+   * **Fleet contract:** every conformant provider (the core simple provider,
+   * `@molecule/api-i18n-simple`, `@molecule/app-i18n-i18next`, and
+   * `@molecule/app-i18n-react-i18next`) MUST throw `Error('Locale "<code>"
+   * not found')` when `locale` is not registered — via the constructor's
+   * `initialLocales`/`locales` config, `addLocale()`, or `addTranslations()`
+   * (all three register a locale). It must NOT silently degrade to
+   * fallback-locale text while `getLocale()` reports the unregistered code —
+   * that divergence makes a misconfigured locale switch indistinguishable
+   * from a working one until a user notices the wrong language on screen.
    */
-  handleCallback: () => Promise<void>
-}
-```
-
-#### `CreatePasswordResetReturn`
-
-Return type for createPasswordReset primitive.
-
-```typescript
-interface CreatePasswordResetReturn {
-  requestState: Accessor<PromiseState<void>>
-  confirmState: Accessor<PromiseState<void>>
-  requestReset: (data: PasswordResetRequest) => Promise<void>
-  confirmReset: (data: PasswordResetConfirm) => Promise<void>
-  reset: () => void
-}
-```
-
-#### `CreatePromiseReturn`
-
-Promise state accessor with actions.
-
-```typescript
-interface CreatePromiseReturn<T> {
-  state: () => PromiseState<T>
-  call: (...args: any[]) => Promise<T>
-  cancel: (message?: string) => void
-  reset: () => void
-}
-```
-
-#### `CreateSignupReturn`
-
-Return type for createSignup primitive.
-
-```typescript
-interface CreateSignupReturn<T = unknown> {
-  state: Accessor<PromiseState<AuthResult<T>>>
-  signup: (data: RegisterData) => Promise<AuthResult<T>>
-  reset: () => void
-}
-```
-
-#### `DevicePrimitives`
-
-Device primitives return type.
-
-```typescript
-interface DevicePrimitives {
-  deviceInfo: DeviceInfo
-  screenInfo: ScreenInfo
-  hardwareInfo: HardwareInfo
-  featureSupport: FeatureSupport
-  supports: (feature: keyof FeatureSupport) => boolean
-  isOnline: () => boolean
-  isStandalone: () => boolean
-  language: string
-  languages: string[]
-}
-```
-
-#### `FormController`
-
-Form controller interface.
-
-All form providers must implement this interface.
-
-```typescript
-interface FormController<T extends Record<string, unknown> = Record<string, unknown>> {
+  setLocale(locale: string): Promise<void>
   /**
-   * Gets the current form state.
+   * Gets all available locales.
    */
-  getState(): FormState<T>
+  getLocales(): LocaleConfig[]
   /**
-   * Gets the value of a specific field.
+   * Adds a locale.
    */
-  getValue(name: string): unknown
-  getValue<K extends keyof T>(name: K): T[K]
+  addLocale(config: LocaleConfig): void
   /**
-   * Gets all form values.
+   * Removes a locale by code, notifying subscribers so language pickers
+   * built on `onLocaleChange` re-render their list. If the removed locale
+   * is currently active, the caller is responsible for switching to a
+   * fallback (e.g. `'en'`) BEFORE calling this — the provider will not
+   * auto-fall-back on its own.
+   *
+   * Returns `true` if the locale was registered and removed, `false`
+   * otherwise.
    */
-  getValues(): T
+  removeLocale(code: string): boolean
   /**
-   * Sets the value of a specific field.
+   * Adds translations to a locale. Auto-creates the locale if it doesn't exist.
+   *
+   * **Fleet contract:** merges are DEEP, not a shallow spread — registering
+   * two calls (e.g. two modules) that share a top-level namespace key merges
+   * their subtrees instead of the second call clobbering the first's nested
+   * translations wholesale. `@molecule/api-i18n-simple` implements the same
+   * contract on the API side.
    */
-  setValue(
-    name: string,
-    value: unknown,
-    options?: {
-      shouldValidate?: boolean
-      shouldDirty?: boolean
-      shouldTouch?: boolean
-    },
-  ): void
+  addTranslations(locale: string, translations: Translations, namespace?: string): void
   /**
-   * Sets multiple values at once.
+   * Translates a key with optional interpolation values and pluralization.
+   *
+   * **Fleet plural contract (matches i18next's own key resolution order):**
+   * when `options.count` is provided, the plural-suffixed key
+   * (`` `${key}_${pluralForm}` ``, e.g. `item_one`/`item_few`/…, falling back
+   * to `` `${key}_other` ``) is looked up FIRST and wins over the base `key`
+   * if BOTH are registered. Only when no plural-suffixed key exists at all
+   * does resolution fall back to the base key. A catalog that ships both
+   * `item` and `item_one`/`item_other` therefore pluralizes identically
+   * whichever provider is bonded.
+   *
+   * @returns The translated string, or the default value / key if not found.
    */
-  setValues(
-    values: Partial<T>,
+  t(
+    key: string,
+    values?: InterpolationValues,
     options?: {
-      shouldValidate?: boolean
+      defaultValue?: string
+      count?: number
     },
-  ): void
-  /**
-   * Gets the error for a specific field.
-   */
-  getError(name: string): string | undefined
-  /**
-   * Sets the error for a specific field.
-   */
-  setError(name: string, error: string | undefined): void
-  /**
-   * Clears the error for a specific field.
-   */
-  clearError<K extends keyof T>(name: K): void
+  ): string
   /**
-   * Clears all errors.
+   * Checks if a translation key exists.
+   *
+   * **Fleet contract:** follows the SAME locale-resolution chain as `t()` —
+   * the active locale, then the English fallback — so `exists(key) === true`
+   * whenever `t(key)` would render real translated text (not the raw key or
+   * an inline `defaultValue`). Do not narrow this to "only the active
+   * locale's own catalog"; that made `exists()` return `false` for keys `t()`
+   * happily rendered via the English fallback, and the answer differed by
+   * provider.
+   *
+   * @returns `true` if the key has a translation.
    */
-  clearErrors(): void
+  exists(key: string): boolean
   /**
-   * Gets the field state for a specific field.
+   * Formats a number according to the current locale.
+   *
+   * @returns The locale-formatted number string.
    */
-  getFieldState<K extends keyof T>(name: K): FieldState<T[K]>
+  formatNumber(value: number, options?: NumberFormatOptions): string
   /**
-   * Registers a field for form management.
+   * Formats a date according to the current locale.
+   *
+   * @returns The locale-formatted date string.
    */
-  register(nameOrOptions: string | RegisterOptions, options?: RegisterOptions): FieldRegistration
+  formatDate(value: Date | number | string, options?: DateFormatOptions): string
   /**
-   * Unregisters a field.
+   * Formats a relative time (e.g. "2 hours ago").
+   *
+   * @returns The locale-formatted relative time string.
    */
-  unregister(name: string): void
+  formatRelativeTime(
+    value: Date | number,
+    options?: {
+      unit?: Intl.RelativeTimeFormatUnit
+    },
+  ): string
   /**
-   * Validates a specific field.
+   * Formats a list (e.g. "A, B, and C").
+   *
+   * @returns The locale-formatted list string.
    */
-  validateField<K extends keyof T>(name: K): Promise<boolean>
+  formatList(
+    values: string[],
+    options?: {
+      type?: 'conjunction' | 'disjunction' | 'unit'
+    },
+  ): string
   /**
-   * Validates all fields.
+   * Subscribes to locale changes.
+   *
+   * @returns An unsubscribe function.
    */
-  validate(): Promise<boolean>
+  onLocaleChange(listener: (locale: string) => void): () => void
   /**
-   * Resets the form to initial values.
+   * Gets the text direction for the current locale.
+   *
+   * @returns `'ltr'` or `'rtl'`.
    */
-  reset(values?: Partial<T>): void
+  getDirection(): 'ltr' | 'rtl'
   /**
-   * Handles form submission.
+   * Checks if a translation key exists (alias for exists).
    */
-  handleSubmit(
-    onSubmit: (values: T) => void | Promise<void>,
-    onError?: (errors: Partial<Record<keyof T, string>>) => void,
-  ): (event?: { preventDefault?: () => void }) => Promise<void>
+  hasKey?(key: string): boolean
   /**
-   * Sets focus to a field.
+   * Checks if the provider is ready.
    */
-  setFocus(name: keyof T): void
+  isReady?(): boolean
   /**
-   * Subscribes to form state changes.
+   * Registers a callback for when the provider is ready.
    */
-  subscribe(callback: (state: FormState<T>) => void): () => void
+  onReady?(callback: () => void): () => void
   /**
-   * Destroys the form controller.
+   * Registers a lazily-loaded content module for automatic reload on locale changes.
+   * All registered content is reloaded during `setLocale()` before listeners fire,
+   * ensuring content is available on the first re-render with no flash.
+   *
+   * Idempotent: registering the same module name twice is a no-op.
    */
-  destroy(): void
+  registerContent?(module: string, loader: (locale: string) => Promise<void>): void
 }
 ```
 
-#### `FormOptions`
+#### `Logger`
 
-Form creation options.
+Logger instance with leveled logging methods, child logger creation,
+and transport management.
 
 ```typescript
-interface FormOptions<T extends Record<string, unknown>> {
+interface Logger {
   /**
-   * Default values.
+   * Logs a trace message.
    */
-  defaultValues?: Partial<T>
+  trace(message: string, ...args: unknown[]): void
   /**
-   * Validation mode.
+   * Logs a debug message.
    */
-  mode?: 'onSubmit' | 'onChange' | 'onBlur' | 'all'
+  debug(message: string, ...args: unknown[]): void
   /**
-   * Revalidation mode.
+   * Logs an info message.
    */
-  reValidateMode?: 'onChange' | 'onBlur' | 'onSubmit'
+  info(message: string, ...args: unknown[]): void
   /**
-   * Whether to focus the first error field on submit.
+   * Logs a warning message.
    */
-  shouldFocusError?: boolean
+  warn(message: string, ...args: unknown[]): void
   /**
-   * Form-level validation function.
+   * Logs an error message.
    */
-  validate?: (
-    values: T,
-  ) => Partial<Record<keyof T, string>> | Promise<Partial<Record<keyof T, string>>>
-}
-```
-
-#### `HttpClient`
-
-HTTP client interface.
-
-All HTTP providers must implement this interface.
-
-```typescript
-interface HttpClient {
+  error(message: string | Error, ...args: unknown[]): void
   /**
-   * Base URL for all requests.
+   * Sets the log level.
    */
-  baseURL: string
+  setLevel(level: LogLevel): void
   /**
-   * Default headers for all requests.
+   * Gets the current log level.
    */
-  defaultHeaders: Record<string, string>
+  getLevel(): LogLevel
   /**
-   * Makes a generic HTTP request.
+   * Creates a child logger with a namespace.
    */
-  request<T = unknown>(config: FullRequestConfig): Promise<HttpResponse<T>>
+  child(name: string, context?: Record<string, unknown>): Logger
   /**
-   * Makes a GET request.
+   * Adds additional context to the logger.
    */
-  get<T = unknown>(url: string, config?: RequestConfig): Promise<HttpResponse<T>>
+  withContext(context: Record<string, unknown>): Logger
   /**
-   * Makes a POST request.
+   * Adds a transport.
    */
-  post<T = unknown>(url: string, data?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>
+  addTransport(transport: LogTransport): () => void
   /**
-   * Makes a PUT request.
+   * Removes a transport.
    */
-  put<T = unknown>(url: string, data?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>
+  removeTransport(transport: LogTransport): void
+}
+```
+
+#### `LoggerProvider`
+
+Logger provider interface that all logger bond packages must implement.
+Creates and manages logger instances and global log configuration.
+
+```typescript
+interface LoggerProvider {
   /**
-   * Makes a PATCH request.
+   * Gets a logger by name, or the root logger if no name given.
    */
-  patch<T = unknown>(url: string, data?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>
+  getLogger(name?: string): Logger
   /**
-   * Makes a DELETE request.
+   * Creates a named logger.
    */
-  delete<T = unknown>(url: string, config?: RequestConfig): Promise<HttpResponse<T>>
+  createLogger(nameOrConfig: string | LoggerConfig, config?: LoggerConfig): Logger
   /**
-   * Adds a request interceptor.
-   * Returns a function to remove the interceptor.
+   * Sets the global log level.
    */
-  addRequestInterceptor(interceptor: RequestInterceptor): () => void
+  setLevel(level: LogLevel): void
   /**
-   * Adds a response interceptor.
-   * Returns a function to remove the interceptor.
+   * Gets the global log level.
    */
-  addResponseInterceptor(interceptor: ResponseInterceptor): () => void
+  getLevel(): LogLevel
   /**
-   * Adds an error interceptor.
-   * Returns a function to remove the interceptor.
+   * Adds a global transport.
    */
-  addErrorInterceptor(interceptor: ErrorInterceptor): () => void
+  addTransport(transport: LogTransport): () => void
   /**
-   * Sets the authorization token.
+   * Enables logging.
    */
-  setAuthToken(token: string | null): void
+  enable(): void
   /**
-   * Returns the current authorization token, or `null` if not set.
+   * Disables logging.
    */
-  getAuthToken(): string | null
+  disable(): void
   /**
-   * Registers a handler for authentication errors (401).
+   * Checks if logging is enabled.
    *
-   * @returns An unsubscribe function.
+   * @returns `true` if logging is currently enabled.
    */
-  onAuthError(handler: () => void): () => void
+  isEnabled(): boolean
 }
 ```
 
-#### `HttpState`
+#### `RouteLocation`
 
-State for async HTTP operations.
+Current URL decomposed into pathname, search string, hash, navigation state, and unique key.
 
 ```typescript
-interface HttpState<T> {
-  data: T | null
-  loading: boolean
-  error: Error | null
+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
 }
 ```
 
-#### `I18nProvider`
+#### `Router`
 
-i18n provider interface.
+Client-side router providing navigation, guards, route matching, and history control.
 
-All i18n providers must implement this interface.
+All routing providers must implement this interface.
 
 ```typescript
-interface I18nProvider {
+interface Router {
+  /**
+   * Returns the current route location (pathname, search, hash, state).
+   */
+  getLocation(): RouteLocation
   /**
-   * Gets the current locale.
+   * Gets the current route params.
    */
-  getLocale(): string
+  getParams<T extends RouteParams = RouteParams>(): T
   /**
-   * Sets the current locale.
-   *
-   * **Fleet contract:** every conformant provider (the core simple provider,
-   * `@molecule/api-i18n-simple`, `@molecule/app-i18n-i18next`, and
-   * `@molecule/app-i18n-react-i18next`) MUST throw `Error('Locale "<code>"
-   * not found')` when `locale` is not registered — via the constructor's
-   * `initialLocales`/`locales` config, `addLocale()`, or `addTranslations()`
-   * (all three register a locale). It must NOT silently degrade to
-   * fallback-locale text while `getLocale()` reports the unregistered code —
-   * that divergence makes a misconfigured locale switch indistinguishable
-   * from a working one until a user notices the wrong language on screen.
+   * Gets the current query params.
    */
-  setLocale(locale: string): Promise<void>
+  getQuery(): QueryParams
   /**
-   * Gets all available locales.
+   * Gets a specific query parameter.
    */
-  getLocales(): LocaleConfig[]
+  getQueryParam(key: string): string | undefined
   /**
-   * Adds a locale.
+   * Gets the current hash.
    */
-  addLocale(config: LocaleConfig): void
+  getHash(): string
   /**
-   * Removes a locale by code, notifying subscribers so language pickers
-   * built on `onLocaleChange` re-render their list. If the removed locale
-   * is currently active, the caller is responsible for switching to a
-   * fallback (e.g. `'en'`) BEFORE calling this — the provider will not
-   * auto-fall-back on its own.
-   *
-   * Returns `true` if the locale was registered and removed, `false`
-   * otherwise.
+   * Navigates to a path.
    */
-  removeLocale(code: string): boolean
+  navigate(path: string, options?: NavigateOptions): void
   /**
-   * Adds translations to a locale. Auto-creates the locale if it doesn't exist.
-   *
-   * **Fleet contract:** merges are DEEP, not a shallow spread — registering
-   * two calls (e.g. two modules) that share a top-level namespace key merges
-   * their subtrees instead of the second call clobbering the first's nested
-   * translations wholesale. `@molecule/api-i18n-simple` implements the same
-   * contract on the API side.
+   * Navigates to a named route.
    */
-  addTranslations(locale: string, translations: Translations, namespace?: string): void
+  navigateTo(
+    name: string,
+    params?: RouteParams,
+    query?: QueryParams,
+    options?: NavigateOptions,
+  ): void
   /**
-   * Translates a key with optional interpolation values and pluralization.
-   *
-   * **Fleet plural contract (matches i18next's own key resolution order):**
-   * when `options.count` is provided, the plural-suffixed key
-   * (`` `${key}_${pluralForm}` ``, e.g. `item_one`/`item_few`/…, falling back
-   * to `` `${key}_other` ``) is looked up FIRST and wins over the base `key`
-   * if BOTH are registered. Only when no plural-suffixed key exists at all
-   * does resolution fall back to the base key. A catalog that ships both
-   * `item` and `item_one`/`item_other` therefore pluralizes identically
-   * whichever provider is bonded.
-   *
-   * @returns The translated string, or the default value / key if not found.
+   * Goes back in history.
    */
-  t(
-    key: string,
-    values?: InterpolationValues,
-    options?: {
-      defaultValue?: string
-      count?: number
-    },
-  ): string
+  back(): void
   /**
-   * Checks if a translation key exists.
-   *
-   * **Fleet contract:** follows the SAME locale-resolution chain as `t()` —
-   * the active locale, then the English fallback — so `exists(key) === true`
-   * whenever `t(key)` would render real translated text (not the raw key or
-   * an inline `defaultValue`). Do not narrow this to "only the active
-   * locale's own catalog"; that made `exists()` return `false` for keys `t()`
-   * happily rendered via the English fallback, and the answer differed by
-   * provider.
-   *
-   * @returns `true` if the key has a translation.
+   * Goes forward in history.
    */
-  exists(key: string): boolean
+  forward(): void
   /**
-   * Formats a number according to the current locale.
-   *
-   * @returns The locale-formatted number string.
+   * Goes to a specific point in history.
    */
-  formatNumber(value: number, options?: NumberFormatOptions): string
+  go(delta: number): void
   /**
-   * Formats a date according to the current locale.
-   *
-   * @returns The locale-formatted date string.
+   * Updates the current query params.
    */
-  formatDate(value: Date | number | string, options?: DateFormatOptions): string
+  setQuery(params: QueryParams, options?: NavigateOptions): void
   /**
-   * Formats a relative time (e.g. "2 hours ago").
-   *
-   * @returns The locale-formatted relative time string.
+   * Updates a specific query parameter.
    */
-  formatRelativeTime(
-    value: Date | number,
-    options?: {
-      unit?: Intl.RelativeTimeFormatUnit
-    },
-  ): string
+  setQueryParam(key: string, value: string | undefined, options?: NavigateOptions): void
   /**
-   * Formats a list (e.g. "A, B, and C").
-   *
-   * @returns The locale-formatted list string.
+   * Updates the current hash.
    */
-  formatList(
-    values: string[],
-    options?: {
-      type?: 'conjunction' | 'disjunction' | 'unit'
-    },
-  ): string
+  setHash(hash: string, options?: NavigateOptions): void
   /**
-   * Subscribes to locale changes.
+   * Checks if a path matches the current location.
    *
-   * @returns An unsubscribe function.
+   * @returns `true` if the path matches the current route.
    */
-  onLocaleChange(listener: (locale: string) => void): () => void
+  isActive(path: string, exact?: boolean): boolean
   /**
-   * Gets the text direction for the current locale.
-   *
-   * @returns `'ltr'` or `'rtl'`.
+   * Matches a path pattern against a pathname.
    */
-  getDirection(): 'ltr' | 'rtl'
+  matchPath<Params extends RouteParams = RouteParams>(
+    pattern: string,
+    pathname: string,
+  ): RouteMatch<Params> | null
   /**
-   * Checks if a translation key exists (alias for exists).
+   * Generates a URL from a named route.
    */
-  hasKey?(key: string): boolean
+  generatePath(name: string, params?: RouteParams, query?: QueryParams): string
   /**
-   * Checks if the provider is ready.
+   * Subscribes to route changes.
    */
-  isReady?(): boolean
+  subscribe(listener: RouteChangeListener): () => void
   /**
-   * Registers a callback for when the provider is ready.
+   * Adds a navigation guard.
    */
-  onReady?(callback: () => void): () => void
+  addGuard(guard: NavigationGuard): () => void
   /**
-   * Registers a lazily-loaded content module for automatic reload on locale changes.
-   * All registered content is reloaded during `setLocale()` before listeners fire,
-   * ensuring content is available on the first re-render with no flash.
-   *
-   * Idempotent: registering the same module name twice is a no-op.
+   * Registers route definitions.
    */
-  registerContent?(module: string, loader: (locale: string) => Promise<void>): void
+  registerRoutes(routes: RouteDefinition[]): void
+  /**
+   * Gets all registered routes.
+   */
+  getRoutes(): RouteDefinition[]
+  /**
+   * Destroys the router.
+   */
+  destroy(): void
 }
 ```
 
-#### `Logger`
+#### `StoreConfig`
 
-Logger instance with leveled logging methods, child logger creation,
-and transport management.
+Configuration for creating a store (initial state, optional name, and middleware chain).
 
 ```typescript
-interface Logger {
+interface StoreConfig<T> {
   /**
-   * Logs a trace message.
+   * Initial state value.
    */
-  trace(message: string, ...args: unknown[]): void
+  initialState: T
   /**
-   * Logs a debug message.
+   * Optional name for debugging.
    */
-  debug(message: string, ...args: unknown[]): void
+  name?: string
   /**
-   * Logs an info message.
+   * Optional middleware functions.
    */
-  info(message: string, ...args: unknown[]): void
+  middleware?: StoreMiddleware<T>[]
+}
+```
+
+#### `MoleculeStore`
+
+Reactive state container with getState, setState, subscribe, and destroy.
+
+All state management providers must implement this interface.
+
+```typescript
+interface Store<T> {
   /**
-   * Logs a warning message.
+   * Gets the current state.
    */
-  warn(message: string, ...args: unknown[]): void
+  getState(): T
   /**
-   * Logs an error message.
+   * Sets the state (partial or via updater function).
    */
-  error(message: string | Error, ...args: unknown[]): void
+  setState(partial: Partial<T> | ((state: T) => Partial<T>)): void
   /**
-   * Sets the log level.
+   * Subscribes to state changes.
+   * Returns an unsubscribe function.
    */
-  setLevel(level: LogLevel): void
+  subscribe(listener: StateListener<T>): () => void
   /**
-   * Gets the current log level.
+   * Destroys the store and cleans up subscriptions.
    */
-  getLevel(): LogLevel
+  destroy(): void
+}
+```
+
+#### `StateProvider`
+
+State provider interface that all state management bond packages
+must implement. Provides the store creation factory.
+
+```typescript
+interface StateProvider {
   /**
-   * Creates a child logger with a namespace.
+   * Creates a new store.
    */
-  child(name: string, context?: Record<string, unknown>): Logger
+  createStore<T>(config: StoreConfig<T>): Store<T>
+}
+```
+
+#### `StorageProvider`
+
+Storage provider interface.
+
+All storage providers must implement this interface.
+
+```typescript
+interface StorageProvider {
+  /**
+   * Gets a value from storage.
+   */
+  get<T = unknown>(key: string): Promise<T | null>
+  /**
+   * Sets a value in storage.
+   */
+  set<T = unknown>(key: string, value: T): Promise<void>
+  /**
+   * Removes a value from storage.
+   */
+  remove(key: string): Promise<void>
+  /**
+   * Clears all values from storage.
+   */
+  clear(): Promise<void>
+  /**
+   * Gets all keys in storage.
+   */
+  keys(): Promise<string[]>
   /**
-   * Adds additional context to the logger.
+   * Gets multiple values from storage.
    */
-  withContext(context: Record<string, unknown>): Logger
+  getMany?<T = unknown>(keys: string[]): Promise<Map<string, T | null>>
   /**
-   * Adds a transport.
+   * Sets multiple values in storage.
    */
-  addTransport(transport: LogTransport): () => void
+  setMany?<T = unknown>(entries: Array<[string, T]>): Promise<void>
   /**
-   * Removes a transport.
+   * Removes multiple values from storage.
    */
-  removeTransport(transport: LogTransport): void
+  removeMany?(keys: string[]): Promise<void>
 }
 ```
 
-#### `LoggerProvider`
+#### `ThemeProvider`
 
-Logger provider interface that all logger bond packages must implement.
-Creates and manages logger instances and global log configuration.
+Manages theme state including the active theme, mode toggling,
+and change subscriptions.
 
 ```typescript
-interface LoggerProvider {
-  /**
-   * Gets a logger by name, or the root logger if no name given.
-   */
-  getLogger(name?: string): Logger
+interface ThemeProvider {
   /**
-   * Creates a named logger.
+   * Returns the currently active theme.
    */
-  createLogger(nameOrConfig: string | LoggerConfig, config?: LoggerConfig): Logger
+  getTheme(): Theme
   /**
-   * Sets the global log level.
+   * Sets the active theme by reference or by name.
+   *
+   * @param theme - A `Theme` object or a theme name string to activate.
    */
-  setLevel(level: LogLevel): void
+  setTheme(theme: Theme | string): void
   /**
-   * Gets the global log level.
+   * Toggles between light and dark mode for the active theme.
    */
-  getLevel(): LogLevel
+  toggleMode(): void
   /**
-   * Adds a global transport.
+   * 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.
    */
-  addTransport(transport: LogTransport): () => void
+  subscribe(callback: (theme: Theme) => void): () => void
   /**
-   * Enables logging.
+   * Returns all registered themes. Optional — not all providers
+   * support multiple themes.
    */
-  enable(): void
+  getThemes?(): Theme[]
   /**
-   * Disables logging.
+   * 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.
    */
-  disable(): void
+  getServerTheme?(): Theme
+}
+```
+
+#### `Theme`
+
+Complete theme definition.
+
+```typescript
+interface Theme {
+  name: string
+  mode: 'light' | 'dark'
+  colors: ThemeColors
+  breakpoints: ThemeBreakpoints
+  spacing: ThemeSpacing
+  typography: ThemeTypography
+  borderRadius: ThemeBorderRadius
+  shadows: ThemeShadows
+  transitions: ThemeTransitions
+  zIndex: ThemeZIndex
+}
+```
+
+#### `CreateAsyncStateReturn`
+
+Return type for createAsyncState.
+
+```typescript
+interface CreateAsyncStateReturn<T> {
+  state: () => 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
+}
+```
+
+#### `CapacitorAppPrimitives`
+
+Capacitor app primitives return type.
+
+```typescript
+interface CapacitorAppPrimitives {
+  state: Accessor<CapacitorAppState>
+  ready: Accessor<boolean>
+  initialize: () => Promise<void>
+}
+```
+
+#### `CreateChangePasswordReturn`
+
+Return type for createChangePassword primitive.
+
+```typescript
+interface CreateChangePasswordReturn {
+  state: Accessor<PromiseState<void>>
+  changePassword: (oldPassword: string, newPassword: string) => Promise<void>
+  reset: () => void
+}
+```
+
+#### `DevicePrimitives`
+
+Device primitives return type.
+
+```typescript
+interface DevicePrimitives {
+  deviceInfo: DeviceInfo
+  screenInfo: ScreenInfo
+  hardwareInfo: HardwareInfo
+  featureSupport: FeatureSupport
+  supports: (feature: keyof FeatureSupport) => boolean
+  isOnline: () => boolean
+  isStandalone: () => boolean
+  language: string
+  languages: string[]
+}
+```
+
+#### `CreateFormResult`
+
+Result of createForm primitive.
+
+```typescript
+interface CreateFormResult<T extends Record<string, unknown>> {
+  /** Reactive form state accessor. */
+  formState: Accessor<FormState<T>>
+
+  /** Whether the form is currently valid. */
+  isValid: Accessor<boolean>
+
+  /** Whether any field has been modified. */
+  isDirty: Accessor<boolean>
+
+  /** Whether the form is currently submitting. */
+  isSubmitting: Accessor<boolean>
+
+  /** Current field errors. */
+  errors: Accessor<Partial<Record<keyof T, string>>>
+
+  /** Register a field for form management. */
+  register: (name: keyof T, options?: RegisterOptions) => FieldRegistration
+
+  /** Get the current value of a field. */
+  getValue: <K extends keyof T>(name: K) => T[K]
+
+  /** Set the value of a field. */
+  setValue: <K extends keyof T>(name: K, value: T[K]) => void
+
+  /** Get the error message for a field. */
+  getError: (name: keyof T) => string | undefined
+
+  /** Set an error message for a field. */
+  setError: (name: keyof T, error: string | undefined) => void
+
+  /** Clear all field errors. */
+  clearErrors: () => void
+
+  /** Create a submit handler function. */
+  handleSubmit: (
+    onSubmit: (values: T) => void | Promise<void>,
+  ) => (event?: { preventDefault?: () => void }) => Promise<void>
+
+  /** Reset the form to initial or provided values. */
+  reset: (values?: Partial<T>) => void
+
+  /** Validate all fields. */
+  validate: () => Promise<boolean>
+
+  /** The raw FormController instance for advanced use. */
+  controller: FormController<T>
+}
+```
+
+#### `CreateLoginReturn`
+
+Return type for createLogin primitive.
+
+```typescript
+interface CreateLoginReturn<T = unknown> {
+  state: Accessor<PromiseState<AuthResult<T>>>
+  login: (credentials: LoginCredentials) => Promise<AuthResult<T>>
+  reset: () => void
+}
+```
+
+#### `CreateOAuthOptions`
+
+OAuth configuration options.
+
+```typescript
+interface CreateOAuthOptions {
+  /** 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. */
+  onError?: (error: string) => void
   /**
-   * Checks if logging is enabled.
-   *
-   * @returns `true` if logging is currently enabled.
+   * Auth client used to establish the session after the code exchange.
+   * Overrides context resolution — when omitted, the client is resolved from
+   * the surrounding `MoleculeProvider` (tolerated when absent; see the
+   * cookie-session fallback documented on
+   * {@link CreateOAuthReturn.handleCallback}).
    */
-  isEnabled(): boolean
+  authClient?: AuthClient<unknown>
 }
 ```
 
-#### `MoleculeConfig`
+#### `CreateOAuthReturn`
 
-Configuration for molecule Solid context.
+Return type for createOAuth primitive.
 
 ```typescript
-interface MoleculeConfig {
-  state?: StateProvider
-  auth?: AuthClient<unknown>
-  theme?: ThemeProvider
-  router?: Router
-  i18n?: I18nProvider
-  http?: HttpClient
-  storage?: StorageProvider
-  logger?: LoggerProvider
+interface CreateOAuthReturn {
+  /** Accessor for the configured OAuth provider names. */
+  providers: Accessor<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 createOAuth});
+   * 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 is available (explicit option or context), 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>
 }
 ```
 
-#### `MoleculeStore`
-
-Reactive state container with getState, setState, subscribe, and destroy.
+#### `CreatePasswordResetReturn`
 
-All state management providers must implement this interface.
+Return type for createPasswordReset primitive.
 
 ```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 CreatePasswordResetReturn {
+  requestState: Accessor<PromiseState<void>>
+  confirmState: Accessor<PromiseState<void>>
+  requestReset: (data: PasswordResetRequest) => Promise<void>
+  confirmReset: (data: PasswordResetConfirm) => Promise<void>
+  reset: () => void
 }
 ```
 
@@ -976,6 +1262,19 @@ interface PlatformPrimitives {
 }
 ```
 
+#### `CreatePromiseReturn`
+
+Promise state accessor with actions.
+
+```typescript
+interface CreatePromiseReturn<T> {
+  state: () => PromiseState<T>
+  call: (...args: any[]) => Promise<T>
+  cancel: (message?: string) => void
+  reset: () => void
+}
+```
+
 #### `PushPrimitives`
 
 Push primitives return type.
@@ -996,137 +1295,106 @@ interface PushPrimitives {
 }
 ```
 
-#### `RouteLocation`
+#### `CreateSignupReturn`
 
-Current URL decomposed into pathname, search string, hash, navigation state, and unique key.
+Return type for createSignup primitive.
 
 ```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
+interface CreateSignupReturn<T = unknown> {
+  state: Accessor<PromiseState<AuthResult<T>>>
+  signup: (data: RegisterData) => Promise<AuthResult<T>>
+  reset: () => void
 }
 ```
 
-#### `Router`
+#### `VersionPrimitives`
 
-Client-side router providing navigation, guards, route matching, and history control.
+Version primitives return type.
 
-All routing providers must implement this interface.
+```typescript
+interface VersionPrimitives {
+  state: Accessor<VersionState>
+  isUpdateAvailable: Accessor<boolean>
+  isChecking: Accessor<boolean>
+  isServiceWorkerWaiting: Accessor<boolean>
+  newVersion: Accessor<string | undefined>
+  checkForUpdates: () => Promise<boolean>
+  applyUpdate: (options?: { force?: boolean }) => void
+  dismissUpdate: () => void
+  startPeriodicChecks: (options?: UpdateCheckOptions) => void
+  stopPeriodicChecks: () => void
+}
+```
+
+#### `MoleculeConfig`
+
+Configuration for molecule Solid context.
 
 ```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
-  /**
-   * Gets a specific query parameter.
-   */
-  getQueryParam(key: string): string | undefined
-  /**
-   * Gets the current hash.
-   */
-  getHash(): string
-  /**
-   * Navigates to a path.
-   */
-  navigate(path: string, options?: NavigateOptions): void
-  /**
-   * Navigates to a named route.
-   */
-  navigateTo(
-    name: string,
-    params?: RouteParams,
-    query?: QueryParams,
-    options?: NavigateOptions,
-  ): void
-  /**
-   * Goes back in history.
-   */
-  back(): void
-  /**
-   * Goes forward in history.
-   */
-  forward(): void
-  /**
-   * Goes to a specific point in history.
-   */
-  go(delta: number): void
-  /**
-   * Updates the current query params.
-   */
-  setQuery(params: QueryParams, options?: NavigateOptions): void
-  /**
-   * Updates a specific query parameter.
-   */
-  setQueryParam(key: string, value: string | undefined, options?: NavigateOptions): void
-  /**
-   * Updates the current hash.
-   */
-  setHash(hash: string, options?: NavigateOptions): void
-  /**
-   * Checks if a path matches the current location.
-   *
-   * @returns `true` if the path matches the current route.
-   */
-  isActive(path: string, exact?: boolean): boolean
-  /**
-   * Matches a path pattern against a pathname.
-   */
-  matchPath<Params extends RouteParams = RouteParams>(
-    pattern: string,
-    pathname: string,
-  ): RouteMatch<Params> | null
-  /**
-   * Generates a URL from a named route.
-   */
-  generatePath(name: string, params?: RouteParams, query?: QueryParams): string
-  /**
-   * Subscribes to route changes.
-   */
-  subscribe(listener: RouteChangeListener): () => void
-  /**
-   * Adds a navigation guard.
-   */
-  addGuard(guard: NavigationGuard): () => void
-  /**
-   * Registers route definitions.
-   */
-  registerRoutes(routes: RouteDefinition[]): void
-  /**
-   * Gets all registered routes.
-   */
-  getRoutes(): RouteDefinition[]
-  /**
-   * Destroys the router.
-   */
-  destroy(): void
+interface MoleculeConfig {
+  state?: StateProvider
+  auth?: AuthClient<unknown>
+  theme?: ThemeProvider
+  router?: Router
+  i18n?: I18nProvider
+  http?: HttpClient
+  storage?: StorageProvider
+  logger?: LoggerProvider
+}
+```
+
+#### `HttpState`
+
+State for async HTTP operations.
+
+```typescript
+interface HttpState<T> {
+  data: T | null
+  loading: boolean
+  error: Error | null
+}
+```
+
+#### `StorageValueState`
+
+State for async storage values.
+
+```typescript
+interface StorageValueState<T> {
+  value: T | undefined
+  loading: boolean
+  error: Error | null
+}
+```
+
+#### `AuthPrimitives`
+
+Auth primitives return type.
+
+```typescript
+interface AuthPrimitives<T = unknown> {
+  state: Accessor<AuthState<T>>
+  user: Accessor<T | null>
+  isAuthenticated: Accessor<boolean>
+  isLoading: Accessor<boolean>
+  login: AuthClient<T>['login']
+  logout: AuthClient<T>['logout']
+  register: AuthClient<T>['register']
+  refresh: AuthClient<T>['refresh']
+}
+```
+
+#### `ThemePrimitives`
+
+Theme primitives return type.
+
+```typescript
+interface ThemePrimitives {
+  theme: Accessor<Theme>
+  themeName: Accessor<string>
+  mode: Accessor<'light' | 'dark'>
+  setTheme: (name: string) => void
+  toggleTheme: () => void
 }
 ```
 
@@ -1147,232 +1415,125 @@ interface RouterPrimitives {
 }
 ```
 
-#### `StateProvider`
+### Types
 
-State provider interface that all state management bond packages
-must implement. Provides the store creation factory.
+#### `Accessor`
 
 ```typescript
-interface StateProvider {
-  /**
-   * Creates a new store.
-   */
-  createStore<T>(config: StoreConfig<T>): Store<T>
-}
+type Accessor<T> = () => T
 ```
 
-#### `StorageProvider`
-
-Storage provider interface.
-
-All storage providers must implement this interface.
+#### `Setter`
 
 ```typescript
-interface StorageProvider {
-  /**
-   * Gets a value from storage.
-   */
-  get<T = unknown>(key: string): Promise<T | null>
-  /**
-   * Sets a value in storage.
-   */
-  set<T = unknown>(key: string, value: T): Promise<void>
-  /**
-   * Removes a value from storage.
-   */
-  remove(key: string): Promise<void>
-  /**
-   * Clears all values from storage.
-   */
-  clear(): Promise<void>
-  /**
-   * Gets all keys in storage.
-   */
-  keys(): Promise<string[]>
-  /**
-   * Gets multiple values from storage.
-   */
-  getMany?<T = unknown>(keys: string[]): Promise<Map<string, T | null>>
-  /**
-   * Sets multiple values in storage.
-   */
-  setMany?<T = unknown>(entries: Array<[string, T]>): Promise<void>
-  /**
-   * Removes multiple values from storage.
-   */
-  removeMany?(keys: string[]): Promise<void>
+type Setter<in out T> = {
+  <U extends T>(
+    ...args: undefined extends T ? [] : [value: Exclude<U, Function> | ((prev: T) => U)]
+  ): undefined extends T ? undefined : U
+  <U extends T>(value: (prev: T) => U): U
+  <U extends T>(value: Exclude<U, Function>): U
+  <U extends T>(value: Exclude<U, Function> | ((prev: T) => U)): U
 }
 ```
 
-#### `StorageValueState`
+#### `RouteParams`
 
-State for async storage values.
+URL path parameter key-value map extracted from dynamic route segments (e.g. `{ id: '123' }`).
 
 ```typescript
-interface StorageValueState<T> {
-  value: T | undefined
-  loading: boolean
-  error: Error | null
-}
+type RouteParams = Record<string, string>
 ```
 
-#### `StoreConfig`
+#### `QueryParams`
 
-Configuration for creating a store (initial state, optional name, and middleware chain).
+URL query string parameter map (single values or arrays for repeated keys).
 
 ```typescript
-interface StoreConfig<T> {
-  /**
-   * Initial state value.
-   */
-  initialState: T
-  /**
-   * Optional name for debugging.
-   */
-  name?: string
-  /**
-   * Optional middleware functions.
-   */
-  middleware?: StoreMiddleware<T>[]
-}
+type QueryParams = Record<string, string | string[] | undefined>
 ```
 
-#### `Theme`
+### Functions
 
-Complete theme definition.
+#### `getStateProvider()`
+
+Get the state provider from context.
 
 ```typescript
-interface Theme {
-  name: string
-  mode: 'light' | 'dark'
-  colors: ThemeColors
-  breakpoints: ThemeBreakpoints
-  spacing: ThemeSpacing
-  typography: ThemeTypography
-  borderRadius: ThemeBorderRadius
-  shadows: ThemeShadows
-  transitions: ThemeTransitions
-  zIndex: ThemeZIndex
-}
+function getStateProvider(): StateProvider
 ```
 
-#### `ThemePrimitives`
+**Returns:** The state provider instance.
 
-Theme primitives return type.
+#### `getAuthClient()`
+
+Get the auth client from context.
 
 ```typescript
-interface ThemePrimitives {
-  theme: Accessor<Theme>
-  themeName: Accessor<string>
-  mode: Accessor<'light' | 'dark'>
-  setTheme: (name: string) => void
-  toggleTheme: () => void
-}
+function getAuthClient(): AuthClient<T, Record<never, never>>
 ```
 
-#### `ThemeProvider`
+**Returns:** The auth client instance.
 
-Manages theme state including the active theme, mode toggling,
-and change subscriptions.
+#### `getThemeProvider()`
+
+Get the theme provider from context.
 
 ```typescript
-interface ThemeProvider {
-  /**
-   * Returns the currently active theme.
-   */
-  getTheme(): Theme
-  /**
-   * Sets the active theme by reference or by name.
-   *
-   * @param theme - A `Theme` object or a theme name string to activate.
-   */
-  setTheme(theme: Theme | string): void
-  /**
-   * Toggles between light and dark mode for the active theme.
-   */
-  toggleMode(): void
-  /**
-   * 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.
-   */
-  subscribe(callback: (theme: Theme) => void): () => void
-  /**
-   * Returns all registered themes. Optional — not all providers
-   * support multiple themes.
-   */
-  getThemes?(): Theme[]
-}
+function getThemeProvider(): ThemeProvider
 ```
 
-#### `VersionPrimitives`
+**Returns:** The theme provider instance.
 
-Version primitives return type.
+#### `getRouter()`
+
+Get the router from context.
 
 ```typescript
-interface VersionPrimitives {
-  state: Accessor<VersionState>
-  isUpdateAvailable: Accessor<boolean>
-  isChecking: Accessor<boolean>
-  isServiceWorkerWaiting: Accessor<boolean>
-  newVersion: Accessor<string | undefined>
-  checkForUpdates: () => Promise<boolean>
-  applyUpdate: (options?: { force?: boolean }) => void
-  dismissUpdate: () => void
-  startPeriodicChecks: (options?: UpdateCheckOptions) => void
-  stopPeriodicChecks: () => void
-}
+function getRouter(): Router
 ```
 
-### Types
+**Returns:** The router instance.
 
-#### `Accessor`
+#### `getI18nProvider()`
+
+Get the i18n provider from context.
 
 ```typescript
-type Accessor<T> = () => T
+function getI18nProvider(): I18nProvider
 ```
 
-#### `QueryParams`
+**Returns:** The i18n provider instance.
 
-URL query string parameter map (single values or arrays for repeated keys).
+#### `getHttpClient()`
+
+Get the HTTP client from context.
 
 ```typescript
-type QueryParams = Record<string, string | string[] | undefined>
+function getHttpClient(): HttpClient
 ```
 
-#### `RouteParams`
-
-URL path parameter key-value map extracted from dynamic route segments (e.g. `{ id: '123' }`).
+**Returns:** The HTTP client instance.
 
-```typescript
-type RouteParams = Record<string, string>
-```
+#### `getStorageProvider()`
 
-#### `Setter`
+Get the storage provider from context.
 
 ```typescript
-type Setter<in out T> = {
-  <U extends T>(
-    ...args: undefined extends T ? [] : [value: Exclude<U, Function> | ((prev: T) => U)]
-  ): undefined extends T ? undefined : U
-  <U extends T>(value: (prev: T) => U): U
-  <U extends T>(value: Exclude<U, Function>): U
-  <U extends T>(value: Exclude<U, Function> | ((prev: T) => U)): U
-}
+function getStorageProvider(): StorageProvider
 ```
 
-### Functions
+**Returns:** The storage provider instance.
 
-#### `applyThemeToDocument()`
+#### `getLoggerProvider()`
 
-Apply theme CSS variables to document.
+Get the logger provider from context.
 
 ```typescript
-function applyThemeToDocument(): void
+function getLoggerProvider(): LoggerProvider
 ```
 
+**Returns:** The logger provider instance.
+
 #### `createAsyncState(initialState)`
 
 Primitive like createSignal but accepts Promises and supports partial state extension.
@@ -1395,18 +1556,6 @@ function createAuth(): AuthPrimitives<T>
 
 **Returns:** Auth primitives object
 
-#### `createAuthFromClient(client)`
-
-Create auth primitives from a specific client.
-
-```typescript
-function createAuthFromClient(client: AuthClient<T>): AuthPrimitives<T>
-```
-
-- `client` — Auth client
-
-**Returns:** Auth primitives
-
 #### `createAuthGuard(redirectTo)`
 
 Create a guard primitive that redirects unauthenticated users.
@@ -1437,6 +1586,18 @@ function createAuthHelpers(): {
 
 **Returns:** The created result.
 
+#### `createAuthFromClient(client)`
+
+Create auth primitives from a specific client.
+
+```typescript
+function createAuthFromClient(client: AuthClient<T, Record<never, never>>): AuthPrimitives<T>
+```
+
+- `client` — Auth client
+
+**Returns:** Auth primitives
+
 #### `createCapacitorApp(options)`
 
 Create Capacitor app primitives for native app initialization.
@@ -1464,16 +1625,29 @@ function createChangePassword(): CreateChangePasswordReturn
 
 #### `createDevice()`
 
-Create device primitives for accessing device information.
+Create device primitives for accessing device information.
+
+This is a static primitive (no reactive signals) since device info
+does not change during the lifecycle of the app.
+
+```typescript
+function createDevice(): DevicePrimitives
+```
+
+**Returns:** Device primitives object
+
+#### `createForm(provider, options)`
 
-This is a static primitive (no reactive signals) since device info
-does not change during the lifecycle of the app.
+Create form primitives for form state management and validation.
 
 ```typescript
-function createDevice(): DevicePrimitives
+function createForm(provider: FormProvider, options: FormOptions<T>): CreateFormResult<T>
 ```
 
-**Returns:** Device primitives object
+- `provider` — Form provider that creates controllers
+- `options` — Form configuration options
+
+**Returns:** Form primitives object
 
 #### `createFieldSignal(controller, name)`
 
@@ -1491,33 +1665,18 @@ function createFieldSignal(
 
 **Returns:** Accessor for the field state
 
-#### `createForm(provider, options)`
-
-Create form primitives for form state management and validation.
-
-```typescript
-function createForm(provider: FormProvider, options: FormOptions<T>): CreateFormResult<T>
-```
-
-- `provider` — Form provider that creates controllers
-- `options` — Form configuration options
-
-**Returns:** Form primitives object
-
-#### `createFormFromController(controller)`
-
-Create form primitives from an existing controller.
+#### `createWatchSignal(controller, name)`
 
-Useful when you have a controller created externally and want to
-wrap it with Solid reactivity.
+Create a reactive accessor that tracks a single field's value.
 
 ```typescript
-function createFormFromController(controller: FormController<T>): CreateFormResult<T>
+function createWatchSignal(controller: FormController<T>, name: K): Accessor<T[K]>
 ```
 
-- `controller` — An existing FormController
+- `controller` — Form controller
+- `name` — Field name to watch
 
-**Returns:** Form primitives object
+**Returns:** Accessor for the field value
 
 #### `createFormHelpers(provider)`
 
@@ -1533,931 +1692,857 @@ function createFormHelpers(provider: FormProvider): {
 
 **Returns:** The created result.
 
-#### `createHttp()`
-
-Creates a http.
-
-```typescript
-function createHttp(): {
-  get: <T>(url: string, config?: RequestConfig) => Promise<HttpResponse<T>>
-  post: <T>(url: string, data?: unknown, config?: RequestConfig) => Promise<HttpResponse<T>>
-  put: <T>(url: string, data?: unknown, config?: RequestConfig) => Promise<HttpResponse<T>>
-  patch: <T>(url: string, data?: unknown, config?: RequestConfig) => Promise<HttpResponse<T>>
-  delete: <T>(url: string, config?: RequestConfig) => Promise<HttpResponse<T>>
-  request: <T>(config: FullRequestConfig) => Promise<HttpResponse<T>>
-}
-```
-
-**Returns:** The created result.
+#### `createFormFromController(controller)`
 
-#### `createHttpFromClient(client)`
+Create form primitives from an existing controller.
 
-Creates a http from client.
+Useful when you have a controller created externally and want to
+wrap it with Solid reactivity.
 
 ```typescript
-function createHttpFromClient(client: HttpClient): {
-  get: <T>(url: string, config?: RequestConfig) => Promise<HttpResponse<T>>
-  post: <T>(url: string, data?: unknown, config?: RequestConfig) => Promise<HttpResponse<T>>
-  put: <T>(url: string, data?: unknown, config?: RequestConfig) => Promise<HttpResponse<T>>
-  patch: <T>(url: string, data?: unknown, config?: RequestConfig) => Promise<HttpResponse<T>>
-  delete: <T>(url: string, config?: RequestConfig) => Promise<HttpResponse<T>>
-  request: <T>(config: FullRequestConfig) => Promise<HttpResponse<T>>
-}
+function createFormFromController(controller: FormController<T>): CreateFormResult<T>
 ```
 
-- `client` — The client instance.
+- `controller` — An existing FormController
 
-**Returns:** The created result.
+**Returns:** Form primitives object
 
-#### `createHttpHelpers()`
+#### `createHttp()`
 
-Creates a http helpers.
+Creates a http.
 
 ```typescript
-function createHttpHelpers(): {
+function createHttp(): {
   get: <T>(url: string, config?: RequestConfig) => Promise<HttpResponse<T>>
   post: <T>(url: string, data?: unknown, config?: RequestConfig) => Promise<HttpResponse<T>>
   put: <T>(url: string, data?: unknown, config?: RequestConfig) => Promise<HttpResponse<T>>
   patch: <T>(url: string, data?: unknown, config?: RequestConfig) => Promise<HttpResponse<T>>
   delete: <T>(url: string, config?: RequestConfig) => Promise<HttpResponse<T>>
-  setAuthToken: (token: string | null) => void
-  getAuthToken: () => string | null
-}
-```
-
-**Returns:** The created result.
-
-#### `createI18n()`
-
-Creates a i18n.
-
-```typescript
-function createI18n(): {
-  t: TranslateFunction
-  locale: Accessor<string>
-  setLocale: (newLocale: string) => Promise<void>
-  isReady: Accessor<boolean>
-  getLocales: () => LocaleConfig[]
-  hasKey: (key: string) => boolean
+  request: <T>(config: FullRequestConfig) => Promise<HttpResponse<T>>
 }
 ```
 
 **Returns:** The created result.
 
-#### `createI18nFromProvider(provider)`
+#### `useFetch(url, config)`
 
-Creates a i18n from provider.
+Create a resource for fetching data.
 
 ```typescript
-function createI18nFromProvider(provider: I18nProvider): {
-  t: TranslateFunction
-  locale: Accessor<string>
-  setLocale: (newLocale: string) => Promise<void>
-  isReady: Accessor<boolean>
-  getLocales: () => LocaleConfig[]
-  hasKey: (key: string) => boolean
-}
+function useFetch(url: string | Accessor<string>, config?: RequestConfig): Resource<T | undefined>
 ```
 
-- `provider` — The provider implementation.
+- `url` — URL string or accessor returning a URL string.
+- `config` — Optional request configuration.
 
-**Returns:** The created result.
+**Returns:** Solid resource
 
-#### `createI18nHelpers()`
+#### `useMutation()`
 
-Creates a i18n helpers.
+Hook for mutation.
 
 ```typescript
-function createI18nHelpers(): {
-  t: TranslateFunction
-  getLocale: () => string
-  setLocale: (locale: string) => Promise<void>
-  getLocales: () => LocaleConfig[]
-  hasKey: (key: string) => boolean
-  isReady: () => boolean
+function useMutation(): {
+  mutate: (
+    url: string,
+    payload?: unknown,
+    method?: 'POST' | 'PUT' | 'PATCH' | 'DELETE',
+  ) => Promise<T>
+  isLoading: Accessor<boolean>
+  error: Accessor<Error | null>
+  data: Accessor<T | null>
+  reset: () => void
 }
 ```
 
-**Returns:** The created result.
-
-#### `createIsActive(path, exact)`
-
-Create a reactive boolean accessor that tracks whether a given path is active.
-
-Unlike `useMatch` which only accepts a static pattern, this factory returns
-a signal that re-evaluates on every route change and supports the `exact`
-parameter from the router's `isActive` method.
-
-```typescript
-function createIsActive(path: string, exact?: boolean): Accessor<boolean>
-```
-
-- `path` — Path to check against the current location
-- `exact` — Whether to require an exact match (default: false)
-
-**Returns:** Accessor<boolean> that is true when the path is active
-
-#### `createLogger(config)`
-
-Create a logger with custom configuration.
-
-```typescript
-function createLogger(config: LoggerConfig): Logger
-```
-
-- `config` — Logger configuration
-
-**Returns:** Logger instance
-
-#### `createLoggerFromProvider(provider, name)`
-
-Create logger from a specific provider.
-
-```typescript
-function createLoggerFromProvider(provider: LoggerProvider, name?: string): Logger
-```
-
-- `provider` — Logger provider
-- `name` — Logger name
-
-**Returns:** Logger instance
+**Returns:** The result.
 
-#### `createLoggerHelpers()`
+#### `useLazyQuery()`
 
-Creates a logger helpers.
+Hook for lazy query.
 
 ```typescript
-function createLoggerHelpers(): {
-  getLogger: (name?: string) => Logger
-  createLogger: (config: LoggerConfig) => Logger
-  setLevel: (level: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'silent') => void
-  getLevel: () => string
-  enable: () => void
-  disable: () => void
-  isEnabled: () => boolean
+function useLazyQuery(): {
+  execute: (url: string, config?: RequestConfig) => Promise<T>
+  data: () => T | null
+  isLoading: () => boolean
+  error: () => Error | null
+  reset: () => void
 }
 ```
 
-**Returns:** The created result.
+**Returns:** The result.
 
-#### `createLoggerHelpersFromProvider(provider)`
+#### `createHttpHelpers()`
 
-Creates a logger helpers from provider.
+Creates a http helpers.
 
 ```typescript
-function createLoggerHelpersFromProvider(provider: LoggerProvider): {
-  getLogger: (name?: string) => Logger
-  createLogger: (config: LoggerConfig) => Logger
-  setLevel: (level: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'silent') => void
-  getLevel: () => string
-  enable: () => void
-  disable: () => void
-  isEnabled: () => boolean
+function createHttpHelpers(): {
+  get: <T>(url: string, config?: RequestConfig) => Promise<HttpResponse<T>>
+  post: <T>(url: string, data?: unknown, config?: RequestConfig) => Promise<HttpResponse<T>>
+  put: <T>(url: string, data?: unknown, config?: RequestConfig) => Promise<HttpResponse<T>>
+  patch: <T>(url: string, data?: unknown, config?: RequestConfig) => Promise<HttpResponse<T>>
+  delete: <T>(url: string, config?: RequestConfig) => Promise<HttpResponse<T>>
+  setAuthToken: (token: string | null) => void
+  getAuthToken: () => string | null
 }
 ```
 
-- `provider` — The provider implementation.
-
 **Returns:** The created result.
 
-#### `createLogin()`
-
-Creates a login primitive with async state tracking.
-
-```typescript
-function createLogin(): CreateLoginReturn<T>
-```
-
-**Returns:** Login state and action
-
-#### `createOAuth(options)`
-
-Creates OAuth helpers.
-
-Automatically handles OAuth callbacks by detecting `code` and `state` URL
-parameters and exchanging them for a session:
+#### `createHttpFromClient(client)`
 
-- Inside a Solid owner (component setup / `createRoot`), the callback
-  handling is deferred to `onMount` so it runs client-side after mount.
-- Outside an owner (a plain function call, e.g. bootstrap code), it runs
-  immediately at creation, browser-guarded.
+Creates a http from client.
 
 ```typescript
-function createOAuth(options?: CreateOAuthOptions): CreateOAuthReturn
+function createHttpFromClient(client: HttpClient): {
+  get: <T>(url: string, config?: RequestConfig) => Promise<HttpResponse<T>>
+  post: <T>(url: string, data?: unknown, config?: RequestConfig) => Promise<HttpResponse<T>>
+  put: <T>(url: string, data?: unknown, config?: RequestConfig) => Promise<HttpResponse<T>>
+  patch: <T>(url: string, data?: unknown, config?: RequestConfig) => Promise<HttpResponse<T>>
+  delete: <T>(url: string, config?: RequestConfig) => Promise<HttpResponse<T>>
+  request: <T>(config: FullRequestConfig) => Promise<HttpResponse<T>>
+}
 ```
 
-- `options` — OAuth configuration
+- `client` — The client instance.
 
-**Returns:** The created instance.
+**Returns:** The created result.
 
-#### `createPasswordReset()`
+#### `createI18n()`
 
-Creates a password reset primitive with async state tracking.
+Creates a i18n.
 
 ```typescript
-function createPasswordReset(): CreatePasswordResetReturn
+function createI18n(): {
+  t: TranslateFunction
+  locale: Accessor<string>
+  setLocale: (newLocale: string) => Promise<void>
+  isReady: Accessor<boolean>
+  getLocales: () => LocaleConfig[]
+  hasKey: (key: string) => boolean
+}
 ```
 
-**Returns:** Password reset state and actions
+**Returns:** The created result.
 
-#### `createPersistedStore(key, initial, storage)`
+#### `useTranslate()`
 
-Create a persisted signal store.
+Get translate function.
 
 ```typescript
-function createPersistedStore(
-  key: string,
-  initial: T,
-  storage: StorageAdapter,
-): [Accessor<T>, (value: T | ((prev: T) => T)) => void]
+function useTranslate(): TranslateFunction
 ```
 
-- `key` — Storage key
-- `initial` — Initial value
-- `storage` — Storage adapter (required - use localStorage, sessionStorage, or `@molecule/app-storage`)
-
-**Returns:** Tuple of accessor and setter
-
-#### `createPlatform()`
+**Returns:** Translate function
 
-Create platform primitives for detecting the current platform.
+#### `useLocale()`
 
-This is a static primitive (no reactive signals) since the platform
-does not change during the lifecycle of the app.
+Get current locale as accessor.
 
 ```typescript
-function createPlatform(): PlatformPrimitives
+function useLocale(): Accessor<string>
 ```
 
-**Returns:** Platform primitives object
+**Returns:** Accessor for current locale
 
-#### `createPromise(asyncFn)`
+#### `useTranslation(key, values, options)`
 
-Primitive that wraps an async function with reactive state tracking.
+Create a reactive translation.
 
 ```typescript
-function createPromise(asyncFn: T): CreatePromiseReturn<Awaited<ReturnType<T>>>
+function useTranslation(
+  key: string,
+  values?: InterpolationValues,
+  options?: TranslateOptions,
+): Accessor<string>
 ```
 
-- `asyncFn` — The async function to wrap
+- `key` — Translation key
+- `values` — Interpolation values for the translation.
+- `options` — Translation options
 
-**Returns:** Object with state accessor, call, cancel, and reset functions
+**Returns:** Accessor for translated string
 
-#### `createPush()`
+#### `usePlural(key, count, values)`
 
-Create push notification primitives.
+Create a reactive plural translation.
 
 ```typescript
-function createPush(): PushPrimitives
+function usePlural(
+  key: string,
+  count: Accessor<number>,
+  values?: InterpolationValues,
+): Accessor<string>
 ```
 
-**Returns:** Push primitives object
-
-#### `createRouter()`
-
-Create router primitives for navigation state and actions.
-
-```typescript
-function createRouter(): RouterPrimitives
-```
+- `key` — Translation key
+- `count` — Count accessor for pluralization
+- `values` — Interpolation values for the translation.
 
-**Returns:** Router primitives object
+**Returns:** Accessor for translated string
 
-#### `createRouterFromInstance(router)`
+#### `createI18nHelpers()`
 
-Create router primitives from a specific router.
+Creates a i18n helpers.
 
 ```typescript
-function createRouterFromInstance(router: Router): RouterPrimitives
+function createI18nHelpers(): {
+  t: TranslateFunction
+  getLocale: () => string
+  setLocale: (locale: string) => Promise<void>
+  getLocales: () => LocaleConfig[]
+  hasKey: (key: string) => boolean
+  isReady: () => boolean
+}
 ```
 
-- `router` — Router instance
-
-**Returns:** Router primitives
+**Returns:** The created result.
 
-#### `createRouterHelpers()`
+#### `createI18nFromProvider(provider)`
 
-Creates a router helpers.
+Creates a i18n from provider.
 
 ```typescript
-function createRouterHelpers(): {
-  navigate: (path: string, options?: NavigateOptions) => void
-  navigateTo: (
-    name: string,
-    params?: RouteParams,
-    query?: QueryParams,
-    options?: NavigateOptions,
-  ) => void
-  back: () => void
-  forward: () => void
-  getLocation: () => RouteLocation
-  getParams: () => RouteParams
-  getQuery: () => QueryParams
-  isActive: (path: string) => boolean
+function createI18nFromProvider(provider: I18nProvider): {
+  t: TranslateFunction
+  locale: Accessor<string>
+  setLocale: (newLocale: string) => Promise<void>
+  isReady: Accessor<boolean>
+  getLocales: () => LocaleConfig[]
+  hasKey: (key: string) => boolean
 }
 ```
 
+- `provider` — The provider implementation.
+
 **Returns:** The created result.
 
-#### `createSignalStore(initial)`
+#### `getLogger(name)`
 
-Create a simple signal-based store without provider.
+Get a logger instance.
 
 ```typescript
-function createSignalStore(initial: T): [Accessor<T>, (value: T | ((prev: T) => T)) => void]
+function getLogger(name?: string): Logger
 ```
 
-- `initial` — Initial state
+- `name` — Logger name
 
-**Returns:** The created instance.
+**Returns:** Logger instance
 
-#### `createSignup()`
+#### `createLogger(config)`
 
-Creates a signup primitive with async state tracking.
+Create a logger with custom configuration.
 
 ```typescript
-function createSignup(): CreateSignupReturn<T>
+function createLogger(config: LoggerConfig): Logger
 ```
 
-**Returns:** Signup state and action
+- `config` — Logger configuration
 
-#### `createStateHelpers()`
+**Returns:** Logger instance
 
-Creates a state helpers.
+#### `getRootLogger()`
+
+Get the root logger.
 
 ```typescript
-function createStateHelpers(): {
-  createStore: <T extends object>(config: StoreConfig<T>) => Store<T>
-}
+function getRootLogger(): Logger
 ```
 
-**Returns:** The created result.
+**Returns:** Root logger instance
 
-#### `createStateHelpersFromProvider(provider)`
+#### `getChildLogger(name, context)`
 
-Creates a state helpers from provider.
+Create a child logger with additional context.
 
 ```typescript
-function createStateHelpersFromProvider(provider: StateProvider): {
-  createStore: <T extends object>(config: StoreConfig<T>) => Store<T>
-}
+function getChildLogger(name: string, context: Record<string, unknown>): Logger
 ```
 
-- `provider` — The provider implementation.
+- `name` — Parent logger name
+- `context` — Additional context
 
-**Returns:** The created result.
+**Returns:** Child logger instance
 
-#### `createStorage()`
+#### `useComponentLogger(componentName)`
 
-Create storage primitives.
+Create a component logger that includes component name in context.
 
 ```typescript
-function createStorage(): {
-  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 useComponentLogger(componentName: string): Logger
 ```
 
-**Returns:** Storage methods
+- `componentName` — Name of the component
 
-#### `createStorageFromProvider(storage)`
+**Returns:** Logger configured for the component
 
-Create storage primitives from a specific provider.
+#### `createLoggerHelpers()`
+
+Creates a logger helpers.
 
 ```typescript
-function createStorageFromProvider(storage: StorageProvider): {
-  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 createLoggerHelpers(): {
+  getLogger: (name?: string) => Logger
+  createLogger: (config: LoggerConfig) => Logger
+  setLevel: (level: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'silent') => void
+  getLevel: () => string
+  enable: () => void
+  disable: () => void
+  isEnabled: () => boolean
 }
 ```
 
-- `storage` — Storage provider
-
-**Returns:** Storage methods
+**Returns:** The created result.
 
-#### `createStorageHelpers()`
+#### `createLoggerHelpersFromProvider(provider)`
 
-Create storage helpers from context.
+Creates a logger helpers from provider.
 
 ```typescript
-function createStorageHelpers(): {
-  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 createLoggerHelpersFromProvider(provider: LoggerProvider): {
+  getLogger: (name?: string) => Logger
+  createLogger: (config: LoggerConfig) => Logger
+  setLevel: (level: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'silent') => void
+  getLevel: () => string
+  enable: () => void
+  disable: () => void
+  isEnabled: () => boolean
 }
 ```
 
-**Returns:** Storage helper functions
+- `provider` — The provider implementation.
 
-#### `createStorageValue(key, defaultValue)`
+**Returns:** The created result.
 
-Create a storage value primitive.
+#### `createLoggerFromProvider(provider, name)`
+
+Create logger from a specific provider.
 
 ```typescript
-function createStorageValue(
-  key: string,
-  defaultValue?: T,
-): {
-  value: () => T | undefined
-  loading: () => boolean
-  error: () => Error | null
-  set: (value: T) => Promise<void>
-  remove: () => Promise<void>
-  refresh: () => Promise<T | undefined>
-}
+function createLoggerFromProvider(provider: LoggerProvider, name?: string): Logger
 ```
 
-- `key` — Storage key
-- `defaultValue` — Default value if not found
+- `provider` — Logger provider
+- `name` — Logger name
 
-**Returns:** Storage value accessor and actions
+**Returns:** Logger instance
 
-#### `createStorageValueFromProvider(storage, key, defaultValue)`
+#### `createLogin()`
 
-Create storage value primitive from a specific provider.
+Creates a login primitive with async state tracking.
 
 ```typescript
-function createStorageValueFromProvider(
-  storage: StorageProvider,
-  key: string,
-  defaultValue?: T,
-): {
-  value: () => T | undefined
-  loading: () => boolean
-  error: () => Error | null
-  set: (value: T) => Promise<void>
-  remove: () => Promise<void>
-}
+function createLogin(): CreateLoginReturn<T>
 ```
 
-- `storage` — Storage provider
-- `key` — Storage key
-- `defaultValue` — Default value
+**Returns:** Login state and action
 
-**Returns:** Storage value accessor and actions
+#### `createOAuth(options)`
 
-#### `createStore(config)`
+Creates OAuth helpers.
 
-Create a reactive store using Solid signals.
+Automatically handles OAuth callbacks by detecting `code` and `state` URL
+parameters and exchanging them for a session:
+
+- Inside a Solid owner (component setup / `createRoot`), the callback
+  handling is deferred to `onMount` so it runs client-side after mount.
+- Outside an owner (a plain function call, e.g. bootstrap code), it runs
+  immediately at creation, browser-guarded.
 
 ```typescript
-function createStore(config: StoreConfig<T>): Store<T>
+function createOAuth(options?: CreateOAuthOptions): CreateOAuthReturn
 ```
 
-- `config` — Store configuration
+- `options` — OAuth configuration
 
-**Returns:** Store instance
+**Returns:** The created instance.
 
-#### `createTheme()`
+#### `createPasswordReset()`
 
-Create theme primitives for theme state and actions.
+Creates a password reset primitive with async state tracking.
 
 ```typescript
-function createTheme(): ThemePrimitives
+function createPasswordReset(): CreatePasswordResetReturn
 ```
 
-**Returns:** The created instance.
+**Returns:** Password reset state and actions
 
-#### `createThemeColors(theme)`
+#### `createPlatform()`
 
-Create a colors accessor derived from a theme accessor.
+Create platform primitives for detecting the current platform.
+
+This is a static primitive (no reactive signals) since the platform
+does not change during the lifecycle of the app.
 
 ```typescript
-function createThemeColors(theme: Accessor<Theme>): Accessor<ThemeColors>
+function createPlatform(): PlatformPrimitives
 ```
 
-- `theme` — Theme accessor (e.g. from createTheme().theme)
-
-**Returns:** Accessor for the current theme colors
+**Returns:** Platform primitives object
 
-#### `createThemeFromProvider(provider)`
+#### `createPromise(asyncFn)`
 
-Create theme primitives from a specific provider.
+Primitive that wraps an async function with reactive state tracking.
 
 ```typescript
-function createThemeFromProvider(provider: ThemeProvider): ThemePrimitives
+function createPromise(asyncFn: T): CreatePromiseReturn<Awaited<ReturnType<T>>>
 ```
 
-- `provider` — Theme provider
+- `asyncFn` — The async function to wrap
 
-**Returns:** Theme primitives
+**Returns:** Object with state accessor, call, cancel, and reset functions
 
-#### `createThemeHelpers()`
+#### `createPush()`
 
-Creates a theme helpers.
+Create push notification primitives.
 
 ```typescript
-function createThemeHelpers(): {
-  getTheme: () => Theme
-  setTheme: (name: string) => void
-  getMode: () => 'light' | 'dark'
-  toggleMode: () => void
-  getAvailableThemes: () => Theme[]
-}
+function createPush(): PushPrimitives
 ```
 
-**Returns:** The created result.
+**Returns:** Push primitives object
 
-#### `createVersion()`
+#### `createRouter()`
 
-Create version primitives for tracking app updates.
+Create router primitives for navigation state and actions.
 
 ```typescript
-function createVersion(): VersionPrimitives
+function createRouter(): RouterPrimitives
 ```
 
-**Returns:** Version primitives object
+**Returns:** Router primitives object
 
-#### `createWatchSignal(controller, name)`
+#### `useLocation()`
 
-Create a reactive accessor that tracks a single field's value.
+Get current route location as accessor.
 
 ```typescript
-function createWatchSignal(controller: FormController<T>, name: K): Accessor<T[K]>
+function useLocation(): Accessor<RouteLocation>
 ```
 
-- `controller` — Form controller
-- `name` — Field name to watch
-
-**Returns:** Accessor for the field value
+**Returns:** Accessor for current location
 
-#### `getAuthClient()`
+#### `useParams()`
 
-Get the auth client from context.
+Get current route params as accessor.
 
 ```typescript
-function getAuthClient(): AuthClient<T>
+function useParams(): Accessor<RouteParams>
 ```
 
-**Returns:** The auth client instance.
+**Returns:** Accessor for route params
 
-#### `getChildLogger(name, context)`
+#### `useQuery()`
 
-Create a child logger with additional context.
+Get current query params as accessor.
 
 ```typescript
-function getChildLogger(name: string, context: Record<string, unknown>): Logger
+function useQuery(): Accessor<QueryParams>
 ```
 
-- `name` — Parent logger name
-- `context` — Additional context
-
-**Returns:** Child logger instance
+**Returns:** Accessor for query params
 
-#### `getHttpClient()`
+#### `useNavigate()`
 
-Get the HTTP client from context.
+Get navigate function.
 
 ```typescript
-function getHttpClient(): HttpClient
+function useNavigate(): (path: string, options?: NavigateOptions) => void
 ```
 
-**Returns:** The HTTP client instance.
+**Returns:** Navigate function
 
-#### `getI18nProvider()`
+#### `useMatch(pattern)`
 
-Get the i18n provider from context.
+Create a match accessor for a path pattern.
 
 ```typescript
-function getI18nProvider(): I18nProvider
+function useMatch(pattern: string): Accessor<boolean>
 ```
 
-**Returns:** The i18n provider instance.
+- `pattern` — Path pattern to match
 
-#### `getLogger(name)`
+**Returns:** Accessor indicating if current path matches
 
-Get a logger instance.
+#### `createIsActive(path, exact)`
+
+Create a reactive boolean accessor that tracks whether a given path is active.
+
+Unlike `useMatch` which only accepts a static pattern, this factory returns
+a signal that re-evaluates on every route change and supports the `exact`
+parameter from the router's `isActive` method.
 
 ```typescript
-function getLogger(name?: string): Logger
+function createIsActive(path: string, exact?: boolean): Accessor<boolean>
 ```
 
-- `name` — Logger name
+- `path` — Path to check against the current location
+- `exact` — Whether to require an exact match (default: false)
 
-**Returns:** Logger instance
+**Returns:** Accessor<boolean> that is true when the path is active
 
-#### `getLoggerProvider()`
+#### `createRouterHelpers()`
 
-Get the logger provider from context.
+Creates a router helpers.
 
 ```typescript
-function getLoggerProvider(): LoggerProvider
+function createRouterHelpers(): {
+  navigate: (path: string, options?: NavigateOptions) => void
+  navigateTo: (
+    name: string,
+    params?: RouteParams,
+    query?: QueryParams,
+    options?: NavigateOptions,
+  ) => void
+  back: () => void
+  forward: () => void
+  getLocation: () => RouteLocation
+  getParams: () => RouteParams
+  getQuery: () => QueryParams
+  isActive: (path: string) => boolean
+}
 ```
 
-**Returns:** The logger provider instance.
+**Returns:** The created result.
 
-#### `getRootLogger()`
+#### `createRouterFromInstance(router)`
 
-Get the root logger.
+Create router primitives from a specific router.
 
 ```typescript
-function getRootLogger(): Logger
+function createRouterFromInstance(router: Router): RouterPrimitives
 ```
 
-**Returns:** Root logger instance
+- `router` — Router instance
 
-#### `getRouter()`
+**Returns:** Router primitives
 
-Get the router from context.
+#### `createSignup()`
+
+Creates a signup primitive with async state tracking.
 
 ```typescript
-function getRouter(): Router
+function createSignup(): CreateSignupReturn<T>
 ```
 
-**Returns:** The router instance.
+**Returns:** Signup state and action
 
-#### `getStateProvider()`
+#### `createStore(config)`
 
-Get the state provider from context.
+Create a reactive store using Solid signals.
 
 ```typescript
-function getStateProvider(): StateProvider
+function createStore(config: StoreConfig<T>): Store<T>
 ```
 
-**Returns:** The state provider instance.
+- `config` — Store configuration
 
-#### `getStorageProvider()`
+**Returns:** Store instance
 
-Get the storage provider from context.
+#### `useStore(store, selector)`
+
+Use a store with optional selector, returning an accessor.
 
 ```typescript
-function getStorageProvider(): StorageProvider
+function useStore(store: Store<T>, selector?: (state: T) => S): Accessor<S>
 ```
 
-**Returns:** The storage provider instance.
+- `store` — Store to subscribe to
+- `selector` — Optional selector function
 
-#### `getThemeProvider()`
+**Returns:** Accessor for selected state
 
-Get the theme provider from context.
+#### `createSignalStore(initial)`
+
+Create a simple signal-based store without provider.
 
 ```typescript
-function getThemeProvider(): ThemeProvider
+function createSignalStore(initial: T): [Accessor<T>, (value: T | ((prev: T) => T)) => void]
 ```
 
-**Returns:** The theme provider instance.
+- `initial` — Initial state
 
-#### `MoleculeProvider(props)`
+**Returns:** The created instance.
 
-MoleculeProvider component that provides all molecule services to the component tree.
+#### `createPersistedStore(key, initial, storage)`
+
+Create a persisted signal store.
 
 ```typescript
-function MoleculeProvider(props: ParentProps<{ config: MoleculeConfig }>): JSX.Element
+function createPersistedStore(
+  key: string,
+  initial: T,
+  storage: StorageAdapter,
+): [Accessor<T>, (value: T | ((prev: T) => T)) => void]
 ```
 
-- `props` — Component props containing the molecule config.
+- `key` — Storage key
+- `initial` — Initial value
+- `storage` — Storage adapter (required - use localStorage, sessionStorage, or `@molecule/app-storage`)
 
-**Returns:** The nested provider tree wrapping children.
+**Returns:** Tuple of accessor and setter
 
-#### `useComponentLogger(componentName)`
+#### `createStateHelpers()`
 
-Create a component logger that includes component name in context.
+Creates a state helpers.
 
 ```typescript
-function useComponentLogger(componentName: string): Logger
+function createStateHelpers(): {
+  createStore: <T extends object>(config: StoreConfig<T>) => Store<T>
+}
 ```
 
-- `componentName` — Name of the component
-
-**Returns:** Logger configured for the component
+**Returns:** The created result.
 
-#### `useFetch(url, config)`
+#### `createStateHelpersFromProvider(provider)`
 
-Create a resource for fetching data.
+Creates a state helpers from provider.
 
 ```typescript
-function useFetch(url: string | Accessor<string>, config?: RequestConfig): Resource<T | undefined>
+function createStateHelpersFromProvider(provider: StateProvider): {
+  createStore: <T extends object>(config: StoreConfig<T>) => Store<T>
+}
 ```
 
-- `url` — URL string or accessor returning a URL string.
-- `config` — Optional request configuration.
+- `provider` — The provider implementation.
 
-**Returns:** Solid resource
+**Returns:** The created result.
 
-#### `useLazyQuery()`
+#### `createStorageValue(key, defaultValue)`
 
-Hook for lazy query.
+Create a storage value primitive.
 
 ```typescript
-function useLazyQuery(): {
-  execute: (url: string, config?: RequestConfig) => Promise<T>
-  data: () => T | null
-  isLoading: () => boolean
+function createStorageValue(
+  key: string,
+  defaultValue?: T,
+): {
+  value: () => T | undefined
+  loading: () => boolean
   error: () => Error | null
-  reset: () => void
+  set: (value: T) => Promise<void>
+  remove: () => Promise<void>
+  refresh: () => Promise<T | undefined>
 }
 ```
 
-**Returns:** The result.
+- `key` — Storage key
+- `defaultValue` — Default value if not found
 
-#### `useLocale()`
+**Returns:** Storage value accessor and actions
 
-Get current locale as accessor.
+#### `createStorage()`
+
+Create storage primitives.
 
 ```typescript
-function useLocale(): Accessor<string>
+function createStorage(): {
+  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:** Accessor for current locale
+**Returns:** Storage methods
 
-#### `useLocation()`
+#### `usePersistedSignal(key, defaultValue)`
 
-Get current route location as accessor.
+Create a persisted signal that syncs with storage.
 
 ```typescript
-function useLocation(): Accessor<RouteLocation>
+function usePersistedSignal(
+  key: string,
+  defaultValue: T,
+): [Accessor<T | undefined>, (value: T | ((prev: T | undefined) => T)) => void]
 ```
 
-**Returns:** Accessor for current location
+- `key` — Storage key
+- `defaultValue` — Default value
 
-#### `useMatch(pattern)`
+**Returns:** Tuple of accessor and setter
 
-Create a match accessor for a path pattern.
+#### `createStorageHelpers()`
+
+Create storage helpers from context.
 
 ```typescript
-function useMatch(pattern: string): Accessor<boolean>
+function createStorageHelpers(): {
+  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[]>
+}
 ```
 
-- `pattern` — Path pattern to match
-
-**Returns:** Accessor indicating if current path matches
+**Returns:** Storage helper functions
 
-#### `useMode()`
+#### `createStorageFromProvider(storage)`
 
-Create a mode accessor.
+Create storage primitives from a specific provider.
 
 ```typescript
-function useMode(): Accessor<'light' | 'dark'>
+function createStorageFromProvider(storage: StorageProvider): {
+  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:** Accessor for current mode
+- `storage` — Storage provider
 
-#### `useMutation()`
+**Returns:** Storage methods
 
-Hook for mutation.
+#### `createStorageValueFromProvider(storage, key, defaultValue)`
+
+Create storage value primitive from a specific provider.
 
 ```typescript
-function useMutation(): {
-  mutate: (
-    url: string,
-    payload?: unknown,
-    method?: 'POST' | 'PUT' | 'PATCH' | 'DELETE',
-  ) => Promise<T>
-  isLoading: Accessor<boolean>
-  error: Accessor<Error | null>
-  data: Accessor<T | null>
-  reset: () => void
+function createStorageValueFromProvider(
+  storage: StorageProvider,
+  key: string,
+  defaultValue?: T,
+): {
+  value: () => T | undefined
+  loading: () => boolean
+  error: () => Error | null
+  set: (value: T) => Promise<void>
+  remove: () => Promise<void>
 }
 ```
 
-**Returns:** The result.
+- `storage` — Storage provider
+- `key` — Storage key
+- `defaultValue` — Default value
 
-#### `useNavigate()`
+**Returns:** Storage value accessor and actions
 
-Get navigate function.
+#### `createTheme()`
+
+Create theme primitives for theme state and actions.
 
 ```typescript
-function useNavigate(): (path: string, options?: NavigateOptions) => void
+function createTheme(): ThemePrimitives
 ```
 
-**Returns:** Navigate function
+**Returns:** The created instance.
 
-#### `useParams()`
+#### `useMode()`
 
-Get current route params as accessor.
+Create a mode accessor.
 
 ```typescript
-function useParams(): Accessor<RouteParams>
+function useMode(): Accessor<'light' | 'dark'>
 ```
 
-**Returns:** Accessor for route params
+**Returns:** Accessor for current mode
 
-#### `usePersistedSignal(key, defaultValue)`
+#### `useThemeName()`
 
-Create a persisted signal that syncs with storage.
+Create a theme name accessor.
 
 ```typescript
-function usePersistedSignal(
-  key: string,
-  defaultValue: T,
-): [Accessor<T | undefined>, (value: T | ((prev: T | undefined) => T)) => void]
+function useThemeName(): Accessor<string>
 ```
 
-- `key` — Storage key
-- `defaultValue` — Default value
-
-**Returns:** Tuple of accessor and setter
+**Returns:** Accessor for current theme name
 
-#### `usePlural(key, count, values)`
+#### `createThemeHelpers()`
 
-Create a reactive plural translation.
+Creates a theme helpers.
 
 ```typescript
-function usePlural(
-  key: string,
-  count: Accessor<number>,
-  values?: InterpolationValues,
-): Accessor<string>
+function createThemeHelpers(): {
+  getTheme: () => Theme
+  setTheme: (name: string) => void
+  getMode: () => 'light' | 'dark'
+  toggleMode: () => void
+  getAvailableThemes: () => Theme[]
+}
 ```
 
-- `key` — Translation key
-- `count` — Count accessor for pluralization
-- `values` — Interpolation values for the translation.
-
-**Returns:** Accessor for translated string
+**Returns:** The created result.
 
-#### `useQuery()`
+#### `createThemeFromProvider(provider)`
 
-Get current query params as accessor.
+Create theme primitives from a specific provider.
 
 ```typescript
-function useQuery(): Accessor<QueryParams>
+function createThemeFromProvider(provider: ThemeProvider): ThemePrimitives
 ```
 
-**Returns:** Accessor for query params
+- `provider` — Theme provider
 
-#### `useStore(store, selector)`
+**Returns:** Theme primitives
 
-Use a store with optional selector, returning an accessor.
+#### `createThemeColors(theme)`
+
+Create a colors accessor derived from a theme accessor.
 
 ```typescript
-function useStore(store: Store<T>, selector?: (state: T) => S): Accessor<S>
+function createThemeColors(theme: Accessor<Theme>): Accessor<ThemeColors>
 ```
 
-- `store` — Store to subscribe to
-- `selector` — Optional selector function
+- `theme` — Theme accessor (e.g. from createTheme().theme)
 
-**Returns:** Accessor for selected state
+**Returns:** Accessor for the current theme colors
 
-#### `useThemeName()`
+#### `applyThemeToDocument()`
 
-Create a theme name accessor.
+Apply theme CSS variables to document.
 
 ```typescript
-function useThemeName(): Accessor<string>
+function applyThemeToDocument(): void
 ```
 
-**Returns:** Accessor for current theme name
-
-#### `useTranslate()`
+#### `createVersion()`
 
-Get translate function.
+Create version primitives for tracking app updates.
 
 ```typescript
-function useTranslate(): TranslateFunction
+function createVersion(): VersionPrimitives
 ```
 
-**Returns:** Translate function
+**Returns:** Version primitives object
 
-#### `useTranslation(key, values, options)`
+#### `MoleculeProvider(props)`
 
-Create a reactive translation.
+MoleculeProvider component that provides all molecule services to the component tree.
 
 ```typescript
-function useTranslation(
-  key: string,
-  values?: InterpolationValues,
-  options?: TranslateOptions,
-): Accessor<string>
+function MoleculeProvider(props: ParentProps<{ config: MoleculeConfig }>): JSX.Element
 ```
 
-- `key` — Translation key
-- `values` — Interpolation values for the translation.
-- `options` — Translation options
+- `props` — Component props containing the molecule config.
 
-**Returns:** Accessor for translated string
+**Returns:** The nested provider tree wrapping children.
 
 ### Constants
 
-#### `AuthContext`
-
-```typescript
-const AuthContext: Context<AuthClient<unknown> | undefined>
-```
+#### `StateContext`
 
-#### `HttpContext`
+Internal contexts for molecule providers.
 
 ```typescript
-const HttpContext: Context<HttpClient | undefined>
+const StateContext: Context<StateProvider | undefined>
 ```
 
-#### `I18nContext`
+#### `AuthContext`
 
 ```typescript
-const I18nContext: Context<I18nProvider | undefined>
+const AuthContext: Context<AuthClient<unknown, Record<never, never>> | undefined>
 ```
 
-#### `LoggerContext`
+#### `ThemeContext`
 
 ```typescript
-const LoggerContext: Context<LoggerProvider | undefined>
+const ThemeContext: Context<ThemeProvider | undefined>
 ```
 
 #### `RouterContext`
@@ -2466,12 +2551,16 @@ const LoggerContext: Context<LoggerProvider | undefined>
 const RouterContext: Context<Router | undefined>
 ```
 
-#### `StateContext`
+#### `I18nContext`
 
-Internal contexts for molecule providers.
+```typescript
+const I18nContext: Context<I18nProvider | undefined>
+```
+
+#### `HttpContext`
 
 ```typescript
-const StateContext: Context<StateProvider | undefined>
+const HttpContext: Context<HttpClient | undefined>
 ```
 
 #### `StorageContext`
@@ -2480,10 +2569,10 @@ const StateContext: Context<StateProvider | undefined>
 const StorageContext: Context<StorageProvider | undefined>
 ```
 
-#### `ThemeContext`
+#### `LoggerContext`
 
 ```typescript
-const ThemeContext: Context<ThemeProvider | undefined>
+const LoggerContext: Context<LoggerProvider | undefined>
 ```
 
 ## Injection Notes