@dotrino/identity 0.115.0 → 0.117.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.115.0",
+  "version": "0.117.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",
@@ -20,6 +20,9 @@
     "./avatar": {
       "import": "./vault/avatar.js"
     },
+    "./facade": {
+      "import": "./vault/facade.js"
+    },
     "./vault/core.js": "./vault/core.js",
     "./vault/remote.js": "./vault/remote.js",
     "./machine": {

package/src/node.js

@@ -19,6 +19,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import os from 'node:os'
 import { createIdentityCore } from '../vault/core.js'
+import { IdentityFacade } from '../vault/facade.js'
 
 /**
  * kv síncrono respaldado por un archivo JSON (estilo localStorage).
@@ -93,21 +94,20 @@ function filePeers (filePath) {
 
 const DEFAULT_DIR = path.join(os.homedir(), '.dotrino', 'identity')
 
-export class Identity {
+export class Identity extends IdentityFacade {
   /**
    * @param {Object} [options]
    * @param {string} [options.dir]  Directorio de persistencia de esta identidad.
    *   Cada directorio = un usuario distinto. Default: ~/.dotrino/identity
    */
   constructor (options = {}) {
+    super(null)
     this._dir = options.dir || DEFAULT_DIR
     this._atRest = options.atRest || null
     // CANDADO DE LA MAESTRA: `{ seal(jwkStr), open(blob) }`. Quien lo provee (el daemon
     // del vault) es el único que tiene la llave que sale de la contraseña. Sin candado,
     // la maestra se guarda como siempre — un perfil sin contraseña no cambia.
     this._keyLock = options.keyLock || null
-    this._core = null
-    this._listeners = new Map()
   }
 
   /**
@@ -133,186 +133,10 @@ export class Identity {
       // apuntando a algo que ya no existe. Se borra el enlace y el acta, nada más.
       removeAccountOnExpulsion: false
     })
-    this._core.onSyncStatus((payload) => this._emit('sync', payload))
-    this._core.onVaultEvent((payload) => this._emit('vault', payload))
+    this._wire()
     return this
   }
 
-  destroy () { this._core = null }
-
-  get me () { return this._core?.me || null }
-
-  // ----- candado de la maestra -----
-  /** `true` si la maestra está sellada: esta identidad NO puede firmar nada. */
-  get masterLocked () { return !!this._core?.masterLocked }
-  /** Sella la maestra que ya existe (se llama al abrir el perfil, con la llave en la mano). */
-  sealMasterKey () { return this._core?.sealMasterKey?.() }
-  /** Vuelve a cargar el par tras abrir el candado, sin reabrir la identidad. */
-  reloadMasterKey () { return this._core?.reloadMasterKey?.() }
-  /** Ver `core.js`: al abrir, los aparatos muertos salen del acta en una sola. */
-  pruneExpiredDevices (now) { return this._core?.pruneExpiredDevices?.(now) }
-
-  _h (method, params = {}) {
-    if (!this._core) throw new Error('Identity not ready — call ready()/connect() first')
-    return this._core.handlers[method](params)
-  }
-
-  // ----- API pública (espeja src/index.js) -----
-
-  makeChallenge () { return this._h('makeChallenge') }
-  signChallenge (nonce) { return this._h('signChallenge', { nonce }) }
-  verifyResponse ({ nonce, publickey, signature, encryptionPubkey }) {
-    return this._h('verifyResponse', { nonce, publickey, signature, encryptionPubkey })
-  }
-  getPeer (publickey) { return this._h('getPeer', { publickey }) }
-  setNickname (publickey, nickname) { return this._h('setNickname', { publickey, nickname }) }
-  setBlocked (publickey, blocked) { return this._h('setBlocked', { publickey, blocked }) }
-  setRating (publickey, rating, notes) { return this._h('setRating', { publickey, rating, notes }) }
-  listPeers () { return this._h('listPeers') }
-  forgetPeer (publickey) { return this._h('forgetPeer', { publickey }) }
-  addContact ({ publickey, nickname, encryptionPubkey, lastToken, notes } = {}) {
-    return this._h('addContact', { publickey, nickname, encryptionPubkey, lastToken, notes })
-  }
-  updateContact (publickey, patch) { return this._h('updateContact', { publickey, patch }) }
-  removeContact (publickey) { return this._h('removeContact', { publickey }) }
-  listContacts () { return this._h('listContacts') }
-  signData (data) { return this._h('signData', { data }) }
-  /**
-   * Prueba firmada con destinatario y vigencia (ver `vault/assertion.js`). Un servicio en
-   * Node la pide igual que una app: `{ audience, nonce, scopes?, ttlMs? }`.
-   */
-  async requestAssertion ({ audience, nonce, scopes, ttlMs } = {}) {
-    const { assertion } = await this._h('requestAssertion', { audience, nonce, scopes, ttlMs })
-    return assertion
-  }
-  // Delegación de capacidad (sub-clave de dispositivo con scope/exp/revocación)
-  signDelegation (sub, scope, opts = {}) { return this._h('signDelegation', { sub, scope, ...opts }) }
-  revokeDelegation (nonce) { return this._h('revokeDelegation', { nonce }) }
-  /** Quitar el DISPOSITIVO: retira todos sus certificados vigentes, no solo uno. */
-  revokeDevice (sub) { return this._h('revokeDevice', { sub }) }
-  listDelegations () { return this._h('listDelegations') }
-  // Acta de perfil (qué llaves son del perfil y qué puede cada una; ver acta-de-perfil.md)
-  profileActa () { return this._h('profileActa') }
-  /** La cadena de selladores, para mandarla con una firma (ver `vault/acta.js`). */
-  sealerChain () { return this._h('sealerChain') }
-  profileMembers () { return this._h('profileMembers') }
-  /**
-   * Quien SELLA SOBRES (la bóveda) registra aquí cómo estrenar su llave de sellado: se
-   * llama al sellar cada acta, porque esa llave rota con el acta (§8.9 de
-   * `dotrino-vault/docs/secretos-sellados.md`). Va por aquí y no por el iframe porque
-   * este puente es en-proceso: al navegador no se le puede pasar una función, y tampoco
-   * la necesita — no sella secretos de nadie.
-   */
-  /** Abre un sobre sellado A ESTE aparato (envoltura + sobre). Ver `core.js`. */
-  openSealedValue (wrap, envelope) { return this._h('openSealedValue', { wrap, envelope }) }
-  /** Re-envuelve para otro miembro una llave que este aparato ya puede abrir. */
-  rewrapFor (wrap, encPub) { return this._h('rewrapFor', { wrap, encPub }) }
-  setSealKeyProvider (provider) { return this._h('setSealKeyProvider', { provider }) }
-  /** Estrena la llave de sellado en un acta nueva, sin tocar a ningún miembro. */
-  rotateSealKey () { return this._h('rotateSealKey') }
-  /** Con qué llave se comprueban los sobres que se firmaron con el acta `seq`. */
-  sealKeyAt (seq) { return this._h('sealKeyAt', { seq }) }
-  myMembership () { return this._h('myMembership') }
-  /**
-   * La CADENA de actas desde `sinceSeq` (para que un dispositivo que estuvo apagado
-   * compruebe el encadenamiento en vez de tragarse un salto a ciegas).
-   *
-   * Vivía en el núcleo pero NO estaba aquí, así que `identity.actaHistory` era
-   * `undefined` en el daemon: al pedir la lista de dispositivos con un `sinceSeq`
-   * —que es lo que manda SIEMPRE un navegador ya emparejado— reventaba con
-   * «is not a function», la bóveda respondía error, y el aparato NUNCA volvía a
-   * sincronizar su acta. Se quedaba con la copia del día que emparejó.
-   */
-  actaHistory (opts) { return this._h('actaHistory', opts || {}) }
-  isMaster () { return this._h('isMaster') }
-  admitMember (member) { return this._h('admitMember', member) }
-  /** Registra la llave de cifrado de un miembro ya admitido (evita re-enrolarlo). */
-  setMemberEncPub (args) { return this._h('setMemberEncPub', args) }
-  setCaps (pub, caps) { return this._h('setCaps', { pub, caps }) }
-  setCapsMany (changes) { return this._h('setCapsMany', { changes }) }
-  setLabel (pub, label) { return this._h('setLabel', { pub, label }) }
-  removeMember (pub) { return this._h('removeMember', { pub }) }
-  handoverMaster (to, member = null) { return this._h('handoverMaster', { to, member }) }
-  renounceCaps (caps) { return this._h('renounceCaps', { caps }) }
-  absorbRenounce (record) { return this._h('absorbRenounce', { record }) }
-  adoptActa (acta) { return this._h('adoptActa', { acta }) }
-  /** Une ESTE perfil a la cuenta de otro (solo si nació para eso: `createProfile(n, { forVault: true })`). */
-  joinProfile (acta) { return this._h('joinProfile', { acta }) }
-  /** Marca este perfil como nacido para ADOPTAR la cuenta de otro (camino A: lo usa la bóveda). */
-  prepareForAdoption () { return this._h('prepareForAdoption') }
-  /** MI tarjeta de perfil: lo mínimo que un contacto necesita para cifrarme a todos mis
-   *  dispositivos (perfil, versión y llaves). Sin etiquetas ni permisos. */
-  profileCard () { return this._h('profileCard') }
-  /** Guarda la tarjeta de otra persona en su ficha de contacto (verificándola). */
-  adoptPeerCard (card) { return this._h('adoptPeerCard', { card }) }
-  /** La clave de contenido del perfil, abierta con la llave de cifrado de este dispositivo. */
-  contentKey () { return this._h('contentKey') }
-  /** Cifra con la clave de contenido del perfil (la privada de cifrado no sale del vault). */
-  sealContent (plaintext) { return this._h('sealContent', { plaintext }) }
-  /** Abre un sobre de contenido con el llavero del perfil. */
-  openContent (envelope) { return this._h('openContent', { envelope }) }
-  /** Rota la clave de contenido (corta el acceso al contenido FUTURO de quien ya no está). */
-  rotateContentKey () { return this._h('rotateContentKey') }
-  // Emparejar ESTE dispositivo con el vault del usuario (Fase 1)
-  enrollDevice (qr, { label = '', join = 'current' } = {}) { return this._h('vaultPair', { qr, label, join }) }
-  vaultStatus () { return this._h('vaultStatus') }
-  unpairDevice () { return this._h('vaultUnpair') }
-  vaultSign (payload) { return this._h('vaultSign', { payload }) }
-  vaultStore (method, args) { return this._h('vaultStore', { method, args }) }
-  listVaultDevices () { return this._h('listVaultDevices') }
-  getVaultCert () { return this._h('getVaultCert') }
-  vaultApprovals (op, args) { return this._h('vaultApprovals', { op, ...(args || {}) }) }
-  /** Los pedidos de TODAS las cuentas que aprueban, sin cambiar la activa. */
-  vaultApprovalsAll (args) { return this._h('vaultApprovalsAll', args || {}) }
-  onVault (handler) { return this.on('vault', handler) }
-  // Multi-perfil por dispositivo (crear/cambiar reinicializa con el nuevo perfil activo).
-  listProfiles () { return this._h('listProfiles') }
-  currentProfile () { return this._h('currentProfile') }
-  createProfile (name, { forVault = false } = {}) { return this._h('createProfile', { name, forVault }) }
-  switchProfile (id) { return this._h('switchProfile', { id }) }
-  renameProfile (id, name) { return this._h('renameProfile', { id, name }) }
-  deleteProfile (id) { return this._h('deleteProfile', { id }) }
-  mergeEndorsements (subject, endorsements, askerPubkey) {
-    return this._h('mergeEndorsements', { subject, endorsements, askerPubkey })
-  }
-  getRatingsForSubject (subject) { return this._h('getRatingsForSubject', { subject }) }
-  recordQuery (askerPubkey, subject) { return this._h('recordQuery', { askerPubkey, subject }) }
-  async setMyNickname (nickname) {
-    const result = await this._h('setMyNickname', { nickname })
-    return result
-  }
-  async updateMe (patch) { return this._h('updateMe', { patch }) }
-  getMe () { return this._h('getMe') }
-  publicMe () { return this._h('publicMe') }
-  /** Cómo fue el último empujón del perfil a la bóveda: `{ ok, at, error }`. */
-  profilePushState () { return this._h('profilePushState') }
-  getEncryptionPubkey () { return this._h('getEncryptionPubkey') }
-  encrypt (recipients, plaintext) { return this._h('encrypt', { recipients, plaintext }) }
-  decrypt (senderEncryptionPubkey, myToken, envelope) {
-    return this._h('decrypt', { senderEncryptionPubkey, myToken, envelope })
-  }
-  exportIdentity () { return this._h('exportIdentity') }
-  async importIdentity (blob) { return this._h('importIdentity', blob || {}) }
-
-  // Sync (Google Drive) no disponible headless — los handlers responden acorde.
-  syncConnect (clientId) { return this._h('syncConnect', { clientId }) }
-  syncDisconnect () { return this._h('syncDisconnect') }
-  syncUnlock (passphrase) { return this._h('syncUnlock', { passphrase }) }
-  syncLock () { return this._h('syncLock') }
-  syncStatus () { return this._h('syncStatus') }
-  syncNow () { return this._h('syncNow') }
-
-  onSync (handler) { return this.on('sync', handler) }
-  on (event, handler) {
-    if (!this._listeners.has(event)) this._listeners.set(event, new Set())
-    this._listeners.get(event).add(handler)
-    return () => this._listeners.get(event)?.delete(handler)
-  }
-  _emit (event, payload) {
-    const set = this._listeners.get(event)
-    if (!set) return
-    for (const h of set) { try { h(payload) } catch (e) { console.error(e) } }
-  }
 }
 
 export default Identity

