Spaces:
Running on Zero
Running on Zero
Download frontend/src/explorer/model-cache.ts from fffiloni/idol-commons: direct link, hf CLI and curl.
- Browser
- Download file 4.91 kB
-
https://huggingface.co/spaces/fffiloni/idol-commons/resolve/main/frontend/src/explorer/model-cache.ts
- Command line
-
hf download hf://spaces/fffiloni/idol-commons/frontend/src/explorer/model-cache.ts
-
curl -L -o model-cache.ts https://huggingface.co/spaces/fffiloni/idol-commons/resolve/main/frontend/src/explorer/model-cache.ts
4.91 kB
| /** Persistent source files, never decoded meshes/textures. Storage is optional. */ | |
| export const MODEL_CACHE_BYTES=256*1024*1024; | |
| export const MODEL_CACHE_ENTRIES=32; | |
| export interface ModelFileCache{ | |
| get(key:string,signal:AbortSignal):Promise<ArrayBuffer|null>; | |
| put(key:string,buffer:ArrayBuffer,signal:AbortSignal):Promise<boolean>; | |
| remove(key:string,signal:AbortSignal):Promise<void>; | |
| } | |
| type Entry={key:string;bytes:number;used:number}; | |
| export function modelCacheKey(url:string,sha256?:string){ | |
| return sha256&&/^[a-f0-9]{64}$/i.test(sha256)?url+'#sha256='+sha256.toLowerCase():null; | |
| } | |
| export function createModelCache({name='scenario-explorer-models-v1',maxBytes=MODEL_CACHE_BYTES,maxEntries=MODEL_CACHE_ENTRIES,timeoutMs=5000}={}):ModelFileCache{ | |
| function open(signal:AbortSignal):Promise<IDBDatabase|null>{ | |
| return new Promise(resolve=>{ | |
| if(signal.aborted){resolve(null);return;} | |
| let done=false,request:IDBOpenDBRequest; | |
| const finish=(db:IDBDatabase|null)=>{if(done){db?.close();return;}done=true;clearTimeout(timer);signal.removeEventListener('abort',abort);resolve(db);}; | |
| const abort=()=>finish(null),timer=setTimeout(abort,timeoutMs); | |
| signal.addEventListener('abort',abort,{once:true}); | |
| try{ | |
| if(!globalThis.indexedDB){finish(null);return;} | |
| request=indexedDB.open(name,1); | |
| request.onupgradeneeded=()=>{ | |
| if(done||signal.aborted){request.transaction?.abort();return;} | |
| request.result.createObjectStore('files'); | |
| request.result.createObjectStore('entries',{keyPath:'key'}); | |
| }; | |
| request.onsuccess=()=>{request.result.onversionchange=()=>request.result.close();finish(request.result);}; | |
| request.onerror=()=>finish(null);request.onblocked=()=>finish(null); | |
| }catch{finish(null);} | |
| }); | |
| } | |
| async function run<T>(mode:IDBTransactionMode,fallback:T,signal:AbortSignal,work:(tx:IDBTransaction,result:(value:T)=>void)=>void):Promise<T>{ | |
| const db=await open(signal);if(!db)return fallback; | |
| if(signal.aborted){db.close();return fallback;} | |
| return new Promise(resolve=>{ | |
| let tx:IDBTransaction,result=fallback,done=false; | |
| const finish=(value:T)=>{if(done)return;done=true;clearTimeout(timer);signal.removeEventListener('abort',abort);db.close();resolve(value);}; | |
| const abort=()=>{try{tx?.abort();}catch{/* It may have committed already. */}finish(fallback);}; | |
| const timer=setTimeout(abort,timeoutMs);signal.addEventListener('abort',abort,{once:true}); | |
| try{ | |
| tx=db.transaction(['entries','files'],mode); | |
| tx.oncomplete=()=>finish(result);tx.onabort=()=>finish(fallback); | |
| tx.onerror=()=>{/* Keep the default abort, so eviction and insertion roll back together. */}; | |
| work(tx,value=>{result=value;}); | |
| }catch{abort();} | |
| }); | |
| } | |
| return { | |
| get:(key,signal)=>run<ArrayBuffer|null>('readwrite',null,signal,(tx,result)=>{ | |
| const entries=tx.objectStore('entries'),files=tx.objectStore('files'); | |
| const entryRequest=entries.get(key); | |
| entryRequest.onsuccess=()=>{ | |
| const entry=entryRequest.result as Entry|undefined;if(!entry)return; | |
| const fileRequest=files.get(key); | |
| fileRequest.onsuccess=()=>{ | |
| const buffer=fileRequest.result; | |
| if(!(buffer instanceof ArrayBuffer)||buffer.byteLength!==entry.bytes){entries.delete(key);files.delete(key);return;} | |
| entries.put({...entry,used:Date.now()});result(buffer); | |
| }; | |
| }; | |
| }), | |
| put:async(key,buffer,signal)=>{ | |
| if(signal.aborted||buffer.byteLength>maxBytes||buffer.byteLength===0||maxEntries<1)return false; | |
| return run<boolean>('readwrite',false,signal,(tx,result)=>{ | |
| const entries=tx.objectStore('entries'),files=tx.objectStore('files'),request=entries.getAll(); | |
| request.onsuccess=()=>{ | |
| try{ | |
| // Metadata is small. Never read every cached model into memory. | |
| const previous=(request.result as Entry[]).filter(e=>e.key!==key).sort((a,b)=>a.used-b.used); | |
| let bytes=previous.reduce((n,e)=>n+e.bytes,0)+buffer.byteLength,count=previous.length+1; | |
| for(const entry of previous){ | |
| if(bytes<=maxBytes&&count<=maxEntries)break; | |
| files.delete(entry.key);entries.delete(entry.key);bytes-=entry.bytes;count--; | |
| } | |
| // ArrayBuffer also works where WebKit cannot persist Blob/File data. | |
| // IndexedDB owns the stored copy; no application RAM cache is kept. | |
| files.put(buffer,key); | |
| entries.put({key,bytes:buffer.byteLength,used:Date.now()} satisfies Entry);result(true); | |
| }catch{tx.abort();} | |
| }; | |
| }); | |
| }, | |
| remove:async(key,signal)=>{await run('readwrite',undefined,signal,tx=>{tx.objectStore('files').delete(key);tx.objectStore('entries').delete(key);});} | |
| }; | |
| } | |
| export const modelCache=createModelCache(); | |