@oxyhq/auth 1.0.0

package/dist/cjs/hooks/useWebSSO.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Web SSO Hook
+ *
+ * Handles cross-domain SSO for web apps using FedCM (Federated Credential Management).
+ *
+ * FedCM is the modern, privacy-preserving standard for cross-domain identity federation.
+ * It works across completely different TLDs (alia.onl, mention.earth, homiio.com, etc.)
+ * without relying on third-party cookies.
+ *
+ * For browsers without FedCM support, users will need to click a sign-in button
+ * which triggers a popup-based authentication flow.
+ *
+ * This is called automatically by OxyContext on web platforms.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/FedCM_API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useWebSSO = useWebSSO;
+exports.isWebBrowser = isWebBrowser;
+const react_1 = require("react");
+/**
+ * Check if we're running in a web browser environment (not React Native)
+ */
+function isWebBrowser() {
+    return typeof window !== 'undefined' &&
+        typeof document !== 'undefined' &&
+        typeof document.documentElement !== 'undefined';
+}
+/**
+ * Check if we're on the identity provider domain (where FedCM would authenticate against itself)
+ * Only auth.oxy.so is the IdP - accounts.oxy.so is a client app like any other
+ */
+function isIdentityProvider() {
+    if (!isWebBrowser())
+        return false;
+    const hostname = window.location.hostname;
+    return hostname === 'auth.oxy.so';
+}
+/**
+ * Hook for automatic cross-domain web SSO
+ *
+ * Uses FedCM (Federated Credential Management) - the modern browser-native
+ * identity federation API. This is the same technology that powers
+ * Google's cross-domain SSO (YouTube, Gmail, Maps, etc.).
+ *
+ * Key benefits:
+ * - Works across different TLDs (alia.onl ↔ mention.earth ↔ homiio.com)
+ * - No third-party cookies required
+ * - Privacy-preserving (browser mediates identity, IdP can't track)
+ * - Automatic silent sign-in after initial authentication
+ *
+ * For browsers without FedCM (Firefox, older browsers), automatic SSO
+ * is not possible. Users will see a sign-in button instead.
+ */
+function useWebSSO({ oxyServices, onSessionFound, onSSOUnavailable, onError, enabled = true, }) {
+    const isCheckingRef = (0, react_1.useRef)(false);
+    const hasCheckedRef = (0, react_1.useRef)(false);
+    // Check FedCM support once
+    const fedCMSupported = isWebBrowser() && oxyServices.isFedCMSupported?.();
+    const checkSSO = (0, react_1.useCallback)(async () => {
+        if (!isWebBrowser() || isCheckingRef.current) {
+            return null;
+        }
+        // Don't use FedCM on the auth domain itself - it would authenticate against itself
+        if (isIdentityProvider()) {
+            onSSOUnavailable?.();
+            return null;
+        }
+        // FedCM is the only reliable cross-domain SSO mechanism
+        if (!fedCMSupported) {
+            onSSOUnavailable?.();
+            return null;
+        }
+        isCheckingRef.current = true;
+        try {
+            const session = await oxyServices.silentSignInWithFedCM?.();
+            if (session) {
+                await onSessionFound(session);
+                return session;
+            }
+            onSSOUnavailable?.();
+            return null;
+        }
+        catch (error) {
+            onSSOUnavailable?.();
+            onError?.(error instanceof Error ? error : new Error(String(error)));
+            return null;
+        }
+        finally {
+            isCheckingRef.current = false;
+        }
+    }, [oxyServices, onSessionFound, onSSOUnavailable, onError, fedCMSupported]);
+    /**
+     * Trigger interactive FedCM sign-in
+     * This shows the browser's native "Sign in with Oxy" prompt.
+     * Use this when silent mediation fails (user hasn't previously consented).
+     */
+    const signInWithFedCM = (0, react_1.useCallback)(async () => {
+        if (!isWebBrowser() || isCheckingRef.current) {
+            return null;
+        }
+        if (!fedCMSupported) {
+            onError?.(new Error('FedCM is not supported in this browser'));
+            return null;
+        }
+        isCheckingRef.current = true;
+        try {
+            const session = await oxyServices.signInWithFedCM?.();
+            if (session) {
+                await onSessionFound(session);
+                return session;
+            }
+            return null;
+        }
+        catch (error) {
+            onError?.(error instanceof Error ? error : new Error(String(error)));
+            return null;
+        }
+        finally {
+            isCheckingRef.current = false;
+        }
+    }, [oxyServices, onSessionFound, onError, fedCMSupported]);
+    // Auto-check SSO on mount (web only, FedCM only, not on auth domain)
+    (0, react_1.useEffect)(() => {
+        if (!enabled || !isWebBrowser() || hasCheckedRef.current || isIdentityProvider()) {
+            if (isIdentityProvider()) {
+                onSSOUnavailable?.();
+            }
+            return;
+        }
+        hasCheckedRef.current = true;
+        if (fedCMSupported) {
+            checkSSO();
+        }
+        else {
+            onSSOUnavailable?.();
+        }
+    }, [enabled, checkSSO, fedCMSupported, onSSOUnavailable]);
+    return {
+        checkSSO,
+        signInWithFedCM,
+        isChecking: isCheckingRef.current,
+        isFedCMSupported: fedCMSupported,
+    };
+}

