@oxyhq/services 26.1.0 → 27.0.0

package/lib/typescript/module/ui/hooks/mutations/useAccountMutations.d.ts

@@ -208,7 +208,7 @@ export declare const useUpdateAccountSettings: () => {
         };
         isManagedAccount?: boolean;
         managedBy?: string;
-        organizationCategory?: import("@oxyhq/contracts").OrganizationCategory;
+        accountCategories?: import("@oxyhq/contracts").AccountCategoryId[];
         languages?: string[];
         notificationPreferences?: NotificationPreferences;
         userPreferences?: UserPreferences;

package/lib/typescript/module/ui/hooks/mutations/useAccountMutations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAccountMutations.d.ts","sourceRoot":"","sources":["../../../../../../src/ui/hooks/mutations/useAccountMutations.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"useAccountMutations.d.ts","sourceRoot":"","sources":["../../../../../../src/ui/hooks/mutations/useAccountMutations.ts"],"names":[],"mappings":"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"}

package/lib/typescript/module/ui/hooks/queries/userCache.d.ts

@@ -36,9 +36,37 @@
  *     never overwritten by a degraded/empty one (empty username, the
  *     `'Unknown user'` ghost-author sentinel, `null` avatar).
  *
+ * EXPRESSING A DELIBERATE CLEAR ("remove my picture")
+ * ---------------------------------------------------
+ * The anti-degradation rule above is right for a sparse source and wrong for a
+ * user who just emptied the field — and the two are NOT distinguishable from the
+ * payload. Measured against oxy-api's canonical serializer (`formatUserResponse`
+ * in `packages/api/src/utils/userTransform.ts`, which passes every field through
+ * `typeof value === 'string' ? value : undefined`): an account whose avatar,
+ * bio and display name were all just CLEARED serializes to
+ * `{"id":…,"publicKey":…,"username":…,"name":{},"languages":[]}` — byte-identical
+ * to the same account read as a sparse projection. There is no `null` and no
+ * `''` on the wire to key on. The information that a field was deliberately
+ * emptied exists ONLY at the call site that performed the write.
+ *
+ * So the caller declares it: `upsertCachedUser(qc, user, viewerId, { cleared:
+ * ['avatar'] })`. For a declared field an incoming EMPTY value means the field
+ * IS empty and the stale value is dropped; a MEANINGFUL incoming value still
+ * wins as usual (so `{ cleared: ['name.displayName'] }` on a personal account,
+ * where clearing the explicit name makes the server return the COMPOSED one,
+ * keeps the composed name rather than blanking it).
+ *
+ * A blanket "this source is authoritative, treat every absent field as cleared"
+ * flag was considered and rejected: because the two payloads are byte-identical,
+ * such a flag is an unverifiable promise about provenance, and the failure mode
+ * of getting it wrong is blanking real identity data in every Oxy app. Naming
+ * the fields states something the caller actually observed — which fields the
+ * user emptied — and bounds the damage to exactly those.
+ *
  * It is a cache write only — zero network, one `setQueryData` per key.
  */
