@oxy.so/services 13.12.0 → 13.13.0

package/src/ui/context/commitSessionFlow.ts

@@ -1,6 +1,7 @@
 import type { User } from '@oxy.so/core';
 import { logger as loggerUtil } from '@oxy.so/core';
 import { isUnauthorizedStatus } from './oxyContextHelpers';
+import { isSessionChangedError } from '../utils/sessionChangedError';
 
 const LOG_CONTEXT = { component: 'OxyContext', method: 'commitSession' } as const;
 
@@ -79,6 +80,7 @@ export async function commitDeviceSetAndResolve(
   };
 
   const logReconcileError = (registrationError: unknown): void => {
+    if (isSessionChangedError(registrationError)) return;
     // A 401 here is the EXPECTED signed-out edge: the bearer was stale/cleared, so
     // the device-set registration (`POST /session/device/add`) cannot carry auth.
     // This is not a failure — the cold boot re-registers on the next load once a
@@ -107,6 +109,7 @@ export async function commitDeviceSetAndResolve(
     try {
       fullUser = await getCurrentUser();
     } catch (profileError) {
+      if (isSessionChangedError(profileError)) throw profileError;
       if (__DEV__) {
         loggerUtil.debug(
           'Failed to fetch full user on commit; using minimal fallback',
@@ -137,6 +140,7 @@ export async function commitDeviceSetAndResolve(
     try {
       await reconcileDeviceSet();
     } catch (registrationError) {
+      if (isSessionChangedError(registrationError)) throw registrationError;
       logReconcileError(registrationError);
     }
     await hydrateAndResolve();

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

@@ -1,5 +1,6 @@
 import { useCallback } from 'react';
 import { logoutIsolatedOAuthSession, readIsolatedOAuthSession } from '../isolatedOAuthSession';
+import { isSessionChangedError } from '../../utils/sessionChangedError';
 import type { ApiError, User } from '@oxy.so/core';
 import type { AuthStateStore, IdentityBinding, SessionClient } from '@oxy.so/core/session';
 import type { ClientSession, SessionLoginResponse } from '@oxy.so/core';
@@ -174,6 +175,7 @@ export const useAuthOperations = ({
           });
           await refreshPinnedAccountId?.();
         } catch (pinError) {
+          if (isSessionChangedError(pinError)) throw pinError;
           logger?.('Failed to persist identity pin after sign-in', pinError);
         }
       }
@@ -192,6 +194,7 @@ export const useAuthOperations = ({
         await syncFromClient();
         deviceRegistrationCommitted = true;
       } catch (registrationError) {
+        if (isSessionChangedError(registrationError)) throw registrationError;
         logger?.('Failed to register sign-in into device session set', registrationError);
       }
 
@@ -214,6 +217,7 @@ export const useAuthOperations = ({
           },
         );
       } catch (error) {
+        if (isSessionChangedError(error)) throw error;
         if (__DEV__ && logger) {
           logger('Failed to fetch device sessions after login', error);
         }
@@ -231,6 +235,7 @@ export const useAuthOperations = ({
         try {
           await oxyServices.session.logout(sessionResponse.sessionId, sessionResponse.sessionId);
         } catch (logoutError) {
+          if (isSessionChangedError(logoutError)) throw logoutError;
           // Non-critical - continue to switch session even if logout fails
           if (__DEV__ && logger) {
             logger('Failed to logout duplicate session, continuing with switch', logoutError);
@@ -289,6 +294,7 @@ export const useAuthOperations = ({
    */
   const signIn = useCallback(
     async (publicKey: string, deviceName?: string): Promise<User> => {
+      let superseded = false;
       runtime.batch(() => {
         runtime.setLoading(true);
         runtime.setError(null);
@@ -297,6 +303,10 @@ export const useAuthOperations = ({
       try {
         return await performSignIn(publicKey);
       } catch (error) {
+        if (isSessionChangedError(error)) {
+          superseded = true;
+          throw error;
+        }
         const message = handleAuthError(error, {
           defaultMessage: 'Sign in failed',
           code: LOGIN_ERROR_CODE,
@@ -307,7 +317,7 @@ export const useAuthOperations = ({
         runtime.setError(message);
         throw error;
       } finally {
-        runtime.setLoading(false);
+        if (!superseded) runtime.setLoading(false);
       }
     },
     [runtime, performSignIn, onError, logger],
@@ -329,7 +339,7 @@ export const useAuthOperations = ({
           revokeSelf: (sessionId) => oxyServices.session.logout(sessionId),
           clearSessionState,
         });
-        if (result.status === 'failed') {
+        if (result.status === 'failed' && !isSessionChangedError(result.error)) {
           handleAuthError(result.error, {
             defaultMessage: 'Logout failed',
             code: LOGOUT_ERROR_CODE,
@@ -378,6 +388,7 @@ export const useAuthOperations = ({
         }
         return { status: 'signed-out' };
       } catch (error) {
+        if (isSessionChangedError(error)) return { status: 'failed', error };
         const isInvalid = isInvalidSessionError(error);
 
         // Compare the RESOLVED target, not the raw optional parameter: every
@@ -459,6 +470,7 @@ export const useAuthOperations = ({
       await clearPersistedAuthSafe(store, logger);
       await clearSessionState();
     } catch (error) {
+      if (isSessionChangedError(error)) throw error;
       if (isInvalidSessionError(error)) {
         // An already-invalid bearer means the sessions this call would have
         // revoked are ALREADY gone — the sign-out happened, it just happened

package/src/ui/context/oxyContextHelpers.ts

@@ -1,3 +1,5 @@
+import { isSessionChangedError } from '../utils/sessionChangedError';
+
 /** Local display hint when a session lacks explicit `expiresAt` (7 days). */
 export const DEFAULT_SESSION_VALIDITY_MS = 7 * 24 * 60 * 60 * 1000;
 
@@ -24,5 +26,6 @@ export function getHttpStatus(error: unknown): number | undefined {
 }
 
 export function isUnauthorizedStatus(error: unknown): boolean {
+  if (isSessionChangedError(error)) return false;
   return getHttpStatus(error) === 401;
 }

package/src/ui/hooks/useFollowTarget.ts

@@ -20,6 +20,7 @@ import type { FollowStatus } from '@oxy.so/contracts';
 import { useOxy } from '../context/oxyRuntimeContext';
 import {
   isCompleteFollowStatus,
+  getFollowTargetGeneration,
   isFollowedGlobally,
   UNKNOWN_FOLLOW_STATUS,
   useFollowTargetStore,
@@ -92,11 +93,14 @@ export function useFollowTarget(
     // that window 401s and would leave the button stuck reporting an error the
     // user cannot act on.
     if (!targetId || !canUsePrivateApi) return;
+    const generation = getFollowTargetGeneration();
     try {
       const next = await oxyServices.follows.targetStatus(targetId);
+      if (generation !== getFollowTargetGeneration()) return;
       useFollowTargetStore.getState().setStatus(targetId, next);
       useFollowTargetStore.getState().setError(targetId, undefined);
     } catch (e) {
+      if (generation !== getFollowTargetGeneration()) return;
       const store = useFollowTargetStore.getState();
       // Leave `isUnknown` false so the button stays interactive and can retry.
       // A failed read is not the same as "never asked" — disabling forever would
@@ -127,6 +131,7 @@ export function useFollowTarget(
       failure: FollowActionErrorCode,
     ): Promise<boolean> => {
       if (!targetId) return false;
+      const generation = getFollowTargetGeneration();
       const store = useFollowTargetStore.getState();
       const previous = store.statuses[targetId];
       store.setStatus(targetId, optimistic);
@@ -134,9 +139,11 @@ export function useFollowTarget(
       store.setError(targetId, undefined);
       try {
         const settled = await run();
+        if (generation !== getFollowTargetGeneration()) return false;
         if (settled) useFollowTargetStore.getState().setStatus(targetId, settled);
         return true;
       } catch (e) {
+        if (generation !== getFollowTargetGeneration()) return false;
         const s = useFollowTargetStore.getState();
         // Back to what was true, not to a guess. Clearing the entry instead
         // would make the next render ask again and flash the wrong state.
@@ -144,7 +151,9 @@ export function useFollowTarget(
         s.setError(targetId, toFollowErrorCode(e, failure));
         return false;
       } finally {
-        useFollowTargetStore.getState().setPending(targetId, false);
+        if (generation === getFollowTargetGeneration()) {
+          useFollowTargetStore.getState().setPending(targetId, false);
+        }
       }
     },
     [targetId],

package/src/ui/hooks/useSessionManagement.ts

@@ -6,6 +6,7 @@ import { getStorageKeys, type StorageInterface } from '../utils/storageHelpers';
 import { handleAuthError, isInvalidSessionError } from '../utils/errorHandlers';
 import type { OxyServices } from '@oxy.so/core';
 import type { QueryClient } from '@tanstack/react-query';
+import { isSessionChangedError } from '../utils/sessionChangedError';
 import { clearQueryCache } from './queryClient';
 import { isWebBrowser } from '../utils/isWebBrowser';
 import { resetSessionScopedStores } from '../stores/resetSessionScopedStores';
@@ -188,6 +189,7 @@ export const useSessionManagement = ({
           });
           activeRuntime.mergeSessions(deviceSessions, { merge: true });
         } catch (error) {
+          if (isSessionChangedError(error)) throw error;
           if (isDev()) {
             console.warn('Failed to synchronize sessions after switch:', error);
           }
@@ -195,6 +197,7 @@ export const useSessionManagement = ({
 
         return user;
       } catch (error) {
+        if (isSessionChangedError(error)) throw error;
         const invalidSession = isInvalidSessionError(error);
 
         if (invalidSession) {

package/src/ui/index.ts

@@ -24,6 +24,9 @@ import '../registerPlatform';
 // in the first-paint bundle of every app that imports anything from `ui`
 // (Allo: +340 KB gzipped).
 
+// Shared organization form validation does not grant creation authority.
+export { parseOrganizationDraft } from './utils/organizationDraft';
+
 // Components
 export { default as OxyProvider } from './components/OxyProvider';
 export { default as OxySignInButton } from './components/OxySignInButton';

package/src/ui/runtime/createOxyRuntime.ts

@@ -652,6 +652,7 @@ export function createOxyRuntime(config: OxyRuntimeConfig): OxyRuntime {
         facts.directory = null;
         facts.profiles = new Map();
         facts.pinnedAccountId = null;
+        facts.isLoading = false;
         touch();
       });
     },

package/src/ui/stores/__tests__/followStore.test.ts

@@ -190,3 +190,65 @@ describe('resetFollowState', () => {
     expect(useFollowStore.getState().followingUsers).toEqual({});
   });
 });
+
+describe('follow operations across account resets', () => {
+  it.each(['resolve', 'reject'] as const)(
+    'does not reconcile a previous account toggle when it %s',
+    async (outcome) => {
+      const { mock, services } = makeServices();
+      let resolve!: (result: FollowMutationResult) => void;
+      let reject!: (error: Error) => void;
+      mock.follows.follow.mockReturnValueOnce(
+        new Promise((res, rej) => {
+          resolve = res;
+          reject = rej;
+        }),
+      );
+      const pending = useFollowStore.getState().toggleFollowUser('u1', services, false);
+      useFollowStore.getState().resetFollowState();
+      useFollowStore.setState({
+        followingUsers: { u1: true },
+        loadingUsers: { u1: true },
+        errors: { u1: 'read_failed' },
+      });
+      if (outcome === 'resolve')
+        resolve({ message: 'ok', counts: { followers: 10, following: 3 } });
+      else reject(new Error('old request failed'));
+      expect(await pending).toBe(false);
+      const state = useFollowStore.getState();
+      expect(state.followingUsers.u1).toBe(true);
+      expect(state.loadingUsers.u1).toBe(true);
+      expect(state.errors.u1).toBe('read_failed');
+      expect(state.followerCounts.u1).toBeUndefined();
+    },
+  );
+
+  it.each(['followMany', 'unfollowMany'] as const)(
+    'does not reconcile a previous account %s',
+    async (method) => {
+      const { services } = makeServices();
+      let resolve!: (result: unknown) => void;
+      const response = new Promise((res) => {
+        resolve = res;
+      });
+      Object.assign(services.follows, { [method]: jest.fn(() => response) });
+      const store = useFollowStore.getState();
+      const pending =
+        method === 'followMany'
+          ? store.followManyUsers(['u1'], services)
+          : store.unfollowManyUsers(['u1'], services);
+      store.resetFollowState();
+      useFollowStore.setState({
+        followingUsers: { u1: true },
+        loadingUsers: { u1: true },
+        errors: { u1: 'read_failed' },
+      });
+      resolve({ results: [] });
+      await expect(pending).rejects.toMatchObject({ code: 'AUTH_SESSION_CHANGED' });
+      const state = useFollowStore.getState();
+      expect(state.followingUsers.u1).toBe(true);
+      expect(state.loadingUsers.u1).toBe(true);
+      expect(state.errors.u1).toBe('read_failed');
+    },
+  );
+});

package/src/ui/stores/followStore.ts

@@ -6,6 +6,7 @@ import type {
   FollowMutationResult,
 } from '@oxy.so/core';
 import { type FollowErrorCode, toFollowErrorCode } from '../utils/followErrors';
+import { createSessionChangedError } from '../utils/sessionChangedError';
 
 interface FollowState {
   // Tri-state follow map: a MISSING key means UNKNOWN (status not yet resolved),
@@ -206,6 +207,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
           });
         })
         .finally(() => {
+          if (generation !== batchGeneration) return;
           for (const id of ids) inFlightIds.delete(id);
         });
     });
@@ -215,6 +217,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
     oxyServices: OxyServices,
     isCurrentlyFollowing: boolean,
   ) => {
+    const generation = batchGeneration;
     // Snapshot the prior value for rollback. `undefined` = was UNKNOWN.
     const priorState = get().followingUsers;
     const hadPrevious = hasKey(priorState, userId);
@@ -233,6 +236,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
       const response: FollowMutationResult = isCurrentlyFollowing
         ? await oxyServices.follows.unfollow(userId)
         : await oxyServices.follows.follow(userId);
+      if (generation !== batchGeneration) return false;
 
       // Reconcile: confirm the optimistic value is authoritative, clear loading.
       set((state) => ({
@@ -262,6 +266,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
       }
       return true;
     } catch (error: unknown) {
+      if (generation !== batchGeneration) return false;
       // Roll back to the prior value (or back to UNKNOWN if there was none).
       set((state) => {
         const followingUsers = { ...state.followingUsers };
@@ -286,6 +291,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
     userIds: string[],
     oxyServices: OxyServices,
   ): Promise<BulkFollowResult> => {
+    const generation = batchGeneration;
     // Snapshot prior values for rollback (tri-state: undefined = unknown).
     const prior = get().followingUsers;
     const previous = new Map<string, boolean | undefined>();
@@ -308,6 +314,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
 
     try {
       const result = await oxyServices.follows.followMany(userIds);
+      if (generation !== batchGeneration) throw createSessionChangedError();
       set((state) => {
         const followingUsers = { ...state.followingUsers };
         const loadingUsers = { ...state.loadingUsers };
@@ -334,6 +341,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
       });
       return result;
     } catch (error: unknown) {
+      if (generation !== batchGeneration) throw createSessionChangedError();
       const code = toFollowErrorCode(error, 'update_failed');
       // Whole batch failed — roll ALL targets back to their prior values.
       set((state) => {
@@ -359,6 +367,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
     userIds: string[],
     oxyServices: OxyServices,
   ): Promise<BulkUnfollowResult> => {
+    const generation = batchGeneration;
     // Snapshot prior values for rollback (tri-state: undefined = unknown).
     const prior = get().followingUsers;
     const previous = new Map<string, boolean | undefined>();
@@ -381,6 +390,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
 
     try {
       const result = await oxyServices.follows.unfollowMany(userIds);
+      if (generation !== batchGeneration) throw createSessionChangedError();
       set((state) => {
         const followingUsers = { ...state.followingUsers };
         const loadingUsers = { ...state.loadingUsers };
@@ -407,6 +417,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
       });
       return result;
     } catch (error: unknown) {
+      if (generation !== batchGeneration) throw createSessionChangedError();
       const code = toFollowErrorCode(error, 'update_failed');
       // Whole batch failed — roll ALL targets back to their prior values.
       set((state) => {
@@ -454,11 +465,13 @@ export const useFollowStore = create<FollowState>((set, get) => ({
     });
   },
   fetchUserCounts: async (userId: string, oxyServices: OxyServices) => {
+    const generation = batchGeneration;
     set((state) => ({
       loadingCounts: { ...state.loadingCounts, [userId]: true },
     }));
     try {
       const user = await oxyServices.users.get(userId);
+      if (generation !== batchGeneration) return;
       if (user?._count) {
         set((state) => ({
           followerCounts: {
@@ -477,6 +490,7 @@ export const useFollowStore = create<FollowState>((set, get) => ({
         }));
       }
     } catch (error: unknown) {
+      if (generation !== batchGeneration) return;
       set((state) => ({
         loadingCounts: { ...state.loadingCounts, [userId]: false },
       }));

package/src/ui/stores/followTargetStore.ts

@@ -29,6 +29,13 @@ import type { FollowErrorCode } from '../utils/followErrors';
 /** The status of one target, or `undefined` when it has never been read. */
 type StatusMap = Record<string, FollowStatus | undefined>;
 
+let followTargetGeneration = 0;
+
+/** The generation changes whenever account-scoped follow state is reset. */
+export function getFollowTargetGeneration(): number {
+  return followTargetGeneration;
+}
+
 interface FollowTargetState {
   statuses: StatusMap;
   /** In-flight writes, per target. Reads do not set this — only mutations do. */
@@ -80,7 +87,10 @@ export const useFollowTargetStore = create<FollowTargetState>((set) => ({
   // account switch the whole map is wrong, not stale — the next user's follows
   // are a different set entirely, and showing one user their previous
   // account's follow state is a privacy failure rather than a rendering one.
-  reset: () => set({ statuses: {}, pending: {}, errors: {} }),
+  reset: () => {
+    followTargetGeneration += 1;
+    set({ statuses: {}, pending: {}, errors: {} });
+  },
 }));
 
 /**

package/src/ui/utils/errorHandlers.ts

@@ -1,4 +1,5 @@
 import type { ApiError } from '@oxy.so/core';
+import { isSessionChangedError } from './sessionChangedError';
 
 type ErrorWithMessage = {
   message?: string;
@@ -52,6 +53,7 @@ const getResponseStatus = (error: unknown): number | undefined => {
  * This centralizes 401 detection across different fetch clients.
  */
 export const isInvalidSessionError = (error: unknown): boolean => {
+  if (isSessionChangedError(error)) return false;
   const status = getResponseStatus(error);
   if (status === 401) {
     return true;

package/src/ui/utils/followErrors.ts

@@ -1,3 +1,5 @@
+import { isSessionChangedError } from './sessionChangedError';
+
 /**
  * What a failed follow read or write leaves behind: a stable CODE, never text.
  *
@@ -43,6 +45,7 @@ const OFFLINE_CODES = new Set(['NETWORK_ERROR', 'CONNECTION_FAILED', 'TIMEOUT'])
  * Anything the cause does not explain falls back to the caller's `action`.
  */
 export function toFollowErrorCode(error: unknown, action: FollowActionErrorCode): FollowErrorCode {
+  if (isSessionChangedError(error)) return action;
   const { status, code } = (error && typeof error === 'object' ? error : {}) as {
     status?: unknown;
     code?: unknown;

package/src/ui/utils/organizationDraft.ts

@@ -0,0 +1,17 @@
+import { checkContract, createOrganizationCheck } from '@oxy.so/contracts/client';
+import type { CreateOrganization } from '@oxy.so/contracts';
+
+/** Normalize and validate form fields; callers must separately authorize creation. */
+export function parseOrganizationDraft(input: {
+  name: string;
+  organizationType: CreateOrganization['organizationType'];
+  websiteUrl: string;
+  countryCode: string;
+}): CreateOrganization | null {
+  return checkContract(createOrganizationCheck, {
+    name: input.name.trim(),
+    organizationType: input.organizationType,
+    websiteUrl: input.websiteUrl.trim() || null,
+    countryCode: input.countryCode.trim().toUpperCase() || null,
+  });
+}

package/src/ui/utils/sessionChangedError.ts

@@ -0,0 +1,14 @@
+/** A locally superseded request is not a server rejection of the new session. */
+export function isSessionChangedError(error: unknown): boolean {
+  return (
+    !!error && typeof error === 'object' && 'code' in error && error.code === 'AUTH_SESSION_CHANGED'
+  );
+}
+
+/** A locally superseded operation must not be mistaken for a server 401. */
+export function createSessionChangedError(): Error & { code: string; status: number } {
+  return Object.assign(new Error('The request session changed'), {
+    code: 'AUTH_SESSION_CHANGED',
+    status: 401,
+  });
+}

package/src/ui/utils/sessionHelpers.ts

@@ -1,4 +1,5 @@
 import type { ClientSession } from '@oxy.so/core';
+import { isSessionChangedError } from './sessionChangedError';
 
 interface DeviceSession {
   sessionId: string;
@@ -73,6 +74,7 @@ export const fetchSessionsWithFallback = async (
     const deviceSessions = await oxyServices.devices.sessions(sessionId);
     return mapSessionsToClient(deviceSessions, fallbackDeviceId, fallbackUserId);
   } catch (error) {
+    if (isSessionChangedError(error)) throw error;
     if (__DEV__ && logger) {
       logger('Failed to get device sessions, falling back to user sessions', error);
     }