@oxyhq/services 25.0.1 → 26.0.1

package/src/ui/context/hooks/useAuthOperations.ts

@@ -1,5 +1,5 @@
 import { useCallback } from 'react';
-import type { ApiError, AuthStateStore, IdentityBinding, SessionClient, User } from '@oxyhq/core';
+import type { ApiError, AuthStateStore, SessionClient, User } from '@oxyhq/core';
 import type { AuthState } from '../../stores/authStore';
 import type { ClientSession, SessionLoginResponse } from '@oxyhq/core';
 import { DeviceManager } from '@oxyhq/core';
@@ -43,15 +43,6 @@ export interface UseAuthOperationsOptions {
   logoutStore: () => void;
   setAuthState: (state: Partial<AuthState>) => void;
   logger?: (message: string, error?: unknown) => void;
-  /**
-   * Identity-bound session (`sessionMode: 'identity'`). When set, a successful
-   * key sign-in writes the durable `{publicKey, accountId}` pin so pinned
-   * re-mints and projections bind immediately instead of waiting for a second
-   * `establishIdentitySession` round-trip.
-   */
-  identityBinding?: IdentityBinding;
-  /** Refreshes the provider's memoised pinned account id after the pin lands. */
-  refreshPinnedAccountId?: () => Promise<string | null>;
 }
 
 export interface UseAuthOperationsResult {
@@ -106,8 +97,6 @@ export const useAuthOperations = ({
   logoutStore,
   setAuthState,
   logger,
-  identityBinding,
-  refreshPinnedAccountId,
 }: UseAuthOperationsOptions): UseAuthOperationsResult => {
   /**
    * Internal function to perform challenge-response sign in.
@@ -166,18 +155,6 @@ export const useAuthOperations = ({
         }
       }
 
-      if (identityBinding) {
-        try {
-          await identityBinding.pinStore.save({
-            publicKey: publicKey.toLowerCase(),
-            accountId: sessionResponse.user.id,
-          });
-          await refreshPinnedAccountId?.();
-        } catch (pinError) {
-          logger?.('Failed to persist identity pin after sign-in', pinError);
-        }
-      }
-
       // Register this recovered account+session into the server-authoritative
       // device-session set AND make it active: `registerAndActivate()` adds via
       // `POST /session/device/add` (identity derived from the bearer
@@ -260,8 +237,6 @@ export const useAuthOperations = ({
       switchSession,
       syncFromClient,
       updateSessions,
-      identityBinding,
-      refreshPinnedAccountId,
     ],
   );
 

package/src/ui/context/oxyContextTypes.ts

@@ -158,9 +158,10 @@ export interface OxyContextProviderProps {
   authWebUrl?: string;
   authRedirectUri?: string;
   /**
-   * Authorize endpoint override for web "Sign in with Oxy". Defaults to the
-   * production Oxy IdP when unset; a local/staging deployment points it at its
-   * own IdP so sign-in never reaches production `auth.oxy.so`.
+   * Authorize endpoint override for silent cross-origin session restore
+   * (web cross-app SSO). Defaults to the production Oxy IdP when unset; a
+   * local/staging deployment points it at its own IdP so cold boot never
+   * bounces the tab to production `auth.oxy.so`.
    */
   authorizeBaseUrl?: string;
   storageKeyPrefix?: string;
@@ -173,31 +174,11 @@ export interface OxyContextProviderProps {
   sessionMode?: SessionMode;
   /**
    * Transport for WEB third-party sign-in. See `OxyProviderProps.webAuthMode`.
-   * @default 'popup'
+   * @default 'redirect'
    */
   webAuthMode?: WebAuthMode;
-  /**
-   * Let NATIVE background code (a home-screen widget's WorkManager worker, a sync
-   * job) authenticate while the app process is dead and there is no JS runtime.
-   *
-   * With this on, the SDK provisions a purpose-built background credential
-   * whenever the app runs and stores it where `so.oxy.session.OxyBackgroundSession`
-   * can read it; Kotlin then exchanges it for a short access token on demand. The
-   * app writes no session code — this prop is the whole integration.
-   *
-   * OFF by default, because a credential that nobody needs is exposure that
-   * nobody needs. Turn it on only in an app that actually has background code to
-   * authenticate. Android-only today; inert on web and iOS.
-   *
-   * The credential cannot create a session (only the running app can provision
-   * one), cannot rotate or otherwise disturb the app's own device credential, and
-   * is re-authorized server-side on every use so it can never outlive a sign-out.
-   * It does NOT reduce authority: the token it mints is a full user access token,
-   * exactly like the device credential's.
-   *
-   * @default false
-   */
-  backgroundSession?: boolean;
+  /** Sync device credentials to auth.oxy.so after interactive sign-in. @default true */
+  hubSync?: boolean;
   onAuthStateChange?: (user: User | null) => void;
   onError?: (error: ApiError) => void;
 }

package/src/ui/context/useOxyAccountGraph.ts

@@ -22,7 +22,7 @@ interface UseOxyAccountGraphParams {
   oxyServices: OxyServices;
   sessionClient: SessionClient;
   syncFromClient: () => Promise<void>;
-  commitSession: (input: CommitInput, options: { activate: boolean }) => Promise<void>;
+  commitSession: (input: CommitInput, options: { activate: boolean; hubSync?: boolean }) => Promise<void>;
   queryClient: QueryClient;
   accountDialogControllerRef: RefObject<AccountDialogController | null>;
   clearSessionStateRef: RefObject<() => Promise<void>>;
@@ -110,9 +110,9 @@ export function useOxyAccountGraph({
           userId: result.user.id,
           user: result.user,
         },
-        // A switch is IN-PLACE. Cross-tab/app propagation rides the
-        // `session_state` socket.
-        { activate: true },
+        // A switch is IN-PLACE: never run the cross-origin hub-sync full-page
+        // redirect. Cross-tab/app propagation rides the `session_state` socket.
+        { activate: true, hubSync: false },
       );
       await runPostAccountSwitchSideEffects();
     },

package/src/ui/hooks/mutations/mutationFactory.ts

@@ -12,7 +12,7 @@
 import type { QueryClient, UseMutationOptions } from '@tanstack/react-query';
 import type { User } from '@oxyhq/core';
 import { queryKeys, invalidateAccountQueries, invalidateUserQueries } from '../queries/queryKeys';
-import { toast } from '@oxyhq/bloom/toast';
+import { toast } from '@oxyhq/bloom';
 import { useAuthStore } from '../../stores/authStore';
 
 /**

package/src/ui/hooks/mutations/useAccountMutations.ts

@@ -17,7 +17,7 @@ import {
 } from '../queries/queryKeys';
 import { mutationKeys } from './mutationKeys';
 import { useOxy } from '../../context/OxyContext';
-import { toast } from '@oxyhq/bloom/toast';
+import { toast } from '@oxyhq/bloom';
 import { refreshAvatarInStore } from '../../utils/avatarUtils';
 import { useAuthStore } from '../../stores/authStore';
 

package/src/ui/hooks/mutations/useServicesMutations.ts

@@ -3,7 +3,7 @@ import type { ClientSession } from '@oxyhq/core';
 import { queryKeys, invalidateSessionQueries } from '../queries/queryKeys';
 import { mutationKeys } from './mutationKeys';
 import { useOxy } from '../../context/OxyContext';
-import { toast } from '@oxyhq/bloom/toast';
+import { toast } from '@oxyhq/bloom';
 
 /**
  * Switch active session

package/src/ui/hooks/queries/paymentTypes.ts

@@ -7,9 +7,8 @@
  * `useUserWalletTransactions`) expose precise types instead of `any`.
  *
  * Source of truth (API):
- *  - Subscription:  GET /subscription/:userId   -> billing-first normalized
- *                   subscription JSON (Stripe `BillingSubscription` with legacy
- *                   `Subscription` fallback), or `{ plan: 'basic' }` when none.
+ *  - Subscription:  GET /subscription/:userId   -> `Subscription` model JSON,
+ *                   or the fallback `{ plan: 'basic' }` when none exists.
  *  - Payments:      GET /payments/user          -> `Payment[]` (sendSuccess).
  *  - Wallet:        GET /wallet/:userId         -> `Wallet` (sendSuccess).
  *  - Transactions:  GET /wallet/transactions/:userId

package/src/ui/hooks/queries/usePaymentQueries.ts

@@ -30,9 +30,8 @@ import type {
  * Get the current user's subscription.
  *
  * Wraps `oxyServices.getCurrentUserSubscription()`
- * (`GET /subscription/:userId`, billing-first). Returns the persisted
- * subscription or the API's `{ plan: 'basic' }` fallback when the user has
- * never subscribed.
+ * (`GET /subscription/:userId`). Returns the persisted subscription or the
+ * API's `{ plan: 'basic' }` fallback when the user has never subscribed.
  */
 export const useUserSubscription = (options?: { enabled?: boolean }) => {
   const { oxyServices, isAuthenticated, activeSessionId, user } = useOxy();

package/src/ui/hooks/queries/userCache.ts

@@ -39,10 +39,10 @@
  * It is a cache write only — zero network, one `setQueryData` per key.
  */
 
-import type { UserNameResponse } from "@oxyhq/contracts";
-import type { QueryClient } from "@tanstack/react-query";
-import { useAuthStore } from "../../stores/authStore";
-import { queryKeys } from "./queryKeys";
+import type { QueryClient } from '@tanstack/react-query';
+import type { UserNameResponse } from '@oxyhq/contracts';
+import { queryKeys } from './queryKeys';
+import { useAuthStore } from '../../stores/authStore';
 
 /**
  * A user-shaped object that can be upserted into the cache. Intentionally
@@ -53,30 +53,30 @@ import { queryKeys } from "./queryKeys";
  * pass through untouched (so the upsert never has to know the full DTO shape).
  */
 export interface CacheableUser {
-	id?: string;
-	/** Some sources (post/notification actors) carry the id as Mongo `_id`. */
-	_id?: string;
-	username?: string;
-	/**
-	 * Canonical structured name (`UserNameResponse`) OR a plain display string on
-	 * the looser actor objects. Normalized to the object shape on write.
-	 */
-	name?: string | UserNameResponse;
-	/** Avatar file id. `null`/`''` are treated as "no avatar" (never degrade). */
-	avatar?: string | null;
-	/** Social counts. A partial `_count` never replaces a fuller one. */
-	_count?: { followers?: number; following?: number } | null;
-	/**
-	 * Viewer-relative follow relationship. Present ONLY on an authenticated
-	 * single-profile fetch; `null`/absent for anon/self/bulk/feed. Never stripped
-	 * from an existing entry by a source that lacks it.
-	 */
-	relationship?: { isFollowing?: boolean; followsYou?: boolean } | null;
-	[key: string]: unknown;
+  id?: string;
+  /** Some sources (post/notification actors) carry the id as Mongo `_id`. */
+  _id?: string;
+  username?: string;
+  /**
+   * Canonical structured name (`UserNameResponse`) OR a plain display string on
+   * the looser actor objects. Normalized to the object shape on write.
+   */
+  name?: string | UserNameResponse;
+  /** Avatar file id. `null`/`''` are treated as "no avatar" (never degrade). */
+  avatar?: string | null;
+  /** Social counts. A partial `_count` never replaces a fuller one. */
+  _count?: { followers?: number; following?: number } | null;
+  /**
+   * Viewer-relative follow relationship. Present ONLY on an authenticated
+   * single-profile fetch; `null`/absent for anon/self/bulk/feed. Never stripped
+   * from an existing entry by a source that lacks it.
+   */
+  relationship?: { isFollowing?: boolean; followsYou?: boolean } | null;
+  [key: string]: unknown;
 }
 
 /** The degraded display-name sentinel (ghost-author rule). */
-const DEGRADED_DISPLAY_NAME = "Unknown user";
+const DEGRADED_DISPLAY_NAME = 'Unknown user';
 
 /** A cache entry always carries a resolved string `id`. */
 type CachedUser = CacheableUser & { id: string; name?: UserNameResponse };
@@ -88,34 +88,28 @@ type CachedUser = CacheableUser & { id: string; name?: UserNameResponse };
  * meaningful (a real `verified: false` or `_count.followers: 0`).
  */
 function isMeaningful(value: unknown): boolean {
-	if (value === undefined || value === null) return false;
-	if (typeof value === "string") return value.trim() !== "";
-	return true;
+  if (value === undefined || value === null) return false;
+  if (typeof value === 'string') return value.trim() !== '';
+  return true;
 }
 
 /** A display name is meaningful only when non-empty AND not the degraded sentinel. */
 function isMeaningfulDisplayName(value: unknown): value is string {
-	return (
-		typeof value === "string" &&
-		value.trim() !== "" &&
-		value !== DEGRADED_DISPLAY_NAME
-	);
+  return typeof value === 'string' && value.trim() !== '' && value !== DEGRADED_DISPLAY_NAME;
 }
 
 function isPlainObject(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
 /** Normalize the polymorphic `name` (string | object | nullish) to the canonical object shape. */
-function normalizeName(
-	name: CacheableUser["name"],
-): UserNameResponse | undefined {
-	if (name === undefined || name === null) return undefined;
-	if (typeof name === "string") {
-		const trimmed = name.trim();
-		return trimmed ? { displayName: trimmed } : undefined;
-	}
-	return name;
+function normalizeName(name: CacheableUser['name']): UserNameResponse | undefined {
+  if (name === undefined || name === null) return undefined;
+  if (typeof name === 'string') {
+    const trimmed = name.trim();
+    return trimmed ? { displayName: trimmed } : undefined;
+  }
+  return name;
 }
 
 /**
@@ -125,12 +119,12 @@ function normalizeName(
  * object so the cache never holds a bare-string name).
  */
 function toCachedUser(user: CacheableUser, fallbackId: string): CachedUser {
-	const { name: rawName, ...rest } = user;
-	const id = String(user.id ?? user._id ?? fallbackId);
-	const name = normalizeName(rawName);
-	const normalized: CachedUser = { ...rest, id };
-	if (name !== undefined) normalized.name = name;
-	return normalized;
+  const { name: rawName, ...rest } = user;
+  const id = String(user.id ?? user._id ?? fallbackId);
+  const name = normalizeName(rawName);
+  const normalized: CachedUser = { ...rest, id };
+  if (name !== undefined) normalized.name = name;
+  return normalized;
 }
 
 /**
@@ -138,43 +132,39 @@ function toCachedUser(user: CacheableUser, fallbackId: string): CachedUser {
  * when no id can be resolved (nothing to key on).
  */
 function normalizeIncoming(user: CacheableUser): CachedUser | null {
-	const cached = toCachedUser(user, "");
-	return cached.id ? cached : null;
+  const cached = toCachedUser(user, '');
+  return cached.id ? cached : null;
 }
 
 /** Merge two `name` objects field-by-field, with anti-degradation on `displayName`. */
 function mergeName(
-	existing: UserNameResponse | undefined,
-	incoming: UserNameResponse | undefined,
+  existing: UserNameResponse | undefined,
+  incoming: UserNameResponse | undefined,
 ): UserNameResponse | undefined {
-	if (incoming === undefined) return existing;
-	if (existing === undefined) return incoming;
-	const merged: UserNameResponse = { ...existing };
-	for (const [key, value] of Object.entries(incoming)) {
-		if (key === "displayName") continue;
-		if (isMeaningful(value)) merged[key] = value;
-	}
-	// Never let an empty / `'Unknown user'` displayName overwrite a real one.
-	if (isMeaningfulDisplayName(incoming.displayName)) {
-		merged.displayName = incoming.displayName;
-	}
-	return merged;
+  if (incoming === undefined) return existing;
+  if (existing === undefined) return incoming;
+  const merged: UserNameResponse = { ...existing };
+  for (const [key, value] of Object.entries(incoming)) {
+    if (key === 'displayName') continue;
+    if (isMeaningful(value)) merged[key] = value;
+  }
+  // Never let an empty / `'Unknown user'` displayName overwrite a real one.
+  if (isMeaningfulDisplayName(incoming.displayName)) {
+    merged.displayName = incoming.displayName;
+  }
+  return merged;
 }
 
 /** Merge `_count` field-by-field so a partial count never replaces a fuller one. */
 function mergeCount(
-	existing: CacheableUser["_count"],
-	incoming: CacheableUser["_count"],
-): CacheableUser["_count"] {
-	if (!isPlainObject(incoming)) return existing;
-	const merged: { followers?: number; following?: number } = {
-		...(isPlainObject(existing) ? existing : {}),
-	};
-	if (typeof incoming.followers === "number")
-		merged.followers = incoming.followers;
-	if (typeof incoming.following === "number")
-		merged.following = incoming.following;
-	return merged;
+  existing: CacheableUser['_count'],
+  incoming: CacheableUser['_count'],
+): CacheableUser['_count'] {
+  if (!isPlainObject(incoming)) return existing;
+  const merged: { followers?: number; following?: number } = { ...(isPlainObject(existing) ? existing : {}) };
+  if (typeof incoming.followers === 'number') merged.followers = incoming.followers;
+  if (typeof incoming.following === 'number') merged.following = incoming.following;
+  return merged;
 }
 
 /**
@@ -182,18 +172,16 @@ function mergeCount(
  * or an anon/self/bulk `null`) must NEVER strip an existing viewer relationship.
  */
 function mergeRelationship(
-	existing: CacheableUser["relationship"],
-	incoming: CacheableUser["relationship"],
-): CacheableUser["relationship"] {
-	if (!isPlainObject(incoming)) return existing;
-	const merged: { isFollowing?: boolean; followsYou?: boolean } = {
-		...(isPlainObject(existing) ? existing : {}),
-	};
-	if (typeof incoming.isFollowing === "boolean")
-		merged.isFollowing = incoming.isFollowing;
-	if (typeof incoming.followsYou === "boolean")
-		merged.followsYou = incoming.followsYou;
-	return merged;
+  existing: CacheableUser['relationship'],
+  incoming: CacheableUser['relationship'],
+): CacheableUser['relationship'] {
+  if (!isPlainObject(incoming)) return existing;
+  const merged: { isFollowing?: boolean; followsYou?: boolean } = {
+    ...(isPlainObject(existing) ? existing : {}),
+  };
+  if (typeof incoming.isFollowing === 'boolean') merged.isFollowing = incoming.isFollowing;
+  if (typeof incoming.followsYou === 'boolean') merged.followsYou = incoming.followsYou;
+  return merged;
 }
 
 /**
@@ -205,63 +193,54 @@ function mergeRelationship(
  * only the by-username key carries it (`useUserByUsername`).
  */
 function mergeUsers(
-	existing: CachedUser,
-	incoming: CachedUser,
-	options?: { includeRelationship?: boolean },
+  existing: CachedUser,
+  incoming: CachedUser,
+  options?: { includeRelationship?: boolean },
 ): CachedUser {
-	const includeRelationship = options?.includeRelationship ?? true;
-	const merged: CachedUser = { ...existing };
-	for (const [key, value] of Object.entries(incoming)) {
-		if (key === "name" || key === "_count" || key === "relationship") continue;
-		if (key === "id") {
-			merged.id = incoming.id;
-			continue;
-		}
-		if (isMeaningful(value)) merged[key] = value;
-	}
-	const name = mergeName(existing.name, incoming.name);
-	if (name !== undefined) merged.name = name;
-	const count = mergeCount(existing._count, incoming._count);
-	if (count !== undefined) merged._count = count;
-	if (includeRelationship) {
-		const relationship = mergeRelationship(
-			existing.relationship,
-			incoming.relationship,
-		);
-		if (relationship !== undefined) merged.relationship = relationship;
-	} else {
-		merged.relationship = undefined;
-	}
-	return merged;
+  const includeRelationship = options?.includeRelationship ?? true;
+  const merged: CachedUser = { ...existing };
+  for (const [key, value] of Object.entries(incoming)) {
+    if (key === 'name' || key === '_count' || key === 'relationship') continue;
+    if (key === 'id') {
+      merged.id = incoming.id;
+      continue;
+    }
+    if (isMeaningful(value)) merged[key] = value;
+  }
+  const name = mergeName(existing.name, incoming.name);
+  if (name !== undefined) merged.name = name;
+  const count = mergeCount(existing._count, incoming._count);
+  if (count !== undefined) merged._count = count;
+  if (includeRelationship) {
+    const relationship = mergeRelationship(existing.relationship, incoming.relationship);
+    if (relationship !== undefined) merged.relationship = relationship;
+  } else {
+    delete merged.relationship;
+  }
+  return merged;
 }
 
 /** Merge-upsert a normalized user into one cache key (see module docs for semantics). */
 function upsertOneKey(
-	queryClient: QueryClient,
-	key: readonly unknown[],
-	incoming: CachedUser,
-	options: { includeRelationship: boolean },
+  queryClient: QueryClient,
+  key: readonly unknown[],
+  incoming: CachedUser,
+  options: { includeRelationship: boolean },
 ): void {
-	const mergeOpts = { includeRelationship: options.includeRelationship };
-	const existing = queryClient.getQueryData<CacheableUser>(key);
-	if (existing === undefined) {
-		// Cold slot: seed the full incoming object, STALE, so react-query refetches
-		// the full authoritative profile (relationship, counts, createdAt, …).
-		const seeded = mergeUsers({ id: incoming.id }, incoming, mergeOpts);
-		queryClient.setQueryData<CachedUser>(key, seeded, { updatedAt: 0 });
-		return;
-	}
-	// Existing entry: merge and leave its freshness lifecycle untouched. The
-	// existing entry is keyed by `incoming.id`, so use it as the fallback id.
-	const merged = mergeUsers(
-		toCachedUser(existing, incoming.id),
-		incoming,
-		mergeOpts,
-	);
-	const dataUpdatedAt = queryClient.getQueryState(key)?.dataUpdatedAt ?? 0;
-	queryClient.setQueryData<CachedUser>(key, merged, {
-		updatedAt: dataUpdatedAt,
-	});
+  const mergeOpts = { includeRelationship: options.includeRelationship };
+  const existing = queryClient.getQueryData<CacheableUser>(key);
+  if (existing === undefined) {
+    // Cold slot: seed the full incoming object, STALE, so react-query refetches
+    // the full authoritative profile (relationship, counts, createdAt, …).
+    const seeded = mergeUsers({ id: incoming.id }, incoming, mergeOpts);
+    queryClient.setQueryData<CachedUser>(key, seeded, { updatedAt: 0 });
+    return;
+  }
+  // Existing entry: merge and leave its freshness lifecycle untouched. The
+  // existing entry is keyed by `incoming.id`, so use it as the fallback id.
+  const merged = mergeUsers(toCachedUser(existing, incoming.id), incoming, mergeOpts);
+  const dataUpdatedAt = queryClient.getQueryState(key)?.dataUpdatedAt ?? 0;
+  queryClient.setQueryData<CachedUser>(key, merged, { updatedAt: dataUpdatedAt });
 }
 
 /**
@@ -272,7 +251,7 @@ function upsertOneKey(
  * empty string is honoured (anonymous scope).
  */
 function resolveViewerId(viewerId?: string): string {
-	return viewerId ?? useAuthStore.getState().user?.id ?? "";
+  return viewerId ?? useAuthStore.getState().user?.id ?? '';
 }
 
 /**
@@ -286,29 +265,29 @@ function resolveViewerId(viewerId?: string): string {
  *                    the current auth-store user id.
  */
 export function upsertCachedUser(
-	queryClient: QueryClient,
-	user: CacheableUser,
-	viewerId?: string,
+  queryClient: QueryClient,
+  user: CacheableUser,
+  viewerId?: string,
 ): void {
-	const incoming = normalizeIncoming(user);
-	if (!incoming) return;
+  const incoming = normalizeIncoming(user);
+  if (!incoming) return;
 
-	// By-id identity entry (read by `useUserById`). Not viewer-scoped — never store
-	// the viewer-relative `relationship` here or one viewer's follow state leaks
-	// into every other viewer's by-id cache entry.
-	upsertOneKey(queryClient, queryKeys.users.detail(incoming.id), incoming, {
-		includeRelationship: false,
-	});
+  // By-id identity entry (read by `useUserById`). Not viewer-scoped — never store
+  // the viewer-relative `relationship` here or one viewer's follow state leaks
+  // into every other viewer's by-id cache entry.
+  upsertOneKey(queryClient, queryKeys.users.detail(incoming.id), incoming, {
+    includeRelationship: false,
+  });
 
-	const username = incoming.username;
-	if (typeof username === "string" && username.trim() !== "") {
-		// By-username entry (read by `useUserByUsername`). Viewer-scoped because the
-		// authenticated single-profile fetch embeds the viewer `relationship`. Build
-		// the key through the SAME helper the hook uses so username normalization
-		// (`trim().toLowerCase()`) matches byte-for-byte.
-		const key = queryKeys.users.byUsername(username, resolveViewerId(viewerId));
-		upsertOneKey(queryClient, key, incoming, { includeRelationship: true });
-	}
+  const username = incoming.username;
+  if (typeof username === 'string' && username.trim() !== '') {
+    // By-username entry (read by `useUserByUsername`). Viewer-scoped because the
+    // authenticated single-profile fetch embeds the viewer `relationship`. Build
+    // the key through the SAME helper the hook uses so username normalization
+    // (`trim().toLowerCase()`) matches byte-for-byte.
+    const key = queryKeys.users.byUsername(username, resolveViewerId(viewerId));
+    upsertOneKey(queryClient, key, incoming, { includeRelationship: true });
+  }
 }
 
 /**
@@ -317,13 +296,13 @@ export function upsertCachedUser(
  * appears twice merges both slices into the single cache entry.
  */
 export function upsertCachedUsers(
-	queryClient: QueryClient,
-	users: readonly CacheableUser[] | null | undefined,
-	viewerId?: string,
+  queryClient: QueryClient,
+  users: readonly CacheableUser[] | null | undefined,
+  viewerId?: string,
 ): void {
-	if (!Array.isArray(users) || users.length === 0) return;
-	const resolvedViewerId = resolveViewerId(viewerId);
-	for (const user of users) {
-		if (user) upsertCachedUser(queryClient, user, resolvedViewerId);
-	}
+  if (!Array.isArray(users) || users.length === 0) return;
+  const resolvedViewerId = resolveViewerId(viewerId);
+  for (const user of users) {
+    if (user) upsertCachedUser(queryClient, user, resolvedViewerId);
+  }
 }

package/src/ui/hooks/useAssets.ts

@@ -48,7 +48,7 @@ export const useAssets = () => {
   // Upload asset with progress tracking
   const upload = useCallback(async (
     file: File, 
-    metadata?: Record<string, unknown>
+    metadata?: Record<string, any>
   ): Promise<Asset | null> => {
     if (!oxyInstance) {
       throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');

package/src/ui/hooks/useAsyncAction.ts

@@ -1,5 +1,5 @@
 import { useState, useCallback } from 'react';
-import { toast } from '@oxyhq/bloom/toast';
+import { toast } from '@oxyhq/bloom';
 
 interface UseAsyncActionOptions<T> {
     /** Function to execute */
@@ -7,11 +7,11 @@ interface UseAsyncActionOptions<T> {
     /** Success message to display */
     successMessage?: string;
     /** Error message to display (or function to get message from error) */
-    errorMessage?: string | ((error: unknown) => string);
+    errorMessage?: string | ((error: any) => string);
     /** Callback on success */
     onSuccess?: (result: T) => void;
     /** Callback on error */
-    onError?: (error: unknown) => void;
+    onError?: (error: any) => void;
     /** Show loading toast */
     showLoadingToast?: boolean;
     /** Loading message */

package/src/ui/hooks/useAuth.ts

@@ -17,10 +17,8 @@
  * }
  * ```
  *
- * Session restore (zero cookies):
- * - Web: this origin's own persisted `{deviceId, deviceSecret}` — a signed-out
- *   origin stays signed out until the user presses "Continue with Oxy". There is
- *   no cross-origin silent SSO: the SDK never navigates the tab on its own.
+ * Cross-domain session (zero cookies):
+ * - Web: silent OAuth (`prompt=none`) on cold boot; hub-ticket sync to auth.oxy.so after sign-in
  * - Native: shared Keychain / app-group identity (Commons)
  * - Realtime sync: Socket.IO `session_state` on `device:<deviceId>` once authenticated
  * - Manual sign-in: signIn() opens the in-app account dialog (web + native)