-import type { UserNameResponse } from "@oxyhq/contracts";
+import type { UserNameResponse, UserProfileUpdate } from "@oxyhq/contracts";
+import type { UpdateAccountInput } from "@oxyhq/core";
 import type { QueryClient } from "@tanstack/react-query";
 /**
  * A user-shaped object that can be upserted into the cache. Intentionally
@@ -76,6 +104,47 @@ export interface CacheableUser {
     } | null;
     [key: string]: unknown;
 }
+/**
+ * The profile fields a user can genuinely EMPTY through a real Oxy write, and
+ * for which "empty" is a state every renderer already handles.
+ *
+ * Deliberately a closed list rather than "any field": a clear DELETES data from
+ * the cache, so the blast radius of a mistaken declaration is bounded here
+ * instead of resting on each call site. `username` is absent because an account
+ * always has one; `_count` and `relationship` are absent because they are
+ * server-derived, never user-emptied — and dropping a viewer `relationship` is
+ * the exact "Follows you vanishes" bug this module exists to prevent.
+ *
+ * Each entry is clearable through a shipped write path: `avatar`, `bio`,
+ * `description` and `name.displayName` via `UserProfileUpdate` (`''` clears) and
+ * `UpdateAccountInput` (`null` clears avatar/bio; `accountCategories: []`
+ * clears the ordered category list), and `color` via its nullable field.
+ */
+export declare const CLEARABLE_USER_FIELDS: readonly ["avatar", "bio", "description", "color", "accountCategories", "name.displayName"];
+/** A field nameable in {@link UpsertCachedUserOptions.cleared}. */
+export type ClearableUserField = (typeof CLEARABLE_USER_FIELDS)[number];
+/**
+ * Fields the caller deliberately emptied in a `PUT /users/me` patch. The wire
+ * response omits cleared scalars, so the cache needs this list to drop stale
+ * values immediately instead of waiting for a refetch that merges the same
+ * sparse payload.
+ */
+export declare function clearedFieldsFromProfileUpdate(updates: UserProfileUpdate): ClearableUserField[];
+/**
+ * Same contract as {@link clearedFieldsFromProfileUpdate} for managed-account
+ * `PATCH /accounts/:id` writes (`null` clears avatar/bio/category).
+ */
+export declare function clearedFieldsFromAccountUpdate(input: UpdateAccountInput): ClearableUserField[];
+/** Options for {@link upsertCachedUser}. */
+export interface UpsertCachedUserOptions {
+    /**
+     * Fields the write that produced this user DELIBERATELY emptied. For each,
+     * an incoming empty value stops meaning "this source does not carry it" and
+     * starts meaning "it is empty" — so the stale value is dropped rather than
+     * preserved. Everything not named here keeps the anti-degradation guard.
+     */
+    cleared?: readonly ClearableUserField[];
+}
 /**
  * Merge-upsert a (possibly partial) user into the SDK's user query cache under
  * both the by-id key and, when a username is present, the viewer-scoped
@@ -85,12 +154,20 @@ export interface CacheableUser {
  * @param user        A `User`-shaped object (may be sparse).
  * @param viewerId    The active viewer id for the by-username key. Defaults to
  *                    the current auth-store user id.
+ * @param options     `cleared` names the fields the write deliberately emptied
+ *                    — the ONLY way "remove my picture" can propagate, since a
+ *                    cleared field and an uncarried one are byte-identical on
+ *                    the wire (see the module docs).
  */
-export declare function upsertCachedUser(queryClient: QueryClient, user: CacheableUser, viewerId?: string): void;
+export declare function upsertCachedUser(queryClient: QueryClient, user: CacheableUser, viewerId?: string, options?: UpsertCachedUserOptions): void;
 /**
  * Batch merge-upsert many users at once (for a feed / list / search response).
  * Resolves the viewer id once and upserts each user cumulatively — a user that
  * appears twice merges both slices into the single cache entry.
+ *
+ * Takes NO `cleared`, deliberately: a batch is a multi-user projection, so it is
+ * exactly the sparse source the anti-degradation guard exists for, and one
+ * declaration could not be true of every user in the array anyway.
  */
 export declare function upsertCachedUsers(queryClient: QueryClient, users: readonly CacheableUser[] | null | undefined, viewerId?: string): void;
 //# sourceMappingURL=userCache.d.ts.map

