@dotrino/identity 0.114.1 → 0.116.0

package/vault/vendor/passmanager/vault/local.js

@@ -0,0 +1,213 @@
+// Bóveda local: la que corre donde SÍ está la CEK — el vault del PC, la app nativa,
+// y la caché opt-in de solo lectura de la extensión (DISENO §3).
+//
+// El almacén se inyecta para no atar la librería a nada: en la app es
+// `@dotrino/store`, en la extensión `chrome.storage.local`, en las pruebas un Map.
+// Solo tiene que cumplir `{ get(k), set(k, v) }`.
+
+import { openEntry, sealEntry, mergePatch, publicView, entryWho, normalizeSites } from '../model.js'
+import { entryDigestValues, fieldKey, normalizeFields, KINDS } from '../fields.js'
+import { makeNonce, fieldHasher } from '../crypto.js'
+import { findForUrl } from '../match.js'
+import { VaultError, CODES } from './errors.js'
+
+const KEY = 'passmanager/entries/v1'
+
+export class LocalVault {
+  /**
+   * @param {object} store almacén `{ get(k), set(k, v) }`
+   * @param {object} opts  `{ readOnly }` — la caché de la extensión va en `true`
+   */
+  constructor (store, opts = {}) {
+    this.store = store
+    this.readOnly = !!opts.readOnly
+    this.key = null
+  }
+
+  get capabilities () {
+    return { canWrite: !this.readOnly, canList: true, needsApproval: false }
+  }
+
+  /** Entrega la CEK. Sin esto, todo lo demás falla con `locked`. */
+  unlock (cek) {
+    this.key = cek
+  }
+
+  lock () {
+    this.key = null
+  }
+
+  #requireKey () {
+    if (!this.key) throw new VaultError(CODES.LOCKED, 'la bóveda está cerrada')
+  }
+
+  async #all () {
+    return (await this.store.get(KEY)) || []
+  }
+
+  /**
+   * Los RESÚMENES de los campos de una entrada, para que quien pregunta pueda comparar
+   * sin abrir nada (§4.0.2). Un nonce por respuesta, no por entrada: así dos entradas de
+   * la misma respuesta se pueden comparar contra lo mismo, y entre dos respuestas no hay
+   * nada que correlacionar.
+   */
+  async #digest (nonce, hash, open) {
+    const fields = {}
+    for (const f of entryDigestValues(open)) fields[f.key] = await hash(f.key, f.value)
+    return { nonce, fields }
+  }
+
+  async find (url) {
+    this.#requireKey()
+    const hits = findForUrl(await this.#all(), url)
+    const nonce = makeNonce()
+    const hash = await fieldHasher(nonce)
+    // El nombre visible obliga a abrir la entrada: por eso lo calcula quien tiene la CEK,
+    // y no quien pregunta. Lo mismo los resúmenes.
+    return Promise.all(hits.map(async ({ entry }) => {
+      const open = await openEntry(this.key, entry)
+      return publicView(entry, entryWho(open), open, await this.#digest(nonce, hash, open))
+    }))
+  }
+
+  async get (id) {
+    this.#requireKey()
+    const entry = (await this.#all()).find(e => e.id === id)
+    if (!entry) throw new VaultError(CODES.NOT_FOUND, 'no hay ninguna entrada con ese id')
+    return openEntry(this.key, entry)
+  }
+
+  async put (plain) {
+    this.#requireKey()
+    if (this.readOnly) throw new VaultError(CODES.READ_ONLY, 'esta copia solo puede leer')
+    const sealed = await sealEntry(this.key, plain)
+    const all = await this.#all()
+    const i = all.findIndex(e => e.id === sealed.id)
+    if (i >= 0) {
+      sealed.createdAt = all[i].createdAt
+      all[i] = sealed
+    } else {
+      all.push(sealed)
+    }
+    await this.store.set(KEY, all)
+    return publicView(sealed)
+  }
+
+  /**
+   * CAMBIAR unos campos de una entrada, dejando el resto como estaba.
+   *
+   * Existe para que quien guarda **no tenga que leerla antes**. Antes el aparato hacía
+   * `get` + fusionar + `put`, y eso tenía dos costes que no se veían: sacaba de la bóveda
+   * la entrada entera —contraseña incluida— para escribir un teléfono, y si esa lectura
+   * fallaba, el `put` que venía detrás escribía la entrada **sin lo que no pudo leer**.
+   * Eso no es un fallo raro: es perder datos por una autorización denegada.
+   *
+   * Aquí la fusión ocurre donde vive el dato. Lo que no venga en `changes` no se toca, y
+   * si la entrada no existe no se crea nada — para crear está `put`.
+   *
+   * `changes`:
+   *   `name`, `title`, `username`, `secret`, `totp`, `notes`  cada uno, si viene, reemplaza
+   *   `fields`  lista `{ label, value, kind, private }`; se casan por su clave (§4.2),
+   *             los que no aparecen se quedan. **`value` sin poner no toca el valor**:
+   *             sirve para cambiar solo la marca de privado, que es lo único que se puede
+   *             hacer desde el gestor con un campo cuyo valor no se tiene delante
+   *   `removeFields`  claves que se van. Un campo libre desaparece; uno de los de siempre
+   *             (`username`, `secret`, `totp`, `notes`) se queda vacío, que es lo mismo
+   *   `sites`   la lista ENTERA, tal cual queda. Es lo que manda el gestor, que la edita
+   *             a mano; vacía significa «sirve en cualquier sitio», que es lo que la
+   *             ausencia de sitios ha significado siempre. Si viene, `addSite` se ignora
+   *   `addSite` suma este sitio **solo si la entrada ya tenía alguno**: una entrada sin
+   *             sitios sirve en cualquier parte, y atarla al primer formulario donde se
+   *             usó sería quitarle eso sin que nadie lo pidiera
+   */
+  async patch (id, changes = {}) {
+    this.#requireKey()
+    if (this.readOnly) throw new VaultError(CODES.READ_ONLY, 'esta copia solo puede leer')
+    const all = await this.#all()
+    const i = all.findIndex(e => e.id === id)
+    if (i < 0) throw new VaultError(CODES.NOT_FOUND, 'no hay ninguna entrada con ese id')
+
+    const base = await openEntry(this.key, all[i])
+    // La fusión vive en `model.js` y la comparten esta bóveda y la sellada: no es un
+    // `{...a, ...b}` —un campo sin `value` dice «déjale el que tenga»— y dos copias de esa
+    // sutileza son una que se queda atrás.
+    const sealed = await sealEntry(this.key, mergePatch(base, changes))
+    all[i] = sealed
+    await this.store.set(KEY, all)
+    return publicView(sealed)
+  }
+
+  /**
+   * EN QUÉ SITIOS HAY ALGO GUARDADO, y cuánto en cada uno.
+   *
+   * Es lo que le permite al gestor abrir con la lista de dominios en vez de con un
+   * buscador en blanco (dueño, 2026-08-29). **No es `list`**, y la diferencia no es de
+   * grado: de aquí no sale ni un id, ni un nombre, ni qué campos lleva nadie, ni un
+   * resumen con el que comparar. Sale el dominio, que **ya viaja en claro** —`sites` no
+   * se cifra, porque hace falta para emparejar con la página sin tener la CEK (§5)— y
+   * cuántas entradas hay en él.
+   *
+   * Lo que sí concede, y conviene decirlo: hoy hay que preguntar sitio por sitio para
+   * saber dónde tienes cuenta, y esto lo contesta de una vez. Es la razón de que el
+   * dueño lo decidiera a propósito y no se colara como un detalle.
+   *
+   * `site: ''` son las entradas SIN sitio, que sirven en cualquier parte.
+   */
+  async sites () {
+    this.#requireKey()
+    const cuenta = new Map()
+    for (const e of await this.#all()) {
+      const suyos = e.sites?.length ? e.sites : ['']
+      for (const s of suyos) cuenta.set(s, (cuenta.get(s) || 0) + 1)
+    }
+    return [...cuenta.entries()]
+      .map(([site, count]) => ({ site, count }))
+      .sort((a, b) => (a.site === '' ? 1 : b.site === '' ? -1 : a.site.localeCompare(b.site)))
+  }
+
+  /**
+   * BUSCAR por texto en toda la bóveda. Devuelve lo público, y como mucho `limit`.
+   *
+   * No es `list` con otro nombre, y la diferencia importa (DISENO §2): `list` lo puede
+   * pedir el código en cualquier momento y devuelve todo; esto exige un término que
+   * **escribe una persona** y devuelve un puñado. Existe porque a veces la cuenta que
+   * sirve está guardada en otro dominio —el subdominio cambió y la clave es la misma— y
+   * sin buscarla no hay forma de llegar a ella.
+   *
+   * Se busca en lo que identifica a la entrada: su título, sus sitios y su nombre
+   * visible. **Nunca en los valores de los campos**: buscar «1700» y que aparezca tu
+   * documento es exactamente lo que no puede pasar.
+   */
+  async search (q, { limit = 20 } = {}) {
+    this.#requireKey()
+    const texto = String(q || '').trim().toLowerCase()
+    if (texto.length < 2) return []
+    const nonce = makeNonce()
+    const hash = await fieldHasher(nonce)
+    const out = []
+    for (const entry of await this.#all()) {
+      if (out.length >= limit) break
+      const open = await openEntry(this.key, entry)
+      const quien = entryWho(open)
+      const heno = [entry.title, quien, ...(entry.sites || [])].filter(Boolean).join(' ').toLowerCase()
+      if (heno.includes(texto)) {
+        out.push(publicView(entry, quien, open, await this.#digest(nonce, hash, open)))
+      }
+    }
+    return out
+  }
+
+  async remove (id) {
+    this.#requireKey()
+    if (this.readOnly) throw new VaultError(CODES.READ_ONLY, 'esta copia solo puede leer')
+    const all = await this.#all()
+    const rest = all.filter(e => e.id !== id)
+    if (rest.length === all.length) throw new VaultError(CODES.NOT_FOUND, 'no hay ninguna entrada con ese id')
+    await this.store.set(KEY, rest)
+  }
+
+  async list () {
+    this.#requireKey()
+    return (await this.#all()).map(e => publicView(e))
+  }
+}

package/vault/vendor/passmanager/vault/remote.js

@@ -0,0 +1,85 @@
+// Bóveda remota: la que usa la extensión de Chrome por defecto (DISENO §2).
+//
+// No tiene la CEK y no guarda nada. Pregunta por un dominio, recibe metadatos, y
+// pide UNA credencial cuando el usuario elige. Quién responde al otro lado del
+// transporte —el vault del PC o el teléfono— le da igual.
+
+import { VaultError, CODES } from './errors.js'
+
+export class RemoteVault {
+  /**
+   * @param {object} transport `{ request(op, payload) }` — proxy, WebSocket o
+   *   `chrome.runtime` según dónde corra. Devuelve la respuesta ya deserializada.
+   */
+  constructor (transport, opts = {}) {
+    this.transport = transport
+    this.needsApproval = opts.needsApproval !== false
+  }
+
+  get capabilities () {
+    return { canWrite: true, canList: false, needsApproval: this.needsApproval }
+  }
+
+  async find (url) {
+    return this.#request('find', { url })
+  }
+
+  /**
+   * UNA credencial, y **solo los campos que se piden**.
+   *
+   * `keys` no es una optimización: es lo que hace que rellenar un nombre no saque de la
+   * bóveda la contraseña. Al otro lado, pedir algo privado puede exigir la huella; pedir
+   * lo público, no (DISENO §4.2).
+   */
+  async get (id, opts = {}) {
+    return this.#request('get', { id, ...(Array.isArray(opts.keys) ? { keys: opts.keys } : {}) })
+  }
+
+  async put (entry) {
+    return this.#request('put', { entry })
+  }
+
+  /**
+   * CAMBIAR unos campos sin leer la entrada antes. Lo demás se queda como estaba, y la
+   * fusión la hace quien tiene el dato — así guardar un teléfono no saca una contraseña.
+   */
+  async patch (id, changes) {
+    return this.#request('patch', { id, changes })
+  }
+
+  /**
+   * No se puede, y no es una limitación técnica: si la extensión pudiera listar la
+   * bóveda entera, el "pide de a una" no significaría nada (DISENO §2).
+   */
+  /** Buscar por texto en toda la bóveda. Lo público, y con tope (ver `LocalVault`). */
+  async search (q, opts = {}) {
+    return this.#request('search', { q, limit: opts.limit })
+  }
+
+  /**
+   * En qué sitios hay algo guardado, y cuántas entradas en cada uno. Ni un id ni un
+   * nombre: el dominio, que ya viaja en claro para poder emparejar (§5).
+   */
+  async sites () {
+    return this.#request('sites', {})
+  }
+
+  /** Quitar una entrada. La borra quien la tiene, no quien la pide. */
+  async remove (id) {
+    return this.#request('remove', { id })
+  }
+
+  async list () {
+    throw new VaultError(CODES.NO_KEY, 'una bóveda remota no lista: pide de a una')
+  }
+
+  async #request (op, payload) {
+    try {
+      return await this.transport.request(op, payload)
+    } catch (e) {
+      // El transporte puede fallar de muchas formas; hacia arriba solo hay códigos.
+      if (e instanceof VaultError) throw e
+      throw new VaultError(e?.code || CODES.UNREACHABLE, e?.message || 'no hay bóveda al otro lado')
+    }
+  }
+}

package/vault/vendor/passmanager/vault/responder.js

@@ -0,0 +1,192 @@
+// El lado que RESPONDE: la bóveda de verdad (el vault del PC, la app nativa).
+//
+// Es donde vive la política, y por eso está aquí y no repartida por cada aparato:
+// quién puede pedir, qué puede pedir, qué exige aprobación y qué queda anotado. Un
+// aparato que pide no decide nada.
+
+import { isRequest, reply, replyError, REMOTE_OPS, ADMIN_OPS } from '../transport/protocol.js'
+import { ApprovalGate } from './approval.js'
+import { privateKeysOf } from '../fields.js'
+import { projectEntry } from '../model.js'
+import { CODES } from './errors.js'
+
+export class VaultResponder {
+  /**
+   * @param {object} opts
+   *   `client`   cliente de @dotrino/proxy-client conectado e identificado
+   *   `vault`    una bóveda con la CEK (LocalVault desbloqueada)
+   *   `isAllowed(pubkey) -> boolean`  qué aparatos pueden pedir. Por defecto NADIE:
+   *              una bóveda que responde a cualquiera no es una bóveda.
+   *   `needsApproval(op, payload, pubkey) -> boolean|Promise`  qué exige un dedo encima.
+   *              Por defecto: **solo `get`, y solo si lo pedido incluye algo privado**
+   *              (dueño, 2026-08-29). Rellenar un nombre no es sacar un secreto.
+   *   `approve({ op, payload, pubkey }) -> Promise<boolean>`  cómo se pide ese dedo
+   *   `onRequest(record)`  la bitácora
+   *   `admin`  `{ devices(), unlink(pubkey) }` — opcional. Sin esto, un aparato no
+   *            puede administrar nada, que es el valor por defecto correcto.
+   *
+   * **La aprobación es del APARATO, no de cada credencial.** Se pide una vez y vale
+   * mientras esta bóveda siga encendida; apagarla la retira. Es el mismo modelo que
+   * `pair --approval` del vault: una por arranque, sin ventana de tiempo que vigilar.
+   *
+   * No se ata a la conexión a propósito: un service worker se duerme cada poco y
+   * reconecta constantemente, así que «por conexión» sería pedir el dedo todo el rato.
+   * Quien manda es la bóveda, que es la que el usuario apaga cuando quiere cortar.
+   */
+  constructor ({ client, vault, isAllowed, needsApproval, approve, onRequest, encPubOf, admin } = {}) {
+    this.admin = admin || null
+    this.client = client
+    this.vault = vault
+    // La pública de cifrado de cada aparato, para sellarle la respuesta. Abrir lo que
+    // llega es cosa del cliente del pilar (`requireSealed` + `myEncPrivateKey`).
+    this.encPubOf = encPubOf || (() => null)
+    this.isAllowed = isAllowed || (() => false)
+    this.needsApproval = needsApproval || ((op, payload) => this.wantsPrivate(op, payload))
+    this.approve = approve || (async () => false)
+    this.onRequest = onRequest || (() => {})
+    this._handler = null
+    // La puerta es la MISMA que la de la bóveda de dentro de la extensión
+    // (`GuardedVault`): dedupe de simultáneas, el sí recordado, el no nunca. Aquí se
+    // recuerda por APARATO, que es lo que dice §2.0, y vive en memoria — apagar la
+    // bóveda retira lo aprobado, que es el diseño.
+    this.gate = new ApprovalGate({
+      ask: ({ op, payload, pubkey }) => this.approve({ op, payload, pubkey }),
+      scope: ({ pubkey }) => pubkey,
+    })
+  }
+
+  /** Retira la aprobación de un aparato sin apagar la bóveda. */
+  revokeApproval (pubkey) {
+    this.gate.revoke(pubkey || null)
+  }
+
+  isApproved (pubkey) {
+    return this.gate.granted(pubkey)
+  }
+
+  /**
+   * ¿Lo que se pide incluye algo PRIVADO? Es la pregunta que decide si hace falta un dedo
+   * encima, y solo la puede contestar quien tiene la llave: hay que abrir la entrada para
+   * saber qué campos marcó el usuario (§4.2).
+   *
+   * Es **pública** para que una bóveda con su propia política la componga en vez de
+   * reescribirla: el vault del ecosistema, por ejemplo, aprueba por aparato *y* quiere
+   * este criterio encima (`needsApproval(pubkey) && responder.wantsPrivate(op, payload)`).
+   * Sin esto, cada bóveda acabaría con su propia idea de qué es privado.
+   *
+   * Si no se puede abrir, se contesta que **sí**: ante la duda, se pregunta.
+   */
+  async wantsPrivate (op, payload) {
+    if (op !== 'get') return false
+    try {
+      const open = await this.vault.get(payload.id)
+      const privadas = privateKeysOf(open)
+      if (!Array.isArray(payload.keys)) return privadas.size > 0
+      return payload.keys.some(k => privadas.has(k))
+    } catch { return true }
+  }
+
+  start () {
+    if (this._handler) return
+    this._handler = (from, payload, meta) => {
+      this.#handle(payload, meta?.fromPubkey || from, meta).catch(() => {})
+    }
+    this.client.on('message', this._handler)
+  }
+
+  stop () {
+    if (this._handler && this.client.off) this.client.off('message', this._handler)
+    this._handler = null
+  }
+
+  async #send (pubkey, msg) {
+    try {
+      // La respuesta lleva la credencial: se sella al aparato que la pidió, o no sale.
+      const encPub = this.encPubOf(pubkey)
+      if (!encPub) return
+      await this.client.sendSealed([pubkey], msg, { peerEncPub: encPub })
+    } catch { /* el que pidió reintentará */ }
+  }
+
+  async #handle (msg, fromPubkey, meta) {
+    if (!isRequest(msg)) return
+
+    // **Nada sin cifrar entra.** El cliente del pilar abre los sobres y marca
+    // `meta.sealed`; aquí se exige esa marca. Sin ella bastaría con mandar la petición
+    // en claro para saltarse el sellado entero, y el proxio vería qué se pide.
+    if (meta?.sealed !== true) {
+      this.onRequest({ op: msg.op, from: fromPubkey, ts: Date.now(), outcome: 'unsealed' })
+      return
+    }
+
+    const record = { op: msg.op, from: fromPubkey, ts: Date.now() }
+
+    // 1. ¿Es un aparato que conozco? Si no, ni se le contesta qué falló.
+    if (!fromPubkey || !this.isAllowed(fromPubkey)) {
+      this.onRequest({ ...record, outcome: 'denied' })
+      return this.#send(fromPubkey, replyError(msg.rid, CODES.DENIED, 'aparato no autorizado'))
+    }
+
+    // 2. `list` no está en la lista, y esa ausencia es el diseño: si un aparato
+    //    pudiera pedir la bóveda entera, el "de a una" no significaría nada.
+    const esAdmin = ADMIN_OPS.includes(msg.op)
+    if (!REMOTE_OPS.includes(msg.op) && !esAdmin) {
+      this.onRequest({ ...record, outcome: 'denied' })
+      return this.#send(fromPubkey, replyError(msg.rid, CODES.DENIED, 'operación no permitida en remoto'))
+    }
+    if (esAdmin && !this.admin) {
+      this.onRequest({ ...record, outcome: 'denied' })
+      return this.#send(fromPubkey, replyError(msg.rid, CODES.DENIED, 'esta bóveda no se administra en remoto'))
+    }
+
+    try {
+      const payload = msg.payload || {}
+
+      // Administrar SIEMPRE se aprueba, y aparte: retirar un aparato desde otro
+      // aparato es tan delicado como entregar una contraseña, y en el otro sentido.
+      // Que el aparato ya esté aprobado para pedir credenciales no le da esto.
+      if (esAdmin) {
+        const ok = await this.approve({ op: msg.op, payload, pubkey: fromPubkey, admin: true })
+        if (!ok) {
+          this.onRequest({ ...record, outcome: 'refused' })
+          return this.#send(fromPubkey, replyError(msg.rid, CODES.NOT_APPROVED, 'no aprobado'))
+        }
+        const result = msg.op === 'devices'
+          ? await this.admin.devices()
+          : await this.admin.unlink(payload.pubkey)
+        this.onRequest({ ...record, outcome: 'served' })
+        return this.#send(fromPubkey, reply(msg.rid, result ?? null))
+      }
+
+      if (await this.needsApproval(msg.op, payload, fromPubkey)) {
+        const ok = await this.gate.allow({ op: msg.op, payload, pubkey: fromPubkey })
+        if (!ok) {
+          this.onRequest({ ...record, outcome: 'refused' })
+          return this.#send(fromPubkey, replyError(msg.rid, CODES.NOT_APPROVED, 'no aprobado'))
+        }
+      }
+
+      let result
+      switch (msg.op) {
+        case 'find': result = await this.vault.find(payload.url); break
+        // Solo lo pedido sale por el cable: sin este recorte, rellenar un nombre mandaba
+        // la entrada entera —contraseña incluida— al aparato que preguntó.
+        case 'get':
+          result = projectEntry(await this.vault.get(payload.id),
+            Array.isArray(payload.keys) ? payload.keys : null)
+          break
+        case 'put': result = await this.vault.put(payload.entry); break
+        case 'patch': result = await this.vault.patch(payload.id, payload.changes); break
+        case 'sites': result = await this.vault.sites(); break
+        case 'search': result = await this.vault.search(payload.q, { limit: payload.limit }); break
+        case 'remove': result = await this.vault.remove(payload.id); break
+      }
+
+      this.onRequest({ ...record, outcome: 'served', id: payload.id })
+      await this.#send(fromPubkey, reply(msg.rid, result ?? null))
+    } catch (e) {
+      this.onRequest({ ...record, outcome: 'error', code: e?.code })
+      await this.#send(fromPubkey, replyError(msg.rid, e?.code || 'error', e?.message))
+    }
+  }
+}

package/vault/vendor/passmanager/vault/sealed-local.js

@@ -0,0 +1,199 @@
+// LA BÓVEDA SELLADA CUANDO QUIEN GUARDA Y QUIEN LEE SON EL MISMO PROCESO.
+//
+// `SealedVault` es el aparato hablando con una bóveda que está al otro lado de un
+// transporte. Esto es el otro caso, y existe de verdad en dos sitios del ecosistema:
+//
+//   · **`dotrino-passmanager serve`** — el mismo proceso atiende por el proxio y es
+//     también la línea de comandos con la que el dueño mira lo suyo;
+//   · **la bóveda de dentro de la extensión** — no hay nadie más a quien preguntar.
+//
+// En los dos, quien lee lo hace con UNA envoltura: la de `#recovery` (el dueño con su
+// contraseña) o la del propio aparato. Se le dice cuál al construirla y no se adivina:
+// adivinarlo sería leer con la que hubiera, y entonces «no puedo abrir esto» y «esto no es
+// para mí» se verían igual.
+//
+// Cumple el contrato de siempre (`./interface.js`) para que nada de lo que hay encima
+// tenga que aprender otra forma de pedir las cosas.
+
+import { VaultError, CODES } from './errors.js'
+import { findForUrl } from '../match.js'
+import { siteIndex, fieldIndex, valueDigest } from '../sealed/keys.js'
+import { buildSealedEntry, openSealedEntry, openSealedView } from '../sealed/device.js'
+import { mergePatch } from '../model.js'
+
+/** Los nombres FIJOS, que viajan tal cual: vocabulario cerrado e igual para todos. */
+const FIXED = ['name', 'username', 'secret', 'totp', 'notes']
+
+export class SealedLocalVault {
+  /**
+   * @param {SealedStore} sealed  el almacén de sobres
+   * @param {object} opts
+   *   `readerPub`   con qué envoltura se lee: `RECOVERY` o la pública de este aparato
+   *   `openSealed({ wrap, envelope })` abre un sobre. La privada no sale de donde viva.
+   *   `author`      `{ publickey, sign(body) }` quien firma lo que se escribe
+   *   `recipients()` → `{ recoveryPub, main, passkeys }` a quién se le envuelve
+   *   `keys()`      → las llaves del perfil (`profileKeys`), para huellas y resúmenes
+   */
+  constructor (sealed, { readerPub, openSealed, author, recipients, keys } = {}) {
+    if (!sealed) throw new Error('SealedLocalVault: missing the sealed store')
+    if (!readerPub) throw new Error('SealedLocalVault: say which wrap this one reads with')
+    for (const n of ['openSealed', 'author', 'recipients', 'keys']) {
+      if (!arguments[1]?.[n]) throw new Error(`SealedLocalVault: missing ${n}`)
+    }
+    this.sealed = sealed
+    this.readerPub = readerPub
+    this.openSealed = openSealed
+    this.author = author
+    this.recipients = recipients
+    this.keys = keys
+  }
+
+  get capabilities () {
+    // `canList` es `true` y aquí sí es verdad: quien pregunta es el dueño en su propia
+    // máquina, no un aparato pidiendo por el proxio. Lo que no existe en remoto sigue sin
+    // existir — esto no se asoma por ningún transporte.
+    return { canWrite: true, canList: true, needsApproval: false, sealed: true }
+  }
+
+  /** De la clave que usa la interfaz a la que guarda la bóveda. La misma que `SealedVault`. */
+  async #sealedKey (k) {
+    if (FIXED.includes(k) || k.startsWith('wa.')) return k
+    const { kidx } = await this.keys()
+    return 'f:' + await fieldIndex(kidx, k)
+  }
+
+  /** Las vistas, abiertas. Es lo que se enseña en una lista: sin valores privados. */
+  async list () {
+    const vistas = await this.sealed.views({ pub: this.readerPub })
+    const out = []
+    for (const v of vistas) {
+      const abierta = await openSealedView({ ...v, openSealed: this.openSealed })
+      // `fieldHashes` con el nombre que ya usa la interfaz para comparar sin abrir nada.
+      // Los resúmenes están GUARDADOS y su clave viaja por huella, así que aquí se
+      // traducen de vuelta — la vista sí lleva los nombres de verdad, porque va sellada.
+      // Sin esto, «¿ya está guardado igual?» se contesta que no siempre, y el aviso de
+      // guardar sale en cada formulario que ya tenías.
+      const fieldHashes = {}
+      for (const k of [...(abierta.fieldKeys || []), 'notes']) {
+        const clave = await this.#sealedKey(k)
+        if (abierta.digests?.[clave] !== undefined) fieldHashes[k] = abierta.digests[clave]
+      }
+      out.push({ ...abierta, fieldHashes })
+    }
+    return out
+  }
+
+  /**
+   * El resumen de un valor, para decir si ya está guardado igual **sin abrir nada** (§2.6).
+   * No hay nonce que compartir: el `id` de la entrada va dentro, que es lo que impide que
+   * un valor repetido en dos entradas se note.
+   */
+  async digest (id, key, value) {
+    const { kcmp } = await this.keys()
+    return valueDigest(kcmp, id, key, String(value))
+  }
+
+  /**
+   * Lo que hay para una URL, ya ORDENADO por lo bien que casa: las entradas, no los pares
+   * `{entry, match}` de `findForUrl`. Es la misma forma que devuelve `SealedVault.find`,
+   * y tiene que serlo — quien llama no debería notar de qué bóveda le están contestando.
+   */
+  async find (url) {
+    return findForUrl(await this.list(), url).map((x) => x.entry)
+  }
+
+  /**
+   * EN QUÉ SITIOS HAY ALGO, y cuánto en cada uno. Misma forma que `LocalVault.sites()`
+   * —`[{ site, count }]`— porque es lo que pinta el gestor: devolver una lista de cadenas
+   * dejaba la fila de dominios vacía sin un solo error.
+   *
+   * El sitio vacío es «sirve en cualquier parte» y va al final, que es donde se busca.
+   */
+  async sites () {
+    const cuenta = new Map()
+    for (const e of await this.list()) {
+      for (const s of (e.sites?.length ? e.sites : [''])) cuenta.set(s, (cuenta.get(s) || 0) + 1)
+    }
+    return [...cuenta.entries()]
+      .map(([site, count]) => ({ site, count }))
+      .sort((a, b) => (a.site === '' ? 1 : b.site === '' ? -1 : a.site.localeCompare(b.site)))
+  }
+
+  /**
+   * BUSCAR por texto. Se mira lo mismo que mira `SealedVault`: el nombre, el SITIO y la
+   * **pista** —el usuario tapado que la vista lleva—, que es por lo que la gente busca de
+   * verdad («ana@…»). Dejarla fuera hacía que buscar la cuenta de otro dominio no
+   * encontrara nada, sin un solo error.
+   *
+   * Se busca sobre las VISTAS, no sobre los valores: aquí no se abre ninguna contraseña
+   * para contestar a un buscador.
+   */
+  async search (texto, { limit = 20 } = {}) {
+    const q = String(texto || '').trim().toLowerCase()
+    if (!q) return []
+    const out = []
+    for (const v of await this.list()) {
+      if (out.length >= limit) break
+      if ([v.title, v.hint, ...(v.sites || [])].filter(Boolean).join(' ').toLowerCase().includes(q)) out.push(v)
+    }
+    return out
+  }
+
+  /** Una entrada ENTERA, o solo los campos que se pidan. */
+  async get (id, { keys = null } = {}) {
+    let got
+    try { got = await this.sealed.get(id, { pub: this.readerPub, keys }) }
+    catch (e) {
+      if (e?.code === 'not-found') throw new VaultError(CODES.NOT_FOUND, 'no hay ninguna entrada con ese id')
+      // «no me la envolvieron a mí» no es «no existe», y confundirlas manda a buscar el
+      // problema al sitio equivocado.
+      if (e?.code === 'not-yours') throw new VaultError(CODES.NOT_ALLOWED, 'esta punta no tiene llave para esa entrada')
+      throw e
+    }
+    return openSealedEntry({ got, openSealed: this.openSealed })
+  }
+
+  /**
+   * GUARDAR. Se cierra aquí y sale cerrado: la entrada se cifra, su llave se envuelve a
+   * los destinatarios que diga el acta AHORA y el conjunto va firmado.
+   *
+   * Los destinatarios se piden en cada escritura y no se cachean: un aparato que acaba de
+   * entrar tiene que poder leer lo siguiente que se guarde.
+   */
+  async put (entry) {
+    const sobre = await buildSealedEntry({
+      plain: entry,
+      keys: await this.keys(),
+      recipients: await this.recipients(),
+      author: this.author
+    })
+    await this.sealed.putSealed(sobre)
+    // La VISTA, como devuelve `LocalVault.put`: quien llama enseña el nombre de lo que
+    // acaba de guardar. Devolver solo el id dejaba un «Guardada: undefined» en la CLI.
+    return { id: sobre.entry.id, title: entry.title || '', sites: entry.sites || [] }
+  }
+
+  /**
+   * Cambiar unos campos. Se hace leyendo y volviendo a escribir porque aquí quien lee y
+   * quien escribe son el mismo: no hay nada que ahorrar ocultándose un valor a sí mismo.
+   * (En remoto SÍ lo hay, y por eso allí existe `patchSealed`.)
+   *
+   * La fusión la hace `mergePatch`, la MISMA que `LocalVault` — y tiene que ser la misma,
+   * porque no es un `{...a, ...b}`: un campo sin `value` dice «déjale el que tenga», no
+   * «bórralo». Marcar uno como privado llega así, y fusionarlo a lo bruto le borraba el
+   * valor. Costó encontrarlo porque no falla: guarda, y el campo ya no está.
+   */
+  async patch (id, changes = {}) {
+    return this.put(mergePatch(await this.get(id), changes))
+  }
+
+  async remove (id) { return this.sealed.remove(id) }
+
+  /** La huella de un sitio, por si quien llama quiere preguntar por ella directamente. */
+  async siteIndexOf (site) {
+    const { kidx } = await this.keys()
+    return siteIndex(kidx, site)
+  }
+}
+
+export default { SealedLocalVault }