@object-ui/app-shell 4.4.0 → 4.6.0

package/dist/context/FavoritesProvider.js

@@ -5,39 +5,38 @@ import { jsx as _jsx } from "react/jsx-runtime";
  * React Context + Provider for shared favorites state across all consumers
  * (HomePage, AppCard, AppSidebar, UnifiedSidebar, StarredApps).
  *
- * Replaces the standalone `useFavorites` hook pattern — all callers now share
- * a single state instance so that toggling a star in AppCard immediately
- * reflects in HomePage's Starred section and sidebar.
- *
- * Persistence: localStorage (key: "objectui-favorites", max 20 items).
- *
- * TODO: Migrate persistence to server-side storage via the adapter/API layer
- * (e.g. PUT /api/user/preferences) so favorites sync across devices and browsers.
- * The provider should accept an optional `persistenceAdapter` prop that implements
- * `load(): Promise<FavoriteItem[]>` and `save(items: FavoriteItem[]): Promise<void>`.
- * When the adapter is provided, localStorage should be used only as a fallback
- * during the initial load while the server response is in-flight.
+ * Persistence is **localStorage-first** with optional backend hydration:
+ * - On mount we render synchronously from localStorage (no flash of empty UI).
+ * - If a `UserDataAdapter<FavoriteItem>` is attached via `UserStateAdaptersProvider`
+ *   (see `./UserStateAdapters`), the provider hydrates from the backend and
+ *   writes-through every mutation through a debounced `adapter.save()`.
+ * - localStorage stays in sync so offline / pre-auth sessions still work and
+ *   gives an instant first paint after sign-in.
+ * - The local key is scoped per `user.id` so different accounts on the same
+ *   browser don't cross-contaminate.
  *
  * @module
  */
-import { createContext, useCallback, useContext, useEffect, useMemo, useState, } from 'react';
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, } from 'react';
+import { useAuth } from '@object-ui/auth';
+import { createDebouncedFlush, scopedKey, useStorageSync, useUserStateAdapter, } from './UserStateAdapters';
 // ---------------------------------------------------------------------------
 // Storage helpers
 // ---------------------------------------------------------------------------
-const STORAGE_KEY = 'objectui-favorites';
+const STORAGE_BASE_KEY = 'objectui-favorites';
 const MAX_FAVORITES = 20;
