File size: 3,443 Bytes
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
// Escribir OPFS desde un Worker — el único camino que existe en iOS.
// ─────────────────────────────────────────────────────────────────────────────
// En escritorio se escribe con `createWritable`, que devuelve un stream y va
// directo a disco. En iOS Safari ESO NO EXISTE en el hilo principal: la única
// forma de escribir OPFS es `createSyncAccessHandle`, y solo dentro de un
// Worker. Sin este fichero, el almacén detecta que no puede escribir y cae a
// Cache Storage — que iOS desaloja entre visitas, así que el teléfono se
// vuelve a descargar el modelo ENTERO cada vez que se abre la página.
//
// No es una optimización: es la diferencia entre un modelo que se guarda y uno
// que no. Por eso el plan lo tenía en el camino crítico.
//
// El handle síncrono bloquea el hilo mientras escribe, y por eso tiene que
// vivir aquí: en el principal congelaría la interfaz durante gigabytes.
//
// Protocolo (un mensaje, una respuesta, siempre con `id` para poder esperar):
//   {id, op:'abrir',    carpeta, nombre}  -> crea/trunca el fichero
//   {id, op:'escribir', buf}              -> escribe al final (buf transferido)
//   {id, op:'cerrar'}                     -> vacía y cierra
//
// Licencia: código propio y PRIVADO — no se publica.

let handle = null;      // FileSystemSyncAccessHandle
let pos = 0;            // dónde va el siguiente byte

async function abrir(carpeta, nombre) {
  await cerrar();                                   // por si quedó uno abierto
  const raiz = await navigator.storage.getDirectory();
  const dir = await raiz.getDirectoryHandle(carpeta, { create: true });
  const fh = await dir.getFileHandle(nombre, { create: true });
  handle = await fh.createSyncAccessHandle();
  // Truncar a cero NO es redundante con `create: true`: si el fichero ya
  // existía de un intento cortado, sin esto quedarían bytes viejos DETRÁS de
  // lo que escribamos, y el modelo saldría más largo de lo que debe sin un
  // solo error. Los restos a medias son la forma más cara de fallar aquí.
  handle.truncate(0);
  pos = 0;
}

function escribir(buf) {
  if (!handle) throw new Error('escritura sin fichero abierto');
  const n = handle.write(new Uint8Array(buf), { at: pos });
  // `write` devuelve cuántos bytes entraron de verdad. Si se ignora y el disco
  // se queda corto, el fichero sale truncado y parece sano.
  if (n !== buf.byteLength) throw new Error(`escritura corta: ${n} de ${buf.byteLength}`);
  pos += n;
  return pos;
}

async function cerrar() {
  if (!handle) return 0;
  const fin = pos;
  try { handle.flush(); handle.close(); } finally { handle = null; pos = 0; }
  return fin;
}

self.onmessage = async (ev) => {
  const { id, op } = ev.data || {};
  try {
    let r = null;
    if (op === 'abrir') r = await abrir(ev.data.carpeta, ev.data.nombre);
    else if (op === 'escribir') r = escribir(ev.data.buf);
    else if (op === 'cerrar') r = await cerrar();
    else throw new Error('operación desconocida: ' + op);
    self.postMessage({ id, ok: true, r });
  } catch (e) {
    // El error viaja como TEXTO: un Error no siempre sobrevive al clonado
    // estructurado y llegaría como «{}», que no dice nada a nadie.
    self.postMessage({ id, ok: false, error: String((e && e.message) || e) });
  }
};