Los límites: lo que ser privado te quita

Todo lo que hace atractivo a OPFS —que aparezca sin permiso, que nadie más lo vea, que el navegador lo gestione por ti— es la misma propiedad mirada desde ángulos distintos, y esa propiedad tiene una cara oscura que conviene ver antes de construir encima. Un almacén que el usuario no puede inspeccionar, ni copiar, ni abrir con otro programa, ni encontrar cuando desinstala el navegador, no es propiedad del dato: es custodia. Y la custodia es exactamente lo que el software local-first prometía terminar.

Lo que no es

Conviene enunciar las cuatro negaciones de forma explícita, porque casi todos los errores de diseño con OPFS consisten en asumir en silencio lo contrario de alguna de ellas.

La primera negación es la que más se olvida en el diseño de producto, porque el usuario tiene un modelo mental de fichero que no se corresponde con nada de esto. Cuando alguien dice que su documento está guardado en su ordenador, quiere decir que puede encontrarlo, copiarlo a un disco externo y abrirlo dentro de diez años. Un fichero en OPFS no cumple ninguna de las tres cosas.

Cuota, desalojo y qué cambia pedir persistencia

El espacio disponible no es fijo ni conocido: se deriva del disco libre y se reporta de forma deliberadamente aproximada para que no sirva como huella identificativa. Lo consultas junto con el consumo:

const { usage, quota } = await navigator.storage.estimate();
const porcentaje = (usage / quota) * 100;

await navigator.storage.persisted();   // ¿ya soy persistente?
await navigator.storage.persist();     // pedir la promoción

Los dos números que devuelve esa llamada engañan si se leen con ingenuidad. La cuota no es tuya: es un techo compartido con el resto del almacenamiento del origen —IndexedDB, cachés, cookies— y se recalcula según el disco libre del sistema, así que puede encoger entre dos ejecuciones sin que hayas escrito nada. Y llega redondeada a propósito, con relleno añadido, para que no sirva como huella identificativa del equipo.

Superar la cuota no devuelve un aviso amable: la escritura falla con QuotaExceededError en mitad de la operación, y como el camino asíncrono solo publica al cerrar, lo normal es que el fichero quede como estaba. Toda escritura grande necesita su bloque de captura y una estrategia de liberación.

async function escribirConMargen(dirHandle, nombre, datos) {
  const { usage, quota } = await navigator.storage.estimate();
  if (usage + datos.size > quota * 0.9) {
    await liberarEspacio(datos.size);      // compactar, podar, borrar caché
  }
  const h = await dirHandle.getFileHandle(nombre, { create: true });
  const w = await h.createWritable();
  try {
    await w.write(datos);
    await w.close();
  } catch (e) {
    await w.abort();                       // el fichero anterior sobrevive
    if (e.name === 'QuotaExceededError') throw new SinEspacio(datos.size);
    throw e;
  }
}

Reservar un margen no es paranoia: una compactación necesita espacio para el resultado antes de poder liberar el original, así que un almacén que solo falla cuando ya está lleno es un almacén que no puede recuperarse. Deja siempre sitio para tu propia limpieza.

flowchart TD
A[El disco del sistema se llena] --> B[El navegador busca origenes que desalojar]
B --> C[Almacenamiento mejor esfuerzo]
B --> D[Almacenamiento persistente]
C --> E[Se borra entero y sin aviso]
D --> F[Se respeta salvo peticion del usuario]
E --> G[Tu aplicacion arranca vacia la proxima vez]

Pedir persistencia cambia la categoría del almacenamiento de mejor esfuerzo a persistente, y con ello deja de ser candidato al desalojo automático. Pero la concesión no la decides tú: unos motores la otorgan por heurística según el compromiso del usuario con el sitio —instalado como aplicación, marcado como favorito, visitado con frecuencia—, otros preguntan, y otros pueden denegarla sin explicación. Trátalo como una mejora probabilística, nunca como una garantía.

La partición: el mismo origen no siempre es el mismo árbol

El aislamiento por origen ya no es toda la historia. Los navegadores modernos particionan el almacenamiento también por el sitio de nivel superior en el que se está navegando, para impedir que un mismo tercero incrustado en muchos sitios los correlacione. La consecuencia práctica es que tu propio origen puede tener varios árboles disjuntos según dónde se ejecute:

flowchart TD
A[tuapp.com abierta como pagina principal] --> B[Arbol 1]
C[tuapp.com dentro de un iframe en otrositio.com] --> D[Arbol 2]
E[tuapp.com dentro de un iframe en tercero.com] --> F[Arbol 3]
B --> G[Tres arboles disjuntos y sin puentes]
D --> G
F --> G

Un widget incrustado que escribe en OPFS no encontrará esos datos cuando el usuario abra tu aplicación directamente, y viceversa. Si tu producto se distribuye como componente empotrable, esto no es un matiz: reorganiza la arquitectura entera, porque el estado local deja de ser único y pasa a ser uno por contexto de incrustación.

Añade a eso el modo privado, donde el almacén suele estar respaldado por memoria y muere con la sesión, y tienes el mapa completo de contextos en los que tu aplicación puede arrancar con un árbol vacío sin que nada haya ido mal.

La consecuencia operativa es que el arranque en frío no es un caso de error. Un almacén local es siempre una caché desde el punto de vista de la corrección, por muy autorizada que sea desde el punto de vista del rendimiento, y tu código de inicio tiene que distinguir sin ambigüedad entre tres situaciones que se parecen mucho vistas desde dentro: el usuario es nuevo, el usuario existía y fue desalojado, y el usuario existía y estás en un contexto particionado distinto. Las tres se presentan como una raíz vacía y las tres piden respuestas diferentes.

La implicación: sin exportación no hay propiedad

// El camino de salida: devolver los bytes al disco que el usuario sí controla.
const raiz = await navigator.storage.getDirectory();
const origen = await (await raiz.getFileHandle('db.sqlite')).getFile();

const destino = await window.showSaveFilePicker({ suggestedName: 'db.sqlite' });
const w = await destino.createWritable();
await w.write(origen);          // el flujo va de OPFS al disco real
await w.close();

Y la exportación solo cuenta si el formato de salida es legible por algo que no seas tú. Un volcado de tu estructura interna en el disco del usuario satisface la letra del ideal y no su intención: sigue siendo un fichero que solo tu programa entiende. Un fichero de SQLite, un archivo comprimido con los adjuntos y un manifiesto en texto plano, o cualquier formato con una especificación pública, son lo que convierte la copia en propiedad de verdad.