// Elffuss Runtime · SDK de la caché compartida de modelos. // ───────────────────────────────────────────────────────────────────────────── // Embebe un iframe oculto al BROKER (origen compartido de Elffuss) y le pide los // modelos por postMessage. Como el broker vive en un subdominio de elffuss.com // —igual que todas las webs de Elffuss (mismo «site»)—, comparte UNA sola OPFS: // el modelo se descarga UNA vez y se reutiliza en claw/translator/copilot/code… // Si el broker no está disponible, el llamador cae a su OPFS local (model-store). // Lo guardado bajo los nombres viejos (*.elffuss.utopiaia.com) es de otro «site» // y no se ve desde aquí: tras el cambio de dominio el modelo se baja otra vez. export const BROKER_URL = 'https://models.elffuss.com/'; // Un iframe POR ORIGEN. La maquinaria está, pero OJO con para qué sirve, porque // medirlo costó una tarde y el resultado no es el que parecía. // // MEDIDO con el registro del servidor —no con tiempos, que engañan porque la // caché HTTP los imita—: se guarda desde un sitio y se lee desde otro, y se // cuentan las peticiones REALES que llegan a nginx. // // broker models → 1 petición · leer desde el otro sitio: CERO // peticiones nuevas. COMPARTE. // broker m1 → 2 peticiones · leer desde el otro sitio se lo vuelve a // bajar entero. NO comparte. // // Mismo sitio (utopiaia.com), mismas cabeceras, misma página de broker. La // diferencia es real y reproducible; la CAUSA sigue sin explicar. No confundir // «no explicado» con «no medido»: esto está medido con el testigo bueno. // // Consecuencia práctica, y es una disyuntiva de verdad: // · compartir entre sitios → un solo origen de broker (models), una sola cuota. // · multiplicar la cuota → repartir entre orígenes, y cada sitio se lo baja. // Hoy no se pueden las dos. Para modelos por debajo del techo (~7 GB) compensa // compartir; por encima, repartir y pagar la descarga por sitio. const _brokers = new Map(); // origen → { iframe, ready } let _seq = 0; function ensure(brokerURL) { const clave = new URL(brokerURL).origin; const ya = _brokers.get(clave); if (ya) return ya.ready; const entrada = {}; _brokers.set(clave, entrada); return _ensureNuevo(brokerURL, entrada); } function _ensureNuevo(brokerURL, entrada) { let _iframe = null, _ready = null; const _url = brokerURL; _iframe = document.createElement('iframe'); _iframe.src = brokerURL; _iframe.setAttribute('aria-hidden', 'true'); _iframe.style.cssText = 'position:absolute;width:0;height:0;border:0;left:-9999px;visibility:hidden'; _ready = new Promise((resolve, reject) => { const to = setTimeout(() => reject(new Error('broker timeout')), 8000); const h = e => { if (e.source === _iframe.contentWindow && e.data?.kind === 'elffuss-broker-ready') { clearTimeout(to); removeEventListener('message', h); resolve(); } }; addEventListener('message', h); _iframe.addEventListener('error', () => { clearTimeout(to); reject(new Error('broker no cargó')); }); }); (document.body || document.documentElement).appendChild(_iframe); entrada.iframe = _iframe; entrada.ready = _ready; return _ready; } const origin = url => new URL(url).origin; const ventana = url => _brokers.get(new URL(url).origin)?.iframe?.contentWindow; // Qué broker guarda un fichero. // ───────────────────────────────────────────────────────────────────────────── // El del ORIGEN DEL PROPIO FICHERO cuando ese origen sirve la página del broker // (models, m1, m2… de elffuss.com, o del dominio anterior mientras dure el // cambio): así cada trozo lo guarda quien lo sirve, la petición es del mismo // origen (sin CORS) y ocupa la cuota de ESE subdominio. Cualquier otro fichero // va al broker compartido. // // Antes se usaba el origen del fichero SIEMPRE, y con un modelo de Hugging Face // eso embebía huggingface.co como si fuera el broker: nadie contestaba, cada // sesión se comía los 8 s del timeout y después daba el broker por caído. const HOST_BROKER = /^(models|m\d+)\.elffuss\.(com|utopiaia\.com)$/; export function brokerFor(url) { // Relativa → lanza, como antes: el broker vive en otro origen y la // resolvería contra el suyo, que es otro fichero. const u = new URL(url); return u.protocol === 'https:' && HOST_BROKER.test(u.hostname) ? u.origin + '/' : BROKER_URL; } // Modelo como Blob (el navegador lo respalda en disco), desde la caché compartida. // Descarga una vez para TODO Elffuss; el resto de webs lo leen sin red. export async function getSharedModel(url, onProgress = () => {}, brokerURL = null) { // Por defecto, el broker que le toca a ESE fichero (ver brokerFor). brokerURL = brokerURL || brokerFor(url); await ensure(brokerURL); return new Promise((resolve, reject) => { const id = ++_seq; // Timeout por INACTIVIDAD: sin CUALQUIER mensaje del broker (progreso/file/ // error) en IDLE ms, la carga está colgada → rechazar para caer a OPFS local. // No es un tope total (una descarga real tarda minutos): cada mensaje del // broker reinicia el reloj, así que solo salta si el broker enmudece de verdad. const IDLE = 30000; let timer; const arm = () => { clearTimeout(timer); timer = setTimeout(() => { removeEventListener('message', h); reject(new Error('broker sin respuesta (timeout de inactividad)')); }, IDLE); }; const done = fn => (...a) => { clearTimeout(timer); removeEventListener('message', h); fn(...a); }; const h = e => { if (e.source !== ventana(brokerURL) || e.data?.id !== id) return; const m = e.data; arm(); // cualquier señal del broker reinicia el reloj if (m.kind === 'progress') onProgress(m); // El broker devuelve un File respaldado en disco (structured-clone por // referencia): no copia los GB a RAM. Se lee con .stream() al subirlo a GPU. else if (m.kind === 'file') done(resolve)(m.file); else if (m.kind === 'error') done(reject)(new Error(m.message)); }; addEventListener('message', h); arm(); ventana(brokerURL).postMessage({ type: 'elffuss-model-get', id, url }, origin(brokerURL)); }); } // ¿ya está en la caché compartida? (para la UI: «cargando desde caché, sin bajar») export async function isSharedCached(url, brokerURL = null) { brokerURL = brokerURL || brokerFor(url); try { await ensure(brokerURL); } catch { return false; } return new Promise(resolve => { const id = ++_seq; const to = setTimeout(() => { removeEventListener('message', h); resolve(false); }, 4000); const h = e => { if (e.source !== ventana(brokerURL) || e.data?.id !== id) return; if (e.data.kind === 'has') { clearTimeout(to); removeEventListener('message', h); resolve(!!e.data.cached); } }; addEventListener('message', h); ventana(brokerURL).postMessage({ type: 'elffuss-model-has', id, url }, origin(brokerURL)); }); } // Cuánto ocupa el almacén COMPARTIDO, y cómo vaciarlo. // ───────────────────────────────────────────────────────────────────────────── // `navigator.storage.estimate()` mide SOLO el origen que lo llama, y el modelo // grande no vive aquí: lo guarda el broker, en su propio origen. Así que el // panel de ajustes contaba los megas del modelo pequeño y se dejaba fuera los // gigas del grande — decía «0,82 GB cacheados» con 7,2 GB guardados al lado— y // su botón de vaciar tampoco los tocaba. Esto es el canal que faltaba. // Lo que ocupa el almacén del broker. Devuelve 0 si no se puede preguntar: la // cifra se SUMA a la local, y un fallo aquí tiene que quedarse en «no sé contar // esto», nunca en romper el panel entero. /** * Cuanto ocupa el almacen compartido. Acepta UN broker o VARIOS. * * Varios porque cada fragmento lo guarda el broker de su propio host: un modelo * repartido entre dos servidores ocupa DOS origenes, y preguntar solo al broker * por defecto enseñaba una fraccion. Con el 27B guardado en dos hosts, el panel * contaba un tercer origen que no tenia nada y mostraba menos de la mitad de lo * que habia en disco. * * Los origenes se deduplican: dos fragmentos del mismo host son un solo * almacen, y sumarlo dos veces seria el error contrario. */ export async function sharedUsage(brokerURL = BROKER_URL) { // Lista VACIA -> al defecto, no a cero. Un cero calculado sobre «no he // preguntado a nadie» se lee igual que «no hay nada guardado», y es el error // que este arreglo venia a quitar. if (Array.isArray(brokerURL) && brokerURL.length === 0) return sharedUsageUno(BROKER_URL); if (Array.isArray(brokerURL)) { const vistos = new Set(); const unicos = brokerURL.filter(u => { try { const o = new URL(u).origin; if (vistos.has(o)) return false; vistos.add(o); return true; } catch { return false; } }); const partes = await Promise.all(unicos.map(u => sharedUsage(u))); return { usage: partes.reduce((n, p) => n + (p.usage || 0), 0), quota: partes.reduce((n, p) => Math.max(n, p.quota || 0), 0), ok: partes.some(p => p.ok), porOrigen: unicos.map((u, i) => ({ origen: u, ...partes[i] })), }; } return sharedUsageUno(brokerURL); } async function sharedUsageUno(brokerURL = BROKER_URL) { try { await ensure(brokerURL); } catch { return { usage: 0, quota: 0, ok: false }; } return new Promise(resolve => { const id = ++_seq; const to = setTimeout(() => { removeEventListener('message', h); resolve({ usage: 0, quota: 0, ok: false }); }, 5000); const h = e => { if (e.source !== ventana(brokerURL) || e.data?.id !== id || e.data.kind !== 'diag') return; clearTimeout(to); removeEventListener('message', h); resolve({ usage: e.data.usado || 0, quota: e.data.quota || 0, ok: true }); }; addEventListener('message', h); // Sin `probar`: el diagnóstico solo hace la prueba de escritura cuando se le // pide un tope, y aquí solo se quiere la cifra. ventana(brokerURL).postMessage({ type: 'elffuss-broker-diag', id }, origin(brokerURL)); }); } // Vacía el almacén compartido. Devuelve cuánto se liberó DE VERDAD (el broker lo // mide antes y después), para poder decirlo en vez de suponerlo. export async function clearShared(brokerURL = BROKER_URL) { try { await ensure(brokerURL); } catch { return { liberado: 0, ok: false }; } return new Promise(resolve => { const id = ++_seq; const to = setTimeout(() => { removeEventListener('message', h); resolve({ liberado: 0, ok: false }); }, 20000); const h = e => { if (e.source !== ventana(brokerURL) || e.data?.id !== id) return; if (e.data.kind !== 'cleared' && e.data.kind !== 'error') return; clearTimeout(to); removeEventListener('message', h); resolve({ liberado: e.data.liberado || 0, ok: e.data.kind === 'cleared' }); }; addEventListener('message', h); ventana(brokerURL).postMessage({ type: 'elffuss-model-clear', id }, origin(brokerURL)); }); }