type Query = Record; export interface CatalogResult { ok: boolean; data?: unknown; message?: string; aborted?: boolean; code?: string; status?: number; authExpired?: boolean; wpSessionExpired?: boolean } export type CatalogRequest = (kind: string, query: Query, signal: AbortSignal) => Promise; interface RecoveryWindow extends Window { FotogenicAI?: { Shared?: { api?: { restFetch?: { readWithRecovery?: (read: (signal: AbortSignal) => Promise, options: { signal: AbortSignal; timeoutMs?: number }) => Promise; } } } } } /** All catalog readers share the REST owner's bounded read budget. */ export const readWithRecovery = (read: (signal: AbortSignal) => Promise, signal: AbortSignal): Promise => { const recover = (window as RecoveryWindow).FotogenicAI?.Shared?.api?.restFetch?.readWithRecovery; if (!recover) throw new Error('The shared request service is unavailable.'); return recover(read, { signal }); }; interface Operation { promise: Promise; controller: AbortController; consumers: number; settled: boolean; refresh: boolean } interface Entry { kind: string; data: unknown; expires: number } const TTL = 300000; const values = new Map(); const pending = new Map(); const revisions = new Map(); let ownerEpoch = 0; const validOwner = (value: unknown): value is string => typeof value === 'string' && value.length > 0 && value.length <= 255 && !/[\u0000-\u0020\u007f]/.test(value); let ownerKey = ''; export const catalogOwnerKey = (): string => ownerKey; const abortError = (): Error => Object.assign(new Error('The catalog request was cancelled.'), { name: 'AbortError' }); const namespace = (kind: string, query: Query): string => kind === 'models' ? `resource:models:${query.source || 'templates'}` : kind === 'environments' ? 'resource:environments' : 'presets'; const cacheKey = (scope: string, kind: string, query: Query): string => `${scope}|${JSON.stringify([ownerKey, ownerEpoch, kind, Object.entries(query).sort(([a], [b]) => a.localeCompare(b))])}`; const record = (value: unknown): Record => value !== null && typeof value === 'object' && !Array.isArray(value) ? value as Record : {}; const initialQuery = (kind: string, query: Record): query is Query => { const keys = Object.keys(query); if (kind === 'catalog' || kind === 'environments') return keys.length === 0; if (kind === 'presets') return keys.length === 1 && query.limit === '24'; return kind === 'models' && keys.length === 1 && ['templates', 'userCreated'].includes(String(query.source)); }; const seedData = (kind: string, value: unknown): boolean => { const data = record(value); if (kind === 'catalog') return data.schemaVersion === 1 && Array.isArray(data.categories) && Array.isArray(data.sections); if (!Array.isArray(data.items) || data.items.length > 24 || !data.items.every(item => { const row = record(item); return typeof row.id === 'string' && row.id.trim().length > 0 && typeof row[kind === 'presets' ? 'title' : 'name'] === 'string'; })) return false; return kind === 'presets' || typeof data.catalogChangeToken === 'string' && data.catalogChangeToken.trim().length > 0; }; try { const encoded = document.querySelector('[data-fa-catalog-cache]')?.textContent || '{}'; if (encoded.length <= 131072) { const seed = record(JSON.parse(encoded)); if (validOwner(seed.ownerKey)) ownerKey = seed.ownerKey; const generated = Number(seed.generatedAt); const navigationAge = typeof performance === 'object' && typeof performance.now === 'function' ? Math.max(0, performance.now()) : 0; if (ownerKey && Number.isSafeInteger(generated) && generated > 0 && Array.isArray(seed.entries) && seed.entries.length <= 5) { for (const value of seed.entries) { const row = record(value), query = record(row.query), remaining = Number(row.expiresAt) - generated; if (typeof row.kind !== 'string' || !initialQuery(row.kind, query) || !Number.isSafeInteger(row.expiresAt) || remaining <= navigationAge || remaining > TTL || !seedData(row.kind, row.data)) continue; const key = cacheKey(namespace(row.kind, query), row.kind, query); if (values.has(key)) continue; values.set(key, { kind: row.kind, data: row.data, expires: Date.now() + remaining - navigationAge }); } } } } catch (error) { console.warn('Fotogenic AI: catalog ownership could not be restored.', error instanceof Error ? error.name : 'Invalid data'); } let connected = Boolean(ownerKey); /** Fresh display data only. Detail always goes through the authenticated request owner. */ export const peekCatalog = (kind: string, query: Query): CatalogResult | null => { const entry = values.get(cacheKey(namespace(kind, query), kind, query)); return kind !== 'detail' && entry && entry.expires > Date.now() ? { ok: true, data: entry.data } : null; }; const clearScope = (scope: string): void => { revisions.set(scope, (revisions.get(scope) || 0) + 1); for (const key of values.keys()) if (key.startsWith(`${scope}|`)) values.delete(key); for (const [key, state] of pending) if (key.startsWith(`${scope}|`)) { state.controller.abort(); pending.delete(key); } }; export const clearCuratedMemory = (): void => { ['resource:models:templates', 'resource:models:userCreated', 'resource:environments'].forEach(clearScope); }; export const clearCatalogMemory = (): void => clearScope('presets'); /** Renew only current card metadata; list placement and the original expiry stay intact. */ export const updatePresetDisplay = (display: { id: string; title: string; preview: { src: string; alt: string; width?: number; height?: number } }): void => { for (const entry of values.values()) { if (entry.kind !== 'presets' || !entry.data || typeof entry.data !== 'object' || Array.isArray(entry.data)) continue; const data = entry.data as Record; if (!Array.isArray(data.items)) continue; let updated = false; const items = data.items.map((raw: unknown) => { if (!raw || typeof raw !== 'object' || Array.isArray(raw) || (raw as Record).id !== display.id) return raw; updated = true; return { ...raw, title: display.title, preview: { ...display.preview } }; }); if (updated) entry.data = { ...data, items }; } }; window.addEventListener('fotogenic-ai:auth-changed', (event) => { const detail = (event as CustomEvent<{ auth?: { cacheOwner?: unknown; connected?: unknown }; cacheOwner?: unknown; connected?: unknown }>).detail; const auth = detail?.auth || detail; const nextOwner = validOwner(auth?.cacheOwner) ? auth.cacheOwner : ''; const nextConnected = typeof auth?.connected === 'boolean' ? auth.connected : Boolean(nextOwner); if (nextOwner === ownerKey && nextConnected === connected) return; ownerKey = nextOwner; connected = nextConnected; ownerEpoch++; clearCatalogMemory(); clearCuratedMemory(); }); window.addEventListener('fotogenic-ai:reference-unavailable', clearCuratedMemory); /** A subscriber cancels only its own wait; the final subscriber cancels the read. */ const subscribe = (state: Operation, signal: AbortSignal): Promise => { if (signal.aborted) return Promise.reject(abortError()); state.consumers++; return new Promise((resolve, reject) => { let finished = false; const finish = (callback: () => void): void => { if (finished) return; finished = true; signal.removeEventListener('abort', cancel); state.consumers--; callback(); if (!state.consumers && !state.settled) state.controller.abort(); }; const cancel = (): void => finish(() => reject(abortError())); signal.addEventListener('abort', cancel, { once: true }); state.promise.then(result => finish(() => resolve(result)), error => finish(() => reject(error))); }); }; const read = async (request: CatalogRequest, kind: string, query: Query, signal: AbortSignal, refresh = false): Promise => { if (signal.aborted) return { ok: false, aborted: true }; const scope = namespace(kind, query), key = cacheKey(scope, kind, query); const cached = !refresh && peekCatalog(kind, query); if (cached) return cached; const epoch = ownerEpoch, revision = revisions.get(scope) || 0; let state = pending.get(key); if (state?.controller.signal.aborted) { pending.delete(key); state = undefined; } if (!state) { const controller = new AbortController(); const owned: Operation = { controller, consumers: 0, settled: false, refresh, promise: Promise.resolve({ ok: false }) }; owned.promise = readWithRecovery(ownedSignal => request(kind, { ...query, ...(refresh && scope !== 'presets' ? { refresh: '1' } : {}) }, ownedSignal), controller.signal) .finally(() => { owned.settled = true; if (pending.get(key) === owned) pending.delete(key); }); void owned.promise.catch(() => {}); pending.set(key, owned); state = owned; } try { const result = await subscribe(state, signal); if (signal.aborted || epoch !== ownerEpoch || revision !== (revisions.get(scope) || 0)) return { ok: false, aborted: true }; if (result.ok && kind !== 'detail') { if (values.size >= 128) values.delete(values.keys().next().value!); values.set(key, { kind, data: result.data, expires: Date.now() + TTL }); } return result; } catch (error) { return { ok: false, aborted: signal.aborted || (error instanceof Error && error.name === 'AbortError'), message: error instanceof Error ? error.message : 'The image library could not be loaded.' }; } }; export const cachedCuratedRequest = (request: CatalogRequest): CatalogRequest => (kind, query, signal) => read(request, kind, query, signal); export const cachedCatalogRequest = (request: CatalogRequest): CatalogRequest => (kind, query, signal) => read(request, kind, query, signal); /** Refresh only this display library. Selected resource identities stay unchanged. */ export const refreshCatalog = (request: CatalogRequest, kind: string, query: Query, signal: AbortSignal): Promise => { const scope = namespace(kind, query); if (!pending.get(cacheKey(scope, kind, query))?.refresh) clearScope(scope); return read(request, kind, query, signal, true); };