@dotrino/identity 0.114.1 → 0.116.0

package/package.json

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

package/src/index.js

@@ -7,6 +7,8 @@
  * use this library share identity even across different origins.
  */
 
+import { browserMachine } from '../vault/machine.js'
+
 const DEFAULT_VAULT_URL = 'https://id.dotrino.com/'
 
 let singleton = null
@@ -125,6 +127,9 @@ export class Identity {
           this._me = msg.me || null
           this._locked = !!msg.locked
           this._readyResolve(this)
+          // Dónde corre esta página (`vault/machine.js`), para los pedidos a la bóveda. Un
+          // iframe viejo no conoce el método: no pasa nada, solo no se manda.
+          this._call('setMachine', { machine: browserMachine() }).catch(() => {})
           return
         }
 
@@ -427,7 +432,9 @@ export class Identity {
    * @returns {Promise<{ ok:boolean, deviceId:string, master:string, exp:number, scope:string[] }>}
    */
   async enrollDevice (qr, { label = '', join = 'current' } = {}) {
-    return this._call('vaultPair', { qr, label, join }, 200000)
+    // DÓNDE CORRE se mira AQUÍ, en la página, y no dentro del iframe: el iframe no ve si la
+    // página es una extensión o la app nativa (`vault/machine.js`).
+    return this._call('vaultPair', { qr, label, join, machine: browserMachine() }, 200000)
   }
 
   /** Estado de emparejamiento: { paired, deviceId?, master?, scope?, exp?, pairedAt? }. */
@@ -853,4 +860,5 @@ export { makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice, ve
 // PARA QUIÉN vale una firma, y hasta cuándo. Verificar NO necesita el iframe ni la clave
 // de nadie, así que un servicio puede importarlo suelto (`@dotrino/identity/assertion`, que
 // no arrastra el cliente del vault); aquí se reexporta para quien ya tiene esto cargado.
+export { cleanMachine, machineLine, browserMachine, MACHINE_KINDS } from '../vault/machine.js'
 export { verifyAssertion, verifySignedFor, newAssertionNonce, cleanScopes, claimsAllowed, assertionBody, SCOPES, SCOPE_CLAIMS, ASSERTION_MAX_TTL_MS, ASSERTION_DEFAULT_TTL_MS, ASSERTION_MAX_SKEW_MS } from '../vault/assertion.js'

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/acta.js

@@ -36,6 +36,8 @@
  */
 import { canonicalStringify } from './core.js'
 import { signWithDevice, verifyDeviceSig, verifyDelegation, pubkeyId } from './capabilities.js'
+import { cleanMachine } from './machine.js'
+export { cleanMachine }
 
 export const ACTA_V = 5
 
@@ -816,7 +818,9 @@ export async function applyChanges (acta, changes, { by, now = Date.now(), sealP
           addedAt: now,
           cert: m.cert || null,
           // Puente con la identidad que este miembro traía de antes (ver makeContinuity).
-          ...(m.continuity ? { continuity: m.continuity } : {})
+          ...(m.continuity ? { continuity: m.continuity } : {}),
+          // DÓNDE CORRE (`machine.js`): lo que dijo al emparejar, para reconocerlo en la lista.
+          ...(cleanMachine(m.machine) ? { machine: cleanMachine(m.machine) } : {})
         })
         break
       }

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,7 +791,43 @@ 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
+  // diga (Node, un cliente viejo) no se manda nada: mejor ningún dato que uno equivocado.
+  let pageMachine = null
   const loadVaultDevice = () => {
+    const d = loadVaultDeviceKey()
+    return d && pageMachine ? { ...d, machine: pageMachine } : d
+  }
+  const loadVaultDeviceKey = () => {
     try {
       const d = JSON.parse(kv.getItem(VAULT_DEVICE_STORAGE) || 'null')
       if (!d) return null
@@ -1293,7 +1329,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
    * 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 = '' }) {
+  async function pairWithVault ({ qr, label = '', machine = undefined }) {
     // 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`
@@ -1307,7 +1343,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
     const continuity = (mine && mine.members.length === 1 && !isPendingJoin())
       ? await Acta.makeContinuity({ member: publickeyJwkStr, from: mine.profileId, privateKey: masterKey() })
       : 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 }) })
