@dotrino/identity 0.79.0 → 0.81.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.79.0",
+  "version": "0.81.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -571,6 +571,14 @@ export class Identity {
   async getMe () { return this._call('getMe') }
   /** Subconjunto PÚBLICO de tu perfil (solo lo visible) — para compartir/publicar. */
   async publicMe () { return this._call('publicMe') }
+  /**
+   * CÓMO FUE EL ÚLTIMO EMPUJÓN del perfil a la bóveda: `{ ok, at, error }`.
+   *
+   * El núcleo lo lleva desde la fase 3 y aquí no estaba, así que una app no podía
+   * preguntarlo — que es justo para lo que se guardó: poder decir «esto no se guardó» en
+   * vez de enseñar tan tranquila un perfil que solo vive en este aparato.
+   */
+  async profilePushState () { return this._call('profilePushState') }
 
   /** Pubkey ECDH (JWK string) propio para encripción. */
   async getEncryptionPubkey () {

package/src/node.js

@@ -269,6 +269,8 @@ export class Identity {
   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) {

package/vault/acta.js

@@ -968,8 +968,8 @@ export function effectiveCaps (acta, pub, extraRenounces = []) {
  * `ns` es opcional y es para lo que va atado a un cajón: un servicio (miembro con `cn`)
  * solo firma dentro del suyo. Sin `ns`, se pregunta por la capacidad a secas.
  */
-export function memberCanSign (acta, pub, ns = null) {
-  if (!memberCan(acta, pub, 'sign')) return false
+export function memberCanSign (acta, pub, ns = null, extraRenounces = []) {
+  if (!memberCan(acta, pub, 'sign', extraRenounces)) return false
   const m = (acta?.members || []).find((x) => x.pub === pub)
   // SIN `cn` = un aparato TUYO: firma como tú, y no hay nada que preguntarle a nadie.
   if (!m?.cn) return true
@@ -996,19 +996,19 @@ export function memberCanSign (acta, pub, ns = null) {
  * Devuelve `false` ante un scope que no reconoce: si aparece uno nuevo, lo que toca es
  * añadirlo aquí, no que se cuele por no estar en la lista.
  */
-export function memberCanScope (acta, pub, scope) {
+export function memberCanScope (acta, pub, scope, extraRenounces = []) {
   if (!acta || typeof scope !== 'string') return false
   const secretos = /^vault:secrets:([a-z0-9-]{1,32})$/.exec(scope)
-  if (secretos) return memberCanReadSecrets(acta, pub, secretos[1])
-  if (scope === 'vault:sign') return memberCanSign(acta, pub)
+  if (secretos) return memberCanReadSecrets(acta, pub, secretos[1], extraRenounces)
+  if (scope === 'vault:sign') return memberCanSign(acta, pub, null, extraRenounces)
   const cap = Object.keys(CAP_SCOPE).find((c) => CAP_SCOPE[c] === scope)
-  return cap ? memberCan(acta, pub, cap) : false
+  return cap ? memberCan(acta, pub, cap, extraRenounces) : false
 }
 
-export function memberCanReadSecrets (acta, pub, ns) {
+export function memberCanReadSecrets (acta, pub, ns, extraRenounces = []) {
   const m = (acta?.members || []).find((x) => x.pub === pub)
   if (!m || !m.cn) return false
-  return m.cn === ns && effectiveCaps(acta, pub).includes('secrets')
+  return m.cn === ns && effectiveCaps(acta, pub, extraRenounces).includes('secrets')
 }
 
 /** Los scopes de cert que le corresponden a un miembro según el acta. */

package/vault/core.js

@@ -124,6 +124,30 @@ const STD_FIELD_CAPS = [
 // (los demás campos estándar se comparten salvo que su flag sea false).
 const STD_FIELDS_SENSITIVE = new Set(['telefono', 'direccion'])
 
+/**
+ * QUÉ CLASE ES CADA DATO DEL PERFIL: `public` o `private`
+ * (`dotrino-vault/docs/datos-del-perfil.md` §2).
+ *
+ * La regla no es nueva —es la que ya decidía `publicMe()`: lo que marcaste visible es lo
+ * que ve quien pregunta desde fuera—. Lo que cambia es que ahora decide **cómo se guarda**:
+ * en claro o en sobre. Por eso vive aquí, exportada y a nivel de módulo, en vez de escondida
+ * dentro de una función: es política y hay que poder mirarla y probarla.
+ *
+ * Sensibles (teléfono, dirección) OCULTOS salvo que su marca diga que sí, explícitamente.
+ * El resto se comparte salvo que digas que no.
+ */
+export function profileFieldClasses (m = {}) {
+  const out = {}
+  const clase = (esPublico) => (esPublico ? 'public' : 'private')
+  if (m.nickname) out.nickname = clase(true)
+  if (m.avatar) out.avatar = clase(m.avatarVisible !== false)
+  for (const [k] of STD_FIELD_CAPS) {
+    if (!m[k]) continue
+    out[k] = clase(STD_FIELDS_SENSITIVE.has(k) ? (m[k + 'Visible'] === true) : (m[k + 'Visible'] !== false))
+  }
+  return out
+}
+
 // Sanea un patch de perfil (avatar/links/fields/nickname + campos estándar). Cada link/field
 // lleva `visible` (oculto = no se comparte). Caps de tamaño para no inflar el `me`. Los ids los pone la UI.
 function sanitizeProfilePatch (patch = {}) {
@@ -1099,15 +1123,118 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   // store). Al editar aquí se EMPUJA; al arrancar se JALA y gana el más nuevo
   // (updatedAt). Las llaves (publickey/encryptionPubkey) son POR dispositivo y
   // nunca se sincronizan. Todo best-effort: sin vault encendido no molesta.
+  /**
+   * QUÉ ES PÚBLICO Y QUÉ ES PRIVADO, en un solo sitio.
+   *
+   * Es la misma regla que ya decidía `publicMe()`: lo que marcaste visible es lo que ve
+   * quien pregunta desde fuera. Lo que cambia es que ahora esa marca decide **cómo se
+   * guarda** —en claro o en sobre— y no solo qué se enseña (`docs/datos-del-perfil.md` §2).
+   *
+   * @returns {Array<{key:string, value:string, cls:'public'|'private'}>}
+   */
+  function profileFields (m) {
+    const out = []
+    const add = (key, value, esPublico) => {
+      if (typeof value !== 'string' || !value) return
+      out.push({ key, value, cls: esPublico ? 'public' : 'private' })
+    }
+    // La clase la decide `profileFieldClasses`, que está exportada y probada: tener la
+    // regla en dos sitios es como acaban divergiendo lo que se enseña y lo que se guarda.
+    const clases = profileFieldClasses(m)
+    for (const [k, cls] of Object.entries(clases)) add(k, m[k], cls === 'public')
+    // Enlaces y campos libres viajan como UN dato cada lista: son arrays y partirlos por
+    // elemento haría que reordenarlos pareciera media docena de cambios.
+    const visibles = (arr) => (arr || []).filter((x) => x.visible !== false).map(({ visible, ...r }) => r)
+    const ocultos = (arr) => (arr || []).filter((x) => x.visible === false)
+    if (Array.isArray(m.links)) {
+      const v = visibles(m.links); if (v.length) add('links', JSON.stringify(v), true)
+      const o = ocultos(m.links); if (o.length) add('links_private', JSON.stringify(o), false)
+    }
+    if (Array.isArray(m.fields)) {
+      const v = visibles(m.fields); if (v.length) add('fields', JSON.stringify(v), true)
+      const o = ocultos(m.fields); if (o.length) add('fields_private', JSON.stringify(o), false)
+    }
+    return out
+  }
+
+  /**
+   * EMPUJAR EL PERFIL, DATO A DATO Y EN SOBRES (`docs/datos-del-perfil.md`).
+   *
+   * Antes se mandaba el `me` entero por `profileSet`, y eso exigía la bóveda ABIERTA —era
+   * ella quien decidía guardarlo, porque lo veía en claro—. Ahora cada dato viaja como un
+   * sobre que la bóveda no puede leer ni fabricar, así que aceptarlo no es decisión suya y
+   * el candado deja de estorbar. Los públicos van en claro porque no hay a quién sellarlos.
+   *
+   * Solo se manda LO QUE CAMBIÓ: cada escritura estrena generación, y reescribir un dato
+   * que no cambió llenaría el llavero y el histórico de ruido.
+   */
+  async function pushProfileFields (v, device) {
+    const campos = profileFields(me || {})
+    const pendientes = campos.filter((c) => lastPushedFields[c.key] !== c.cls + '\u0000' + c.value)
+    if (!pendientes.length) return
+
+    const privados = pendientes.filter((c) => c.cls === 'private')
+    let destinatarios = null
+    if (privados.length) {
+      destinatarios = await remoteStore({
+        master: v.master, proxy: v.proxy, device, cert: v.cert,
+        method: 'profileRecipients', args: {}, onRevoked: wipeVaultLink
+      })
+      if (!destinatarios?.recoveryPub) {
+        throw new Error('the vault did not say who to seal the profile for')
+      }
+    }
+
+    for (const c of pendientes) {
+      const args = { key: c.key, cls: c.cls }
+      if (c.cls === 'public') {
+        args.value = c.value
+      } else {
+        // Envolver solo necesita PÚBLICAS: por eso esto se puede hacer aquí, en el
+        // navegador, sin que ninguna privada ande suelta.
+        const cek = await Content.makeContentKey()
+        const e = await Content.encryptWithCek({ cek, gen: 0, plaintext: c.value })
+        const wraps = { '#recovery': await Content.wrapForMember({ cek, memberEncPub: destinatarios.recoveryPub }) }
+        for (const m of destinatarios.members || []) {
+          if (m.encPub) wraps[m.pub] = await Content.wrapForMember({ cek, memberEncPub: m.encPub })
+        }
+        args.sobre = { e, wraps }
+      }
+      await remoteStore({ master: v.master, proxy: v.proxy, device, cert: v.cert, method: 'profilePut', args, onRevoked: wipeVaultLink })
+      lastPushedFields[c.key] = c.cls + '\u0000' + c.value
+    }
+  }
+
+  /** Lo último que se consiguió empujar de cada dato, para no reescribir lo que no cambió. */
+  const lastPushedFields = Object.create(null)
+
   let profilePushTimer = null
+  /**
+   * CÓMO FUE EL ÚLTIMO EMPUJÓN. Se guarda para que la UI pueda decir «esto no se guardó»
+   * en vez de enseñar un perfil que solo existe en este aparato. Sin esto, el usuario ve
+   * su cambio en pantalla y cree que está hecho.
+   */
+  // `ok: null` = TODAVÍA NO SE HA EMPUJADO NADA. Nacía en `true`, así que «nunca se
+  // intentó» y «salió bien» se veían igual — un valor por defecto que dice que sí, en la
+  // función que existe justamente para no tragarse el fallo. Quien pregunte tiene que
+  // poder distinguir las tres cosas, y por eso son tres valores y no dos.
+  let lastProfilePush = { ok: null, at: 0, error: null }
   function pushProfileToVault () {
     const v = loadVaultCert(); const device = loadVaultDevice()
     if (!v?.cert || !device) return
     clearTimeout(profilePushTimer)
     profilePushTimer = setTimeout(() => {
-      const { publickey, encryptionPubkey, ...content } = me || {}
-      remoteStore({ master: v.master, proxy: v.proxy, device, cert: v.cert, method: 'profileSet', args: { me: content }, onRevoked: wipeVaultLink })
-        .catch(() => {}) // el vault puede estar apagado; se reintenta en la próxima edición
+      pushProfileFields(v, device)
+        .then(() => { lastProfilePush = { ok: true, at: Date.now(), error: null } })
+        .catch((e) => {
+          // EL FALLO SE VE. Aquí había un `.catch(() => {})` con un comentario que decía
+          // «se reintenta en la próxima edición», y era falso de dos maneras: la próxima
+          // edición se encontraba la bóveda cerrada otra vez, y mientras tanto el aparato
+          // se quedaba con datos que nadie más tenía. Es exactamente lo que produjo el
+          // «edito y no funciona, y cada dispositivo ve algo distinto».
+          lastProfilePush = { ok: false, at: Date.now(), error: e?.message || String(e) }
+          try { console.warn('[identity] the profile change did NOT reach the vault:', lastProfilePush.error) } catch (_) {}
+        })
     }, 800) // debounce: ediciones seguidas = un solo push
   }
   /**
@@ -1152,6 +1279,41 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
    * quedaba enseñando un perfil del que ya no era, para siempre, sin que nadie pulsara
    * nada porque no había nada que pulsar.
    */
+  /**
+   * COMPONE EL `me` CON LO QUE SE PUDO ABRIR. Devuelve si cambió algo, para no avisar de
+   * una sincronización que no movió nada.
+   *
+   * `links`/`fields` viajan como UN dato cada lista (y su gemelo privado), así que aquí se
+   * vuelven a juntar con su marca de visibilidad — que es de dónde salió la separación.
+   */
+  function applyPulledProfile (content) {
+    const antes = JSON.stringify(me || {})
+    const next = { ...(me || {}) }
+    const lista = (json, visible) => {
+      try { return (JSON.parse(json) || []).map((x) => ({ ...x, visible })) } catch (_) { return [] }
+    }
+    for (const [k, v] of Object.entries(content)) {
+      if (k === 'links' || k === 'fields' || k === 'links_private' || k === 'fields_private') continue
+      next[k] = v
+    }
+    if (content.links != null || content.links_private != null) {
+      next.links = [...lista(content.links, true), ...lista(content.links_private, false)]
+    }
+    if (content.fields != null || content.fields_private != null) {
+      next.fields = [...lista(content.fields, true), ...lista(content.fields_private, false)]
+    }
+    next.publickey = publickeyJwkStr
+    next.encryptionPubkey = encPublickeyJwkStr
+    if (JSON.stringify(next) === antes) return false
+    me = next
+    saveMe(me)
+    if (typeof next.nickname === 'string') {
+      const list = loadProfiles(); const e = list.find((p) => p.id === currentPid)
+      if (e && e.name !== next.nickname) { e.name = next.nickname; saveProfiles(list) }
+    }
+    return true
+  }
+
   async function pullProfileFromVault () {
     try {
       const v = loadVaultCert(); const device = loadVaultDevice()
@@ -1161,23 +1323,31 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       // lo habían echado. La bóveda contesta «vencido» y no pasa nada; y si además ya no
       // está en el acta, contesta con el aviso firmado y aquí se le borra la cuenta.
       if (!v?.cert || !device) return
-      const res = await remoteStore({ master: v.master, proxy: v.proxy, device, cert: v.cert, method: 'profileGet', args: {}, onRevoked: wipeVaultLink })
-      const remoteMe = res?.me
-      if (!remoteMe) {
-        // el vault aún no tiene perfil: sembrar con el local (si tiene contenido)
+      // EL PAQUETE LO ARMA ESTE APARATO (dueño, 2026-09-03). La bóveda entrega los sobres
+      // que tiene; aquí se abren los que nos tocan y se compone el perfil.
+      const b = await remoteStore({ master: v.master, proxy: v.proxy, device, cert: v.cert, method: 'profileBundle', args: {}, onRevoked: wipeVaultLink })
+      const entries = b?.entries || {}
+      if (!Object.keys(entries).length) {
+        // La bóveda aún no tiene perfil: sembrar con el local (si tiene contenido).
         if (me?.nickname || me?.avatar) pushProfileToVault()
         return
       }
-      if ((remoteMe.updatedAt || 0) > (me?.updatedAt || 0)) {
-        const { publickey, encryptionPubkey, ...content } = remoteMe
-        me = { ...(me || {}), ...content, publickey: publickeyJwkStr, encryptionPubkey: encPublickeyJwkStr }
-        saveMe(me)
-        if (typeof content.nickname === 'string') {
-          const list = loadProfiles(); const e = list.find((p) => p.id === currentPid)
-          if (e && e.name !== content.nickname) { e.name = content.nickname; saveProfiles(list) }
+      const keyring = (b.wraps || []).map((w) => ({ gen: w.gen, wraps: { [publickeyJwkStr]: w.wrap } }))
+      const content = {}
+      for (const [key, e] of Object.entries(entries)) {
+        try {
+          if (e.cls === 'public') { content[key] = e.pubv; continue }
+          content[key] = await Content.decryptWithKeyring({
+            envelope: e.e, keyring, myPub: publickeyJwkStr, myEncPrivateKey: encKeypair.privateKey
+          })
+        } catch (_) {
+          // SIN ENVOLTURA NO SE INVENTA NADA. Un aparato que entró después de escribirse un
+          // dato no tiene su llave hasta que el dueño abra la bóveda; dejarlo fuera es
+          // correcto, y poner un valor por defecto sería fabricar un perfil falso.
         }
-        emitVault({ phase: 'profile-sync', updatedAt: remoteMe.updatedAt })
       }
+      if (!applyPulledProfile(content)) return
+      emitVault({ phase: 'profile-sync' })
     } catch (_) { /* vault apagado: el perfil local sigue mandando */ }
   }
 
@@ -2275,6 +2445,13 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       return { me: applyMeUpdate(patch || {}) }
     },
     async getMe () { return me },
+    /**
+     * CÓMO FUE EL ÚLTIMO EMPUJÓN del perfil a la bóveda. Existe para que la interfaz pueda
+     * decir «esto no se guardó» en vez de enseñar tan tranquila un perfil que solo vive en
+     * este aparato — que es lo que pasaba cuando el fallo se tragaba.
+     * `{ ok, at, error }`.
+     */
+    async profilePushState () { return lastProfilePush },
     // Subconjunto PÚBLICO del perfil (solo lo marcado visible) — para compartir/publicar.
     async publicMe () {
       const m = me || {}

package/vault/vendor/proxy-client/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/proxy-client@0.13.1 (dotrino-proxy-client/src/{index,client,signature,canonical,sealing,webrtc}.js).
+Copia vendorizada de @dotrino/proxy-client@0.17.0 (dotrino-proxy-client/src/{index,client,signature,canonical,sealing,webrtc}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 sealing.js resuelve @dotrino/identity/content de forma PEREZOSA (= ../../content.js
 por el import map): solo se carga si de verdad se sella algo.

package/vault/vendor/proxy-client/client.js

@@ -1,6 +1,6 @@
 import { buildSignedChannel, getPublicKeyJwk, signData } from './signature.js'
 import { seal, open, isSealed } from './sealing.js'
-import { WebRTCManager, RTC_TAG, DEFAULT_ICE_SERVERS } from './webrtc.js'
+import { WebRTCManager, RTC_TAG, DEFAULT_ICE_SERVERS, loadNodePeerConnection, resolvePeerConnection } from './webrtc.js'
 
 /**
  * Error con un `code` estable.
@@ -96,15 +96,39 @@ export class WebSocketProxyClient {
       getSelfToken: () => this.token,
       signalSend: (to, payload) => this._proxySendOne(to, payload),
       deliverMessage: (from, parsed, meta) => this._deliver(from, parsed, meta),
-      emit: (event, ...args) => this._emit(event, ...args),
+      emit: (event, ...args) => {
+        // UN CANAL QUE SE CAE SE VUELVE A INTENTAR. Sin esto, el «un intento y no más» de
+        // `_upgradeDirect` sería para siempre: una desconexión momentánea condenaría a ese
+        // destinatario a ir por el proxio el resto de la vida del proceso.
+        if (event === 'webrtc_close') this._rtcTried?.delete(args[0])
+        this._emit(event, ...args)
+      },
       config: this.iceServers ? { iceServers: this.iceServers } : null
     }) : null
+    // QUIÉN PUEDE HACERTE NEGOCIAR UN CANAL DIRECTO. Sin política, cualquiera que sepa
+    // alcanzarte por el proxio — y negociar arranca DTLS/ICE/SCTP, o sea código que parsea
+    // red no confiable. En un navegador se vive con ello; en un proceso que guarda llaves,
+    // no. Quien monta el cliente lo acota (`acceptDirectFrom`).
+    if (this._rtc && typeof options.acceptDirectFrom === 'function') {
+      this._rtc.acceptFrom = options.acceptDirectFrom
+    }
   }
 
   // ---------- public API ----------
 
   get isConnected () { return this._connected }
 
+  /**
+   * WEBRTC EN NODE, si hay con qué. Se busca UNA vez al conectar y no en medio de una
+   * negociación: importar un paquete es asíncrono y hacerlo tarde metería una espera justo
+   * donde no puede haberla. Si no hay implementación, no pasa nada — se sigue por el
+   * proxio, que es el escalón que siempre funciona.
+   */
+  async _prepareWebRTC () {
+    if (!this._rtc || resolvePeerConnection()) return
+    await loadNodePeerConnection()
+  }
+
   connect () {
     return new Promise((resolve, reject) => {
       if (this._connected) return resolve(this.token)
@@ -198,6 +222,41 @@ export class WebSocketProxyClient {
     }
     if (proxyTokens.length) {
       this._sendRaw({ to: proxyTokens, message: messageStr })
+      // Y SE INTENTA IR DIRECTO PARA LA PRÓXIMA, sin esperar a nadie.
+      this._upgradeDirect(proxyTokens)
+    }
+  }
+
+  /**
+   * SIEMPRE EL CAMINO MÁS DIRECTO (dueño, 2026-09-03), pero sin pagar por ello.
+   *
+   * Hablarle a alguien por primera vez sale por el proxio, que es lo que hay AHORA. En
+   * paralelo se abre un canal directo, y desde el segundo mensaje `trySend` ya lo prefiere
+   * solo — eso no hay que cambiarlo, ya estaba.
+   *
+   * **No se espera a la negociación.** Bloquear el primer mensaje hasta tener canal directo
+   * haría más lento justo el arranque, que es lo que se quiere arreglar: se manda por donde
+   * se pueda y la conexión mejora por debajo.
+   *
+   * Un intento por destinatario y no más: si no salió, casi siempre es que no se puede
+   * (dos NAT que no se dejan, un navegador sin permisos) y reintentar en cada mensaje sería
+   * quemar CPU y señalización para nada. Si el canal se cae, `webrtc_close` lo desapunta y
+   * el siguiente mensaje vuelve a intentarlo.
+   */
+  _upgradeDirect (tokens) {
+    if (!this._rtc) return
+    this._rtcTried = this._rtcTried || new Set()
+    for (const t of tokens) {
+      if (this._rtcTried.has(t) || this._rtc.isOpen(t)) continue
+      this._rtcTried.add(t)
+      // La implementación se busca AQUÍ, justo antes de negociar, y no al conectar: esto ya
+      // corre desatendido, así que la espera no se la come nadie. Lanzarlo desde `connect`
+      // metía un microtask de más y descuadraba los tiempos de otras cosas — lo cazaron
+      // las pruebas del protocolo, que fallaban solo al correr todas juntas.
+      Promise.resolve()
+        .then(() => this._prepareWebRTC())
+        .then(() => this._rtc.connect(t))
+        .catch(() => {})   // no poder ir directo no es un fallo: es el caso normal en internet
     }
   }
 
@@ -415,14 +474,31 @@ export class WebSocketProxyClient {
    * (típicamente por el identity vault). Devuelve la respuesta del proxy con
    * `queued_delivered` (mensajes offline despachados al instante).
    */
-  identify ({ data, signature, cert, acta }) {
+  /**
+   * @param {(data:any)=>Promise<any>} [opts.sign] Con qué firmar. Solo se usa para encender
+   *   TURN, y por eso es opcional: quien no lo pase se queda como estaba.
+   *
+   *   TURN NO ES UN CANAL APARTE: es lo que WebRTC usa cuando no consigue ir directo. Pero
+   *   un canal por TURN sigue siendo mejor que el proxio, y no por velocidad — **el relevo
+   *   no puede leer lo que reenvía** (va cifrado extremo a extremo) y el proxio sí. Por eso
+   *   el orden es: aquí mismo, directo, por TURN, y el proxio el último (dueño, 2026-09-03).
+   *
+   *   Se enciende SOLO y por detrás: encenderlo pide credenciales al proxio, y hacer
+   *   esperar a `identify` por eso retrasaría todo lo que viene después para ganar algo que
+   *   solo hace falta cuando se negocie el primer canal.
+   */
+  identify ({ data, signature, cert, acta, sign }) {
     if (!data || !signature) throw new Error('identify requires {data, signature}')
     const msg = { type: 'identify', data, signature }
     if (cert) msg.cert = cert // "una identidad": el proxy bindea este token también bajo tu maestra M
     // Acta de perfil: el proxy la verifica (va firmada) y bindea también el `profileId`, así
     // escribirle a la PERSONA llega a cualquiera de sus dispositivos. Ver acta-de-perfil.md.
     if (acta) msg.acta = acta
-    return this._request(msg, 'identified')
+    const done = this._request(msg, 'identified')
+    if (this._rtc && typeof sign === 'function' && data.publickey) {
+      done.then(() => this.enableTurn({ publicKey: data.publickey, sign })).catch(() => {})
+    }
+    return done
   }
 
   /**

package/vault/vendor/proxy-client/webrtc.js

@@ -20,6 +20,60 @@ export const DEFAULT_ICE_SERVERS = [
 
 const RTC_TAG = '__cc_rtc__'
 
+/**
+ * DE DÓNDE SALE `RTCPeerConnection`, y por qué esto existe.
+ *
+ * En un navegador es nativo. En Node no hay ninguno, y por eso el ecosistema tenía WebRTC
+ * apagado a mano en todas partes: dos máquinas Node se hablaban por el proxio aunque
+ * estuvieran en la misma red, que es lo contrario de la regla («siempre el camino más
+ * directo», CLAUDE.md).
+ *
+ * Se resuelve en este orden:
+ *
+ *   1. el del entorno (navegador, o un Node que algún día lo traiga);
+ *   2. el que le inyecten (`setPeerConnection`), para no atarse a un paquete concreto;
+ *   3. **`@dotrino/webrtc`**, si está instalado — y si no, **`werift`**, del que aquél es
+ *      una poda. Los dos son WebRTC en JavaScript puro, sin binario nativo, y eso no es una
+ *      preferencia estética: la bóveda se distribuye como un ejecutable único (SEA) y un
+ *      `.node` no entra ahí. Se cargan PEREZOSO y ninguno es dependencia de este paquete:
+ *      quien lo quiera en Node lo instala.
+ *
+ *      La poda va primero porque es la mitad de paquetes y sin la pila de audio y vídeo,
+ *      que un canal de datos no toca. Se sigue aceptando el de arriba para no obligar a
+ *      nadie a cambiar, y porque son el mismo código.
+ *
+ * Si no hay ninguno, WebRTC queda apagado y se sigue por el proxio. Eso no es un fallo:
+ * es el escalón 4, que siempre funciona.
+ */
+let _PC = null
+let _PCBuscado = false
+
+export function setPeerConnection (impl) { _PC = impl; _PCBuscado = true }
+
+export function resolvePeerConnection () {
+  if (_PCBuscado) return _PC
+  _PCBuscado = true
+  if (typeof globalThis.RTCPeerConnection === 'function') { _PC = globalThis.RTCPeerConnection; return _PC }
+  return _PC
+}
+
+/**
+ * Busca una implementación para Node. Es ASÍNCRONO —importar un paquete lo es— así que se
+ * llama una vez al arrancar, no en medio de una negociación.
+ */
+export async function loadNodePeerConnection () {
+  if (_PCBuscado && _PC) return _PC
+  if (typeof globalThis.RTCPeerConnection === 'function') { _PC = globalThis.RTCPeerConnection; _PCBuscado = true; return _PC }
+  for (const nombre of ['@dotrino/webrtc', 'werift']) {
+    try {
+      const w = await import(nombre)
+      if (typeof w?.RTCPeerConnection === 'function') { _PC = w.RTCPeerConnection; _PCBuscado = true; return _PC }
+    } catch (_) { /* no está: se prueba el siguiente, y si no, el proxio (escalón 4) */ }
+  }
+  _PCBuscado = true
+  return _PC
+}
+
 export class WebRTCManager {
   /**
    * @param {object} opts
@@ -31,6 +85,7 @@ export class WebRTCManager {
    * @param {{iceServers?: any[]}} [opts.config]
    */
   constructor (opts) {
+    this.acceptFrom = null   // ver `handleIncoming`: lo pone quien monta el cliente
     this.getSelfToken = opts.getSelfToken
     this.signalSend = opts.signalSend
     this.deliverMessage = opts.deliverMessage
@@ -43,8 +98,19 @@ export class WebRTCManager {
    * True if this is a control envelope and was consumed.
    * Otherwise the caller should keep delivering it normally.
    */
+  /**
+   * QUIÉN PUEDE HACERTE NEGOCIAR. Antes: cualquiera que supiera alcanzarte por el proxio.
+   *
+   * Aceptar una señal arranca DTLS, ICE y SCTP — código que parsea red no confiable— así
+   * que quien decide si eso corre no puede ser el que llama a la puerta. En un navegador
+   * eso ya era así y se vivía con ello; en la bóveda es el proceso que tiene la maestra.
+   *
+   * `acceptFrom` lo decide quien monta el cliente: la bóveda solo acepta a MIEMBROS DE SU
+   * ACTA. Sin política se mantiene lo de antes, para no romper a quien ya dependía de ello.
+   */
   handleIncoming (from, parsed) {
     if (!parsed || typeof parsed !== 'object' || parsed.t !== RTC_TAG) return false
+    if (this.acceptFrom && !this.acceptFrom(from)) return false
     const peer = this._ensurePeer(from)
     this._handleSignal(peer, parsed).catch((e) => {
       this.emit('error', { type: 'webrtc_signal', error: e, peer: from })
@@ -135,7 +201,9 @@ export class WebRTCManager {
   }
 
   _createPC (peer) {
-    const pc = new RTCPeerConnection({ iceServers: this.iceServers })
+    const PC = resolvePeerConnection()
+    if (!PC) throw new Error('no WebRTC here: install `werift` for Node, or run this in a browser')
+    const pc = new PC({ iceServers: this.iceServers })
     peer.pc = pc
     peer.polite = this._isPolite(peer.remote)
 

package/vault/vendor/vault/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/vault@0.53.0 (dotrino-vault/lib/src/{index,enroll,protocol}.js).
+Copia vendorizada de @dotrino/vault@0.61.0 (dotrino-vault/lib/src/{index,enroll,protocol}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 index.js importa ./enroll.js y ./protocol.js (relativos, van en esta misma copia),
 @dotrino/identity/{capabilities,acta} (= ../../{capabilities,acta}.js) y

package/vault/vendor/vault/enroll.js

@@ -52,7 +52,18 @@ export const MSG_REVOKED = 'vault.revoked'
 export const MSG_ERROR = 'vault.error'
 
 /** Los scopes del cert se corresponden 1:1 con las capacidades del acta (§D7). */
-const SCOPE_TO_CAP = { 'vault:sign': 'sign', 'vault:store': 'store', 'vault:read': 'read', 'vault:admin': 'admin', 'vault:passwords': 'passwords' }
+const SCOPE_TO_CAP = {
+  'vault:sign': 'sign',
+  'vault:store': 'store',
+  'vault:read': 'read',
+  'vault:admin': 'admin',
+  'vault:passwords': 'passwords',
+  // `replica` SÍ se empareja, al revés que `sealer` y `admin`. La razón es la misma que
+  // hace estrecho al permiso: un replicador reparte sobres que no puede abrir y no cambia
+  // nada. Y se despliega sin teclado —un contenedor, una máquina ajena—, que es justo
+  // donde obligar a un segundo paso a mano es el paso que nadie da.
+  'vault:replica': 'replica'
+}
 export const scopeToCaps = (scope) =>
   (Array.isArray(scope) ? scope : [scope]).map((s) => SCOPE_TO_CAP[s]).filter(Boolean)
 

package/vault/vendor/vault/index.js

@@ -84,7 +84,10 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
   const client = injectedClient || await (async () => {
     const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
     const c = new WebSocketProxyClient({
-      url: proxy, enableWebRTC: false, autoReconnect: true,
+  // WEBRTC SOLO DONDE EXISTE (ver `lib/src/service.js`): en Node no hay
+  // `RTCPeerConnection` y encenderlo reventaría al negociar; en un navegador es nativo y es
+  // el camino directo que hay que preferir. Se mira, en vez de apagarlo para siempre.
+      url: proxy, enableWebRTC: typeof globalThis.RTCPeerConnection === 'function', autoReconnect: true,
       maxReconnectAttempts: 100000, reconnectDelay: 4000
     })
     await c.connect()

package/vault/vendor/vault/protocol.js

@@ -128,3 +128,18 @@ export const isValidSecretsNs = (ns) => typeof ns === 'string' && /^[a-z0-9-]{1,
  * remota y el lector de `.env`, y tres copias de una regla son tres reglas.
  */
 export const isValidVarKey = (key) => typeof key === 'string' && /^[A-Z0-9_]{1,64}$/.test(key)
+
+/**
+ * LA VERSIÓN DEL CABLE (CONVENCIONES §14, `@dotrino/compat`).
+ *
+ * Sube **solo cuando cambia el protocolo**, no con cada release: es lo que decide *si dos
+ * piezas pueden hablar*. La `version` del paquete decide otra cosa —si esa build concreta
+ * está rota— y por eso hacen falta las dos.
+ *
+ * Empieza en 1 hoy, con todo lo anterior sin declarar nada: a quien calla se le atiende
+ * hasta que cierre la ventana de migración del pilar, y después no.
+ */
+export const VAULT_PROTOCOL = 1
+
+/** Los protocolos que esta build entiende. Al añadir el 2, aquí van `[1, 2]`. */
+export const VAULT_SPEAKS = [1]