@dotrino/identity 0.114.1 → 0.116.0

package/vault/vendor/vault/core/sha256.js

@@ -0,0 +1,69 @@
+/**
+ * SHA-256 SÍNCRONO, en JavaScript puro.
+ *
+ * El navegador solo trae `crypto.subtle.digest`, que es asíncrono, y la bitácora de la
+ * bóveda encadena cada línea con el hash de la anterior en el mismo paso en que la escribe:
+ * volverlo asíncrono dejaría dos entradas apuntando a la misma anterior. Así el binario y
+ * el navegador encadenan exactamente igual, y lo comprueba la prueba contra `node:crypto`.
+ */
+const K = new Uint32Array([
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+])
+
+/** @param {Uint8Array} data */
+export function sha256Bytes (data) {
+  const h = new Uint32Array([0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19])
+  const len = data.length
+  const total = ((len + 9 + 63) >> 6) << 6
+  const buf = new Uint8Array(total)
+  buf.set(data)
+  buf[len] = 0x80
+  const bits = len * 8
+  const view = new DataView(buf.buffer)
+  view.setUint32(total - 8, Math.floor(bits / 0x100000000))
+  view.setUint32(total - 4, bits >>> 0)
+  const w = new Uint32Array(64)
+  for (let off = 0; off < total; off += 64) {
+    for (let i = 0; i < 16; i++) w[i] = view.getUint32(off + i * 4)
+    for (let i = 16; i < 64; i++) {
+      const a = w[i - 15], b = w[i - 2]
+      const s0 = ((a >>> 7) | (a << 25)) ^ ((a >>> 18) | (a << 14)) ^ (a >>> 3)
+      const s1 = ((b >>> 17) | (b << 15)) ^ ((b >>> 19) | (b << 13)) ^ (b >>> 10)
+      w[i] = (w[i - 16] + s0 + w[i - 7] + s1) >>> 0
+    }
+    let [a, b, c, d, e, f, g, hh] = h
+    for (let i = 0; i < 64; i++) {
+      const S1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7))
+      const ch = (e & f) ^ (~e & g)
+      const t1 = (hh + S1 + ch + K[i] + w[i]) >>> 0
+      const S0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10))
+      const maj = (a & b) ^ (a & c) ^ (b & c)
+      const t2 = (S0 + maj) >>> 0
+      hh = g; g = f; f = e; e = (d + t1) >>> 0
+      d = c; c = b; b = a; a = (t1 + t2) >>> 0
+    }
+    h[0] = (h[0] + a) >>> 0; h[1] = (h[1] + b) >>> 0; h[2] = (h[2] + c) >>> 0; h[3] = (h[3] + d) >>> 0
+    h[4] = (h[4] + e) >>> 0; h[5] = (h[5] + f) >>> 0; h[6] = (h[6] + g) >>> 0; h[7] = (h[7] + hh) >>> 0
+  }
+  const out = new Uint8Array(32)
+  const ov = new DataView(out.buffer)
+  for (let i = 0; i < 8; i++) ov.setUint32(i * 4, h[i])
+  return out
+}
+
+/** El hash de un texto (UTF-8), en hexadecimal. Lo mismo que `createHash('sha256').update(text, 'utf8').digest('hex')`. */
+export function sha256Hex (text) {
+  const bytes = typeof text === 'string' ? new TextEncoder().encode(text) : text
+  let s = ''
+  for (const b of sha256Bytes(bytes)) s += b.toString(16).padStart(2, '0')
+  return s
+}
+
+export default { sha256Bytes, sha256Hex }

package/vault/vendor/vault/core/store.js

