@dotrino/identity 0.114.1 → 0.116.0

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

@@ -0,0 +1,159 @@
+// EL LADO QUE RESPONDE, con el formato sellado.
+//
+// Hace lo mismo que `VaultResponder` —es donde vive la política: quién puede pedir, qué
+// exige un dedo encima y qué queda anotado— con una diferencia que lo cambia todo: **esta
+// bóveda no puede abrir nada**. Así que lo que entrega son sobres, y lo que comprueba es lo
+// que se puede comprobar sin ninguna llave.
+//
+// Va aparte del responder de siempre y no dentro de él porque el protocolo es OTRO
+// (`pm2.*`, ver `../transport/protocol.js`): mezclarlos daría una clase con dos modos, que
+// es como se acaba sirviendo el formato viejo «mientras tanto» — o sea, el agujero otra vez.
+
+import { isRequest, reply, replyError, SEALED_OPS } from '../transport/protocol.js'
+import { ApprovalGate } from './approval.js'
+import { ALWAYS_PRIVATE } from '../fields.js'
+import { CODES } from './errors.js'
+import { PASSKEY_FIELD } from '../sealed/entry.js'
+
+/** Lo que es privado POR LO QUE ES, sin mirar ninguna marca. */
+const SIEMPRE_PRIVADO = new Set([...ALWAYS_PRIVATE.filter((k) => k !== 'webauthn'), PASSKEY_FIELD, 'wa.userHandle'])
+
+export class SealedResponder {
+  /**
+   * @param {object} opts
+   *   `client`    cliente de `@dotrino/proxy-client` conectado e identificado
+   *   `store`     una `SealedStore`
+   *   `recipients()` → `{ recoveryPub, main, passkeys }`, del acta
+   *   `isAllowed(pubkey)`  quién puede pedir (el acta: `passwords`). Por defecto NADIE.
+   *   `needsApproval(pubkey)`  si ese aparato tiene que pedir permiso (el acta:
+   *      `unattended`). Se compone con el criterio de abajo: **solo lo privado pregunta**.
+   *   `approve({ op, payload, pubkey })`  pide el visto bueno y espera
+   *   `encPubOf(pubkey)`  para sellarle la respuesta
+   *   `onRequest(record)` la bitácora
+   */
+  constructor ({ client, store, recipients, isAllowed, needsApproval, approve, encPubOf, onRequest } = {}) {
+    this.client = client
+    this.store = store
+    this.recipients = recipients || (async () => ({ recoveryPub: null, main: [], passkeys: [] }))
+    this.isAllowed = isAllowed || (() => false)
+    this.encPubOf = encPubOf || (() => null)
+    this.needsApproval = needsApproval || (async () => true)
+    this.approve = approve || (async () => false)
+    this.onRequest = onRequest || (() => {})
+    this._handler = null
+    this.gate = new ApprovalGate({
+      ask: ({ op, payload, pubkey }) => this.approve({ op, payload, pubkey }),
+      scope: ({ pubkey }) => pubkey
+    })
+  }
+
+  revokeApproval (pubkey) { this.gate.revoke(pubkey || null) }
+  isApproved (pubkey) { return this.gate.granted(pubkey) }
+
+  /**
+   * ¿LO QUE SE PIDE ES PRIVADO? Aquí se contesta SIN abrir nada, y por eso hace falta la
+   * lista en claro de la entrada (`priv`): la bóveda no ve la vista.
+   *
+   * Sin `keys` se pide la entrada entera, y eso siempre es privado: pedir todo es pedir la
+   * contraseña.
+   */
+  async wantsPrivate (op, payload) {
+    if (op !== 'pm2.get') return false
+    const keys = payload?.keys
+    if (!Array.isArray(keys)) return true
+    const priv = new Set(await this.store.privateKeysOf(payload?.id))
+    return keys.some((k) => SIEMPRE_PRIVADO.has(k) || priv.has(k))
+  }
+
+  start () {
+    if (this._handler) return
+    this._handler = async (from, msg, meta) => {
+      const p = typeof msg === 'string' ? (() => { try { return JSON.parse(msg) } catch (_) { return null } })() : msg
+      if (!isRequest(p)) return
+      // QUIÉN PREGUNTA lo dice el proxio (`fromPubkey`: la llave con la que se identificó esa
+      // conexión) o un saludo previo (`pubkeyOfToken`). Aquí se leía `meta.pubkey`, que no
+      // existe, y se caía al token: ninguna bóveda sabía a quién sellarle la respuesta, no
+      // contestaba, y del otro lado se veía «nadie respondió». Sin llave no hay a quién
+      // contestar sellado, así que no se contesta — el token no es una llave.
+      const pubkey = meta?.fromPubkey || this.client?.pubkeyOfToken?.(from) || null
+      if (!pubkey) { this.onRequest({ op: p.op, outcome: 'anonymous', from: null }); return }
+      await this.handle({ from, pubkey, msg: p, sealed: meta?.sealed === true })
+    }
+    this.client.on('message', this._handler)
+  }
+
+  stop () {
+    if (!this._handler) return
+    this.client.off?.('message', this._handler)
+    this._handler = null
+  }
+
+  /** Contesta UNA petición. Público para que las pruebas no tengan que fingir un socket. */
+  async handle ({ from, pubkey, msg, sealed = true }) {
+    const { rid, op, payload } = msg
+    const anota = (outcome, extra = {}) => this.onRequest({ op, outcome, from: pubkey, ...extra })
+    // EL SELLADO DEL TRANSPORTE NO ES OPCIONAL (CONVENCIONES §4.1): lo que llega en claro
+    // no se atiende, porque contestarlo sería mandar sobres a quien no sabemos que es.
+    //
+    // Los códigos son los del responder de siempre (`responder.js`): «la política dice que
+    // no» es `denied` y «el humano dijo que no» es `not-approved`. Se arreglan distinto —uno
+    // dando permiso al aparato, el otro volviendo a pedir— y quien pide los distingue así.
+    if (!sealed) { anota('unsealed'); return this.#send(from, pubkey, replyError(rid, CODES.UNSEALED, 'unsealed request')) }
+    if (!SEALED_OPS.includes(op)) { anota('unknown-op'); return this.#send(from, pubkey, replyError(rid, CODES.DENIED, 'operation not allowed: ' + op)) }
+    if (!this.isAllowed(pubkey)) { anota('denied'); return this.#send(from, pubkey, replyError(rid, CODES.DENIED, 'this device cannot ask for passwords')) }
+
+    try {
+      if (await this.#needsApproval(op, payload, pubkey)) {
+        // `allow`, no `ask`: es el que RECUERDA el sí y junta las simultáneas. `ask` es la
+        // función cruda de preguntar, y usarla directamente hacía sonar el teléfono en cada
+        // petición — que es como se enseña a aprobar sin mirar.
+        const ok = await this.gate.allow({ op, payload, pubkey })
+        if (!ok) { anota('rejected'); return this.#send(from, pubkey, replyError(rid, CODES.NOT_APPROVED, 'not approved on the trusted device')) }
+      }
+      const result = await this.#run(op, payload, pubkey)
+      anota('ok')
+      return this.#send(from, pubkey, reply(rid, result))
+    } catch (e) {
+      anota('error', { code: e?.code })
+      return this.#send(from, pubkey, replyError(rid, e?.code || CODES.UNKNOWN, e?.message || 'error'))
+    }
+  }
+
+  async #needsApproval (op, payload, pubkey) {
+    return await this.needsApproval(pubkey) && await this.wantsPrivate(op, payload)
+  }
+
+  async #run (op, payload = {}, pubkey) {
+    switch (op) {
+      case 'pm2.recipients': return this.recipients()
+      case 'pm2.profile':
+        // Con `set` se estrena (al convertir); sin él, se pide la que hay.
+        if (payload.set) return this.store.setProfile(payload.set)
+        return this.store.profile({ pub: pubkey })
+      case 'pm2.views': return this.store.views({ pub: pubkey })
+      case 'pm2.find': return this.store.find({ pub: pubkey, idx: payload.idx || [] })
+      case 'pm2.passkey': return this.store.findPasskey({ pub: pubkey, rp: payload.rp, cred: payload.cred })
+      case 'pm2.get': return this.store.get(payload.id, { pub: pubkey, keys: payload.keys })
+      case 'pm2.put': return this.store.putSealed({ ...payload, by: pubkey })
+      case 'pm2.patch': return this.store.patchSealed({ ...payload, by: pubkey })
+      case 'pm2.remove': return this.store.remove(payload.id)
+      default: throw Object.assign(new Error('operation not allowed: ' + op), { code: CODES.DENIED })
+    }
+  }
+
+  /** `to` es por dónde se contesta (el token); `pubkey`, a quién se le sella. */
+  #send (to, pubkey, msg) {
+    const encPub = this.encPubOf(pubkey)
+    // La respuesta va SELLADA: el proxio enruta pero no cifra. Si no se puede sellar, no se
+    // manda — mandarlo en claro sería entregar los sobres y las envolturas a quien mire.
+    if (encPub && typeof this.client.sendSealedTo === 'function') {
+      return this.client.sendSealedTo(to, msg, { peerEncPub: encPub })
+    }
+    if (typeof this.client.sendSealed === 'function' && encPub) {
+      return this.client.sendSealed([to], msg, { peerEncPub: encPub })
+    }
+    throw Object.assign(new Error('cannot seal the reply to that device: it has no encryption key in the record'), { code: 'no-encpub' })
+  }
+}
+
+export default SealedResponder

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

@@ -0,0 +1,362 @@
+// LA BÓVEDA SELLADA, VISTA DESDE EL APARATO.
+//
+// Cumple el MISMO contrato que `RemoteVault` (`./interface.js`: find/get/put/patch/search/
+// sites/remove) para que la interfaz no tenga que aprender nada nuevo. Lo que cambia está
+// debajo: al otro lado ya no hay una bóveda que abre entradas, hay una que guarda sobres.
+// Así que todo lo que antes hacía ella lo hace esto, aquí:
+//
+//   · **buscar por sitio** — se calculan las huellas de la URL que hay delante y la bóveda
+//     compara cadenas. El emparejamiento de verdad (subdominios, comodines) se rehace aquí
+//     con `match.js` sobre las vistas ya abiertas, así que la regla no cambia;
+//   · **abrir** — cada sobre con la envoltura de este aparato;
+//   · **escribir** — cifrar, envolver a los destinatarios que dice el acta y firmar;
+//   · **buscar por texto** — la bóveda no ve ningún texto: se piden las vistas y se busca
+//     aquí (§2.2). Son vistas, no valores.
+//
+// Lo que este aparato no puede abrir se dice en `withheld` en vez de aparecer vacío.
+
+import { SEALED_OPS } from '../transport/protocol.js'
+import { VaultError, CODES } from './errors.js'
+import { hostOf, registrableDomain, findForUrl } from '../match.js'
+import { profileKeys, siteIndex, fieldIndex, passkeyIndex, valueDigest } from '../sealed/keys.js'
+import { buildSealedEntry, buildSealedPatch, buildProfileKey, openSealedEntry, makeOpener } from '../sealed/device.js'
+import { openView, PASSKEY_FIELD } from '../sealed/entry.js'
+import { fieldKey, normalizeFields } from '../fields.js'
+
+/** Las claves de campo de la interfaz, tal como las pide `get(id, { keys })`. */
+const FIXED = ['name', 'username', 'secret', 'totp', 'notes']
+
+/**
+ * DE LA CLAVE QUE USA LA INTERFAZ A LA QUE GUARDA LA BÓVEDA.
+ *
+ * Las fijas viajan por su nombre —vocabulario cerrado, igual para todo el mundo— y las
+ * libres por HUELLA: «cédula» es del usuario y la bóveda no tiene por qué leerlo. La
+ * traducción vive aquí y en un solo sitio; si quien guarda y quien pide la hicieran
+ * distinta, el sobre no se encontraría y no habría forma de verlo.
+ */
+const esFija = (k) => FIXED.includes(k) || k.startsWith('wa.')
+
+export class SealedVault {
+  /**
+   * @param {object} transport `{ request(op, payload) }` — el mismo de `RemoteVault`
+   * @param {object} opts
+   *   `identity` `{ publickey, sign(body), openSealed({ wrap, envelope }) }`. La privada de
+   *     cifrado no sale de donde viva: aquí solo se pide abrir.
+   *   `needsApproval` si lo privado exige un dedo encima al otro lado (solo informativo)
+   */
+  constructor (transport, { identity, needsApproval = true } = {}) {
+    if (!transport?.request) throw new Error('SealedVault: missing transport')
+    if (typeof identity?.sign !== 'function' || typeof identity?.openSealed !== 'function') {
+      throw new Error('SealedVault: identity needs { publickey, sign(body), openSealed({wrap,envelope}) }')
+    }
+    this.transport = transport
+    this.identity = identity
+    this.needsApproval = needsApproval
+    this._keys = null
+    this._recipients = null
+  }
+
+  get capabilities () {
+    return { canWrite: true, canList: false, needsApproval: this.needsApproval, sealed: true }
+  }
+
+  /** Lo que se cachea muere al dormirse el worker, que es justo cuando hay que releerlo. */
+  forget () { this._keys = null; this._recipients = null }
+
+  async #request (op, payload) {
+    if (!SEALED_OPS.includes(op)) throw new VaultError(CODES.NOT_ALLOWED, 'operación desconocida: ' + op)
+    try {
+      return await this.transport.request(op, payload)
+    } catch (e) {
+      if (e instanceof VaultError) throw e
+      throw new VaultError(e?.code || CODES.UNREACHABLE, e?.message || 'no hay bóveda al otro lado')
+    }
+  }
+
+  /**
+   * LAS LLAVES DEL PERFIL. Sin ellas no se puede ni buscar (el índice va con huella) ni
+   * comparar, así que es lo primero que pide este aparato al despertar.
+   */
+  async keys () {
+    if (this._keys) return this._keys
+    const { envelope, wrap } = await this.#request('pm2.profile', {})
+    const base = await this.identity.openSealed({ wrap, envelope })
+    this._keys = await profileKeys(base)
+    return this._keys
+  }
+
+  /** A quién hay que envolverle cada llave. La lista sale del acta y la sabe la bóveda. */
+  async recipients () {
+    if (this._recipients) return this._recipients
+    this._recipients = await this.#request('pm2.recipients', {})
+    return this._recipients
+  }
+
+  async #sealedKey (k) {
+    if (esFija(k)) return k
+    const { kidx } = await this.keys()
+    return 'f:' + await fieldIndex(kidx, k)
+  }
+
+  #opener (wraps) {
+    return makeOpener({ wraps, openSealed: (x) => this.identity.openSealed(x) })
+  }
+
+  async #openView (v) {
+    const abierta = await openView(
+      { id: v.id, updatedAt: v.updatedAt, view: v.view, digests: v.digests },
+      this.#opener({ [v.view.gen]: v.wrap })
+    )
+    // `fieldHashes` conserva el nombre que ya usa la interfaz para comparar. Dos cosas
+    // cambian debajo: los resúmenes están GUARDADOS (antes era un HMAC con un nonce de la
+    // respuesta), y su clave viaja por huella — así que aquí se traducen de vuelta a los
+    // nombres de verdad, que la vista sí lleva porque va sellada.
+    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]
+    }
+    return { ...abierta, fieldHashes }
+  }
+
+  /**
+   * LAS HUELLAS DE LA URL QUE HAY DELANTE. El sitio guardado puede ser el dominio y la URL
+   * un subdominio suyo (`empresa.com` vale en `login.empresa.com`), así que se calculan las
+   * huellas de CADA variante: el host, sus padres hasta el dominio registrable, y las de
+   * comodín. La bóveda solo compara cadenas.
+   */
+  async #hashesFor (url) {
+    const { kidx } = await this.keys()
+    const host = hostOf(url)
+    if (!host) return []
+    const base = registrableDomain(host)
+    const variantes = new Set([host])
+    let actual = host
+    while (actual.includes('.') && actual !== base) {
+      actual = actual.slice(actual.indexOf('.') + 1)
+      variantes.add(actual)
+    }
+    const out = []
+    for (const v of variantes) {
+      out.push(await siteIndex(kidx, v))
+      out.push(await siteIndex(kidx, '*.' + v))
+    }
+    return out
+  }
+
+  /**
+   * QUÉ HAY PARA ESTE SITIO. Las huellas son un filtro previo; el emparejamiento de verdad
+   * —el que decide si `empresa.com` vale aquí— se rehace con `match.js` sobre las vistas ya
+   * abiertas, para que la regla siga siendo UNA y no dos que se desincronizan.
+   */
+  async find (url) {
+    const hits = await this.#request('pm2.find', { idx: await this.#hashesFor(url) })
+    const vistas = []
+    for (const v of hits) vistas.push(await this.#openView(v))
+    return findForUrl(vistas, url).map((x) => x.entry)
+  }
+
+  /** La passkey que este sitio pide, o la que tiene ese id de credencial. */
+  async findPasskey ({ rpId = null, credentialId = null } = {}) {
+    const { kidx } = await this.keys()
+    const hits = await this.#request('pm2.passkey', {
+      ...(rpId ? { rp: await passkeyIndex(kidx, 'rp', rpId) } : {}),
+      ...(credentialId ? { cred: await passkeyIndex(kidx, 'cred', credentialId) } : {})
+    })
+    const out = []
+    for (const v of hits) out.push(await this.#openView(v))
+    return out
+  }
+
+  /** UNA credencial, y solo los campos pedidos. */
+  async get (id, opts = {}) {
+    const keys = Array.isArray(opts.keys) ? await Promise.all(opts.keys.map((k) => this.#sealedKey(k))) : null
+    const got = await this.#request('pm2.get', { id, ...(keys ? { keys } : {}) })
+    return openSealedEntry({ got, openSealed: (x) => this.identity.openSealed(x) })
+  }
+
+  async put (plain) {
+    const [keys, recipients] = await Promise.all([this.keys(), this.recipients()])
+    const sobre = await buildSealedEntry({ plain, keys, recipients, author: this.#author() })
+    await this.#request('pm2.put', sobre)
+    // La vista se devuelve ARMADA AQUÍ: quien guardó ya la tiene en claro, y pedírsela a la
+    // bóveda sería un viaje para que nos devuelva lo que acabamos de sellar.
+    return this.#viewOf(plain)
+  }
+
+  /**
+   * CAMBIAR unos campos sin leer los demás (§2.4).
+   *
+   * La vista se rehace aquí con lo que ya se sabe: los NOMBRES de los campos y cuáles son
+   * privados viven en ella, no en los sobres, así que marcar un teléfono como privado no
+   * saca el teléfono de la bóveda.
+   */
+  async patch (id, changes = {}) {
+    const [keys, recipients] = await Promise.all([this.keys(), this.recipients()])
+    const actual = await this.#viewById(id)
+    if (!actual) throw new VaultError(CODES.NOT_FOUND, 'no hay ninguna entrada con ese id')
+
+    const values = {}
+    const drop = []
+    for (const k of FIXED) if (typeof changes[k] === 'string') values[k] = { name: k, value: changes[k] }
+    if (typeof changes.title === 'string') actual.title = changes.title
+
+    const campos = normalizeFields(Array.isArray(changes.fields) ? changes.fields : [])
+    for (const f of campos) {
+      const k = fieldKey(f)
+      // LA MARCA VA DENTRO DEL SOBRE, así que cambiarla es reescribir el campo — y para eso
+      // hay que tener su valor. Quien edita lo tiene: si solo trae la marca, hay que leerlo
+      // primero. Leer uno PÚBLICO no cuesta aprobación; quitarle la marca a uno privado sí,
+      // y está bien, porque vas a exponerlo.
+      let valor = f.value
+      if (typeof valor !== 'string' || !valor) {
+        if (f.private === undefined) continue
+        const leido = await this.get(id, { keys: [k] })
+        valor = (JSON.parse(leido.fields || '[]').find((x) => fieldKey(x) === k) || {}).value || ''
+        if (!valor) continue
+      }
+      values[await this.#sealedKey(k)] = {
+        name: k,
+        value: JSON.stringify({ label: f.label, value: valor, kind: f.kind, ...(f.private ? { private: true } : {}) })
+      }
+      const privados = new Set(actual.privateKeys)
+      if (f.private) privados.add(k); else if (f.private === false) privados.delete(k)
+      actual.privateKeys = [...privados]
+      if (!actual.fieldKeys.includes(k)) actual.fieldKeys.push(k)
+    }
+    for (const k of (changes.removeFields || [])) {
+      drop.push(await this.#sealedKey(k))
+      actual.fieldKeys = actual.fieldKeys.filter((x) => x !== k)
+      actual.privateKeys = actual.privateKeys.filter((x) => x !== k)
+    }
+    for (const k of FIXED) {
+      if (typeof changes[k] !== 'string') continue
+      if (changes[k]) { if (!actual.fieldKeys.includes(k) && k !== 'name') actual.fieldKeys.push(k) } else {
+        drop.push(k)
+        actual.fieldKeys = actual.fieldKeys.filter((x) => x !== k)
+      }
+    }
+    // Los sitios: la lista entera manda, y `addSite` solo suma si ya tenía alguno — una
+    // entrada sin sitios sirve en cualquier parte y atarla al primer formulario donde se
+    // usó sería cambiarle el sentido.
+    let sites = null
+    if (Array.isArray(changes.sites)) sites = changes.sites
+    else if (changes.addSite && actual.sites.length) sites = [...new Set([...actual.sites, changes.addSite])]
+    if (sites) actual.sites = sites
+
+    if (typeof changes.name === 'string' || typeof changes.username === 'string') {
+      actual.hint = changes.name || actual.hint
+    }
+
+    const vista = {
+      type: actual.type,
+      title: actual.title,
+      sites: actual.sites,
+      hint: actual.hint,
+      fieldKeys: actual.fieldKeys,
+      privateKeys: actual.privateKeys,
+      has: {
+        secret: drop.includes('secret') ? false : (actual.hasSecret || !!values.secret),
+        totp: drop.includes('totp') ? false : (actual.hasTotp || !!values.totp),
+        notes: drop.includes('notes') ? false : (actual.hasNotes || !!values.notes),
+        fields: actual.fieldKeys.some((k) => !FIXED.includes(k)),
+        webauthn: actual.hasWebauthn
+      },
+      ...(actual.webauthn ? { webauthn: actual.webauthn } : {})
+    }
+    const idx = sites ? await Promise.all(sites.map((s) => siteIndex(keys.kidx, s))) : null
+    const parche = await buildSealedPatch({
+      id, view: vista, values, drop,
+      priv: await Promise.all(vista.privateKeys.map((k) => this.#sealedKey(k))),
+      ...(idx ? { idx } : {}), keys, recipients, author: this.#author()
+    })
+    await this.#request('pm2.patch', parche)
+    return { id, ...vista, updatedAt: Date.now() }
+  }
+
+  /** Buscar por texto: la bóveda no ve ninguno, así que se busca aquí sobre las vistas. */
+  async search (q, opts = {}) {
+    const termino = String(q || '').trim().toLowerCase()
+    if (!termino) return []
+    const limite = Number(opts.limit) > 0 ? Number(opts.limit) : 20
+    const out = []
+    for (const v of await this.#views()) {
+      const texto = [v.title, v.hint, ...(v.sites || [])].join(' ').toLowerCase()
+      if (texto.includes(termino)) out.push(v)
+      if (out.length >= limite) break
+    }
+    return out
+  }
+
+  /** En qué sitios hay algo. Los nombres salen de abrir las vistas, no de la bóveda. */
+  async sites () {
+    const cuenta = new Map()
+    for (const v of await this.#views()) {
+      for (const s of v.sites || []) cuenta.set(s, (cuenta.get(s) || 0) + 1)
+    }
+    return [...cuenta].map(([site, count]) => ({ site, count })).sort((a, b) => a.site.localeCompare(b.site))
+  }
+
+  async remove (id) {
+    await this.#request('pm2.remove', { id })
+  }
+
+  /**
+   * LA BÓVEDA ENTERA, ABIERTA AQUÍ. No es `list` de la bóveda: son las VISTAS, que no
+   * llevan ningún valor, y las abre este aparato con su llave. Es lo que sustituye a
+   * buscar dentro de la bóveda (§2.2), y por eso existe donde antes no podía existir.
+   */
+  async list () {
+    return this.#views()
+  }
+
+  /** El resumen de un valor, para decir si ya está guardado igual sin abrir nada (§2.6). */
+  async digest (id, key, value) {
+    const { kcmp } = await this.keys()
+    return valueDigest(kcmp, id, key, String(value))
+  }
+
+  async #views () {
+    const crudas = await this.#request('pm2.views', {})
+    const out = []
+    for (const v of crudas) out.push(await this.#openView(v))
+    return out
+  }
+
+  async #viewById (id) {
+    return (await this.#views()).find((v) => v.id === id) || null
+  }
+
+  #author () {
+    return { publickey: this.identity.publickey, sign: (body) => this.identity.sign(body) }
+  }
+
+  /** La vista de lo que se acaba de guardar, con la forma que espera la interfaz. */
+  #viewOf (plain) {
+    const campos = normalizeFields(Array.isArray(plain.fields) ? plain.fields : [])
+    return {
+      id: plain.id,
+      type: plain.type || 'login',
+      title: plain.title || '',
+      sites: plain.sites || [],
+      hasSecret: !!plain.secret,
+      hasTotp: !!plain.totp,
+      hasNotes: !!plain.notes,
+      hasFields: campos.length > 0,
+      hasWebauthn: !!plain.webauthn,
+      updatedAt: Date.now()
+    }
+  }
+
+  /** Estrenar la llave del perfil. Solo al convertir: después ya está y se pide. */
+  async initProfileKey () {
+    const recipients = await this.recipients()
+    const pk = await buildProfileKey({ recipients })
+    await this.#request('pm2.profile', { set: { envelope: pk.envelope, wraps: pk.wraps } })
+    this._keys = await profileKeys(pk.base)
+    return this._keys
+  }
+}
+
+export { PASSKEY_FIELD }
+export default SealedVault