:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
feat(mobile): keep recent analytics and inbox available offline (#127543)
Chris Volzerf372195baacb
diff --git a/products/mobile/app/_layout.tsx b/products/mobile/app/_layout.tsxindex 716ac5c41d8b..7688c0e9fb5a 100644--- a/products/mobile/app/_layout.tsx+++ b/products/mobile/app/_layout.tsx@@ -7,13 +7,13 @@ import { StyleSheet, View } from 'react-native'import { GestureHandlerRootView } from 'react-native-gesture-handler'import { KeyboardProvider } from 'react-native-keyboard-controller'import { SafeAreaProvider } from 'react-native-safe-area-context'-import { queryClient } from '@/api/queryClient'import { installAuthProvider, useAuthStore } from '@/auth/authStore'import { BootSplash } from '@/auth/BootSplash'import { SPLASH_TIMEOUT_MS, shouldHideSplash, useBootGate } from '@/auth/bootGate'import { useAuthRedirect } from '@/auth/useAuthRedirect'import { useDemoHydrated } from '@/demo/demoMode'+import { installOfflineCache } from '@/features/offlineCache'import '@/features/chat/draftPersistence'import { AiApprovalDialog } from '@/features/ai/AiApprovalDialog'import { useHedgehogWidgetSync } from '@/features/hedgehog/useHedgehogWidgetSync'@@ -33,6 +33,7 @@ export { RouteErrorBoundary as ErrorBoundary }SplashScreen.preventAutoHideAsync().catch(() => undefined)SplashScreen.setOptions({ fade: true, duration: 250 })installAuthProvider()+installOfflineCache()configureNotifications()initAnalytics()const bootStartedAt = Date.now()diff --git a/products/mobile/docs/ARCHITECTURE.md b/products/mobile/docs/ARCHITECTURE.mdindex 13790cb47b80..ad9db232f993 100644--- a/products/mobile/docs/ARCHITECTURE.md+++ b/products/mobile/docs/ARCHITECTURE.md@@ -196,6 +196,28 @@ Details per domain: [DATA.md](DATA.md), [HANDOFF.md](HANDOFF.md), [CHAT.md](CHAT- `usePushStore` (`src/features/notifications/pushStore.ts`, persisted): permission state andthe registered token.+## Offline read cache++`src/features/offlineCache.ts` scopes persistence to the verified account and project.+`src/api/readCache.ts` restores and tracks eligible TanStack queries.+`src/api/readCacheStore.ts` enforces limits and stores each entry through `src/lib/secureStorage.ts`.+Native builds use SecureStore; the web preview uses memory.++The allowlist covers aggregate Views and the first 20 Inbox rows, including signal counts.+It excludes report bodies, transcripts, actor rows, searches, SQL results, and mutations.+Inbox snapshots use a separate read-only query.++- **Limits:** 24-hour TTL, 24 entries per project, 32 KiB per entry, 128 KiB per project, and eight projects per account.+ Size limits measure UTF-8 JSON.+- **Freshness:** Preserve successful capture times across failed refreshes, metadata updates, and pagination.+ Query garbage collection leaves disk entries intact.+- **Restoration:** Require the matching host, user, and project. Keep newer live data.+ Retry failed reads before replacement saves resume.+- **Access:** Evict denied data from its original project, including late responses after a project switch.+ Missing Views scopes purge Views across the account. Sign-out clears the account cache.+- **Storage:** Write only changed entries. Serialize operations per key and journal unfinished chunks until cleanup succeeds.+ The adapter is shared with chat drafts; cache eviction preserves drafts.+## Module boundaries- `app/` imports screens only.diff --git a/products/mobile/src/api/readCache.test.ts b/products/mobile/src/api/readCache.test.tsnew file mode 100644index 000000000000..d3106c206c37--- /dev/null+++ b/products/mobile/src/api/readCache.test.ts@@ -0,0 +1,752 @@+import { QueryClient } from '@tanstack/react-query'++import type { StringStorage } from '@/lib/secureStorage'+import { insightSnapshot } from '@/model/adapters/insightSnapshot'+import { cacheable } from '@/model/adapters/readCache'+import { webOverviewSnapshot } from '@/model/adapters/webOverview'+import { ApiError } from './client'+import { persistReadCache } from './readCache'+import { inboxCacheKey } from './readCacheKeys'+import { boundedEntries, cacheKey, READ_CACHE_TTL_MS, type ReadCacheScope, ReadCacheStore } from './readCacheStore'++const scope: ReadCacheScope = { account: 'account-1', host: 'https://example.com', projectId: 1 }+const key = ['views', scope.host, 1, 'insight', 'view-1', '-', '-']+const aggregate = {+ queryKind: 'TrendsQuery',+ sqlTable: null,+ value: 42,+ readAt: 100,+ lastRefreshAt: '2026-10-01T12:00:00Z',+}++function memoryStorage(): StringStorage {+ const values = new Map<string, string>()+ return {+ getItem: async (name) => values.get(name) ?? null,+ setItem: async (name, value) => {+ values.set(name, value)+ },+ removeItem: async (name) => {+ values.delete(name)+ },+ }+}++function client(): QueryClient {+ return new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: Infinity } } })+}++describe('bounded offline read cache', () => {+ beforeEach(() => {+ jest.useFakeTimers()+ jest.setSystemTime(new Date('2026-10-01T13:00:00Z'))+ })+ afterEach(() => jest.useRealTimers())++ it('restores supported aggregate data with its original age and excludes raw or unrelated queries', async () => {+ const store = new ReadCacheStore(memoryStorage())+ const source = client()+ const subscription = persistReadCache(source, store, scope, () => true)+ await subscription.ready+ const updatedAt = Date.now() - 60_000+ source.setQueryData(key, aggregate, { updatedAt })+ source.setQueryData(['views', scope.host, 1, 'actors', 'query'], [{ id: 'private-person' }])+ source.setQueryData(['tasks', scope.host, 1, 'task', '1'], { transcript: 'Private message' })+ source.setQueryData(['views', scope.host, 1, 'insight', 'sql', '-', '-'], {+ queryKind: 'HogQLQuery',+ sqlTable: { rows: [['private-person']] },+ })+ await subscription.flush()+ await store.settled()+ subscription.stop()+ const restored = client()+ const restarted = persistReadCache(restored, store, scope, () => true)+ await restarted.ready+ expect(restored.getQueryData(key)).toEqual({ ...aggregate, restoredFromDevice: true })+ expect(restored.getQueryState(key)?.dataUpdatedAt).toBe(updatedAt)+ expect(restored.getQueryCache().getAll()).toHaveLength(1)+ restarted.stop()+ })++ test.each([401, 403, 404])('purges denied data on %s so the next restart cannot resurrect it', async (status) => {+ const store = new ReadCacheStore(memoryStorage())+ const otherRange = [...key.slice(0, -1), 'other-range']+ await store.save(+ scope,+ () => [key, otherRange].map((variant) => ({ key: variant, data: aggregate, updatedAt: Date.now() })),+ () => true+ )+ const active = client()+ const session = persistReadCache(active, store, scope, () => true)+ await session.ready+ expect(active.getQueryData(key)).toBeDefined()+ await expect(+ active.fetchQuery({+ queryKey: key,+ queryFn: async () => {+ throw new ApiError(status, {})+ },+ })+ ).rejects.toBeInstanceOf(ApiError)+ await store.settled()+ expect(active.getQueryData(key)).toBeUndefined()+ session.stop()+ const next = client()+ const restarted = persistReadCache(next, store, scope, () => true)+ await restarted.ready+ expect(next.getQueryData(key)).toBeUndefined()+ expect(next.getQueryData(otherRange)).toBeUndefined()+ restarted.stop()+ })++ it('drops the read-only inbox fallback after a live inbox denial', async () => {+ const store = new ReadCacheStore(memoryStorage())+ const cached = inboxCacheKey(scope)+ await store.save(+ scope,+ () => [{ key: cached, data: { items: [], sourceUpdatedAt: Date.now() }, updatedAt: Date.now() }],+ () => true+ )+ const active = client()+ const session = persistReadCache(active, store, scope, () => true)+ await session.ready+ await active+ .fetchQuery({+ queryKey: ['signals', scope.host, 1, 'inbox'],+ queryFn: async () => {+ throw new ApiError(403, {})+ },+ })+ .catch(() => undefined)+ await store.settled()+ session.stop()+ const next = client()+ const restarted = persistReadCache(next, store, scope, () => true)+ await restarted.ready+ expect(next.getQueryData(cached)).toBeUndefined()+ restarted.stop()+ })++ it('does not let delayed hydration cross a scope switch or replace a newer response', async () => {+ const storage = memoryStorage()+ const store = new ReadCacheStore(storage)+ await store.save(+ scope,+ () => [{ key, data: aggregate, updatedAt: Date.now() - 1000 }],+ () => true+ )+ const read = storage.getItem+ let finish!: () => void+ const gate = new Promise<void>((resolve) => {+ finish = resolve+ })+ storage.getItem = async (name) => {+ await gate+ return read(name)+ }+ let current = true+ const active = client()+ const session = persistReadCache(active, store, scope, () => current)+ current = false+ finish()+ await session.ready+ expect(active.getQueryData(key)).toBeUndefined()+ session.stop()+ const newer = client()+ newer.setQueryData(key, { ...aggregate, value: 99 }, { updatedAt: Date.now() })+ const next = persistReadCache(newer, store, scope, () => true)+ await next.ready+ expect(newer.getQueryData(key)).toMatchObject({ value: 99 })+ next.stop()+ })++ test.each(['timer', 'flush'] as const)(+ 'retries failed hydration on %s before replacing saved entries',+ async (retry) => {+ const storage = memoryStorage()+ const store = new ReadCacheStore(storage)+ const savedAt = Date.now() - 1000+ await store.save(+ scope,+ () => [{ key, data: aggregate, updatedAt: savedAt }],+ () => true+ )+ const read = storage.getItem+ const original = await read(cacheKey(scope))+ let unavailable = true+ storage.getItem = async (name) => {+ if (unavailable) throw new Error('Temporary read failure')+ return read(name)+ }+ const active = client()+ const session = persistReadCache(active, store, scope, () => true)+ await session.ready+ const newerKey = [...key.slice(0, 4), 'new-view', '-', '-']+ active.setQueryData(newerKey, { ...aggregate, value: 99 })+ await session.flush()+ await jest.advanceTimersByTimeAsync(1000)+ expect(await read(cacheKey(scope))).toBe(original)+ unavailable = false+ if (retry === 'timer') await jest.advanceTimersByTimeAsync(5000)+ else await session.flush()+ expect(active.getQueryData(key)).toMatchObject({ value: 42, restoredFromDevice: true })+ expect(active.getQueryState(key)?.dataUpdatedAt).toBe(savedAt)+ expect(active.getQueryData(newerKey)).toMatchObject({ value: 99 })+ await session.flush()+ expect(await store.load(scope)).toHaveLength(2)+ session.stop()+ }+ )++ it('clears every account project and pending writes on sign-out without touching another account', async () => {+ const store = new ReadCacheStore(memoryStorage())+ const other = { ...scope, account: 'account-2' }+ const entries = () => [{ key, data: aggregate, updatedAt: Date.now() }]+ await store.save(scope, entries, () => true)+ await store.save(+ { ...scope, projectId: 2 },+ () => [{ data: aggregate, updatedAt: Date.now(), key: ['views', scope.host, 2, 'web', '-'] }],+ () => true+ )+ await store.save(other, entries, () => true)+ const waiting = store.save(scope, entries, () => true)+ const clearing = store.clearAccount(scope.account)+ await Promise.all([waiting, clearing])+ expect(await store.load(scope)).toEqual([])+ expect(await store.load({ ...scope, projectId: 2 })).toEqual([])+ expect(await store.load(other)).toHaveLength(1)+ })++ it('bounds age, count and encoded size and rejects host/project mismatches', async () => {+ const now = Date.now()+ const entries = Array.from({ length: 30 }, (_, index) => ({ key, updatedAt: now - index, data: aggregate }))+ expect(boundedEntries(entries)).toHaveLength(24)+ const beyondLimit = {+ key,+ updatedAt: now - 31,+ data: {+ toJSON: () => {+ throw new Error('Outside the entry budget')+ },+ },+ }+ expect(() => boundedEntries([...entries, beyondLimit])).not.toThrow()+ expect(boundedEntries([{ key, updatedAt: now - READ_CACHE_TTL_MS, data: aggregate }])).toEqual([])+ expect(boundedEntries([{ key, updatedAt: now, data: '界'.repeat(20_000) }])).toEqual([])+ const storage = memoryStorage()+ await storage.setItem(+ cacheKey(scope),+ JSON.stringify([+ { key: ['views', 'https://other.example.com', 1, 'web', '-'], updatedAt: now, data: aggregate },+ ])+ )+ expect(await new ReadCacheStore(storage).load(scope)).toEqual([])+ expect(cacheable(key, aggregate, { ...scope, projectId: 2 })).toBe(false)+ })+ it('purges a view denied during hydration and does not restore it on the next restart', async () => {+ const storage = memoryStorage()+ const store = new ReadCacheStore(storage)+ await store.save(+ scope,+ () => [{ key, data: aggregate, updatedAt: Date.now() }],+ () => true+ )+ const read = storage.getItem+ let finish!: () => void+ const gate = new Promise<void>((resolve) => {+ finish = resolve+ })+ storage.getItem = async (name) => {+ await gate+ return read(name)+ }+ let blocked = false+ const active = client()+ const session = persistReadCache(+ active,+ store,+ scope,+ () => true,+ () => blocked+ )+ blocked = true+ session.purgeDeniedViews()+ finish()+ await session.ready+ await session.flush()+ await store.settled()+ session.stop()+ const next = client()+ const reopened = persistReadCache(next, store, scope, () => true)+ await reopened.ready+ expect(next.getQueryData(key)).toBeUndefined()+ reopened.stop()+ })+ it('coalesces read updates and strips nested dashboard response payloads', async () => {+ const storage = memoryStorage()+ const store = new ReadCacheStore(storage)+ const active = client()+ const session = persistReadCache(active, store, scope, () => true)+ await session.ready+ const dashboard = ['views', scope.host, 1, 'dashboard', '1', '-']+ active.setQueryData(dashboard, {+ view: {+ id: 1,+ name: 'Dashboard',+ tiles: [+ {+ tileId: 1,+ kind: 'insight',+ shortId: 'view-1',+ name: 'Count',+ response: { persons: ['private-person-row'] },+ query: { kind: 'HogQLQuery' },+ },+ ],+ },+ readAt: Date.now(),+ refreshFailed: false,+ })+ active.setQueryData(key, { ...aggregate, value: 10, secretResponse: 'private-person-row' })+ active.setQueryData(key, { ...aggregate, value: 20, secretResponse: 'private-person-row' })+ expect(await storage.getItem(cacheKey(scope))).toBeNull()+ await jest.advanceTimersByTimeAsync(500)+ await store.settled()+ const raw = await storage.getItem(cacheKey(scope))+ expect(raw).not.toContain('private-person-row')+ expect(raw).not.toContain('HogQLQuery')+ expect((await store.load(scope)).find((entry) => entry.key[3] === 'insight')?.data).toMatchObject({ value: 20 })+ session.stop()+ })+ it('does not renew the offline TTL when an attempted refresh only updates failure metadata', async () => {+ const store = new ReadCacheStore(memoryStorage())+ const active = client()+ const session = persistReadCache(active, store, scope, () => true)+ await session.ready+ const savedAt = Date.now()+ active.setQueryData(key, { ...aggregate, refreshFailed: false })+ await session.flush()+ jest.setSystemTime(savedAt + READ_CACHE_TTL_MS - 1000)+ active.setQueryData(key, { ...aggregate, readAt: Date.now(), refreshFailed: true })+ await session.flush()+ expect((await store.load(scope))[0]?.updatedAt).toBe(savedAt)+ jest.setSystemTime(savedAt + READ_CACHE_TTL_MS + 1000)+ active.setQueryData(key, { ...aggregate, readAt: Date.now(), refreshFailed: true })+ await session.flush()+ expect(await store.load(scope)).toEqual([])+ session.stop()+ })++ it('keeps a retained result age when a metadata-only insight or web read misses the server cache', async () => {+ const store = new ReadCacheStore(memoryStorage())+ const active = client()+ const session = persistReadCache(active, store, scope, () => true)+ await session.ready+ const savedAt = Date.now()+ const response = {+ id: 1,+ short_id: 'view-1',+ name: 'Count',+ derived_name: null,+ query: {+ kind: 'InsightVizNode',+ source: { kind: 'TrendsQuery', series: [{ kind: 'EventsNode', event: 'example' }] },+ },+ result: [{ action: { order: 0 }, days: ['2026-10-01'], data: [42] }],+ last_refresh: new Date(savedAt).toISOString(),+ cache_target_age: null,+ next_allowed_client_refresh: null,+ }+ const original = insightSnapshot(response, undefined, { readAt: savedAt, serverNow: savedAt })+ const originalWeb = webOverviewSnapshot(+ { results: [{ key: 'visitors', kind: 'unit', value: 42 }] },+ undefined,+ savedAt+ )+ const webKey = ['views', scope.host, 1, 'web', '-']+ active.setQueryData(key, original)+ active.setQueryData(webKey, originalWeb)+ await session.flush()+ jest.setSystemTime(savedAt + READ_CACHE_TTL_MS - 1000)+ const miss = insightSnapshot({ ...response, result: null }, original, {+ readAt: Date.now(),+ serverNow: Date.now(),+ })+ active.setQueryData(key, miss)+ active.setQueryData(webKey, webOverviewSnapshot({}, originalWeb, Date.now()))+ await session.flush()+ expect((await store.load(scope)).map((entry) => entry.updatedAt)).toEqual([savedAt, savedAt])+ jest.setSystemTime(savedAt + READ_CACHE_TTL_MS + 1000)+ active.setQueryData(+ key,+ insightSnapshot({ ...response, result: null }, miss, { readAt: Date.now(), serverNow: Date.now() })+ )+ active.setQueryData(webKey, webOverviewSnapshot({}, originalWeb, Date.now()))+ await session.flush()+ expect(await store.load(scope)).toEqual([])+ session.stop()+ })++ test.each(['insight', 'web'] as const)(+ 'restores %s results after a metadata-only read during hydration',+ async (kind) => {+ const storage = memoryStorage()+ const store = new ReadCacheStore(storage)+ const savedAt = Date.now() - 1000+ const response = {+ id: 1,+ short_id: 'view-1',+ name: 'Saved name',+ derived_name: null,+ query: {+ kind: 'InsightVizNode',+ source: { kind: 'TrendsQuery', series: [{ kind: 'EventsNode', event: 'example' }] },+ },+ result: [{ action: { order: 0 }, days: ['2026-09-30'], data: [42], count: 42 }],+ last_refresh: new Date(savedAt).toISOString(),+ cache_target_age: null,+ next_allowed_client_refresh: null,+ }+ const target = kind === 'insight' ? key : ['views', scope.host, 1, 'web', '-']+ const original =+ kind === 'insight'+ ? insightSnapshot(response, undefined, { readAt: savedAt, serverNow: savedAt })+ : webOverviewSnapshot(+ { results: [{ key: 'visitors', kind: 'unit', value: 42 }] },+ undefined,+ savedAt+ )+ await store.save(+ scope,+ () => [{ key: target, data: original, updatedAt: savedAt }],+ () => true+ )+ const read = storage.getItem+ let finish!: () => void+ const gate = new Promise<void>((resolve) => {+ finish = resolve+ })+ storage.getItem = async (name) => {+ await gate+ return read(name)+ }+ const active = client()+ const session = persistReadCache(active, store, scope, () => true)+ const placeholder =+ kind === 'insight'+ ? insightSnapshot({ ...response, name: 'Current name', result: null }, undefined, {+ readAt: Date.now(),+ serverNow: Date.now(),+ })+ : webOverviewSnapshot({}, undefined, Date.now())+ active.setQueryData(target, placeholder)+ finish()+ await session.ready+ expect(active.getQueryData(target)).toMatchObject({+ dataReadAt: savedAt,+ readAt: Date.now(),+ restoredFromDevice: true,+ })+ if (kind === 'insight')+ expect(active.getQueryData(target)).toMatchObject({ value: 42, name: 'Current name' })+ else+ expect(active.getQueryData(target)).toMatchObject({+ metrics: expect.arrayContaining([expect.objectContaining({ value: 42 })]),+ })+ await session.flush()+ expect((await store.load(scope))[0]?.updatedAt).toBe(savedAt)+ session.stop()+ }+ )++ it('retains a hydrated inbox until its first visit after the normal query GC interval', async () => {+ const store = new ReadCacheStore(memoryStorage())+ const inbox = inboxCacheKey(scope)+ await store.save(+ scope,+ () => [+ {+ key: inbox,+ data: { items: [], signalCounts: { report: 12 }, sourceUpdatedAt: Date.now() },+ updatedAt: Date.now(),+ },+ ],+ () => true+ )+ const active = new QueryClient({ defaultOptions: { queries: { gcTime: 5 * 60_000 } } })+ const session = persistReadCache(active, store, scope, () => true)+ await session.ready+ await jest.advanceTimersByTimeAsync(6 * 60_000)+ expect(active.getQueryData(inbox)).toMatchObject({ items: [], signalCounts: { report: 12 } })+ session.stop()+ active.clear()+ })++ it('bounds a full hydration batch without repeatedly serializing earlier entries', async () => {+ const storage = memoryStorage()+ const entries = Array.from({ length: 24 }, (_, index) => ({+ key: [...key.slice(0, 4), String(index), '-', '-'],+ data: { ...aggregate, value: String(index) },+ updatedAt: Date.now(),+ }))+ await storage.setItem(cacheKey(scope), JSON.stringify(entries))+ const stringify = jest.spyOn(JSON, 'stringify')+ const active = client()+ const session = persistReadCache(active, new ReadCacheStore(storage), scope, () => true)+ await session.ready+ const serializedEntries = stringify.mock.calls.filter(+ ([value]) => typeof value === 'object' && value !== null && 'updatedAt' in value+ ).length+ stringify.mockRestore()+ expect(serializedEntries).toBeLessThanOrEqual(entries.length * 2)+ expect(active.getQueryCache().getAll()).toHaveLength(24)+ session.stop()+ })++ it('writes only changed entries in a full project and removes all payloads on logout', async () => {+ const storage = memoryStorage()+ const store = new ReadCacheStore(storage)+ const entries = Array.from({ length: 24 }, (_, index) => ({+ key: [...key.slice(0, 4), String(index), '-', '-'],+ data: { ...aggregate, series: 'x'.repeat(5000) },+ updatedAt: Date.now(),+ }))+ const write = jest.spyOn(storage, 'setItem')+ await store.save(+ scope,+ () => entries,+ () => true+ )+ expect(await store.load(scope)).toHaveLength(24)+ write.mockClear()+ const changed = entries[0]+ if (!changed) throw new Error('Missing full-cache fixture')+ entries[0] = { ...changed, data: { ...changed.data, value: 43 } }+ await store.save(+ scope,+ () => entries,+ () => true+ )+ expect(write).toHaveBeenCalledTimes(1)+ expect(write.mock.calls[0]?.[1].length).toBeLessThan(6000)+ write.mockClear()+ await store.save(+ scope,+ () => entries,+ () => true+ )+ expect(write).not.toHaveBeenCalled()+ await store.clearAccount(scope.account)+ expect(await store.load(scope)).toEqual([])+ for (let slot = 0; slot < 24; slot++)+ expect(await storage.getItem(`${cacheKey(scope)}.entry.${slot}`)).toBeNull()+ })++ it('keeps disk copies after query garbage collection and still purges denied resource variants', async () => {+ const store = new ReadCacheStore(memoryStorage())+ const otherRange = [...key.slice(0, -1), 'other-range']+ await store.save(+ scope,+ () => [key, otherRange].map((variant) => ({ key: variant, data: aggregate, updatedAt: Date.now() })),+ () => true+ )+ const active = client()+ const session = persistReadCache(active, store, scope, () => true)+ await session.ready+ active.removeQueries()+ await session.flush()+ expect(await store.load(scope)).toHaveLength(2)+ await active+ .fetchQuery({+ queryKey: key,+ queryFn: async () => {+ throw new ApiError(403, {})+ },+ })+ .catch(() => undefined)+ await store.settled()+ session.stop()+ const next = client()+ const restored = persistReadCache(next, store, scope, () => true)+ await restored.ready+ expect(next.getQueryData(key)).toBeUndefined()+ expect(next.getQueryData(otherRange)).toBeUndefined()+ restored.stop()+ })++ it('keeps at most eight recently saved projects without touching the draft namespace', async () => {+ const storage = memoryStorage()+ const store = new ReadCacheStore(storage)+ await storage.setItem('mobile-drafts-example', 'Keep draft')+ for (let projectId = 1; projectId <= 9; projectId++) {+ const target = { ...scope, projectId }+ await store.save(+ target,+ () => [+ { key: ['views', scope.host, projectId, 'web', '-'], data: { metrics: [] }, updatedAt: Date.now() },+ ],+ () => true+ )+ }+ expect(await store.load(scope)).toEqual([])+ expect(await store.load({ ...scope, projectId: 9 })).toHaveLength(1)+ expect(JSON.parse((await storage.getItem(`${scope.account}.scopes`)) ?? '[]')).toHaveLength(8)+ expect(await storage.getItem('mobile-drafts-example')).toBe('Keep draft')+ })+ test.each([+ { name: 'offline', error: new TypeError('Offline') },+ { name: 'server error', error: new ApiError(500, {}) },+ ])('keeps a saved value after transient refetch failure: $name', async ({ error }) => {+ const store = new ReadCacheStore(memoryStorage())+ const updatedAt = Date.now() - 60_000+ await store.save(+ scope,+ () => [{ key, data: aggregate, updatedAt }],+ () => true+ )+ const active = client()+ const session = persistReadCache(active, store, scope, () => true)+ await session.ready+ await active+ .fetchQuery({+ queryKey: key,+ queryFn: async () => {+ throw error+ },+ })+ .catch(() => undefined)+ expect(active.getQueryData(key)).toMatchObject({ value: 42 })+ await session.flush()+ session.stop()+ const next = client()+ const restored = persistReadCache(next, store, scope, () => true)+ await restored.ready+ expect(next.getQueryData(key)).toMatchObject({ value: 42 })+ expect(next.getQueryState(key)?.dataUpdatedAt).toBe(updatedAt)+ restored.stop()+ })++ it('respects a permission denial that arrived before the cache lifecycle started', async () => {+ const store = new ReadCacheStore(memoryStorage())+ const otherRange = [...key.slice(0, -1), 'other-range']+ await store.save(+ scope,+ () => [key, otherRange].map((variant) => ({ key: variant, data: aggregate, updatedAt: Date.now() })),+ () => true+ )+ const active = client()+ active.setQueryData(key, aggregate)+ await active+ .fetchQuery({+ queryKey: key,+ queryFn: async () => {+ throw new ApiError(403, {})+ },+ })+ .catch(() => undefined)+ const session = persistReadCache(active, store, scope, () => true)+ await session.ready+ expect(active.getQueryData(otherRange)).toBeUndefined()+ await session.flush()+ session.stop()+ const next = client()+ const restored = persistReadCache(next, store, scope, () => true)+ await restored.ready+ expect(next.getQueryData(otherRange)).toBeUndefined()+ restored.stop()+ })++ it('finishes denying an old project even when the active project changes during disk access', async () => {+ const storage = memoryStorage()+ const store = new ReadCacheStore(storage)+ await store.save(+ scope,+ () => [{ key, data: aggregate, updatedAt: Date.now() }],+ () => true+ )+ let current = true+ const active = client()+ const session = persistReadCache(active, store, scope, () => current)+ await session.ready+ let started!: () => void+ let finish!: () => void+ const reading = new Promise<void>((resolve) => {+ started = resolve+ })+ const gate = new Promise<void>((resolve) => {+ finish = resolve+ })+ const read = storage.getItem+ storage.getItem = async (name) => {+ if (name === `${scope.account}.scopes` || name === cacheKey(scope)) {+ started()+ await gate+ }+ return read(name)+ }+ await active+ .fetchQuery({+ queryKey: key,+ queryFn: async () => {+ throw new ApiError(403, {})+ },+ })+ .catch(() => undefined)+ await reading+ current = false+ finish()+ await store.settled()+ session.stop()+ const next = client()+ const restored = persistReadCache(next, store, scope, () => true)+ await restored.ready+ expect(next.getQueryData(key)).toBeUndefined()+ restored.stop()+ })++ it('does not resurrect denied data after an older device write finishes late', async () => {+ const storage = memoryStorage()+ const store = new ReadCacheStore(storage)+ const active = client()+ const session = persistReadCache(active, store, scope, () => true)+ await session.ready+ let started!: () => void+ let finish!: () => void+ const writing = new Promise<void>((resolve) => {+ started = resolve+ })+ const gate = new Promise<void>((resolve) => {+ finish = resolve+ })+ const write = storage.setItem+ let delayed = false+ storage.setItem = async (name, value) => {+ if (name === cacheKey(scope) && !delayed) {+ delayed = true+ started()+ await gate+ }+ await write(name, value)+ }+ active.setQueryData(key, aggregate)+ const pending = session.flush()+ await writing+ await active+ .fetchQuery({+ queryKey: key,+ queryFn: async () => {+ throw new ApiError(403, {})+ },+ })+ .catch(() => undefined)+ finish()+ await pending+ await store.settled()+ session.stop()+ const next = client()+ const restored = persistReadCache(next, store, scope, () => true)+ await restored.ready+ expect(next.getQueryData(key)).toBeUndefined()+ restored.stop()+ })+})diff --git a/products/mobile/src/api/readCache.ts b/products/mobile/src/api/readCache.tsnew file mode 100644index 000000000000..f0dd1d86104e--- /dev/null+++ b/products/mobile/src/api/readCache.ts@@ -0,0 +1,251 @@+import type { Query, QueryClient, QueryKey } from '@tanstack/react-query'+import { asRecord } from '@/lib/records'+import { cacheable, isReadCacheKey, projectedData } from '@/model/adapters/readCache'+import { ApiError } from './client'+import { inboxCacheKey } from './readCacheKeys'+import { boundedEntries, type ReadCacheEntry, type ReadCacheScope, type ReadCacheStore } from './readCacheStore'++export function deniedRead(error: unknown): boolean {+ return error instanceof ApiError && [401, 403, 404].includes(error.status)+}++function keyId(key: QueryKey): string {+ return JSON.stringify(key)+}++function resourceKey(key: QueryKey): string {+ return keyId(key[0] === 'views' ? key.slice(0, key[3] === 'web' ? 4 : 5) : key)+}++export function persistReadCache(+ client: QueryClient,+ store: ReadCacheStore,+ scope: ReadCacheScope,+ current: () => boolean,+ deniedView: (key: QueryKey) => boolean = () => false,+ sameAccount: () => boolean = current+): {+ ready: Promise<void>+ pause: () => void+ stop: () => void+ purgeDeniedViews: (keys?: readonly QueryKey[]) => void+ flush: () => Promise<void>+} {+ // Saved inbox queries cannot refetch, so retain them before hydration creates inactive queries.+ client.setQueryDefaults(['read-inbox'], { gcTime: Infinity })+ let stopped = false+ let loading = false+ let hydrated = false+ let retryTimer: ReturnType<typeof setTimeout> | undefined+ let restoring = false+ const denied = new Set<string>()+ const deniedResources = new Set<string>()+ const good = new Map<string, ReadCacheEntry>()+ const valid = (): boolean => !stopped && current()+ const keep = (candidates: readonly ReadCacheEntry[]): void => {+ const entries = boundedEntries(candidates)+ good.clear()+ for (const saved of entries) good.set(keyId(saved.key), saved)+ }+ const remember = (key: QueryKey, data: unknown, updatedAt: number): void => {+ if (!cacheable(key, data, scope)) {+ good.delete(keyId(key))+ return+ }+ const value = asRecord(data)+ if (!value || value.refreshFailed === true) return+ let capture = updatedAt+ if (typeof value.dataReadAt === 'number') capture = value.dataReadAt+ else if (value.restoredFromDevice === true) capture = good.get(keyId(key))?.updatedAt ?? updatedAt+ if (capture <= 0) return+ good.set(keyId(key), { key, data: projectedData(key, data), updatedAt: capture })+ }+ for (const query of client.getQueryCache().getAll()) {+ remember(query.queryKey, query.state.data, query.state.dataUpdatedAt)+ }+ keep([...good.values()])+ const collect = (): ReadCacheEntry[] =>+ boundedEntries([...good.values()]).filter(+ ({ key, data }) =>+ !deniedRead(client.getQueryState(key)?.error) &&+ !denied.has(keyId(key)) &&+ !deniedResources.has(resourceKey(key)) &&+ !deniedView(key) &&+ cacheable(key, data, scope)+ )+ let timer: ReturnType<typeof setTimeout> | undefined+ const flush = async (): Promise<void> => {+ if (timer) clearTimeout(timer)+ timer = undefined+ if (!hydrated && valid()) await hydrate()+ if (hydrated && valid()) await store.save(scope, collect, valid).catch(() => undefined)+ }+ const save = (): void => {+ if (!hydrated || loading || !valid() || timer) return+ timer = setTimeout(() => {+ timer = undefined+ void flush()+ }, 500)+ }+ const clear = (key: QueryKey): void => {+ denied.add(keyId(key))+ good.delete(keyId(key))+ const query = client.getQueryCache().find({ queryKey: key, exact: true })+ if (query?.state.data !== undefined) query.setState({ data: undefined, dataUpdatedAt: 0 })+ }+ const clearResource = (key: QueryKey): void => {+ deniedResources.add(resourceKey(key))+ for (const saved of good.values()) {+ if (resourceKey(saved.key) === resourceKey(key)) good.delete(keyId(saved.key))+ }+ for (const query of client.getQueryCache().getAll()) {+ if (resourceKey(query.queryKey) === resourceKey(key)) clear(query.queryKey)+ }+ }+ const isInboxSource = (key: QueryKey): boolean =>+ key[0] === 'signals' && key[3] === 'inbox' && key[1] === scope.host && key[2] === scope.projectId+ const denyQuery = (key: QueryKey): void => {+ clearResource(key)+ if (isInboxSource(key)) clear(inboxCacheKey(scope))+ }+ const evictDenied = (): Promise<void> => {+ const resources = new Set(deniedResources)+ const keys = new Set(denied)+ return store+ .evict(+ scope,+ (entry) => resources.has(resourceKey(entry.key)) || keys.has(keyId(entry.key)) || deniedView(entry.key)+ )+ .catch(() => undefined)+ }+ const onError = (query: Query): void => {+ if (!deniedRead(query.state.error)) return+ if (!isReadCacheKey(query.queryKey, scope) && !isInboxSource(query.queryKey)) return+ denyQuery(query.queryKey)+ // Leaving a project cancels saves, but its known-denied copies must still be removed.+ void evictDenied()+ }+ const onSuccess = (query: Query): void => {+ if (!isReadCacheKey(query.queryKey, scope)) return+ denied.delete(keyId(query.queryKey))+ remember(query.queryKey, query.state.data, query.state.dataUpdatedAt)+ keep([...good.values()])+ deniedResources.delete(resourceKey(query.queryKey))+ save()+ }+ const unsubscribe = client.getQueryCache().subscribe((event) => {+ if (restoring || event.type !== 'updated') return+ if (sameAccount() && event.action.type === 'error') onError(event.query)+ if (valid() && event.action.type === 'success') onSuccess(event.query)+ })+ for (const query of client.getQueryCache().getAll()) onError(query)+ const purgeDeniedViews = (extraKeys: readonly QueryKey[] = []): void => {+ if (!sameAccount()) return+ let purged = false+ const keys = [...good.values()]+ .map((entry) => entry.key)+ .concat(+ extraKeys,+ client+ .getQueryCache()+ .getAll()+ .map((query) => query.queryKey)+ )+ for (const key of keys) {+ if (isReadCacheKey(key, scope) && deniedView(key)) {+ clearResource(key)+ purged = true+ }+ }+ if (purged) void evictDenied()+ }+ const mayRestore = (entry: ReadCacheEntry): boolean =>+ cacheable(entry.key, entry.data, scope) &&+ !denied.has(keyId(entry.key)) &&+ !deniedResources.has(resourceKey(entry.key)) &&+ !deniedView(entry.key)+ const restore = (entry: ReadCacheEntry): void => {+ if (!mayRestore(entry)) return+ const state = client.getQueryState(entry.key)+ const currentData = asRecord(state?.data)+ const capturedAt =+ typeof currentData?.dataReadAt === 'number' ? currentData.dataReadAt : (state?.dataUpdatedAt ?? 0)+ if (deniedRead(state?.error) || capturedAt >= entry.updatedAt) return+ const projected = projectedData(entry.key, entry.data)+ const data =+ entry.key[0] === 'views'+ ? {+ ...asRecord(projected),+ ...(currentData && capturedAt === 0+ ? Object.fromEntries(+ [+ 'readAt',+ 'refreshFailed',+ 'name',+ 'description',+ 'query',+ 'savedRange',+ 'usesOwnRange',+ 'kindLabel',+ 'createdBy',+ 'createdAt',+ ]+ .filter((name) => name in currentData)+ .map((name) => [name, currentData[name]])+ )+ : {}),+ restoredFromDevice: true,+ }+ : projected+ client.setQueryData(entry.key, data, { updatedAt: entry.updatedAt })+ }+ const hydrate = async (): Promise<void> => {+ if (loading || hydrated || !valid()) return+ if (retryTimer) clearTimeout(retryTimer)+ retryTimer = undefined+ loading = true+ try {+ const entries = await store.load(scope)+ if (!valid()) return+ restoring = true+ for (const entry of entries) {+ if (deniedView(entry.key)) deniedResources.add(resourceKey(entry.key))+ }+ const merged = new Map(good)+ for (const entry of entries) {+ if (!mayRestore(entry)) continue+ const known = merged.get(keyId(entry.key))+ if (!known || known.updatedAt < entry.updatedAt) merged.set(keyId(entry.key), entry)+ }+ keep([...merged.values()])+ for (const entry of good.values()) restore(entry)+ hydrated = true+ } catch {+ if (valid()) retryTimer = setTimeout(() => void hydrate(), 5000)+ } finally {+ restoring = false+ loading = false+ if (hydrated) {+ if (valid() && (denied.size || deniedResources.size)) await evictDenied()+ else save()+ }+ }+ }+ const ready = hydrate()+ const pause = (): void => {+ stopped = true+ good.clear()+ if (timer) clearTimeout(timer)+ if (retryTimer) clearTimeout(retryTimer)+ }+ return {+ ready,+ pause,+ purgeDeniedViews,+ flush,+ stop: () => {+ pause()+ unsubscribe()+ },+ }+}diff --git a/products/mobile/src/api/readCacheKeys.ts b/products/mobile/src/api/readCacheKeys.tsnew file mode 100644index 000000000000..27806c385e18--- /dev/null+++ b/products/mobile/src/api/readCacheKeys.ts@@ -0,0 +1,12 @@+import type { InboxItem } from '@/model/types'+import type { ProjectScope } from './reports'++export interface SavedInbox {+ items: InboxItem[]+ signalCounts?: Record<string, number>+ sourceUpdatedAt: number+}++export function inboxCacheKey(scope: ProjectScope | null): readonly unknown[] {+ return ['read-inbox', scope?.host ?? 'none', scope?.projectId ?? null]+}diff --git a/products/mobile/src/api/readCacheStore.native.test.ts b/products/mobile/src/api/readCacheStore.native.test.tsnew file mode 100644index 000000000000..e1196784d934--- /dev/null+++ b/products/mobile/src/api/readCacheStore.native.test.ts@@ -0,0 +1,167 @@+import { QueryClient } from '@tanstack/react-query'+import * as SecureStore from 'expo-secure-store'+import { Platform } from 'react-native'+import { secureStorage } from '@/lib/secureStorage'+import { persistReadCache } from './readCache'+import { ReadCacheStore } from './readCacheStore'++const mockValues = new Map<string, string>()+let mockRevision = 0+jest.mock('expo-crypto', () => ({ randomUUID: () => `revision-${mockRevision++}` }))+jest.mock('expo-secure-store', () => ({+ getItemAsync: jest.fn(async (key: string) => mockValues.get(key) ?? null),+ setItemAsync: jest.fn(async (key: string, value: string) => {+ mockValues.set(key, value)+ }),+ deleteItemAsync: jest.fn(async (key: string) => {+ mockValues.delete(key)+ }),+}))++describe('encrypted read cache native storage work', () => {+ beforeEach(() => {+ jest.useFakeTimers()+ mockValues.clear()+ jest.mocked(SecureStore.getItemAsync).mockImplementation(async (key) => mockValues.get(key) ?? null)+ jest.mocked(SecureStore.setItemAsync).mockImplementation(async (key, value) => {+ mockValues.set(key, value)+ })+ jest.mocked(SecureStore.deleteItemAsync).mockImplementation(async (key) => {+ mockValues.delete(key)+ })+ jest.replaceProperty(Platform, 'OS', 'android')+ })+ afterEach(() => {+ jest.restoreAllMocks()+ jest.useRealTimers()+ })++ test.each(['chunk', 'manifest'] as const)(+ 'propagates a temporary %s read failure without erasing saved data',+ async (part) => {+ const scope = { account: 'example-account', host: 'https://example.com', projectId: 1 }+ const key = ['views', scope.host, 1, 'web', '-']+ const store = new ReadCacheStore(secureStorage)+ await store.save(+ scope,+ () => [{ key, updatedAt: Date.now(), data: { metrics: [], readAt: Date.now() } }],+ () => true+ )+ const saved = new Map(mockValues)+ const read = jest.mocked(SecureStore.getItemAsync)+ const original = read.getMockImplementation()+ if (!original) throw new Error('Missing native read mock')+ read.mockImplementation(async (name, options) => {+ if (part === 'manifest' ? name === `${scope.account}.1` : /revision-.*\.0$/.test(name))+ throw new Error('Temporary read failure')+ return original(name, options)+ })+ const client = new QueryClient({ defaultOptions: { queries: { gcTime: Infinity } } })+ const session = persistReadCache(client, store, scope, () => true)+ await session.ready+ await session.flush()+ expect(mockValues).toEqual(saved)+ read.mockImplementation(original)+ await session.flush()+ expect(client.getQueryData(key)).toMatchObject({ metrics: [], restoredFromDevice: true })+ session.stop()+ client.clear()+ }+ )++ test.each(['chunk', 'manifest', 'cleanup', 'remove'] as const)(+ 'recovers all chunks after interruption during %s',+ async (stage) => {+ const key = 'example-value'+ const oldValue = 'a'.repeat(1200)+ const nextValue = 'b'.repeat(1200)+ await secureStorage.setItem(key, oldValue)+ const set = jest.mocked(SecureStore.setItemAsync)+ const remove = jest.mocked(SecureStore.deleteItemAsync)+ const read = jest.mocked(SecureStore.getItemAsync)+ const originalSet = set.getMockImplementation()+ const originalRemove = remove.getMockImplementation()+ const originalRead = read.getMockImplementation()+ if (!originalSet || !originalRemove || !originalRead) throw new Error('Missing native storage mock')+ let interrupted = false+ const fail = (): never => {+ interrupted = true+ throw new Error('Storage interrupted')+ }+ read.mockImplementation(async (name, options) => {+ if (interrupted) fail()+ return originalRead(name, options)+ })+ set.mockImplementation(async (name, value, options) => {+ if (interrupted) fail()+ await originalSet(name, value, options)+ if ((stage === 'chunk' && name.endsWith('.0')) || (stage === 'manifest' && name === key)) fail()+ })+ remove.mockImplementation(async (name, options) => {+ if (interrupted) fail()+ if (stage === 'cleanup' && name.endsWith('.0')) fail()+ await originalRemove(name, options)+ if (stage === 'remove' && name === key) fail()+ })+ const work = stage === 'remove' ? secureStorage.removeItem(key) : secureStorage.setItem(key, nextValue)+ await expect(work).rejects.toThrow('Storage interrupted')+ read.mockImplementation(originalRead)+ set.mockImplementation(originalSet)+ remove.mockImplementation(originalRemove)+ const expected = stage === 'remove' ? null : stage === 'chunk' ? oldValue : nextValue+ expect(await secureStorage.getItem(key)).toBe(expected)+ expect(mockValues.has(`${key}.revisions`)).toBe(false)+ const current = JSON.parse(mockValues.get(key) ?? 'null')+ expect([...mockValues.keys()].sort()).toEqual(+ current+ ? [+ key,+ ...Array.from({ length: current.count }, (_, i) => `${key}.${current.revision}.${i}`),+ ].sort()+ : []+ )+ await secureStorage.removeItem(key)+ expect(mockValues.size).toBe(0)+ }+ )++ it('limits a full-cache refresh to changed chunks and clears the account on logout', async () => {+ jest.replaceProperty(Platform, 'OS', 'android')+ const scope = { account: 'example-account', host: 'https://example.com', projectId: 1 }+ const store = new ReadCacheStore(secureStorage)+ const entries = Array.from({ length: 24 }, (_, index) => ({+ key: ['views', scope.host, 1, 'insight', String(index), '-', '-'],+ updatedAt: Date.now(),+ data: { series: 'x'.repeat(5000), value: 42 },+ }))+ await store.save(+ scope,+ () => entries,+ () => true+ )+ jest.mocked(SecureStore.setItemAsync).mockClear()+ jest.mocked(SecureStore.deleteItemAsync).mockClear()+ const first = entries[0]+ if (!first) throw new Error('Missing full-cache fixture')+ entries[0] = { ...first, data: { ...first.data, value: 43 } }+ await store.save(+ scope,+ () => entries,+ () => true+ )+ expect(jest.mocked(SecureStore.setItemAsync).mock.calls.length).toBeLessThan(16)+ expect(jest.mocked(SecureStore.deleteItemAsync).mock.calls.length).toBeLessThan(16)+ expect(await store.load(scope)).toHaveLength(24)+ jest.mocked(SecureStore.setItemAsync).mockClear()+ jest.mocked(SecureStore.deleteItemAsync).mockClear()+ await store.save(+ scope,+ () => entries,+ () => true+ )+ expect(SecureStore.setItemAsync).not.toHaveBeenCalled()+ expect(SecureStore.deleteItemAsync).not.toHaveBeenCalled()+ await store.clearAccount(scope.account)+ expect(mockValues.size).toBe(0)+ })+})diff --git a/products/mobile/src/api/readCacheStore.ts b/products/mobile/src/api/readCacheStore.tsnew file mode 100644index 000000000000..f31e08f08b03--- /dev/null+++ b/products/mobile/src/api/readCacheStore.ts@@ -0,0 +1,237 @@+import type { QueryKey } from '@tanstack/react-query'+import { asRecord } from '@/lib/records'+import type { StringStorage } from '@/lib/secureStorage'++export const READ_CACHE_TTL_MS = 24 * 60 * 60_000+export const READ_CACHE_ENTRY_LIMIT = 24+export const READ_CACHE_PROJECT_LIMIT = 8+export const READ_CACHE_ENTRY_BYTES = 32 * 1024+export const READ_CACHE_BYTES = 128 * 1024++export interface ReadCacheScope {+ account: string+ host: string+ projectId: number+}++export interface ReadCacheEntry {+ key: QueryKey+ updatedAt: number+ data: unknown+}++export function cacheKey(scope: ReadCacheScope): string {+ return `${scope.account}.${scope.projectId}`+}++export function boundedEntries(entries: readonly ReadCacheEntry[], now = Date.now()): ReadCacheEntry[] {+ let bytes = 2+ const saved: ReadCacheEntry[] = []+ for (const entry of [...entries].sort((a, b) => b.updatedAt - a.updatedAt)) {+ if (saved.length >= READ_CACHE_ENTRY_LIMIT) break+ if (!Number.isFinite(entry.updatedAt) || entry.updatedAt > now || now - entry.updatedAt >= READ_CACHE_TTL_MS)+ continue+ const size = Array.from(JSON.stringify(entry)).reduce(+ (total, character) => {+ const code = character.codePointAt(0) ?? 0+ return total + (code < 128 ? 1 : code < 2048 ? 2 : code < 65536 ? 3 : 4)+ },+ saved.length ? 1 : 0+ )+ if (size > READ_CACHE_ENTRY_BYTES || bytes + size > READ_CACHE_BYTES) continue+ bytes += size+ saved.push(entry)+ }+ return saved+}++export class ReadCacheStore {+ private writes: Promise<unknown> = Promise.resolve()+ private generation = 0++ constructor(private readonly storage: StringStorage) {}++ private enqueue<T>(work: () => Promise<T>): Promise<T> {+ const result = this.writes.then(work)+ this.writes = result.catch(() => undefined)+ return result+ }++ private async bundle(scope: ReadCacheScope): Promise<{ slots: number[]; entries: (ReadCacheEntry | null)[] }> {+ const key = cacheKey(scope)+ const raw = await this.storage.getItem(key)+ let value: unknown+ try {+ value = raw ? JSON.parse(raw) : []+ } catch {+ value = []+ }+ const slots =+ value && typeof value === 'object' && 'slots' in value && Array.isArray(value.slots)+ ? value.slots.filter(+ (slot): slot is number => Number.isInteger(slot) && slot >= 0 && slot < READ_CACHE_ENTRY_LIMIT+ )+ : []+ const entries: unknown[] = Array.isArray(value)+ ? value+ : await Promise.all(+ slots.map(async (slot) => {+ const entry = await this.storage.getItem(`${key}.entry.${slot}`)+ try {+ return entry ? JSON.parse(entry) : null+ } catch {+ return null+ }+ })+ )+ return {+ slots,+ entries: entries.map((entry): ReadCacheEntry | null => {+ const record = asRecord(entry)+ return record &&+ Array.isArray(record.key) &&+ typeof record.updatedAt === 'number' &&+ record.key[1] === scope.host &&+ record.key[2] === scope.projectId+ ? { key: record.key, updatedAt: record.updatedAt, data: record.data }+ : null+ }),+ }+ }++ private async read(scope: ReadCacheScope): Promise<ReadCacheEntry[]> {+ return boundedEntries(+ (await this.bundle(scope)).entries.filter((entry): entry is ReadCacheEntry => entry !== null)+ )+ }++ private async remove(key: string): Promise<void> {+ const raw = await this.storage.getItem(key)+ let value: unknown+ try {+ value = raw ? JSON.parse(raw) : null+ } catch {+ value = null+ }+ if (value && typeof value === 'object' && 'slots' in value && Array.isArray(value.slots)) {+ await Promise.all(+ value.slots+ .filter(+ (slot): slot is number => Number.isInteger(slot) && slot >= 0 && slot < READ_CACHE_ENTRY_LIMIT+ )+ .map((slot) => this.storage.removeItem(`${key}.entry.${slot}`))+ )+ }+ await this.storage.removeItem(key)+ }++ private serialize(entry: ReadCacheEntry | null): string {+ return JSON.stringify(entry && { key: entry.key, updatedAt: entry.updatedAt, data: entry.data })+ }++ private async write(scope: ReadCacheScope, entries: ReadCacheEntry[]): Promise<void> {+ const key = cacheKey(scope)+ const previous = await this.bundle(scope)+ const remaining = new Set(previous.slots)+ const contents = new Map(previous.entries.map((entry, index) => [this.serialize(entry), previous.slots[index]]))+ const slots = entries.map((entry) => {+ const slot = contents.get(this.serialize(entry))+ if (slot !== undefined) remaining.delete(slot)+ return slot+ })+ for (const [index, entry] of entries.entries()) {+ if (slots[index] !== undefined) continue+ const slot = Array.from({ length: READ_CACHE_ENTRY_LIMIT }, (_, candidate) => candidate).find(+ (candidate) => !slots.includes(candidate)+ )+ if (slot === undefined) continue+ slots[index] = slot+ remaining.delete(slot)+ await this.storage.setItem(`${key}.entry.${slot}`, this.serialize(entry))+ }+ const manifest = JSON.stringify({ slots })+ if (manifest !== JSON.stringify({ slots: previous.slots }) || !previous.slots.length) {+ await this.storage.setItem(key, manifest)+ }+ await Promise.all([...remaining].map((slot) => this.storage.removeItem(`${key}.entry.${slot}`)))+ }++ load(scope: ReadCacheScope): Promise<ReadCacheEntry[]> {+ return this.enqueue(() => this.read(scope))+ }++ evict(scope: ReadCacheScope, rejected: (entry: ReadCacheEntry) => boolean): Promise<void> {+ const generation = this.generation+ return this.enqueue(async () => {+ if (generation !== this.generation) return+ const remaining = (await this.read(scope)).filter((entry) => !rejected(entry))+ if (generation !== this.generation) return+ if (remaining.length) await this.write(scope, remaining)+ else await this.remove(cacheKey(scope))+ })+ }++ evictAccountViews(account: string, host: string): Promise<void> {+ const generation = this.generation+ return this.enqueue(async () => {+ const raw = await this.storage.getItem(`${account}.scopes`)+ const keys: unknown = raw ? JSON.parse(raw) : []+ if (!Array.isArray(keys)) return+ for (const key of keys) {+ if (generation !== this.generation) return+ if (typeof key !== 'string' || !key.startsWith(`${account}.`)) continue+ const projectId = Number(key.slice(account.length + 1))+ if (!Number.isSafeInteger(projectId) || projectId <= 0) continue+ const scope = { account, host, projectId }+ const remaining = (await this.read(scope)).filter((entry) => entry.key[0] !== 'views')+ if (generation !== this.generation) return+ if (remaining.length) await this.write(scope, remaining)+ else await this.remove(key)+ }+ })+ }++ save(scope: ReadCacheScope, entries: () => ReadCacheEntry[], current: () => boolean): Promise<void> {+ const generation = this.generation+ return this.enqueue(async () => {+ if (generation !== this.generation || !current()) return+ const index = `${scope.account}.scopes`+ const raw = await this.storage.getItem(index)+ const parsed: unknown = raw ? JSON.parse(raw) : []+ const scopes = Array.isArray(parsed)+ ? parsed.filter(+ (key): key is string =>+ typeof key === 'string' && key.startsWith(`${scope.account}.`) && key !== index+ )+ : []+ const key = cacheKey(scope)+ const order = [...scopes.filter((saved) => saved !== key), key]+ if (JSON.stringify(order) !== raw) await this.storage.setItem(index, JSON.stringify(order))+ await Promise.all(order.slice(0, -READ_CACHE_PROJECT_LIMIT).map((stale) => this.remove(stale)))+ if (order.length > READ_CACHE_PROJECT_LIMIT)+ await this.storage.setItem(index, JSON.stringify(order.slice(-READ_CACHE_PROJECT_LIMIT)))+ if (generation !== this.generation || !current()) return+ await this.write(scope, boundedEntries(entries()))+ })+ }++ clearAccount(account: string): Promise<void> {+ this.generation+++ return this.enqueue(async () => {+ const index = `${account}.scopes`+ const raw = await this.storage.getItem(index)+ const parsed: unknown = raw ? JSON.parse(raw) : []+ const keys = Array.isArray(parsed)+ ? parsed.filter(+ (key): key is string => typeof key === 'string' && key.startsWith(`${account}.`) && key !== index+ )+ : []+ await Promise.all(keys.map((key) => this.remove(key)))+ await this.storage.removeItem(index)+ })+ }++ settled(): Promise<unknown> {+ return this.writes+ }+}diff --git a/products/mobile/src/auth/BootSplash.test.tsx b/products/mobile/src/auth/BootSplash.test.tsxindex 42096bfe9c88..5a090b3f3e22 100644--- a/products/mobile/src/auth/BootSplash.test.tsx+++ b/products/mobile/src/auth/BootSplash.test.tsx@@ -43,6 +43,7 @@ jest.mock('@/ui/appearanceStore', () => ({jest.mock('@/features/ai/AiApprovalDialog', () => ({ AiApprovalDialog: () => null }))jest.mock('@/features/updates/useAutomaticUpdates', () => ({ useAutomaticUpdates: jest.fn() }))jest.mock('@/features/chat/draftPersistence', () => ({}))+jest.mock('@/features/offlineCache', () => ({ installOfflineCache: jest.fn() }))jest.mock('@/features/hedgehog/useHedgehogWidgetSync', () => ({ useHedgehogWidgetSync: jest.fn() }))jest.mock('@/features/notifications/pushRegistration', () => ({ configureNotifications: jest.fn() }))jest.mock('@/features/notifications/useNotificationRouting', () => ({ useNotificationRouting: jest.fn() }))diff --git a/products/mobile/src/auth/offlineSessionRestore.test.ts b/products/mobile/src/auth/offlineSessionRestore.test.tsnew file mode 100644index 000000000000..08b534b48b0d--- /dev/null+++ b/products/mobile/src/auth/offlineSessionRestore.test.ts@@ -0,0 +1,66 @@+import { installAuthProvider, useAuthStore } from './authStore'+import { saveTokens, setSessionTokens } from './tokens'++jest.mock('@react-native-async-storage/async-storage', () =>+ require('@react-native-async-storage/async-storage/jest/async-storage-mock')+)+jest.mock('expo-secure-store', () => {+ const values = new Map<string, string>()+ return {+ getItemAsync: async (key: string) => values.get(key) ?? null,+ setItemAsync: async (key: string, value: string) => {+ values.set(key, value)+ },+ deleteItemAsync: async (key: string) => {+ values.delete(key)+ },+ }+})++describe('offline session restoration', () => {+ it('keeps an existing verified owner and selected project when refresh and account reads are offline', async () => {+ await useAuthStore.persist.rehydrate()+ const host = 'https://example.com'+ await saveTokens(+ {+ kind: 'oauth',+ accessToken: 'example-access',+ refreshToken: 'example-refresh',+ expiresAt: 0,+ grantedScopes: null,+ requestedScopes: null,+ },+ { host, clientId: 'example-client', method: 'oauth', userUuid: 'example-user' }+ )+ useAuthStore.setState({+ status: 'loading',+ signedIn: false,+ clientId: 'example-client',+ method: 'oauth',+ host,+ user: { uuid: 'example-user', distinctId: 'example-user', email: '[email protected]', name: 'Example' },+ projectId: 1,+ projects: [+ {+ id: 1,+ name: 'Example project',+ organizationId: 'example-org',+ organizationName: 'Example organization',+ },+ ],+ })+ setSessionTokens(null)+ globalThis.fetch = jest.fn(async () => {+ throw new TypeError('Offline')+ }) as typeof fetch+ installAuthProvider()+ await useAuthStore.getState().restore()+ expect(useAuthStore.getState()).toMatchObject({+ status: 'signed_in',+ signedIn: true,+ host,+ user: { uuid: 'example-user' },+ projectId: 1,+ })+ })+})diff --git a/products/mobile/src/features/chat/draftPersistence.ts b/products/mobile/src/features/chat/draftPersistence.tsindex a5d723a6fbb1..fc720b9829cd 100644--- a/products/mobile/src/features/chat/draftPersistence.ts+++ b/products/mobile/src/features/chat/draftPersistence.ts@@ -1,107 +1,11 @@import * as Crypto from 'expo-crypto'-import * as SecureStore from 'expo-secure-store'-import { Platform } from 'react-native'import { addSessionEndTask, useAuthStore } from '@/auth/authStore'import { getSessionTokens } from '@/auth/tokens'-import { type DraftStorage, DraftStore } from './draftStore'+import { secureStorage as storage } from '@/lib/secureStorage'-const webMemory = new Map<string, string>()-const itemStorage: DraftStorage = {- getItem: (key) =>- Platform.OS === 'web' ? Promise.resolve(webMemory.get(key) ?? null) : SecureStore.getItemAsync(key),- setItem: async (key, value) => {- if (Platform.OS === 'web') {- webMemory.set(key, value)- } else {- await SecureStore.setItemAsync(key, value)- }- },- removeItem: async (key) => {- if (Platform.OS === 'web') {- webMemory.delete(key)- } else {- await SecureStore.deleteItemAsync(key)- }- },-}--interface Manifest {- revision: string- count: number-}--async function manifest(key: string): Promise<Manifest | null> {- const stored = await itemStorage.getItem(key)- try {- const value: unknown = JSON.parse(stored ?? 'null')- if (value && typeof value === 'object') {- const record = value as Record<string, unknown>- if (- typeof record.revision === 'string' &&- typeof record.count === 'number' &&- Number.isSafeInteger(record.count) &&- record.count > 0 &&- record.count <= 10000- ) {- return { revision: record.revision, count: record.count }- }- }- } catch {}- return null-}--async function removeChunks(key: string, saved: Manifest | null): Promise<void> {- if (saved) {- await Promise.all(- Array.from({ length: saved.count }, (_, index) =>- itemStorage.removeItem(`${key}.${saved.revision}.${index}`)- )- )- }-}--// Each chunk stays below SecureStore's 2 KiB limit even for non-ASCII text. The manifest switches only after all-// chunks are saved, so an interrupted write leaves the previous complete draft readable.-const storage: DraftStorage = {- getItem: async (key) => {- const saved = await manifest(key)- if (!saved) {- return null- }- const parts = await Promise.all(- Array.from({ length: saved.count }, (_, index) => itemStorage.getItem(`${key}.${saved.revision}.${index}`))- )- return parts.every((part) => part !== null) ? parts.join('') : null- },- setItem: async (key, value) => {- const previous = await manifest(key)- const revision = Crypto.randomUUID()- const characters = Array.from(value)- const parts: string[] = []- for (let index = 0; index < characters.length; index += 500) {- parts.push(characters.slice(index, index + 500).join(''))- }- if (!parts.length) {- parts.push('')- }- const next = { revision, count: parts.length }- try {- await Promise.all(parts.map((part, index) => itemStorage.setItem(`${key}.${revision}.${index}`, part)))- await itemStorage.setItem(key, JSON.stringify(next))- } catch (error) {- await removeChunks(key, next).catch(() => undefined)- throw error- }- await removeChunks(key, previous)- },- removeItem: async (key) => {- const previous = await manifest(key)- await itemStorage.removeItem(key)- await removeChunks(key, previous)- },-}+import { DraftStore } from './draftStore'export const chatDrafts = new DraftStore(storage)diff --git a/products/mobile/src/features/inbox/hooks.test.tsx b/products/mobile/src/features/inbox/hooks.test.tsxindex c863247206e3..7f6d3239ed35 100644--- a/products/mobile/src/features/inbox/hooks.test.tsx+++ b/products/mobile/src/features/inbox/hooks.test.tsx@@ -3,11 +3,16 @@ import { act, renderHook, waitFor } from '@testing-library/react-native'import type { ReactElement, ReactNode } from 'react'import { AppState, type AppStateStatus } from 'react-native'import { setAuthProvider } from '@/api/client'+import { inboxCacheKey, type SavedInbox } from '@/api/readCacheKeys'import { INBOX_PAGE_SIZE, postReadStates, reportKeys } from '@/api/reports'import { useAuthStore } from '@/auth/authStore'import { type DataMode, useDemoMode } from '@/demo/demoMode'+import { inboxFromReports } from '@/model/adapters/inbox'import { reportFixture } from '@/model/adapters/testFixtures'+import { snoozeKey } from '../snooze/snoozeEntries'+import { useSnoozeStore } from '../snooze/snoozeStore'+import { useInboxItems, useMarkReadOnOpen, useSetReportRead } from './hooks'jest.mock('@react-native-async-storage/async-storage', () =>@@ -42,6 +47,7 @@ describe('inbox hooks', () => {beforeEach(() => {posted.length = 0+ useSnoozeStore.setState({ entries: {} })jest.spyOn(AppState, 'addEventListener').mockReturnValue({ remove: () => undefined })setAuthProvider({getAuth: () => ({ host: 'https://app.example.com', accessToken: 'token', projectId: 2, session: 1 }),@@ -385,6 +391,8 @@ describe('inbox hooks', () => {test.each(['server error', 'invalid page', 'invalid report'])('pages through the ranking, retrying after %s only when asked, reading states once per page',async (failure) => {+ let now = Date.now()+ jest.spyOn(Date, 'now').mockImplementation(() => now)const offsets: string[] = []const readStateBatches: string[][] = []const firstPage = Array.from({ length: INBOX_PAGE_SIZE }, (_, index) => reportFixture({ id: `r${index}` }))@@ -421,6 +429,9 @@ describe('inbox hooks', () => {await waitFor(() => expect(result.current.data).toHaveLength(INBOX_PAGE_SIZE))expect(result.current.hasMore).toBe(true)+ await waitFor(() => expect(queryClient.getQueryData<SavedInbox>(inboxCacheKey(scopeOf()))).toBeDefined())+ const firstCapture = queryClient.getQueryData<SavedInbox>(inboxCacheKey(scopeOf()))?.sourceUpdatedAt+ now += 60_000act(() => result.current.loadMore())await waitFor(() => expect(result.current.loadMoreFailed).toBe(true))expect(result.current.data).toHaveLength(INBOX_PAGE_SIZE)@@ -432,6 +443,11 @@ describe('inbox hooks', () => {await waitFor(() => expect(readStateBatches).toHaveLength(2))expect(result.current.hasMore).toBe(false)+ expect(queryClient.getQueryData<SavedInbox>(inboxCacheKey(scopeOf()))).toMatchObject({+ sourceUpdatedAt: firstCapture,+ })+ expect(queryClient.getQueryState(inboxCacheKey(scopeOf()))?.dataUpdatedAt).toBe(firstCapture)+ expect(queryClient.getQueryData<SavedInbox>(inboxCacheKey(scopeOf()))?.items).toHaveLength(INBOX_PAGE_SIZE)expect(offsets).toEqual(['0', String(INBOX_PAGE_SIZE), String(INBOX_PAGE_SIZE)])expect(readStateBatches.map((ids) => ids.length)).toEqual([INBOX_PAGE_SIZE, 1])}@@ -474,4 +490,83 @@ describe('inbox hooks', () => {expect(result.current.data?.map((item) => item.id).slice(0, 3)).toEqual(['last', 'r19', 'r18'])expect(result.current.data?.at(-1)?.id).toBe('r0')})+ test('preserves the first-page capture time through a delayed failed refresh', async () => {+ let now = Date.now()+ jest.spyOn(Date, 'now').mockImplementation(() => now)+ let fail!: (error: Error) => void+ let refreshing = false+ globalThis.fetch = jest.fn(async (url: string) => {+ if (new URL(url).pathname.endsWith('/read_state/')) return jsonResponse({ states: {} })+ if (refreshing)+ return new Promise<Response>((_resolve, reject) => {+ fail = reject+ })+ return jsonResponse({ count: 1, next: null, results: [reportFixture({ id: 'r1' })] })+ }) as typeof fetch+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: Infinity } } })+ const wrapper = ({ children }: { children: ReactNode }): ReactElement => (+ <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>+ )+ const hook = renderHook(() => useInboxItems(), { wrapper })+ const savedKey = inboxCacheKey(scopeOf())+ await waitFor(() => expect(queryClient.getQueryData<SavedInbox>(savedKey)).toBeDefined())+ const capturedAt = queryClient.getQueryData<SavedInbox>(savedKey)?.sourceUpdatedAt+ now += 60_000+ refreshing = true+ let pending: unknown+ act(() => {+ pending = hook.result.current.refetch()+ })+ await waitFor(() => expect(fail).toBeDefined())+ expect(queryClient.getQueryData<SavedInbox>(savedKey)?.sourceUpdatedAt).toBe(capturedAt)+ await act(async () => {+ fail(new TypeError('Offline'))+ await pending+ })+ expect(queryClient.getQueryData<SavedInbox>(savedKey)?.sourceUpdatedAt).toBe(capturedAt)+ expect(queryClient.getQueryState(savedKey)?.dataUpdatedAt).toBe(capturedAt)+ hook.unmount()+ queryClient.clear()+ })++ test('shows a saved inbox offline, then replaces it with a successful live list', async () => {+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: Infinity } } })+ const scope = scopeOf()+ const cached = inboxFromReports([reportFixture({ id: 'saved-report', status: 'pending_input' })])+ useSnoozeStore+ .getState()+ .put(snoozeKey(scope, 'saved-report'), { kind: 'signals', threshold: 10, at: new Date().toISOString() })+ const sourceUpdatedAt = Date.now() - 60_000+ queryClient.setQueryData<SavedInbox>(inboxCacheKey(scope), {+ items: cached,+ signalCounts: { 'saved-report': 12 },+ sourceUpdatedAt,+ })+ globalThis.fetch = jest.fn(async () => {+ throw new TypeError('Offline')+ }) as typeof fetch+ const wrapper = ({ children }: { children: ReactNode }): ReactElement => (+ <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>+ )+ const hook = renderHook(() => useInboxItems(), { wrapper })+ await waitFor(() => expect(hook.result.current.data?.[0]?.id).toBe('saved-report'))+ expect(hook.result.current.data?.[0]).toMatchObject({ needsInput: true })+ expect(hook.result.current.data?.[0]?.state).not.toBe('snoozed')+ globalThis.fetch = jest.fn(async (url: string) =>+ new URL(url).pathname.endsWith('/read_state/')+ ? jsonResponse({ states: {} })+ : jsonResponse({ results: [reportFixture({ id: 'live-report' })], count: 1, next: null })+ ) as typeof fetch+ await act(async () => {+ await hook.result.current.refetch()+ })+ await waitFor(() => expect(hook.result.current.data?.[0]?.id).toBe('live-report'))+ await waitFor(() =>+ expect(queryClient.getQueryData<SavedInbox>(inboxCacheKey(scope))?.signalCounts).toEqual({+ 'live-report': 12,+ })+ )+ hook.unmount()+ queryClient.clear()+ })})diff --git a/products/mobile/src/features/inbox/hooks.ts b/products/mobile/src/features/inbox/hooks.tsindex cdf909c62fbd..d9df6ab4c1ac 100644--- a/products/mobile/src/features/inbox/hooks.ts+++ b/products/mobile/src/features/inbox/hooks.ts@@ -2,14 +2,16 @@ import {type InfiniteData,type QueryClient,type QueryKey,+ skipToken,type UseQueryResult,useInfiniteQuery,useQueries,+ useQuery,useQueryClient,} from '@tanstack/react-query'import { useCallback, useEffect, useMemo, useRef, useState } from 'react'-import { NotSignedInError } from '@/api/client'+import { inboxCacheKey, type SavedInbox } from '@/api/readCacheKeys'import {fetchInboxPage,INBOX_PAGE_SIZE,@@ -54,7 +56,8 @@ export interface InboxQueryState extends QueryState<InboxItem[]> {unfiltered: readonly InboxItem[] | undefined}-type InboxPages = InfiniteData<InboxPageApi, number>+type CapturedInboxPage = InboxPageApi & { capturedAt?: number }+type InboxPages = InfiniteData<CapturedInboxPage, number>const noop = (): void => undefinedconst noMorePages = { hasMore: false, isLoadingMore: false, loadMoreFailed: false, loadMore: noop, retryLoadMore: noop }@@ -111,8 +114,12 @@ function nextOffset(lastPage: InboxPageApi, _pages: InboxPageApi[], lastOffset:// Refetching every loaded page ranks the whole list once per page, so a refresh starts again from the first page.function keepFirstPage(queryClient: QueryClient, scope: ProjectScope): void {- queryClient.setQueryData<InboxPages>(reportKeys.inbox(scope), (data) =>- data ? { pages: data.pages.slice(0, 1), pageParams: data.pageParams.slice(0, 1) } : data+ const key = reportKeys.inbox(scope)+ const updatedAt = queryClient.getQueryState(key)?.dataUpdatedAt+ queryClient.setQueryData<InboxPages>(+ key,+ (data) => (data ? { pages: data.pages.slice(0, 1), pageParams: data.pageParams.slice(0, 1) } : data),+ { updatedAt })}@@ -131,14 +138,21 @@ function useLiveInboxItems(const list = useInfiniteQuery({queryKey: reportKeys.inbox(scope),- queryFn: ({ pageParam, signal }) => fetchInboxPage(pageParam, signal),+ queryFn: async ({ pageParam, signal }): Promise<CapturedInboxPage> => {+ const page = await fetchInboxPage(pageParam, signal)+ return { ...page, capturedAt: Date.now() }+ },initialPageParam: 0,getNextPageParam: nextOffset,enabled: active,})+ const saved = useQuery<SavedInbox>({ queryKey: inboxCacheKey(scope), queryFn: skipToken })const reports = useMemo(() => (list.data ? reportsFromPages(list.data.pages) : undefined), [list.data])- const baseItems = useMemo(() => (reports ? inboxFromReports(reports) : undefined), [reports])- const signalCounts = useMemo(() => (reports ? signalCountsFromReports(reports) : {}), [reports])+ const baseItems = useMemo(() => (reports ? inboxFromReports(reports) : saved.data?.items), [reports, saved.data])+ const signalCounts = useMemo(+ () => (reports ? signalCountsFromReports(reports) : (saved.data?.signalCounts ?? {})),+ [reports, saved.data]+ )// One read-state request per page, so loading a page does not ask again for the pages before it.const pageIds = useMemo(@@ -168,6 +182,31 @@ function useLiveInboxItems(combine: mergeReadStates,})+ const firstPage = list.data?.pages[0]+ const capturedAt = firstPage?.capturedAt+ const savedCounts = useMemo(() => (firstPage ? signalCountsFromReports(firstPage.results) : {}), [firstPage])+ const savedItems = useMemo(+ () =>+ firstPage+ ? inboxFromReports(firstPage.results).map((item) => ({+ ...item,+ read: readStates[item.reportId] !== false,+ }))+ : undefined,+ [firstPage, readStates]+ )+ useEffect(() => {+ if (!active || !scope || !list.isSuccess || !savedItems || !capturedAt) return+ const key = inboxCacheKey(scope)+ const previous = queryClient.getQueryData<SavedInbox>(key)+ if (previous?.items === savedItems && previous.sourceUpdatedAt === capturedAt) return+ queryClient.setQueryData<SavedInbox>(+ key,+ { items: savedItems, signalCounts: savedCounts, sourceUpdatedAt: capturedAt },+ { updatedAt: capturedAt }+ )+ }, [active, scope, list.isSuccess, capturedAt, savedItems, savedCounts, queryClient])+const polling = active && appActive && refreshWhileVisibleconst wasPolling = useRef(polling)useEffect(() => {@@ -181,9 +220,11 @@ function useLiveInboxItems(if (!baseItems || !scope) {return undefined}- const withRead = baseItems.map((item) => ({ ...item, read: readStates[item.reportId] !== false }))+ const withRead = reports+ ? baseItems.map((item) => ({ ...item, read: readStates[item.reportId] !== false }))+ : baseItemsreturn applySnoozes(applyInboxFilters(withRead, filters, now.getTime()), snoozes, scope, now, signalCounts)- }, [baseItems, readStates, filters, snoozes, scope, now, signalCounts])+ }, [baseItems, reports, readStates, filters, snoozes, scope, now, signalCounts])const {refetch: refetchList,diff --git a/products/mobile/src/features/offlineCache.test.ts b/products/mobile/src/features/offlineCache.test.tsnew file mode 100644index 000000000000..c1267e94500f--- /dev/null+++ b/products/mobile/src/features/offlineCache.test.ts@@ -0,0 +1,296 @@+import { act, waitFor } from '@testing-library/react-native'+import { AppState } from 'react-native'++let mockOwner = { host: 'https://example.com', userUuid: 'user-1' }+let mockTokens = true+let mockReadGate: Promise<void> | undefined+const mockDigestGates = new Map<string, Promise<void>>()+const mockValues = new Map<string, string>()+const mockReads: string[] = []+const mockEndTasks = new Set<() => Promise<void>>()++jest.mock('expo-crypto', () => ({+ CryptoDigestAlgorithm: { SHA256: 'SHA256' },+ digestStringAsync: async (_algorithm: string, input: string) => {+ await mockDigestGates.get(input)+ return input.replace(/\W/g, '_')+ },+}))+jest.mock('@/auth/tokens', () => ({+ getSessionTokens: () => (mockTokens ? {} : null),+ getSessionIdentity: () => mockOwner,+}))+jest.mock('@/auth/authStore', () => {+ const { create } = jest.requireActual<typeof import('zustand')>('zustand')+ return {+ useAuthStore: create(() => ({+ signedIn: true,+ host: 'https://example.com',+ user: { uuid: 'user-1' },+ projectId: 1,+ })),+ addSessionEndTask: (task: () => Promise<void>) => {+ mockEndTasks.add(task)+ return () => {+ mockEndTasks.delete(task)+ }+ },+ }+})+jest.mock('@/features/views/viewsCache', () => {+ const { create } = jest.requireActual<typeof import('zustand')>('zustand')+ return { useItemErrors: create(() => ({ errors: {} })) }+})+jest.mock('@/features/views/useViewsAccess', () => {+ const { create } = jest.requireActual<typeof import('zustand')>('zustand')+ return { useScopeErrorStore: create(() => ({ reported: { views: null, errors: null, replay: null } })) }+})+jest.mock('@/lib/secureStorage', () => ({+ secureStorage: {+ getItem: async (key: string) => {+ mockReads.push(key)+ await mockReadGate+ return mockValues.get(key) ?? null+ },+ setItem: async (key: string, value: string) => {+ mockValues.set(key, value)+ },+ removeItem: async (key: string) => {+ mockValues.delete(key)+ },+ },+}))++import { ApiError } from '@/api/client'+import { queryClient } from '@/api/queryClient'+import { useAuthStore } from '@/auth/authStore'+import { useScopeErrorStore } from '@/features/views/useViewsAccess'+import { useItemErrors } from '@/features/views/viewsCache'+import { installOfflineCache } from './offlineCache'++function account(user = 'user-1', host = 'https://example.com'): string {+ return `mobile-read-cache-v1-${JSON.stringify([host, user]).replace(/\W/g, '_')}`+}+function seed(projectId: number, user = 'user-1'): readonly unknown[] {+ const key = ['views', 'https://example.com', projectId, 'web', '-']+ mockValues.set(+ `${account(user)}.${projectId}`,+ JSON.stringify([{ key, updatedAt: Date.now() - 1000, data: { metrics: [], readAt: Date.now() - 1000 } }])+ )+ const index = `${account(user)}.scopes`+ const scopes: string[] = JSON.parse(mockValues.get(index) ?? '[]')+ mockValues.set(index, JSON.stringify([...new Set([...scopes, `${account(user)}.${projectId}`])]))+ return key+}++describe('authenticated offline-cache lifecycle', () => {+ beforeEach(() => {+ mockOwner = { host: 'https://example.com', userUuid: 'user-1' }+ mockTokens = true+ mockReadGate = undefined+ mockDigestGates.clear()+ mockValues.clear()+ mockReads.length = 0+ useScopeErrorStore.setState({ reported: { views: null, errors: null, replay: null } })+ queryClient.clear()+ useItemErrors.setState({ errors: {} })+ useAuthStore.setState({+ signedIn: true,+ host: 'https://example.com',+ user: { uuid: 'user-1', distinctId: 'user-1', email: '[email protected]', name: 'Example' },+ projectId: 1,+ })+ jest.spyOn(AppState, 'addEventListener').mockReturnValue({ remove: () => undefined })+ })+ afterEach(() => {+ jest.restoreAllMocks()+ queryClient.clear()+ })++ test.each(['digest', 'load'])(+ 'does not hydrate project 1 after switching while its %s is pending',+ async (stage) => {+ const first = seed(1)+ const second = seed(2)+ let finish!: () => void+ const gate = new Promise<void>((resolve) => {+ finish = resolve+ })+ if (stage === 'digest') mockDigestGates.set(JSON.stringify(['https://example.com', 'user-1']), gate)+ else mockReadGate = gate+ const stop = installOfflineCache()+ await act(async () => {+ useAuthStore.setState({ projectId: 2 })+ finish()+ })+ await waitFor(() => expect(queryClient.getQueryData(second)).toBeDefined())+ expect(queryClient.getQueryData(first)).toBeUndefined()+ stop()+ }+ )++ it('requires the secure owner to match before reading cached data', async () => {+ const key = seed(1)+ mockOwner = { host: 'https://example.com', userUuid: 'other-user' }+ const stop = installOfflineCache()+ await act(async () => undefined)+ expect(queryClient.getQueryData(key)).toBeUndefined()+ stop()+ })++ it('purges the departing account after delayed hydration and leaves another account intact', async () => {+ const key = seed(1)+ seed(1, 'user-2')+ let finish!: () => void+ mockReadGate = new Promise<void>((resolve) => {+ finish = resolve+ })+ const stop = installOfflineCache()+ await act(async () => undefined)+ mockTokens = false+ const cleanup = Promise.all([...mockEndTasks].map((task) => task()))+ finish()+ await cleanup+ expect(queryClient.getQueryData(key)).toBeUndefined()+ expect(mockValues.has(`${account()}.1`)).toBe(false)+ expect(mockValues.has(`${account('user-2')}.1`)).toBe(true)+ stop()+ })+ it('does not hydrate the previous account into the next account while its read is pending', async () => {+ const key = seed(1)+ mockValues.set(+ `${account('user-2')}.1`,+ JSON.stringify([+ { key, updatedAt: Date.now() - 500, data: { metrics: [{ key: 'user-2' }], readAt: Date.now() - 500 } },+ ])+ )+ let finish!: () => void+ mockReadGate = new Promise<void>((resolve) => {+ finish = resolve+ })+ const stop = installOfflineCache()+ await waitFor(() => expect(mockReads).toContain(`${account()}.1`))+ await act(async () => {+ mockOwner = { host: 'https://example.com', userUuid: 'user-2' }+ useAuthStore.setState({+ user: { uuid: 'user-2', distinctId: 'user-2', email: '[email protected]', name: 'Other' },+ })+ finish()+ })+ await waitFor(() => expect(queryClient.getQueryData(key)).toMatchObject({ metrics: [{ key: 'user-2' }] }))+ stop()+ })+ it('does not restore an inbox refused before the account digest finishes', async () => {+ const key = ['read-inbox', 'https://example.com', 1]+ mockValues.set(+ `${account()}.1`,+ JSON.stringify([+ { key, updatedAt: Date.now() - 1000, data: { items: [], sourceUpdatedAt: Date.now() - 1000 } },+ ])+ )+ let finish!: () => void+ mockDigestGates.set(+ JSON.stringify(['https://example.com', 'user-1']),+ new Promise<void>((resolve) => {+ finish = resolve+ })+ )+ const stop = installOfflineCache()+ await queryClient+ .fetchQuery({+ queryKey: ['signals', 'https://example.com', 1, 'inbox'],+ queryFn: async () => {+ throw new ApiError(403, {})+ },+ retry: false,+ })+ .catch(() => undefined)+ finish()+ await waitFor(() => expect(JSON.parse(mockValues.get(`${account()}.1`) ?? '[]')).toEqual([]))+ expect(queryClient.getQueryData(key)).toBeUndefined()+ stop()+ })++ test.each(['view-error', 'query-error'] as const)(+ 'evicts the original project after a late %s across a project switch',+ async (source) => {+ const first = seed(1)+ const second = seed(2)+ let stop = installOfflineCache()+ await waitFor(() => expect(queryClient.getQueryData(first)).toBeDefined())+ let deny = (): void => undefined+ const request =+ source === 'query-error'+ ? queryClient+ .fetchQuery({+ queryKey: first,+ staleTime: 0,+ queryFn: () =>+ new Promise<never>((_resolve, reject) => {+ deny = () => reject(new ApiError(403, {}))+ }),+ retry: false,+ })+ .catch(() => undefined)+ : Promise.resolve()+ await act(async () => {+ useAuthStore.setState({ projectId: 2 })+ })+ await waitFor(() => expect(queryClient.getQueryData(second)).toBeDefined())+ await act(async () => {+ if (source === 'view-error') {+ queryClient.removeQueries({ queryKey: first })+ useItemErrors.setState({ errors: { [JSON.stringify(first)]: 'no_access' } })+ }+ deny()+ await request+ })+ await waitFor(() => expect(mockValues.has(`${account()}.1`)).toBe(false))+ expect(queryClient.getQueryData(second)).toBeDefined()+ stop()+ queryClient.clear()+ useItemErrors.setState({ errors: {} })+ useAuthStore.setState({ projectId: 1 })+ stop = installOfflineCache()+ await act(async () => undefined)+ expect(queryClient.getQueryData(first)).toBeUndefined()+ stop()+ }+ )++ it('clears Views from unvisited saved projects after a scope denial and preserves inbox and other accounts', async () => {+ const first = seed(1)+ const unvisited = seed(2)+ seed(2, 'user-2')+ const inbox = ['read-inbox', 'https://example.com', 2]+ const saved = JSON.parse(mockValues.get(`${account()}.2`) ?? '[]')+ saved.push({+ key: inbox,+ updatedAt: Date.now() - 1000,+ data: { items: [], sourceUpdatedAt: Date.now() - 1000 },+ })+ mockValues.set(`${account()}.2`, JSON.stringify(saved))+ let stop = installOfflineCache()+ await waitFor(() => expect(queryClient.getQueryData(first)).toBeDefined())+ useScopeErrorStore.setState({ reported: { views: 'insights:read', errors: null, replay: null } })+ await waitFor(() => expect(mockValues.get(`${account()}.2`)).not.toContain('"views"'))+ stop()+ queryClient.clear()+ useScopeErrorStore.setState({ reported: { views: null, errors: null, replay: null } })+ useAuthStore.setState({ projectId: 2 })+ stop = installOfflineCache()+ await waitFor(() => expect(queryClient.getQueryData(inbox)).toBeDefined())+ expect(queryClient.getQueryData(unvisited)).toBeUndefined()+ expect(mockValues.get(`${account('user-2')}.2`)).toContain('"views"')+ stop()+ })++ it('does not rehydrate views when the existing access gate reports a missing scope', async () => {+ const key = seed(1)+ useScopeErrorStore.setState({ reported: { views: 'insights:read', errors: null, replay: null } })+ const stop = installOfflineCache()+ await waitFor(() => expect(JSON.parse(mockValues.get(`${account()}.1`) ?? '[]')).toEqual([]))+ expect(queryClient.getQueryData(key)).toBeUndefined()+ stop()+ })+})diff --git a/products/mobile/src/features/offlineCache.ts b/products/mobile/src/features/offlineCache.tsnew file mode 100644index 000000000000..27afc37262db--- /dev/null+++ b/products/mobile/src/features/offlineCache.ts@@ -0,0 +1,139 @@+import type { QueryKey } from '@tanstack/react-query'+import * as Crypto from 'expo-crypto'+import { AppState } from 'react-native'+import { queryClient } from '@/api/queryClient'+import { persistReadCache } from '@/api/readCache'+import { ReadCacheStore } from '@/api/readCacheStore'+import { missingViewsScope } from '@/api/scopeErrors'+import { addSessionEndTask, useAuthStore } from '@/auth/authStore'+import { getSessionIdentity, getSessionTokens } from '@/auth/tokens'+import { useScopeErrorStore } from '@/features/views/useViewsAccess'+import { useItemErrors } from '@/features/views/viewsCache'+import { secureStorage } from '@/lib/secureStorage'++const store = new ReadCacheStore(secureStorage)++function identity(): string | null {+ const state = useAuthStore.getState()+ const owner = getSessionIdentity()+ return getSessionTokens() &&+ state.signedIn &&+ state.host &&+ state.user &&+ state.projectId !== null &&+ owner?.host === state.host &&+ owner.userUuid === state.user.uuid+ ? JSON.stringify([state.host, state.user.uuid, state.projectId])+ : null+}++async function accountKey(host: string, userId: string): Promise<string> {+ const hash = await Crypto.digestStringAsync(Crypto.CryptoDigestAlgorithm.SHA256, JSON.stringify([host, userId]))+ return `mobile-read-cache-v1-${hash}`+}++function viewsScopeDenied(): boolean {+ const tokens = getSessionTokens()+ return (+ useScopeErrorStore.getState().reported.views !== null ||+ (tokens?.kind === 'oauth' && missingViewsScope(tokens.grantedScopes) !== null)+ )+}++export function installOfflineCache(): () => void {+ let active: ReturnType<typeof persistReadCache> | undefined+ const sessions = new Map<string, ReturnType<typeof persistReadCache>>()+ let owner: string | null = null+ let previous: string | null = null+ let generation = 0+ const update = (): void => {+ const target = identity()+ if (target === previous) return+ previous = target+ const mine = ++generation+ active?.pause()+ active = undefined+ const nextOwner = target ? JSON.stringify(JSON.parse(target).slice(0, 2)) : null+ if (owner !== nextOwner) {+ for (const session of sessions.values()) session.stop()+ sessions.clear()+ owner = nextOwner+ }+ if (!target) return+ const state = useAuthStore.getState()+ if (!state.host || !state.user || state.projectId === null) return+ const { host, projectId } = state+ void accountKey(host, state.user.uuid)+ .then(async (account) => {+ if (mine !== generation || identity() !== target) return+ if (viewsScopeDenied()) await store.evictAccountViews(account, host)+ if (mine !== generation || identity() !== target) return+ active = persistReadCache(+ queryClient,+ store,+ { account, host, projectId },+ () => identity() === target,+ (key) =>+ key[0] === 'views' &&+ (viewsScopeDenied() ||+ ['deleted', 'no_access', 'scope'].includes(+ useItemErrors.getState().errors[JSON.stringify(key)] ?? ''+ )),+ () => {+ const verified = identity()+ return verified !== null && JSON.stringify(JSON.parse(verified).slice(0, 2)) === nextOwner+ }+ )+ sessions.get(target)?.stop()+ sessions.set(target, active)+ })+ .catch(() => undefined)+ }+ const unsubscribe = useAuthStore.subscribe(update)+ const purge = (): void => {+ const keys: QueryKey[] = []+ for (const key of Object.keys(useItemErrors.getState().errors)) {+ try {+ const parsed: unknown = JSON.parse(key)+ if (Array.isArray(parsed)) keys.push(parsed)+ } catch {}+ }+ for (const session of sessions.values()) session.purgeDeniedViews(keys)+ const target = identity()+ if (!target || !viewsScopeDenied()) return+ const [host, userId] = JSON.parse(target) as [string, string, number]+ void accountKey(host, userId)+ .then(async (account) => {+ const verified = identity()+ if (!verified || JSON.stringify(JSON.parse(verified).slice(0, 2)) !== JSON.stringify([host, userId]))+ return+ await store.evictAccountViews(account, host)+ })+ .catch(() => undefined)+ }+ const unsubscribeErrors = useItemErrors.subscribe(purge)+ const unsubscribeScopes = useScopeErrorStore.subscribe(purge)+ const unsubscribeEnd = addSessionEndTask(async () => {+ generation+++ previous = null+ for (const session of sessions.values()) session.stop()+ sessions.clear()+ active = undefined+ const state = useAuthStore.getState()+ if (state.host && state.user) await store.clearAccount(await accountKey(state.host, state.user.uuid))+ })+ const appState = AppState.addEventListener('change', (state) => {+ if (state !== 'active') void active?.flush()+ })+ update()+ return () => {+ generation+++ for (const session of sessions.values()) session.stop()+ sessions.clear()+ unsubscribe()+ unsubscribeErrors()+ unsubscribeScopes()+ unsubscribeEnd()+ appState.remove()+ }+}diff --git a/products/mobile/src/features/views/freshness.test.ts b/products/mobile/src/features/views/freshness.test.tsindex db7cd3992db8..4c4ee5b5664c 100644--- a/products/mobile/src/features/views/freshness.test.ts+++ b/products/mobile/src/features/views/freshness.test.ts@@ -85,6 +85,19 @@ describe('freshness', () => {false,"Couldn't refresh. Updated 1 min ago",],+ ['a saved device snapshot', [snap({ restoredFromDevice: true })], false, 'Updated 10 min ago'],+ [+ 'a saved snapshot without a refresh time',+ [snap({ restoredFromDevice: true, lastRefreshAt: null })],+ false,+ null,+ ],+ [+ 'a failed refresh of a saved snapshot',+ [snap({ restoredFromDevice: true, refreshFailed: true })],+ false,+ "Couldn't refresh. Updated 10 min ago",+ ],['no data items', [undefined, snap({ lastRefreshAt: null })], false, null],])('statusLine for %s', (_name, snapshots, busy, expected) => {expect(statusLine(snapshots, busy, T).text).toBe(expected)diff --git a/products/mobile/src/features/views/offlineViews.test.tsx b/products/mobile/src/features/views/offlineViews.test.tsxnew file mode 100644index 000000000000..bfbc0f39d5e8--- /dev/null+++ b/products/mobile/src/features/views/offlineViews.test.tsx@@ -0,0 +1,104 @@+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'+import { act, renderHook, waitFor } from '@testing-library/react-native'+import type { ReactElement, ReactNode } from 'react'++import { setAuthProvider } from '@/api/client'+import { persistReadCache } from '@/api/readCache'+import { ReadCacheStore } from '@/api/readCacheStore'+import { useAuthStore } from '@/auth/authStore'+import { setSessionTokens } from '@/auth/tokens'+import { demoAnchor, demoInsightResponse } from '@/demo/views'+import { insightSnapshot } from '@/model/adapters/insightSnapshot'++import { insightQueryKey } from './items'+import { useViewsList } from './pinHooks'+import { useDeviceRecent } from './recentStore'+import { viewsQueue } from './refreshQueue'+import { useInsightScreen } from './viewHooks'++const scope = { host: 'https://example.com', projectId: 1 }+jest.mock('expo-router', () => ({ useFocusEffect: () => {}, useIsFocused: () => false }))+jest.mock('@/demo/demoMode', () => ({ ...jest.requireActual('@/demo/demoMode'), useDataMode: () => 'live' }))++let client: QueryClient+function wrapper({ children }: { children: ReactNode }): ReactElement {+ return <QueryClientProvider client={client}>{children}</QueryClientProvider>+}++describe('cold offline Views navigation', () => {+ it('opens a saved insight from the device Recent list without loading shortcuts or metadata', async () => {+ await useAuthStore.persist.rehydrate()+ await useDeviceRecent.persist.rehydrate()+ const values = new Map<string, string>()+ const store = new ReadCacheStore({+ getItem: async (key) => values.get(key) ?? null,+ setItem: async (key, value) => {+ values.set(key, value)+ },+ removeItem: async (key) => {+ values.delete(key)+ },+ })+ const cacheScope = { ...scope, account: 'example-account' }+ const shortId = 'demo-ins-signups'+ const response = demoInsightResponse({ shortId, dashboardRef: null, override: null }, demoAnchor())+ if (!response) throw new Error('Missing demo insight')+ const snapshot = insightSnapshot(response, undefined, { readAt: Date.now(), serverNow: Date.now() })+ const source = new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: Infinity } } })+ const session = persistReadCache(source, store, cacheScope, () => true)+ await session.ready+ source.setQueryData(insightQueryKey(scope, { shortId, dashboardRef: null, override: null }), snapshot)+ await session.flush()+ session.stop()+ source.clear()+ useDeviceRecent.getState().record(`${scope.host}|${scope.projectId}`, {+ kind: 'insight',+ ref: shortId,+ name: snapshot.name,+ viewedAt: new Date().toISOString(),+ })+ useAuthStore.setState({+ status: 'signed_in',+ signedIn: true,+ host: scope.host,+ projectId: 1,+ method: 'personal_api_key',+ user: { uuid: 'example-user', distinctId: 'example-user', email: '[email protected]', name: 'Example' },+ })+ setSessionTokens({+ kind: 'personal_api_key',+ accessToken: 'example-token',+ refreshToken: null,+ expiresAt: null,+ grantedScopes: null,+ requestedScopes: null,+ })+ setAuthProvider({+ getAuth: () => ({ ...scope, accessToken: 'example-token', session: 1 }),+ refreshAccessToken: async () => null,+ })+ globalThis.fetch = jest.fn(async () => {+ throw new TypeError('Offline')+ }) as typeof fetch+ client = new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: Infinity } } })+ const restored = persistReadCache(client, store, cacheScope, () => true)+ await restored.ready+ const list = renderHook(() => useViewsList(), { wrapper })+ await waitFor(() => expect(list.result.current.recent.data?.some((item) => item.ref === shortId)).toBe(true))+ const insight = renderHook(() => useInsightScreen(shortId, { from: 'recent' }), { wrapper })+ await waitFor(() => expect(insight.result.current.insight.data?.value).toBe(snapshot.value))+ expect(insight.result.current.insight.data?.restoredFromDevice).toBe(true)+ expect(insight.result.current.refresh.status.text).toMatch(+ /^(?:Couldn't refresh\. )?Updated \d+ (?:min|h) ago$/+ )+ await act(async () => {+ insight.unmount()+ list.unmount()+ })+ restored.stop()+ client.clear()+ viewsQueue.reset()+ setAuthProvider(null)+ setSessionTokens(null)+ })+})diff --git a/products/mobile/src/lib/secureStorage.ts b/products/mobile/src/lib/secureStorage.tsnew file mode 100644index 000000000000..ada2d2e24cf8--- /dev/null+++ b/products/mobile/src/lib/secureStorage.ts@@ -0,0 +1,151 @@+import * as Crypto from 'expo-crypto'+import * as SecureStore from 'expo-secure-store'+import { Platform } from 'react-native'++export interface StringStorage {+ getItem: (key: string) => Promise<string | null>+ setItem: (key: string, value: string) => Promise<void>+ removeItem: (key: string) => Promise<void>+}++const webMemory = new Map<string, string>()+const itemStorage: StringStorage = {+ getItem: (key) =>+ Platform.OS === 'web' ? Promise.resolve(webMemory.get(key) ?? null) : SecureStore.getItemAsync(key),+ setItem: async (key, value) => {+ if (Platform.OS === 'web') {+ webMemory.set(key, value)+ } else {+ await SecureStore.setItemAsync(key, value)+ }+ },+ removeItem: async (key) => {+ if (Platform.OS === 'web') {+ webMemory.delete(key)+ } else {+ await SecureStore.deleteItemAsync(key)+ }+ },+}++interface Manifest {+ revision: string+ count: number+}++function asManifest(value: unknown): Manifest | null {+ if (value && typeof value === 'object') {+ const record = value as Record<string, unknown>+ if (+ typeof record.revision === 'string' &&+ typeof record.count === 'number' &&+ Number.isSafeInteger(record.count) &&+ record.count > 0 &&+ record.count <= 10000+ ) {+ return { revision: record.revision, count: record.count }+ }+ }+ return null+}++async function storedJson(key: string): Promise<unknown> {+ const raw = await itemStorage.getItem(key)+ try {+ return JSON.parse(raw ?? 'null')+ } catch {+ return null+ }+}++async function revisions(key: string): Promise<Manifest[]> {+ const value = await storedJson(`${key}.revisions`)+ return Array.isArray(value) ? value.map(asManifest).filter((entry): entry is Manifest => entry !== null) : []+}++async function complete(work: Promise<void>[]): Promise<void> {+ // Settle every native operation before cleanup can remove partially written chunks.+ const results = await Promise.allSettled(work)+ const failed = results.find((result) => result.status === 'rejected')+ if (failed?.status === 'rejected') throw failed.reason+}++async function removeChunks(key: string, saved: Manifest | null): Promise<void> {+ if (saved) {+ await complete(+ Array.from({ length: saved.count }, (_, index) =>+ itemStorage.removeItem(`${key}.${saved.revision}.${index}`)+ )+ )+ }+}++async function recover(key: string): Promise<Manifest | null> {+ const saved = asManifest(await storedJson(key))+ const journal = await revisions(key)+ for (const entry of journal) {+ if (entry.revision !== saved?.revision) await removeChunks(key, entry)+ }+ if (journal.length) await itemStorage.removeItem(`${key}.revisions`)+ return saved+}++const operations = new Map<string, Promise<unknown>>()++function serialized<T>(key: string, work: () => Promise<T>): Promise<T> {+ const result = (operations.get(key) ?? Promise.resolve()).then(work)+ const settled = result.catch(() => undefined)+ operations.set(key, settled)+ void settled.then(() => {+ if (operations.get(key) === settled) operations.delete(key)+ })+ return result+}++// Each chunk stays below SecureStore's 2 KiB limit even for non-ASCII text. The journal retains+// unfinished revisions across restarts, while the manifest points to the last complete value.+export const secureStorage: StringStorage = {+ getItem: (key) =>+ serialized(key, async () => {+ const saved = await recover(key)+ if (!saved) return null+ const parts = await Promise.all(+ Array.from({ length: saved.count }, (_, index) =>+ itemStorage.getItem(`${key}.${saved.revision}.${index}`)+ )+ )+ if (parts.some((part) => part === null)) throw new Error('Incomplete secure storage value')+ return parts.join('')+ }),+ setItem: (key, value) =>+ serialized(key, async () => {+ const previous = await recover(key)+ const revision = Crypto.randomUUID()+ const characters = Array.from(value)+ const parts: string[] = []+ for (let index = 0; index < characters.length; index += 500) {+ parts.push(characters.slice(index, index + 500).join(''))+ }+ if (!parts.length) parts.push('')+ const next = { revision, count: parts.length }+ await itemStorage.setItem(`${key}.revisions`, JSON.stringify(previous ? [previous, next] : [next]))+ try {+ await complete(parts.map((part, index) => itemStorage.setItem(`${key}.${revision}.${index}`, part)))+ await itemStorage.setItem(key, JSON.stringify(next))+ } catch (error) {+ await recover(key).catch(() => undefined)+ throw error+ }+ await recover(key)+ }),+ removeItem: (key) =>+ serialized(key, async () => {+ const previous = asManifest(await storedJson(key))+ const journal = await revisions(key)+ if (previous && !journal.some((entry) => entry.revision === previous.revision)) journal.push(previous)+ if (journal.length) await itemStorage.setItem(`${key}.revisions`, JSON.stringify(journal))+ await itemStorage.removeItem(key)+ for (const entry of journal) await removeChunks(key, entry)+ if (journal.length) await itemStorage.removeItem(`${key}.revisions`)+ }),+}diff --git a/products/mobile/src/model/adapters/insightSnapshot.ts b/products/mobile/src/model/adapters/insightSnapshot.tsindex 05f9b7393416..99f5c87561cc 100644--- a/products/mobile/src/model/adapters/insightSnapshot.ts+++ b/products/mobile/src/model/adapters/insightSnapshot.ts@@ -494,6 +494,7 @@ export function insightSnapshot(inProgressFrom: null,capabilities: capabilitiesOf(query),computed: false,+ dataReadAt: 0,}}const resolvedRange = resolvedRangeOf(response)@@ -523,6 +524,7 @@ export function insightSnapshot(nextAllowedRefreshAt: response.next_allowed_client_refresh,readAt: context.readAt,refreshFailed: false,+ dataReadAt: context.readAt,resolvedRange,timezone: response.timezone ?? null,interval,diff --git a/products/mobile/src/model/adapters/readCache.ts b/products/mobile/src/model/adapters/readCache.tsnew file mode 100644index 000000000000..ac8f9524d1d7--- /dev/null+++ b/products/mobile/src/model/adapters/readCache.ts@@ -0,0 +1,158 @@+import type { QueryKey } from '@tanstack/react-query'+import type { ProjectScope } from '@/api/reports'+import { asRecord } from '@/lib/records'++export function isReadCacheKey(key: QueryKey, scope: ProjectScope): boolean {+ if (key[1] !== scope.host || key[2] !== scope.projectId) return false+ if (key[0] === 'read-inbox') return key.length === 3+ if (key[0] !== 'views') return false+ const lengths: Record<string, number> = { insight: 7, web: 5, dashboard: 6 }+ return key.length === lengths[String(key[3])]+}++export function cacheable(key: QueryKey, data: unknown, scope: ProjectScope): boolean {+ if (!isReadCacheKey(key, scope)) return false+ const value = asRecord(data)+ if (!value) return false+ if (key[0] === 'read-inbox') return Array.isArray(value.items) && typeof value.sourceUpdatedAt === 'number'+ if (key[3] === 'insight')+ return (+ ['TrendsQuery', 'FunnelsQuery', 'RetentionQuery'].includes(String(value.queryKind)) &&+ value.sqlTable === null &&+ !rawQueryPayload(value.query)+ )+ if (key[3] === 'web') return Array.isArray(value.metrics)+ return Array.isArray(asRecord(value.view)?.tiles)+}++function fields(value: Record<string, unknown>, names: readonly string[]): Record<string, unknown> {+ return Object.fromEntries(names.filter((name) => name in value).map((name) => [name, value[name]]))+}++function rawQueryPayload(value: unknown, depth = 0): boolean {+ if (depth > 16) return true+ if (Array.isArray(value)) return value.some((item) => rawQueryPayload(item, depth + 1))+ const record = asRecord(value)+ return (+ !!record &&+ (['HogQLQuery', 'ActorsQuery', 'EventsQuery', 'PersonsNode'].includes(String(record.kind)) ||+ Object.entries(record).some(+ ([name, child]) =>+ ['response', 'results', 'actors', 'persons'].includes(name) || rawQueryPayload(child, depth + 1)+ ))+ )+}++export function projectedData(key: QueryKey, data: unknown): unknown {+ const value = asRecord(data)+ if (!value) return null+ if (key[0] === 'read-inbox')+ return {+ sourceUpdatedAt: value.sourceUpdatedAt,+ signalCounts: value.signalCounts,+ items: Array.isArray(value.items)+ ? value.items.map((item) =>+ fields(asRecord(item) ?? {}, [+ 'id',+ 'reportId',+ 'title',+ 'sourceProduct',+ 'sourceLabel',+ 'sources',+ 'accent',+ 'createdAt',+ 'updatedAt',+ 'modelScore',+ 'reason',+ 'state',+ 'needsInput',+ 'read',+ 'agent',+ 'pullRequestUrl',+ 'pullRequestState',+ ])+ )+ : [],+ }+ if (key[3] === 'dashboard') {+ const view = asRecord(value.view) ?? {}+ return {+ readAt: value.readAt,+ refreshFailed: value.refreshFailed,+ restoredFromDevice: value.restoredFromDevice,+ view: {+ ...fields(view, ['id', 'name', 'description', 'savedRange', 'lastRefresh']),+ tiles: Array.isArray(view.tiles)+ ? view.tiles.map((tile) =>+ fields(asRecord(tile) ?? {}, [+ 'tileId',+ 'kind',+ 'insightId',+ 'shortId',+ 'name',+ 'text',+ 'usesOwnRange',+ 'ignoresRangeOverride',+ 'capabilities',+ 'kindLabel',+ 'seriesCount',+ 'hasBreakdown',+ ])+ )+ : [],+ },+ }+ }+ if (key[3] === 'web')+ return fields(value, [+ 'metrics',+ 'resolvedRange',+ 'timezone',+ 'computed',+ 'lastRefreshAt',+ 'cacheTargetAge',+ 'nextAllowedRefreshAt',+ 'readAt',+ 'dataReadAt',+ 'refreshFailed',+ 'restoredFromDevice',+ ])+ return fields(value, [+ 'insightId',+ 'shortId',+ 'name',+ 'description',+ 'queryKind',+ 'query',+ 'resolvedRange',+ 'timezone',+ 'savedRange',+ 'interval',+ 'format',+ 'value',+ 'valueAt',+ 'previous',+ 'delta',+ 'series',+ 'allSeries',+ 'chartKind',+ 'funnel',+ 'retention',+ 'ranking',+ 'sqlTable',+ 'inProgressFrom',+ 'usesOwnRange',+ 'capabilities',+ 'kindLabel',+ 'computed',+ 'createdBy',+ 'createdAt',+ 'lastRefreshAt',+ 'cacheTargetAge',+ 'nextAllowedRefreshAt',+ 'readAt',+ 'dataReadAt',+ 'refreshFailed',+ 'restoredFromDevice',+ ])+}diff --git a/products/mobile/src/model/adapters/webOverview.ts b/products/mobile/src/model/adapters/webOverview.tsindex 256cb5183604..fd8e88d0ee75 100644--- a/products/mobile/src/model/adapters/webOverview.ts+++ b/products/mobile/src/model/adapters/webOverview.ts@@ -70,11 +70,13 @@ export function webOverviewSnapshot(nextAllowedRefreshAt: null,readAt,refreshFailed: failed,+ dataReadAt: 0,}}const range = response.resolved_date_rangereturn {metrics: (response.results ?? []).map(metricOf),+ dataReadAt: readAt,resolvedRange: range?.date_from && range.date_to ? { from: range.date_from, to: range.date_to } : null,timezone: response.timezone ?? null,computed: response.is_cached === false,diff --git a/products/mobile/src/model/views.ts b/products/mobile/src/model/views.tsindex 5de1b9dafa49..77f9a3cfcc27 100644--- a/products/mobile/src/model/views.ts+++ b/products/mobile/src/model/views.ts@@ -66,6 +66,9 @@ export interface DeviceRecentEntry {/** The refresh fields of one data item. They change only on a response with a result and no error. */export interface Freshness {+ restoredFromDevice?: boolean+ /** Cache-only misses must not renew the age of the last successful result. */+ dataReadAt?: numberlastRefreshAt: string | nullcacheTargetAge: string | nullnextAllowedRefreshAt: string | null