@dotrino/identity 0.78.0 → 0.80.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.78.0",
+  "version": "0.80.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",
@@ -39,6 +39,7 @@
     "LICENSE"
   ],
   "scripts": {
+    "vendor": "node vendor.mjs",
     "test": "node --test \"test/*.test.js\" \"test/*.test.mjs\"",
     "type-check": "tsc --noEmit"
   },

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

@@ -103,7 +103,7 @@ const conCampoSellador = (acta) => Number(acta?.v) < V_SIN_CAMPO_SELLADOR
  * el rol de master, que no se delega. Así un dispositivo con `admin` robado hace daño
  * acotado y **reversible** (se le revoca), en vez de poder dejarte fuera de tu cuenta.
  */
-export const CAPS = Object.freeze(['sign', 'store', 'read', 'secrets', 'admin', 'approve', 'passwords', 'sealer', 'unattended'])
+export const CAPS = Object.freeze(['sign', 'store', 'read', 'secrets', 'admin', 'approve', 'passwords', 'sealer', 'unattended', 'replica'])
 
 /** Capacidades de un DISPOSITIVO (sin CN): acceso a todo lo del usuario. */
 /**
@@ -117,6 +117,15 @@ export const CAPS = Object.freeze(['sign', 'store', 'read', 'secrets', 'admin',
  * pedirle algo a la bóveda es exactamente lo que decide el acta — tener dos registros
  * de lo mismo obliga a acordarse de los dos al quitar un aparato.
  *
+ * `replica` es REPARTIR, NO DECIDIR. Un replicador no tiene maestra: guarda el acta y los
+ * sobres —que ya vienen sellados a su destinatario, así que tampoco puede abrirlos— y los
+ * entrega cuando la bóveda no está. Firma su respuesta con su propia llave de aparato, y
+ * es este permiso el que hace que un cliente la acepte como respondedor.
+ *
+ * Lo que NO le concede, y por eso es estrecho: no sella actas, no emite certificados, no
+ * abre nada. Un replicador comprometido cuesta disponibilidad, no confidencialidad.
+ * Diseño: `dotrino-vault/docs/replicas.md` §8.bis.
+ *
  * `unattended` es RECIBIR CLAVES PRIVADAS SIN QUE NADIE APRUEBE. Sin él, la bóveda no
  * entrega nada hasta que un aparato con `approve` lo firme — una vez por arranque del
  * servicio, no por petición.
@@ -131,7 +140,7 @@ export const CAPS = Object.freeze(['sign', 'store', 'read', 'secrets', 'admin',
  * de la cuenta, se ve en la pantalla de permisos como los demás, y se quita quitándolo —
  * sin acordarse de un segundo registro escondido.
  */
-export const DEVICE_CAPS = Object.freeze(['sign', 'store', 'read', 'admin', 'approve', 'passwords', 'sealer', 'unattended'])
+export const DEVICE_CAPS = Object.freeze(['sign', 'store', 'read', 'admin', 'approve', 'passwords', 'sealer', 'unattended', 'replica'])
 
 /**
  * Lo que recibe un dispositivo recién emparejado. `admin` **no está**: no se
@@ -158,19 +167,16 @@ export const isValidCn = (cn) => typeof cn === 'string' && /^[a-z0-9-]{1,32}$/.t
  * scope de secretos «de todos».
  */
 export function capScope (cap, cn = null) {
-  if (cap === 'sign') return 'vault:sign'
-  if (cap === 'store') return 'vault:store'
-  if (cap === 'read') return 'vault:read'
-  if (cap === 'admin') return 'vault:admin'
-  if (cap === 'approve') return 'vault:approve'
-  if (cap === 'passwords') return 'vault:passwords'
-  if (cap === 'sealer') return 'vault:sealer'
+  // SALE DE `CAP_SCOPE`, no de una cadena de `if` escrita a mano. Esto era lo segundo: la
+  // lista de arriba y esta se escribían por separado, así que un permiso nuevo entraba en
+  // una y no en la otra y se quedaba sin scope en silencio. Ya pasó con `sealer`,
+  // `unattended` y `secrets`; con `replica` se cortó aquí.
   if (cap === 'secrets') return isValidCn(cn) ? 'vault:secrets:' + cn : null
-  return null
+  return CAP_SCOPE[cap] || null
 }
 
 /** Compat: el mapa directo, para las capacidades de dispositivo. */