-function loadFavorites() {
+function loadFavorites(userId) {
     try {
-        const raw = localStorage.getItem(STORAGE_KEY);
+        const raw = localStorage.getItem(scopedKey(STORAGE_BASE_KEY, userId));
         return raw ? JSON.parse(raw) : [];
     }
     catch {
         return [];
     }
 }
-function saveFavorites(items) {
+function saveFavorites(items, userId) {
     try {
-        localStorage.setItem(STORAGE_KEY, JSON.stringify(items));
+        localStorage.setItem(scopedKey(STORAGE_BASE_KEY, userId), JSON.stringify(items));
     }
     catch {
         // Storage full — silently ignore
@@ -48,12 +47,64 @@ function saveFavorites(items) {
 // ---------------------------------------------------------------------------
 const FavoritesContext = createContext(null);
 export function FavoritesProvider({ children }) {
-    const [favorites, setFavorites] = useState(loadFavorites);
-    // Re-sync from storage on mount (handles cases where storage was written
-    // before this provider was mounted, e.g. on initial page load).
+    const { user } = useAuth();
+    const userId = user?.id ?? null;
+    const adapter = useUserStateAdapter('favorites');
+    const [favorites, setFavorites] = useState(() => loadFavorites(userId));
+    // Re-load from localStorage whenever the active user changes (sign-in /
+    // account switch). Prevents one account from seeing another's favorites.
     useEffect(() => {
-        setFavorites(loadFavorites());
-    }, []);
+        setFavorites(loadFavorites(userId));
+    }, [userId]);
+    // Cross-tab sync: when another tab writes the same scoped key, mirror the
+    // change locally. `storage` events do not fire in the tab that wrote them,
+    // so this never echoes our own mutations.
+    useStorageSync(scopedKey(STORAGE_BASE_KEY, userId), value => {
+        setFavorites(Array.isArray(value)
+            ? value.filter(it => it && typeof it.id === 'string').slice(0, MAX_FAVORITES)
+            : []);
+    });
+    // Hydrate from backend whenever an adapter is attached (or user changes).
+    // Backend wins on conflict; we then write through to localStorage so the
+    // next reload is instant.
+    const hydrationToken = useRef(0);
+    useEffect(() => {
+        if (!adapter)
+            return;
+        const token = ++hydrationToken.current;
+        let cancelled = false;
+        void (async () => {
+            try {
+                const remote = await adapter.load();
+                if (cancelled || token !== hydrationToken.current)
+                    return;
+                // Defensive sanitize: drop unparseable shapes, enforce cap.
+                const sane = (Array.isArray(remote) ? remote : [])
+                    .filter(it => it && typeof it.id === 'string')
+                    .slice(0, MAX_FAVORITES);
+                setFavorites(sane);
+                saveFavorites(sane, userId);
+            }
+            catch {
+                // Keep localStorage state — adapter degrade-to-noop is acceptable.
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [adapter, userId]);
+    // Debounced write-through to backend.
+    const flusher = useMemo(() => createDebouncedFlush(async (items) => {
+        if (adapter)
+            await adapter.save(items);
+    }, 500), [adapter]);
+    // Flush pending writes when the adapter detaches / user changes.
+    useEffect(() => () => { void flusher.flush(); }, [flusher]);
+    const commit = useCallback((next) => {
+        saveFavorites(next, userId);
+        if (adapter)
+            flusher.schedule(next);
+    }, [userId, adapter, flusher]);
     const addFavorite = useCallback((item) => {
         setFavorites(prev => {
             if (prev.some(f => f.id === item.id))
@@ -62,44 +113,39 @@ export function FavoritesProvider({ children }) {
                 { ...item, favoritedAt: new Date().toISOString() },
                 ...prev,
             ].slice(0, MAX_FAVORITES);
-            saveFavorites(updated);
+            commit(updated);
             return updated;
         });
-    }, []);
+    }, [commit]);
     const removeFavorite = useCallback((id) => {
         setFavorites(prev => {
             const updated = prev.filter(f => f.id !== id);
-            saveFavorites(updated);
+            commit(updated);
             return updated;
         });
-    }, []);
+    }, [commit]);
     const toggleFavorite = useCallback((item) => {
         setFavorites(prev => {
             const exists = prev.some(f => f.id === item.id);
             const updated = exists
                 ? prev.filter(f => f.id !== item.id)
                 : [{ ...item, favoritedAt: new Date().toISOString() }, ...prev].slice(0, MAX_FAVORITES);
-            saveFavorites(updated);
+            commit(updated);
             return updated;
         });
-    }, []);
+    }, [commit]);
     const clearFavorites = useCallback(() => {
         setFavorites([]);
-        saveFavorites([]);
-    }, []);
+        commit([]);
+    }, [commit]);
     const value = useMemo(() => ({
         favorites,
         addFavorite,
         removeFavorite,
         toggleFavorite,
-        // Inlined here so useMemo sees the freshest `favorites` without needing
-        // a separate useCallback([favorites]) entry in the deps array.
         isFavorite: (id) => favorites.some(f => f.id === id),
         clearFavorites,
-    }), 
-    // addFavorite / removeFavorite / toggleFavorite / clearFavorites are all
-    // stable (useCallback with [] deps) and never cause extra re-renders.
-    [favorites, addFavorite, removeFavorite, toggleFavorite, clearFavorites]);
+    }), [favorites, addFavorite, removeFavorite, toggleFavorite, clearFavorites]);
     return (_jsx(FavoritesContext.Provider, { value: value, children: children }));
 }
 // ---------------------------------------------------------------------------

package/dist/context/RecentItemsProvider.d.ts