package/vault/content.js

@@ -133,6 +133,33 @@ export async function encryptWithCek ({ cek, gen, plaintext }) {
   return { gen, iv: b64(iv), ct: b64(ct) }
 }
 
+/**
+ * Cifra BYTES con una clave simétrica, y devuelve bytes: `{ iv, ct }` como `Uint8Array`.
+ *
+ * Es la hermana binaria de `encryptWithCek`, para lo que no tiene por qué pasar por texto:
+ * un archivo de 5 MB cifrado y en base64 ocupa 6,7 MB, y si además iba dentro de un JSON en
+ * base64, 8,9 MB. Así viaja con lo que ocupa. Lo usa el transporte para los mensajes con
+ * archivos: el archivo se cifra con una CEK nueva y solo la CEK pasa por el sellado de
+ * siempre (`wrapForMember`, o la bóveda).
+ *
+ * @param {{ cek: string, bytes: Uint8Array }} o
+ * @returns {Promise<{ iv: Uint8Array, ct: Uint8Array }>}
+ */
+export async function encryptBytesWithCek ({ cek, bytes }) {
+  if (!(bytes instanceof Uint8Array)) throw new Error('encryptBytesWithCek: bytes must be a Uint8Array')
+  const k = await subtle.importKey('raw', fromB64(cek), { name: 'AES-GCM' }, false, ['encrypt'])
+  const iv = globalThis.crypto.getRandomValues(new Uint8Array(12))
+  const ct = new Uint8Array(await subtle.encrypt({ name: 'AES-GCM', iv }, k, bytes))
+  return { iv, ct }
+}
+
+/** El inverso de `encryptBytesWithCek`. Lanza si los bytes no son de esa clave o se tocaron. */
+export async function decryptBytesWithCek ({ cek, iv, ct }) {
+  if (!(iv instanceof Uint8Array) || !(ct instanceof Uint8Array)) throw new Error('decryptBytesWithCek: iv and ct must be Uint8Array')
+  const k = await subtle.importKey('raw', fromB64(cek), { name: 'AES-GCM' }, false, ['decrypt'])
+  return new Uint8Array(await subtle.decrypt({ name: 'AES-GCM', iv }, k, ct))
+}
+
 /** Cierra con la LLAVE DE LA CUENTA (generación `gen`): el sobre lleva la marca. */
 export async function sealAccount ({ cek, gen, plaintext }) {
   if (!Number.isInteger(gen) || gen < 1) throw new Error('sealAccount: the account key generation starts at 1')
@@ -243,5 +270,5 @@ export async function resealStale (value, { gen, reseal, now = Date.now() }) {
 
 export default {
   makeContentKey, wrapForMember, openWrap, makeGeneration, myContentKey,
-  encryptWithCek, sealAccount, decryptWithCek, decryptWithKeyring, CEK_ENVELOPE, isCekEnvelope, isLegacyCekEnvelope, LEGACY_UNMARKED_UNTIL, resealStale
+  encryptWithCek, encryptBytesWithCek, decryptBytesWithCek, sealAccount, decryptWithCek, decryptWithKeyring, CEK_ENVELOPE, isCekEnvelope, isLegacyCekEnvelope, LEGACY_UNMARKED_UNTIL, resealStale
 }

package/vault/core.js

@@ -24,7 +24,7 @@ import * as Content from './content.js'
 import { syncPeers, stampOf } from './peerSync.js'
 import { assertionBody, cleanScopes, claimsAllowed, ASSERTION_DEFAULT_TTL_MS, ASSERTION_MAX_TTL_MS } from './assertion.js'
 import { pubkeyId as pubkeyIdOf, signWithDevice } from './capabilities.js'
-import { enrollDevice as remoteEnroll, requestSign as remoteSign, requestStore as remoteStore, requestDevices as remoteDevices, requestRenew as remoteRenew, requestAdmin as remoteAdmin, requestApproval as remoteApproval, requestRenounce as remoteRenounce, checkMembership as remoteCheck } from './remote.js'
+import { enrollDevice as remoteEnroll, requestSign as remoteSign, requestStore as remoteStore, requestDevices as remoteDevices, requestRenew as remoteRenew, requestAdmin as remoteAdmin, requestApproval as remoteApproval, requestRenounce as remoteRenounce, checkMembership as remoteCheck, registerLocalVault } from './remote.js'
 
 export const KEY_STORAGE = 'dotrino.identity.keypair'
 export const ENC_KEY_STORAGE = 'dotrino.identity.enc-keypair'
@@ -791,6 +791,33 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
   const encKeyId = async (encPub) => (await pubkeyIdOf(encPub)).slice(0, 16)
 
   const loadVaultCert = () => { try { return JSON.parse(kv.getItem(VAULT_CERT_STORAGE) || 'null') } catch (_) { return null } }
+
+  /**
+   * LA BÓVEDA QUE CORRE AQUÍ MISMO. Cuando esta pestaña o esta extensión ES la bóveda de la
+   * cuenta (`startBrowserVault` de `@dotrino/vault`), administrarla y aprobar sus pedidos se
+   * hace con el MISMO protocolo que contra el binario, firmado con la llave del perfil y con
+   * el papel que la bóveda se da a sí misma; el viaje lo hace el camino local de
+   * `remote.js`, sin proxio.
+   *
+   * Vive en memoria y NO se guarda como emparejamiento: este navegador no tiene «una bóveda
+   * aparte», y fingirlo haría creer, por ejemplo, que lo suyo está respaldado en otro sitio.
+   * Lo pone quien levanta la bóveda (`setSelfVault`) y lo quita al pararla.
+   */
+  let selfLink = null
+  let selfLinkOff = null
+  /** El enlace con el que administrar: el emparejamiento si lo hay, y si no, la bóveda local. */
+  const adminLink = () => {
+    const v = loadVaultCert(); const device = loadVaultDevice()
+    if (v?.cert && device) return { v, device, self: false }
+    if (selfLink && publickeyJwkStr && masterKey()) {
+      return {
+        v: { cert: selfLink.cert, master: publickeyJwkStr, proxy: selfLink.proxy },
+        device: { publickey: publickeyJwkStr, privateKey: masterKey(), ...(pageMachine ? { machine: pageMachine } : {}) },
+        self: true
+      }
+    }
+    return null
+  }
   // DÓNDE CORRE ESTE APARATO (`machine.js`). Lo dice la PÁGINA al conectar (`setMachine`),
   // porque el iframe no ve si está dentro de una extensión o de la app nativa, y viaja con
   // cada pedido firmado a la bóveda para que su lista lo enseñe al día. Sin página que lo
@@ -3097,8 +3124,10 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
      * master, en su máquina.
      */
     async vaultAdmin ({ op, ...rest } = {}) {
-      const v = loadVaultCert(); const device = loadVaultDevice()
-      if (!v?.cert || !device) throw new Error('this device is not paired with a vault')
+      const link = adminLink()
+      if (!link) throw new Error('this device is not paired with a vault')
+      const { v, device } = link
+      if (link.self) return remoteAdmin({ master: v.master, proxy: v.proxy, device, cert: v.cert, op, ...rest })
       maybeRenewVaultCert()
       try { return await remoteAdmin({ master: v.master, proxy: v.proxy, device, cert: v.cert, op, ...rest, onRevoked: wipeVaultLink }) }
       catch (e) { return handleVaultError(e) }
@@ -3114,8 +3143,14 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
      */
     async vaultApprovals ({ op, id, profile = null, notify } = {}) {
       if (profile && profile !== currentPid) return approvalsDeOtroPerfil(profile, { op, id })
-      const v = loadVaultCert(); const device = loadVaultDevice()
-      if (!v?.cert || !device) throw new Error('this device is not paired with a vault')
+      const link = adminLink()
+      if (!link) throw new Error('this device is not paired with a vault')
+      const { v, device } = link
+      if (link.self) {
+        const r = await remoteApproval({ master: v.master, proxy: v.proxy, device, cert: v.cert, op, id, notify })
+        if (Array.isArray(r?.items)) return { ...r, items: await abrirContextos(r.items, currentPid) }
+        return r
+      }
       maybeRenewVaultCert()
       const ask = (cert) => remoteApproval({ master: v.master, proxy: v.proxy, device, cert, op, id, notify, onRevoked: wipeVaultLink })
       try {
@@ -3164,12 +3199,14 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
       try { maybeRenewVaultCert() } catch (_) {}
       const perfiles = loadProfiles()
       const salida = await Promise.all(perfiles.map(async (p) => {
-        const v = p.id === currentPid ? loadVaultCert() : vaultCertOf(p.id)
+        // La activa: su emparejamiento, o la bóveda que corre aquí mismo si no tiene otro.
+        const propia = p.id === currentPid && !loadVaultCert() ? adminLink() : null
+        const v = p.id === currentPid ? (loadVaultCert() || propia?.v || null) : vaultCertOf(p.id)
         if (!v?.cert) return null                                             // sin bóveda: no es asunto suyo
         if (!(v.cert.scope || []).includes('vault:approve')) return null      // no aprueba: tampoco
         const base = { profile: p.id, name: p.name || '', current: p.id === currentPid }
         let device = null
-        try { device = p.id === currentPid ? loadVaultDevice() : await signerForProfile(p.id) } catch (e) {
+        try { device = p.id === currentPid ? (propia?.device || loadVaultDevice()) : await signerForProfile(p.id) } catch (e) {
           return { ...base, items: [], error: e?.code || 'no-key' }
         }
         if (!device) return { ...base, items: [], error: 'no-key' }
@@ -3210,6 +3247,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
 
     /** ¿Puede ESTE dispositivo aprobar pedidos? Mismo criterio que `canAdminVault`. */
     async canApproveVault () {
+      if (!loadVaultCert() && selfLink) return (adminLink()?.v.cert.scope || []).includes('vault:approve')
       if (certDesfasadoDelActa()) { try { await renovarCert() } catch (_) {} }
       const v = loadVaultCert()
       return !!v?.cert && (v.cert.scope || []).includes('vault:approve')
@@ -3225,6 +3263,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
       // renovarlo aquí mismo. Disparar la renovación y contestar «no» dejaba la consola
       // escondida hasta la siguiente visita, y el dueño —que acababa de dar el permiso— no
       // tenía forma de saber que solo faltaba recargar.
+      if (!loadVaultCert() && selfLink) return (adminLink()?.v.cert.scope || []).includes('vault:admin')
       if (certDesfasadoDelActa()) { try { await renovarCert() } catch (_) {} }
       const v = loadVaultCert()
       return !!v?.cert && (v.cert.scope || []).includes('vault:admin')
@@ -3233,6 +3272,13 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
     // Lista (solo lectura) de dispositivos enrolados en tu vault.
     async listVaultDevices () {
       const v = loadVaultCert(); const device = loadVaultDevice()
+      // ESTE NAVEGADOR ES LA BÓVEDA: la lista sale de ella, por el camino local, con lo mismo
+      // que da el binario (qué versión corre cada aparato, dónde corre, si le llegan avisos).
+      // El acta es la nuestra: no hay nada que adoptar.
+      if ((!v?.cert || !device) && adminLink()?.self) {
+        const self = adminLink()
+        return remoteDevices({ master: self.v.master, proxy: self.v.proxy, device: self.device, cert: self.v.cert, sinceSeq: loadActa()?.seq ?? 0 })
+      }
       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í
@@ -3640,6 +3686,19 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
      * `handlers`) porque ninguna aplicación tiene por qué poder instalar una identidad.
      */
     adoptLogin,
+    /**
+     * La bóveda que corre aquí mismo se presenta (`startBrowserVault`): `{ cert, proxy, open }`
+     * —`open` es su canal local, ver `registerLocalVault` en `remote.js`—, o `null` al
+     * pararse (ver `adminLink`). En el núcleo y no en `handlers`: ninguna
+     * aplicación tiene por qué poder decir dónde está la bóveda de esta cuenta.
+     */
+    setSelfVault (self = null) {
+      if (self && (!self.cert || typeof self.proxy !== 'string' || typeof self.open !== 'function')) throw new Error('setSelfVault: cert, proxy and open are required')
+      try { selfLinkOff?.() } catch (_) {}
+      selfLinkOff = null
+      selfLink = self ? { cert: self.cert, proxy: self.proxy } : null
+      if (self && publickeyJwkStr) selfLinkOff = registerLocalVault(publickeyJwkStr, self.open)
+    },
     onSyncStatus (fn) { if (sync) sync.onStatus(fn) },
     onVaultEvent (fn) { vaultListeners.add(fn); return () => vaultListeners.delete(fn) }
   }

package/vault/facade.js

@@ -0,0 +1,200 @@
+/**
+ * LA IDENTIDAD COMO OBJETO, sobre un core ya creado (`createIdentityCore`).
+ *
+ * Es la misma API que usa el binario (`@dotrino/identity/node`, que la extiende creando el
+ * core sobre archivos) y la que necesita la bóveda del navegador: allí el core ya lo creó el
+ * iframe o la extensión, y la bóveda lo envuelve con esto. Una sola envoltura, para que la
+ * bóveda llame a lo mismo en las tres versiones.
+ */
+export class IdentityFacade {
+  /** @param {object} [core]  el resultado de `createIdentityCore` */
+  constructor (core = null) {
+    this._core = core
+    this._listeners = new Map()
+    if (core) this._wire()
+  }
+
+  /** Engancha los eventos del core a `on()`. Lo llama quien pone el core. */
+  _wire () {
+    this._core.onSyncStatus?.((payload) => this._emit('sync', payload))
+    this._core.onVaultEvent?.((payload) => this._emit('vault', payload))
+  }
+
+  destroy () { this._core = null }
+
+  get me () { return this._core?.me || null }
+
+  // ----- candado de la maestra -----
+  /** `true` si la maestra está sellada: esta identidad NO puede firmar nada. */
+  get masterLocked () { return !!this._core?.masterLocked }
+  /** Sella la maestra que ya existe (se llama al abrir el perfil, con la llave en la mano). */
+  sealMasterKey () { return this._core?.sealMasterKey?.() }
+  /** Vuelve a cargar el par tras abrir el candado, sin reabrir la identidad. */
+  reloadMasterKey () { return this._core?.reloadMasterKey?.() }
+  /** Ver `core.js`: al abrir, los aparatos muertos salen del acta en una sola. */
+  pruneExpiredDevices (now) { return this._core?.pruneExpiredDevices?.(now) }
+
+  _h (method, params = {}) {
+    if (!this._core) throw new Error('Identity not ready — call ready()/connect() first')
+    return this._core.handlers[method](params)
+  }
+
+  // ----- API pública (espeja src/index.js) -----
+
+  makeChallenge () { return this._h('makeChallenge') }
+  signChallenge (nonce) { return this._h('signChallenge', { nonce }) }
+  verifyResponse ({ nonce, publickey, signature, encryptionPubkey }) {
+    return this._h('verifyResponse', { nonce, publickey, signature, encryptionPubkey })
+  }
+  getPeer (publickey) { return this._h('getPeer', { publickey }) }
+  setNickname (publickey, nickname) { return this._h('setNickname', { publickey, nickname }) }
+  setBlocked (publickey, blocked) { return this._h('setBlocked', { publickey, blocked }) }
+  setRating (publickey, rating, notes) { return this._h('setRating', { publickey, rating, notes }) }
+  listPeers () { return this._h('listPeers') }
+  forgetPeer (publickey) { return this._h('forgetPeer', { publickey }) }
+  addContact ({ publickey, nickname, encryptionPubkey, lastToken, notes } = {}) {
+    return this._h('addContact', { publickey, nickname, encryptionPubkey, lastToken, notes })
+  }
+  updateContact (publickey, patch) { return this._h('updateContact', { publickey, patch }) }
+  removeContact (publickey) { return this._h('removeContact', { publickey }) }
+  listContacts () { return this._h('listContacts') }
+  signData (data) { return this._h('signData', { data }) }
+  /**
+   * Prueba firmada con destinatario y vigencia (ver `vault/assertion.js`). Un servicio en
+   * Node la pide igual que una app: `{ audience, nonce, scopes?, ttlMs? }`.
+   */
+  async requestAssertion ({ audience, nonce, scopes, ttlMs } = {}) {
+    const { assertion } = await this._h('requestAssertion', { audience, nonce, scopes, ttlMs })
+    return assertion
+  }
+  // Delegación de capacidad (sub-clave de dispositivo con scope/exp/revocación)
+  signDelegation (sub, scope, opts = {}) { return this._h('signDelegation', { sub, scope, ...opts }) }
+  revokeDelegation (nonce) { return this._h('revokeDelegation', { nonce }) }
+  /** Quitar el DISPOSITIVO: retira todos sus certificados vigentes, no solo uno. */
+  revokeDevice (sub) { return this._h('revokeDevice', { sub }) }
+  listDelegations () { return this._h('listDelegations') }
+  // Acta de perfil (qué llaves son del perfil y qué puede cada una; ver acta-de-perfil.md)
+  profileActa () { return this._h('profileActa') }
+  /** La cadena de selladores, para mandarla con una firma (ver `vault/acta.js`). */
+  sealerChain () { return this._h('sealerChain') }
+  profileMembers () { return this._h('profileMembers') }
+  /**
+   * Quien SELLA SOBRES (la bóveda) registra aquí cómo estrenar su llave de sellado: se
+   * llama al sellar cada acta, porque esa llave rota con el acta (§8.9 de
+   * `dotrino-vault/docs/secretos-sellados.md`). Va por aquí y no por el iframe porque
+   * este puente es en-proceso: al navegador no se le puede pasar una función, y tampoco
+   * la necesita — no sella secretos de nadie.
+   */
+  /** Abre un sobre sellado A ESTE aparato (envoltura + sobre). Ver `core.js`. */
+  openSealedValue (wrap, envelope) { return this._h('openSealedValue', { wrap, envelope }) }
+  /** Re-envuelve para otro miembro una llave que este aparato ya puede abrir. */
+  rewrapFor (wrap, encPub) { return this._h('rewrapFor', { wrap, encPub }) }
+  setSealKeyProvider (provider) { return this._h('setSealKeyProvider', { provider }) }
+  /** Estrena la llave de sellado en un acta nueva, sin tocar a ningún miembro. */
+  rotateSealKey () { return this._h('rotateSealKey') }
+  /** Con qué llave se comprueban los sobres que se firmaron con el acta `seq`. */
+  sealKeyAt (seq) { return this._h('sealKeyAt', { seq }) }
+  myMembership () { return this._h('myMembership') }
+  /**
+   * La CADENA de actas desde `sinceSeq` (para que un dispositivo que estuvo apagado
+   * compruebe el encadenamiento en vez de tragarse un salto a ciegas).
+   *
+   * Vivía en el núcleo pero NO estaba aquí, así que `identity.actaHistory` era
+   * `undefined` en el daemon: al pedir la lista de dispositivos con un `sinceSeq`
+   * —que es lo que manda SIEMPRE un navegador ya emparejado— reventaba con
+   * «is not a function», la bóveda respondía error, y el aparato NUNCA volvía a
+   * sincronizar su acta. Se quedaba con la copia del día que emparejó.
+   */
+  actaHistory (opts) { return this._h('actaHistory', opts || {}) }
+  isMaster () { return this._h('isMaster') }
+  admitMember (member) { return this._h('admitMember', member) }
+  /** Registra la llave de cifrado de un miembro ya admitido (evita re-enrolarlo). */
+  setMemberEncPub (args) { return this._h('setMemberEncPub', args) }
+  setCaps (pub, caps) { return this._h('setCaps', { pub, caps }) }
+  setCapsMany (changes) { return this._h('setCapsMany', { changes }) }
+  setLabel (pub, label) { return this._h('setLabel', { pub, label }) }
+  removeMember (pub) { return this._h('removeMember', { pub }) }
+  handoverMaster (to, member = null) { return this._h('handoverMaster', { to, member }) }
+  renounceCaps (caps) { return this._h('renounceCaps', { caps }) }
+  absorbRenounce (record) { return this._h('absorbRenounce', { record }) }
+  adoptActa (acta) { return this._h('adoptActa', { acta }) }
+  /** Une ESTE perfil a la cuenta de otro (solo si nació para eso: `createProfile(n, { forVault: true })`). */
+  joinProfile (acta) { return this._h('joinProfile', { acta }) }
+  /** Marca este perfil como nacido para ADOPTAR la cuenta de otro (camino A: lo usa la bóveda). */
+  prepareForAdoption () { return this._h('prepareForAdoption') }
+  /** MI tarjeta de perfil: lo mínimo que un contacto necesita para cifrarme a todos mis
+   *  dispositivos (perfil, versión y llaves). Sin etiquetas ni permisos. */
+  profileCard () { return this._h('profileCard') }
+  /** Guarda la tarjeta de otra persona en su ficha de contacto (verificándola). */
+  adoptPeerCard (card) { return this._h('adoptPeerCard', { card }) }
+  /** La clave de contenido del perfil, abierta con la llave de cifrado de este dispositivo. */
+  contentKey () { return this._h('contentKey') }
+  /** Cifra con la clave de contenido del perfil (la privada de cifrado no sale del vault). */
+  sealContent (plaintext) { return this._h('sealContent', { plaintext }) }
+  /** Abre un sobre de contenido con el llavero del perfil. */
+  openContent (envelope) { return this._h('openContent', { envelope }) }
+  /** Rota la clave de contenido (corta el acceso al contenido FUTURO de quien ya no está). */
+  rotateContentKey () { return this._h('rotateContentKey') }
+  // Emparejar ESTE dispositivo con el vault del usuario (Fase 1)
+  enrollDevice (qr, { label = '', join = 'current' } = {}) { return this._h('vaultPair', { qr, label, join }) }
+  vaultStatus () { return this._h('vaultStatus') }
+  unpairDevice () { return this._h('vaultUnpair') }
+  vaultSign (payload) { return this._h('vaultSign', { payload }) }
+  vaultStore (method, args) { return this._h('vaultStore', { method, args }) }
+  listVaultDevices () { return this._h('listVaultDevices') }
+  getVaultCert () { return this._h('getVaultCert') }
+  vaultApprovals (op, args) { return this._h('vaultApprovals', { op, ...(args || {}) }) }
+  /** Los pedidos de TODAS las cuentas que aprueban, sin cambiar la activa. */
+  vaultApprovalsAll (args) { return this._h('vaultApprovalsAll', args || {}) }
+  onVault (handler) { return this.on('vault', handler) }
+  // Multi-perfil por dispositivo (crear/cambiar reinicializa con el nuevo perfil activo).
+  listProfiles () { return this._h('listProfiles') }
+  currentProfile () { return this._h('currentProfile') }
+  createProfile (name, { forVault = false } = {}) { return this._h('createProfile', { name, forVault }) }
+  switchProfile (id) { return this._h('switchProfile', { id }) }
+  renameProfile (id, name) { return this._h('renameProfile', { id, name }) }
+  deleteProfile (id) { return this._h('deleteProfile', { id }) }
+  mergeEndorsements (subject, endorsements, askerPubkey) {
+    return this._h('mergeEndorsements', { subject, endorsements, askerPubkey })
+  }
+  getRatingsForSubject (subject) { return this._h('getRatingsForSubject', { subject }) }
+  recordQuery (askerPubkey, subject) { return this._h('recordQuery', { askerPubkey, subject }) }
+  async setMyNickname (nickname) {
+    const result = await this._h('setMyNickname', { nickname })
+    return result
+  }
+  async updateMe (patch) { return this._h('updateMe', { patch }) }
+  getMe () { return this._h('getMe') }
+  publicMe () { return this._h('publicMe') }
+  /** Cómo fue el último empujón del perfil a la bóveda: `{ ok, at, error }`. */
+  profilePushState () { return this._h('profilePushState') }
+  getEncryptionPubkey () { return this._h('getEncryptionPubkey') }
+  encrypt (recipients, plaintext) { return this._h('encrypt', { recipients, plaintext }) }
+  decrypt (senderEncryptionPubkey, myToken, envelope) {
+    return this._h('decrypt', { senderEncryptionPubkey, myToken, envelope })
+  }
+  exportIdentity () { return this._h('exportIdentity') }
+  async importIdentity (blob) { return this._h('importIdentity', blob || {}) }
+
+  // Sync (Google Drive) no disponible headless — los handlers responden acorde.
+  syncConnect (clientId) { return this._h('syncConnect', { clientId }) }
+  syncDisconnect () { return this._h('syncDisconnect') }
+  syncUnlock (passphrase) { return this._h('syncUnlock', { passphrase }) }
+  syncLock () { return this._h('syncLock') }
+  syncStatus () { return this._h('syncStatus') }
+  syncNow () { return this._h('syncNow') }
+
+  onSync (handler) { return this.on('sync', handler) }
+  on (event, handler) {
+    if (!this._listeners.has(event)) this._listeners.set(event, new Set())
+    this._listeners.get(event).add(handler)
+    return () => this._listeners.get(event)?.delete(handler)
+  }
+  _emit (event, payload) {
+    const set = this._listeners.get(event)
+    if (!set) return
+    for (const h of set) { try { h(payload) } catch (e) { console.error(e) } }
+  }
+}
+
+export default IdentityFacade

package/vault/index.html

@@ -155,7 +155,17 @@
   <script type="importmap">
   { "imports": {
     "@dotrino/proxy-client": "./vendor/proxy-client/index.js",
+    "@dotrino/proxy-client/sealing": "./vendor/proxy-client/sealing.js",
     "@dotrino/vault": "./vendor/vault/index.js",
+    "@dotrino/vault/browser": "./vendor/vault/browser.js",
+    "@dotrino/compat": "./vendor/compat/index.js",
+    "@dotrino/compat/ranges": "./vendor/compat/ranges.js",
+    "@dotrino/roadmap": "./vendor/roadmap/index.js",
+    "@dotrino/passmanager": "./vendor/passmanager/index.js",
+    "@dotrino/passmanager/sealed": "./vendor/passmanager/sealed/index.js",
+    "@dotrino/store/core": "./vendor/store/core.js",
+    "@dotrino/identity/facade": "./facade.js",
+    "@dotrino/identity/machine": "./machine.js",
     "@dotrino/vault/password-logins": "./vendor/vault/passwordLogins.js",
     "@dotrino/vault/login-client": "./vendor/vault/loginClient.js",
     "@dotrino/opaque": "./vendor/opaque/src/index.js",