@@ -0,0 +1,68 @@
+/**
+ * Store del árbol de contenidos del vault (`vault.json`). **Cifrado en reposo**
+ * con la misma clave ligada a la máquina que la identidad (`atrest.js`): el
+ * contenido del usuario no es menos sensible que la maestra. NO guarda
+ * identidad/dispositivos/certs: de eso se encarga
+ * `@dotrino/identity` dentro del mismo dir (keypair, contactos, delegaciones,
+ * revocaciones). Aquí vive solo lo del usuario: el árbol y los settings.
+ */
+import { readJson, writeJson } from './disk.js'
+
+const SCHEMA_VERSION = 1
+
+function newTree () {
+  return { id: 'root', name: '', type: 'folder', children: [] }
+}
+
+function findNode (node, id) {
+  if (!node) return null
+  if (node.id === id) return node
+  if (Array.isArray(node.children)) {
+    for (const c of node.children) {
+      const r = findNode(c, id)
+      if (r) return r
+    }
+  }
+  return null
+}
+
+export function openStore (disk) {
+  const file = 'vault.json'
+  let data = readJson(disk, file, null)
+  if (!data || data.schemaVersion !== SCHEMA_VERSION) {
+    data = { schemaVersion: SCHEMA_VERSION, tree: newTree(), settings: {} }
+  }
+  // Se reescribe SIEMPRE al abrir: así un archivo de una instalación anterior
+  // (en claro) queda cifrado sin pedirle nada al usuario.
+  writeJson(disk, file, data)
+  const save = () => writeJson(disk, file, data)
+
+  return {
+    get raw () { return data },
+    getTree () { return data.tree },
+    getNode (id) { return findNode(data.tree, id || 'root') },
+    addNode (parentId, node) {
+      const parent = findNode(data.tree, parentId || 'root')
+      if (!parent) throw new Error('parent node not found: ' + parentId)
+      if (!Array.isArray(parent.children)) parent.children = []
+      parent.children.push(node)
+      save()
+      return node
+    },
+    removeNode (id) {
+      const remove = (node) => {
+        if (!Array.isArray(node.children)) return false
+        const i = node.children.findIndex((c) => c.id === id)
+        if (i >= 0) { node.children.splice(i, 1); return true }
+        return node.children.some(remove)
+      }
+      const ok = remove(data.tree)
+      if (ok) save()
+      return ok
+    },
+    getSetting (k) { return data.settings[k] },
+    setSetting (k, v) { if (v === undefined) delete data.settings[k]; else data.settings[k] = v; save() },
+    /** Todos los ajustes (copia). Para quien necesita buscar por prefijo. */
+    listSettings () { return { ...data.settings } }
+  }
+}

package/vault/vendor/vault/core/subacta.js

