File size: 7,114 Bytes
b30b7c5
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4bd8362
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
// Arranque de la caché de modelos: (1) pide almacenamiento PERSISTENTE para que
// el navegador no desaloje los pesos cacheados, y (2) registra el service worker
// (sw.js) y espera a que CONTROLE la página antes de descargar nada — así hasta
// la primera descarga queda cacheada. Idempotente y a prueba de fallos.
let started = null;

export function ensureModelCache() {
  if (started) return started;
  started = (async () => {
    try {
      if (navigator.storage && navigator.storage.persist) {
        const persisted = navigator.storage.persisted ? await navigator.storage.persisted() : false;
        const ok = persisted || await navigator.storage.persist();
        console.log('[elffuss] almacenamiento persistente:', ok);
      }
    } catch { /* no soportado */ }

    if (!('serviceWorker' in navigator)) return false;
    try {
      await navigator.serviceWorker.register('sw.js');
      await navigator.serviceWorker.ready;
      if (!navigator.serviceWorker.controller) {
        await new Promise(res => {
          const t = setTimeout(res, 1500);
          navigator.serviceWorker.addEventListener('controllerchange', () => { clearTimeout(t); res(); }, { once: true });
        });
      }
      console.log('[elffuss] caché de modelos activa (service worker)');
      return true;
    } catch (e) {
      console.warn('[elffuss] service worker no disponible:', e.message);
      return false;
    }
  })();
  return started;
}

// Espacio ocupado por la caché (para mostrarlo en Ajustes).
export async function cacheEstimate() {
  try {
    const e = await navigator.storage.estimate();
    return { usage: e.usage || 0, quota: e.quota || 0, persisted: navigator.storage.persisted ? await navigator.storage.persisted() : false };
  } catch { return { usage: 0, quota: 0, persisted: false }; }
}

// Vaciar la caché de modelos (botón en Ajustes).
export async function clearModelCache() {
  if (navigator.serviceWorker && navigator.serviceWorker.controller)
    navigator.serviceWorker.controller.postMessage('clear-models');
  try { await caches.delete('elffuss-models-v1'); } catch { /* */ }
}

// ── Lo que ocupan los MODELOS, y vaciarlos de verdad ─────────────────────────
// El chip 💾 y «Vaciar caché» medían `navigator.storage.estimate()` (el origen
// ENTERO: conversaciones, el proyecto de prueba en OPFS…) y lo llamaban
// «modelos guardados», y al vaciar solo borraban la Cache Storage vieja. Pero
// los pesos viven en otros sitios: la carpeta OPFS del almacén de modelos
// (runtime/model-store.js), la caché de transformers.js (el modelo ONNX) y el
// almacén COMPARTIDO del broker, que está en otro origen. Ahora se cuenta y se
// vacía cada uno, y se dice lo que de verdad se liberó.
const MODEL_CACHES = ['elffuss-models-v1', 'transformers-cache'];
const MODEL_DIR = 'elffuss-models';

async function opfsModelBytes() {
  try {
    const dir = await (await navigator.storage.getDirectory()).getDirectoryHandle(MODEL_DIR);
    let n = 0;
    for await (const e of dir.values()) if (e.kind === 'file') n += (await e.getFile()).size;
    return n;
  } catch { return 0; }               // no existe todavía: nada guardado
}
async function cacheModelBytes() {
  if (typeof caches === 'undefined') return 0;
  let n = 0;
  for (const name of await caches.keys().catch(() => [])) {
    if (!MODEL_CACHES.includes(name) && !name.startsWith('transformers')) continue;
    try {
      const c = await caches.open(name);
      for (const req of await c.keys()) {
        const res = await c.match(req);
        const len = +(res?.headers.get('content-length') || 0);
        n += len || (res ? (await res.blob()).size : 0);
      }
    } catch { /* una caché ilegible no rompe la cuenta */ }
  }
  return n;
}
// El almacén compartido vive en el origen del broker: solo se puede medir y
// vaciar si el broker sabe hacerlo (sharedUsage / clearShared). Si no, se dice.
//
// Los orígenes son los del registro del motor (m1, m2…: los hosts de sus pesos)
// MÁS SIEMPRE el broker por defecto. El registro solo da los hosts de Elffuss,
// y en el broker por defecto vive todo lo que viene de otros sitios: el Gemma
// de LiteRT y el Qwen3.5-0.8B del motor, que se bajan de Hugging Face. Sin él,
// «Vaciar caché» dejaba esos modelos guardados y aun así decía «Liberados…».
async function brokerApi() {
  try {
    const b = await import('./runtime/model-broker.js');
    if (typeof b.sharedUsage !== 'function') return null;
    let origenes = [];
    // Puede devolver la lista o una promesa de ella: se espera siempre.
    try { const r = await import('./engine/registro.js'); origenes = (r.origenesAlmacen ? await r.origenesAlmacen() : null) || []; }
    catch { /* sin motor: solo el broker por defecto */ }
    const porDefecto = b.BROKER_URL || 'https://models.elffuss.com/';
    return { b, origenes: [...new Set([...(Array.isArray(origenes) ? origenes : []), porDefecto])] };
  } catch { return null; }
}

// { local, shared, total, sharedOk }: `sharedOk` es false cuando el almacén
// compartido no se pudo consultar (puede haber más guardado del que se cuenta).
export async function modelUsage() {
  const local = (await opfsModelBytes()) + (await cacheModelBytes());
  let shared = 0, sharedOk = false;
  const api = await brokerApi();
  if (api) {
    try { const r = await api.b.sharedUsage(api.origenes); shared = r.usage || 0; sharedOk = !!r.ok; }
    catch { sharedOk = false; }
  }
  return { local, shared, total: local + shared, sharedOk };
}

// Vacía TODO lo que son pesos de modelo y devuelve cuánto se liberó DE VERDAD
// (se mide antes y después), más lo que no se pudo tocar.
export async function clearModels() {
  const antes = await modelUsage();
  const fallos = [];
  if (navigator.serviceWorker?.controller) navigator.serviceWorker.controller.postMessage('clear-models');
  if (typeof caches !== 'undefined') {
    for (const name of await caches.keys().catch(() => [])) {
      if (!MODEL_CACHES.includes(name) && !name.startsWith('transformers')) continue;
      try { await caches.delete(name); } catch (e) { fallos.push(name + ': ' + (e?.message || e)); }
    }
  }
  try {
    const { clearAll } = await import('./runtime/model-store.js');
    await clearAll();
  } catch (e) { fallos.push('OPFS: ' + (e?.message || e)); }
  const api = await brokerApi();
  if (api && typeof api.b.clearShared === 'function') {
    // Todos A LA VEZ: uno tras otro, cada broker que no contesta (una página de
    // broker sin el manejador de «vaciar») sumaba su tiempo de espera, y el chip y
    // el botón se quedaban ocupados todo ese rato antes de decir que falló.
    await Promise.all(api.origenes.map(async o => {
      try { const r = await api.b.clearShared(o); if (!r?.ok) fallos.push('broker ' + o); }
      catch (e) { fallos.push('broker ' + o + ': ' + (e?.message || e)); }
    }));
  }
  const despues = await modelUsage();
  return { liberado: Math.max(0, antes.total - despues.total), antes, despues, fallos, sharedOk: antes.sharedOk };
}