-export const CAP_SCOPE = Object.freeze({ sign: 'vault:sign', store: 'vault:store', read: 'vault:read', admin: 'vault:admin', approve: 'vault:approve', passwords: 'vault:passwords', sealer: 'vault:sealer' })
+export const CAP_SCOPE = Object.freeze({ sign: 'vault:sign', store: 'vault:store', read: 'vault:read', admin: 'vault:admin', approve: 'vault:approve', passwords: 'vault:passwords', sealer: 'vault:sealer', replica: 'vault:replica' })
 
 const enc = (s) => new TextEncoder().encode(s)
 const hex = (buf) => [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, '0')).join('')

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/index.html

@@ -26,7 +26,8 @@
     "@dotrino/proxy-client": "./vendor/proxy-client/index.js",
     "@dotrino/vault": "./vendor/vault/index.js",
     "@dotrino/identity/capabilities": "./capabilities.js",
-    "@dotrino/identity/acta": "./acta.js"
+    "@dotrino/identity/acta": "./acta.js",
+    "@dotrino/identity/content": "./content.js"
   } }
   </script>
   <script type="module" src="./vault.js"></script>

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

@@ -1 +1,4 @@
-0.11.0
+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,5 +1,6 @@
 import { buildSignedChannel, getPublicKeyJwk, signData } from './signature.js'
-import { WebRTCManager, RTC_TAG, DEFAULT_ICE_SERVERS } from './webrtc.js'
+import { seal, open, isSealed } from './sealing.js'
+import { WebRTCManager, RTC_TAG, DEFAULT_ICE_SERVERS, loadNodePeerConnection, resolvePeerConnection } from './webrtc.js'
 
 /**
  * Error con un `code` estable.
@@ -43,6 +44,33 @@ export class WebSocketProxyClient {
     this.enableWebRTC = options.enableWebRTC !== false
     this.iceServers = options.iceServers || null
 
+    /**
+     * Refuse to send or accept directed messages in the clear.
+     *
+     * The proxy does not encrypt payloads, so anything sensitive sent with
+     * `sendByPubkey` is readable by whoever runs the proxy. With this on:
+     *   · `sendSealed()` is the only way out — plain `sendByPubkey` throws
+     *   · unsealed directed messages are dropped and reported as 'unsealed'
+     *
+     * Off by default so existing apps keep working; public channels are unaffected
+     * either way, since they are public by design.
+     */
+    this.requireSealed = options.requireSealed === true
+    this.myEncPrivateKey = options.myEncPrivateKey || null
+
+    /**
+     * Who does the sealing. Two worlds, and only one of them holds the key:
+     *
+     *   · headless devices (a CLI, an agent) have their own encryption private key,
+     *     so `myEncPrivateKey` is enough
+     *   · browser apps do NOT: the private key lives in the vault, and they delegate
+     *     with `identity.encrypt` / `identity.decrypt`
+     *
+     * Pass `sealing: { seal(msg, peerEncPub), open(envelope), isSealed(msg) }` to
+     * plug the second case in. Without it, the built-in sealing is used.
+     */
+    this.sealing = options.sealing || null
+
     // Heartbeat de aplicación: el WebSocket del browser NO expone ping/pong de
     // protocolo, así que mandamos `{type:'ping'}` y esperamos cualquier tráfico
     // de vuelta (el server responde `pong`). Si no hay respuesta en
