@oxyhq/services 22.4.2 → 22.6.0

package/src/ui/components/fileManagement/styles.ts

@@ -382,43 +382,6 @@ export const fileManagementStyles = StyleSheet.create({
         flex: 1,
         padding: 16,
     },
-    fileDetailCard: {
-        padding: 18,
-        borderRadius: 14,
-        borderWidth: 1,
-        alignItems: 'center',
-    },
-    fileDetailIcon: {
-        marginBottom: 16,
-    },
-    fileDetailName: {
-        fontSize: 20,
-        fontWeight: 'bold',
-        textAlign: 'center',
-        marginBottom: 24,
-    },
-    fileDetailInfo: {
-        width: '100%',
-        marginBottom: 32,
-    },
-    detailRow: {
-        flexDirection: 'row',
-        justifyContent: 'space-between',
-        alignItems: 'flex-start',
-        marginBottom: 12,
-        flexWrap: 'wrap',
-    },
-    detailLabel: {
-        fontSize: 16,
-        fontWeight: '500',
-        flex: 1,
-        minWidth: 100,
-    },
-    detailValue: {
-        fontSize: 16,
-        flex: 2,
-        textAlign: 'right',
-    },
     modalActions: {
         flexDirection: 'row',
         gap: 12,
@@ -858,191 +821,3 @@ export const fileManagementStyles = StyleSheet.create({
         borderRadius: 8,
     },
 });
-
-/**
- * Styles for the dedicated photo picker view used when `selectMode + image-only`
- * is active (e.g. the avatar picker context). This view is intentionally
- * flagship-grade: black backdrop, translucent header, edge-to-edge grid.
- *
- * Kept in a separate StyleSheet so the rest of `fileManagementStyles` does not
- * carry a black-background bias when used elsewhere.
- */
-export const photoPickerStyles = StyleSheet.create({
-    root: {
-        flex: 1,
-        backgroundColor: '#000000',
-    },
-    headerSpacer: {
-        // Reserved for the absolute header so content does not sit underneath it.
-        backgroundColor: '#000000',
-    },
-    header: {
-        position: 'absolute',
-        top: 0,
-        left: 0,
-        right: 0,
-        backgroundColor: 'rgba(0,0,0,0.92)',
-        flexDirection: 'row',
-        alignItems: 'center',
-        justifyContent: 'space-between',
-        paddingHorizontal: 12,
-        zIndex: 30,
-    },
-    headerRow: {
-        flexDirection: 'row',
-        alignItems: 'center',
-        justifyContent: 'space-between',
-        width: '100%',
-        // Material 3 top app bar height — leaves a generous tap target for
-        // the Cancel / Upload pills without crowding the title.
-        height: 56,
-    },
-    headerSide: {
-        flexBasis: 0,
-        flexGrow: 1,
-        flexDirection: 'row',
-        alignItems: 'center',
-    },
-    headerSideRight: {
-        justifyContent: 'flex-end',
-    },
-    headerSideLeft: {
-        justifyContent: 'flex-start',
-    },
-    headerTitle: {
-        fontSize: 17,
-        fontWeight: '600',
-        color: '#FFFFFF',
-        letterSpacing: -0.2,
-        textAlign: 'center',
-    },
-    headerCancel: {
-        paddingHorizontal: 6,
-        paddingVertical: 8,
-        minHeight: 36,
-        minWidth: 44,
-        justifyContent: 'center',
-    },
-    headerCancelText: {
-        fontSize: 17,
-        fontWeight: '500',
-        color: '#FFFFFF',
-    },
-    headerPrimaryPill: {
-        flexDirection: 'row',
-        alignItems: 'center',
-        gap: 6,
-        paddingHorizontal: 14,
-        paddingVertical: 8,
-        borderRadius: 999,
-        minHeight: 36,
-    },
-    headerPrimaryPillIconOnly: {
-        paddingHorizontal: 8,
-        width: 36,
-        justifyContent: 'center',
-    },
-    headerPrimaryText: {
-        color: '#FFFFFF',
-        fontSize: 15,
-        fontWeight: '600',
-    },
-    headerProgressBarTrack: {
-        position: 'absolute',
-        left: 0,
-        right: 0,
-        bottom: 0,
-        height: 2,
-        backgroundColor: 'rgba(255,255,255,0.12)',
-    },
-    headerProgressBarFill: {
-        height: '100%',
-    },
-    grid: {
-        flex: 1,
-    },
-    gridContent: {
-        // Top inset is set dynamically (header height + safe area).
-        paddingBottom: 24,
-    },
-    cellWrapper: {
-        position: 'relative',
-        // width/height set dynamically per device
-    },
-    cellInner: {
-        flex: 1,
-        borderRadius: 8,
-        overflow: 'hidden',
-        backgroundColor: '#111111',
-    },
-    cellImage: {
-        width: '100%',
-        height: '100%',
-    },
-    cellRing: {
-        position: 'absolute',
-        top: 0,
-        left: 0,
-        right: 0,
-        bottom: 0,
-        borderRadius: 8,
-        borderWidth: 3,
-    },
-    cellDim: {
-        opacity: 0.6,
-    },
-    cellBadge: {
-        position: 'absolute',
-        top: 6,
-        right: 6,
-        minWidth: 22,
-        height: 22,
-        paddingHorizontal: 6,
-        borderRadius: 11,
-        alignItems: 'center',
-        justifyContent: 'center',
-    },
-    cellBadgeText: {
-        color: '#FFFFFF',
-        fontSize: 12,
-        fontWeight: '700',
-        lineHeight: 14,
-    },
-    empty: {
-        flex: 1,
-        alignItems: 'center',
-        justifyContent: 'center',
-        paddingHorizontal: 32,
-    },
-    emptyIconWrap: {
-        opacity: 0.3,
-        marginBottom: 16,
-    },
-    emptyTitle: {
-        fontSize: 17,
-        fontWeight: '600',
-        textAlign: 'center',
-        marginBottom: 6,
-    },
-    emptySubtitle: {
-        fontSize: 14,
-        fontWeight: '400',
-        textAlign: 'center',
-        opacity: 0.7,
-        marginBottom: 24,
-    },
-    emptyCta: {
-        flexDirection: 'row',
-        alignItems: 'center',
-        gap: 8,
-        paddingHorizontal: 22,
-        paddingVertical: 12,
-        borderRadius: 999,
-    },
-    emptyCtaText: {
-        color: '#FFFFFF',
-        fontSize: 15,
-        fontWeight: '600',
-    },
-});
-

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

@@ -170,8 +170,11 @@ export const useAuthOperations = ({
         logger?.('Failed to register sign-in into device session set', registrationError);
       }
 
-      // Get full user data
-      fullUser = await oxyServices.getUserBySession(sessionResponse.sessionId);
+      // Hydrate the full user from the bearer (`GET /users/me`) — `verifyChallenge`
+      // has already planted the access token for this session, so the bearer IS
+      // the session identity. Avoids a second, session-id-keyed source of truth
+      // (`GET /session/user/:sessionId`) that can disagree with the bearer.
+      fullUser = await oxyServices.getCurrentUser();
 
       // Fetch device sessions
       let allDeviceSessions: ClientSession[] = [];

package/src/ui/context/useOxyAccountGraph.ts

@@ -5,6 +5,7 @@ import { logger as loggerUtil } from '@oxyhq/core';
 import { useAuthStore } from '../stores/authStore';
 import { isUnauthorizedStatus } from './oxyContextHelpers';
 import { resetSessionScopedStores } from '../stores/resetSessionScopedStores';
+import { ASSET_DOWNLOAD_URLS_QUERY_KEY } from '../hooks/useResolvedFileUrls';
 import type { CommitInput } from './oxyContextTypes';
 
 interface UseOxyAccountGraphParams {
@@ -63,6 +64,10 @@ export function useOxyAccountGraph({
 
   const runPostAccountSwitchSideEffects = useCallback(async (): Promise<void> => {
     resetSessionScopedStores();
+    // Scoped media tokens are per-viewer — drop any cached URLs immediately so
+    // `keepPreviousData`-style placeholders cannot flash the prior account's
+    // private thumbnails while the new bearer mint lands.
+    queryClient.removeQueries({ queryKey: [ASSET_DOWNLOAD_URLS_QUERY_KEY] });
     await refreshAccounts();
     queryClient.invalidateQueries();
   }, [refreshAccounts, queryClient]);

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

@@ -0,0 +1,361 @@
+/**
+ * userCache — canonical merge-upsert into the SDK user query cache.
+ *
+ * Covers the merge semantics that eliminate the "sparse source strips a field an
+ * authoritative fetch stored" class of bug:
+ *  - cold slot seeds the full object STALE (so react-query refetches)
+ *  - a sparse user merged over a full entry KEEPS relationship / createdAt / etc.
+ *  - null / empty / undefined incoming fields never strip or degrade
+ *  - nested name / _count / relationship merge field-by-field
+ *  - anti-degradation (empty username, 'Unknown user', null avatar)
+ *  - both cache keys written; by-username is viewer-scoped and case-insensitive
+ *  - batch upsert; viewer id defaults from the auth store
+ */
+
+import { QueryClient } from '@tanstack/react-query';
+import { upsertCachedUser, upsertCachedUsers } from '../userCache';
+import type { CacheableUser } from '../userCache';
+import { queryKeys } from '../queryKeys';
+import { useAuthStore } from '../../../stores/authStore';
+
+function makeClient(): QueryClient {
+  return new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  });
+}
+
+/** Read the by-id cache entry. */
+function readById(qc: QueryClient, id: string): CacheableUser | undefined {
+  return qc.getQueryData<CacheableUser>(queryKeys.users.detail(id));
+}
+
+/** Read the viewer-scoped by-username cache entry. */
+function readByUsername(qc: QueryClient, username: string, viewerId: string): CacheableUser | undefined {
+  return qc.getQueryData<CacheableUser>(queryKeys.users.byUsername(username, viewerId));
+}
+
+beforeEach(() => {
+  // Default to anonymous viewer unless a test sets one.
+  useAuthStore.setState({ user: null });
+});
+
+describe('upsertCachedUser — cold slot', () => {
+  it('seeds the full object and marks it STALE (updatedAt: 0) under both keys', () => {
+    const qc = makeClient();
+    const user: CacheableUser = {
+      id: 'u1',
+      username: 'Alice',
+      name: { displayName: 'Alice A' },
+      avatar: 'file_a',
+      createdAt: '2020-01-01T00:00:00Z',
+      _count: { followers: 10, following: 5 },
+      relationship: { isFollowing: true, followsYou: false },
+    };
+
+    upsertCachedUser(qc, user, 'viewer-1');
+
+    // by-id
+    expect(readById(qc, 'u1')).toMatchObject({ id: 'u1', username: 'Alice', avatar: 'file_a' });
+    expect(qc.getQueryState(queryKeys.users.detail('u1'))?.dataUpdatedAt).toBe(0);
+
+    // by-username (viewer-scoped, normalized to lowercase)
+    const uname = readByUsername(qc, 'alice', 'viewer-1');
+    expect(uname).toMatchObject({ id: 'u1', relationship: { isFollowing: true } });
+    expect(qc.getQueryState(queryKeys.users.byUsername('alice', 'viewer-1'))?.dataUpdatedAt).toBe(0);
+  });
+
+  it('resolves the id from _id when id is absent', () => {
+    const qc = makeClient();
+    upsertCachedUser(qc, { _id: 'mongo1', username: 'bob' }, '');
+    expect(readById(qc, 'mongo1')).toMatchObject({ id: 'mongo1', username: 'bob' });
+  });
+
+  it('is a no-op when no id can be resolved', () => {
+    const qc = makeClient();
+    upsertCachedUser(qc, { username: 'ghost' }, '');
+    expect(qc.getQueryCache().getAll()).toHaveLength(0);
+  });
+
+  it('normalizes a plain-string name into { displayName }', () => {
+    const qc = makeClient();
+    upsertCachedUser(qc, { id: 'u1', username: 'alice', name: 'Alice Display' }, '');
+    expect(readById(qc, 'u1')?.name).toEqual({ displayName: 'Alice Display' });
+  });
+});
+
+describe('upsertCachedUser — merge over an existing full entry', () => {
+  const full: CacheableUser = {
+    id: 'u1',
+    username: 'alice',
+    name: { displayName: 'Alice A', first: 'Alice' },
+    avatar: 'file_a',
+    verified: true,
+    badges: ['og'],
+    createdAt: '2020-01-01T00:00:00Z',
+    _count: { followers: 10, following: 5 },
+    relationship: { isFollowing: true, followsYou: true },
+  };
+
+  function seedFull(qc: QueryClient): void {
+    // Represents an authoritative single-profile fetch already in cache (fresh).
+    qc.setQueryData(queryKeys.users.detail('u1'), full);
+    qc.setQueryData(queryKeys.users.byUsername('alice', 'viewer-1'), full);
+  }
+
+  it('keeps relationship + createdAt + _count when a SPARSE feed user is upserted', () => {
+    const qc = makeClient();
+    seedFull(qc);
+
+    // A feed author: no relationship, no createdAt, no counts.
+    upsertCachedUser(qc, { id: 'u1', username: 'alice', name: { displayName: 'Alice A' }, avatar: 'file_a' }, 'viewer-1');
+
+    const byId = readById(qc, 'u1');
+    expect(byId?.createdAt).toBe('2020-01-01T00:00:00Z');
+    expect(byId?._count).toEqual({ followers: 10, following: 5 });
+    expect(byId?.verified).toBe(true);
+
+    const byName = readByUsername(qc, 'alice', 'viewer-1');
+    expect(byName?.relationship).toEqual({ isFollowing: true, followsYou: true });
+    expect(byName?.createdAt).toBe('2020-01-01T00:00:00Z');
+  });
+
+  it('does NOT mark an existing entry stale', () => {
+    const qc = makeClient();
+    seedFull(qc);
+    const before = qc.getQueryState(queryKeys.users.detail('u1'))?.dataUpdatedAt;
+    expect(before).not.toBe(0);
+
+    upsertCachedUser(qc, { id: 'u1', username: 'alice' }, 'viewer-1');
+
+    const after = qc.getQueryState(queryKeys.users.detail('u1'))?.dataUpdatedAt;
+    expect(after).toBe(before); // freshness preserved, not reset to 0
+  });
+
+  it('null / empty / undefined incoming fields never strip an existing field', () => {
+    const qc = makeClient();
+    seedFull(qc);
+
+    upsertCachedUser(
+      qc,
+      { id: 'u1', username: '', avatar: null, createdAt: '', _count: undefined, relationship: null },
+      'viewer-1',
+    );
+
+    const byId = readById(qc, 'u1');
+    expect(byId?.username).toBe('alice');
+    expect(byId?.avatar).toBe('file_a');
+    expect(byId?.createdAt).toBe('2020-01-01T00:00:00Z');
+    expect(byId?._count).toEqual({ followers: 10, following: 5 });
+
+    const byName = readByUsername(qc, 'alice', 'viewer-1');
+    expect(byName?.relationship).toEqual({ isFollowing: true, followsYou: true });
+  });
+
+  it('updates the fields the incoming user DOES carry', () => {
+    const qc = makeClient();
+    seedFull(qc);
+
+    upsertCachedUser(qc, { id: 'u1', username: 'alice', bio: 'new bio', avatar: 'file_new' }, 'viewer-1');
+
+    const byId = readById(qc, 'u1');
+    expect(byId?.bio).toBe('new bio');
+    expect(byId?.avatar).toBe('file_new');
+    // untouched fields survive
+    expect(byId?.createdAt).toBe('2020-01-01T00:00:00Z');
+  });
+
+  it('a defined boolean/number (verified:false, _count.followers:0) DOES override', () => {
+    const qc = makeClient();
+    seedFull(qc);
+
+    upsertCachedUser(qc, { id: 'u1', username: 'alice', verified: false, _count: { followers: 0 } }, 'viewer-1');
+
+    const byId = readById(qc, 'u1');
+    expect(byId?.verified).toBe(false);
+    // partial _count overrides only followers; following kept from existing
+    expect(byId?._count).toEqual({ followers: 0, following: 5 });
+  });
+});
+
+describe('upsertCachedUser — nested merge', () => {
+  it('a partial name never replaces a fuller name; displayName upgrades', () => {
+    const qc = makeClient();
+    qc.setQueryData(queryKeys.users.detail('u1'), {
+      id: 'u1',
+      username: 'alice',
+      name: { first: 'Alice', last: 'Adams', displayName: 'Alice A' },
+    });
+
+    upsertCachedUser(qc, { id: 'u1', username: 'alice', name: { displayName: 'Alice Adams' } }, '');
+
+    expect(readById(qc, 'u1')?.name).toEqual({
+      first: 'Alice',
+      last: 'Adams',
+      displayName: 'Alice Adams',
+    });
+  });
+
+  it('a partial relationship never nulls out the other field', () => {
+    const qc = makeClient();
+    qc.setQueryData(queryKeys.users.byUsername('alice', 'v1'), {
+      id: 'u1',
+      username: 'alice',
+      relationship: { isFollowing: true, followsYou: true },
+    });
+
+    upsertCachedUser(qc, { id: 'u1', username: 'alice', relationship: { followsYou: false } }, 'v1');
+
+    expect(readByUsername(qc, 'alice', 'v1')?.relationship).toEqual({ isFollowing: true, followsYou: false });
+  });
+});
+
+describe('upsertCachedUser — anti-degradation', () => {
+  it('never overwrites a good displayName with the "Unknown user" sentinel', () => {
+    const qc = makeClient();
+    qc.setQueryData(queryKeys.users.detail('u1'), { id: 'u1', username: 'alice', name: { displayName: 'Alice A' } });
+
+    upsertCachedUser(qc, { id: 'u1', username: 'alice', name: { displayName: 'Unknown user' } }, '');
+
+    expect(readById(qc, 'u1')?.name).toEqual({ displayName: 'Alice A' });
+  });
+
+  it('never overwrites a good username with an empty one', () => {
+    const qc = makeClient();
+    qc.setQueryData(queryKeys.users.detail('u1'), { id: 'u1', username: 'alice' });
+
+    upsertCachedUser(qc, { id: 'u1', username: '   ' }, '');
+
+    expect(readById(qc, 'u1')?.username).toBe('alice');
+  });
+
+  it('never nulls out a good avatar', () => {
+    const qc = makeClient();
+    qc.setQueryData(queryKeys.users.detail('u1'), { id: 'u1', username: 'alice', avatar: 'file_a' });
+
+    upsertCachedUser(qc, { id: 'u1', username: 'alice', avatar: null }, '');
+
+    expect(readById(qc, 'u1')?.avatar).toBe('file_a');
+  });
+
+  it('upgrades a degraded existing displayName when a real one arrives', () => {
+    const qc = makeClient();
+    qc.setQueryData(queryKeys.users.detail('u1'), { id: 'u1', username: 'alice', name: { displayName: 'Unknown user' } });
+
+    upsertCachedUser(qc, { id: 'u1', username: 'alice', name: { displayName: 'Alice A' } }, '');
+
+    expect(readById(qc, 'u1')?.name).toEqual({ displayName: 'Alice A' });
+  });
+});
+
+describe('upsertCachedUser — keys & viewer scoping', () => {
+  it('writes ONLY the by-id key when no username is present', () => {
+    const qc = makeClient();
+    upsertCachedUser(qc, { id: 'u1' }, 'v1');
+    expect(readById(qc, 'u1')).toBeDefined();
+    // no username-derived entries
+    const usernameEntries = qc
+      .getQueryCache()
+      .getAll()
+      .filter((q) => (q.queryKey as unknown[]).includes('username'));
+    expect(usernameEntries).toHaveLength(0);
+  });
+
+  it('viewer-scopes the by-username key (different viewers -> different entries)', () => {
+    const qc = makeClient();
+    upsertCachedUser(qc, { id: 'u1', username: 'alice', relationship: { isFollowing: true, followsYou: false } }, 'viewerA');
+
+    expect(readByUsername(qc, 'alice', 'viewerA')).toBeDefined();
+    expect(readByUsername(qc, 'alice', 'viewerB')).toBeUndefined();
+  });
+
+  it('never stores viewer-relative relationship on the viewer-independent by-id key', () => {
+    const qc = makeClient();
+    upsertCachedUser(
+      qc,
+      { id: 'u1', username: 'alice', relationship: { isFollowing: true, followsYou: true } },
+      'viewerA',
+    );
+
+    expect(readById(qc, 'u1')?.relationship).toBeUndefined();
+    expect(readByUsername(qc, 'alice', 'viewerA')?.relationship).toEqual({
+      isFollowing: true,
+      followsYou: true,
+    });
+  });
+
+  it('strips a stale relationship from an existing by-id entry on merge', () => {
+    const qc = makeClient();
+    qc.setQueryData(queryKeys.users.detail('u1'), {
+      id: 'u1',
+      username: 'alice',
+      relationship: { isFollowing: true, followsYou: true },
+    });
+
+    upsertCachedUser(qc, { id: 'u1', username: 'alice', avatar: 'file_a' }, 'viewerA');
+
+    expect(readById(qc, 'u1')?.relationship).toBeUndefined();
+    expect(readById(qc, 'u1')?.avatar).toBe('file_a');
+  });
+
+  it('is case-insensitive on username (byUsername normalization)', () => {
+    const qc = makeClient();
+    upsertCachedUser(qc, { id: 'u1', username: 'AlIcE' }, 'v1');
+    // read with any casing resolves the same entry
+    expect(readByUsername(qc, 'alice', 'v1')).toMatchObject({ id: 'u1' });
+    expect(readByUsername(qc, 'ALICE', 'v1')).toMatchObject({ id: 'u1' });
+  });
+
+  it('defaults the viewer id from the auth store when omitted', () => {
+    const qc = makeClient();
+    useAuthStore.setState({ user: { id: 'store-viewer', username: 'me', name: { displayName: 'Me' }, publicKey: 'pk' } });
+
+    upsertCachedUser(qc, { id: 'u1', username: 'alice' });
+
+    expect(readByUsername(qc, 'alice', 'store-viewer')).toMatchObject({ id: 'u1' });
+    expect(readByUsername(qc, 'alice', '')).toBeUndefined();
+  });
+});
+
+describe('upsertCachedUsers — batch', () => {
+  it('upserts every user under both keys', () => {
+    const qc = makeClient();
+    upsertCachedUsers(
+      qc,
+      [
+        { id: 'u1', username: 'alice' },
+        { id: 'u2', username: 'bob' },
+      ],
+      'v1',
+    );
+
+    expect(readById(qc, 'u1')).toMatchObject({ username: 'alice' });
+    expect(readById(qc, 'u2')).toMatchObject({ username: 'bob' });
+    expect(readByUsername(qc, 'alice', 'v1')).toBeDefined();
+    expect(readByUsername(qc, 'bob', 'v1')).toBeDefined();
+  });
+
+  it('accumulates fields when the same user appears twice with different slices', () => {
+    const qc = makeClient();
+    // Seed a fresh (non-cold) authoritative entry first so both batch items merge.
+    qc.setQueryData(queryKeys.users.detail('u1'), { id: 'u1', username: 'alice' });
+    upsertCachedUsers(
+      qc,
+      [
+        { id: 'u1', username: 'alice', avatar: 'file_a' },
+        { id: 'u1', username: 'alice', bio: 'hello' },
+      ],
+      'v1',
+    );
+
+    const byId = readById(qc, 'u1');
+    expect(byId?.avatar).toBe('file_a');
+    expect(byId?.bio).toBe('hello');
+  });
+
+  it('ignores null / empty input', () => {
+    const qc = makeClient();
+    upsertCachedUsers(qc, null, 'v1');
+    upsertCachedUsers(qc, [], 'v1');
+    expect(qc.getQueryCache().getAll()).toHaveLength(0);
+  });
+});

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

@@ -50,6 +50,15 @@ export const useUserProfiles = (sessionIds: string[], options?: { enabled?: bool
 /**
  * Get current authenticated user.
  *
+ * Hydrates from `GET /users/me` (the bearer identifies the session) rather than
+ * `GET /session/user/:activeSessionId`. Post zero-cookie cutover the bearer is
+ * the single source of session truth, so keying the CURRENT user off a session
+ * id in the URL was a second, independently-updated source that could disagree
+ * with the bearer during an account switch — the request fired under the
+ * previous account's token against the new account's session id and 404'd. The
+ * query KEY stays scoped to the active account so the cache re-scopes (and
+ * refetches) on a switch; only the URL stopped carrying a session id.
+ *
  * The store-mirror effect must NOT overwrite the in-memory user while a
  * write mutation is in flight — otherwise a stale background refetch
  * landing between optimistic update and server-confirmed update would
@@ -67,10 +76,7 @@ export const useCurrentUser = (options?: { enabled?: boolean }) => {
   const query = useQuery({
     queryKey: queryKeys.accounts.current(activeSessionId),
     queryFn: async () => {
-      if (!activeSessionId) {
-        throw new Error('No active session');
-      }
-      return await oxyServices.getUserBySession(activeSessionId);
+      return await oxyServices.getCurrentUser();
     },
     enabled: (options?.enabled !== false) && isAuthenticated && !!activeSessionId,
     staleTime: 1 * 60 * 1000, // 1 minute for current user
@@ -200,7 +206,10 @@ export const useUserByUsername = (username: string | null, options?: { enabled?:
       if (!username) {
         throw new Error('Username is required');
       }
-      return await oxyServices.getProfileByUsername(username);
+      // Match queryKeys.users.byUsername normalization so the cache key and
+      // the API request agree (case-insensitive local handles).
+      const normalizedUsername = username.trim().toLowerCase();
+      return await oxyServices.getProfileByUsername(normalizedUsername);
     },
     enabled: (options?.enabled !== false) && !!username,
     staleTime: 5 * 60 * 1000,