@dotrino/identity 0.62.0 → 0.63.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.62.0",
+  "version": "0.63.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",
@@ -39,7 +39,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "test": "node --test test/*.test.js",
+    "test": "node --test \"test/*.test.js\" \"test/*.test.mjs\"",
     "type-check": "tsc --noEmit"
   },
   "keywords": [

package/vault/acta.js

@@ -6,9 +6,16 @@
  * Diseño completo y decisiones en `dotrino-vault/docs/acta-de-perfil.md`.
  *
  * Las cuatro reglas que este módulo hace cumplir:
- *   1. **Un solo sellador** (el «master»). Solo el sellador vigente puede producir la
- *      siguiente acta. Como las llaves son intransferibles no se puede clonar → dos actas
- *      legítimas con el mismo `seq` son imposibles: no hay bifurcaciones que resolver.
+ *   1. **Solo sella quien el acta nombra.** Normalmente uno —`sealer`, el master—, y
+ *      entonces dos actas legítimas con el mismo `seq` son imposibles: no hay
+ *      bifurcaciones que resolver.
+ *      **MULTIVAULT** (dueño, 2026-08-30): se pueden nombrar selladores adicionales en
+ *      `cosealers`, para que perder una bóveda no se lleve la cuenta por delante. Ahí la
+ *      imposibilidad pasa de criptográfica a práctica —«no suelen estar las dos abiertas
+ *      a la vez»—, así que el empate deja de ser imposible y pasa a ser raro. Lo resuelve
+ *      `canAdopt` con las reglas que ya existían: gana el traspaso, y si no, la de hash
+ *      menor. Determinista, sin relojes y sin votación. Lo que NO resuelve: el que pierde
+ *      el desempate **pierde su cambio**, y quien lo selló tiene que enterarse (§2.4.1.5).
  *   2. **`seq` monotónico + `prev`** (hash del acta anterior): cadena verificable.
  *   3. **Nunca dejar el perfil sin quien firme**: un cambio que quite el último `sign` se
  *      rechaza.
@@ -42,7 +49,15 @@ export const ACTA_V = 2
 const ACTA_LEIBLES = Object.freeze([1, 2])
 
 /**
- * Lista CERRADA de capacidades. Sellar y admitir no están: eso es ser el master.
+ * Lista CERRADA de capacidades.
+ *
+ * `sealer` es SELLAR EL ACTA, y desde 2026-08-30 es un permiso como los demás — se da y se
+ * quita con `caps <ID> +sella`. Antes no existía: sellar era «ser el master», y punto. Se
+ * abrió para el **multivault**: que una segunda bóveda pueda sellar hace que perder una
+ * máquina no se lleve la cuenta por delante. Cuidado con no confundirlo con el CAMPO
+ * `acta.sealer`, que es otra cosa: el campo dice **quién manda** (y solo cambia en un
+ * traspaso); el permiso dice **quién puede firmar el acta**. Admitir sigue sin ser un
+ * permiso: se admite sellando.
  *
  * `secrets` es distinta de las otras: solo la pueden tener los miembros con **CN**
  * (los servicios), y lo que abre es únicamente el cajón de SU nombre. Ver `cn` abajo.
@@ -53,7 +68,7 @@ const ACTA_LEIBLES = Object.freeze([1, 2])
  * el rol de master, que no se delega. Así un dispositivo con `admin` robado hace daño
  * acotado y **reversible** (se le revoca), en vez de poder dejarte fuera de tu cuenta.
  */
-export const CAPS = Object.freeze(['sign', 'store', 'read', 'secrets', 'admin', 'approve', 'passwords'])
+export const CAPS = Object.freeze(['sign', 'store', 'read', 'secrets', 'admin', 'approve', 'passwords', 'sealer'])
 
 /** Capacidades de un DISPOSITIVO (sin CN): acceso a todo lo del usuario. */
 /**
@@ -67,7 +82,7 @@ export const CAPS = Object.freeze(['sign', 'store', 'read', 'secrets', 'admin',
  * pedirle algo a la bóveda es exactamente lo que decide el acta — tener dos registros
  * de lo mismo obliga a acordarse de los dos al quitar un aparato.
  */
-export const DEVICE_CAPS = Object.freeze(['sign', 'store', 'read', 'admin', 'approve', 'passwords'])
+export const DEVICE_CAPS = Object.freeze(['sign', 'store', 'read', 'admin', 'approve', 'passwords', 'sealer'])
 
 /**
  * Lo que recibe un dispositivo recién emparejado. `admin` **no está**: no se
@@ -100,12 +115,13 @@ export function capScope (cap, cn = null) {
   if (cap === 'admin') return 'vault:admin'
   if (cap === 'approve') return 'vault:approve'
   if (cap === 'passwords') return 'vault:passwords'
+  if (cap === 'sealer') return 'vault:sealer'
   if (cap === 'secrets') return isValidCn(cn) ? 'vault:secrets:' + cn : null
   return null
 }
 
 /** Compat: el mapa directo, para las capacidades de dispositivo. */
-export const CAP_SCOPE = Object.freeze({ sign: 'vault:sign', store: 'vault:store', read: 'vault:read', admin: 'vault:admin', approve: 'vault:approve', passwords: 'vault:passwords' })
+export const CAP_SCOPE = Object.freeze({ sign: 'vault:sign', store: 'vault:store', read: 'vault:read', admin: 'vault:admin', approve: 'vault:approve', passwords: 'vault:passwords', sealer: 'vault:sealer' })
 
 const enc = (s) => new TextEncoder().encode(s)
 const hex = (buf) => [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, '0')).join('')
