@oxyhq/services 23.0.2 → 23.0.3

package/lib/typescript/module/notifications/deviceNotifications.d.ts

@@ -0,0 +1,192 @@
+/**
+ * The ONE place `@oxyhq/services` touches `expo-notifications`.
+ *
+ * Every Oxy app that receives push needs the identical adapter — native-only,
+ * dynamically imported, reading the OS permission and minting an EXPO push
+ * token — so it lives here instead of being copied into each app. The
+ * bearer-authenticated transport (`registerPushToken` / `unregisterPushToken`)
+ * already lives in `@oxyhq/core`; core may never import an `expo-*` module, and
+ * this adapter is the Expo-side half that closes that gap.
+ *
+ * ## Reached through its OWN entry point, never the root barrel
+ *
+ * ```ts
+ * import { getExpoPushToken } from '@oxyhq/services/notifications';
+ * ```
+ *
+ * This is the only module in the package that depends on peers an app which
+ * does not use push genuinely never installs, and a barrel export would put it
+ * in EVERY consumer's import graph. `tsc` resolves the specifier of an
+ * `import()` even when the call is lazy and inside a try/catch, so a barrel
+ * export turned "optional peer" into a hard requirement: consumers with no
+ * interest in push failed to type-check with TS2307. The subpath is what keeps
+ * the optionality honest — see the note in `src/index.ts`.
+ *
+ * Metro is the resolver that behaves differently here, and in the useful
+ * direction: an unresolvable DYNAMIC `import()` bundles fine (the `catch` below
+ * takes over at runtime), where a static import fails the build outright. That
+ * is why the runtime shape below must stay dynamic-and-guarded.
+ *
+ * ## Native-only by construction
+ *
+ * Every entry point resolves its null/no-op result from `Platform.OS` BEFORE the
+ * dynamic `import()`, so a web bundle never requests `expo-notifications` at all.
+ * `expo-notifications` and `expo-constants` are OPTIONAL peer dependencies: an
+ * app that does not use push never installs them, and a build without them
+ * degrades to "notifications unavailable" rather than throwing at
+ * module-evaluation time.
+ *
+ * ## The token is an EXPO push token — never a raw device token
+ *
+ * {@link getExpoPushToken} calls `getExpoPushTokenAsync()`, which returns the
+ * `ExponentPushToken[…]` handle Expo's push service delivers through — the only
+ * form it accepts. `getDevicePushTokenAsync()` — the raw APNs/FCM token — is
+ * deliberately NOT used anywhere: registering one of those looks entirely
+ * successful (the row is stored, the endpoint returns 200) and then every push
+ * silently fails at delivery time. `@oxyhq/core`'s `registerPushToken` rejects a
+ * raw device token before sending, and this module is the reason it never has to.
+ *
+ * ## The payload is untrusted
+ *
+ * Nothing here surfaces a notification's `title` / `body` / `subtitle`. The only
+ * payload that leaves this module is the raw `content.data` — the routing keys —
+ * typed `unknown`, so a caller has to validate it before acting on it and there
+ * is no exported shape that invites rendering push-delivered text. The
+ * foreground handler likewise answers with a visibility verdict and nothing else.
+ */
+import type { PushTokenPlatform } from '@oxyhq/core';
+/**
+ * The platform tag the push-token registry stores this installation under, or
+ * `null` on a platform Oxy does not deliver push to.
+ *
+ * Synchronous and import-free — the answer is a property of the bundle, not of
+ * any native module.
+ *
+ * Web is `null` on purpose: the registry accepts a `web` platform, but browser
+ * push needs a VAPID key + service-worker subscription no Oxy app has wired, so
+ * there is no token to register and claiming otherwise would store a row nothing
+ * can ever deliver to.
+ */
+export declare function pushTokenPlatform(): PushTokenPlatform | null;
+/**
+ * Whether the OS notification permission is ALREADY granted.
+ *
+ * Never prompts, so an app can re-check on every cold boot without ever asking
+ * the user twice. Use {@link requestNotificationPermission} for the one place
+ * that is allowed to show the system dialog.
+ */
+export declare function hasNotificationPermission(): Promise<boolean>;
+/**
+ * Ensure the OS notification permission, prompting at most once.
+ *
+ * An installation that already answered the system dialog is never asked again:
+ * an already-granted permission resolves `true` without a second dialog, and a
+ * denial with `canAskAgain: false` resolves `false` without issuing a request
+ * the OS would silently ignore.
+ *
+ * @returns Whether notifications are granted once this call is done.
+ */
+export declare function requestNotificationPermission(): Promise<boolean>;
+/**
+ * This installation's Expo push token (`ExponentPushToken[…]`), or `null` when
+ * one cannot be minted.
+ *
+ * Deliberately `getExpoPushTokenAsync` — see the module header for why the raw
+ * device-token variant is never used.
+ *
+ * Every `null` is logged with the reason it happened. A missing EAS project id
+ * in particular is a BUILD MISCONFIGURATION, not a user state: no token can ever
+ * be minted, so push is off for every install of that build until the config is
+ * fixed. It is reported as such rather than blending into the
+ * indistinguishable "permission denied / offline" bucket.
+ */
+export declare function getExpoPushToken(): Promise<string | null>;
+/**
+ * Take the payload of the notification that COLD-LAUNCHED the app, if any.
+ *
+ * "Take" is literal: the response is cleared from `expo-notifications` once
+ * read, so a listener attached later in the same launch is not handed the same
+ * tap again. Clearing is best-effort across OS/module versions, so a caller that
+ * must not act twice still needs its own idempotency ledger.
+ *
+ * @returns The raw, untrusted `content.data` of the launching notification, or
+ *   `null`. Parsing/validation is the caller's job.
+ */
+export declare function takeLaunchNotificationData(): Promise<unknown>;
+/**
+ * What the OS should do with a notification that arrives while the app is
+ * FOREGROUNDED.
+ *
+ * `'suppress'` is `expo-notifications`' own default for a foregrounded app, so a
+ * decision function that only ever returns `'show'` for the payloads it
+ * recognises leaves every other notification exactly as it behaves today.
+ */
+export type ForegroundPresentation = 'show' | 'suppress';
+/** How prominently Android surfaces a channel's notifications. */
+export type NotificationChannelImportance = 'default' | 'high';
+/** An Android notification channel this app delivers on. */
+export interface NotificationChannelSpec {
+    /**
+     * The channel id. It MUST match the id the sender attaches: Android 8+ drops
+     * a notification whose channel the app has not created, silently and with no
+     * error on either side, which is the hardest push symptom there is to
+     * diagnose. Ids that cross the wire belong in `@oxyhq/contracts`, not in a
+     * string typed on both sides.
+     */
+    id: string;
+    /** User-visible channel name — app copy, so the caller localizes it. */
+    name: string;
+    /** User-visible description shown in Android's notification settings. */
+    description?: string;
+    importance?: NotificationChannelImportance;
+}
+/**
+ * Create (or update) an Android notification channel.
+ *
+ * A no-op everywhere but Android: iOS has no channels, and web never loads the
+ * native module. Call it BEFORE registering a push token, so the very first
+ * notification the server sends already has a channel to land on.
+ *
+ * Failure is non-fatal and logged: a missing channel costs visibility, and
+ * refusing to register a token over it would cost the feature entirely.
+ *
+ * @returns Whether the channel was actually created (`false` off Android, or
+ *   when the native module is unavailable, or when creation failed).
+ */
+export declare function ensureNotificationChannel(spec: NotificationChannelSpec): Promise<boolean>;
+/**
+ * Install the ONE process-wide handler that decides whether an incoming
+ * notification is shown while the app is in the FOREGROUND.
+ *
+ * Without a handler, `expo-notifications` shows nothing at all while the app is
+ * open — which is exactly when a time-critical notification (a "Sign in with
+ * Oxy" approval request, say) matters most, because the user is already holding
+ * the phone.
+ *
+ * The handler ONLY decides visibility. It never navigates, never acts on the
+ * notification, and never reads the payload for display — `decide` is handed the
+ * raw, untrusted `content.data` and may answer nothing but `'show'` /
+ * `'suppress'`. Acting on a notification stays with a TAP, routed by
+ * {@link subscribeToNotificationResponses}. No notification actions/categories
+ * are registered here, so the banner cannot carry an action button.
+ *
+ * The one-shot latch is set BEFORE the first `await`, so concurrent callers
+ * cannot both reach `setNotificationHandler`.
+ *
+ * @param decide - Maps the raw, untrusted payload to a presentation verdict.
+ *   Must not throw; a throw is reported by the OS as a handling error and the
+ *   notification is dropped.
+ * @returns Whether a handler was installed by THIS call (`false` on a repeat
+ *   call, on web, or when the native module is unavailable).
+ */
+export declare function installForegroundNotificationHandler(decide: (data: unknown) => ForegroundPresentation): Promise<boolean>;
+/**
+ * Subscribe to notification TAPS (responses) while the app is running.
+ *
+ * @param listener - Receives the raw, untrusted `content.data` of the tapped
+ *   notification. Parsing/validation is the caller's job.
+ * @returns An unsubscribe function. Safe to call even if the subscription could
+ *   not be established.
+ */
+export declare function subscribeToNotificationResponses(listener: (data: unknown) => void): Promise<() => void>;
+//# sourceMappingURL=deviceNotifications.d.ts.map