@@ -0,0 +1,45 @@
+/**
+ * RecentItemsProvider
+ *
+ * Shared "recently-accessed" state with optional backend persistence. Mirrors
+ * the design of `FavoritesProvider`:
+ *
+ * - localStorage-first: instant first paint, works offline / pre-auth.
+ * - Hydrates from `UserDataAdapter<RecentItem>` when one is attached via
+ *   `UserStateAdaptersProvider` (typically by `ConnectedShell`'s bridge).
+ * - Writes are debounced and pushed to the adapter; localStorage stays in
+ *   sync as a cold-start cache.
+ * - Storage key is scoped by `user.id` to avoid cross-account leakage.
+ *
+ * The legacy `useRecentItems()` import path (`hooks/useRecentItems`) is
+ * preserved via a re-export shim so existing call sites keep working.
+ *
+ * @module
+ */
+import { type ReactNode } from 'react';
+export interface RecentItem {
+    /** Unique key, e.g. "object:contact" or "dashboard:sales_overview" */
+    id: string;
+    label: string;
+    href: string;
+    type: 'object' | 'dashboard' | 'page' | 'report' | 'record';
+    /** ISO timestamp of last visit */
+    visitedAt: string;
+}
+interface RecentItemsContextValue {
+    recentItems: RecentItem[];
+    addRecentItem: (item: Omit<RecentItem, 'visitedAt'>) => void;
+    clearRecentItems: () => void;
+}
+export declare function RecentItemsProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Access shared "recently-accessed" state.
+ *
+ * Falls back to a no-op implementation when used outside a
+ * `<RecentItemsProvider>` (e.g. unit tests that only render presentational
+ * components).
+ */
+export declare function useRecentItems(): RecentItemsContextValue;
+export {};

package/dist/context/RecentItemsProvider.js