@@ -147,6 +163,44 @@ export async function memberId (pub) {
 }
 
 /** ¿Esta acta es un traspaso? (la firmó uno y nombra master a otro) */
+/**
+ * QUIÉNES PUEDEN SELLAR ESTA ACTA: quien manda (`sealer`) más todo miembro con el permiso
+ * `sealer`. Normalmente solo el primero, y entonces dos actas legítimas con el mismo `seq`
+ * son imposibles (D4) — de ahí salía «no hay merge, ni precedencia, ni votación».
+ *
+ * **MULTIVAULT** (dueño, 2026-08-30): dándole el permiso a otra bóveda, perder una máquina
+ * deja de llevarse la cuenta. El precio es que la imposibilidad baja de criptográfica a
+ * práctica —«no suelen estar las dos abiertas a la vez»—, así que el empate ya no es
+ * imposible: es raro. Lo resuelve `canAdopt` con las reglas que ya existían: gana el
+ * traspaso, y si no, la de hash menor. Determinista, sin relojes y sin votación. Lo que NO
+ * resuelve: el que pierde el desempate **pierde su cambio**, y quien selló tiene que
+ * enterarse (§2.4.1 punto 5).
+ *
+ * Es un PERMISO y no un campo aparte, y eso se nota en todo lo que ya no hace falta
+ * escribir: se da y se quita con `caps`, quitar al miembro se lo lleva, y no hay forma de
+ * nombrar sellador a quien no está en la cuenta.
+ */
+export const sealersOf = (acta, renounces = []) => {
+  if (!acta) return []
+  const extra = (acta.members || [])
+    .filter((m) => m.pub !== acta.sealer && memberCan(acta, m.pub, 'sealer', renounces))
+    .map((m) => m.pub)
+  return [acta.sealer, ...extra]
+}
+
+/** ¿Puede `pub` sellar la siguiente acta de este perfil? */
+export const canSeal = (acta, pub, renounces = []) =>
+  !!acta && (pub === acta.sealer || memberCan(acta, pub, 'sealer', renounces))
+
+/**
+ * El acta la firmó alguien DISTINTO del sellador que ella misma nombra.
+ *
+ * ⚠️ Desde el multivault esto ya NO significa «es un traspaso», y confundirlo costó un
+ * desempate mal resuelto: cuando sella la segunda bóveda, el acta sigue nombrando
+ * sellador a la primera y la firma la segunda, así que esto da `true` sin que nadie
+ * traspase nada. Es condición NECESARIA de un traspaso, no suficiente — lo que lo
+ * distingue es que un traspaso CAMBIA a quién nombra (ver `canAdopt`).
+ */
 export const isHandover = (acta) => !!acta && acta.sealer !== acta.sealedBy
 
 /**
@@ -262,6 +316,7 @@ export async function verifyActa ({ acta, expectedProfileId } = {}) {
  *
  * Cambios: `{op:'admit', member}` · `{op:'caps', pub, caps}` · `{op:'remove', pub}` ·
  * `{op:'handover', to}` · `{op:'revoke', nonce, until}` · `{op:'renounce', record}`.
+ * Sellar se concede con `{op:'caps'}` como cualquier otro permiso.
  * Van en ARRAY porque hay combinaciones que deben ser atómicas: admitir al nuevo sellador y
  * traspasarle el master ocurre en el MISMO `seq` (§2.1.3).
  */