package/lib/typescript/module/notifications/deviceNotifications.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deviceNotifications.d.ts","sourceRoot":"","sources":["../../../../src/notifications/deviceNotifications.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AA4ErD;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,IAAI,iBAAiB,GAAG,IAAI,CAE5D;AAED;;;;;;GAMG;AACH,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,OAAO,CAAC,CAgBlE;AAED;;;;;;;;;GASG;AACH,wBAAsB,6BAA6B,IAAI,OAAO,CAAC,OAAO,CAAC,CAuBtE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA0B/D;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,0BAA0B,IAAI,OAAO,CAAC,OAAO,CAAC,CA6BnE;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,sBAAsB,GAAG,MAAM,GAAG,UAAU,CAAC;AAiBzD,kEAAkE;AAClE,MAAM,MAAM,6BAA6B,GAAG,SAAS,GAAG,MAAM,CAAC;AAE/D,4DAA4D;AAC5D,MAAM,WAAW,uBAAuB;IACtC;;;;;;OAMG;IACH,EAAE,EAAE,MAAM,CAAC;IACX,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;IACb,yEAAyE;IACzE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,6BAA6B,CAAC;CAC5C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,uBAAuB,GAC5B,OAAO,CAAC,OAAO,CAAC,CA0BlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,oCAAoC,CACxD,MAAM,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,sBAAsB,GAChD,OAAO,CAAC,OAAO,CAAC,CAsClB;AAED;;;;;;;GAOG;AACH,wBAAsB,gCAAgC,CACpD,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,GAChC,OAAO,CAAC,MAAM,IAAI,CAAC,CAkBrB"}