@@ -0,0 +1,101 @@
+/**
+ * subacta.js — LO DECIDIDO QUE TODAVÍA NO SELLÓ EL ACTA.
+ *
+ * Idea del dueño (2026-09-04): *«una subacta efímera que se comparte entre todos los
+ * dispositivos y puede tener decisiones a futuro que se aceptan cuando el acta se abre»*.
+ *
+ * EL AGUJERO QUE TAPA. Sellar el acta es de la maestra, y con el perfil cerrado la maestra
+ * no está. Así que una renuncia —«me quito estos permisos»— no surtía NINGÚN efecto hasta
+ * que alguien iba a la máquina y tecleaba la contraseña. Justo el caso que la renuncia
+ * existe para cubrir: te roban el teléfono, renuncias desde él, y el ladrón sigue siendo
+ * admin hasta que llegues. El pilar ya tenía la pieza (`extraRenounces`) y no la pasaba
+ * nadie.
+ *
+ * LA REGLA DURA, y es la que sostiene todo lo demás:
+ *
+ *     LA SUBACTA SOLO PUEDE QUITAR, NUNCA DAR.
+ *
+ * De ahí salen las tres propiedades que la hacen segura sin maestra:
+ *
+ *   · **Se autentica sola.** Cada entrada la firma EL MIEMBRO AL QUE AFECTA. No hace falta
+ *     sellador, así que no hay una segunda autoridad al lado del acta.
+ *   · **Una entrada falsa o repetida cuesta disponibilidad, no autoridad.** Lo peor que
+ *     consigue quien cuele una es quitarle permisos a alguien: molesto y reversible.
+ *   · **Nadie puede quitarle nada a otro.** Si valiera la firma de cualquiera, un servicio
+ *     con `secrets` en un VPS alquilado podría dejar sin `admin` a tu teléfono.
+ *
+ * Y por eso el catálogo de operaciones es una LISTA BLANCA de una sola: `renounce`. La
+ * lista es la regla — si algún día entra otra, tiene que quitar y venir firmada por su
+ * sujeto, y se escribe aquí a propósito, no se cuela.
+ *
+ * JUNTAR DOS ES UNIR. Dos entradas nunca se contradicen porque las dos quitan, así que no
+ * hay conflictos ni hace falta un `seq`. Y **solo salen al absorberse** en el acta: nunca
+ * por reloj, o un aparato apagado perdería justo la que lo protege.
+ */
+import { verifyRenounce } from '@dotrino/identity/acta'
+import { readJson, writeJson } from './disk.js'
+
+/** Las operaciones que caben. La lista ES la regla: todas quitan, todas las firma su sujeto. */
+export const OPS = Object.freeze(['renounce'])
+
+/** Identidad de una entrada, para no guardar dos veces la misma. */
+const idOf = (e) => `${e.op}|${e.member}|${[...(e.caps || [])].sort().join(',')}|${e.ts}`
+
+/**
+ * ¿Es una entrada que se puede aceptar? Comprueba la FORMA y la FIRMA; que quite es
+ * estructural (el catálogo) y no una comprobación aparte.
+ */
+export async function isAcceptable (e) {
+  if (!e || !OPS.includes(e.op)) return false
+  if (e.op === 'renounce') return verifyRenounce(e).catch(() => false)
+  return false
+}
+
+/**
+ * La subacta de un perfil. Vive en su directorio y va cifrada en reposo como todo lo
+ * demás: sus entradas dicen qué aparatos se quedaron sin qué, y eso es material de la
+ * cuenta aunque no sea un secreto.
+ */
+export function openSubacta (disk) {
+  const file = 'subacta.json'
+  let data = readJson(disk, file, null) || { v: 1, entries: [] }
+  const guardar = () => writeJson(disk, file, data)
+
+  return {
+    /** Las entradas vigentes, tal cual se le pasan a `memberCan` y compañía. */
+    entries () { return [...data.entries] },
+    get count () { return data.entries.length },
+
+    /** Las de UN miembro. Es lo que se mira al decidir sobre él. */
+    forMember (pub) { return data.entries.filter((e) => e.member === pub) },
+
+    /**
+     * Acepta una entrada. Devuelve `{ok, reason}` — y un `false` aquí no es un fallo del
+     * que la manda: puede ser que ya la tuviéramos, que es el caso normal cuando dos
+     * aparatos se cuentan lo mismo.
+     */
+    async add (e) {
+      if (!(await isAcceptable(e))) return { ok: false, reason: 'no-aceptable' }
+      const id = idOf(e)
+      if (data.entries.some((x) => idOf(x) === id)) return { ok: false, reason: 'ya-estaba' }
+      data.entries = [...data.entries, e]
+      guardar()
+      return { ok: true, reason: 'nueva' }
+    },
+
+    /**
+     * SACA TODO para absorberlo en el acta, y vacía. Se llama con la bóveda ABIERTA, que es
+     * la única que puede sellar. Vaciar aquí y fallar el sellado perdería la entrada, así
+     * que quien llama tiene que absorber primero y vaciar después (`clear`).
+     */
+    drain () { return [...data.entries] },
+
+    /** Vacía lo ya absorbido. Se le pasa lo que se absorbió, no «todo»: mientras se sella
+     *  puede haber entrado una nueva, y tirarla sería perder una renuncia sin aplicar. */
+    clear (absorbidas) {
+      const ids = new Set(absorbidas.map(idOf))
+      data.entries = data.entries.filter((e) => !ids.has(idOf(e)))
+      guardar()
+    }
+  }
+}

package/vault/vendor/vault/core/threadStore.js