@@ -269,13 +324,15 @@ export async function applyChanges (acta, changes, { by, now = Date.now(), sealP
   const shape = checkShape(acta)
   if (shape) throw new Error('invalid record: ' + shape)
   if (!by) throw new Error('applyChanges: missing `by` (who seals)')
-  if (by !== acta.sealer) throw new Error('only the master can change the record; this device is not the master')
+  // El mensaje conserva «not the master» a propósito: es una cadena que hay código y
+  // pruebas emparejando, y cambiarla en silencio es justo lo que rompe cosas sin ruido.
+  if (!canSeal(acta, by)) throw new Error('only a sealer named by the record can change it: this device is not the master, nor a co-sealer')
 
   const list = (Array.isArray(changes) ? changes : [changes]).filter(Boolean)
   // Estrenar la llave de sellado ES un cambio del acta, aunque no toque a ningún miembro:
   // rota con el acta (§8.9) y el acta es lo que le da autoridad. Por eso una lista vacía
   // se acepta si viene con llave nueva, y solo entonces.
-  if (list.length === 0 && !sealPub) throw new Error('applyChanges: no hay cambios')
+  if (list.length === 0 && !sealPub) throw new Error('applyChanges: no changes')
 
   const next = {
     ...acta,
@@ -315,7 +372,7 @@ export async function applyChanges (acta, changes, { by, now = Date.now(), sealP
     switch (ch?.op) {
       case 'admit': {
         const m = ch.member
-        if (!isPub(m?.pub)) throw new Error('admit: falta la pubkey del miembro')
+        if (!isPub(m?.pub)) throw new Error('admit: missing member pubkey')
         if (find(m.pub)) throw new Error('admit: that member is already in the record')
         const cn = m.cn != null ? String(m.cn) : null
         if (cn !== null && !isValidCn(cn)) throw new Error('admit: invalid CN (lowercase, digits and hyphens)')
@@ -380,6 +437,7 @@ export async function applyChanges (acta, changes, { by, now = Date.now(), sealP
         const i = next.members.findIndex((m) => m.pub === ch.pub)
         if (i < 0) throw new Error('remove: that member is not in the record')
         if (next.members[i].pub === next.sealer) throw new Error('remove: cannot remove the master; hand the sealing over first')
+        // Quitar al miembro se lleva su permiso de sellar: no hay lista aparte que limpiar.
         const fuera = next.members.splice(i, 1)[0]
         // Sus envolturas se van con él: sin ellas no puede abrir ninguna generación. (El
         // acceso al contenido FUTURO se corta rotando, ver content.js; lo ya leído no vuelve.)
@@ -409,7 +467,7 @@ export async function applyChanges (acta, changes, { by, now = Date.now(), sealP
         break
       }
       case 'revoke': {
-        if (typeof ch.nonce !== 'string') throw new Error('revoke: falta el nonce')
+        if (typeof ch.nonce !== 'string') throw new Error('revoke: missing nonce')
         next.revoked.push({ nonce: ch.nonce, until: ch.until || (now + 30 * 24 * 60 * 60 * 1000) })
         break
       }
@@ -424,7 +482,7 @@ export async function applyChanges (acta, changes, { by, now = Date.now(), sealP
         break
       }
       default:
-        throw new Error('cambio desconocido: ' + ch?.op)
+        throw new Error('unknown change: ' + ch?.op)
     }
   }
 
@@ -459,7 +517,7 @@ export function sealKeyAt (acta, seq) {
 /** Crea el registro firmado con el que un miembro se QUITA capacidades a sí mismo. */
 export async function makeRenounce ({ member, caps, privateKey, privateJwk, now = Date.now() }) {
   const body = { op: 'renounce', member, caps: cleanCaps(caps), ts: now }
-  if (body.caps.length === 0) throw new Error('renuncia: no hay capacidades que quitar')
+  if (body.caps.length === 0) throw new Error('resign: no capabilities to remove')
   const { signature } = await signWithDevice({ privateKey, privateJwk, publickey: member, data: body })
   return { ...body, sig: signature }
 }
@@ -629,7 +687,7 @@ export async function canAdopt ({ candidate, current }) {
   if (!current) return { adopt: true, reason: 'sin-acta-previa' }
 
   if (candidate.seq > current.seq) {
-    if (candidate.sealedBy !== current.sealer) return { adopt: false, reason: 'sellador-no-autorizado' }
+    if (!canSeal(current, candidate.sealedBy)) return { adopt: false, reason: 'sellador-no-autorizado' }
     if (candidate.seq === current.seq + 1 && candidate.prev !== await actaHash(current)) {
       return { adopt: false, reason: 'no-encadena' }
     }
@@ -639,9 +697,31 @@ export async function canAdopt ({ candidate, current }) {
   if (candidate.seq === current.seq) {
     const [hCan, hCur] = [await actaHash(candidate), await actaHash(current)]
     if (hCan === hCur) return { adopt: false, reason: 'misma-acta' }
-    if (candidate.sealedBy !== current.sealedBy) return { adopt: false, reason: 'otro-sellador' }
-    const canT = isHandover(candidate)
-    const curT = isHandover(current)
+    // A igual `seq`, con multivault, las dos ramas pueden venir de selladores DISTINTOS y
+    // ser las dos legítimas. Antes era imposible y se rechazaba de plano; ahora se
+    // desempata con las reglas de abajo, que ya estaban escritas.
+    //
+    // Se conserva primero la comparación de siempre (`mismo sealedBy`) y no se sustituye:
+    // en un TRASPASO las dos ramas las firmó el saliente, y `current` ya nombra al
+    // entrante como `sealer` — así que preguntarle a `current` si el saliente puede
+    // sellar da «no», y se perdería el desempate «gana la que traspasa». La pregunta
+    // correcta es por el acta PADRE, que aquí no se tiene; tener el mismo `sealedBy` es
+    // exactamente lo que dice que las dos salieron de ella.
+    const mismoFirmante = candidate.sealedBy === current.sealedBy
+    if (!mismoFirmante && !canSeal(current, candidate.sealedBy)) return { adopt: false, reason: 'otro-sellador' }
+    // UN TRASPASO ES EL QUE CAMBIA A QUIÉN NOMBRA, no el que firma otro. Con una sola
+    // bóveda daba igual —solo un traspaso podía firmar sin ser el sellador—, pero con dos
+    // la segunda firma sin serlo cada vez que sella, y entonces TODA acta suya se leía
+    // como un traspaso y ganaba el desempate por la puerta de atrás.
+    //
+    // Las dos ramas salen del mismo padre, así que comparar a quién nombra cada una
+    // resuelve los tres casos: si nombran al mismo (dos coselladores trabajando), no hay
+    // traspaso y decide el hash; si una nombra a otro, esa es la que traspasa y gana; y
+    // si las dos traspasan a destinos distintos, vuelven a empatar y decide el hash,
+    // que es lo que §2.4.1 ya decía.
+    const mismoSellador = candidate.sealer === current.sealer
+    const canT = isHandover(candidate) && !mismoSellador
+    const curT = isHandover(current) && !mismoSellador
     if (canT && !curT) return { adopt: true, reason: 'traspaso-gana' }
     if (!canT && curT) return { adopt: false, reason: 'traspaso-gana' }
     return hCan < hCur ? { adopt: true, reason: 'desempate-hash' } : { adopt: false, reason: 'desempate-hash' }
@@ -654,6 +734,6 @@ export default {
   ACTA_V, CAPS, CAP_SCOPE, genesisActa, actaBody, actaHash, memberId, checkShape, isHandover,
   sealActa, verifyActa, applyChanges, makeRenounce, verifyRenounce,
   makeContinuity, verifyContinuity,
-  cardBody, makeProfileCard, verifyProfileCard, canAdoptCard,
+  cardBody, makeProfileCard, verifyProfileCard, canAdoptCard, sealersOf, canSeal,
   effectiveCaps, memberCan, memberCanReadSecrets, memberScopes, isService, capScope, isValidCn, canAdopt
 }

package/vault/capabilities.js

@@ -155,7 +155,7 @@ export async function makeDeviceEncKey () {
  * dice nada útil.
  */
 export async function importDeviceEncKey (encPrivateJwk) {
-  if (!encPrivateJwk || typeof encPrivateJwk !== 'object') throw new Error('importDeviceEncKey: falta el JWK de la privada')
+  if (!encPrivateJwk || typeof encPrivateJwk !== 'object') throw new Error('importDeviceEncKey: missing private JWK')
   return crypto.subtle.importKey('jwk', encPrivateJwk, ECDH, false, ['deriveBits'])
 }
 
@@ -178,7 +178,7 @@ export async function signWithDevice ({ privateJwk, privateKey, publickey, data
   // `privateKey` (CryptoKey, posiblemente NO extractable) tiene prioridad: firma
   // sin tocar bytes de la privada. Con CryptoKey es obligatorio pasar `publickey`.
   if (privateKey) {
-    if (!publickey) throw new Error('signWithDevice: con privateKey (CryptoKey) se requiere publickey')
+    if (!publickey) throw new Error('signWithDevice: publickey is required when privateKey is a CryptoKey')
     const signature = await rawSign(privateKey, enc(canonicalStringify(data)))
     return { signature, publickey }
   }

package/vault/content.js

@@ -54,8 +54,8 @@ export async function makeContentKey () {
  * @returns {Promise<{epk:string, iv:string, ct:string}>}
  */
 export async function wrapForMember ({ cek, memberEncPub }) {
-  if (typeof cek !== 'string' || !cek) throw new Error('wrapForMember: falta la clave de contenido')
-  if (typeof memberEncPub !== 'string' || !memberEncPub) throw new Error('wrapForMember: el miembro no tiene llave de cifrado')
+  if (typeof cek !== 'string' || !cek) throw new Error('wrapForMember: missing content key')
+  if (typeof memberEncPub !== 'string' || !memberEncPub) throw new Error('wrapForMember: member has no encryption key')
   const eph = await subtle.generateKey(ECDH, false, ['deriveBits'])
   const key = await sharedKey(eph.privateKey, memberEncPub)
   const iv = globalThis.crypto.getRandomValues(new Uint8Array(12))

package/vault/core.js

@@ -590,7 +590,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     try {
       const { generation } = await Content.makeGeneration({ members: base.members, gen: 1 })
       base.keyring = [generation]
-    } catch (e) { console.warn('[identity] no se pudo crear la clave de contenido:', e.message) }
+    } catch (e) { console.warn('[identity] could not create the content key:', e.message) }
     saveActa(await seal(base))
     return loadActa()
   }
@@ -716,9 +716,9 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     // firmado por ella misma: es el puente para que su reputación previa siga contando.
     // Solo si esta llave tenía vida propia. Una recién creada para adoptar (camino B) no
     // tiene pasado que salvar: mandarle un puente de continuidad sería puro ruido.
-    const mio = loadActa()
-    const continuity = (mio && mio.members.length === 1 && !isPendingJoin())
-      ? await Acta.makeContinuity({ member: publickeyJwkStr, from: mio.profileId, privateKey: keypair.privateKey })
+    const mine = loadActa()
+    const continuity = (mine && mine.members.length === 1 && !isPendingJoin())
+      ? await Acta.makeContinuity({ member: publickeyJwkStr, from: mine.profileId, privateKey: keypair.privateKey })
       : null
     const res = await remoteEnroll({ qr, device, continuity, encPub: encPublickeyJwkStr, label: label || me?.nickname || '', onChallenge: (c) => emitVault({ phase: 'challenge', deviceId: c.deviceId, code: c.code }) })
     kv.setItem(VAULT_DEVICE_STORAGE, JSON.stringify({ useIdentityKey: true, publickey: publickeyJwkStr }))
@@ -1022,7 +1022,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
    * maestra que dice la propia acta (`sealer`). Si sigue dentro, no pasa nada. Si no, la
    * bóveda contesta con el aviso FIRMADO y aquí se ejecuta el borrado.
    */
-  async function preguntarSiSigoDentro () {
+  async function askIfStillAMember () {
     try {
       const acta = loadActa()
       if (!acta || acta.sealer === publickeyJwkStr) return          // no hay cuenta ajena que confirmar: mando yo
@@ -1124,7 +1124,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const tries = (() => { try { return JSON.parse(kv.getItem('dotrino.identity.pwd.tries') || 'null') } catch (_) { return null } })() || { n: 0, at: 0 }
       const waitMs = tries.n >= 5 ? Math.min(2 ** (tries.n - 4) * 1000, 5 * 60 * 1000) : 0
       const left = tries.at + waitMs - Date.now()
-      if (left > 0) throw new Error(`demasiados intentos: espera ${Math.ceil(left / 1000)} s`)
+      if (left > 0) throw new Error(`too many attempts: wait ${Math.ceil(left / 1000)} s`)
       const proof = await derivePwd(password, pwd.salt, pwd.iter)
       if (proof !== pwd.verifier) {
         kv.setItem('dotrino.identity.pwd.tries', JSON.stringify({ n: tries.n + 1, at: Date.now() }))
@@ -1137,7 +1137,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     },
     // Poner/cambiar contraseña (requiere estar desbloqueado; cambiar exige la actual vía unlock previo).
     async setProfilePassword ({ password }) {
-      if (locked) throw new Error('perfil bloqueado')
+      if (locked) throw new Error('profile locked')
       if (!password || String(password).length < 4) throw new Error('password must be at least 4 characters')
       const salt = b64(crypto.getRandomValues(new Uint8Array(16)))
       const verifier = await derivePwd(password, salt, PWD_ITER)
@@ -1146,7 +1146,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       return { ok: true }
     },
     async removeProfilePassword () {
-      if (locked) throw new Error('perfil bloqueado')
+      if (locked) throw new Error('profile locked')
       kv.removeItem(PWD_STORAGE)
       try { sessionKv?.removeItem(_scoped(PWD_SESSION)) } catch (_) {}
       return { ok: true }
@@ -1431,13 +1431,13 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       return { id: pid, name: me.nickname, pubkey: publickeyJwkStr, pendingJoin: !!forVault }
     },
     async switchProfile ({ id } = {}) {
-      if (!loadProfiles().find((p) => p.id === id)) throw new Error('perfil no existe')
+      if (!loadProfiles().find((p) => p.id === id)) throw new Error('profile does not exist')
       rawKv.setItem(CURRENT_STORAGE, id) // la app recarga la página → re-init con el nuevo perfil
       return { id }
     },
     async renameProfile ({ id, name } = {}) {
       const list = loadProfiles(); const e = list.find((p) => p.id === (id || currentPid))
-      if (!e) throw new Error('perfil no existe')
+      if (!e) throw new Error('profile does not exist')
       e.name = String(name || '').slice(0, 40); saveProfiles(list)
       if (e.id === currentPid) { me = { ...(me || {}), nickname: e.name }; saveMe(me) }
       return { id: e.id, name: e.name }
@@ -1448,7 +1448,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       // dejarte sin ninguna de un clic. La expulsión no pasa por aquí (ver `purgeProfile`):
       // ahí sí se va la última, porque no es un descuido sino que te echaron.
       if (list.length <= 1) throw new Error('cannot delete the only profile')
-      if (!list.find((p) => p.id === id)) throw new Error('perfil no existe')
+      if (!list.find((p) => p.id === id)) throw new Error('profile does not exist')
       return purgeProfile(id)
     },
 
@@ -1852,8 +1852,8 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      * que manda hoy.
      */
     async vaultAdopt ({ qr, label = '' } = {}) {
-      const mio = loadActa()
-      if (!mio) throw new Error('this device has no account to hand over yet')
+      const mine = loadActa()
+      if (!mine) throw new Error('this device has no account to hand over yet')
       if (!amMaster()) throw new Error('not-the-master: another device or vault is in charge of this account; the handover is done from there')
 
       const device = { publickey: publickeyJwkStr, privateKey: keypair.privateKey }
@@ -1861,7 +1861,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
         qr,
         device,
         intent: 'adopt',
-        profileId: mio.profileId,
+        profileId: mine.profileId,
         encPub: encPublickeyJwkStr,
         label: label || me?.nickname || '',
         onChallenge: (c) => emitVault({ phase: 'challenge', deviceId: c.deviceId, code: c.code }),
@@ -1890,7 +1890,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const ok = r.adopted || r.reason === 'misma-acta'
       emitVault({ phase: 'adopted', master: res.master, seq: res.acta?.seq, ok })
       if (!ok) throw new Error('the vault returned a record that does not fit: ' + r.reason)
-      return { ok: true, adopted: true, profileId: mio.profileId, seq: r.seq ?? res.acta?.seq, master: res.master, deviceId: res.deviceId }
+      return { ok: true, adopted: true, profileId: mine.profileId, seq: r.seq ?? res.acta?.seq, master: res.master, deviceId: res.deviceId }
     },
 
     /**
@@ -2179,7 +2179,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const raw = kv.getItem(KEY_STORAGE)
       if (!raw) {
         throw new Error('This profile stores its key as NON-exportable (theft protection). ' +
-          'Para usar tu identidad en otro navegador, conecta ese navegador a tu bóveda (vault) desde profile.dotrino.com.')
+          'To use this identity in another browser, link that browser to your vault from profile.dotrino.com.')
       }
       const keys = JSON.parse(raw)
       const encRaw = kv.getItem(ENC_KEY_STORAGE)
@@ -2314,13 +2314,13 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     kv.setItem(ME_STORAGE, JSON.stringify(me))
   }
   // Acta de perfil: si no existe, nace ahora (un miembro, este dispositivo, que es el master).
-  try { await ensureActa() } catch (e) { console.warn('[identity] no se pudo crear el acta de perfil:', e.message) }
+  try { await ensureActa() } catch (e) { console.warn('[identity] could not create the profile record:', e.message) }
 
   // Perfil compartido: jalar del vault en background (gana el más nuevo).
   pullProfileFromVault()
   // Y, si a este aparato no le queda papel con el que llamar, preguntar si sigue siendo de
   // la casa. Es lo único que le queda por hacer, y hasta ahora no lo hacía nadie.
-  preguntarSiSigoDentro()
+  askIfStillAMember()
 
   // Registrar el pubkey (y nombre) del perfil activo en su meta → para avatar/listado sin abrir cada perfil.
   {

package/vault/remote.js

@@ -87,7 +87,7 @@ async function identifyAsDevice (client, device, { cert = null, acta = null } =
  * que esto no dice que sea TU bóveda — eso lo dice el código de 6 dígitos, que solo
  * aprende la bóveda donde tú lo tecleas.
  */
-async function verificarHola (p, sn) {
+async function verifyHello (p, sn) {
   const b = p?.body
   if (!b?.iss || b.sn !== sn) throw new Error('the vault answered a different pairing')
   if (!(await verifyDeviceSig({ publickey: b.iss, data: b, signature: p.signature }))) {
@@ -101,7 +101,7 @@ async function verificarHola (p, sn) {
  * Canjea la CITA del QR: devuelve la dirección real de la conexión de la bóveda. El
  * código se quema al usarse, así que esto va una sola vez por emparejamiento.
  */
-async function canjearCita (client, code) {
+async function redeemCode (client, code) {
   const r = await client.redeemPairingCode(code)
   if (!r?.ok || !r.instance) throw new Error(r?.error || 'that pairing code is no longer valid')
   return r.instance
@@ -109,15 +109,15 @@ async function canjearCita (client, code) {
 
 /** «¿Quién eres?» del QR corto: devuelve `{ iss, proxy, acct, m }` de la bóveda. */
 async function askVault (client, qr) {
-  const destino = await canjearCita(client, qr.conn)
+  const target = await redeemCode(client, qr.conn)
   return new Promise((resolve, reject) => {
     const off = client.on('message', (_from, p) => {
-      if (p?.type === MSG.HELLO_OK) { fin(); verificarHola(p, qr.sn).then((b) => resolve({ iss: b.iss, proxy: b.proxy || qr.proxy, acct: b.acct || '', m: b.m || qr.m }), reject) }
-      else if (p?.type === MSG.ERROR) { fin(); reject(new Error(p.error)) }
+      if (p?.type === MSG.HELLO_OK) { done(); verifyHello(p, qr.sn).then((b) => resolve({ iss: b.iss, proxy: b.proxy || qr.proxy, acct: b.acct || '', m: b.m || qr.m }), reject) }
+      else if (p?.type === MSG.ERROR) { done(); reject(new Error(p.error)) }
     })
-    const t = setTimeout(() => { fin(); reject(new Error('the vault did not answer: that code may have expired')) }, 15000)
-    const fin = () => { off(); clearTimeout(t) }
-    try { client.send(destino, { type: MSG.HELLO, sn: qr.sn }) } catch (e) { fin(); reject(e) }
+    const t = setTimeout(() => { done(); reject(new Error('the vault did not answer: that code may have expired')) }, 15000)
+    const done = () => { off(); clearTimeout(t) }
+    try { client.send(target, { type: MSG.HELLO, sn: qr.sn }) } catch (e) { done(); reject(e) }
   })
 }
 
@@ -161,11 +161,11 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', conti
     // rechaza el que no coincida con el modo con el que ella abrió el emparejamiento. Así
     // ninguno de los dos puede hacer, a mitad de camino, algo distinto de lo que el humano
     // vio anunciado en las dos pantallas.
-    const adoptar = intent === 'adopt'
-    if (adoptar && typeof onAdopt !== 'function') throw new Error('enrollDevice(adopt): falta onAdopt')
+    const adopting = intent === 'adopt'
+    if (adopting && typeof onAdopt !== 'function') throw new Error('enrollDevice(adopt): missing onAdopt')
     const data = {
       op: 'enroll', dpub: dev.publickey, token: qr.token || qr.sn, sn: qr.sn, commit, label, ts: Date.now(), intent,
-      ...(adoptar && profileId ? { profileId } : {}),
+      ...(adopting && profileId ? { profileId } : {}),
       ...(continuity ? { continuity } : {}), ...(encPub ? { encPub } : {})
     }
     const { signature } = await signWithDevice({ privateJwk: dev.privateJwk, privateKey: dev.privateKey, publickey: dev.publickey, data })
@@ -181,7 +181,7 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', conti
         // CAMINO A · la bóveda dice quién es (con el código de vuelta, misma defensa que el
         // ENROLLED): este aparato la admite en SU acta, le envuelve la clave de contenido y
         // le traspasa el mando, todo en un solo `seq`, y le manda el acta sellada.
-        else if (p.type === MSG.ENROLL_ADOPT && adoptar) {
+        else if (p.type === MSG.ENROLL_ADOPT && adopting) {
           if (p.code !== code || sellando) return
           sellando = true
           Promise.resolve(onAdopt({ pub: p.pub, encPub: p.encPub || null, label: p.label || '' }))
@@ -190,7 +190,7 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', conti
         }
         // La bóveda ya se vio como sellador y devuelve el acta definitiva (con los certs
         // re-emitidos, §D9). Es la que este aparato adopta.
-        else if (p.type === MSG.ACTA_ADOPTED && adoptar) { cleanup(); resolve(p) }
+        else if (p.type === MSG.ACTA_ADOPTED && adopting) { cleanup(); resolve(p) }
         else if (p.type === MSG.ERROR) { cleanup(); reject(new Error(p.error)) }
       })
       const t = setTimeout(() => { cleanup(); reject(new Error('timeout waiting for approval at the vault')) }, approveTimeoutMs)
@@ -201,7 +201,7 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', conti
 
     // Camino A: aquí no hay cert que validar — este aparato NO delega su identidad, sigue
     // siendo la cuenta. Lo que vuelve es el acta ya sellada por la bóveda.
-    if (adoptar) {
+    if (adopting) {
       if (!res.acta) throw new Error('the vault did not return the adopted record')
       if (res.acta.sealer !== qr.iss) throw new Error('the record is sealed by a vault other than the one you saw')
       return { device: dev, cert: null, master: qr.iss, proxy: qr.proxy, deviceId, acta: res.acta, adopted: true }
@@ -210,8 +210,8 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', conti
     // Validación estricta antes de guardar (cierra inyección de cert / sustitución de maestra).
     const v = await verifyDelegation({ cert: res.cert, expectedSub: dev.publickey })
     if (!v.ok) throw new Error('invalid cert: ' + v.reason)
-    if (res.cert.iss !== qr.iss) throw new Error('cert firmado por una maestra distinta a la que viste')
-    if (res.cert.sub !== dev.publickey) throw new Error('cert emitido para otro dispositivo')
+    if (res.cert.iss !== qr.iss) throw new Error('cert signed by a master key different from the one you saw')
+    if (res.cert.sub !== dev.publickey) throw new Error('cert issued for a different device')
     return { device: dev, cert: res.cert, master: qr.iss, proxy: qr.proxy, deviceId, acta: res.acta || null }
   } finally { try { client.close() } catch (_) {} }
 }
@@ -245,7 +245,7 @@ const REVOKE_GRACE_MS = 1500
  * ejecuta el autoborrado (`onRevoked`) tras verificar la firma contra la maestra pineada.
  */
 async function vaultRpc ({ master, proxy, device, cert, acta = null, sendType, okType, data, onRevoked, timeoutMs = 15000 }) {
-  if (!master || !proxy || !(device?.privateJwk || device?.privateKey) || !cert) throw new Error('faltan datos de emparejamiento')
+  if (!master || !proxy || !(device?.privateJwk || device?.privateKey) || !cert) throw new Error('missing pairing data')
   const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
   const client = new WebSocketProxyClient({ url: proxy, enableWebRTC: false, autoReconnect: false })
   await client.connect()
@@ -298,7 +298,7 @@ async function vaultRpc ({ master, proxy, device, cert, acta = null, sendType, o
  * nada, como cualquier otro mensaje sin firma.
  */
 export async function checkMembership ({ master, proxy, device, onRevoked, timeoutMs = 12000 } = {}) {
-  if (!master || !proxy || !(device?.privateJwk || device?.privateKey)) throw new Error('faltan datos del dispositivo')
+  if (!master || !proxy || !(device?.privateJwk || device?.privateKey)) throw new Error('missing device data')
   const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
   const client = new WebSocketProxyClient({ url: proxy, enableWebRTC: false, autoReconnect: false })
   await client.connect()
@@ -309,20 +309,20 @@ export async function checkMembership ({ master, proxy, device, onRevoked, timeo
     const data = { op: 'check', publickey: device.publickey, ts: Date.now() }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, privateKey: device.privateKey, publickey: device.publickey, data })
     const res = await new Promise((resolve) => {
-      let hecho = false
-      const fin = (v) => { if (!hecho) { hecho = true; cleanup(); resolve(v) } }
+      let settled = false
+      const done = (v) => { if (!settled) { settled = true; cleanup(); resolve(v) } }
       const off = client.on('message', (_f, p) => {
         if (!p || typeof p !== 'object') return
         if (p.type === MSG.REVOKED) {
           isAuthenticRevoke({ body: p.body, signature: p.signature, master, devicePubkey: device.publickey, currentNonce: null })
-            .then((ok) => { if (ok) { try { onRevoked?.() } catch (_) {} ; fin({ in: false, wiped: true }) } })
+            .then((ok) => { if (ok) { try { onRevoked?.() } catch (_) {} ; done({ in: false, wiped: true }) } })
             .catch(() => {})
           return
         }
-        if (p.type === MSG.CHECKED) fin({ in: !!p.in })
-        else if (p.type === MSG.ERROR) fin({ error: p.error })
+        if (p.type === MSG.CHECKED) done({ in: !!p.in })
+        else if (p.type === MSG.ERROR) done({ error: p.error })
       })
-      const t = setTimeout(() => fin({ error: 'the vault did not reply' }), timeoutMs)
+      const t = setTimeout(() => done({ error: 'the vault did not reply' }), timeoutMs)
       const cleanup = () => { off(); clearTimeout(t) }
       client.sendByPubkey(master, { type: MSG.CHECK, data, signature })
     })