@@ -0,0 +1,139 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * RecentItemsProvider
+ *
+ * Shared "recently-accessed" state with optional backend persistence. Mirrors
+ * the design of `FavoritesProvider`:
+ *
+ * - localStorage-first: instant first paint, works offline / pre-auth.
+ * - Hydrates from `UserDataAdapter<RecentItem>` when one is attached via
+ *   `UserStateAdaptersProvider` (typically by `ConnectedShell`'s bridge).
+ * - Writes are debounced and pushed to the adapter; localStorage stays in
+ *   sync as a cold-start cache.
+ * - Storage key is scoped by `user.id` to avoid cross-account leakage.
+ *
+ * The legacy `useRecentItems()` import path (`hooks/useRecentItems`) is
+ * preserved via a re-export shim so existing call sites keep working.
+ *
+ * @module
+ */
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, } from 'react';
+import { useAuth } from '@object-ui/auth';
+import { createDebouncedFlush, scopedKey, useStorageSync, useUserStateAdapter, } from './UserStateAdapters';
+// ---------------------------------------------------------------------------
+// Storage helpers
+// ---------------------------------------------------------------------------
+const STORAGE_BASE_KEY = 'objectui-recent-items';
+const MAX_RECENT = 8;
+function loadRecent(userId) {
+    try {
+        const raw = localStorage.getItem(scopedKey(STORAGE_BASE_KEY, userId));
+        return raw ? JSON.parse(raw) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function saveRecent(items, userId) {
+    try {
+        localStorage.setItem(scopedKey(STORAGE_BASE_KEY, userId), JSON.stringify(items));
+    }
+    catch {
+        // ignore
+    }
+}
+// ---------------------------------------------------------------------------
+// Context
+// ---------------------------------------------------------------------------
+const RecentItemsContext = createContext(null);
+// ---------------------------------------------------------------------------
+// Provider
+// ---------------------------------------------------------------------------
+export function RecentItemsProvider({ children }) {
+    const { user } = useAuth();
+    const userId = user?.id ?? null;
+    const adapter = useUserStateAdapter('recent');
+    const [recentItems, setRecentItems] = useState(() => loadRecent(userId));
+    useEffect(() => {
+        setRecentItems(loadRecent(userId));
+    }, [userId]);
+    // Cross-tab sync — see FavoritesProvider for the rationale.
+    useStorageSync(scopedKey(STORAGE_BASE_KEY, userId), value => {
+        setRecentItems(Array.isArray(value)
+            ? value.filter(it => it && typeof it.id === 'string').slice(0, MAX_RECENT)
+            : []);
+    });
+    const hydrationToken = useRef(0);
+    useEffect(() => {
+        if (!adapter)
+            return;
+        const token = ++hydrationToken.current;
+        let cancelled = false;
+        void (async () => {
+            try {
+                const remote = await adapter.load();
+                if (cancelled || token !== hydrationToken.current)
+                    return;
+                const sane = (Array.isArray(remote) ? remote : [])
+                    .filter(it => it && typeof it.id === 'string')
+                    .slice(0, MAX_RECENT);
+                setRecentItems(sane);
+                saveRecent(sane, userId);
+            }
+            catch {
+                // ignore — degrade to localStorage
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [adapter, userId]);
+    const flusher = useMemo(() => createDebouncedFlush(async (items) => {
+        if (adapter)
+            await adapter.save(items);
+    }, 500), [adapter]);
+    useEffect(() => () => { void flusher.flush(); }, [flusher]);
+    const commit = useCallback((next) => {
+        saveRecent(next, userId);
+        if (adapter)
+            flusher.schedule(next);
+    }, [userId, adapter, flusher]);
+    const addRecentItem = useCallback((item) => {
+        setRecentItems(prev => {
+            const filtered = prev.filter(r => r.id !== item.id);
+            const updated = [
+                { ...item, visitedAt: new Date().toISOString() },
+                ...filtered,
+            ].slice(0, MAX_RECENT);
+            commit(updated);
+            return updated;
+        });
+    }, [commit]);
+    const clearRecentItems = useCallback(() => {
+        setRecentItems([]);
+        commit([]);
+    }, [commit]);
+    const value = useMemo(() => ({ recentItems, addRecentItem, clearRecentItems }), [recentItems, addRecentItem, clearRecentItems]);
+    return (_jsx(RecentItemsContext.Provider, { value: value, children: children }));
+}
+// ---------------------------------------------------------------------------
+// Hook
+// ---------------------------------------------------------------------------
+/**
+ * Access shared "recently-accessed" state.
+ *
+ * Falls back to a no-op implementation when used outside a
+ * `<RecentItemsProvider>` (e.g. unit tests that only render presentational
+ * components).
+ */
+export function useRecentItems() {
+    const ctx = useContext(RecentItemsContext);
+    if (!ctx) {
+        return {
+            recentItems: [],
+            addRecentItem: () => { },
+            clearRecentItems: () => { },
+        };
+    }
+    return ctx;
+}

package/dist/context/UserStateAdapters.d.ts

@@ -0,0 +1,61 @@
+/**
+ * UserStateAdapters
+ *
+ * Injection point for backend persistence of per-user UI state (favorites,
+ * recently-accessed items, …). Keeps `FavoritesProvider` / `RecentItemsProvider`
+ * decoupled from any specific backend (REST, ObjectQL, GraphQL).
+ *
+ * The provider is stateful: a bridge component mounted lower in the tree
+ * (where the data adapter + authenticated user are available) calls
+ * `useAttachUserStateAdapters()` to inject adapters at runtime. While no
+ * adapter is attached, hosting providers transparently fall back to
+ * localStorage-only behaviour.
+ *
+ * @module
+ */
+import { type ReactNode } from 'react';
+/**
+ * Generic persistence adapter for a user-scoped list.
+ *
+ * Implementations must be safe to call concurrently and should *never*
+ * throw — failures should be swallowed so the hosting provider can degrade
+ * to localStorage-only mode without crashing the UI.
+ */
+export interface UserDataAdapter<T> {
+    /** Load the persisted list for the current user. Resolve to [] when absent. */
+    load(): Promise<T[]>;
+    /** Persist the full list (debounced upstream). Errors are silently ignored. */
+    save(items: T[]): Promise<void>;
+}
+export type UserStateKind = 'favorites' | 'recent';
+export declare function UserStateAdaptersProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/** Read the currently-attached adapter for a given kind. */
+export declare function useUserStateAdapter<T>(kind: UserStateKind): UserDataAdapter<T> | null;
+/**
+ * Imperative API used by bridge components to plug an adapter in/out.
+ * Returns a stable function across re-renders.
+ */
+export declare function useAttachUserStateAdapters(): (kind: UserStateKind, adapter: UserDataAdapter<any> | null) => void;
+/**
+ * Build a user-scoped localStorage key. Falls back to the unscoped key for
+ * unauthenticated / preview sessions to preserve current behaviour.
+ */
+export declare function scopedKey(base: string, userId?: string | null): string;
+/**
+ * Subscribe to cross-tab updates of a specific localStorage key. The browser
+ * fires `storage` events only in *other* tabs, so we never echo our own
+ * writes. `onValue` receives the parsed JSON payload (or null if the key was
+ * removed / unparseable).
+ */
+export declare function useStorageSync<T>(key: string, onValue: (value: T | null) => void): void;
+/**
+ * Tiny debounced flush helper. Returns `{ schedule, flush, cancel }`.
+ * Designed for the "save full list to backend" pattern.
+ */
+export declare function createDebouncedFlush<T>(fn: (value: T) => Promise<void> | void, delayMs?: number): {
+    schedule: (value: T) => void;
+    flush: () => Promise<void>;
+    cancel: () => void;
+};

package/dist/context/UserStateAdapters.js

@@ -0,0 +1,141 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * UserStateAdapters
+ *
+ * Injection point for backend persistence of per-user UI state (favorites,
+ * recently-accessed items, …). Keeps `FavoritesProvider` / `RecentItemsProvider`
+ * decoupled from any specific backend (REST, ObjectQL, GraphQL).
+ *
+ * The provider is stateful: a bridge component mounted lower in the tree
+ * (where the data adapter + authenticated user are available) calls
+ * `useAttachUserStateAdapters()` to inject adapters at runtime. While no
+ * adapter is attached, hosting providers transparently fall back to
+ * localStorage-only behaviour.
+ *
+ * @module
+ */
+import { createContext, useCallback, useContext, useEffect, useRef, useState, } from 'react';
+// ---------------------------------------------------------------------------
+// Contexts (split read / write so consumers don't re-render unnecessarily)
+// ---------------------------------------------------------------------------
+const ReadCtx = createContext({ favorites: null, recent: null });
+const WriteCtx = createContext(null);
+// ---------------------------------------------------------------------------
+// Provider
+// ---------------------------------------------------------------------------
+export function UserStateAdaptersProvider({ children }) {
+    const [adapters, setAdapters] = useState({
+        favorites: null,
+        recent: null,
+    });
+    // Stable attach API so bridge useEffect deps don't churn.
+    const attachRef = useRef({
+        attach: (kind, adapter) => {
+            setAdapters(prev => (prev[kind] === adapter ? prev : { ...prev, [kind]: adapter }));
+        },
+    });
+    return (_jsx(WriteCtx.Provider, { value: attachRef.current, children: _jsx(ReadCtx.Provider, { value: adapters, children: children }) }));
+}
+// ---------------------------------------------------------------------------
+// Hooks
+// ---------------------------------------------------------------------------
+/** Read the currently-attached adapter for a given kind. */
+export function useUserStateAdapter(kind) {
+    return useContext(ReadCtx)[kind];
+}
+/**
+ * Imperative API used by bridge components to plug an adapter in/out.
+ * Returns a stable function across re-renders.
+ */
+export function useAttachUserStateAdapters() {
+    const ctx = useContext(WriteCtx);
+    return useCallback((kind, adapter) => {
+        ctx?.attach(kind, adapter);
+    }, [ctx]);
+}
+// ---------------------------------------------------------------------------
+// Shared helpers (used by FavoritesProvider / RecentItemsProvider)
+// ---------------------------------------------------------------------------
+/**
+ * Build a user-scoped localStorage key. Falls back to the unscoped key for
+ * unauthenticated / preview sessions to preserve current behaviour.
+ */
+export function scopedKey(base, userId) {
+    return userId ? `${base}:u:${userId}` : base;
+}
+/**
+ * Subscribe to cross-tab updates of a specific localStorage key. The browser
+ * fires `storage` events only in *other* tabs, so we never echo our own
+ * writes. `onValue` receives the parsed JSON payload (or null if the key was
+ * removed / unparseable).
+ */
+export function useStorageSync(key, onValue) {
+    // Keep the latest callback in a ref so re-renders of the caller don't
+    // tear down and re-add the window listener.
+    const cbRef = useRef(onValue);
+    cbRef.current = onValue;
+    useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        const handler = (e) => {
+            if (e.key !== key || e.storageArea !== localStorage)
+                return;
+            if (e.newValue == null) {
+                cbRef.current(null);
+                return;
+            }
+            try {
+                cbRef.current(JSON.parse(e.newValue));
+            }
+            catch {
+                cbRef.current(null);
+            }
+        };
+        window.addEventListener('storage', handler);
+        return () => window.removeEventListener('storage', handler);
+    }, [key]);
+}
+/**
+ * Tiny debounced flush helper. Returns `{ schedule, flush, cancel }`.
+ * Designed for the "save full list to backend" pattern.
+ */
+export function createDebouncedFlush(fn, delayMs = 500) {
+    let timer = null;
+    let pending = null;
+    let hasPending = false;
+    const flush = async () => {
+        if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        if (!hasPending)
+            return;
+        const payload = pending;
+        hasPending = false;
+        pending = null;
+        try {
+            await fn(payload);
+        }
+        catch {
+            // Swallow — adapter is responsible for its own error handling.
+        }
+    };
+    const schedule = (value) => {
+        pending = value;
+        hasPending = true;
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            timer = null;
+            void flush();
+        }, delayMs);
+    };
+    const cancel = () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = null;
+        hasPending = false;
+        pending = null;
+    };
+    return { schedule, flush, cancel };
+}

package/dist/context/index.d.ts

@@ -1,3 +1,7 @@
 export { NavigationProvider, useNavigationContext } from './NavigationContext';
 export { FavoritesProvider, useFavorites } from './FavoritesProvider';
 export type { FavoriteItem } from './FavoritesProvider';
+export { RecentItemsProvider, useRecentItems } from './RecentItemsProvider';
+export type { RecentItem } from './RecentItemsProvider';
+export { UserStateAdaptersProvider, useUserStateAdapter, useAttachUserStateAdapters, } from './UserStateAdapters';
+export type { UserDataAdapter, UserStateKind } from './UserStateAdapters';

package/dist/context/index.js

@@ -1,2 +1,4 @@
 export { NavigationProvider, useNavigationContext } from './NavigationContext';
 export { FavoritesProvider, useFavorites } from './FavoritesProvider';
+export { RecentItemsProvider, useRecentItems } from './RecentItemsProvider';
+export { UserStateAdaptersProvider, useUserStateAdapter, useAttachUserStateAdapters, } from './UserStateAdapters';

package/dist/hooks/index.d.ts

@@ -6,3 +6,4 @@ export { useObjectActions } from './useObjectActions';
 export { useRecentItems, type RecentItem } from './useRecentItems';
 export { useRecordApprovals, type ApprovalProcessLite, type ApprovalRequestLite } from './useRecordApprovals';
 export { useResponsiveSidebar } from './useResponsiveSidebar';
+export { useTrackRouteAsRecent, type UseTrackRouteAsRecentOptions } from './useTrackRouteAsRecent';

package/dist/hooks/index.js

@@ -6,3 +6,4 @@ export { useObjectActions } from './useObjectActions';
 export { useRecentItems } from './useRecentItems';
 export { useRecordApprovals } from './useRecordApprovals';
 export { useResponsiveSidebar } from './useResponsiveSidebar';
+export { useTrackRouteAsRecent } from './useTrackRouteAsRecent';

package/dist/hooks/useRecentItems.d.ts

@@ -1,21 +1,13 @@
 /**
- * useRecentItems
+ * useRecentItems — re-export shim
+ *
+ * The recent-items state has been migrated to a React Context so all consumers
+ * share a single state instance and can be backed by an optional backend
+ * persistence adapter. See `../context/RecentItemsProvider`.
+ *
+ * All existing imports of `useRecentItems` and `RecentItem` from this path
+ * continue to work without any changes at the call sites.
  *
- * Tracks recently visited items (objects, dashboards, pages) with
- * localStorage persistence. Exposes helpers to add and retrieve items.
  * @module
  */
-export interface RecentItem {
-    /** Unique key, e.g. "object:contact" or "dashboard:sales_overview" */
-    id: string;
-    label: string;
-    href: string;
-    type: 'object' | 'dashboard' | 'page' | 'report' | 'record';
-    /** ISO timestamp of last visit */
-    visitedAt: string;
-}
-export declare function useRecentItems(): {
-    recentItems: RecentItem[];
-    addRecentItem: (item: Omit<RecentItem, "visitedAt">) => void;
-    clearRecentItems: () => void;
-};
+export { useRecentItems, type RecentItem } from '../context/RecentItemsProvider';