package/lib/typescript/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/module/ui/boot/runProviderColdBoot.d.ts

@@ -0,0 +1,60 @@
+import { type AuthStateStore, type IdentityBinding, type OxyServices, type SessionMode } from '@oxyhq/core';
+import type { SessionClient } from '@oxyhq/core';
+import type { CommitInput } from '../context/oxyContextTypes.js';
+/** How long the cold boot waits for the post-boot SessionClient handoff (ms). */
+export declare const SESSION_HANDOFF_DEADLINE_MS = 6000;
+/**
+ * HARD overall deadline (ms) for the whole `runSessionColdBoot` step chain.
+ *
+ * Bounds time-to-route: routing gates on `isAuthResolved`, which resolves when
+ * the cold boot finishes, so a network step that never settles (a black-hole
+ * network that neither connects nor rejects) would otherwise hang routing
+ * indefinitely. 12s comfortably exceeds the healthy worst case of the
+ * sequential, single-attempt (`retry:false`), 5s-capped network steps, so it is
+ * INERT on healthy loads and only trips on a pathological network. Offline
+ * devices short-circuit far sooner via the connectivity hint below.
+ */
+export declare const COLD_BOOT_OVERALL_DEADLINE_MS = 12000;
+export interface RunProviderColdBootOptions {
+    oxyServices: OxyServices;
+    authStore: AuthStateStore;
+    clientId?: string;
+    authRedirectUri?: string;
+    /**
+     * Who owns the session this boot resolves. `'account'` (the default) is the
+     * device's active account — every ordinary Oxy app. `'identity'` binds the
+     * boot to the owner of this device's PRIMARY identity key and REQUIRES
+     * {@link identity}; it also disables the web OAuth return leg below, which
+     * commits whatever account the IdP hands back.
+     */
+    sessionMode?: SessionMode;
+    /** The identity binding required by `sessionMode: 'identity'`. */
+    identity?: IdentityBinding;
+    sessionClient: SessionClient;
+    syncDeviceCredentialToHost: () => Promise<void>;
+    commitSession: (input: CommitInput, options: {
+        activate: boolean;
+    }) => Promise<void>;
+    markAuthResolved: () => void;
+    setTokenReady: (ready: boolean) => void;
+}
+/**
+ * Device-first cold boot for `@oxyhq/services` providers.
+ *
+ * Ordered pipeline:
+ * 1. Complete an OAuth authorization-code return already on the URL (web)
+ * 2. `runSessionColdBoot` — device-secret mint (+ native shared-key, or the
+ *    primary-identity-key lane in `sessionMode: 'identity'`)
+ *
+ * Step 1 is ACCOUNT-MODE ONLY: it commits whichever account the IdP resolves,
+ * which for an identity-bound client is somebody else's account by construction.
+ * In `'identity'` mode the boot is exactly step 2.
+ *
+ * The boot NEVER navigates the top-level window. There is no automatic
+ * `prompt=none` bounce to the IdP: a web origin with no local device credential
+ * resolves SIGNED OUT and waits for the user's next explicit "Continue with
+ * Oxy", which opens a popup from a real gesture (#691 phase 7b). Step 1 is not a
+ * navigation — it only consumes a code that is already in the address bar.
+ */
+export declare function runProviderColdBoot(opts: RunProviderColdBootOptions): Promise<void>;
+//# sourceMappingURL=runProviderColdBoot.d.ts.map

