@dotrino/identity 0.114.1 → 0.116.0

package/vault/vendor/passmanager/model.js

@@ -0,0 +1,332 @@
+// Una entrada de la bóveda: cómo se sella, cómo se abre y qué se puede enseñar sin
+// abrirla. Ver DISENO §5.
+//
+// Qué va en claro y por qué: `sites` y `title`. Los `sites` hacen falta para
+// emparejar con la página SIN tener la CEK — es lo que permite que la extensión
+// pregunte "¿tienes algo para salesforce.com?" sin poder abrir nada. Es una decisión
+// consciente: revela EN QUÉ SITIOS tienes cuenta, que es bastante menos que la
+// credencial. Todo lo demás (usuario, contraseña, TOTP, notas, llave WebAuthn) va
+// cifrado.
+
+import { sealValue, openValue, fieldTag } from './crypto.js'
+import { normalizeFields, entryFieldKeys, privateKeysOf, fieldKey, KINDS } from './fields.js'
+
+export const TYPES = ['login', 'note', 'card', 'webauthn', 'data']
+
+// `fields` es la lista de campos libres del usuario, y va cifrada como todo lo
+// demás: un correo o una cédula identifican a una persona igual que una contraseña
+// da acceso. Se sella como JSON, en un solo criptograma.
+//
+// `name` —el nombre que el usuario le pone a la entrada— va SELLADO y no en claro como
+// `title`: «la cuenta de mi mamá» dice bastante más de una persona que el dominio donde
+// la usa. Quien puede abrir la entrada lo pone en la vista pública (§4.0.2), igual que
+// el nombre visible de siempre.
+const SEALED_FIELDS = ['name', 'username', 'secret', 'totp', 'notes', 'fields']
+
+function uuid () {
+  if (globalThis.crypto?.randomUUID) return globalThis.crypto.randomUUID()
+  const b = new Uint8Array(16)
+  globalThis.crypto.getRandomValues(b)
+  b[6] = (b[6] & 0x0f) | 0x40
+  b[8] = (b[8] & 0x3f) | 0x80
+  const h = [...b].map(x => x.toString(16).padStart(2, '0')).join('')
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`
+}
+
+/** Entrada nueva en claro, lista para `sealEntry`. */
+export function newEntry (fields = {}) {
+  const now = Date.now()
+  const type = TYPES.includes(fields.type) ? fields.type : 'login'
+  return {
+    id: fields.id || uuid(),
+    type,
+    title: String(fields.title || '').trim(),
+    // El nombre que le puso el usuario. Vacío = el que se calcula solo (`entryWho`).
+    name: String(fields.name || '').trim(),
+    sites: normalizeSites(fields.sites),
+    username: fields.username || '',
+    secret: fields.secret || '',
+    // Los campos libres viajan como JSON dentro de un único criptograma. Una lista
+    // vacía es NADA, no un criptograma vacío: si no, la entrada se anuncia con campos
+    // que no tiene y la UI ofrece rellenar lo que no existe.
+    fields: (() => {
+      if (!Array.isArray(fields.fields)) return fields.fields || ''
+      const limpios = normalizeFields(fields.fields)
+      return limpios.length ? JSON.stringify(limpios) : ''
+    })(),
+    totp: fields.totp || '',
+    notes: fields.notes || '',
+    webauthn: fields.webauthn || null,
+    createdAt: fields.createdAt || now,
+    updatedAt: now,
+  }
+}
+
+export function normalizeSites (sites) {
+  const out = []
+  for (const s of Array.isArray(sites) ? sites : [sites]) {
+    const v = String(s || '').trim().toLowerCase()
+    if (v && !out.includes(v)) out.push(v)
+  }
+  return out
+}
+
+/** Cifra los campos sensibles. Devuelve lo que se guarda de verdad. */
+export async function sealEntry (key, plain) {
+  const e = newEntry(plain)
+  const out = {
+    id: e.id,
+    type: e.type,
+    title: e.title,
+    sites: e.sites,
+    createdAt: e.createdAt,
+    updatedAt: e.updatedAt,
+  }
+  for (const f of SEALED_FIELDS) {
+    out[f] = e[f] ? await sealValue(key, String(e[f]), fieldTag(e.id, f)) : null
+  }
+  if (e.webauthn) {
+    // `rpId` y `credentialId` quedan en claro: el navegador los necesita para saber
+    // qué credencial ofrecer antes de que nadie desbloquee nada.
+    out.webauthn = {
+      credentialId: e.webauthn.credentialId,
+      rpId: e.webauthn.rpId,
+      signCount: e.webauthn.signCount || 0,
+      userHandle: e.webauthn.userHandle
+        ? await sealValue(key, String(e.webauthn.userHandle), fieldTag(e.id, 'wa.userHandle'))
+        : null,
+      privateKey: e.webauthn.privateKey
+        ? await sealValue(key, String(e.webauthn.privateKey), fieldTag(e.id, 'wa.privateKey'))
+        : null,
+    }
+  } else {
+    out.webauthn = null
+  }
+  return out
+}
+
+/** Abre una entrada sellada. Exige la CEK, o sea: no lo hace la extensión. */
+export async function openEntry (key, entry) {
+  const out = {
+    id: entry.id,
+    type: entry.type,
+    title: entry.title,
+    sites: entry.sites || [],
+    createdAt: entry.createdAt,
+    updatedAt: entry.updatedAt,
+    webauthn: null,
+  }
+  for (const f of SEALED_FIELDS) {
+    out[f] = entry[f] ? await openValue(key, entry[f], fieldTag(entry.id, f)) : ''
+  }
+  if (entry.webauthn) {
+    out.webauthn = {
+      credentialId: entry.webauthn.credentialId,
+      rpId: entry.webauthn.rpId,
+      signCount: entry.webauthn.signCount || 0,
+      userHandle: entry.webauthn.userHandle
+        ? await openValue(key, entry.webauthn.userHandle, fieldTag(entry.id, 'wa.userHandle'))
+        : '',
+      privateKey: entry.webauthn.privateKey
+        ? await openValue(key, entry.webauthn.privateKey, fieldTag(entry.id, 'wa.privateKey'))
+        : '',
+    }
+  }
+  return out
+}
+
+/**
+ * Lo que puede ver quien NO tiene la CEK: para elegir entre varias cuentas del mismo
+ * sitio, no para usarlas. El `hint` lo calcula quien sí puede abrir (§2).
+ *
+ * `open` es la entrada abierta, y solo la tiene quien puede abrirla. Con ella salen los
+ * NOMBRES de los campos que lleva —nunca sus valores—, que es lo que permite ofrecer
+ * «rellenar el número de socio» sin sacar nada de la bóveda.
+ *
+ * `digest` son los RESÚMENES de esos campos (`{ nonce, fields }`, ver `fieldHasher`):
+ * con ellos, quien pregunta puede decir si lo que tiene delante ya está guardado igual
+ * sin abrir nada y sin pedir una autorización. Van para todos los campos, públicos y
+ * privados: un solo método de comparación (dueño, 2026-08-29).
+ *
+ * `privateKeys` dice **cuáles de esos campos son privados**. No es lo mismo que el valor:
+ * es lo que permite pedir los públicos —y solo los públicos— sin disparar una
+ * autorización, que es lo que hace falta para enseñar en una lista con qué se va a
+ * rellenar cada casilla.
+ */
+export function publicView (entry, hint, open, digest) {
+  return {
+    id: entry.id,
+    type: entry.type,
+    title: entry.title,
+    sites: entry.sites || [],
+    hasSecret: !!entry.secret,
+    hasTotp: !!entry.totp,
+    hasNotes: !!entry.notes,
+    hasFields: !!entry.fields,
+    hasWebauthn: !!entry.webauthn,
+    updatedAt: entry.updatedAt,
+    ...(hint ? { hint } : {}),
+    ...(open ? { fieldKeys: entryFieldKeys(open), privateKeys: [...privateKeysOf(open)] } : {}),
+    ...(digest ? { nonce: digest.nonce, fieldHashes: digest.fields } : {}),
+  }
+}
+
+/**
+ * CÓMO SE LLAMA una entrada para quien tiene que elegir entre varias.
+ *
+ * **El que le puso el usuario**, si le puso alguno. Y si no, su dato público más claro,
+ * **sin esconder caracteres** (dueño, 2026-08-28): el usuario; si no tiene, el correo; y
+ * si tampoco, el primer campo que lleve. Un `d•••g` no le dice nada a nadie — hay que
+ * poder reconocer la cuenta de un vistazo.
+ *
+ * **Los campos privados no salen aquí.** Para eso está la marca (§4.2): lo privado solo
+ * sale con confirmación, así que nunca es el nombre visible de una entrada.
+ */
+export function entryWho (open) {
+  // Lo que el usuario escribió MANDA. Lo de abajo es solo el nombre que se calcula cuando
+  // no ha escrito ninguno: útil para no dejar filas en blanco, pero es una suposición, y
+  // una suposición no le gana a una decisión (dueño, 2026-08-29).
+  if (open?.name) return String(open.name)
+  if (open?.username) return String(open.username)
+  const campos = (() => {
+    if (Array.isArray(open?.fields)) return open.fields
+    try { return JSON.parse(open?.fields || '[]') } catch { return [] }
+  })()
+  const publicos = campos.filter(f => f && !f.private && f.value)
+  const correo = publicos.find(f => f.kind === 'email')
+  return String((correo || publicos[0])?.value || '')
+}
+
+/**
+ * LA ENTRADA RECORTADA a los campos que se pidieron.
+ *
+ * Pedir «el nombre» no puede devolver también la contraseña. Sin esto, `get` era todo o
+ * nada y cualquier relleno de un dato público sacaba de la bóveda la credencial entera —
+ * que además es lo que obligaba a pedir autorización para rellenar un nombre.
+ *
+ * Sin `keys` devuelve la entrada tal cual: hay quien necesita todo (una passkey al
+ * firmar), y eso sí se autoriza.
+ */
+export function projectEntry (open, keys) {
+  if (!Array.isArray(keys)) return open
+  const quiere = new Set(keys)
+  const campos = (() => {
+    if (Array.isArray(open.fields)) return open.fields
+    try { return JSON.parse(open.fields || '[]') } catch { return [] }
+  })()
+  return {
+    ...open,
+    username: quiere.has('username') ? open.username : '',
+    secret: quiere.has('secret') ? open.secret : '',
+    totp: quiere.has('totp') ? open.totp : '',
+    notes: quiere.has('notes') ? open.notes : '',
+    webauthn: quiere.has('webauthn') ? open.webauthn : null,
+    fields: JSON.stringify(campos.filter(f => quiere.has(fieldKey(f)))),
+  }
+}
+
+/** `sandrade@dotrino.com` → `s•••e@dotrino.com`. Sigue para la CLI; la extensión ya no. */
+export function maskUsername (username) {
+  const u = String(username || '')
+  if (!u) return ''
+  const at = u.indexOf('@')
+  if (at > 0) return mask(u.slice(0, at)) + u.slice(at)
+  return mask(u)
+}
+
+function mask (s) {
+  if (s.length <= 2) return s[0] + '•'
+  return s[0] + '•••' + s[s.length - 1]
+}
+
+/**
+ * LA FUSIÓN DE UN PARCHE con lo que ya había, que es más sutil de lo que parece y por eso
+ * vive aquí y no en cada bóveda.
+ *
+ * La diferencia que lo ordena todo: **un campo sin `value` dice «déjale el que tenga»**,
+ * no «bórralo». Marcar uno como privado llega así —solo la etiqueta y la marca—, y una
+ * bóveda que lo tomara al pie de la letra borraría su valor al marcarlo. Pasó: la bóveda
+ * sellada de la extensión se quedó sin campos al primer `patch`.
+ *
+ * @param {object} base     la entrada ABIERTA tal como está
+ * @param {object} changes  lo que se quiere cambiar
+ * @returns {object} la entrada completa, lista para volver a cerrar
+ */
+export function mergePatch (base, changes = {}) {
+  const fields = normalizeFields((() => {
+    if (Array.isArray(base.fields)) return base.fields
+    try { return JSON.parse(base.fields || '[]') } catch { return [] }
+  })())
+
+  // Como `normalizeFields`, pero **conservando la ausencia de `value`**: ahí está la
+  // diferencia entre «ponle este valor» y «déjale el que tenga».
+  const propuestos = (Array.isArray(changes.fields) ? changes.fields : [])
+    .filter((f) => f && (f.label || f.value !== undefined))
+    .map((f) => ({
+      label: String(f.label || '').trim(),
+      kind: KINDS.includes(f.kind) ? f.kind : undefined,
+      ...(f.value === undefined ? {} : { value: String(f.value) }),
+      ...(f.private === undefined ? {} : { private: !!f.private }),
+    }))
+
+  for (const f of propuestos) {
+    const k = fieldKey(f)
+    // Se casa por su clave; y si no aparece, **por su etiqueta**. Un mismo campo puede
+    // llegar con clase una vez y sin ella otra —la página declara el `autocomplete` en un
+    // formulario y no en el siguiente—, y sin este respaldo eso creaba un duplicado.
+    const j = (() => {
+      const exacto = fields.findIndex((x) => fieldKey(x) === k)
+      if (exacto >= 0) return exacto
+      return f.label ? fields.findIndex((x) => x.label === f.label) : -1
+    })()
+    if (j >= 0) {
+      // La etiqueta que ya tenía MANDA: es la identidad de un campo libre, y cambiarla
+      // sería crear otro. Y lo que era privado sigue siéndolo salvo que se diga.
+      fields[j] = {
+        ...fields[j],
+        ...(f.value === undefined ? {} : { value: f.value }),
+        ...(f.kind ? { kind: f.kind } : {}),
+      }
+      if (f.private === undefined ? fields[j].private : f.private) fields[j].private = true
+      else delete fields[j].private
+    } else if (f.value !== undefined) {
+      // Un campo que no existe y del que no se dice el valor no es nada que crear.
+      fields.push({ ...f, value: f.value })
+    }
+  }
+
+  // QUITAR. Va al final, para que quitar gane si en la misma tanda también se editaba.
+  // Los de siempre no se pueden borrar —son parte de la forma de una entrada—, así que
+  // quitarlos es dejarlos vacíos, que para todo lo demás es lo mismo.
+  const fuera = new Set(Array.isArray(changes.removeFields) ? changes.removeFields : [])
+  const vaciados = {}
+  for (const k of ['username', 'secret', 'totp', 'notes']) if (fuera.has(k)) vaciados[k] = ''
+  const quedan = fields
+    .filter((f) => !fuera.has(fieldKey(f)))
+    // Un campo sin valor no es un campo: no se rellena, no se compara y no se enseña.
+    .filter((f) => f.value)
+
+  const sites = (() => {
+    // La lista puesta a mano MANDA sobre el «súmame este sitio» del guardado automático:
+    // una es una decisión del usuario y el otro una consecuencia de dónde estabas.
+    if (Array.isArray(changes.sites)) return normalizeSites(changes.sites)
+    const suyos = base.sites || []
+    if (!changes.addSite || !suyos.length || suyos.includes(changes.addSite)) return suyos
+    return [...suyos, changes.addSite]
+  })()
+
+  return {
+    ...base,
+    ...(changes.name !== undefined ? { name: changes.name } : {}),
+    ...(changes.title !== undefined ? { title: changes.title } : {}),
+    ...(changes.username !== undefined ? { username: changes.username } : {}),
+    ...(changes.secret !== undefined ? { secret: changes.secret } : {}),
+    ...(changes.totp !== undefined ? { totp: changes.totp } : {}),
+    ...(changes.notes !== undefined ? { notes: changes.notes } : {}),
+    ...vaciados,
+    sites,
+    fields: quedan,
+    id: base.id,
+    createdAt: base.createdAt,
+  }
+}

package/vault/vendor/passmanager/pubkey.js

@@ -0,0 +1,33 @@
+// Comparar llaves públicas.
+//
+// **Nunca con `===` sobre el JSON.** Una misma llave se serializa de varias formas: el
+// orden de las claves del JWK cambia según quién la escriba, y sobran campos como
+// `ext` o `key_ops` que no son parte de la llave. Comparar cadenas hace que un aparato
+// autorizado aparezca como desconocido, y eso se manifiesta como un «denegado» que no
+// hay forma de explicar mirando los dos valores, porque *parecen* iguales.
+//
+// Es una lección que el ecosistema ya tenía escrita (en `@dotrino/reputation`: comparar
+// con `samePubkey`, nunca con `===`) y que aquí se volvió a tropezar.
+
+/** Los campos que IDENTIFICAN una llave EC; lo demás es adorno de la serialización. */
+function canonical (jwkOrString) {
+  let k = jwkOrString
+  if (typeof k === 'string') {
+    try { k = JSON.parse(k) } catch { return null }
+  }
+  if (!k || typeof k !== 'object') return null
+  if (!k.kty || !k.crv || !k.x) return null
+  return `${k.kty}|${k.crv}|${k.x}|${k.y || ''}`
+}
+
+/** ¿Son la misma llave, aunque vengan escritas distinto? */
+export function samePubkey (a, b) {
+  const ca = canonical(a)
+  const cb = canonical(b)
+  return !!ca && ca === cb
+}
+
+/** Una forma estable de la llave, para usarla como clave de un mapa o de un log. */
+export function pubkeyId (jwkOrString) {
+  return canonical(jwkOrString)
+}

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

@@ -0,0 +1,72 @@
+// CONVERTIR UNA BÓVEDA AL FORMATO SELLADO (`docs/sealed-passwords.md` §2.7).
+//
+// Es un acto único y hay que hacerlo en las CUATRO bóvedas —el binario, la pestaña, la de
+// dentro de la extensión y `passmanager serve`—, así que vive aquí y no en ninguna de
+// ellas. Cuatro copias de esto serían cuatro formas sutilmente distintas de reescribir lo
+// mismo, y la que se quedara atrás no fallaría al convertir: fallaría al leerlo otra
+// bóveda, meses después.
+//
+// Durante la conversión —y SOLO durante la conversión— quien convierte ve los valores: hay
+// que abrirlos con la llave vieja para volver a cerrarlos uno a uno. Por eso lo último que
+// hace es **borrar la llave vieja**: mientras siga ahí, el agujero sigue abierto.
+//
+// Y por eso no se convierte «en segundo plano»: hace falta la contraseña de la copia de
+// recuperación, que es lo único que puede volver a abrir esto el día que no quede ningún
+// aparato. Sin ella no se empieza.
+
+import { openEntry } from '../model.js'
+import { buildSealedEntry, buildProfileKey } from './device.js'
+import { profileKeys } from './keys.js'
+
+/**
+ * @param {object} o
+ *   `store`      el almacén `{ get(k), set(k, v) }` con las entradas viejas
+ *   `sealed`     la `SealedStore` de esta bóveda
+ *   `cek`        la llave vieja (`CryptoKey`), o `null` si no hay nada que convertir
+ *   `recipients` `{ recoveryPub, main, passkeys }` — a quién se le envuelve
+ *   `author`     `{ publickey, sign(body) }` — quien firma lo que se escribe
+ *   `dropOldKey` borra la llave vieja. Se llama AL FINAL y solo si salió todo
+ *   `legacyKey`  dónde viven las entradas viejas (cada bóveda la guarda en su sitio)
+ * @returns {Promise<{already:boolean, entries:number}>}
+ */
+export async function convertToSealed ({
+  store, sealed, cek, recipients, author, dropOldKey,
+  legacyKey = 'passmanager/entries/v1', log = () => {}
+} = {}) {
+  if (!sealed) throw new Error('convertToSealed: missing the sealed store')
+  // `recoveryPub: null` vale: se convierte sin copia de recuperación y se añade después
+  // (`SealedStore.addRecovery`). Lo que no vale es no haber preguntado.
+  if (!recipients || recipients.recoveryPub === undefined) {
+    throw new Error('convertToSealed: missing the recipients')
+  }
+  // Ya convertida: no se vuelve a hacer. Repetirlo estrenaría otra llave de perfil y
+  // dejaría las entradas de antes con la anterior — la mitad de la bóveda ilegible.
+  if (await sealed.sealed()) return { already: true, entries: 0 }
+
+  const viejas = (await store.get(legacyKey)) || []
+
+  // 1. La llave del perfil, de la que salen el índice de sitios y los resúmenes.
+  const pk = await buildProfileKey({ recipients })
+  await sealed.setProfile({ envelope: pk.envelope, wraps: pk.wraps })
+  const keys = await profileKeys(pk.base)
+
+  // 2. Cada entrada, reescrita: un sobre por campo, la vista sellada, sus huellas.
+  let hechas = 0
+  for (const vieja of viejas) {
+    if (!cek) break
+    const abierta = await openEntry(cek, vieja)
+    await sealed.putSealed(await buildSealedEntry({ plain: abierta, keys, recipients, author }))
+    hechas++
+  }
+
+  // 3. Y se va lo viejo: las entradas con la llave que las abría, y la llave misma. Solo
+  //    si TODAS pasaron: quedarse a medias y borrar la llave es perder lo que faltaba.
+  if (hechas === viejas.length) {
+    await store.set(legacyKey, [])
+    await dropOldKey?.()
+  }
+  log(`passwords: ${hechas} entries converted to the sealed format`)
+  return { already: false, entries: hechas }
+}
+
+export default { convertToSealed }

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

@@ -0,0 +1,211 @@
+// EL LADO DEL APARATO: construir los sobres y abrirlos.
+//
+// La bóveda ya no puede hacer nada de esto —no tiene ninguna llave— así que lo hace quien
+// pide: cifra lo que guarda, lo envuelve a cada destinatario y firma el conjunto; y al
+// leer, abre su envoltura y con ella el sobre. Es lo mismo que `buildSealedVar` hace con
+// una variable de un cajón (`@dotrino/vault/admin`), con una diferencia: una entrada tiene
+// muchos campos y **dos juegos de destinatarios** (§2.8), no uno.
+//
+// QUIÉN FIRMA VA COMO FUNCIÓN, no como llave, por el mismo motivo que allí: en un navegador
+// la privada del aparato vive dentro del iframe de identidad y no sale. Aquí se pide la
+// firma, no la llave.
+
+// ESTÁTICO, no `import()`: un service worker MV3 no admite el import dinámico (lo prohíbe
+// la especificación), y esta pieza corre justamente ahí — dentro de la extensión del gestor.
+import { makeContentKey, wrapForMember, encryptWithCek } from '@dotrino/identity/content'
+import { sealEntry, openView, openFields, PASSKEY_FIELD } from './entry.js'
+import { RECOVERY } from './store.js'
+import { makePasswordKey, profileKeys, valueDigest } from './keys.js'
+
+/**
+ * LO QUE FIRMA EL AUTOR. Un solo sitio: quien firma y quien comprueba miran exactamente lo
+ * mismo, o la comprobación pasa a ser decorativa.
+ *
+ * Va lo que identifica el contenido —los criptogramas, no los valores— y las huellas: si la
+ * bóveda cambiara un sobre por otro, o el índice de sitios de una entrada, la firma deja de
+ * cuadrar. Lo que NO va es la generación, que la pone el almacén después.
+ */
+export function entryAuthorBody (entry, ts) {
+  return {
+    op: 'pm.entry',
+    id: entry.id,
+    idx: [...(entry.idx || [])].sort(),
+    wa: entry.wa || null,
+    view: entry.view.iv + '.' + entry.view.ct,
+    fields: Object.keys(entry.fields).sort().map((k) => k + ':' + entry.fields[k].iv + '.' + entry.fields[k].ct),
+    digests: entry.digests || {},
+    ts
+  }
+}
+
+/**
+ * LO QUE FIRMA QUIEN CAMBIA UNOS CAMPOS. Cubre exactamente lo que el parche pide hacer —
+ * qué sobres entran, cuáles se van y con qué vista queda— y nada más: lo que no se toca
+ * ya lo firmó quien lo escribió.
+ */
+export function patchAuthorBody ({ id, view, fields = {}, drop = [], digests = {}, priv = null, idx = null, wa }, ts) {
+  return {
+    op: 'pm.patch',
+    id,
+    view: view.iv + '.' + view.ct,
+    fields: Object.keys(fields).sort().map((k) => k + ':' + fields[k].iv + '.' + fields[k].ct),
+    drop: [...drop].sort(),
+    digests,
+    priv: Array.isArray(priv) ? [...priv].sort() : null,
+    idx: Array.isArray(idx) ? [...idx].sort() : null,
+    wa: wa === undefined ? null : (wa || null),
+    ts
+  }
+}
+
+// `recoveryPub: null` es «la cuenta aún no tiene copia de recuperación» y se sella solo a
+// los aparatos; `undefined` es que nadie preguntó a quién, y eso es un error.
+const wrapAll = async (cek, { recoveryPub, members }) => {
+  if (recoveryPub === undefined) throw new Error('sealed: ask the vault for the recipients first')
+  const wraps = recoveryPub ? { [RECOVERY]: await wrapForMember({ cek, memberEncPub: recoveryPub }) } : {}
+  for (const m of members || []) wraps[m.pub] = await wrapForMember({ cek, memberEncPub: m.encPub })
+  return wraps
+}
+
+/**
+ * UNA ENTRADA LISTA PARA GUARDAR: cifrada, envuelta a quien toca y firmada.
+ *
+ * @param {object} o
+ *   `plain`       la entrada en claro
+ *   `keys`        las llaves del perfil (`profileKeys`)
+ *   `recipients`  `{ recoveryPub, main: [{pub,encPub}], passkeys: [{pub,encPub}] }`, tal
+ *                 como las contesta la bóveda: la lista sale del acta y la sabe ella.
+ *   `author`      `{ publickey, sign(body) }`
+ */
+export async function buildSealedEntry ({ plain, keys, recipients, author } = {}) {
+  if (typeof author?.sign !== 'function' || typeof author?.publickey !== 'string') {
+    throw new Error('buildSealedEntry: author needs { publickey, sign(body) }')
+  }
+  const cek = await makeContentKey()
+  // La privada de la passkey va con SU llave y sus destinatarios. Se estrena solo si la
+  // entrada lleva una: repartir una llave que nadie va a usar es ruido en el llavero.
+  const llevaPasskey = !!plain?.webauthn?.privateKey
+  const cekPk = llevaPasskey ? await makeContentKey() : null
+
+  // `gen: 0` a propósito: la generación DE VERDAD la pone el almacén al guardar, como en
+  // los cajones. Aquí solo hace falta un número para que el sobre tenga forma.
+  const entry = await sealEntry({
+    plain,
+    main: { gen: 0, cek },
+    ...(cekPk ? { passkeys: { gen: 0, cek: cekPk } } : {}),
+    keys
+  })
+  const ts = Date.now()
+  const { signature } = await author.sign(entryAuthorBody(entry, ts))
+  return {
+    entry: { ...entry, author: { pub: author.publickey, sig: signature, ts } },
+    main: { wraps: await wrapAll(cek, { recoveryPub: recipients?.recoveryPub, members: recipients?.main }) },
+    ...(cekPk
+      ? { passkeys: { wraps: await wrapAll(cekPk, { recoveryPub: recipients?.recoveryPub, members: recipients?.passkeys }) } }
+      : {})
+  }
+}
+
+/** La llave del perfil, estrenada y envuelta. Se hace una vez, al convertir. */
+export async function buildProfileKey ({ recipients } = {}) {
+  const base = await makePasswordKey()
+  const cek = await makeContentKey()
+  return {
+    base,
+    envelope: await encryptWithCek({ cek, gen: 0, plaintext: base }),
+    wraps: await wrapAll(cek, { recoveryPub: recipients?.recoveryPub, members: recipients?.main })
+  }
+}
+
+/**
+ * EL ABRIDOR de este aparato: con su envoltura saca la llave y con ella el sobre.
+ *
+ * `openSealed({ wrap, envelope })` es `identity.openSealedValue`: la privada de cifrado no
+ * sale del iframe (ni del núcleo, en la extensión). Aquí solo se empareja cada sobre con la
+ * envoltura de su generación.
+ */
+export function makeOpener ({ wraps, openSealed }) {
+  if (typeof openSealed !== 'function') throw new Error('makeOpener: missing openSealed({ wrap, envelope })')
+  return async ({ envelope }) => {
+    const wrap = wraps?.[envelope?.gen]
+    if (!wrap) {
+      throw Object.assign(new Error('this device has no key for that content generation'), { code: 'no-wrap' })
+    }
+    return openSealed({ wrap, envelope })
+  }
+}
+
+/** La vista de una entrada, abierta con las envolturas que vinieron con ella. */
+export async function openSealedView ({ view, wrap, id, updatedAt, digests, openSealed }) {
+  const open = makeOpener({ wraps: { [view.gen]: wrap }, openSealed })
+  return openView({ id, updatedAt, view, digests }, open)
+}
+
+/** Los campos que vinieron de `get`, con la forma de siempre. */
+export async function openSealedEntry ({ got, openSealed, view = null }) {
+  const open = makeOpener({ wraps: got.wraps, openSealed })
+  const vista = view || await openView({ id: got.id, updatedAt: got.updatedAt, view: got.view, digests: got.digests }, open)
+  const abierta = await openFields({
+    sealed: { id: got.id, updatedAt: got.updatedAt },
+    envelopes: got.envelopes,
+    open,
+    view: vista
+  })
+  return { ...abierta, withheld: got.withheld || [] }
+}
+
+/**
+ * UN PARCHE LISTO PARA MANDAR: los campos que cambian, cifrados y envueltos, y la vista
+ * nueva. Lo que no viene aquí se queda en la bóveda como estaba, sin abrirse.
+ *
+ * @param {object} o
+ *   `id`, `view`   la entrada y su vista NUEVA en claro (la arma quien cambia, que ya la
+ *                  tenía abierta: la vista no es un valor)
+ *   `values`       solo lo que cambia: `{ <clave que guarda la bóveda>: { name, value } }`.
+ *                  La clave de un campo libre es una HUELLA y el `name` es su nombre de
+ *                  verdad — hace falta porque el RESUMEN se calcula sobre el nombre, no
+ *                  sobre la huella, o dejaría de casar con lo que escribió quien creó la
+ *                  entrada.
+ *   `drop`         las claves que se van (ya traducidas)
+ *   `keys`, `recipients`, `author`  como en `buildSealedEntry`
+ */
+export async function buildSealedPatch ({ id, view, values = {}, drop = [], priv = null, idx = null, wa, keys, recipients, author } = {}) {
+  if (typeof author?.sign !== 'function') throw new Error('buildSealedPatch: author needs { publickey, sign(body) }')
+  const cek = await makeContentKey()
+  const hayPasskey = Object.prototype.hasOwnProperty.call(values, PASSKEY_FIELD)
+  const cekPk = hayPasskey ? await makeContentKey() : null
+
+  const fields = {}
+  const digests = {}
+  for (const [k, v] of Object.entries(values)) {
+    const { name, value } = (v && typeof v === 'object') ? v : { name: k.replace(/^f:/, ''), value: v }
+    const conQue = k === PASSKEY_FIELD ? cekPk : cek
+    fields[k] = await encryptWithCek({ cek: conQue, gen: 0, plaintext: String(value) })
+    // El resumen es del VALOR y del NOMBRE, con el id de la entrada dentro (§2.6). La
+    // privada de una passkey no se compara nunca: no se teclea, así que no hay nada que
+    // cotejar.
+    if (k !== PASSKEY_FIELD) digests[k] = await valueDigest(keys.kcmp, id, name, String(value))
+  }
+  const vista = await encryptWithCek({ cek, gen: 0, plaintext: JSON.stringify(view) })
+  const ts = Date.now()
+  const cuerpo = patchAuthorBody({ id, view: vista, fields, drop, digests, priv, idx, wa }, ts)
+  const { signature } = await author.sign(cuerpo)
+  return {
+    id,
+    view: vista,
+    fields,
+    drop,
+    digests,
+    ...(Array.isArray(priv) ? { priv } : {}),
+    ...(Array.isArray(idx) ? { idx } : {}),
+    ...(wa === undefined ? {} : { wa }),
+    author: { pub: author.publickey, sig: signature, ts },
+    main: { wraps: await wrapAll(cek, { recoveryPub: recipients?.recoveryPub, members: recipients?.main }) },
+    ...(cekPk
+      ? { passkeys: { wraps: await wrapAll(cekPk, { recoveryPub: recipients?.recoveryPub, members: recipients?.passkeys }) } }
+      : {})
+  }
+}
+
+export { PASSKEY_FIELD, profileKeys }
+export default { buildSealedEntry, buildSealedPatch, buildProfileKey, openSealedEntry, openSealedView, makeOpener, entryAuthorBody, patchAuthorBody }