@@ -0,0 +1,273 @@
+/**
+ * Sub-store de HILOS + APERTURAS del vault (Fase 3: store centralizado).
+ *
+ * Espeja el modelo de datos de `@dotrino/store` (store.dotrino.com):
+ *   threads: { [threadKey]: Entry[] }   (Entry tiene `id` + `ts`, opaco para el store)
+ *   opens:   { [appId]: { count, ts } } (contador de "recientes" del hub)
+ * para que un dispositivo emparejado pueda guardar su contenido EN el vault del
+ * usuario (su propio servidor) en vez de —o además de— el IndexedDB del navegador.
+ *
+ * File-backed (`threads.json`), síncrono y simple (sin cuota/IndexedDB). Es el
+ * backend autoritativo; el navegador usa su IndexedDB como caché y sincroniza.
+ * **Cifrado en reposo** con la clave ligada a la máquina (`atrest.js`): aquí
+ * vive el contenido de las apps y el perfil del usuario, que es exactamente lo
+ * que el ecosistema promete que no queda en claro en ningún disco.
+ */
+import * as core from '@dotrino/store/core'
+import { resealStale } from '@dotrino/identity/content'
+import { readJson, writeJson } from './disk.js'
+
+// El MISMO tope que acepta la página del almacén. Era 1000: una app que guarda más en un
+// hilo (los compradores de facturero, por ejemplo) perdía aquí lo más viejo sin decir nada,
+// y el navegador lo volvía a subir en cada sincronización.
+const MAX_PER_THREAD = core.MAX_PER_THREAD_LIMIT
+
+// DATOS SENSIBLES (F4): topes para que un dispositivo con `vault:store` no pueda
+// llenar el disco de la bóveda. Son generosos para el uso real (unas contraseñas,
+// notas, un documento corto) y ridículos para un abuso.
+// LO QUE SE VUELVE A CERRAR AL ROTAR NO SE BORRA: la versión anterior de cada sobre se
+// guarda como respaldo AL MENOS UN AÑO (política del dueño, 2026-09-30). No se sirve por
+// ningún método; solo está por si volver a cerrar sale mal.
+export const RESEALED_KEEP_MS = 366 * 24 * 60 * 60 * 1000
+
+const MAX_SECURE_ITEMS = 2000
+const MAX_SECURE_BLOB = 64 * 1024   // por campo sellado (meta y valor)
+
+export function openThreadStore (disk) {
+  const file = 'threads.json'
+  let data = readJson(disk, file, null)
+  if (!data || typeof data !== 'object') data = { v: 1, threads: {}, opens: {} }
+  if (!data.threads) data.threads = {}
+  if (!data.opens) data.opens = {}
+  if (!data.secure) data.secure = {}
+  // Lápidas de lo borrado (`@dotrino/store/core`): sin ellas un borrado vuelve desde el
+  // primer aparato que todavía tenga la entrada.
+  if (!data.tombs) data.tombs = {}
+  core.pruneTombs(data.tombs, Date.now())
+  const save = () => writeJson(disk, file, data)
+  save() // reescribe al abrir: cifra lo que venía en claro
+  const budget = (n) => Math.min(Math.max(Number(n) || core.PAGE_BYTES, 1024), core.PAGE_BYTES)
+  const needKeys = (keys) => {
+    if (!Array.isArray(keys) || !keys.every((k) => typeof k === 'string')) throw new Error('keys must be a list of thread keys')
+    return keys
+  }
+  const needMap = (value, what) => {
+    if (value == null) return {}
+    if (typeof value !== 'object' || Array.isArray(value)) throw new Error(`${what} must be an object`)
+    return value
+  }
+
+  const methods = {
+    appendMessage ({ threadKey, entry }) {
+      core.writeEntry(data.threads, data.tombs, threadKey, entry, { max: MAX_PER_THREAD, now: Date.now(), newId: () => crypto.randomUUID() })
+      save(); return entry
+    },
+    listThread ({ threadKey, limit, before }) {
+      if (!core.validKey(threadKey) || !Object.hasOwn(data.threads, threadKey)) return []
+      let arr = data.threads[threadKey]
+      if (typeof before === 'number') arr = arr.filter((e) => (e.ts || 0) < before)
+      if (typeof limit === 'number' && limit > 0) arr = arr.slice(-limit)
+      return arr
+    },
+    listThreadKeys () { return Object.keys(data.threads) },
+    getThreadSummaries () {
+      const out = {}
+      for (const [k, arr] of Object.entries(data.threads)) out[k] = { lastEntry: arr.length ? arr[arr.length - 1] : null, count: arr.length }
+      return out
+    },
+    removeThread ({ threadKey }) {
+      const removed = core.removeWholeThread(data.threads, data.tombs, threadKey, Date.now())
+      if (removed) save()
+      return { removed }
+    },
+    removeMessage ({ threadKey, id }) {
+      const removed = core.removeEntry(data.threads, data.tombs, threadKey, id, Date.now())
+      if (removed) save()
+      return { removed }
+    },
+    recordOpen ({ appId }) {
+      if (!appId || typeof appId !== 'string') throw new Error('appId required')
+      const prev = data.opens[appId]
+      data.opens[appId] = { count: (prev?.count || 0) + 1, ts: Date.now() }
+      save(); return data.opens[appId]
+    },
+    getOpens () { return { ...data.opens } },
+    clearOpens () { data.opens = {}; save(); return { ok: true } },
+    /** Mezcla el contador de un aparato (el mayor de cada lado) y devuelve el resultado. */
+    mergeOpens ({ opens }) {
+      if (core.mergeOpens(data.opens, needMap(opens, 'opens'))) save()
+      return { ...data.opens }
+    },
+    exportThreads () { return { threads: data.threads } },
+    // ----- SINCRONIZAR POR PARTES (@dotrino/store ≥ 0.11) -----
+    // `exportThreads`/`importThreads` a secas mueven TODO en un mensaje, y el proxio corta
+    // los frames en 1 MB: con unos cientos de KB de datos la sincronización dejaba de caber.
+    // Con esto el aparato pregunta qué hilos difieren (una huella por hilo), baja su índice
+    // (id y ts) y pide solo las entradas que le faltan, todo por páginas con tope de bytes.
+    // Las reglas —huella, mezcla, lápidas— son las de `@dotrino/store/core`, las mismas que
+    // aplica el navegador: si cada lado llevara las suyas, las huellas no coincidirían nunca.
+    getThreadDigests ({ keys } = {}) {
+      return core.digestsOf(data.threads, keys == null ? undefined : needKeys(keys))
+    },
+    getThreadIndexes ({ keys, cursor, maxBytes }) {
+      return core.indexPage(data.threads, data.tombs, needKeys(keys), cursor || null, budget(maxBytes))
+    },
+    getEntries ({ refs, maxBytes }) {
+      return core.entriesPage(data.threads, needMap(refs, 'refs'), budget(maxBytes))
+    },
+    importThreads ({ threads, tombs, mode = 'merge' }) {
+      if (!threads || typeof threads !== 'object') throw new Error('threads required')
+      if (mode === 'replace') { data.threads = threads; save(); return { mode, count: Object.keys(threads).length } }
+      if (mode !== 'merge' && mode !== 'upsert') throw new Error(`unknown import mode: ${mode}`)
+      const now = Date.now()
+      const buried = core.applyTombs(data.threads, data.tombs, needMap(tombs, 'tombs'), now)
+      const merged = core.mergeEntries(data.threads, data.tombs, threads, { mode, max: MAX_PER_THREAD })
+      core.pruneTombs(data.tombs, now)
+      if (buried.tombsChanged || buried.changed.size || merged.size) save()
+      return { mode, count: Object.keys(data.threads).length, changed: [...new Set([...buried.changed, ...merged])] }
+    },
+    // ----- PERFIL del usuario (me): el vault es la copia AUTORITATIVA -----
+    // Cada dispositivo emparejado lo empuja al editarlo y lo jala al arrancar →
+    // el mismo perfil (apodo/avatar/datos) en todos los dispositivos.
+    profileSet ({ me }) {
+      if (!me || typeof me !== 'object') throw new Error('me required')
+      // nunca guardar llaves de dispositivo (son por-dispositivo)
+      const { publickey, encryptionPubkey, ...content } = me
+      data.profile = { ...content, updatedAt: content.updatedAt || Date.now() }
+      save(); return { ok: true, updatedAt: data.profile.updatedAt }
+    },
+    profileGet () { return { me: data.profile || null } },
+
+    // LOS DATOS DEL PERFIL EN SOBRES (`docs/datos-del-perfil.md`). Están aquí solo para
+    // que el filtro de métodos los reconozca: los atiende `handleProfile` en `vault.js`,
+    // antes de llegar a este store, porque su puerta es otra —`firma` y sin candado—.
+    // Si alguna vez alguien los llamara por este camino, contestan que no en vez de
+    // hacer algo a medias.
+    profilePut () { throw new Error('profilePut is handled before the store: see handleProfile') },
+    profileBundle () { throw new Error('profileBundle is handled before the store: see handleProfile') },
+    profilePublic () { throw new Error('profilePublic is handled before the store: see handleProfile') },
+    profileRecipients () { throw new Error('profileRecipients is handled before the store: see handleProfile') },
+
+    // ----- DATOS SENSIBLES del usuario (F4, docs/consola-remota.md §6) -----
+    //
+    // Contraseñas, notas, documentos: van al contenido del perfil, cifrados con la
+    // CEK de la cuenta y accesibles con `vault:store` — el mismo camino que hilos y
+    // perfil. NO tocan `secrets.json`: ese es el cajón de los SERVICIOS (proxy, geo),
+    // acotado por CN y con clave ligada a la máquina. Mismo nombre coloquial, distinto
+    // dueño.
+    //
+    // La bóveda guarda DOS SOBRES OPACOS por ficha y no abre ninguno:
+    //   `meta` — lo que hace falta para pintar la lista (nombre, tipo, carpeta)
+    //   `enc`  — el valor en sí, que solo viaja cuando abres la ficha
+    // Los sella el dispositivo con la clave de contenido (`identity.sealContent`). Que
+    // sean dos y no uno es lo que permite listar sin bajar todas las contraseñas, y que
+    // el nombre («Banco») tampoco quede legible aquí.
+    //
+    // Alcance: esto es el ALMACÉN. Una app de contraseñas con generador y
+    // autocompletado es otra cosa y no vive aquí.
+    'secure.list' () {
+      return Object.values(data.secure)
+        .map(({ enc, ...rest }) => rest)   // el valor NO viaja al listar
+        .sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0))
+    },
+    'secure.get' ({ id }) {
+      if (!id || typeof id !== 'string') throw new Error('id required')
+      return data.secure[id] || null
+    },
+    'secure.put' ({ id, meta, enc }) {
+      if (typeof enc !== 'string' || !enc) throw new Error('enc required (sealed value)')
+      if (meta != null && typeof meta !== 'string') throw new Error('meta must be a sealed string')
+      // Se comprueba el TAMAÑO, nunca el contenido: son sobres cerrados.
+      if (enc.length > MAX_SECURE_BLOB || (meta || '').length > MAX_SECURE_BLOB) throw new Error('secure: item too large')
+      const prev = id ? data.secure[id] : null
+      if (!prev && Object.keys(data.secure).length >= MAX_SECURE_ITEMS) throw new Error('secure: too many items')
+      const rec = {
+        id: prev?.id || id || crypto.randomUUID(),
+        ts: prev?.ts || Date.now(),
+        updatedAt: Date.now(),
+        meta: meta ?? prev?.meta ?? null,
+        enc
+      }
+      data.secure[rec.id] = rec
+      save()
+      return { id: rec.id, updatedAt: rec.updatedAt }
+    },
+    'secure.del' ({ id }) {
+      if (!id || typeof id !== 'string') throw new Error('id required')
+      const had = !!data.secure[id]
+      delete data.secure[id]
+      if (had) save()
+      return { removed: had ? 1 : 0 }
+    },
+
+    getStats () {
+      const threads = {}
+      for (const [k, arr] of Object.entries(data.threads)) threads[k] = { count: arr.length }
+      return { threadCount: Object.keys(data.threads).length, threads, opensCount: Object.keys(data.opens).length, secureCount: Object.keys(data.secure).length }
+    }
+  }
+  /**
+   * VUELVE A CERRAR CON LA LLAVE VIGENTE todo sobre de la cuenta (`t: 'dotrino-cek'`) de
+   * una generación anterior que haya en lo guardado. Lo llama la BÓVEDA al abrirse y
+   * después de quitar un aparato —que es cuando la llave rota—; NO está en `methods`, así
+   * que ningún aparato puede dispararlo.
+   *
+   * Lo que sirve la bóveda va así siempre con la generación vigente: un aparato que entra
+   * después, que solo recibe esa, abre todo; y la vieja deja de abrir nada porque ya no se
+   * sirve nada cerrado con ella (dueño, 2026-09-30). Cada entrada que cambia estrena `ts`,
+   * para que los aparatos la bajen en su siguiente sincronización.
+   *
+   * También MIGRA los sobres de la cuenta anteriores a la marca (`{ gen, iv, ct }` a secas,
+   * identity < 0.107): si abren con la llave de la cuenta se vuelven a cerrar marcados; si no,
+   * no eran de la cuenta y se cuentan en `skipped` sin tocarlos.
+   *
+   * La versión anterior NO se tira: queda en `resealed` con la fecha, por si algo sale mal
+   * (lo pidió el dueño: «podría retenerlos… pero no los envía»), y se guarda AL MENOS un
+   * año (`RESEALED_KEEP_MS`). No se sirve por ningún método.
+   *
+   * @param {{ gen: number, reseal: (env: object) => Promise<object> }} o
+   * @returns {Promise<{ changed: number, entries: number, skipped: number }>}
+   */
+  async function resealStaleEnvelopes ({ gen, reseal }) {
+    let changed = 0; let entries = 0; let skipped = 0
+    const now = Date.now()
+    if (!data.resealed) data.resealed = []
+    // Solo sale lo que ya cumplió su año de respaldo.
+    const antes = data.resealed.length
+    data.resealed = data.resealed.filter((x) => now - (x.at || 0) < RESEALED_KEEP_MS)
+    const podados = antes - data.resealed.length
+    for (const [key, arr] of Object.entries(data.threads)) {
+      for (let i = 0; i < arr.length; i++) {
+        const r = await resealStale(arr[i], { gen, reseal })
+        skipped += r.skipped || 0
+        if (!r.changed) continue
+        data.resealed.push({ threadKey: key, at: now, gen, before: arr[i] })
+        arr[i] = { ...r.value, ts: Math.max(now, (arr[i].ts || 0) + 1) }
+        changed += r.changed; entries++
+      }
+    }
+    if (entries || podados) save()
+    return { changed, entries, skipped }
+  }
+
+  return { methods, raw: () => data, resealStaleEnvelopes }
+}
+
+/**
+ * Métodos del store que son de SOLO LECTURA (para decidir el scope necesario).
+ *
+ * `secure.list`/`secure.get` NO están aquí a propósito, aunque sean lecturas: los datos
+ * sensibles piden `vault:store` (doc §6), que es MÁS estricto que `vault:read`. Un
+ * dispositivo al que solo le diste «leer» no lee tus contraseñas.
+ */
+export const STORE_READ_METHODS = new Set([
+  'listThread', 'listThreadKeys', 'getThreadSummaries', 'getOpens', 'exportThreads', 'getStats', 'profileGet',
+  'getThreadDigests', 'getThreadIndexes', 'getEntries'
+])
+
+/**
+ * Métodos que EDITAN el perfil del usuario (quién es: apodo, avatar, campos).
+ * Son los únicos que el candado por contraseña bloquea (`vault.js`): el resto del
+ * store —contenido de las apps— sigue disponible con el perfil bloqueado.
+ */
+export const PROFILE_EDIT_METHODS = new Set(['profileSet'])