package/lib/typescript/module/ui/boot/runProviderColdBoot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runProviderColdBoot.d.ts","sourceRoot":"","sources":["../../../../../src/ui/boot/runProviderColdBoot.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,WAAW,EACjB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAKjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA4B,CAAC;AAE9D,iFAAiF;AACjF,eAAO,MAAM,2BAA2B,OAAO,CAAC;AAEhD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,6BAA6B,QAAS,CAAC;AA0CpD,MAAM,WAAW,0BAA0B;IACzC,WAAW,EAAE,WAAW,CAAC;IACzB,SAAS,EAAE,cAAc,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,kEAAkE;IAClE,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,aAAa,EAAE,aAAa,CAAC;IAC7B,0BAA0B,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAChD,aAAa,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE;QAAE,QAAQ,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACrF,gBAAgB,EAAE,MAAM,IAAI,CAAC;IAC7B,aAAa,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACzC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,0BAA0B,GAAG,OAAO,CAAC,IAAI,CAAC,CA4HzF"}

package/lib/typescript/module/ui/client.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Client-only UI exports (tree-shakeable)
+ *
+ * Import from this module for client-side bundles where tree-shaking is important.
+ * These are direct exports without runtime detection overhead.
+ *
+ * @example
+ * import { OxyProvider, useOxy, LogoIcon } from '@oxyhq/services/ui/client';
+ */
+export { default as OxyProvider } from './components/OxyProvider.js';
+export { default as OxySignInButton } from './components/OxySignInButton.js';
+export { default as OxyAuthPrompt } from './components/OxyAuthPrompt.js';
+export type { OxyAuthPromptProps } from './components/OxyAuthPrompt.js';
+export { LogoIcon } from './components/logo/LogoIcon.js';
+export { LogoText } from './components/logo/LogoText.js';
+export { default as FollowButton } from './components/FollowButton.js';
+export { default as OxyPayButton } from './components/OxyPayButton.js';
+export { useOxy } from './context/OxyContext.js';
+export { useAuth } from './hooks/useAuth.js';
+export type { AuthState, AuthActions, UseAuthReturn } from './hooks/useAuth.js';
+export { useFollow } from './hooks/useFollow.js';
+export { useStorage } from './hooks/useStorage.js';
+export type { UseStorageOptions, UseStorageResult } from './hooks/useStorage.js';
+export { default as ProfileScreen } from './screens/ProfileScreen.js';
+export { default as ManageAccountScreen } from './screens/ManageAccountScreen.js';
+export { useAuthStore } from './stores/authStore.js';
+export { useAccountStore } from './stores/accountStore.js';
+export { handleAuthError, isInvalidSessionError, isTimeoutOrNetworkError, extractErrorMessage, } from './utils/errorHandlers.js';
+export type { HandleAuthErrorOptions } from './utils/errorHandlers.js';
+//# sourceMappingURL=client.d.ts.map

package/lib/typescript/module/ui/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/ui/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,6BAA0B,CAAC;AAClE,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,iCAA8B,CAAC;AAC1E,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,+BAA4B,CAAC;AACtE,YAAY,EAAE,kBAAkB,EAAE,MAAM,+BAA4B,CAAC;AACrE,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA4B,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA4B,CAAC;AACtD,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,8BAA2B,CAAC;AACpE,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,8BAA2B,CAAC;AAGpE,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAsB,CAAC;AAG9C,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAiB,CAAC;AAC1C,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,oBAAiB,CAAC;AAC7E,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAmB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAoB,CAAC;AAChD,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,uBAAoB,CAAC;AAG9E,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,4BAAyB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,kCAA+B,CAAC;AAG/E,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAoB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAAuB,CAAC;AAGxD,OAAO,EACH,eAAe,EACf,qBAAqB,EACrB,uBAAuB,EACvB,mBAAmB,GACtB,MAAM,0BAAuB,CAAC;AAC/B,YAAY,EAAE,sBAAsB,EAAE,MAAM,0BAAuB,CAAC"}

package/lib/typescript/module/ui/components/AvatarCameraBadge.d.ts

@@ -0,0 +1,4 @@
+import type React from 'react';
+declare const AvatarCameraBadge: React.FC;
+export default AvatarCameraBadge;
+//# sourceMappingURL=AvatarCameraBadge.d.ts.map

package/lib/typescript/module/ui/components/AvatarCameraBadge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AvatarCameraBadge.d.ts","sourceRoot":"","sources":["../../../../../src/ui/components/AvatarCameraBadge.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAyB/B,QAAA,MAAM,iBAAiB,EAAE,KAAK,CAAC,EAO9B,CAAC;AAEF,eAAe,iBAAiB,CAAC"}

package/lib/typescript/module/ui/components/FollowButton.d.ts

