@dotrino/identity 0.49.0 → 0.52.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.49.0",
+  "version": "0.52.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",
@@ -39,7 +39,8 @@
     "LICENSE"
   ],
   "scripts": {
-    "test": "node --test test/*.test.js"
+    "test": "node --test test/*.test.js",
+    "type-check": "tsc --noEmit"
   },
   "keywords": [
     "identity",
@@ -58,6 +59,8 @@
     "@dotrino/proxy-client": "0.10.0"
   },
   "devDependencies": {
-    "fake-indexeddb": "^6.2.5"
+    "fake-indexeddb": "^6.2.5",
+    "typescript": "^5.7.3",
+    "@types/node": "^22.0.0"
   }
 }

package/src/index.js

@@ -133,7 +133,14 @@ export class Identity {
           if (!pending) return
           this._pending.delete(msg.id)
           clearTimeout(pending.timer)
-          if (msg.error) pending.reject(new Error(msg.error))
+          // El rechazo llega con su `code` (y `detail`) puestos, como si el error se hubiera
+          // lanzado aquí: quien lo atrapa comprueba `e.code`, nunca la frase.
+          if (msg.error) {
+            const err = new Error(msg.error)
+            if (msg.code) err.code = msg.code
+            if (msg.detail) err.detail = msg.detail
+            pending.reject(err)
+          }
           else pending.resolve(msg.result)
           return
         }

package/src/types.d.ts

@@ -0,0 +1,5 @@
+interface Element { [key: string]: any; }
+interface EventTarget { [key: string]: any; }
+interface HTMLElement { [key: string]: any; }
+interface Event { [key: string]: any; }
+interface Window { [key: string]: any; }

package/vault/core.js

@@ -22,7 +22,7 @@ import { signDelegationWith, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from './
 import * as Acta from './acta.js'
 import * as Content from './content.js'
 import { pubkeyId as pubkeyIdOf } from './capabilities.js'
-import { enrollDevice as remoteEnroll, requestSign as remoteSign, requestStore as remoteStore, requestDevices as remoteDevices, requestRenew as remoteRenew, requestAdmin as remoteAdmin, requestRenounce as remoteRenounce } from './remote.js'
+import { enrollDevice as remoteEnroll, requestSign as remoteSign, requestStore as remoteStore, requestDevices as remoteDevices, requestRenew as remoteRenew, requestAdmin as remoteAdmin, requestRenounce as remoteRenounce, checkMembership as remoteCheck } from './remote.js'
 
 export const KEY_STORAGE = 'dotrino.identity.keypair'
 export const ENC_KEY_STORAGE = 'dotrino.identity.enc-keypair'
@@ -396,6 +396,60 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     emitVault({ phase: 'account-removed', removed: gone, current: currentPid })
   }
 