@@ -67,16 +95,40 @@ export class WebSocketProxyClient {
     this._rtc = this.enableWebRTC ? new WebRTCManager({
       getSelfToken: () => this.token,
       signalSend: (to, payload) => this._proxySendOne(to, payload),
-      deliverMessage: (from, parsed, meta) => this._emit('message', from, parsed, meta),
-      emit: (event, ...args) => this._emit(event, ...args),
+      deliverMessage: (from, parsed, meta) => this._deliver(from, parsed, meta),
+      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)
@@ -127,6 +179,19 @@ export class WebSocketProxyClient {
     if (typeof options.autoReconnect === 'boolean') this.autoReconnect = options.autoReconnect
     if (typeof options.maxReconnectAttempts === 'number') this.maxReconnectAttempts = options.maxReconnectAttempts
     if (typeof options.reconnectDelay === 'number') this.reconnectDelay = options.reconnectDelay
+
+    // La configuración de sellado TAMBIÉN se aplica aquí. Casi todas las apps piden el
+    // cliente con `getWebSocketProxyClient()`, que es un singleton: si el primero en
+    // pedirlo no puso `requireSealed`, el que sí lo pide después se quedaba sin él y
+    // sin enterarse — la garantía perdida en silencio, que es la peor forma de
+    // perderla.
+    if (options.sealing) this.sealing = options.sealing
+    if (options.myEncPrivateKey) this.myEncPrivateKey = options.myEncPrivateKey
+
+    // Se puede ENCENDER, no apagar. Bajar la exigencia en caliente dejaría que
+    // cualquier otro módulo de la app la desactivara sin querer, y no hay ningún
+    // motivo legítimo para hacerlo a mitad de una sesión.
+    if (options.requireSealed === true) this.requireSealed = true
   }
 
   on (event, handler) {
@@ -157,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
     }
   }
 
@@ -265,7 +365,67 @@ export class WebSocketProxyClient {
    * incorrecto (reinicia negociaciones imposibles y muestra movimientos fuera de
    * contexto). NO lo uses para mensajes de chat, que sí quieren esperar.
    */
+  /**
+   * Seal a payload towards a peer's encryption key and send it. This is what an app
+   * should use for anything that is not meant for the proxy's eyes.
+   */
+  async sendSealed (toPubkeys, payload, { peerEncPub, ...opts } = {}) {
+    if (this.sealing) {
+      this._sendByPubkeyRaw(toPubkeys, await this.sealing.seal(payload, peerEncPub), opts)
+      return
+    }
+    if (!peerEncPub) throw Object.assign(new Error('sendSealed: missing peerEncPub'), { code: 'unsealed' })
+    this._sendByPubkeyRaw(toPubkeys, await seal(payload, peerEncPub), opts)
+  }
+
+  _isSealed (msg) {
+    return this.sealing ? this.sealing.isSealed(msg) : isSealed(msg)
+  }
+
   sendByPubkey (toPubkeys, payload, opts = {}) {
+    if (this.requireSealed && !this._isSealed(payload)) {
+      throw Object.assign(
+        new Error('requireSealed: refusing to send a directed message in the clear — use sendSealed()'),
+        { code: 'unsealed' })
+    }
+    this._sendByPubkeyRaw(toPubkeys, payload, opts)
+  }
+
+  /**
+   * Hands a message to the app, opening it first when it is sealed.
+   *
+   * With `requireSealed`, anything that arrives in the clear is DROPPED and reported
+   * as `{ type: 'unsealed' }`. Sealing on the way out is not enough on its own: if the
+   * receiving end still accepts plaintext, sending it that way bypasses the sealing
+   * entirely — and a peer that never read anything could still push a forged payload
+   * into the app.
+   */
+  async _deliver (from, payload, meta) {
+    if (this._isSealed(payload)) {
+      if (!this.sealing && !this.myEncPrivateKey) {
+        this._emit('error', { type: 'unsealed', reason: 'no_encryption_key', from })
+        return
+      }
+      try {
+        const opened = this.sealing
+          ? await this.sealing.open(payload, meta)
+          : await open(payload, this.myEncPrivateKey)
+        this._emit('message', from, opened, { ...meta, sealed: true })
+      } catch (e) {
+        // Sealed to somebody else, or tampered with. Staying quiet is the point.
+        this._emit('error', { type: 'undecipherable', from, error: e })
+      }
+      return
+    }
+
+    if (this.requireSealed) {
+      this._emit('error', { type: 'unsealed', reason: 'plaintext_rejected', from })
+      return
+    }
+    this._emit('message', from, payload, { ...meta, sealed: false })
+  }
+
+  _sendByPubkeyRaw (toPubkeys, payload, opts = {}) {
     const list = Array.isArray(toPubkeys) ? toPubkeys : [toPubkeys]
     const msg = {
       to_publickey: list,
@@ -314,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
   }
 
   /**
@@ -713,7 +890,7 @@ export class WebSocketProxyClient {
           this._rtc.handleIncoming(from, parsed)
           break
         }
-        this._emit('message', from, parsed ?? message, {
+        this._deliver(from, parsed ?? message, {
           raw: message, timestamp, via: 'proxy',
           fromPubkey: from_publickey || null,
           queued: !!queued,

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

@@ -1,6 +1,10 @@
 export { WebSocketProxyClient } from './client.js'
 export { canonicalStringify } from './canonical.js'
-export { getPublicKeyJwk, signData, buildSignedChannel } from './signature.js'
+export { getPublicKeyJwk, signData, buildSignedChannel, setKeypairStore } from './signature.js'
+export {
+  seal, open, isSealed, makeEncKeypair, importEncPrivate, exportEncPrivate,
+  setSealingPrimitives,
+} from './sealing.js'
 
 import { WebSocketProxyClient } from './client.js'
 

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

@@ -0,0 +1,77 @@
+/**
+ * End-to-end sealing for directed messages.
+ *
+ * The proxy routes by public key but does NOT encrypt the payload: `sendByPubkey`
+ * serializes it and sends it as-is. Anything sensitive that travels this way is
+ * readable by whoever runs the proxy — which is exactly what the ecosystem promises
+ * does not happen.
+ *
+ * This is NOT new cryptography. It is `wrapForMember`/`openWrap` from
+ * `@dotrino/identity/content`, the same primitives the vault uses for sealed secrets:
+ * ephemeral ECDH P-256 against the recipient's encryption public key, plus AES-GCM.
+ * Each message carries its own ephemeral key, so there is no shared state to keep.
+ *
+ * `@dotrino/identity` is a PEER dependency on purpose: bundling it here would ship a
+ * second, older copy of a pillar inside every consumer.
+ */
+
+const ECDH = { name: 'ECDH', namedCurve: 'P-256' }
+const VERSION = 1
+
+let primitives = null
+
+async function crypto_ () {
+  if (primitives) return primitives
+  try {
+    primitives = await import('@dotrino/identity/content')
+  } catch (e) {
+    throw new Error(
+      'sealing requires @dotrino/identity (peer dependency) — install it, or pass ' +
+      'your own primitives to setSealingPrimitives()')
+  }
+  return primitives
+}
+
+/** Inject the primitives instead of resolving `@dotrino/identity` (bundlers, tests). */
+export function setSealingPrimitives (mod) {
+  primitives = mod
+}
+
+/** A durable encryption keypair for this device. Its public half goes in the pairing code. */
+export async function makeEncKeypair () {
+  const pair = await globalThis.crypto.subtle.generateKey(ECDH, true, ['deriveBits'])
+  const pub = await globalThis.crypto.subtle.exportKey('jwk', pair.publicKey)
+  return {
+    privateKey: pair.privateKey,
+    publicKey: pair.publicKey,
+    encPub: JSON.stringify({ kty: pub.kty, crv: pub.crv, x: pub.x, y: pub.y }),
+  }
+}
+
+export async function importEncPrivate (jwk) {
+  return globalThis.crypto.subtle.importKey('jwk', jwk, ECDH, true, ['deriveBits'])
+}
+
+export async function exportEncPrivate (privateKey) {
+  return globalThis.crypto.subtle.exportKey('jwk', privateKey)
+}
+
+/** Seal a message towards a peer's encryption public key. */
+export async function seal (message, peerEncPub) {
+  if (!peerEncPub) throw new Error('seal: missing peer encryption key')
+  const { wrapForMember } = await crypto_()
+  const sealed = await wrapForMember({ cek: JSON.stringify(message), memberEncPub: peerEncPub })
+  return { v: VERSION, sealed }
+}
+
+/** Open a message sealed to me. Throws if it is not mine or was tampered with. */
+export async function open (envelope, myEncPrivateKey) {
+  if (!isSealed(envelope)) throw new Error('open: not a sealed envelope')
+  if (!myEncPrivateKey) throw new Error('open: missing my encryption key')
+  const { openWrap } = await crypto_()
+  return JSON.parse(await openWrap({ wrap: envelope.sealed, myEncPrivateKey }))
+}
+
+export function isSealed (msg) {
+  return !!msg && msg.v === VERSION && !!msg.sealed?.ct && !!msg.sealed?.epk
+}

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

@@ -1,17 +1,141 @@
 /**
- * ECDSA P-256 keypair management using SubtleCrypto, persisted in localStorage as JWK.
+ * ECDSA P-256 keypair management using SubtleCrypto.
+ *
+ * Persisted in localStorage as JWK where it exists. Where it does NOT — a service
+ * worker, which is where a browser extension keeps its background logic — the pair
+ * used to be regenerated on every call and never stored, so the identity changed
+ * every time the worker went to sleep. Any peer that knows a device by its public
+ * key would see a stranger each time. IndexedDB is the fallback there: it is
+ * available in workers, and it can store the CryptoKey itself, so the private key
+ * stays non-extractable instead of being written out as a JWK.
+ *
  * Public key in JWK form is what the proxy expects in `channel.data.publickey`.
  */
 import { canonicalStringify } from './canonical.js'
 
 const STORAGE_KEY = 'dotrino.proxy-client.keypair'
+const DB_NAME = 'dotrino.proxy-client'
+const DB_STORE = 'keypair'
 
 let cachedKeypair = null
+let injectedStore = null
+let injectedExtractable = false
+
+/**
+ * Override where the keypair is kept. Takes `{ get(), set(pair) }` handling
+ * `{ privateKey, publicKey, publicJwk }`. Rarely needed: the defaults already cover
+ * pages (localStorage) and workers (IndexedDB).
+ *
+ * `extractable` matters: a store that keeps CryptoKeys as-is (IndexedDB) does not
+ * need it and is safer without, but a store that serializes to disk or to text has
+ * to export the private key as a JWK, and that throws on a non-extractable key. Pass
+ * `{ extractable: true }` for those.
+ */
+export function setKeypairStore (store, { extractable = false } = {}) {
+  injectedStore = store
+  injectedExtractable = !!extractable
+  cachedKeypair = null
+}
+
+function idb () {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(DB_NAME, 1)
+    req.onupgradeneeded = () => {
+      if (!req.result.objectStoreNames.contains(DB_STORE)) req.result.createObjectStore(DB_STORE)
+    }
+    req.onsuccess = () => resolve(req.result)
+    req.onerror = () => reject(req.error)
+  })
+}
+
+function idbRequest (db, mode, fn) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(DB_STORE, mode)
+    const req = fn(tx.objectStore(DB_STORE))
+    req.onsuccess = () => resolve(req.result)
+    req.onerror = () => reject(req.error)
+  })
+}
+
+const indexedDbStore = {
+  async get () {
+    const db = await idb()
+    try { return await idbRequest(db, 'readonly', s => s.get(STORAGE_KEY)) } finally { db.close() }
+  },
+  async set (pair) {
+    const db = await idb()
+    try { await idbRequest(db, 'readwrite', s => s.put(pair, STORAGE_KEY)) } finally { db.close() }
+  },
+}
+
+/**
+ * Is there a WORKING localStorage? Not "is it defined" — Node >= 22 exposes one that
+ * throws unless started with `--localstorage-file`, so checking for existence alone
+ * sends the keypair down a path that fails. Anything headless without a shim would
+ * crash instead of quietly falling back.
+ */
+function localStorageWorks () {
+  try {
+    if (typeof localStorage === 'undefined') return false
+    const probe = STORAGE_KEY + '.probe'
+    localStorage.setItem(probe, '1')
+    localStorage.removeItem(probe)
+    return true
+  } catch (e) {
+    return false
+  }
+}
+
+function fallbackStore () {
+  if (injectedStore) return injectedStore
+  if (!localStorageWorks() && typeof indexedDB !== 'undefined') return indexedDbStore
+  return null
+}
 
 async function loadOrCreate () {
   if (cachedKeypair) return cachedKeypair
 
-  if (typeof localStorage !== 'undefined') {
+  const store = fallbackStore()
+  if (store) {
+    try {
+      const saved = await store.get()
+      if (saved?.privateKey && saved?.publicKey) {
+        cachedKeypair = {
+          privateKey: saved.privateKey,
+          publicKey: saved.publicKey,
+          publicJwk: saved.publicJwk || await crypto.subtle.exportKey('jwk', saved.publicKey),
+        }
+        return cachedKeypair
+      }
+    } catch (e) {
+      // unreadable entry, regenerate below
+    }
+
+    // Non-extractable by default: nothing here needs to export the private key, and
+    // a CryptoKey survives structured clone, so with IndexedDB it never has to leave
+    // as a JWK. A store that serializes has to opt in via `setKeypairStore`.
+    const extractable = store === indexedDbStore ? false : injectedExtractable
+    const pair = await crypto.subtle.generateKey(
+      { name: 'ECDSA', namedCurve: 'P-256' },
+      extractable, ['sign', 'verify']
+    )
+    const publicJwk = await crypto.subtle.exportKey('jwk', pair.publicKey)
+    const entry = { privateKey: pair.privateKey, publicKey: pair.publicKey, publicJwk }
+    try {
+      await store.set(entry)
+    } catch (e) {
+      // Loud on purpose. If this fails the identity is regenerated on every start,
+      // and every peer that knows this device by its public key stops recognising
+      // it — the exact failure this whole path exists to prevent. A silent catch
+      // here means finding out days later, from the other side.
+      console.error('[proxy-client] could not persist the keypair: %s', e?.message || e)
+      console.error('[proxy-client] identity will NOT survive a restart. If the store serializes, pass { extractable: true } to setKeypairStore.')
+    }
+    cachedKeypair = entry
+    return cachedKeypair
+  }
+
+  if (localStorageWorks()) {
     const raw = localStorage.getItem(STORAGE_KEY)
     if (raw) {
       try {
@@ -40,7 +164,7 @@ async function loadOrCreate () {
   )
   const privateJwk = await crypto.subtle.exportKey('jwk', pair.privateKey)
   const publicJwk = await crypto.subtle.exportKey('jwk', pair.publicKey)
-  if (typeof localStorage !== 'undefined') {
+  if (localStorageWorks()) {
     localStorage.setItem(STORAGE_KEY, JSON.stringify({ privateJwk, publicJwk }))
   }
   cachedKeypair = { privateKey: pair.privateKey, publicKey: pair.publicKey, publicJwk }

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,6 +1,5 @@
-Copia vendorizada de @dotrino/vault@0.34.0 (lib/src/{index,enroll,protocol}.js, sin dependencias).
-El iframe de identity se sirve estatico (vanilla, sin build); asi startDeviceVault
-resuelve en el navegador sin bundler. index.js importa ./enroll.js y ./protocol.js
-(relativos, se vendorizan tambien) y @dotrino/identity/capabilities (=../../capabilities.js)
-y @dotrino/proxy-client (=../proxy-client/), ambos via el import map de index.html.
-Re-vendorizar LOS TRES archivos al subir @dotrino/vault.
+Copia vendorizada de @dotrino/vault@0.60.3 (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
+@dotrino/proxy-client (= ../proxy-client/), todos por el import map de index.html.

package/vault/vendor/vault/enroll.js

@@ -30,7 +30,7 @@
  * `docs/pairing-protocol.md`).
  */
 import { verifyDeviceSig, pubkeyId, commitCode } from '@dotrino/identity/capabilities'
-import { verifyContinuity } from '@dotrino/identity/acta'
+import { verifyContinuity, canSeal } from '@dotrino/identity/acta'
 
 /** Un token de emparejamiento vale 5 min. */
 export const PAIRING_TTL_MS = 5 * 60 * 1000
@@ -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' }
+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)
 
@@ -277,7 +288,12 @@ export function createEnrollDesk ({
       pend.continuity = (okC && d.continuity.member === d.dpub) ? d.continuity : null
     }
     pend.from = from // la bóveda NO conoce el código: lo aprende cuando lo tipeas
-    if (d.label) pend.label = String(d.label).slice(0, 60)
+    // EL NOMBRE QUE PUSISTE AQUÍ MANDA. El aparato manda el suyo al enrolarse, y hasta
+    // ahora pisaba siempre al de la bóveda — como el aparato usa por defecto el apodo del
+    // PERFIL, acababas con varios dispositivos llamados igual que tú y sin forma de saber
+    // cuál era cuál. Si en `pair` le diste un nombre, ese es el nombre; el del aparato
+    // sigue valiendo como propuesta cuando no dijiste nada.
+    if (d.label && !pend.label) pend.label = String(d.label).slice(0, 60)
     // Camino A: de qué cuenta estamos hablando. Se guarda para poder comprobar, cuando
     // llegue el acta sellada, que es la que este dispositivo dijo que iba a entregar.
     if (intent === 'adopt' && typeof d.profileId === 'string') pend.profileId = d.profileId
@@ -359,7 +375,7 @@ export function createEnrollDesk ({
     pend.state = 'DONE'
     pending.delete(pend.token)
     fire(onPendingChange)
-    log('[vault] device approved: %s', pend.deviceId)
+    log(`[vault] device approved: ${pend.deviceId}`)
     return { ok: true, deviceId: pend.deviceId, cert }
   }
 
@@ -383,9 +399,12 @@ export function createEnrollDesk ({
     const pend = [...pending.values()].find((x) => x.state === 'AWAITING_ACTA' && (x.from === from || x.dpub))
     if (!pend) return reply(from, { type: MSG_ERROR, error: 'no adoption awaiting a record' })
     if (!record || typeof record !== 'object') return reply(from, { type: MSG_ERROR, error: 'record missing or unreadable' })
-    if (record.sealer !== iss) {
+    // Ya no hay campo `sealer`: se le pregunta al PERMISO. Es la misma comprobación —«¿me
+    // nombra a mí la que me mandan?»— dicha en el idioma nuevo, y con varios selladores la
+    // respuesta puede ser que sí para más de uno, que es lo correcto.
+    if (!canSeal(record, iss)) {
       audit('rejected', { what: 'adopt', reason: 'not-sealer' })
-      return reply(from, { type: MSG_ERROR, error: 'that record does not name this vault as the sealer' })
+      return reply(from, { type: MSG_ERROR, error: 'that record does not let this vault seal it' })
     }
     if (record.sealedBy !== pend.dpub) {
       audit('rejected', { what: 'adopt', reason: 'sealed-by-other' })

package/vault/vendor/vault/index.js

@@ -26,13 +26,13 @@
  * No reimplementa nada del ecosistema.
  */
 import { verifyChain, verifyDeviceSig } from '@dotrino/identity/capabilities'
+import { memberCanScope, sealersOf, memberScopes } from '@dotrino/identity/acta'
 import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS, FRESH_WINDOW_MS } from './enroll.js'
 // Las constantes del protocolo salen del MISMO módulo que usa el daemon: si la lista
 // local se queda corta, el dispositivo deja de handle mensajes sin que nadie lo note.
 import { MSG, SCOPE } from './protocol.js'
 
 const SIGN_SCOPE = SCOPE.SIGN
-const SELFCERT_TTL_MS = 24 * 60 * 60 * 1000    // el self-cert P←P se regenera cada 24 h
 const RENEW_TTL_MS = DEVICE_TTL_MS             // la renovación extiende la misma ventana (30 días)
 
 /** deviceId legible (p. ej. `C440-AC0E`) desde una pubkey JWK. */
@@ -57,10 +57,24 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
 
   // ----- self-cert P ← P (para que este dispositivo pueda además actuar de cliente
   // de sus propias máquinas: lo firma la propia P y verifyChain lo acepta) -----
+  /**
+   * Con qué se juzga un papel: el acta que tiene esta bóveda. Sustituye a `trustedIssuer`,
+   * que fijaba UNA llave y por eso los papeles de una segunda selladora no valían.
+   * Sin acta van nulos y `verifyDelegation` contesta `no-acta`: no hay con qué decidir, así
+   * que no se decide que sí.
+   */
+  async function contextoActa () {
+    const acta = (await identity.profileActa?.().catch(() => null))?.acta || null
+    if (!acta) return { actaSeq: null, sealers: null }
+    return { actaSeq: acta.seq, sealers: sealersOf(acta) }
+  }
+
   let _selfCert = null
   const getSelfCert = async () => {
-    if (_selfCert && _selfCert.exp > Date.now() + 60_000) return _selfCert
-    const { cert } = await identity.signDelegation(iss, SIGN_SCOPE, { ttlMs: SELFCERT_TTL_MS })
+    // Se rehace cuando el acta cambia, no cuando pasa el tiempo: el papel ya no caduca.
+    const { actaSeq } = await contextoActa()
+    if (_selfCert && _selfCert.seq === actaSeq) return _selfCert
+    const { cert } = await identity.signDelegation(iss, SIGN_SCOPE)
     _selfCert = cert
     return cert
   }
@@ -70,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()
@@ -137,13 +154,20 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
     if (typeof d.ts !== 'number' || Math.abs(Date.now() - d.ts) > FRESH_WINDOW_MS) {
       return send(from, { type: MSG.ERROR, error: 'stale request: ts outside the ±5 min window (possible replay, or the device clock is off)' })
     }
-    const chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, trustedIssuer: iss, revoked: await revocationSet() })
+    const chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, ...(await contextoActa()), revoked: await revocationSet() })
     if (!chk.ok) return send(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
     // Reusar el label del cert original (si sigue registrado en delegations).
     const { issued } = await identity.listDelegations()
     const prev = (issued || []).find((x) => x.nonce === p.cert.nonce)
-    const { cert } = await identity.signDelegation(p.cert.sub, p.cert.scope, { ttlMs: RENEW_TTL_MS, label: prev?.label || '' })
-    send(from, { type: MSG.RENEWED, cert })
+    // EL SCOPE SALE DEL ACTA, no del papel viejo: el papel dice a qué se comprometió esta
+    // bóveda al conectar el aparato; el acta, lo que puede HOY.
+    const acta = (await identity.profileActa?.().catch(() => null))?.acta || null
+    if (!acta) return send(from, { type: MSG.ERROR, error: 'unauthorized: this vault has no record to decide with' })
+    const scope = memberScopes(acta, p.cert.sub)
+    if (!scope.length) return send(from, { type: MSG.ERROR, error: 'unauthorized: the record no longer lists this device' })
+    const { cert } = await identity.signDelegation(p.cert.sub, scope, { label: prev?.label || '' })
+    // El acta viaja con el papel: sin ella quien lo recibe no puede comprobar quién lo firmó.
+    send(from, { type: MSG.RENEWED, cert, acta })
   }
 
   // Consulta de revocaciones (igual que `vault.devices` del daemon): responde la lista
@@ -153,12 +177,12 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
     const d = p?.data
     if (!d || !p.signature || !p.cert) return send(from, { type: MSG.ERROR, error: 'invalid request' })
     if (typeof d.ts !== 'number' || Math.abs(Date.now() - d.ts) > FRESH_WINDOW_MS) return
-    const chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, trustedIssuer: iss })
+    const chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, ...(await contextoActa()) })
     if (!chk.ok) return send(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
     const { issued, revoked, revokedCerts } = await identity.listDelegations()
     const devices = await Promise.all((issued || []).map(async (x) => ({
       deviceId: x.sub ? await deviceIdOf(x.sub) : null, sub: x.sub || null,
-      label: x.label || '', scope: x.scope, exp: x.exp, nonce: x.nonce
+      label: x.label || '', scope: x.scope, seq: x.seq, nonce: x.nonce
     })))
     send(from, { type: MSG.DEVICES_RESULT, devices, revoked: (revoked || []).map((r) => r.nonce || r) })
     // ¿el que consulta es una máquina revocada que reapareció? → re-emite el REVOKED firmado.
@@ -188,12 +212,23 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
     const chk = await verifyChain({
       data: d, signature: p.signature, cert: p.cert,
       ...(expectedScope ? { expectedScope } : {}),
-      trustedIssuer: iss, revoked: await revocationSet(),
+      ...(await contextoActa()), revoked: await revocationSet(),
     })
     if (!chk.ok) {
       send(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
       return null
     }
+    // EL ACTA MANDA, EL PAPEL SOLO ACOMPAÑA. Aquí y no en cada mostrador: el certificado
+    // dice a qué se comprometió esta bóveda al conectar el aparato, y el acta lo que puede
+    // HOY. Quitarle un permiso sella el acta pero no le retira el papel, que vive hasta 30
+    // días, así que sin esto seguiría entrando hasta que lo renovara.
+    if (expectedScope) {
+      const record = (await identity.profileActa?.().catch(() => null))?.acta || null
+      if (record && !memberCanScope(record, chk.device, expectedScope)) {
+        send(from, { type: MSG.ERROR, error: 'unauthorized: acta — this member no longer has that permission' })
+        return null
+      }
+    }
     return chk
   }
 
@@ -302,13 +337,14 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
    */
   async function listMachines () {
     const { issued } = await identity.listDelegations()
-    const now = Date.now()
     const bySub = new Map()
     for (const x of (issued || [])) {
-      if (!x.sub || x.revokedAt || (x.exp && x.exp <= now)) continue // revocada = fuera de la lista
+      if (!x.sub || x.revokedAt) continue                       // revocada = fuera de la lista
       if (!Array.isArray(x.scope) || !x.scope.includes(SIGN_SCOPE)) continue
       if (!x.label || x.label === 'cli') continue
-      if (!bySub.has(x.sub) || (x.exp || 0) > (bySub.get(x.sub).exp || 0)) bySub.set(x.sub, x)
+      // Se queda el papel del acta MÁS NUEVA de esa llave: ya no hay «el que vence más
+      // tarde», porque ninguno vence.
+      if (!bySub.has(x.sub) || (x.seq || 0) > (bySub.get(x.sub).seq || 0)) bySub.set(x.sub, x)
     }
     return Promise.all([...bySub.values()].map(async (x) => ({ ...x, deviceId: await deviceIdOf(x.sub) })))
   }

package/vault/vendor/vault/protocol.js

@@ -86,6 +86,10 @@ export const MSG = Object.freeze({
   // contrapartida de administrar a distancia: sin esto, un enrolamiento remoto sería
   // invisible para el resto de tus dispositivos.
   ADMIN_EVENT: 'vault.admin.event',           // vault → todos: { body:{ev,deviceId,by,ts}, signature }
+  // RÉPLICAS: la principal empuja lo que hay que servir (el acta y los sobres, que van
+  // firmados de antes y no se pueden falsificar) y la réplica acusa hasta qué `seq` tiene.
+  REPLICA_PUSH: 'vault.replica.push',         // master → réplica: { body:{seq,acta,secrets,ts}, signature }
+  REPLICA_ACK: 'vault.replica.ack',           // réplica → master: { body:{seq,ts}, signature }
   ERROR: 'vault.error'                        // vault → dispositivo: { error }
 })
 
@@ -98,7 +102,15 @@ export const SCOPE = Object.freeze({
   // NO incluye cambiar permisos, traspasar el mando ni conceder `admin`: eso es el rol
   // de master y sigue siendo local. No se empareja — se concede desde el PC.
   ADMIN: 'vault:admin',
-  APPROVE: 'vault:approve' // aprobar pedidos de secretos (cajones con `approval`); se concede a mano, como admin
+  APPROVE: 'vault:approve', // aprobar pedidos de secretos (cajones con `approval`); se concede a mano, como admin
+  // El gestor de contraseñas: pedir credenciales de la bóveda, de a una y por dominio.
+  // Nunca lista la bóveda entera. Este SÍ se empareja (`pair --scope contrasenas`): es
+  // lo primero que hace la extensión, y no tendría sentido obligar a un segundo paso.
+  PASSWORDS: 'vault:passwords',
+  // SELLAR EL ACTA: la OTRA bóveda de esta cuenta. Con esto puede admitir aparatos y
+  // cambiar permisos si la principal se pierde — que es todo el punto del multivault. Como
+  // `admin`, no se empareja: se concede a mano (`caps <ID> +sella`).
+  SEALER: 'vault:sealer'
 })
 
 /**