@@ -0,0 +1,39 @@
+import type React from 'react';
+import type { ViewStyle, TextStyle, StyleProp } from 'react-native';
+import type { BulkFollowResult, BulkUnfollowResult } from '@oxyhq/core';
+/** Props shared by both single- and multi-user follow modes. */
+interface FollowButtonBaseProps {
+    size?: 'small' | 'medium' | 'large';
+    style?: StyleProp<ViewStyle>;
+    textStyle?: StyleProp<TextStyle>;
+    disabled?: boolean;
+    showLoadingState?: boolean;
+    preventParentActions?: boolean;
+    theme?: 'light' | 'dark';
+    onFollowChange?: (isFollowing: boolean) => void;
+}
+/** Single-user mode — follows/unfollows one user (existing behavior). */
+export interface SingleFollowButtonProps extends FollowButtonBaseProps {
+    userId: string;
+    initiallyFollowing?: boolean;
+    userIds?: never;
+}
+/** Multi-user mode — follows MANY users in one "Follow all" action (follow-only). */
+export interface MultiFollowButtonProps extends FollowButtonBaseProps {
+    userIds: string[];
+    initiallyAllFollowing?: boolean;
+    followAllLabel?: string;
+    followedAllLabel?: string;
+    onBulkFollow?: (result: BulkFollowResult) => void;
+    onBulkUnfollow?: (result: BulkUnfollowResult) => void;
+    userId?: never;
+}
+/**
+ * FollowButton accepts EITHER single-user mode (`userId`) or multi-user mode
+ * (`userIds`), never both. Existing `{ userId, ... }` callers remain valid.
+ */
+export type FollowButtonProps = SingleFollowButtonProps | MultiFollowButtonProps;
+declare const FollowButton: React.FC<FollowButtonProps>;
+export { FollowButton };
+export default FollowButton;
+//# sourceMappingURL=FollowButton.d.ts.map

package/lib/typescript/module/ui/components/FollowButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FollowButton.d.ts","sourceRoot":"","sources":["../../../../../src/ui/components/FollowButton.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EACV,SAAS,EACT,SAAS,EACT,SAAS,EACV,MAAM,cAAc,CAAC;AAQtB,OAAO,KAAK,EAAe,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAMrF,gEAAgE;AAChE,UAAU,qBAAqB;IAC7B,IAAI,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;IACpC,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IAC7B,SAAS,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IACjC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IACzB,cAAc,CAAC,EAAE,CAAC,WAAW,EAAE,OAAO,KAAK,IAAI,CAAC;CACjD;AAED,yEAAyE;AACzE,MAAM,WAAW,uBAAwB,SAAQ,qBAAqB;IACpE,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,OAAO,CAAC,EAAE,KAAK,CAAC;CACjB;AAED,qFAAqF;AACrF,MAAM,WAAW,sBAAuB,SAAQ,qBAAqB;IACnE,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAClD,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,IAAI,CAAC;IACtD,MAAM,CAAC,EAAE,KAAK,CAAC;CAChB;AAED;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,uBAAuB,GAAG,sBAAsB,CAAC;AA+MjF,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAiD7C,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,CAAC;AACxB,eAAe,YAAY,CAAC"}

package/lib/typescript/module/ui/components/OxyAccountDialogScreen.d.ts

@@ -0,0 +1,40 @@
+/**
+ * OxyAccountDialogScreen — the ONE unified account dialog BODY for `@oxyhq/services`.
+ *
+ * The header (title/subtitle per view + back button) around the headless chooser
+ * logic, which lives in `OxyAuthChooser` — the account switcher, sign-in,
+ * sign-up, and QR views are ALL there, extracted so the same chooser can be
+ * mounted bare by a future host with no Dialog chrome (e.g. an auth.oxy.so hub
+ * page driving the cross-origin passkey popup, b2). This file owns ONLY the
+ * header + the scroll body.
+ *
+ * It is presented as the `AccountDialog` route on the shared Bloom SURFACE STACK
+ * (`@oxyhq/bloom/surfaces`) — `OxyContext.openAccountDialog` calls
+ * `presentDetached('AccountDialog', …, { placement: { base: 'bottom', md:
+ * 'center' }, dismissOnBackdrop: false, maxWidth: 420 })`, so the STACK owns the
+ * responsive `<Dialog>` chrome and this component renders only its content. That
+ * replaces the previous standalone controlled `<Dialog open={isAccountDialogOpen}>`
+ * mount: dismissal now flows through the stack (backdrop/swipe disabled), and the
+ * header close button (and `OxyAuthChooser`'s `onComplete`) drive
+ * `useOxy().closeAccountDialog`, which dismisses the surface and runs its exit
+ * animation. The view-enum (`accounts|signin|qr|add|signup`) stays internal here,
+ * driven by the shared `AccountDialogController` in `@oxyhq/core`.
+ */
+import type React from 'react';
+import type { BaseScreenProps } from '../types/navigation.js';
+/**
+ * The unified account dialog BODY — the header + `OxyAuthChooser` chooser.
+ *
+ * Presented as the `AccountDialog` surface (route) on the shared Bloom surface
+ * stack; the surface owns the `<Dialog>` chrome (responsive `{ base: 'bottom',
+ * md: 'center' }` placement, `dismissOnBackdrop={false}`, `maxWidth={420}` — set
+ * by `OxyContext` when it presents this surface), so this component renders ONLY
+ * the content. Open it via `useOxy().openAccountDialog(view?)` or the imperative
+ * `openAccountDialog('signin')`; the view-enum (`accounts|signin|qr|add|signup`)
+ * stays internal here, driven by the shared `AccountDialogController` in
+ * `@oxyhq/core`. Closing routes through `useOxy().closeAccountDialog`, which
+ * dismisses the surface and runs its exit animation.
+ */
+declare const OxyAccountDialogScreen: React.FC<BaseScreenProps>;
+export default OxyAccountDialogScreen;
+//# sourceMappingURL=OxyAccountDialogScreen.d.ts.map