+  /**
+   * Deja ABIERTA otra cuenta de este dispositivo: puntero, peers, llaves y `me`. Es lo que
+   * el arranque hace con la cuenta activa, en una función, para que crear una cuenta y
+   * volver atrás cuando algo falla sean el mismo camino recorrido en los dos sentidos.
+   *
+   * Ojo: no es «cambiar de cuenta» de cara a las apps (eso exige recargar, multi-perfil no
+   * es reactivo). Es dejar esta identidad coherente consigo misma antes de contestar.
+   */
+  async function openProfileInMemory (pid) {
+    currentPid = pid
+    rawKv.setItem(CURRENT_STORAGE, pid)
+    await peers.setProfile?.(pid)
+    await initPeerStorage()
+    keypair = await loadOrCreateKeypair(); publickeyJwkStr = JSON.stringify(keypair.publicJwk)
+    encKeypair = await loadOrCreateEncKeypair(); encPublickeyJwkStr = JSON.stringify(encKeypair.publicJwk)
+    const saved = loadMe()
+    me = (saved && saved.publickey === publickeyJwkStr)
+      ? { ...saved, encryptionPubkey: encPublickeyJwkStr }
+      : { publickey: publickeyJwkStr, encryptionPubkey: encPublickeyJwkStr }
+    return { id: pid, name: me.nickname || '', pubkey: publickeyJwkStr }
+  }
+
+  /**
+   * Tira la cuenta que NACIÓ para un emparejamiento que no llegó a término, y vuelve a la
+   * que estabas usando.
+   *
+   * Sin esto, cada intento fallido dejaba una cuenta fantasma —vacía, sin bóveda y encima
+   * puesta como activa—: probar tres veces con el código vencido te dejaba tres cuentas
+   * que no eran de nadie y la tuya sin abrir. La cuenta que se descarta es siempre una
+   * recién creada por `vaultPair`, así que no hay nada dentro que perder.
+   */
+  async function discardBornProfile (pid, backTo) {
+    try {
+      await purgeProfile(pid)
+      if (backTo && loadProfiles().some((p) => p.id === backTo)) await openProfileInMemory(backTo)
+    } catch (e) {
+      console.warn('[identity] could not discard the account born for the pairing:', e?.message || e)
+    }
+  }
+
+  /** El certificado de bóveda guardado en OTRA cuenta de este dispositivo (sin abrirla). */
+  const vaultCertOf = (pid) => {
+    try {
+      const raw = rawKv.getItem(VAULT_CERT_STORAGE.replace(/^dotrino\.identity\./, `dotrino.identity.p.${pid}.`))
+      return raw ? JSON.parse(raw) : null
+    } catch (_) { return null }
+  }
+
+  /** La cuenta de este dispositivo que YA está emparejada con la bóveda `master`, si la hay. */
+  const profilePairedWith = (master) => {
+    if (!master) return null
+    return loadProfiles().find((p) => vaultCertOf(p.id)?.master === master) || null
+  }
+
   /**
    * Borra un perfil y todo lo suyo. Sin preguntas: el freno de «no te quedes sin ninguna»
    * es de la interfaz y vive en `deleteProfile`.
@@ -632,6 +686,35 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     return { joined: true, profileId: candidate.profileId, seq: candidate.seq }
   }
 
+  /**
+   * El emparejamiento propiamente dicho: con la cuenta ya decidida (`vaultPair`), genera el
+   * cert contra la bóveda y entra a su cuenta. Aparte para que la decisión de CUÁL cuenta y
+   * el deshacerla si esto falla vivan juntos arriba, y aquí solo quede el trámite.
+   */
+  async function pairWithVault ({ qr, label = '' }) {
+    // Usa la PROPIA llave de identidad de este navegador como dispositivo: el cert delega
+    // TU identidad (P) desde la maestra M → una sola identidad (signData/identify/cert = P).
+    // La privada es la CryptoKey del perfil (no extractable): se pasa como `privateKey`
+    // y NO se persiste ningún JWK del dispositivo (marcador useIdentityKey).
+    const device = { publickey: publickeyJwkStr, privateKey: keypair.privateKey }
+    // Si esta identidad ya existía por su cuenta, se lleva un certificado de continuidad
+    // 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 })
+      : 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 }))
+    kv.setItem(VAULT_CERT_STORAGE, JSON.stringify({ cert: res.cert, master: res.master, proxy: res.proxy, deviceId: res.deviceId, pairedAt: Date.now() }))
+    // Conectarse a una bóveda es ENTRAR A SU CUENTA: el acta viene con el cert.
+    const unido = res.acta ? await joinProfile(res.acta) : { joined: false, reason: 'sin-acta' }
+    emitVault({ phase: 'paired', deviceId: res.deviceId, master: res.master, join: unido })
+    pullProfileFromVault() // adoptar el perfil que ya viva en el vault (si hay)
+    return { ok: true, deviceId: res.deviceId, master: res.master, exp: res.cert.exp, scope: res.cert.scope, join: unido }
+  }
+
   /**
    * Adopta un acta que llega de otro miembro, si gana según §2.4.1 (seq mayor que encadene,
    * o el traspaso a igual seq). Nunca retrocede.
@@ -650,12 +733,28 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     return last || { adopted: false, reason: 'nada-que-adoptar', seq: loadActa()?.seq ?? null }
   }
 
+  /**
+   * SI EL ACTA NUEVA YA NO ME NOMBRA, ME BORRO. Sin botón y sin preguntar.
+   *
+   * El acta manda —es quien dice de quién es el perfil— y viene FIRMADA por el master, así
+   * que enterarse por ella es tan bueno como el aviso de expulsión: no hay wipe-DoS que
+   * valga, porque un tercero no puede fabricar un acta sellada. Antes solo se hacía caso al
+   * aviso, que es un mensaje suelto: si se perdía —el aparato apagado, la cola del proxy
+   * dura 24 h— el aparato se quedaba enseñando para siempre una cuenta de la que ya lo
+   * habían echado, aunque la propia acta que acababa de recibir dijera lo contrario.
+   */
   async function adoptActa (candidate) {
     const current = loadActa()
     const r = await Acta.canAdopt({ candidate, current })
     if (!r.adopt) return { adopted: false, reason: r.reason, seq: current?.seq ?? null }
     saveActa(candidate)
     emitVault({ phase: 'acta', seq: candidate.seq, sealer: candidate.sealer, adopted: r.reason })
+    const sigoDentro = (candidate.members || []).some((m) => m?.pub === publickeyJwkStr)
+    if (!sigoDentro) {
+      console.warn('[identity] the new record no longer lists this device: removing the account')
+      wipeVaultLink()
+      return { adopted: true, expelled: true, reason: r.reason, seq: candidate.seq }
+    }
     return { adopted: true, reason: r.reason, seq: candidate.seq }
   }
 
@@ -892,15 +991,62 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     clearTimeout(profilePushTimer)
     profilePushTimer = setTimeout(() => {
       const { publickey, encryptionPubkey, ...content } = me || {}
-      remoteStore({ master: v.master, proxy: v.proxy, device, cert: v.cert, method: 'profileSet', args: { me: content } })
+      remoteStore({ master: v.master, proxy: v.proxy, device, cert: v.cert, method: 'profileSet', args: { me: content }, onRevoked: wipeVaultLink })
         .catch(() => {}) // el vault puede estar apagado; se reintenta en la próxima edición
     }, 800) // debounce: ediciones seguidas = un solo push
   }