package/lib/typescript/module/ui/hooks/queries/userCache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"userCache.d.ts","sourceRoot":"","sources":["../../../../../../src/ui/hooks/queries/userCache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAIzD;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC7B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,2EAA2E;IAC3E,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAAC;IACjC,8EAA8E;IAC9E,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,qEAAqE;IACrE,MAAM,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAC3D;;;;OAIG;IACH,YAAY,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,OAAO,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IACtE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACvB;AA0MD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC/B,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,aAAa,EACnB,QAAQ,CAAC,EAAE,MAAM,GACf,IAAI,CAoBN;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAChC,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,SAAS,aAAa,EAAE,GAAG,IAAI,GAAG,SAAS,EAClD,QAAQ,CAAC,EAAE,MAAM,GACf,IAAI,CAMN"}
+{"version":3,"file":"userCache.d.ts","sourceRoot":"","sources":["../../../../../../src/ui/hooks/queries/userCache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAIzD;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC7B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,2EAA2E;IAC3E,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAAC;IACjC,8EAA8E;IAC9E,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,qEAAqE;IACrE,MAAM,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAC3D;;;;OAIG;IACH,YAAY,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,OAAO,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IACtE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACvB;AAKD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,qBAAqB,6FAOxB,CAAC;AAEX,mEAAmE;AACnE,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC;AAExE;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC7C,OAAO,EAAE,iBAAiB,GACxB,kBAAkB,EAAE,CAsBtB;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAC7C,KAAK,EAAE,kBAAkB,GACvB,kBAAkB,EAAE,CAuBtB;AAED,4CAA4C;AAC5C,MAAM,WAAW,uBAAuB;IACvC;;;;;OAKG;IACH,OAAO,CAAC,EAAE,SAAS,kBAAkB,EAAE,CAAC;CACxC;AAgQD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAC/B,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,aAAa,EACnB,QAAQ,CAAC,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,uBAAuB,GAC/B,IAAI,CAyBN;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAChC,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,SAAS,aAAa,EAAE,GAAG,IAAI,GAAG,SAAS,EAClD,QAAQ,CAAC,EAAE,MAAM,GACf,IAAI,CAMN"}

package/lib/typescript/module/ui/screens/AccountSettingsScreen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AccountSettingsScreen.d.ts","sourceRoot":"","sources":["../../../../../src/ui/screens/AccountSettingsScreen.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAe/B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAqB,CAAC;AAY3D;;;;;;GAMG;AACH,QAAA,MAAM,qBAAqB,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAyOpD,CAAC;AAEF,eAAe,qBAAqB,CAAC"}
+{"version":3,"file":"AccountSettingsScreen.d.ts","sourceRoot":"","sources":["../../../../../src/ui/screens/AccountSettingsScreen.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAe/B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAqB,CAAC;AAgB3D;;;;;;GAMG;AACH,QAAA,MAAM,qBAAqB,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CA6OpD,CAAC;AAEF,eAAe,qBAAqB,CAAC"}

package/lib/typescript/module/ui/screens/CreateAccountScreen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CreateAccountScreen.d.ts","sourceRoot":"","sources":["../../../../../src/ui/screens/CreateAccountScreen.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAM/B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAqB,CAAC;AA2F3D;;;;;GAKG;AACH,QAAA,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CA+SlD,CAAC;AAEF,eAAe,mBAAmB,CAAC"}
+{"version":3,"file":"CreateAccountScreen.d.ts","sourceRoot":"","sources":["../../../../../src/ui/screens/CreateAccountScreen.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAM/B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAqB,CAAC;AAmG3D;;;;;GAKG;AACH,QAAA,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAkVlD,CAAC;AAEF,eAAe,mBAAmB,CAAC"}

package/lib/typescript/module/ui/utils/avatarUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"avatarUtils.d.ts","sourceRoot":"","sources":["../../../../../src/ui/utils/avatarUtils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAG1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGzD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,WAAW,GACvB,IAAI,CAON;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,iBAAiB,EAC1B,WAAW,EAAE,WAAW,EACxB,eAAe,EAAE,MAAM,GAAG,IAAI,EAC9B,WAAW,EAAE,WAAW,EACxB,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAChC,OAAO,CAAC,IAAI,CAAC,CAoCf"}
+{"version":3,"file":"avatarUtils.d.ts","sourceRoot":"","sources":["../../../../../src/ui/utils/avatarUtils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAG1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAOzD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,WAAW,GACvB,IAAI,CAON;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,iBAAiB,EAC1B,WAAW,EAAE,WAAW,EACxB,eAAe,EAAE,MAAM,GAAG,IAAI,EAC9B,WAAW,EAAE,WAAW,EACxB,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAChC,OAAO,CAAC,IAAI,CAAC,CAyCf"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxyhq/services",
-  "version": "26.1.0",
+  "version": "27.0.0",
   "description": "OxyHQ Expo/React Native SDK — UI components, screens, and native features",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",
@@ -138,7 +138,7 @@
     }
   },
   "dependencies": {
-    "@oxyhq/contracts": "0.22.0",
+    "@oxyhq/contracts": "0.23.0",
     "@simplewebauthn/browser": "^13.3.0",
     "color": "^4.2.3"
   },
@@ -147,7 +147,7 @@
     "@commitlint/cli": "^21.2.1",
     "@commitlint/config-conventional": "^21.2.0",
     "@expo/vector-icons": "^15.0.3",
-    "@oxyhq/core": "17.1.0",
+    "@oxyhq/core": "19.0.0",
     "@react-native-async-storage/async-storage": "^2.0.0",
     "@react-native-community/netinfo": "^11.4.1",
     "@react-native/babel-preset": "^0.86.0",
@@ -190,7 +190,7 @@
   "peerDependencies": {
     "@expo/vector-icons": "^15.0.3",
     "@oxyhq/bloom": ">=0.59.0",
-    "@oxyhq/core": "^17.0.3",
+    "@oxyhq/core": "^19.0.0",
     "@react-native-async-storage/async-storage": "^2.0.0",
     "@react-native-community/netinfo": ">=11.4.1",
     "@tanstack/query-async-storage-persister": "^5.101",

package/src/index.ts

@@ -173,9 +173,21 @@ export {
 // SDK's user query cache under both keys it owns (by-id + viewer-scoped
 // by-username). Consumers route ALL cache seeds (feed / list / search / profile
 // hydration) through this so a sparse source can never strip a field an
-// authoritative fetch already stored.
-export { upsertCachedUser, upsertCachedUsers } from './ui/hooks/queries/userCache';
-export type { CacheableUser } from './ui/hooks/queries/userCache';
+// authoritative fetch already stored. A write that DELIBERATELY empties a field
+// ("remove my picture") says so with `{ cleared: [...] }` — the payload cannot
+// express it, see the module docs.
+export {
+    upsertCachedUser,
+    upsertCachedUsers,
+    CLEARABLE_USER_FIELDS,
+    clearedFieldsFromProfileUpdate,
+    clearedFieldsFromAccountUpdate,
+} from './ui/hooks/queries/userCache';
+export type {
+    CacheableUser,
+    ClearableUserField,
+    UpsertCachedUserOptions,
+} from './ui/hooks/queries/userCache';
 
 // Mutation status aggregator (for "Syncing..." indicators)
 export { useMutationStatus } from './ui/hooks/useMutationStatus';

package/src/ui/components/authChooser/requestSurfaces.tsx

@@ -13,11 +13,11 @@
  */
 
 import type React from 'react';
-import { View } from 'react-native';
+import { ActivityIndicator, View } from 'react-native';
 import MaterialCommunityIcons from '@expo/vector-icons/MaterialCommunityIcons';
 import QRCode from 'react-native-qrcode-svg';
 import { Button } from '@oxyhq/bloom/button';
-import { Loading } from '@oxyhq/bloom/loading';
+import { useTheme } from '@oxyhq/bloom/theme';
 import { Text } from '@oxyhq/bloom/typography';
 import type { CommonsDeliveryRoute, SignInProgress } from '@oxyhq/core';
 import { authChooserStyles as styles } from './styles';
@@ -30,8 +30,16 @@ const QR_SIZE = 196;
 /** The leading route glyph, sized to sit where the QR plate otherwise would. */
 const ROUTE_GLYPH_SIZE = 44;
 
-/** The indeterminate leading visual: the request exists but has nothing to show yet. */
-export const PreparingSurface: React.FC = () => <Loading variant="spinner" size="large" />;
+/**
+ * The indeterminate leading visual: the request exists but has nothing to show yet.
+ * Uses RN's ActivityIndicator — `@oxyhq/bloom/loading` can tree-shake to `undefined`
+ * in rolldown-vite production bundles when co-imported with `@oxyhq/bloom/button`
+ * (auth.oxy.so/authorize blank screen, React #130).
+ */
+export const PreparingSurface: React.FC = () => {
+  const theme = useTheme();
+  return <ActivityIndicator size="large" color={theme.colors.primary} />;
+};
 
 /** The leading glyph for a route whose surface is elsewhere (the phone, Commons). */
 export const RouteGlyph: React.FC<{

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

@@ -20,6 +20,11 @@ import { useOxy } from '../../context/OxyContext';
 import { toast } from '@oxyhq/bloom/toast';
 import { refreshAvatarInStore } from '../../utils/avatarUtils';
 import { useAuthStore } from '../../stores/authStore';
+import { useAccountStore } from '../../stores/accountStore';
+import {
+  clearedFieldsFromProfileUpdate,
+  upsertCachedUser,
+} from '../queries/userCache';
 
 /**
  * Update user profile with optimistic updates and offline queue support
@@ -104,9 +109,21 @@ export const useUpdateProfile = () => {
       // Update authStore so frontend components see the changes immediately
       useAuthStore.getState().setUser(data);
 
-      // If avatar was updated, refresh accountStore with cache-busted URL
-      if (updates.avatar && activeSessionId && oxyServices) {
-        refreshAvatarInStore(activeSessionId, updates.avatar, oxyServices);
+      const cleared = clearedFieldsFromProfileUpdate(updates);
+      upsertCachedUser(queryClient, data, data.id, {
+        cleared: cleared.length > 0 ? cleared : undefined,
+      });
+
+      // Avatar add/remove: keep the account switcher in sync with profile writes
+      if (typeof updates.avatar === 'string' && activeSessionId) {
+        if (updates.avatar && oxyServices) {
+          refreshAvatarInStore(activeSessionId, updates.avatar, oxyServices);
+        } else {
+          useAccountStore.getState().updateAccount(activeSessionId, {
+            avatar: undefined,
+            avatarUrl: undefined,
+          });
+        }
       }
 
       // Invalidate all related queries so every consumer (the account dialog,

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

@@ -0,0 +1,301 @@
+/**
+ * userCache — DELIBERATE CLEARS vs sparse sources.
+ *
+ * `upsertCachedUser` refuses an empty incoming value so a sparse feed/post/list
+ * author can never blank a field the authoritative profile fetch stored. That is
+ * right for a projection and wrong for a user who just removed their picture,
+ * and the payload cannot tell the two apart: oxy-api's `formatUserResponse`
+ * emits a cleared field as `undefined`, which `JSON.stringify` drops, so a
+ * cleared avatar and an uncarried one arrive byte-identical. The caller declares
+ * the difference with `{ cleared: [...] }`.
+ *
+ * WHAT MAKES THIS SUITE NON-VACUOUS
+ * ---------------------------------
+ * Every assertion here is paired: the SAME incoming payload is upserted once
+ * WITHOUT `cleared` and once WITH it, and the two must disagree. A suite whose
+ * fixtures only ever passed `cleared` could not tell "the guard was removed"
+ * from "the clear works", which is the whole risk — dropping the guard would
+ * blank real avatars across every Oxy app. The `does not` half of each pair is
+ * what pins the guard; `userCache.test.ts` keeps its own anti-degradation
+ * coverage independently.
+ */
+
+import { QueryClient } from '@tanstack/react-query';
+import {
+  CLEARABLE_USER_FIELDS,
+  clearedFieldsFromAccountUpdate,
+  clearedFieldsFromProfileUpdate,
+  upsertCachedUser,
+  upsertCachedUsers,
+} from '../userCache';
+import type { CacheableUser, ClearableUserField } from '../userCache';
+import { queryKeys } from '../queryKeys';
+import { useAuthStore } from '../../../stores/authStore';
+
+function makeClient(): QueryClient {
+  return new QueryClient({ defaultOptions: { queries: { retry: false } } });
+}
+
+function readById(qc: QueryClient, id: string): CacheableUser | undefined {
+  return qc.getQueryData<CacheableUser>(queryKeys.users.detail(id));
+}
+
+function readByUsername(
+  qc: QueryClient,
+  username: string,
+  viewerId: string,
+): CacheableUser | undefined {
+  return qc.getQueryData<CacheableUser>(
+    queryKeys.users.byUsername(username, viewerId),
+  );
+}
+
+/** A warm, fully-populated entry — what an authoritative profile fetch stored. */
+function seedFullEntry(qc: QueryClient, viewerId = ''): void {
+  const full = {
+    id: 'u1',
+    username: 'alice',
+    name: { displayName: 'Alice A', first: 'Alice' },
+    avatar: 'file_old',
+    bio: 'old bio',
+    description: 'old description',
+    color: 'teal',
+    accountCategories: ['agency'],
+    _count: { followers: 10, following: 5 },
+  };
+  qc.setQueryData(queryKeys.users.detail('u1'), full);
+  qc.setQueryData(queryKeys.users.byUsername('alice', viewerId), {
+    ...full,
+    relationship: { isFollowing: true, followsYou: true },
+  });
+}
+
+/**
+ * The write response for an account that just emptied everything, in the shape
+ * oxy-api's `formatUserResponse` actually produces — MEASURED, not assumed:
+ *
+ *   {"id":"acc1","publicKey":"pk","username":"chan","name":{},"languages":[]}
+ *
+ * The two details that matter and are easy to get wrong: every cleared scalar is
+ * OMITTED (serialized as `undefined`, which `JSON.stringify` drops), while
+ * `name` survives as a PRESENT-but-EMPTY object. Writing this fixture as
+ * `{ id, username }` instead — with no `name` key — routes `mergeName` down its
+ * "incoming absent" branch and leaves the "incoming present, displayName empty"
+ * branch untested; mutation-testing caught exactly that. Nothing in this object
+ * says "cleared", which is the whole point.
+ */
+const clearedResponse: CacheableUser = { id: 'u1', username: 'alice', name: {} };
+
+/**
+ * The same clear expressed the way a caller echoing its own REQUEST would send
+ * it: `UserProfileUpdate` clears a display name with `''`. It must land on the
+ * same result as the response shape above.
+ */
+const clearedByEmptyString: CacheableUser = {
+  id: 'u1',
+  username: 'alice',
+  name: { displayName: '' },
+};
+
+beforeEach(() => {
+  useAuthStore.setState({ user: null });
+});
+
+describe('upsertCachedUser — a declared clear empties the field', () => {
+  it.each(
+    CLEARABLE_USER_FIELDS.filter(
+      (field): field is Exclude<ClearableUserField, 'name.displayName'> =>
+        field !== 'name.displayName',
+    ),
+  )('drops a stale `%s` only when the caller declares it cleared', (field) => {
+    // WITHOUT the declaration: the guard holds, the stored value survives.
+    const guarded = makeClient();
+    seedFullEntry(guarded);
+    upsertCachedUser(guarded, clearedResponse, '');
+    expect(readById(guarded, 'u1')?.[field]).toBeDefined();
+
+    // WITH it: the same payload now empties exactly that field.
+    const cleared = makeClient();
+    seedFullEntry(cleared);
+    upsertCachedUser(cleared, clearedResponse, '', { cleared: [field] });
+    expect(readById(cleared, 'u1')?.[field]).toBeUndefined();
+  });
+
+  // Three `name` shapes, because `mergeName` branches on them and a single
+  // fixture leaves one branch untested (mutation-verified): the measured
+  // response carries `name: {}`, a request echo carries `name: {displayName:''}`,
+  // and a caller passing a bare object carries no `name` key at all.
+  it.each([
+    ['present but empty (the measured oxy-api shape)', clearedResponse],
+    ['an explicit empty displayName (the request shape)', clearedByEmptyString],
+    ['no `name` key at all', { id: 'u1', username: 'alice' } as CacheableUser],
+  ])(
+    'drops a stale display name only when declared — incoming name %s',
+    (_label, incoming) => {
+      const guarded = makeClient();
+      seedFullEntry(guarded);
+      upsertCachedUser(guarded, incoming, '');
+      expect(readById(guarded, 'u1')?.name).toEqual({
+        displayName: 'Alice A',
+        first: 'Alice',
+      });
+
+      const cleared = makeClient();
+      seedFullEntry(cleared);
+      upsertCachedUser(cleared, incoming, '', {
+        cleared: ['name.displayName'],
+      });
+      // `first` is not what was cleared and must survive — a clear is per-field,
+      // not "drop the whole `name` object".
+      expect(readById(cleared, 'u1')?.name).toEqual({ first: 'Alice' });
+    },
+  );
+
+  it('never lets the "Unknown user" sentinel survive a declared display-name clear', () => {
+    // The ghost-author sentinel is not a real value, so it must not block the
+    // clear either — it is "empty" for this purpose, exactly as it is for the
+    // anti-degradation guard.
+    const qc = makeClient();
+    seedFullEntry(qc);
+    upsertCachedUser(
+      qc,
+      { id: 'u1', username: 'alice', name: { displayName: 'Unknown user' } },
+      '',
+      { cleared: ['name.displayName'] },
+    );
+    expect(readById(qc, 'u1')?.name).toEqual({ first: 'Alice' });
+  });
+
+  it('clears under the by-username key too, not just by-id', () => {
+    const qc = makeClient();
+    seedFullEntry(qc, 'viewer-1');
+    upsertCachedUser(qc, clearedResponse, 'viewer-1', { cleared: ['avatar'] });
+
+    expect(readByUsername(qc, 'alice', 'viewer-1')?.avatar).toBeUndefined();
+    expect(readById(qc, 'u1')?.avatar).toBeUndefined();
+  });
+
+  it('clears ONLY the declared fields, leaving every other one intact', () => {
+    const qc = makeClient();
+    seedFullEntry(qc);
+    upsertCachedUser(qc, clearedResponse, '', { cleared: ['avatar'] });
+
+    const entry = readById(qc, 'u1');
+    expect(entry?.avatar).toBeUndefined();
+    // Vacuity floor: if a clear were implemented as "drop everything absent
+    // from the payload", all of these would be gone too and the test above
+    // would still pass.
+    expect(entry?.bio).toBe('old bio');
+    expect(entry?.description).toBe('old description');
+    expect(entry?.color).toBe('teal');
+    expect(entry?.name).toEqual({ displayName: 'Alice A', first: 'Alice' });
+    expect(entry?._count).toEqual({ followers: 10, following: 5 });
+  });
+
+  it('never drops the viewer relationship, whatever is declared', () => {
+    // `relationship` is not declarable (it is absent from CLEARABLE_USER_FIELDS)
+    // and is server-derived, never user-emptied. Dropping it is the
+    // "Follows you tag vanishes" bug this module exists to prevent.
+    const qc = makeClient();
+    seedFullEntry(qc, 'viewer-1');
+    upsertCachedUser(qc, clearedResponse, 'viewer-1', {
+      cleared: [...CLEARABLE_USER_FIELDS],
+    });
+
+    expect(readByUsername(qc, 'alice', 'viewer-1')?.relationship).toEqual({
+      isFollowing: true,
+      followsYou: true,
+    });
+    expect(readByUsername(qc, 'alice', 'viewer-1')?.username).toBe('alice');
+  });
+});
+
+describe('upsertCachedUser — a declared clear never beats a real value', () => {
+  it('keeps a meaningful incoming value for a field declared cleared', () => {
+    // The server-COMPOSED display name case: clearing the EXPLICIT name makes
+    // oxy-api return the composed one, which must be stored rather than
+    // blanked. Same rule for every field: `cleared` lowers the guard, it does
+    // not force an erasure.
+    const qc = makeClient();
+    seedFullEntry(qc);
+
+    upsertCachedUser(
+      qc,
+      {
+        id: 'u1',
+        username: 'alice',
+        name: { displayName: 'Alice Anderson' },
+        avatar: 'file_new',
+      },
+      '',
+      { cleared: ['name.displayName', 'avatar'] },
+    );
+
+    expect(readById(qc, 'u1')?.name).toEqual({
+      displayName: 'Alice Anderson',
+      first: 'Alice',
+    });
+    expect(readById(qc, 'u1')?.avatar).toBe('file_new');
+  });
+
+  it('treats an explicit null and an empty string as cleared, not as values', () => {
+    // oxy-api omits a cleared field, but `UpdateAccountInput` clears with `null`
+    // and `UserProfileUpdate` clears with `''`, so a caller echoing its own
+    // request must land on the same result as one passing the response.
+    for (const empty of [null, '', '   ']) {
+      const qc = makeClient();
+      seedFullEntry(qc);
+      upsertCachedUser(qc, { id: 'u1', username: 'alice', avatar: empty }, '', {
+        cleared: ['avatar'],
+      });
+      expect(readById(qc, 'u1')?.avatar).toBeUndefined();
+    }
+  });
+
+  it('is a no-op on a cold slot (nothing stale to drop)', () => {
+    const qc = makeClient();
+    upsertCachedUser(qc, clearedResponse, '', { cleared: ['avatar'] });
+
+    expect(readById(qc, 'u1')).toMatchObject({ id: 'u1', username: 'alice' });
+    expect(readById(qc, 'u1')?.avatar).toBeUndefined();
+    // The cold-slot stale-seed contract still holds.
+    expect(qc.getQueryState(queryKeys.users.detail('u1'))?.dataUpdatedAt).toBe(0);
+  });
+});
+
+describe('upsertCachedUsers — the batch path stays guarded', () => {
+  it('takes no clear declaration and never empties a field', () => {
+    // A batch is a multi-user projection: exactly the sparse source the guard
+    // exists for. If it ever grows a `cleared` option this test should fail.
+    const qc = makeClient();
+    seedFullEntry(qc);
+
+    upsertCachedUsers(qc, [{ id: 'u1', username: 'alice', avatar: null }], '');
+
+    expect(readById(qc, 'u1')?.avatar).toBe('file_old');
+  });
+});
+
+describe('clearedFieldsFromProfileUpdate', () => {
+  it('names only fields the patch deliberately emptied', () => {
+    expect(
+      clearedFieldsFromProfileUpdate({ avatar: '', bio: '', name: { displayName: '' } }),
+    ).toEqual(['avatar', 'bio', 'name.displayName']);
+    expect(clearedFieldsFromProfileUpdate({ avatar: 'file_new', bio: 'hello' })).toEqual([]);
+    expect(clearedFieldsFromProfileUpdate({ color: null })).toEqual(['color']);
+  });
+});
+
+describe('clearedFieldsFromAccountUpdate', () => {
+  it('treats null clears on managed accounts like profile clears', () => {
+    expect(
+      clearedFieldsFromAccountUpdate({
+        avatar: null,
+        bio: null,
+        accountCategories: [],
+        name: { displayName: '' },
+      }),
+    ).toEqual(['avatar', 'bio', 'accountCategories', 'name.displayName']);
+    expect(clearedFieldsFromAccountUpdate({ bio: 'still here' })).toEqual([]);
+  });
+});