package/lib/typescript/module/ui/components/OxyAccountDialogScreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OxyAccountDialogScreen.d.ts","sourceRoot":"","sources":["../../../../../src/ui/components/OxyAccountDialogScreen.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAO/B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAqB,CAAC;AAc3D;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,sBAAsB,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CA+DrD,CAAC;AA+EF,eAAe,sBAAsB,CAAC"}

package/lib/typescript/module/ui/components/OxyAuthChooser.d.ts

@@ -0,0 +1,54 @@
+/**
+ * OxyAuthChooser — the account switcher + sign-in/sign-up surface, WITHOUT
+ * any dialog chrome.
+ *
+ * A thin React Native binding over the headless `AccountDialogController` in
+ * `@oxyhq/core` (bound via `useSyncExternalStore`) — the same data/state
+ * machine {@link OxyAccountDialogScreen} renders, extracted so it can be mounted in
+ * TWO places: wrapped in Bloom's `<Dialog>` by `OxyAccountDialogScreen` (the normal
+ * in-app surface), and mounted bare by a future auth.oxy.so hub page for the
+ * cross-origin passkey popup (b2) — same chooser, two hosts, two completion
+ * strategies via the `onComplete` prop. Neither host duplicates view logic.
+ *
+ * This file owns WIRING only: the controller binding, the action handlers, and
+ * which view module renders. Every view lives in `./authChooser/`, one
+ * responsibility each:
+ *
+ *  - `accounts` → `AccountsMenuView` — the signed-in Oxy account menu.
+ *  - `add` / `signin` → `SignInEntryView` — ONE primary action, "Continue with
+ *    Oxy" (issue #691, Phase 5). On WEB this view is transient: the flow
+ *    auto-starts the instant the view is reached, because the request surface
+ *    (a QR on an unknown desktop, "Check Commons on your phone" where Oxy could
+ *    deliver) IS the primary route there, never something behind a second tap.
+ *  - `qr` → `SignInRequestView` — the ACTIVE REQUEST: the controller-bound
+ *    wiring over the shared, presentational `OxySignInRequestSurface` (the same
+ *    component the auth.oxy.so IdP mounts from its OAuth-bound request). It maps
+ *    `snapshot.signIn` onto that surface's props; alternatives stay behind
+ *    "Having trouble?" until the chosen route reports `routeFailed`.
+ *  - `signup` → `SignUpView` — account creation, Commons-first.
+ *
+ * Per-account color re-theming uses Bloom's `APP_COLOR_PRESETS` + `BloomColorScope`
+ * (same visual language auth.oxy.so uses). Base theming is `useTheme()` + a
+ * `StyleSheet`, so this renders correctly in EVERY consumer — including apps
+ * that do not use NativeWind (e.g. the accounts app).
+ */
+import type React from 'react';
+export interface OxyAuthChooserProps {
+    /** Called after a completed switch, sign-in, or sign-up. */
+    onComplete?: () => void;
+    /**
+     * When false, the web sign-in entry does not auto-start a device-flow
+     * session on mount. Use for hosts (e.g. the cross-origin passkey hub) that
+     * already have a pending `authorizeCode` and must not spawn a second one.
+     * @default true
+     */
+    autoStartSignIn?: boolean;
+}
+/**
+ * The account switcher + sign-in/sign-up chooser. Mounted by `OxyAccountDialogScreen`
+ * (wrapped in Bloom's `<Dialog>`) today; mountable bare by any future host that
+ * supplies its own `onComplete`.
+ */
+declare const OxyAuthChooser: React.FC<OxyAuthChooserProps>;
+export default OxyAuthChooser;
+//# sourceMappingURL=OxyAuthChooser.d.ts.map

package/lib/typescript/module/ui/components/OxyAuthChooser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OxyAuthChooser.d.ts","sourceRoot":"","sources":["../../../../../src/ui/components/OxyAuthChooser.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAoC/B,MAAM,WAAW,mBAAmB;IAClC,4DAA4D;IAC5D,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IACxB;;;;;OAKG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;GAIG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,mBAAmB,CA0UjD,CAAC;AA4BF,eAAe,cAAc,CAAC"}