+    const res = await remoteEnroll({ qr, device, continuity, encPub: encPublickeyJwkStr, label: label || me?.nickname || '', machine: machine === undefined && pageMachine ? pageMachine : machine, 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.
@@ -2560,6 +2596,8 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
         isService: !!m.cn,
         caps: Acta.effectiveCaps(acta, m.pub, pend),
         addedAt: m.addedAt || null,
+        // Dónde corre, según dijo al emparejarse (`machine.js`). `null` si entró antes.
+        machine: m.machine || null,
         isMe: m.pub === publickeyJwkStr,
         isMaster: Acta.canSeal(acta, m.pub),
         // La llave de CIFRADO del miembro y, derivado, si se le puede envolver algo.
@@ -2605,7 +2643,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
      * Admite un miembro (solo el master). El cert lo emite quien llama, antes o después.
      * `continuity`: si esa identidad ya existía por su cuenta, su puente firmado (F3).
      */
-    async admitMember ({ pub, encPub = null, label = '', cn = null, caps = null, cert = null, continuity = null } = {}) {
+    async admitMember ({ pub, encPub = null, label = '', cn = null, caps = null, cert = null, continuity = null, machine = null } = {}) {
       // `cn`: si viene, este miembro es un SERVICIO: abre el cajón de secretos de ESE nombre
       // por llevarlo, sin permiso aparte, y no ve nada más del usuario. Sin `cn` es un dispositivo.
       const finales = caps || (cn ? [] : ['store', 'read'])
@@ -2622,7 +2660,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
         const mine = encPub ? await myCek() : null
         if (mine) wrap = { op: 'wrap', gen: mine.gen, pub, wrap: await Content.wrapForMember({ cek: mine.cek, memberEncPub: encPub }) }
       } catch (_) { wrap = null }
-      const acta = await sealChanges([{ op: 'admit', member: { pub, encPub, label, cn, caps: finales, cert, continuity } }, ...(wrap ? [wrap] : [])])
+      const acta = await sealChanges([{ op: 'admit', member: { pub, encPub, label, cn, caps: finales, cert, continuity, machine } }, ...(wrap ? [wrap] : [])])
       return { ok: true, seq: acta.seq, wrapped: !!wrap }
     },
 
@@ -2898,8 +2936,8 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
      *                   master: si esta cuenta ya la manda otra bóveda, no hay nada que
      *                   regalar y falla en voz alta.
      */
-    async vaultPair ({ qr, label = '', join = 'current' }) {
-      if (join === 'adopt') return handlers.vaultAdopt({ qr, label })
+    async vaultPair ({ qr, label = '', join = 'current', machine = undefined }) {
+      if (join === 'adopt') return handlers.vaultAdopt({ qr, label, machine })
       // 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
@@ -2929,7 +2967,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
         }
       }
       try {
-        return await pairWithVault({ qr, label })
+        return await pairWithVault({ qr, label, machine })
       } 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
@@ -2953,7 +2991,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
      * bóveda, este aparato no puede regalar lo que no tiene; el traspaso se hace desde la
      * que manda hoy.
      */
-    async vaultAdopt ({ qr, label = '' } = {}) {
+    async vaultAdopt ({ qr, label = '', machine = undefined } = {}) {
       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')
@@ -2963,6 +3001,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
         qr,
         device,
         intent: 'adopt',
+        machine,
         profileId: mine.profileId,
         encPub: encPublickeyJwkStr,
         label: label || me?.nickname || '',
@@ -3009,6 +3048,15 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
       return { ok: true, pending: true }
     },
 
+    /**
+     * La página dice dónde corre (`machine.js`); se manda con los pedidos a la bóveda.
+     * @param {any} [args]
+     */
+    async setMachine ({ machine } = {}) {
+      pageMachine = Acta.cleanMachine(machine)
+      return { ok: true }
+    },
+
     async vaultStatus () {
       const v = loadVaultCert()
       if (!v?.cert) return { paired: false }
@@ -3076,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) }
@@ -3093,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 {
@@ -3143,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' }
@@ -3189,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')
@@ -3204,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')
@@ -3212,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í
@@ -3619,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) }
   }