+  /**
+   * SIN PAPEL, SE PREGUNTA. Y AL ARRANCAR, SOLO.
+   *
+   * Un aparato que perdió su certificado no puede firmar, ni leer, ni renovar: TODO lo que
+   * habla con la bóveda lo exige. Así que tampoco tenía forma de enterarse de que lo habían
+   * echado —el aviso firmado se emite al quitarlo, y si estaba apagado la cola del proxy
+   * dura 24 h— y se quedaba enseñando para siempre una cuenta que ya no era suya.
+   *
+   * Se pregunta con la llave del propio aparato, que es la que el acta nombra, y a la
+   * 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 () {
+    try {
+      const acta = loadActa()
+      if (!acta || acta.sealer === publickeyJwkStr) return          // no hay cuenta ajena que confirmar: mando yo
+      // El acta que ya tengo no me nombra: no hace falta preguntar nada, el acta manda y va
+      // firmada. (Normalmente esto lo resuelve `adoptActa` al recibirla.)
+      if (!(acta.members || []).some((m) => m?.pub === publickeyJwkStr)) {
+        console.warn('[identity] the stored record does not list this device: removing the account')
+        return wipeVaultLink()
+      }
+      const v = loadVaultCert()
+      if (v?.cert && loadVaultDevice()) return                      // con papel, ya lo comprueba el camino normal
+      const r = await remoteCheck({
+        master: acta.sealer,
+        proxy: v?.proxy || 'wss://proxy.dotrino.com',
+        device: { publickey: publickeyJwkStr, privateKey: keypair.privateKey },
+        onRevoked: wipeVaultLink
+      })
+      if (r?.error) console.warn('[identity] could not confirm membership with the vault:', r.error)
+    } catch (e) { console.warn('[identity] could not confirm membership with the vault:', e?.message || e) }
+  }
+
+  /**
+   * EL TOQUE AL ARRANCAR. Corre en cada apertura de la identidad, así que es también el
+   * momento en el que este aparato se entera de que lo echaron: la bóveda contesta al
+   * revocado —tiene que hacerlo— con el aviso FIRMADO, que es lo único que le borra la
+   * cuenta. Sin `onRevoked` ese aviso llegaba y se tiraba a la basura, y el aparato se
+   * quedaba enseñando un perfil del que ya no era, para siempre, sin que nadie pulsara
+   * nada porque no había nada que pulsar.
+   */
   async function pullProfileFromVault () {
     try {
       const v = loadVaultCert(); const device = loadVaultDevice()
-      if (!v?.cert || !device || v.cert.exp <= Date.now()) return
-      const res = await remoteStore({ master: v.master, proxy: v.proxy, device, cert: v.cert, method: 'profileGet', args: {} })
+      // SE TOCA AUNQUE EL PAPEL ESTÉ VENCIDO. Antes se salía sin llamar, y ese es justo el
+      // aparato que más falta le hace: no puede firmar, ni leer, ni renovar —o sea que ya
+      // está roto para todo— y encima era el único que no tenía forma de enterarse de que
+      // lo habían echado. La bóveda contesta «vencido» y no pasa nada; y si además ya no
+      // está en el acta, contesta con el aviso firmado y aquí se le borra la cuenta.
+      if (!v?.cert || !device) return
+      const res = await remoteStore({ master: v.master, proxy: v.proxy, device, cert: v.cert, method: 'profileGet', args: {}, onRevoked: wipeVaultLink })
       const remoteMe = res?.me
       if (!remoteMe) {
         // el vault aún no tiene perfil: sembrar con el local (si tiene contenido)
@@ -1256,16 +1402,15 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      */
     async createProfile ({ name, forVault = false } = {}) {
       const pid = 'p' + crypto.randomUUID().slice(0, 8)
-      currentPid = pid
-      rawKv.setItem(CURRENT_STORAGE, pid)
-      await peers.setProfile?.(pid)
-      await initPeerStorage()
-      keypair = await loadOrCreateKeypair(); publickeyJwkStr = JSON.stringify(keypair.publicJwk)
-      encKeypair = await loadOrCreateEncKeypair(); encPublickeyJwkStr = JSON.stringify(encKeypair.publicJwk)
+      // `from`: de qué cuenta se venía. Solo se anota en la que nace para una bóveda, y es
+      // lo que deja volver a casa si el emparejamiento no llega a término —también cuando
+      // se cortó por lo bruto (cerrar la pestaña) y quien limpia es el arranque siguiente.
+      const from = currentPid
+      await openProfileInMemory(pid)
       me = { publickey: publickeyJwkStr, encryptionPubkey: encPublickeyJwkStr, nickname: String(name || '').slice(0, 40) }
       saveMe(me)
       const list = loadProfiles()
-      list.push({ id: pid, name: me.nickname, pubkey: publickeyJwkStr, ...(forVault ? { pendingJoin: true } : {}) })
+      list.push({ id: pid, name: me.nickname, pubkey: publickeyJwkStr, ...(forVault ? { pendingJoin: true, ...(from ? { from } : {}) } : {}) })
       saveProfiles(list)
       await ensureActa(me.nickname) // el perfil nuevo nace con su acta (él mismo es el master)
       return { id: pid, name: me.nickname, pubkey: publickeyJwkStr, pendingJoin: !!forVault }
@@ -1509,6 +1654,11 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      * se adivina):
      *   · `'new'`     → camino B: crea aquí una cuenta más, con llave nueva, y ES ESA la que
      *                   entra al acta de la bóveda. La que estabas usando **no se toca**.
+     *                   Con dos frenos, porque una cuenta más solo vale si de verdad es
+     *                   otra: si ESTE dispositivo ya tiene la cuenta de esa bóveda, no nace
+     *                   ninguna (se re-empareja la que hay, o se avisa con `ALREADY_PAIRED`
+     *                   de que vive en otra cuenta de aquí); y si el intento falla, la que
+     *                   nació para él se descarta en vez de quedarse de fantasma.
      *   · `'current'` → sigue con la cuenta abierta. Solo vale si nació para adoptar
      *                   (`forVault`) o si ya está emparejada con ESA misma bóveda
      *                   (re-emparejar). En cualquier otro caso falla **antes de tocar la
@@ -1521,35 +1671,43 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      */
     async vaultPair ({ qr, label = '', join = 'current' }) {
       if (join === 'adopt') return handlers.vaultAdopt({ qr, label })
+      // La cuenta abierta AQUÍ y la que se cree para este intento. `born` es la que hay que
+      // tirar si el emparejamiento no llega a término: nació para él y no tiene nada dentro.
+      const from = currentPid
+      let born = null
       if (join === 'new') {
-        await handlers.createProfile({ name: label || me?.nickname || '', forVault: true })
-      } else {
+        // RE-EMPAREJAR NO ES UNA CUENTA MÁS. Volver a esta pantalla con la bóveda que ya te
+        // tiene —porque el papel venció, porque lo retiraron, porque se rehízo el
+        // emparejamiento— pedía otra cuenta nueva y te dejaba la MISMA cuenta dos veces en
+        // el conmutador, con dos llaves distintas metidas en el acta de la bóveda.
+        if (qr?.iss && loadVaultCert()?.master === qr.iss) join = 'current'
+        else {
+          const otra = qr?.iss ? profilePairedWith(qr.iss) : null
+          // Y si la que tiene esa bóveda es OTRA cuenta de este mismo dispositivo, tampoco se
+          // duplica: cambiar de cuenta exige recargar (multi-perfil no es reactivo), así que
+          // esto se dice con código para que la consola ofrezca ir a ella.
+          if (otra) {
+            throw Object.assign(new Error(`this device already has the account of that vault (profile ${otra.id})`),
+              { code: 'ALREADY_PAIRED', detail: { profile: otra.id, name: otra.name || '' } })
+          }
+          born = await handlers.createProfile({ name: label || me?.nickname || '', forVault: true })
+        }
+      }
+      if (join !== 'new') {
         const yaConEsta = loadVaultCert()?.master === qr?.iss
         if (loadActa() && !isPendingJoin() && !yaConEsta) {
           throw new Error('this device is already using an account: to also use your vault account, create a new account here (the open one is untouched)')
         }
       }
-      // Usa la PROPIA llave de identidad de este navegador como dispositivo: el cert delega
-      // TU identidad (P) desde la maestra M → una sola identidad (signData/identify/cert = P).
-      // La privada es la CryptoKey del perfil (no extractable): se pasa como `privateKey`
-      // y NO se persiste ningún JWK del dispositivo (marcador useIdentityKey).
-      const device = { publickey: publickeyJwkStr, privateKey: keypair.privateKey }
-      // Si esta identidad ya existía por su cuenta, se lleva un certificado de continuidad
-      // 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 })
-        : 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 }))
-      kv.setItem(VAULT_CERT_STORAGE, JSON.stringify({ cert: res.cert, master: res.master, proxy: res.proxy, deviceId: res.deviceId, pairedAt: Date.now() }))
-      // Conectarse a una bóveda es ENTRAR A SU CUENTA: el acta viene con el cert.
-      const unido = res.acta ? await joinProfile(res.acta) : { joined: false, reason: 'sin-acta' }
-      emitVault({ phase: 'paired', deviceId: res.deviceId, master: res.master, join: unido })
-      pullProfileFromVault() // adoptar el perfil que ya viva en el vault (si hay)
-      return { ok: true, deviceId: res.deviceId, master: res.master, exp: res.cert.exp, scope: res.cert.scope, join: unido }
+      try {
+        return await pairWithVault({ qr, label })
+      } catch (e) {
+        // El intento falló (código vencido, la bóveda dijo que no, se agotó la espera): la
+        // cuenta que nació para él se va con él. Si no, cada reintento dejaba una cuenta
+        // fantasma —y encima puesta como activa—.
+        if (born) await discardBornProfile(born.id, from)
+        throw e
+      }
     },
 
     /**
@@ -1712,7 +1870,19 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     // Lista (solo lectura) de dispositivos enrolados en tu vault.
     async listVaultDevices () {
       const v = loadVaultCert(); const device = loadVaultDevice()
-      if (!v?.cert || !device) throw new Error('this device is not paired with a vault')
+      if (!v?.cert || !device) {
+        // SOLO SE AVISA SI ES RARO. Un aparato que manda en su propia cuenta —o que aún no
+        // entró en ninguna bóveda— no está paired y no pasa absolutamente nada: avisar ahí
+        // es ensuciar la consola de todo el mundo con el estado normal. Lo que sí es raro,
+        // y hasta ahora era mudo, es guardar el acta de OTRO y no tener con qué llamarle.
+        const acta = loadActa()
+        if (acta && acta.sealer !== publickeyJwkStr) {
+          console.warn('[identity] cannot reach the vault that seals this account:', JSON.stringify({
+            cert: !!v?.cert, device: !!device, acta: acta.seq
+          }))
+        }
+        throw new Error('this device is not paired with a vault')
+      }
       maybeRenewVaultCert()
       try {
         const res = await remoteDevices({ master: v.master, proxy: v.proxy, device, cert: v.cert, sinceSeq: loadActa()?.seq ?? 0, onRevoked: wipeVaultLink })
@@ -1890,6 +2060,30 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
 
   // ----- bootstrap -----
 
+  // Cuentas que NACIERON para un emparejamiento que nunca llegó a término y se quedaron ahí:
+  // se cerró la pestaña con el código en pantalla, o se recargó a mitad. No tienen bóveda y
+  // no pueden llegar a tenerla —el intento vivía en la llamada que se cortó—, así que son
+  // cuentas fantasma: vacías, sin dueño y ensuciando el conmutador. Aquí se recogen, y si la
+  // activa era una de ellas se vuelve a la que estabas usando antes (`from`).
+  //
+  // Nunca se borra la última: quedarse sin ninguna es peor que quedarse con una vacía. Y solo
+  // se van las marcadas `pendingJoin` SIN certificado: en cuanto una se une a la bóveda la
+  // marca se consume, así que ninguna cuenta de verdad entra en este barrido.
+  {
+    const list = loadProfiles()
+    const orphan = (p) => p.pendingJoin && !vaultCertOf(p.id)
+    const dead = list.filter(orphan)
+    const alive = list.filter((p) => !orphan(p))
+    if (dead.length && alive.length) {
+      const stored = rawKv.getItem(CURRENT_STORAGE)
+      const back = dead.find((p) => p.id === stored)?.from
+      for (const p of dead) {
+        try { await purgeProfile(p.id) } catch (e) { console.warn('[identity] could not discard a ghost account:', e?.message || e) }
+      }
+      if (back && alive.some((p) => p.id === back)) rawKv.setItem(CURRENT_STORAGE, back)
+    }
+  }
+
   // Perfil activo (multi-perfil por dispositivo). Si no hay perfiles, se crea el primero; si
   // existe una identidad ÚNICA vieja (pre-multi-perfil, claves sin namespace), se ADOPTA como
   // "Perfil 1" — sin pérdida. A partir de acá `kv` está scopeado a `currentPid`.
@@ -1955,6 +2149,9 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
 
   // 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()
 
   // Registrar el pubkey (y nombre) del perfil activo en su meta → para avatar/listado sin abrir cada perfil.
   {

package/vault/remote.js

@@ -28,6 +28,9 @@ const MSG = {
   ACTA_SEALED: 'vault.acta.sealed',
   ACTA_ADOPTED: 'vault.acta.adopted',
   REVOKED: 'vault.revoked',
+  // «¿sigo siendo de esta casa?»: la única pregunta que la bóveda atiende SIN certificado.
+  CHECK: 'vault.check',
+  CHECKED: 'vault.checked',
   // Consola remota: administrar el perfil desde un dispositivo (scope `vault:admin`).
   ADMIN: 'vault.admin',
   ADMIN_RESULT: 'vault.admin.result',
@@ -278,6 +281,51 @@ async function vaultRpc ({ master, proxy, device, cert, acta = null, sendType, o
   } finally { try { client.close() } catch (_) {} }
 }
 
+/**
+ * PREGUNTA SIN CERTIFICADO: «¿sigo estando en el acta?».
+ *
+ * Es el único camino que le queda al aparato que perdió su papel — sin cert no puede
+ * firmar, ni leer, ni renovar, así que tampoco podía enterarse de que lo habían echado y se
+ * quedaba enseñando una cuenta que ya no era suya. Va firmada con SU llave, que es lo que
+ * el acta nombra.
+ *
+ * La bóveda contesta sí o no, y nada más. Si el no viene acompañado del aviso FIRMADO de
+ * expulsión, ESE es el que borra la cuenta aquí (`onRevoked`); el «no» pelado no borra
+ * 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')
+  const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
+  const client = new WebSocketProxyClient({ url: proxy, enableWebRTC: false, autoReconnect: false })
+  await client.connect()
+  try {
+    // Identificarse hace además que el proxy entregue lo ENCOLADO (un aviso de cuando
+    // estaba apagado, si todavía está dentro de las 24 h).
+    try { await identifyAsDevice(client, device) } catch (_) {}
+    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) } }
+      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 }) } })
+            .catch(() => {})
+          return
+        }
+        if (p.type === MSG.CHECKED) fin({ in: !!p.in })
+        else if (p.type === MSG.ERROR) fin({ error: p.error })
+      })
+      const t = setTimeout(() => fin({ error: 'the vault did not reply' }), timeoutMs)
+      const cleanup = () => { off(); clearTimeout(t) }
+      client.sendByPubkey(master, { type: MSG.CHECK, data, signature })
+    })
+    return res
+  } finally { try { client.close() } catch (_) {} }
+}
+
 /** Lee/escribe el store de hilos+aperturas EN el vault (con el cert del dispositivo). */
 export async function requestStore ({ master, proxy, device, cert, method, args, enc, onRevoked } = {}) {
   // `enc`: argumentos cifrados con la clave de contenido del perfil (el proxy no los ve).

package/vault/vault.js

@@ -277,7 +277,15 @@ import { pubkeyId } from './capabilities.js'
       const result = await handler(params || {})
       reply({ result })
     } catch (e) {
-      reply({ error: e?.message || String(e) })
+      // `code` (y su `detail`) CRUZAN. Sin ellos, al otro lado solo llegaba la frase, y una
+      // app que quiere reaccionar a un rechazo concreto —«esa bóveda ya está en otra cuenta
+      // de este aparato»— no tenía más remedio que emparejarla por su texto: se traduce o se
+      // reescribe y deja de funcionar sin que nadie se entere.
+      reply({
+        error: e?.message || String(e),
+        ...(e?.code ? { code: e.code } : {}),
+        ...(e?.detail ? { detail: e.detail } : {})
+      })
     }
   })
 