package/lib/typescript/module/ui/components/OxyAuthPrompt.d.ts

@@ -0,0 +1,59 @@
+import type React from 'react';
+import { type StyleProp, type ViewStyle } from 'react-native';
+export interface OxyAuthPromptProps {
+    /**
+     * Short label describing what the user is trying to access. Rendered as
+     * the prompt title (e.g. "Notifications", "Privacy"). Keep it to 1-3
+     * words; the subtitle expands on the rationale.
+     */
+    label: string;
+    /**
+     * Optional longer description. If omitted, a generic
+     * `"Sign in to access your {label.toLowerCase()}."` is shown.
+     */
+    description?: string;
+    /**
+     * Variant of the embedded `OxySignInButton`. Defaults to `contained` for
+     * primary placement; pass `outline` or `default` for secondary contexts.
+     */
+    signInButtonVariant?: 'default' | 'outline' | 'contained';
+    /**
+     * Container style override. Use sparingly - the prompt is designed to fit
+     * inside a parent screen / sheet body with its own spacing.
+     */
+    style?: StyleProp<ViewStyle>;
+}
+/**
+ * Inline empty-state shown when an unauthenticated user reaches a surface
+ * that requires sign-in (e.g. a settings subscreen, a deep-linked private
+ * route, the body of a tab that requires identity).
+ *
+ * Renders the Oxy logo, a section label, a rationale line, and an embedded
+ * `OxySignInButton` that opens the standard sign-in flow (web modal /
+ * native bottom sheet, identical to anywhere else `OxySignInButton` is
+ * used).
+ *
+ * Mounts as a regular flex child - it does NOT cover the screen, take over
+ * the navigation, or block the back button. For full-screen modal gating
+ * use a Bloom Dialog/BottomSheet at the layout level and place this
+ * component inside it.
+ *
+ * When the user is authenticated this component renders `null`. This makes
+ * it safe to drop into a screen body without an `isAuthenticated` guard at
+ * the call site.
+ *
+ * @example
+ * ```tsx
+ * if (!isAuthenticated) {
+ *   return (
+ *     <ThemedView className="flex-1">
+ *       <Header options={{ title: 'Notifications' }} />
+ *       <OxyAuthPrompt label="Notifications" />
+ *     </ThemedView>
+ *   );
+ * }
+ * ```
+ */
+export declare const OxyAuthPrompt: React.FC<OxyAuthPromptProps>;
+export default OxyAuthPrompt;
+//# sourceMappingURL=OxyAuthPrompt.d.ts.map

package/lib/typescript/module/ui/components/OxyAuthPrompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OxyAuthPrompt.d.ts","sourceRoot":"","sources":["../../../../../src/ui/components/OxyAuthPrompt.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAIH,KAAK,SAAS,EACd,KAAK,SAAS,EACjB,MAAM,cAAc,CAAC;AAOtB,MAAM,WAAW,kBAAkB;IAC/B;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,mBAAmB,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,WAAW,CAAC;IAE1D;;;OAGG;IACH,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,kBAAkB,CAkDtD,CAAC;AAuCF,eAAe,aAAa,CAAC"}

package/lib/typescript/module/ui/components/OxyConsentScreen.d.ts

@@ -0,0 +1,45 @@
+/** The requesting application, resolved by the caller (never user-supplied raw). */
+export interface OxyConsentApplication {
+    /** Display name of the requesting application. */
+    name: string;
+    /** Application icon — a URL or bare file id passed straight to `<Avatar source>`. */
+    iconUrl?: string;
+    /** Public website of the application, shown as a link when present. */
+    websiteUrl?: string;
+    /** Privacy policy URL, shown as a link when present. */
+    privacyPolicyUrl?: string;
+    /** Terms of service URL, shown as a link when present. */
+    termsUrl?: string;
+    /** Human-readable publisher, used for the "Published by …" provenance line. */
+    developerName?: string;
+    /** True for first-party / official Oxy applications. */
+    isOfficial?: boolean;
+}
+/** The account that will authorize the request (the currently signed-in user). */
+export interface OxyConsentUser {
+    /** Real display name, when the profile has one. */
+    displayName?: string;
+    /** Normalized handle — the sanctioned fallback when `displayName` is absent. */
+    handle?: string;
+    /** Avatar — a URL or bare file id passed straight to `<Avatar source>`. */
+    avatarUri?: string;
+}
+export interface OxyConsentScreenProps {
+    /** The resolved requesting application. */
+    application: OxyConsentApplication;
+    /** OAuth scopes requested by the client (mapped to friendly labels). */
+    scopes: string[];
+    /** The account that will authorize the request, when known. */
+    user?: OxyConsentUser;
+    /** Approve handler — the caller mints the code / completes the flow. */
+    onAllow: () => void | Promise<void>;
+    /** Deny handler — the caller cancels the flow. */
+    onDeny: () => void;
+    /** True while a decision is in flight; disables both actions and spins Allow. */
+    busy?: boolean;
+    /** A blocking error message for the request, when present. */
+    error?: string | null;
+}
+export declare function OxyConsentScreen({ application, scopes, user, onAllow, onDeny, busy, error, }: OxyConsentScreenProps): import("react").JSX.Element;
+export default OxyConsentScreen;
+//# sourceMappingURL=OxyConsentScreen.d.ts.map

