idol-commons / frontend /src /explorer /model-cache.ts
fffiloni's picture
Deploy tested IDOL Commons private development build
26fa2b2 verified
Raw History Blame Contribute Delete
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();