package/vault/vendor/vault/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/vault@0.18.0 (lib/src/{index,enroll,protocol}.js, sin dependencias).
+Copia vendorizada de @dotrino/vault@0.24.0 (lib/src/{index,enroll,protocol}.js, sin dependencias).
 El iframe de identity se sirve estatico (vanilla, sin build); asi startDeviceVault
 resuelve en el navegador sin bundler. index.js importa ./enroll.js y ./protocol.js
 (relativos, se vendorizan tambien) y @dotrino/identity/capabilities (=../../capabilities.js)

package/vault/vendor/vault/enroll.js

@@ -104,13 +104,16 @@ export async function deviceIdOf (pub) {
  * @param {(...a:any[])=>void} [opts.log]
  * @param {(c:{deviceId:string, scope:any, label:string})=>void} [opts.onChallenge]  un dispositivo espera aprobación.
  * @param {()=>void} [opts.onPendingChange]
+ * @param {(sub:string)=>void} [opts.onDeviceRemoved]  se quitó un aparato (fuera del acta y sin papeles):
+ *   para que quien guarde algo indexado por esa llave lo suelte. Se avisa desde AQUÍ y no desde
+ *   quien llama porque a `revokeDevice` se entra por dos puertas (el PC y la consola remota).
  * @param {string[]} [opts.defaultScope]
  * @param {number} [opts.defaultTtlMs]
  */
 export function createEnrollDesk ({
   identity, iss, proxy, send, sendByPubkey,
   audit = () => {}, log = () => {},
-  onChallenge = () => {}, onPendingChange = () => {}, onAdopted = () => {},
+  onChallenge = () => {}, onPendingChange = () => {}, onAdopted = () => {}, onDeviceRemoved = () => {},
   defaultScope = ['vault:sign'], defaultTtlMs = DEVICE_TTL_MS,
   // Camino A: lo que ESTA bóveda le manda al aparato para que la meta en su acta. `encPub`
   // es su llave de CIFRADO — sin ella entra mandando pero sin poder leer el contenido.
@@ -231,7 +234,7 @@ export function createEnrollDesk ({
     }
     if (intent !== (pend.mode || 'join')) {
       audit('rejected', { what: 'enroll', reason: 'intent-mismatch' })
-      return reply(from, { type: MSG_ERROR, error: `este emparejamiento se abrió para «${pend.mode || 'join'}» y el dispositivo pidió «${intent}»` })
+      return reply(from, { type: MSG_ERROR, error: `this pairing was opened for "${pend.mode || 'join'}" and the device asked for "${intent}"` })
     }
     if (!isFresh(d)) {
       audit('rejected', { what: 'enroll', reason: 'stale' })
@@ -329,25 +332,25 @@ export function createEnrollDesk ({
     // Aprobar un emparejamiento ES admitir al dispositivo en el perfil: el cert es la
     // credencial y el acta es la política, y no tiene sentido emitir una sin la otra.
     // Las capacidades salen del scope que se pidió al emparejar (cert ∩ acta, §2.3).
-    let acta = null
+    let record = null
     try {
       if (typeof identity.admitMember === 'function') {
         const cn = scopeToCn(pend.scope)
         const caps = cn ? ['secrets'] : scopeToCaps(pend.scope)
         if (caps.length) await identity.admitMember({ pub: pend.dpub, encPub: pend.encPub || null, label: pend.label || '', cn, caps, cert, continuity: pend.continuity || null })
       }
-      acta = (await identity.profileActa?.())?.acta || null
-    } catch (e) { log('[vault] no se pudo admitir en el acta:', e.message) }
+      record = (await identity.profileActa?.())?.acta || null
+    } catch (e) { log('[vault] could not admit into the record:', e.message) }
 
     audit('enroll', { device: pend.deviceId, label: pend.label || '', scope: pend.scope })
     // Echamos el código tipeado junto al cert: el DISPOSITIVO acepta solo si coincide
     // con el que generó → una bóveda falsa (que no lo conoce) no puede enrolarlo.
     // El acta viaja con el cert: el dispositivo ya sabe de quién es el perfil al que entra.
-    reply(pend.from, { type: MSG_ENROLLED, code, cert, iss, acta })
+    reply(pend.from, { type: MSG_ENROLLED, code, cert, iss, acta: record })
     pend.state = 'DONE'
     pending.delete(pend.token)
     fire(onPendingChange)
-    log('[vault] dispositivo aprobado: %s', pend.deviceId)
+    log('[vault] device approved: %s', pend.deviceId)
     return { ok: true, deviceId: pend.deviceId, cert }
   }
 
@@ -367,39 +370,39 @@ export function createEnrollDesk ({
    * pisar una cuenta con datos, y eso no puede pasar por accidente.
    */
   async function handleActaSealed (from, p) {
-    const acta = p?.acta
+    const record = p?.acta
     const pend = [...pending.values()].find((x) => x.state === 'AWAITING_ACTA' && (x.from === from || x.dpub))
     if (!pend) return reply(from, { type: MSG_ERROR, error: 'no adoption awaiting a record' })
-    if (!acta || typeof acta !== 'object') return reply(from, { type: MSG_ERROR, error: 'record missing or unreadable' })
-    if (acta.sealer !== iss) {
+    if (!record || typeof record !== 'object') return reply(from, { type: MSG_ERROR, error: 'record missing or unreadable' })
+    if (record.sealer !== iss) {
       audit('rejected', { what: 'adopt', reason: 'not-sealer' })
       return reply(from, { type: MSG_ERROR, error: 'that record does not name this vault as the sealer' })
     }
-    if (acta.sealedBy !== pend.dpub) {
+    if (record.sealedBy !== pend.dpub) {
       audit('rejected', { what: 'adopt', reason: 'sealed-by-other' })
       return reply(from, { type: MSG_ERROR, error: 'that record was not sealed by the device of this pairing' })
     }
-    if (pend.profileId && acta.profileId !== pend.profileId) {
+    if (pend.profileId && record.profileId !== pend.profileId) {
       audit('rejected', { what: 'adopt', reason: 'other-profile' })
       return reply(from, { type: MSG_ERROR, error: 'that record belongs to an account other than the one the device announced' })
     }
 
     try {
-      const r = await identity.joinProfile(acta)
+      const r = await identity.joinProfile(record)
       if (!r?.joined) throw new Error(r?.reason || 'could not adopt')
-      audit('adopt', { device: pend.deviceId, profile: acta.profileId, seq: acta.seq })
+      audit('adopt', { device: pend.deviceId, profile: record.profileId, seq: record.seq })
       // El acta que vuelve es la que la bóveda tiene guardada: el aparato la adopta y los
       // dos quedan en la misma versión.
-      const mia = (await identity.profileActa?.())?.acta || acta
-      reply(pend.from, { type: MSG_ACTA_ADOPTED, code: p.code, acta: mia })
+      const mine = (await identity.profileActa?.())?.acta || record
+      reply(pend.from, { type: MSG_ACTA_ADOPTED, code: p.code, acta: mine })
       pend.state = 'DONE'
       pending.delete(pend.token)
       fire(onPendingChange)
-      fire(onAdopted, { deviceId: pend.deviceId, profileId: acta.profileId, seq: mia.seq })
-      log('[vault] cuenta adoptada del dispositivo %s (perfil %s)', pend.deviceId, acta.profileId?.slice(0, 12))
-      return { ok: true, adopted: true, profileId: acta.profileId, seq: mia.seq }
+      fire(onAdopted, { deviceId: pend.deviceId, profileId: record.profileId, seq: mine.seq })
+      log('[vault] account adopted from device %s (profile %s)', pend.deviceId, record.profileId?.slice(0, 12))
+      return { ok: true, adopted: true, profileId: record.profileId, seq: mine.seq }
     } catch (e) {
-      log('[vault] no se pudo adoptar la cuenta: %s', e.message)
+      log('[vault] could not adopt the account: %s', e.message)
       reply(pend.from, { type: MSG_ERROR, error: 'the vault could not adopt the account: ' + e.message })
       return { ok: false, error: e.message }
     }
@@ -435,15 +438,39 @@ export function createEnrollDesk ({
   async function revoke (nonce) {
     audit('revoke', { nonce })
     const { issued } = await identity.listDelegations()
-    const dele = (issued || []).find((d) => d.nonce === nonce)
+    const delegation = (issued || []).find((d) => d.nonce === nonce)
     const res = await identity.revokeDelegation(nonce)
-    if (dele?.sub) await emitRevoke(dele.sub, nonce)
+    if (delegation?.sub) await emitRevoke(delegation.sub, nonce)
+    return res
+  }
+
+  /**
+   * QUITA EL DISPOSITIVO entero: retira TODOS sus certificados vigentes y le manda una
+   * sola orden de autoborrado. `revoke(nonce)` retira un papel, y un aparato puede tener
+   * varios (una renovación dejaba vivo el anterior): quitarle uno no lo echaba, y podía
+   * quedarse dentro justo con el que llevaba `vault:admin`.
+   */
+  async function revokeDevice (sub) {
+    if (!sub) throw new Error('sub (device pubkey) required')
+    const { issued } = await identity.listDelegations()
+    const mine = (issued || []).filter((d) => d.sub === sub)
+    audit('revoke-device', { certs: mine.length })
+    // Si el núcleo no trae `revokeDevice` (bóveda vieja), se cae a retirarlos uno a uno.
+    const res = identity.revokeDevice
+      ? await identity.revokeDevice(sub)
+      : { ok: true, nonces: await (async () => {
+          const done = []
+          for (const d of mine) { await identity.revokeDelegation(d.nonce); done.push(d.nonce) }
+          return done
+        })() }
+    await emitRevoke(sub, mine[0]?.nonce || null)
+    fire(onDeviceRemoved, sub)
     return res
   }
 
   return {
     startPairing, stopPairing, handleEnroll, handleActaSealed, handleHello, approve, reject,
-    listPending, findPending, emitRevoke, revoke,
+    listPending, findPending, emitRevoke, revoke, revokeDevice,
     get pendingCount () { return pending.size }
   }
 }

package/vault/vendor/vault/index.js

@@ -52,7 +52,7 @@ export { deviceIdOf }
  */
 export async function startDeviceVault (identity, { proxyUrl, client: injectedClient } = {}) {
   const iss = identity.me?.publickey
-  if (!iss) throw new Error('sin identidad: crea/desbloquea tu identidad antes de usar el dispositivo como bóveda')
+  if (!iss) throw new Error('no identity: create/unlock your identity before using this device as a vault')
   const proxy = proxyUrl || 'wss://proxy.dotrino.com'
 
   // ----- self-cert P ← P (para que este dispositivo pueda además actuar de cliente
@@ -133,7 +133,7 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
    */
   async function handleRenew (from, p) {
     const d = p?.data
-    if (!d || !p.signature || !p.cert) return send(from, { type: MSG.ERROR, error: 'petición inválida' })
+    if (!d || !p.signature || !p.cert) return send(from, { type: MSG.ERROR, error: 'invalid request' })
     if (typeof d.ts !== 'number' || Math.abs(Date.now() - d.ts) > FRESH_WINDOW_MS) {
       return send(from, { type: MSG.ERROR, error: 'stale request: ts outside the ±5 min window (possible replay, or the device clock is off)' })
     }
@@ -151,18 +151,20 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
   // QUIEN consulta es una máquina ya revocada (reapareció), le re-emite el REVOKED firmado.
   async function handleDevices (from, p) {
     const d = p?.data
-    if (!d || !p.signature || !p.cert) return send(from, { type: MSG.ERROR, error: 'petición inválida' })
+    if (!d || !p.signature || !p.cert) return send(from, { type: MSG.ERROR, error: 'invalid request' })
     if (typeof d.ts !== 'number' || Math.abs(Date.now() - d.ts) > FRESH_WINDOW_MS) return
     const chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, trustedIssuer: iss })
-    if (!chk.ok) return send(from, { type: MSG.ERROR, error: 'no autorizado: ' + chk.reason })
-    const { issued, revoked } = await identity.listDelegations()
+    if (!chk.ok) return send(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
+    const { issued, revoked, revokedCerts } = await identity.listDelegations()
     const devices = await Promise.all((issued || []).map(async (x) => ({
       deviceId: x.sub ? await deviceIdOf(x.sub) : null, sub: x.sub || null,
       label: x.label || '', scope: x.scope, exp: x.exp, nonce: x.nonce
     })))
     send(from, { type: MSG.DEVICES_RESULT, devices, revoked: (revoked || []).map((r) => r.nonce || r) })
     // ¿el que consulta es una máquina revocada que reapareció? → re-emite el REVOKED firmado.
-    const mine = (issued || []).find((x) => x.sub === chk.device && x.revokedAt)
+    // Se busca en `revokedCerts`: desde que `issued` solo trae lo vigente, los retirados
+    // ya no están ahí y este aviso dejaba de dispararse (se caía en silencio).
+    const mine = (revokedCerts || issued || []).find((x) => x.sub === chk.device && x.revokedAt)
     if (mine) desk.emitRevoke(chk.device, mine.nonce)
   }
 
@@ -204,8 +206,14 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
     reject: (deviceId) => desk.reject(deviceId),
     listPending: desk.listPending,
     listMachines,
-    // Revoca y AVISA a la máquina con un REVOKED firmado para que se auto-borre (ahora si
-    // está online, o al reaparecer vía handleDevices).
+    // QUITA LA MÁQUINA entera (por su llave): fuera del acta y sin ningún certificado
+    // vigente, que son las dos caras del mismo acto. Y AVISA con un REVOKED firmado para
+    // que se auto-borre (ahora si está online, o al reaparecer vía handleDevices).
+    revokeDevice: (sub) => desk.revokeDevice(sub),
+    // Retira UN certificado. No es quitar la máquina: sigue siendo miembro del acta, y
+    // quien queda así ya no recibe el aviso de expulsión (mientras siga en el acta, un
+    // papel retirado significa «renueva»). Usar `revokeDevice` salvo que quieras
+    // exactamente esto.
     revoke: (nonce) => desk.revoke(nonce),
     getSelfCert,
     onPendingChange (fn) { _onPendingChange = fn || (() => {}) },

package/vault/vendor/vault/protocol.js

@@ -33,6 +33,11 @@ export const MSG = Object.freeze({
   ACTA_SEALED: 'vault.acta.sealed',           // dispositivo → vault: { acta, code }
   ACTA_ADOPTED: 'vault.acta.adopted',         // vault → dispositivo: { acta }
   REVOKED: 'vault.revoked',                   // vault → dispositivo: { body:{op,sub,nonce,iat,exp}, signature }
+  // «¿sigo siendo de esta casa?» — la ÚNICA pregunta que se puede hacer SIN certificado:
+  // va firmada con la llave del propio aparato, que es lo que el acta nombra. Existe para
+  // el aparato que perdió su papel: sin ella no tiene forma de enterarse de que lo echaron.
+  CHECK: 'vault.check',                       // dispositivo → vault: { data:{op:'check',publickey,ts}, signature }
+  CHECKED: 'vault.checked',                   // vault → dispositivo: { in:boolean } — y si no, el REVOKED firmado
   SIGN: 'vault.sign',                         // dispositivo → vault: { data, signature, cert }
   SIGNED: 'vault.signed',                     // vault → dispositivo: { signature, publickey, device }
   GET: 'vault.get',                           // dispositivo → vault: { data, signature, cert }
@@ -42,6 +47,8 @@ export const MSG = Object.freeze({
   DEVICES: 'vault.devices',                   // dispositivo → vault: { data:{publickey,ts}, signature, cert }
   DEVICES_RESULT: 'vault.devices.result',     // vault → dispositivo: { devices, revoked }
   RENEW: 'vault.renew',                       // dispositivo → vault: { data:{op,publickey,ts}, signature, cert }
+  RENOUNCE: 'vault.renounce',                 // dispositivo → vault: { record }  (RENUNCIA firmada por el propio miembro)
+  RENOUNCE_RESULT: 'vault.renounce.result',   // vault → dispositivo: { ok, seq }
   RENEWED: 'vault.renewed',                   // vault → dispositivo: { cert }  (cert fresco, misma sub-clave/scope)
   SECRETS: 'vault.secrets',                   // servicio → vault: { data:{op,ns,ek,publickey,ts}, signature, cert }
   SECRETS_RESULT: 'vault.secrets.result',     // vault → servicio: { body:{op,ns,enc,ts}, signature } (enc SELLADO a ek; body firmado por la maestra)
@@ -91,3 +98,10 @@ export const SCOPE = Object.freeze({
 export const SECRETS_SCOPE_PREFIX = 'vault:secrets:'
 export const secretsScope = (ns) => SECRETS_SCOPE_PREFIX + ns
 export const isValidSecretsNs = (ns) => typeof ns === 'string' && /^[a-z0-9-]{1,32}$/.test(ns)
+
+/**
+ * Nombre de una variable de entorno: `MAYUSCULAS_CON_GUION_BAJO`, hasta 64. Vive aquí
+ * —y no en el cajón que la guarda— porque la comprueban también la TUI, la consola
+ * remota y el lector de `.env`, y tres copias de una regla son tres reglas.
+ */
+export const isValidVarKey = (key) => typeof key === 'string' && /^[A-Z0-9_]{1,64}$/.test(key)