Spaces:
Running
Running
File size: 11,546 Bytes
d305959 4bd8362 d305959 4bd8362 d305959 4bd8362 d305959 4bd8362 d305959 4bd8362 d305959 4bd8362 d305959 4bd8362 d305959 4bd8362 d305959 4bd8362 d305959 4bd8362 d305959 4bd8362 d305959 4bd8362 d305959 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 | // 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));
});
}
|