@dotrino/identity 0.114.1 → 0.116.0

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",

package/vault/machine.js

@@ -0,0 +1,95 @@
+/**
+ * QUÉ MÁQUINA ES CADA APARATO: dónde corre, y nada más.
+ *
+ * En la lista de aparatos de la bóveda solo había un ID (`AB12-CD34`), una etiqueta que pone
+ * el propio aparato —muchas veces el apodo del usuario, igual en todos— y la fecha de alta.
+ * Con tres navegadores y dos agentes no había forma de saber cuál era cuál (dueño,
+ * 2026-10-15). Esto es lo que lo distingue a simple vista:
+ *
+ *   · `kind` — qué es: `node` (un agente o un comando), `browser`, `extension`, `ios`, `android`.
+ *   · `os`   — el sistema donde corre (`Linux 7.0.0`, `Windows`, `macOS`, `Android 14`).
+ *   · `name` — en Node, el hostname; en un navegador, el navegador (`Chrome`). Un navegador no
+ *     sabe el nombre de la máquina, y lo que no se sabe no se inventa.
+ *
+ * Lo DICE el aparato y va dentro de lo que firma, así que nadie más puede escribirlo por él.
+ * Tampoco es una prueba de nada: un aparato puede llamarse como quiera. Sirve para reconocerlo,
+ * no para decidir — ninguna puerta mira esto.
+ *
+ * Una sola pieza para las dos puntas: lo limpia igual quien lo manda y quien lo guarda (el acta,
+ * la bóveda), para que un campo de más o una cadena de un megabyte no entren por ningún lado.
+ */
+
+export const MACHINE_KINDS = ['node', 'browser', 'extension', 'ios', 'android']
+
+const clip = (s, n) => (typeof s === 'string' ? s.replace(/[\u0000-\u001f\u007f]/g, '').trim().slice(0, n) : '')
+
+/**
+ * Lo deja en la forma de siempre, o `null` si no dice nada que valga. Nunca lanza: un aparato
+ * viejo o raro no puede tumbar un emparejamiento por cómo describe su máquina.
+ * @param {any} raw
+ * @returns {{ kind: string, os: string, name: string } | null}
+ */
+export function cleanMachine (raw) {
+  if (!raw || typeof raw !== 'object') return null
+  const kind = MACHINE_KINDS.includes(raw.kind) ? raw.kind : ''
+  const os = clip(raw.os, 40)
+  const name = clip(raw.name, 64)
+  if (!kind && !os && !name) return null
+  return { kind, os, name }
+}
+
+/** Una línea para enseñarlo: `node · Linux 7.0.0 · mi-pc`. Vacía si no hay nada. */
+export function machineLine (m) {
+  const c = cleanMachine(m)
+  return c ? [c.kind, c.os, c.name].filter(Boolean).join(' · ') : ''
+}
+
+/** ¿Dicen lo mismo? Para no reescribir un archivo cada vez que un aparato repite lo de siempre. */
+export const sameMachine = (a, b) => machineLine(a) === machineLine(b)
+
+/** @type {Array<[RegExp, (v: string) => string]>} */
+const UA_OS = [
+  [/Android ([\d.]+)/, (v) => 'Android ' + v.split('.')[0]],
+  [/(?:iPhone|iPad|iPod).*? OS (\d+)/, (v) => 'iOS ' + v],
+  [/Windows NT/, () => 'Windows'],
+  [/CrOS/, () => 'ChromeOS'],
+  [/Mac OS X/, () => 'macOS'],
+  [/Linux/, () => 'Linux']
+]
+/** @type {Array<[RegExp, string]>} */
+const UA_BROWSER = [
+  [/Edg\//, 'Edge'], [/OPR\//, 'Opera'], [/Firefox\//, 'Firefox'], [/SamsungBrowser\//, 'Samsung Internet'],
+  [/Chrome\//, 'Chrome'], [/Safari\//, 'Safari']
+]
+
+/**
+ * La máquina de ESTE navegador. `env` se inyecta en las pruebas; en la página es `globalThis`.
+ * Lo nativo se reconoce por el puente de `dotrino-native` (`DotrinoNative.platform()`), la
+ * extensión por tener `chrome.runtime.id`, y el resto es un navegador.
+ * @param {any} [env]
+ */
+export function browserMachine (env = globalThis) {
+  /** @type {any} */
+  const nav = env?.navigator || {}
+  const ua = String(nav.userAgent || '')
+  // Node también tiene `navigator` (`Node.js/22`): no es un navegador, y su máquina la dice
+  // quien sabe mirarla (`selfMachine` de `@dotrino/vault`). Aquí no se inventa.
+  if (env?.process?.versions?.node || !ua || ua.startsWith('Node.js')) return null
+  let kind = 'browser'
+  try {
+    const p = env?.DotrinoNative?.platform?.()
+    if (p === 'ios' || p === 'android') kind = p
+    else if (env?.chrome?.runtime?.id) kind = 'extension'
+  } catch (_) { /* un puente roto no cambia qué navegador es: se queda en `browser` */ }
+  let os = ''
+  for (const [re, fmt] of UA_OS) { const m = ua.match(re); if (m) { os = fmt(m[1] || ''); break } }
+  // iPadOS se presenta como un Mac de escritorio: lo delata la pantalla táctil.
+  if (os === 'macOS' && nav.maxTouchPoints > 1) os = 'iPadOS'
+  let name = ''
+  if (kind === 'browser' || kind === 'extension') {
+    for (const [re, n] of UA_BROWSER) if (re.test(ua)) { name = n; break }
+  }
+  return cleanMachine({ kind, os, name })
+}
+
+export default { MACHINE_KINDS, cleanMachine, machineLine, sameMachine, browserMachine }

package/vault/remote.js

@@ -15,6 +15,7 @@
  */
 import { makeDeviceKey, signWithDevice, verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from './capabilities.js'
 import { checkVaultReply } from './acta.js'
+import { cleanMachine, browserMachine } from './machine.js'
 
 const MSG = {
   HELLO: 'vault.hello',
@@ -130,7 +131,7 @@ async function askVault (client, qr) {
  * @param {number} [opts.approveTimeoutMs]  Espera de la aprobación humana (def 3 min).
  * @returns {Promise<{device, cert, master:string, proxy:string, deviceId:string, account:string}>}
  */
-export async function enrollDevice ({ qr, device, onChallenge, label = '', continuity = null, encPub = null, approveTimeoutMs = 180000, intent = 'join', profileId = null, onAdopt = null } = {}) {
+export async function enrollDevice ({ qr, device, onChallenge, label = '', continuity = null, encPub = null, approveTimeoutMs = 180000, intent = 'join', profileId = null, onAdopt = null, machine = undefined } = {}) {
   if (!qr?.sn || !(qr.iss || qr.conn)) throw new Error('invalid qr: missing vault or nonce')
   const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
   const client = new WebSocketProxyClient({ url: qr.proxy || 'wss://proxy.dotrino.com', enableWebRTC: false, autoReconnect: false })
@@ -162,12 +163,16 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', conti
     // rechaza el que no coincida con el modo con el que ella abrió el emparejamiento. Así
     // ninguno de los dos puede hacer, a mitad de camino, algo distinto de lo que el humano
     // vio anunciado en las dos pantallas.
+    // DÓNDE CORRE (`machine.js`), para que la bóveda lo reconozca en su lista. Quien llama
+    // puede pasarlo (lo sabe mejor); si no, se mira el navegador. `null` es no decir nada.
+    const maquina = cleanMachine(machine === undefined ? browserMachine() : machine)
     const adopting = intent === 'adopt'
     if (adopting && typeof onAdopt !== 'function') throw new Error('enrollDevice(adopt): missing onAdopt')
     const data = {
       op: 'enroll', dpub: dev.publickey, token: qr.token || qr.sn, sn: qr.sn, commit, label, ts: Date.now(), intent,
       ...(adopting && profileId ? { profileId } : {}),
-      ...(continuity ? { continuity } : {}), ...(encPub ? { encPub } : {})
+      ...(continuity ? { continuity } : {}), ...(encPub ? { encPub } : {}),
+      ...(maquina ? { machine: maquina } : {})
     }
     // `dev.sign`: la llave vive fuera (el chip del teléfono) y solo se le pide la firma.
     const { signature } = await signWithDevice({ privateJwk: dev.privateJwk, privateKey: dev.privateKey, publickey: dev.publickey, sign: dev.sign, data })
@@ -276,14 +281,56 @@ function vaultError (p) {
   return e
 }
 
-async function vaultRpc ({ master, proxy, device, cert, acta = null, sendType, okType, data, onRevoked, timeoutMs = 15000 }) {
-  if (!master || !proxy || !(device?.privateJwk || device?.privateKey || typeof device?.sign === 'function') || !cert) throw new Error('missing pairing data')
+/**
+ * LA BÓVEDA DE ESTE MISMO NAVEGADOR, sin dar la vuelta por el proxio.
+ *
+ * Cuando esta pestaña o esta extensión ES la bóveda (`@dotrino/vault`, `startBrowserVault`),
+ * lo que el aparato le pide a su bóveda —administrar, aprobar, firmar— va directo al núcleo
+ * que corre aquí. Es el mostrador local del binario en el navegador: el MISMO protocolo, la
+ * misma firma y el mismo certificado, comprobados igual. Alcanzar el atajo no autoriza nada.
+ *
+ * `open(onReply)` → `{ send(payload), close() }`. Lo registra quien levanta la bóveda.
+ */
+const localVaults = new Map()
+export function registerLocalVault (master, open) {
+  if (typeof master !== 'string' || typeof open !== 'function') throw new Error('registerLocalVault: master and open are required')
+  localVaults.set(master, open)
+  return () => { if (localVaults.get(master) === open) localVaults.delete(master) }
+}
+
+/** Un cliente con la forma del del proxio que habla con la bóveda local. */
+function localClient (open) {
+  const handlers = new Set()
+  const chan = open((reply) => { for (const h of [...handlers]) { try { h('local', reply) } catch (_) {} } })
+  return {
+    connect: async () => {},
+    identifyAs: async () => {},
+    on (ev, fn) {
+      if (ev !== 'message') return () => {}
+      handlers.add(fn)
+      return () => handlers.delete(fn)
+    },
+    sendByPubkey (_to, payload) { chan.send(payload) },
+    close () { handlers.clear(); chan.close() }
+  }
+}
+
+/** El cliente para hablar con `master`: el local si esa bóveda corre aquí, y si no el del proxio. */
+async function clientFor (proxy, master) {
+  const open = master ? localVaults.get(master) : null
+  if (open) return localClient(open)
   const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
   const client = new WebSocketProxyClient({ url: proxy, enableWebRTC: false, autoReconnect: false })
   await client.connect()
+  return client
+}
+
+async function vaultRpc ({ master, proxy, device, cert, acta = null, sendType, okType, data, onRevoked, timeoutMs = 15000 }) {
+  if (!master || !proxy || !(device?.privateJwk || device?.privateKey || typeof device?.sign === 'function') || !cert) throw new Error('missing pairing data')
+  const client = await clientFor(proxy, master)
   try {
     try { await identifyAsDevice(client, device, { cert, acta }) } catch (_) { /* sin identify seguimos: solo perdemos la cola */ }
-    const signed = { ...data, publickey: device.publickey, ts: Date.now() }
+    const signed = { ...data, publickey: device.publickey, ts: Date.now(), ...(cleanMachine(device.machine) ? { machine: cleanMachine(device.machine) } : {}) }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, privateKey: device.privateKey, publickey: device.publickey, sign: device.sign, data: signed })
     const pending = new Promise((resolve, reject) => {
       let graceTimer = null
@@ -331,14 +378,12 @@ async function vaultRpc ({ master, proxy, device, cert, acta = null, sendType, o
  */
 export async function checkMembership ({ master, proxy, device, onRevoked, timeoutMs = 12000 } = {}) {
   if (!master || !proxy || !(device?.privateJwk || device?.privateKey || typeof device?.sign === 'function')) throw new Error('missing device data')
-  const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
-  const client = new WebSocketProxyClient({ url: proxy, enableWebRTC: false, autoReconnect: false })
-  await client.connect()
+  const client = await clientFor(proxy, master)
   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 data = { op: 'check', publickey: device.publickey, ts: Date.now(), ...(cleanMachine(device.machine) ? { machine: cleanMachine(device.machine) } : {}) }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, privateKey: device.privateKey, publickey: device.publickey, sign: device.sign, data })
     const res = await new Promise((resolve) => {
       let settled = false

package/vault/vault.js

@@ -185,9 +185,9 @@ import { useBackend as usePeerBackend } from './peerStore.js'
   core.onSyncStatus((p) => broadcast('sync', p))
   core.onVaultEvent((p) => broadcast('vault', p))
 
-  // ---- Modo SELF: este navegador actúa como bóveda (daemon device-vault) ----
-  // startDeviceVault convierte la identidad P en CA: atiende enrolamientos y consultas
-  // de revocación por el proxy. Solo UN iframe por origin es el daemon activo
+  // ---- Modo SELF: este navegador actúa como bóveda ----
+  // Corre la MISMA bóveda que el binario (`startBrowserVault`): emparejar, firmar, cajones,
+  // aprobaciones, consola remota, inicios de sesión. Solo UN iframe por origin es el activo
   // (navigator.locks): la pestaña VISIBLE sostiene el lock; al pasar a background lo
   // libera y otra pestaña visible lo toma. Así varias apps abiertas no compiten.
   const SELF_FLAG = 'dotrino.self-vault.enabled' // persistido en localStorage (kv)
@@ -208,79 +208,47 @@ import { useBackend as usePeerBackend } from './peerStore.js'
       return /^wss?:\/\//.test(p || '') ? p : null
     } catch (_) { return null }
   })()
-  let daemon = null           // handle de startDeviceVault cuando ESTE iframe es el activo
+  let daemon = null           // la bóveda (`startBrowserVault`) cuando ESTE iframe es el activo
   let _lockResolver = null    // resolver del callback del lock (libera al resolverlo)
 
-  // Adaptador: startDeviceVault exige identity.{me.publickey, signData, signDelegation,
-  // listDelegations, revokeDelegation}; el core los expone vía handlers + getter me.
-  // `admitMember`/`profileActa` son opcionales para el mostrador de enrolamiento, pero sin
-  // ellos aprobar emitiría el cert SIN meter al dispositivo en el acta: se pasan también.
-  const selfIdentity = {
-    get me () { return core.me },
-    signData: (data) => handlers.signData({ data }),
-    signDelegation: (sub, scope, opts) => handlers.signDelegation({ sub, scope, ...(opts || {}) }),
-    listDelegations: () => handlers.listDelegations({}),
-    revokeDelegation: (nonce) => handlers.revokeDelegation({ nonce }),
-    revokeDevice: (sub) => handlers.revokeDevice({ sub }),
-    admitMember: (m) => handlers.admitMember(m),
-    profileActa: () => handlers.profileActa({}),
-    // Camino A (`mode: 'adopt'`): la bóveda se queda con la cuenta que trae el aparato,
-    // y para eso tiene que poder ENTRAR en su acta. Sin esto, adoptar fallaba con un
-    // «no es una función» en vez de con un error del protocolo.
-    joinProfile: (acta) => handlers.joinProfile({ acta })
-  }
+  // La dirección `nombre@AB12-CD34-EF56` sale del acta de la cuenta.
+  const selfIdentity = { profileActa: () => handlers.profileActa({}) }
 
   /**
-   * EL ESCRITORIO DE LOS INICIOS DE SESIÓN CON CONTRASEÑA, con el almacén de este navegador.
-   *
-   * La bóveda no decide dónde se guarda nada: en el navegador no hay archivos, así que el
-   * estado lo pone quien la monta —esto—. Sin escritorio la pestaña contesta
-   * `logins-unavailable`, que es distinto de «contraseña incorrecta» y por eso se ve.
-   *
-   * Cuelga del PERFIL ACTIVO: los inicios de sesión son de una cuenta, no de este
-   * navegador, y dos cuentas en el mismo equipo no comparten usuarios.
-   *
-   * Se carga solo aquí, y no arriba, porque arrastra el OPAQUE en WASM (~270 KB): el
-   * iframe lo cargan las ~30 apps del ecosistema y solo esta pestaña es bóveda.
-   *
-   * Lo que guarda aguanta lo mismo que el disco del daemon: con una copia de este
-   * `localStorage` se pueden probar contraseñas sin límite contra el registro de OPAQUE.
-   * Lo único que aguanta ahí es que la contraseña sea larga (`temporary-access.md` §4).
+   * LOS INICIOS DE SESIÓN QUE ESTA PESTAÑA GUARDABA ANTES de correr la bóveda entera. Ahora
+   * viven en el almacén de la bóveda (IndexedDB cifrado, uno por perfil); lo de antes se le
+   * pasa una vez y se borra de aquí. Si está y no parsea, REVIENTA a propósito: tomarlo por
+   * vacío perdería los inicios de sesión de la cuenta sin que nadie se enterara.
    */
-  async function makeLoginDesk () {
-    const { createLoginDesk } = await import('@dotrino/vault/password-logins')
+  async function legacyLogins () {
     const { id: pid } = await handlers.currentProfile()
-    if (!pid) throw new Error('no profile: password logins belong to an account')
+    if (!pid) return null
     const key = `dotrino.identity.p.${pid}.self-vault.logins`
-    return createLoginDesk({
-      load: () => {
-        const raw = kv.getItem(key)
-        // Si está y no parsea, REVIENTA aquí a propósito: devolver `null` haría nacer el
-        // escritorio vacío, y el primer guardado se llevaría por delante todos los inicios
-        // de sesión de esta cuenta sin que nadie se enterara.
-        return raw ? JSON.parse(raw) : null
-      },
-      save: (s) => kv.setItem(key, JSON.stringify(s))
-    })
+    const raw = kv.getItem(key)
+    if (!raw) return null
+    return { state: JSON.parse(raw), drop: () => kv.removeItem(key) }
   }
 
   async function startSelfDaemon () {
     if (daemon) return
     try {
-      // Import dinámico: aísla fallos del vendor del arranque del vault (cargado por
-      // todas las apps). El import map de index.html resuelve @dotrino/vault.
-      const { startDeviceVault } = await import('@dotrino/vault')
-      daemon = await startDeviceVault(selfIdentity, {
+      // LA MISMA BÓVEDA QUE EL BINARIO (`@dotrino/vault/browser`): el núcleo entero, con el
+      // disco en IndexedDB. Import dinámico: el iframe lo cargan las ~30 apps y solo esta
+      // pestaña es bóveda; además aísla un fallo del vendor del arranque de la identidad.
+      const { startBrowserVault } = await import('@dotrino/vault/browser')
+      daemon = await startBrowserVault({
+        core,
         ...(selfProxyUrl ? { proxyUrl: selfProxyUrl } : {}),
-        logins: await makeLoginDesk()
+        legacyLogins,
+        onPendingChange: () => broadcast('selfVault', { pending: daemon ? daemon.listPending() : [] }),
+        log: (...a) => console.log(...a)
       })
-      daemon.onPendingChange(() => broadcast('selfVault', { pending: daemon.listPending() }))
       broadcast('selfVault', { running: true })
     } catch (e) { daemon = null; broadcast('selfVault', { error: e?.message || String(e) }) }
   }
   function stopSelfDaemon () {
     if (!daemon) return
-    try { daemon.close() } catch {}
+    try { daemon.close()?.catch?.(() => {}) } catch {}
     daemon = null
     broadcast('selfVault', { running: false })
   }
@@ -340,6 +308,9 @@ import { useBackend as usePeerBackend } from './peerStore.js'
     // agentes siempre, sin depender de qué pestaña sostenga el lock del daemon.
     listVaultDevices: async () => {
       if (kv.getItem(SELF_FLAG) !== '1') return handlers.listVaultDevices({})
+      // Con la bóveda encendida en ESTA pestaña, la lista sale de ella (por el camino
+      // local): trae lo mismo que la del binario. Sin ella encendida, se lee lo guardado.
+      if (daemon) return handlers.listVaultDevices({})
       const { issued, revoked } = await handlers.listDelegations({})
       const now = Date.now()
       const bySub = new Map()
@@ -491,7 +462,7 @@ import { useBackend as usePeerBackend } from './peerStore.js'
     selfVaultLoginRemove: async ({ user } = {}) => {
       const d = pidaDaemon()
       const fila = d.listLogins().find((x) => x.user === user)
-      const r = d.removeLogin({ user })
+      const r = await d.removeLogin({ user })
       if (r?.ok && fila?.pub) {
         try { await handlers.revokeDevice({ sub: fila.pub }) } catch (e) {
           throw Object.assign(new Error(`the login is gone but its key is still in the record: ${e.message}`), { code: 'revoke-failed' })

package/vault/vendor/compat/VERSION.txt

@@ -0,0 +1,3 @@
+Copia vendorizada de @dotrino/compat@0.4.0 (dotrino-compat/src/{advisory,index,ranges}.js).
+NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
+Qué versión es cada pieza y si pueden hablar (CONVENCIONES §14).