package/dist/cjs/index.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * @oxyhq/auth — OxyHQ Web Authentication SDK
+ *
+ * Headless authentication for React web apps (Next.js, Vite, CRA).
+ * Zero React Native / Expo dependencies.
+ *
+ * @example
+ * ```tsx
+ * import { WebOxyProvider, useAuth } from '@oxyhq/auth';
+ *
+ * function App() {
+ *   return (
+ *     <WebOxyProvider baseURL="https://api.oxy.so">
+ *       <YourApp />
+ *     </WebOxyProvider>
+ *   );
+ * }
+ *
+ * function YourApp() {
+ *   const { user, isAuthenticated, signIn, signOut } = useAuth();
+ *   // ...
+ * }
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withAuthErrorHandling = exports.ensureValidToken = exports.useFileFiltering = exports.useFollowerCounts = exports.useFollow = exports.setOxyFileUrlInstance = exports.useFileDownloadUrl = exports.setOxyAssetInstance = exports.useAssets = exports.useSessionSocket = exports.createGenericMutation = exports.createProfileMutation = exports.useRemoveDevice = exports.useUpdateDeviceName = exports.useLogoutAll = exports.useLogoutSession = exports.useSwitchSession = exports.useUploadFile = exports.useUpdatePrivacySettings = exports.useUpdateAccountSettings = exports.useUploadAvatar = exports.useUpdateProfile = exports.useRecentSecurityActivity = exports.useSecurityActivity = exports.useSecurityInfo = exports.useUserDevices = exports.useDeviceSessions = exports.useSession = exports.useSessions = exports.usePrivacySettings = exports.useUsersBySessions = exports.useUserByUsername = exports.useUserById = exports.useCurrentUser = exports.useUserProfiles = exports.useUserProfile = exports.useIsAssetLinked = exports.useAssetUsageCount = exports.useAssetsByEntity = exports.useAssetsByApp = exports.useAssetErrors = exports.useAssetLoading = exports.useUploadProgress = exports.useAsset = exports.useAssetsStore = exports.useAssetStore = exports.useAuthStore = exports.useAuth = exports.useWebOxy = exports.WebOxyProvider = void 0;
+exports.createCrossDomainAuth = exports.createAuthManager = exports.AuthManager = exports.CrossDomainAuth = exports.OxyServices = exports.extractErrorMessage = exports.isTimeoutOrNetworkError = exports.isInvalidSessionError = exports.handleAuthError = exports.AuthenticationFailedError = exports.SessionSyncRequiredError = exports.isAuthenticationError = exports.authenticatedApiCall = void 0;
+// --- Provider & Hooks ---
+var WebOxyProvider_1 = require("./WebOxyProvider");
+Object.defineProperty(exports, "WebOxyProvider", { enumerable: true, get: function () { return WebOxyProvider_1.WebOxyProvider; } });
+Object.defineProperty(exports, "useWebOxy", { enumerable: true, get: function () { return WebOxyProvider_1.useWebOxy; } });
+Object.defineProperty(exports, "useAuth", { enumerable: true, get: function () { return WebOxyProvider_1.useAuth; } });
+// --- Stores ---
+var authStore_1 = require("./stores/authStore");
+Object.defineProperty(exports, "useAuthStore", { enumerable: true, get: function () { return authStore_1.useAuthStore; } });
+var assetStore_1 = require("./stores/assetStore");
+Object.defineProperty(exports, "useAssetStore", { enumerable: true, get: function () { return assetStore_1.useAssetStore; } });
+Object.defineProperty(exports, "useAssetsStore", { enumerable: true, get: function () { return assetStore_1.useAssets; } });
+Object.defineProperty(exports, "useAsset", { enumerable: true, get: function () { return assetStore_1.useAsset; } });
+Object.defineProperty(exports, "useUploadProgress", { enumerable: true, get: function () { return assetStore_1.useUploadProgress; } });
+Object.defineProperty(exports, "useAssetLoading", { enumerable: true, get: function () { return assetStore_1.useAssetLoading; } });
+Object.defineProperty(exports, "useAssetErrors", { enumerable: true, get: function () { return assetStore_1.useAssetErrors; } });
+Object.defineProperty(exports, "useAssetsByApp", { enumerable: true, get: function () { return assetStore_1.useAssetsByApp; } });
+Object.defineProperty(exports, "useAssetsByEntity", { enumerable: true, get: function () { return assetStore_1.useAssetsByEntity; } });
+Object.defineProperty(exports, "useAssetUsageCount", { enumerable: true, get: function () { return assetStore_1.useAssetUsageCount; } });
+Object.defineProperty(exports, "useIsAssetLinked", { enumerable: true, get: function () { return assetStore_1.useIsAssetLinked; } });
+// --- Query Hooks ---
+var queries_1 = require("./hooks/queries");
+Object.defineProperty(exports, "useUserProfile", { enumerable: true, get: function () { return queries_1.useUserProfile; } });
+Object.defineProperty(exports, "useUserProfiles", { enumerable: true, get: function () { return queries_1.useUserProfiles; } });
+Object.defineProperty(exports, "useCurrentUser", { enumerable: true, get: function () { return queries_1.useCurrentUser; } });
+Object.defineProperty(exports, "useUserById", { enumerable: true, get: function () { return queries_1.useUserById; } });
+Object.defineProperty(exports, "useUserByUsername", { enumerable: true, get: function () { return queries_1.useUserByUsername; } });
+Object.defineProperty(exports, "useUsersBySessions", { enumerable: true, get: function () { return queries_1.useUsersBySessions; } });
+Object.defineProperty(exports, "usePrivacySettings", { enumerable: true, get: function () { return queries_1.usePrivacySettings; } });
+Object.defineProperty(exports, "useSessions", { enumerable: true, get: function () { return queries_1.useSessions; } });
+Object.defineProperty(exports, "useSession", { enumerable: true, get: function () { return queries_1.useSession; } });
+Object.defineProperty(exports, "useDeviceSessions", { enumerable: true, get: function () { return queries_1.useDeviceSessions; } });
+Object.defineProperty(exports, "useUserDevices", { enumerable: true, get: function () { return queries_1.useUserDevices; } });
+Object.defineProperty(exports, "useSecurityInfo", { enumerable: true, get: function () { return queries_1.useSecurityInfo; } });
+Object.defineProperty(exports, "useSecurityActivity", { enumerable: true, get: function () { return queries_1.useSecurityActivity; } });
+Object.defineProperty(exports, "useRecentSecurityActivity", { enumerable: true, get: function () { return queries_1.useRecentSecurityActivity; } });
+// --- Mutation Hooks ---
+var mutations_1 = require("./hooks/mutations");
+Object.defineProperty(exports, "useUpdateProfile", { enumerable: true, get: function () { return mutations_1.useUpdateProfile; } });
+Object.defineProperty(exports, "useUploadAvatar", { enumerable: true, get: function () { return mutations_1.useUploadAvatar; } });
+Object.defineProperty(exports, "useUpdateAccountSettings", { enumerable: true, get: function () { return mutations_1.useUpdateAccountSettings; } });
+Object.defineProperty(exports, "useUpdatePrivacySettings", { enumerable: true, get: function () { return mutations_1.useUpdatePrivacySettings; } });
+Object.defineProperty(exports, "useUploadFile", { enumerable: true, get: function () { return mutations_1.useUploadFile; } });
+Object.defineProperty(exports, "useSwitchSession", { enumerable: true, get: function () { return mutations_1.useSwitchSession; } });
+Object.defineProperty(exports, "useLogoutSession", { enumerable: true, get: function () { return mutations_1.useLogoutSession; } });
+Object.defineProperty(exports, "useLogoutAll", { enumerable: true, get: function () { return mutations_1.useLogoutAll; } });
+Object.defineProperty(exports, "useUpdateDeviceName", { enumerable: true, get: function () { return mutations_1.useUpdateDeviceName; } });
+Object.defineProperty(exports, "useRemoveDevice", { enumerable: true, get: function () { return mutations_1.useRemoveDevice; } });
+var mutationFactory_1 = require("./hooks/mutations/mutationFactory");
+Object.defineProperty(exports, "createProfileMutation", { enumerable: true, get: function () { return mutationFactory_1.createProfileMutation; } });
+Object.defineProperty(exports, "createGenericMutation", { enumerable: true, get: function () { return mutationFactory_1.createGenericMutation; } });
+// --- Custom Hooks ---
+var useSessionSocket_1 = require("./hooks/useSessionSocket");
+Object.defineProperty(exports, "useSessionSocket", { enumerable: true, get: function () { return useSessionSocket_1.useSessionSocket; } });
+var useAssets_1 = require("./hooks/useAssets");
+Object.defineProperty(exports, "useAssets", { enumerable: true, get: function () { return useAssets_1.useAssets; } });
+Object.defineProperty(exports, "setOxyAssetInstance", { enumerable: true, get: function () { return useAssets_1.setOxyAssetInstance; } });
+var useFileDownloadUrl_1 = require("./hooks/useFileDownloadUrl");
+Object.defineProperty(exports, "useFileDownloadUrl", { enumerable: true, get: function () { return useFileDownloadUrl_1.useFileDownloadUrl; } });
+Object.defineProperty(exports, "setOxyFileUrlInstance", { enumerable: true, get: function () { return useFileDownloadUrl_1.setOxyFileUrlInstance; } });
+var useFollow_1 = require("./hooks/useFollow");
+Object.defineProperty(exports, "useFollow", { enumerable: true, get: function () { return useFollow_1.useFollow; } });
+Object.defineProperty(exports, "useFollowerCounts", { enumerable: true, get: function () { return useFollow_1.useFollowerCounts; } });
+var useFileFiltering_1 = require("./hooks/useFileFiltering");
+Object.defineProperty(exports, "useFileFiltering", { enumerable: true, get: function () { return useFileFiltering_1.useFileFiltering; } });
+// --- Auth Helpers ---
+var authHelpers_1 = require("./utils/authHelpers");
+Object.defineProperty(exports, "ensureValidToken", { enumerable: true, get: function () { return authHelpers_1.ensureValidToken; } });
+Object.defineProperty(exports, "withAuthErrorHandling", { enumerable: true, get: function () { return authHelpers_1.withAuthErrorHandling; } });
+Object.defineProperty(exports, "authenticatedApiCall", { enumerable: true, get: function () { return authHelpers_1.authenticatedApiCall; } });
+Object.defineProperty(exports, "isAuthenticationError", { enumerable: true, get: function () { return authHelpers_1.isAuthenticationError; } });
+Object.defineProperty(exports, "SessionSyncRequiredError", { enumerable: true, get: function () { return authHelpers_1.SessionSyncRequiredError; } });
+Object.defineProperty(exports, "AuthenticationFailedError", { enumerable: true, get: function () { return authHelpers_1.AuthenticationFailedError; } });
+// --- Error Handlers ---
+var errorHandlers_1 = require("./utils/errorHandlers");
+Object.defineProperty(exports, "handleAuthError", { enumerable: true, get: function () { return errorHandlers_1.handleAuthError; } });
+Object.defineProperty(exports, "isInvalidSessionError", { enumerable: true, get: function () { return errorHandlers_1.isInvalidSessionError; } });
+Object.defineProperty(exports, "isTimeoutOrNetworkError", { enumerable: true, get: function () { return errorHandlers_1.isTimeoutOrNetworkError; } });
+Object.defineProperty(exports, "extractErrorMessage", { enumerable: true, get: function () { return errorHandlers_1.extractErrorMessage; } });
+// Re-export core for convenience
+var core_1 = require("@oxyhq/core");
+Object.defineProperty(exports, "OxyServices", { enumerable: true, get: function () { return core_1.OxyServices; } });
+Object.defineProperty(exports, "CrossDomainAuth", { enumerable: true, get: function () { return core_1.CrossDomainAuth; } });
+Object.defineProperty(exports, "AuthManager", { enumerable: true, get: function () { return core_1.AuthManager; } });
+Object.defineProperty(exports, "createAuthManager", { enumerable: true, get: function () { return core_1.createAuthManager; } });
+Object.defineProperty(exports, "createCrossDomainAuth", { enumerable: true, get: function () { return core_1.createCrossDomainAuth; } });
+const WebOxyProvider_2 = require("./WebOxyProvider");
+exports.default = WebOxyProvider_2.WebOxyProvider;

package/dist/cjs/stores/accountStore.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAccountLoadingSession = exports.useAccountError = exports.useAccountLoading = exports.useAccounts = exports.useAccountStore = void 0;
+const zustand_1 = require("zustand");
+const initialState = {
+    accounts: {},
+    accountOrder: [],
+    accountsArray: [],
+    loading: false,
+    loadingSessionIds: new Set(),
+    error: null,
+};
+// Helper: Build accounts array from accounts map and order
+const buildAccountsArray = (accounts, order) => {
+    const result = [];
+    for (const id of order) {
+        const account = accounts[id];
+        if (account)
+            result.push(account);
+    }
+    return result;
+};
+// Helper: Create QuickAccount from user data
+const createQuickAccount = (sessionId, userData, existingAccount, oxyServices) => {
+    const displayName = userData.name?.full || userData.name?.first || userData.username || 'Account';
+    const userId = userData.id || userData._id?.toString();
+    // Preserve existing avatarUrl if avatar hasn't changed (prevents image reload)
+    let avatarUrl;
+    if (existingAccount && existingAccount.avatar === userData.avatar && existingAccount.avatarUrl) {
+        avatarUrl = existingAccount.avatarUrl; // Reuse existing URL
+    }
+    else if (userData.avatar && oxyServices) {
+        avatarUrl = oxyServices.getFileDownloadUrl(userData.avatar, 'thumb');
+    }
+    return {
+        sessionId,
+        userId,
+        username: userData.username || '',
+        displayName,
+        avatar: userData.avatar,
+        avatarUrl,
+    };
+};
+exports.useAccountStore = (0, zustand_1.create)((set, get) => ({
+    ...initialState,
+    setAccounts: (accounts) => set((state) => {
+        const accountMap = {};
+        const order = [];
+        const seenSessionIds = new Set();
+        for (const account of accounts) {
+            if (seenSessionIds.has(account.sessionId))
+                continue;
+            seenSessionIds.add(account.sessionId);
+            accountMap[account.sessionId] = account;
+            order.push(account.sessionId);
+        }
+        const accountsArray = buildAccountsArray(accountMap, order);
+        const sameOrder = order.length === state.accountOrder.length &&
+            order.every((id, i) => id === state.accountOrder[i]);
+        const sameAccounts = sameOrder &&
+            order.every(id => {
+                const existing = state.accounts[id];
+                const newAccount = accountMap[id];
+                return existing &&
+                    existing.sessionId === newAccount.sessionId &&
+                    existing.userId === newAccount.userId &&
+                    existing.avatar === newAccount.avatar &&
+                    existing.avatarUrl === newAccount.avatarUrl;
+            });
+        if (sameAccounts)
+            return {};
+        return { accounts: accountMap, accountOrder: order, accountsArray };
+    }),
+    addAccount: (account) => set((state) => {
+        // Check if account with same sessionId exists
+        if (state.accounts[account.sessionId]) {
+            // Update existing
+            const existing = state.accounts[account.sessionId];
+            if (existing.avatar === account.avatar && existing.avatarUrl === account.avatarUrl) {
+                return {}; // No change
+            }
+            const newAccounts = { ...state.accounts, [account.sessionId]: account };
+            return {
+                accounts: newAccounts,
+                accountsArray: buildAccountsArray(newAccounts, state.accountOrder),
+            };
+        }
+        const newAccounts = { ...state.accounts, [account.sessionId]: account };
+        const newOrder = [account.sessionId, ...state.accountOrder];
+        return {
+            accounts: newAccounts,
+            accountOrder: newOrder,
+            accountsArray: buildAccountsArray(newAccounts, newOrder),
+        };
+    }),
+    updateAccount: (sessionId, updates) => set((state) => {
+        const existing = state.accounts[sessionId];
+        if (!existing)
+            return {};
+        const updated = { ...existing, ...updates };
+        if (existing.avatar === updated.avatar && existing.avatarUrl === updated.avatarUrl) {
+            return {}; // No change
+        }
+        const newAccounts = { ...state.accounts, [sessionId]: updated };
+        return {
+            accounts: newAccounts,
+            accountsArray: buildAccountsArray(newAccounts, state.accountOrder),
+        };
+    }),
+    removeAccount: (sessionId) => set((state) => {
+        if (!state.accounts[sessionId])
+            return {};
+        const { [sessionId]: _removed, ...rest } = state.accounts;
+        const newOrder = state.accountOrder.filter(id => id !== sessionId);
+        return {
+            accounts: rest,
+            accountOrder: newOrder,
+            accountsArray: buildAccountsArray(rest, newOrder),
+        };
+    }),
+    moveAccountToTop: (sessionId) => set((state) => {
+        if (!state.accounts[sessionId])
+            return {};
+        const filtered = state.accountOrder.filter(id => id !== sessionId);
+        const newOrder = [sessionId, ...filtered];
+        return {
+            accountOrder: newOrder,
+            accountsArray: buildAccountsArray(state.accounts, newOrder),
+        };
+    }),
+    setLoading: (loading) => set({ loading }),
+    setLoadingSession: (sessionId, loading) => set((state) => {
+        const newSet = new Set(state.loadingSessionIds);
+        if (loading) {
+            newSet.add(sessionId);
+        }
+        else {
+            newSet.delete(sessionId);
+        }
+        return { loadingSessionIds: newSet };
+    }),
+    setError: (error) => set({ error }),
+    loadAccounts: async (sessionIds, oxyServices, existingAccounts = [], preserveOrder = true) => {
+        const state = get();
+        const uniqueSessionIds = Array.from(new Set(sessionIds));
+        if (uniqueSessionIds.length === 0) {
+            get().setAccounts([]);
+            return;
+        }
+        // Try to get data from TanStack Query cache first
+        try {
+            // This will be called from a component, so we need to access queryClient differently
+            // For now, we'll keep the API call but optimize it
+            const existingMap = new Map(existingAccounts.map(a => [a.sessionId, a]));
+            for (const account of Object.values(state.accounts)) {
+                existingMap.set(account.sessionId, account);
+            }
+            const missingSessionIds = uniqueSessionIds.filter(id => !existingMap.has(id));
+            if (missingSessionIds.length === 0) {
+                const ordered = uniqueSessionIds
+                    .map(id => existingMap.get(id))
+                    .filter((acc) => acc !== undefined);
+                get().setAccounts(ordered);
+                return;
+            }
+            if (state.loading) {
+                return;
+            }
+            set({ loading: true, error: null });
+            try {
+                const batchResults = await oxyServices.getUsersBySessions(missingSessionIds);
+                const accountMap = new Map();
+                for (const { sessionId, user: userData } of batchResults) {
+                    if (userData && !accountMap.has(sessionId)) {
+                        const existing = existingMap.get(sessionId);
+                        accountMap.set(sessionId, createQuickAccount(sessionId, userData, existing, oxyServices));
+                    }
+                }
+                for (const [sessionId, account] of accountMap) {
+                    existingMap.set(sessionId, account);
+                }
+                const orderToUse = preserveOrder ? uniqueSessionIds : [...uniqueSessionIds, ...state.accountOrder];
+                const seen = new Set();
+                const ordered = [];
+                for (const sessionId of orderToUse) {
+                    if (seen.has(sessionId))
+                        continue;
+                    seen.add(sessionId);
+                    const account = existingMap.get(sessionId);
+                    if (account)
+                        ordered.push(account);
+                }
+                get().setAccounts(ordered);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Failed to load accounts';
+                if (__DEV__) {
+                    console.error('AccountStore: Failed to load accounts:', error);
+                }
+                set({ error: errorMessage });
+            }
+            finally {
+                set({ loading: false });
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Failed to load accounts';
+            if (__DEV__) {
+                console.error('AccountStore: Failed to load accounts:', error);
+            }
+            set({ error: errorMessage, loading: false });
+        }
+    },
+    reset: () => set(initialState),
+}));
+// Selectors for performance - return cached array to prevent infinite loops
+const useAccounts = () => {
+    return (0, exports.useAccountStore)(state => state.accountsArray);
+};
+exports.useAccounts = useAccounts;
+const useAccountLoading = () => (0, exports.useAccountStore)(s => s.loading);
+exports.useAccountLoading = useAccountLoading;
+const useAccountError = () => (0, exports.useAccountStore)(s => s.error);
+exports.useAccountError = useAccountError;
+const useAccountLoadingSession = (sessionId) => (0, exports.useAccountStore)(s => s.loadingSessionIds.has(sessionId));
+exports.useAccountLoadingSession = useAccountLoadingSession;

package/dist/cjs/stores/assetStore.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useIsAssetLinked = exports.useAssetUsageCount = exports.useAssetsByEntity = exports.useAssetsByApp = exports.useAssetErrors = exports.useAssetLoading = exports.useUploadProgress = exports.useAsset = exports.useAssets = exports.useAssetStore = void 0;
+const zustand_1 = require("zustand");
+const initialState = {
+    assets: {},
+    uploadProgress: {},
+    loading: {
+        uploading: false,
+        linking: false,
+        deleting: false,
+    },
+    errors: {},
+};
+exports.useAssetStore = (0, zustand_1.create)((set, get) => ({
+    ...initialState,
+    // Asset management
+    setAsset: (asset) => {
+        set((state) => ({
+            assets: {
+                ...state.assets,
+                [asset.id]: asset,
+            },
+        }));
+    },
+    setAssets: (assets) => {
+        set((state) => {
+            const assetMap = assets.reduce((acc, asset) => {
+                acc[asset.id] = asset;
+                return acc;
+            }, {});
+            return {
+                assets: {
+                    ...state.assets,
+                    ...assetMap,
+                },
+            };
+        });
+    },
+    removeAsset: (assetId) => {
+        set((state) => {
+            const { [assetId]: removed, ...rest } = state.assets;
+            return { assets: rest };
+        });
+    },
+    // Upload progress
+    setUploadProgress: (fileId, progress) => {
+        set((state) => ({
+            uploadProgress: {
+                ...state.uploadProgress,
+                [fileId]: progress,
+            },
+        }));
+    },
+    removeUploadProgress: (fileId) => {
+        set((state) => {
+            const { [fileId]: removed, ...rest } = state.uploadProgress;
+            return { uploadProgress: rest };
+        });
+    },
+    // Link management
+    addLink: (assetId, link) => {
+        set((state) => {
+            const asset = state.assets[assetId];
+            if (!asset)
+                return state;
+            // Check if link already exists
+            const existingLink = asset.links.find((l) => l.app === link.app &&
+                l.entityType === link.entityType &&
+                l.entityId === link.entityId);
+            if (existingLink)
+                return state;
+            const updatedAsset = {
+                ...asset,
+                links: [...asset.links, link],
+                usageCount: asset.links.length + 1,
+            };
+            return {
+                assets: {
+                    ...state.assets,
+                    [assetId]: updatedAsset,
+                },
+            };
+        });
+    },
+    removeLink: (assetId, app, entityType, entityId) => {
+        set((state) => {
+            const asset = state.assets[assetId];
+            if (!asset)
+                return state;
+            const filteredLinks = asset.links.filter((link) => !(link.app === app &&
+                link.entityType === entityType &&
+                link.entityId === entityId));
+            const updatedAsset = {
+                ...asset,
+                links: filteredLinks,
+                usageCount: filteredLinks.length,
+                status: filteredLinks.length === 0 ? 'trash' : asset.status,
+            };
+            return {
+                assets: {
+                    ...state.assets,
+                    [assetId]: updatedAsset,
+                },
+            };
+        });
+    },
+    // Loading states
+    setUploading: (uploading) => {
+        set((state) => ({
+            loading: { ...state.loading, uploading },
+        }));
+    },
+    setLinking: (linking) => {
+        set((state) => ({
+            loading: { ...state.loading, linking },
+        }));
+    },
+    setDeleting: (deleting) => {
+        set((state) => ({
+            loading: { ...state.loading, deleting },
+        }));
+    },
+    // Error management
+    setUploadError: (error) => {
+        set((state) => ({
+            errors: { ...state.errors, upload: error },
+        }));
+    },
+    setLinkError: (error) => {
+        set((state) => ({
+            errors: { ...state.errors, link: error },
+        }));
+    },
+    setDeleteError: (error) => {
+        set((state) => ({
+            errors: { ...state.errors, delete: error },
+        }));
+    },
+    clearErrors: () => {
+        set({ errors: {} });
+    },
+    // Utility methods
+    getAssetsByApp: (app) => {
+        const { assets } = get();
+        return Object.values(assets).filter((asset) => asset.links.some((link) => link.app === app));
+    },
+    getAssetsByEntity: (app, entityType, entityId) => {
+        const { assets } = get();
+        return Object.values(assets).filter((asset) => asset.links.some((link) => link.app === app &&
+            link.entityType === entityType &&
+            link.entityId === entityId));
+    },
+    getAssetUsageCount: (assetId) => {
+        const { assets } = get();
+        const asset = assets[assetId];
+        return asset ? asset.usageCount : 0;
+    },
+    isAssetLinked: (assetId, app, entityType, entityId) => {
+        const { assets } = get();
+        const asset = assets[assetId];
+        if (!asset)
+            return false;
+        return asset.links.some((link) => link.app === app &&
+            link.entityType === entityType &&
+            link.entityId === entityId);
+    },
+    // Reset store
+    reset: () => {
+        set(initialState);
+    },
+}));
+// Selector hooks for convenience
+const useAssets = () => (0, exports.useAssetStore)((state) => Object.values(state.assets));
+exports.useAssets = useAssets;
+const useAsset = (assetId) => (0, exports.useAssetStore)((state) => state.assets[assetId]);
+exports.useAsset = useAsset;
+const useUploadProgress = () => (0, exports.useAssetStore)((state) => state.uploadProgress);
+exports.useUploadProgress = useUploadProgress;
+const useAssetLoading = () => (0, exports.useAssetStore)((state) => state.loading);
+exports.useAssetLoading = useAssetLoading;
+const useAssetErrors = () => (0, exports.useAssetStore)((state) => state.errors);
+exports.useAssetErrors = useAssetErrors;
+// Typed selectors for specific use cases
+const useAssetsByApp = (app) => (0, exports.useAssetStore)((state) => state.getAssetsByApp(app));
+exports.useAssetsByApp = useAssetsByApp;
+const useAssetsByEntity = (app, entityType, entityId) => (0, exports.useAssetStore)((state) => state.getAssetsByEntity(app, entityType, entityId));
+exports.useAssetsByEntity = useAssetsByEntity;
+const useAssetUsageCount = (assetId) => (0, exports.useAssetStore)((state) => state.getAssetUsageCount(assetId));
+exports.useAssetUsageCount = useAssetUsageCount;
+const useIsAssetLinked = (assetId, app, entityType, entityId) => (0, exports.useAssetStore)((state) => state.isAssetLinked(assetId, app, entityType, entityId));
+exports.useIsAssetLinked = useIsAssetLinked;