package/lib/typescript/module/ui/components/OxyConsentScreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OxyConsentScreen.d.ts","sourceRoot":"","sources":["../../../../../src/ui/components/OxyConsentScreen.tsx"],"names":[],"mappings":"AA8BA,oFAAoF;AACpF,MAAM,WAAW,qBAAqB;IACpC,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,qFAAqF;IACrF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uEAAuE;IACvE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,wDAAwD;IACxD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,+EAA+E;IAC/E,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,wDAAwD;IACxD,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,kFAAkF;AAClF,MAAM,WAAW,cAAc;IAC7B,mDAAmD;IACnD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gFAAgF;IAChF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,qBAAqB;IACpC,2CAA2C;IAC3C,WAAW,EAAE,qBAAqB,CAAC;IACnC,wEAAwE;IACxE,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,+DAA+D;IAC/D,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,wEAAwE;IACxE,OAAO,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpC,kDAAkD;IAClD,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,iFAAiF;IACjF,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,8DAA8D;IAC9D,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAgHD,wBAAgB,gBAAgB,CAAC,EAC/B,WAAW,EACX,MAAM,EACN,IAAI,EACJ,OAAO,EACP,MAAM,EACN,IAAY,EACZ,KAAY,GACb,EAAE,qBAAqB,+BA6KvB;AAoID,eAAe,gBAAgB,CAAC"}

package/lib/typescript/module/ui/components/OxyOAuthCallback.d.ts

@@ -0,0 +1,11 @@
+export interface OxyOAuthCallbackProps {
+    /** Where to navigate after OAuth exchange completes. @default '/' */
+    redirectTo?: string;
+}
+/**
+ * Optional dedicated OAuth callback route for apps using `/oauth/callback`.
+ * `OxyProvider` cold boot handles `?code=` on any route; mount this on the
+ * callback path for a Clerk-style loading shell while auth resolves.
+ */
+export declare function OxyOAuthCallback({ redirectTo }: OxyOAuthCallbackProps): import("react").JSX.Element;
+//# sourceMappingURL=OxyOAuthCallback.d.ts.map

package/lib/typescript/module/ui/components/OxyOAuthCallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OxyOAuthCallback.d.ts","sourceRoot":"","sources":["../../../../../src/ui/components/OxyOAuthCallback.tsx"],"names":[],"mappings":"AAKA,MAAM,WAAW,qBAAqB;IACpC,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,UAAgB,EAAE,EAAE,qBAAqB,+BAsB3E"}

package/lib/typescript/module/ui/components/OxyPayButton.d.ts

@@ -0,0 +1,29 @@
+import type React from 'react';
+import type { ViewStyle, TextStyle, StyleProp } from 'react-native';
+import type { PaymentItem, PaymentGatewayResult } from '../screens/PaymentGatewayScreen.js';
+export interface OxyPayButtonProps {
+    style?: StyleProp<ViewStyle>;
+    textStyle?: StyleProp<TextStyle>;
+    text?: string;
+    disabled?: boolean;
+    amount: number | string;
+    currency?: string;
+    paymentItems?: PaymentItem[];
+    description?: string;
+    onPaymentResult?: (result: PaymentGatewayResult) => void;
+    /**
+     * Button background color. If not provided, uses variant ('white' or 'black').
+     */
+    color?: string;
+    /**
+     * Button color variant: 'white' (default) or 'black'. Ignored if color is set.
+     */
+    variant?: 'white' | 'black';
+}
+/**
+ * A pre-styled button for OxyPay payments that opens the Payment Gateway
+ * - Only black or white by default, but can be customized with the color prop.
+ */
+declare const OxyPayButton: React.FC<OxyPayButtonProps>;
+export default OxyPayButton;
+//# sourceMappingURL=OxyPayButton.d.ts.map

package/lib/typescript/module/ui/components/OxyPayButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OxyPayButton.d.ts","sourceRoot":"","sources":["../../../../../src/ui/components/OxyPayButton.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAGpE,OAAO,KAAK,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,oCAAiC,CAAC;AAGzF,MAAM,WAAW,iBAAiB;IAC9B,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IAC7B,SAAS,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,WAAW,EAAE,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,IAAI,CAAC;IACzD;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;CAC/B;AAED;;;GAGG;AACH,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CA4B7C,CAAC;AAcF,eAAe,YAAY,CAAC"}