@dotrino/identity 0.110.2 → 0.112.0

package/package.json

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

package/vault/acta.js

@@ -94,8 +94,8 @@ const conCampoSellador = (acta) => Number(acta?.v) < V_SIN_CAMPO_SELLADOR
  * traspaso); el permiso dice **quién puede firmar el acta**. Admitir sigue sin ser un
  * permiso: se admite sellando.
  *
- * `secrets` es distinta de las otras: solo la pueden tener los miembros con **CN**
- * (los servicios), y lo que abre es únicamente el cajón de SU nombre. Ver `cn` abajo.
+ * El cajón de un servicio NO está en la lista: lo abre su **CN**, no un permiso. Ver
+ * `cnScope` abajo.
  *
  * `admin` es la rendija que se le abre a la consola remota (`dotrino-vault/docs/
  * consola-remota.md`): deja **admitir y expulsar** miembros a distancia, y nada más.
@@ -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', 'passkeys', 'sealer', 'unattended', 'replica'])
+export const CAPS = Object.freeze(['sign', 'store', 'read', 'admin', 'approve', 'passwords', 'passkeys', 'sealer', 'unattended', 'replica'])
 
 /** Capacidades de un DISPOSITIVO (sin CN): acceso a todo lo del usuario. */
 /**
@@ -158,32 +158,57 @@ export const DEVICE_CAPS = Object.freeze(['sign', 'store', 'read', 'admin', 'app
  */
 export const PAIRED_CAPS = Object.freeze(['sign', 'store', 'read'])
 
-/** Capacidades de un SERVICIO (con CN): solo su propio cajón de secretos. */
-export const SERVICE_CAPS = Object.freeze(['secrets'])
-
 /**
- * Qué capacidades puede llevar un miembro según tenga cajón (CN) o no. Con CN: su cajón
- * y, si se le conceden, las de aparato. Sin CN: solo las de aparato (no hay cajón que abrir).
+ * EL CAJÓN NO ES UN PERMISO: LO ABRE EL CN (dueño, 2026-10-13).
+ *
+ * Antes existía la capacidad `secrets`, y abrir el cajón exigía las dos cosas: llevar el
+ * `cn` de ese cajón Y tener `secrets`. La segunda no decidía nada —el alta se la ponía sola
+ * a todo miembro con `cn`— y en la pantalla de permisos salía como una casilla más al lado
+ * de las de verdad. Un servicio abre el cajón de SU nombre porque el acta dice que es ese
+ * servicio; para cortárselo se le bloquea o se le quita.
+ *
+ * Las actas ya selladas que llevan la palabra se siguen leyendo: es una capacidad que este
+ * lector no conoce, así que no cuenta (ver `checkShape`).
  */
-export const allowedCaps = (cn) => (cn ? [...SERVICE_CAPS, ...DEVICE_CAPS] : [...DEVICE_CAPS])
+
+/** Qué capacidades puede llevar un miembro: las mismas con cajón (CN) que sin él. */
+export const allowedCaps = () => [...DEVICE_CAPS]
 
 /** Un CN válido: minúsculas, números y guiones (igual que el namespace de secretos). */
 export const isValidCn = (cn) => typeof cn === 'string' && /^[a-z0-9-]{1,32}$/.test(cn)
 
 /**
- * Scope del cert que corresponde a cada capacidad. `secrets` necesita el CN para
- * completarse: el miembro `proxy` obtiene `vault:secrets:proxy` y nada más — no existe un
- * scope de secretos «de todos».
+ * Scope del cert que corresponde a cada capacidad. El del cajón no sale de aquí: lo da el
+ * CN (`cnScope`).
  */
-export function capScope (cap, cn = null) {
+export function capScope (cap) {
   // 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 CAP_SCOPE[cap] || null
 }
 
+/**
+ * EL NOMBRE DE LA PROPIA BÓVEDA NO ES UN SERVICIO, Y NO TIENE CAJÓN.
+ *
+ * La llave de comunicación de la bóveda entra en el acta con este `cn` para hablar por la
+ * bóveda y no firmar por la persona. Es la que firma con el perfil CERRADO, así que un sobre
+ * dirigido a ella sería leer secretos sin abrir la bóveda. Mientras existió la capacidad
+ * `secrets` lo impedía no tenerla; ahora que el cajón lo abre el `cn`, se dice aquí y por
+ * su nombre: este `cn` no abre ninguno, tampoco uno que se llame igual.
+ */
+export const VAULT_CN = 'vault'
+
+/** ¿Es el `cn` de un servicio con cajón? Válido y distinto del de la propia bóveda. */
+const hasDrawer = (cn) => isValidCn(cn) && cn !== VAULT_CN
+
+/**
+ * El scope del cajón de un servicio: el miembro `proxy` obtiene `vault:secrets:proxy` y nada
+ * más — no existe un scope de secretos «de todos».
+ */
+export const cnScope = (cn) => (hasDrawer(cn) ? 'vault:secrets:' + cn : 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', replica: 'vault:replica' })
 
@@ -479,11 +504,7 @@ export function checkShape (acta) {
     // El CN es la frontera: un SERVICIO solo puede abrir su propio cajón, y un
     // DISPOSITIVO no tiene cajón que abrir. Que no se pueda escribir un acta que
     // mezcle las dos cosas es lo que hace que el límite sea real y no una costumbre.
-    if (m.cn != null) {
-      if (!isValidCn(m.cn)) return 'cn-invalido'
-    } else if (m.caps.includes('secrets')) {
-      return 'secretos-sin-cn'
-    }
+    if (m.cn != null && !isValidCn(m.cn)) return 'cn-invalido'
     // La llave de cifrado: por ahora se valida la FORMA y solo si viene. NO se exige
     // todavía, aunque el destino sea exigírsela a quien recibe secretos.
     //
@@ -777,8 +798,8 @@ export async function applyChanges (acta, changes, { by, now = Date.now(), sealP
           cn,
           // PERMISOS, no tipos (2026-08-22): el CN dice qué cajón abre; no recorta lo demás.
           // Un miembro con CN puede llevar además las capacidades de aparato (un bot que
-          // firma como aparato del acta Y lee su cajón). Sin CN, `secrets` no significa nada.
-          caps: cleanCaps(m.caps).filter((c) => allowedCaps(cn).includes(c)),
+          // firma como aparato del acta Y lee su cajón).
+          caps: cleanCaps(m.caps),
           addedAt: now,
           cert: m.cert || null,
           // Puente con la identidad que este miembro traía de antes (ver makeContinuity).
@@ -803,8 +824,8 @@ export async function applyChanges (acta, changes, { by, now = Date.now(), sealP
         const m = find(ch.pub)
         if (!m) throw new Error('caps: that member is not in the record')
         // El CN no cambia por aquí (quitar el cajón es sacar al miembro y volver a admitirlo,
-        // que es un gesto visible); las capacidades sí, dentro de lo que su CN permite.
-        m.caps = cleanCaps(ch.caps).filter((c) => allowedCaps(m.cn).includes(c))
+        // que es un gesto visible); las capacidades sí.
+        m.caps = cleanCaps(ch.caps)
         // CONCEDER LIMPIA LA RENUNCIA. `effectiveCaps` resta lo renunciado, así que sin
         // esto una renuncia sellada era IRREVERSIBLE: el master le devolvía el permiso en
         // `caps` y la resta seguía dejándolo fuera, para siempre. La interfaz promete
@@ -1066,15 +1087,14 @@ export function memberCanScope (acta, pub, scope, extraRenounces = []) {
 
 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, extraRenounces).includes('secrets')
+  return !!m && hasDrawer(m.cn) && m.cn === ns
 }
 
 /** Los scopes de cert que le corresponden a un miembro según el acta. */
 export function memberScopes (acta, pub, extraRenounces = []) {
   const m = (acta?.members || []).find((x) => x.pub === pub)
   if (!m) return []
-  return effectiveCaps(acta, pub, extraRenounces).map((c) => capScope(c, m.cn)).filter(Boolean)
+  return [cnScope(m.cn), ...effectiveCaps(acta, pub, extraRenounces).map((c) => capScope(c))].filter(Boolean)
 }
 
 /** ¿Es un servicio (tiene CN) o un dispositivo del usuario? */
@@ -1276,6 +1296,6 @@ export default {
   sealActa, verifyActa, checkVaultReply, applyChanges, makeRenounce, verifyRenounce,
   makeContinuity, verifyContinuity,
   cardBody, makeProfileCard, verifyProfileCard, canAdoptCard, sealersOf, canSeal,
-  effectiveCaps, memberCan, memberCanSign, memberCanScope, memberCanReadSecrets, memberScopes, isService, capScope, isValidCn, canAdopt,
+  effectiveCaps, memberCan, memberCanSign, memberCanScope, memberCanReadSecrets, memberScopes, isService, capScope, cnScope, VAULT_CN, isValidCn, canAdopt,
   samePubkey, memberEncPub
 }

package/vault/core.js

@@ -2596,9 +2596,9 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
      * `continuity`: si esa identidad ya existía por su cuenta, su puente firmado (F3).
      */
     async admitMember ({ pub, encPub = null, label = '', cn = null, caps = null, cert = null, continuity = null } = {}) {
-      // `cn`: si viene, este miembro es un SERVICIO y su único permiso es abrir el cajón de
-      // secretos de ESE nombre — no ve nada más del usuario. Sin `cn` es un dispositivo.
-      const finales = caps || (cn ? ['secrets'] : ['store', 'read'])
+      // `cn`: si viene, este miembro es un SERVICIO: abre el cajón de secretos de ESE nombre
+      // por llevarlo, sin permiso aparte, y no ve nada más del usuario. Sin `cn` es un dispositivo.
+      const finales = caps || (cn ? [] : ['store', 'read'])
       // Que entre al perfil incluye poder LEER lo que ya hay: se le envuelve la clave
       // vigente (no hace falta rotar; rotar es para cuando alguien SALE).
       //

package/vault/remote.js

@@ -374,7 +374,9 @@ export async function requestStore ({ master, proxy, device, cert, method, args,
 export async function requestDevices ({ master, proxy, device, cert, sinceSeq, onRevoked } = {}) {
   const data = typeof sinceSeq === 'number' ? { op: 'devices', sinceSeq } : { op: 'devices' }
   const res = await vaultRpc({ master, proxy, device, cert, onRevoked, sendType: 'vault.devices', okType: 'vault.devices.result', data })
-  return { devices: res.devices || [], revoked: res.revoked || [], acta: res.acta || null, chain: res.chain || null }
+  // `sealerChain`: [génesis, …cambios de sellador…, actual], lo que una firma de este aparato
+  // tiene que llevar para que `verifySignedFor` la ate a la cuenta (vaultd ≥ 0.154.0).
+  return { devices: res.devices || [], revoked: res.revoked || [], acta: res.acta || null, chain: res.chain || null, sealerChain: res.sealerChain || null }
 }
 
 /**

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

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/proxy-client@0.30.4 (dotrino-proxy-client/src/{index,client,signature,canonical,sealing,encpub,webrtc,stats,stats-log}.js).
+Copia vendorizada de @dotrino/proxy-client@0.32.0 (dotrino-proxy-client/src/{index,client,signature,canonical,sealing,encpub,webrtc,stats,stats-log}.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,7 +1,7 @@
 import { buildSignedChannel, getPublicKeyJwk, signData, samePubkey } from './signature.js'
 import { seal, open, isSealed } from './sealing.js'
 import { buildEncPubStatement, readEncPubStatement, isEncPub } from './encpub.js'
-import { WebRTCManager, RTC_TAG, DEFAULT_ICE_SERVERS, loadNodePeerConnection, resolvePeerConnection } from './webrtc.js'
+import { WebRTCManager, RTC_TAG, DEFAULT_ICE_SERVERS, loadNodePeerConnection, resolvePeerConnection, pinTurnToIPv4 } from './webrtc.js'
 import { TrafficStats, utf8Length, registerTransport, unregisterTransport } from './stats.js'
 
 /**
@@ -1002,9 +1002,35 @@ export class WebSocketProxyClient {
       clearTimeout(this._turnTimer)
       this._turnTimer = null
     }
-    const res = await this.getTurnCredentials({ publicKey, sign })
-    if (!res.enabled || !res.iceServers) return false
-    this._rtc.setIceServers([...res.iceServers, ...DEFAULT_ICE_SERVERS])
+    let res
+    try {
+      res = await this.getTurnCredentials({ publicKey, sign })
+    } catch (e) {
+      if (e?.status !== 429) throw e
+      // 429: EL PROXIO DICE «AHORA NO» (tope diario de tráfico, cuota por hora, o no puede
+      // leer el consumo). No es un fallo: se sigue por el proxio, que es el escalón que
+      // siempre funciona. Se quita el relevo que hubiera (sus credenciales ya no se
+      // renuevan), se dice por un evento y en `stats()`, y se vuelve a pedir cuando el
+      // proxio dice que se puede — si no, un aparato que pasó por un día con el tope
+      // alcanzado se quedaría sin relevo hasta su siguiente reconexión.
+      this._rtc.setIceServers(DEFAULT_ICE_SERVERS)
+      const retryAfterMs = Math.max(60000, Number(e.retryAfterMs) || 0)
+      this._turn = { active: false, code: e.code || null, retryAt: Date.now() + retryAfterMs }
+      this._emit('turn_unavailable', { code: e.code || null, retryAfterMs })
+      this._turnTimer = setTimeout(() => {
+        this._turnTimer = null
+        this.enableTurn({ publicKey, sign }).catch(() => {})
+      }, retryAfterMs)
+      return false
+    }
+    if (!res.enabled || !res.iceServers) {
+      this._turn = { active: false, code: 'turn-disabled', retryAt: null }
+      return false
+    }
+    this._turn = { active: true, code: null, expiresAt: res.expiresAt || null }
+    // En Node el relevo va con su dirección IPv4 ya escrita (ver `pinTurnToIPv4`).
+    const turnServers = await pinTurnToIPv4(res.iceServers)
+    this._rtc.setIceServers([...turnServers, ...DEFAULT_ICE_SERVERS])
     // Renovar con margen antes de expirar (mínimo 30 s entre renovaciones)
     const refreshIn = Math.max(30000, (res.expiresAt || 0) - Date.now() - 60000)
     this._turnTimer = setTimeout(() => {
@@ -1523,6 +1549,8 @@ export class WebSocketProxyClient {
       publickey: this.myPublickey,
       connected: this._connected,
       webrtc: !!this._rtc,
+      // El relevo: null si nunca se pidió; si no, activo o por qué no (`code`, `retryAt`).
+      turn: this._turn ? { ...this._turn } : null,
       since: t.since,
       proxy: { ...t.proxy },
       peers
@@ -1566,7 +1594,11 @@ export class WebSocketProxyClient {
     this._pending.delete(id)
     // Con su `code`: quien llama distingue los casos por él, no por la frase (que el proxio
     // puede cambiar o traducir). Antes se perdía aquí y solo quedaba comparar el texto.
-    entry.reject(errorCon(data.error || 'Server error', data.code || null))
+    const e = errorCon(data.error || 'Server error', data.code || null)
+    // «Ahora no» (429) y cuánto esperar, cuando el proxio lo dice.
+    if (data.status) e.status = data.status
+    if (data.retry_after_ms) e.retryAfterMs = data.retry_after_ms
+    entry.reject(e)
   }
 
   _emit (event, ...args) {

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

@@ -11,7 +11,7 @@ export {
 } from './encpub.js'
 
 export { listTransports, routeOf } from './stats.js'
-export { logStats, formatStats } from './stats-log.js'
+export { logStats, formatStats, netReport, splitPeers } from './stats-log.js'
 
 import { WebSocketProxyClient } from './client.js'
 

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

@@ -54,6 +54,7 @@ export function formatStats (s, opts = {}) {
     ` ws.in=${s.proxy.bytesIn} ws.out=${s.proxy.bytesOut}` +
     ` ${pairs('in', sum(s.peers, 'bytesIn'))} ${pairs('out', sum(s.peers, 'bytesOut'))}` +
     ` peers=${talking.length} routes=${routeList}` +
+    (s.turn ? ` turn=${s.turn.active ? 'on' : `off(${s.turn.code || '?'})`}` : '') +
     (silent.length ? ` unanswered=${silent.length} unanswered.out=${silent.reduce((n, p) => n + PATHS.reduce((m, k) => m + p.bytesOut[k], 0), 0)}` : '') +
     (unknown.length ? ` unknown=${unknown.length} unknown.in=${unknown.reduce((n, p) => n + PATHS.reduce((m, k) => m + p.bytesIn[k], 0), 0)}` : '')
   ]
@@ -105,3 +106,63 @@ export function logStats (opts = {}) {
     stop: async () => { clearInterval(timer); await flush() }
   }
 }
+
+/** Bytes para el informe de texto: `B`, `KB` con un decimal, `MB` con dos. */
+const rBytes = (n) => (n < 1024 ? `${n} B` : n < 1024 * 1024 ? `${(n / 1024).toFixed(1)} KB` : `${(n / 1024 / 1024).toFixed(2)} MB`)
+const rPaths = (o) => {
+  const parts = PATHS.filter((k) => (o?.[k] || 0) > 0).map((k) => `${k} ${rBytes(o[k])}`)
+  return parts.length ? parts.join(', ') : '0 B'
+}
+
+/**
+ * Los que contestaron algo (`talking`) y los que solo recibieron (`silent`, resumidos): a un
+ * aparato apagado al que se le mandó un ping no se le llama conexión. `unknown`: quien nos
+ * escribió, nunca recibió respuesta y no sabemos su llave. Tampoco es una conexión.
+ *
+ * @param {Array<object>} peers `TransportStats.peers`
+ */
+export function splitPeers (peers) {
+  const total = (o) => PATHS.reduce((n, k) => n + (o?.[k] || 0), 0)
+  const talking = []
+  const silent = { count: 0, bytesOut: 0, msgsOut: 0 }
+  const unknown = { count: 0, bytesIn: 0, msgsIn: 0 }
+  for (const p of peers) {
+    if (!((p.msgsIn || 0) > 0)) { silent.count++; silent.bytesOut += total(p.bytesOut); silent.msgsOut += p.msgsOut || 0 } else if (!p.pubkey && !((p.msgsOut || 0) > 0)) { unknown.count++; unknown.bytesIn += total(p.bytesIn); unknown.msgsIn += p.msgsIn || 0 } else talking.push(p)
+  }
+  return { talking, silent, unknown }
+}
+
+/**
+ * EL INFORME DE RED COMO TEXTO, para que lo lea una persona: las mismas líneas que el modal de
+ * red del topbar y que las apps nativas (`NetworkStats.report`). A diferencia de `formatStats`
+ * (que va a un log en disco y por eso calla la llave), este se enseña en pantalla a quien lo
+ * pidió, y dice con quién es cada conexión.
+ *
+ * @param {Array<object>} list lo que devolvió `client.stats()` de cada cliente (o `{ url, error }`)
+ * @param {{ label?: (pubkey: string) => string | Promise<string>, now?: Date }} [opts]
+ *   `label`: cómo se nombra un aparato a partir de su llave (su id `AB12-CD34`, su nombre).
+ *   Sin él, o si falla, sale `?`: nunca un trozo de la llave.
+ * @returns {Promise<string>}
+ */
+export async function netReport (list, opts = {}) {
+  const now = opts.now || new Date()
+  let out = `Dotrino network stats · ${now.toISOString().replace(/\.\d{3}Z$/, 'Z')}\n`
+  if (!list.length) out += '(no transports)\n'
+  for (const s of list) {
+    if (s.error) { out += `Proxy ${s.url} | error: ${s.error}\n`; continue }
+    const hhmm = new Date(s.since).toTimeString().slice(0, 8)
+    out += `Proxy ${s.url}${s.app ? ` | app=${s.app}` : ''}${s.node ? ` | node=${s.node}` : ''} | ${s.connected ? 'connected' : 'disconnected'} | since ${hhmm}\n`
+    out += `  proxy total: in ${rBytes(s.proxy.bytesIn)} / out ${rBytes(s.proxy.bytesOut)} (frames ${s.proxy.framesIn ?? '?'}/${s.proxy.framesOut ?? '?'})\n`
+    const { talking, silent, unknown } = splitPeers(s.peers)
+    out += `  peers: ${talking.length}\n`
+    for (const p of talking) {
+      let who = '?'
+      if (p.pubkey && opts.label) { try { who = (await opts.label(p.pubkey)) || '?' } catch (_) { who = '?' } }
+      const tok = p.token ? ` (token ${p.token})` : ''
+      out += `  - ${who}${tok} | route=${p.route} | in: ${rPaths(p.bytesIn)} | out: ${rPaths(p.bytesOut)} | ${(p.msgsIn || 0) + (p.msgsOut || 0)} msgs\n`
+    }
+    if (silent.count) out += `  no answer: ${silent.count} (out ${rBytes(silent.bytesOut)}, ${silent.msgsOut} msgs)\n`
+    if (unknown.count) out += `  unknown senders: ${unknown.count} (in ${rBytes(unknown.bytesIn)}, ${unknown.msgsIn} msgs)\n`
+  }
+  return out
+}

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

@@ -6,7 +6,7 @@
  *   `send()` payloads tagged with `_rtc`.
  * - Once the DataChannel is open, payloads from `client.send(token, ...)`
  *   travel P2P; before that (or on failure) they fall back to the proxy.
- * - STUN-only (no TURN). Symmetric NATs will simply stay on the proxy.
+ * - STUN by default; `client.enableTurn()` adds the proxy's temporary TURN servers.
  *
  * Glare resolution: the peer with the lexicographically smaller token is
  * the "polite" one (rolls back on collision).
@@ -76,6 +76,55 @@ export async function loadNodePeerConnection () {
   return _PC
 }
 
+/**
+ * EL RELEVO, FIJADO A IPv4 — solo fuera del navegador.
+ *
+ * La implementación de Node (`@dotrino/webrtc`, o sea werift) abre el socket UDP hacia el
+ * relevo en IPv4 y nada más, pero resuelve el nombre sin pedir familia. En una máquina con
+ * las dos, el nombre sale en IPv6: el pedido se manda a una dirección que ese socket no
+ * alcanza, se reintenta siete veces (6,4 s medidos) y solo entonces se cae a TCP. Y como la
+ * oferta espera a que termine de reunir candidatos, CADA negociación arrancaba 6,4 s tarde
+ * por punta — una sesión más corta que eso no salía nunca del proxio.
+ *
+ * Con la dirección ya escrita no hay nada que resolver: 30 ms, y el relevo va por UDP.
+ *
+ * Solo las `turn:`. Una `turns:` necesita el nombre para comprobar el certificado, y a un
+ * `stun:` no le pasa esto. Se envuelve desde aquí y no se toca la librería, que es una poda
+ * sin cambios de lógica (README de `dotrino-webrtc`).
+ *
+ * Si el nombre no tiene dirección IPv4, se deja como vino: esa máquina no tiene por dónde
+ * llegar en UDP, y con el nombre la librería todavía llega por TCP.
+ *
+ * @param {any[]} iceServers
+ * @param {{ native?: boolean, lookup?: (host: string) => Promise<string> }} [opts]
+ * @returns {Promise<any[]>}
+ */
+export async function pinTurnToIPv4 (iceServers, opts = {}) {
+  const native = opts.native ?? (typeof globalThis.RTCPeerConnection === 'function')
+  if (native || !Array.isArray(iceServers)) return iceServers
+  let lookup = opts.lookup
+  if (!lookup) {
+    // El nombre va en una variable para que ningún empaquetador lo siga: esto lo importan
+    // las apps de navegador, donde `node:dns` no existe (y donde no se llega hasta aquí).
+    const mod = 'node:dns'
+    const dns = await import(mod)
+    lookup = async (host) => (await dns.promises.lookup(host, { family: 4 })).address
+  }
+  const cache = new Map()
+  const pin = async (url) => {
+    const m = /^(turn:)([^:?[\]]+)((?::\d+)?(?:\?.*)?)$/i.exec(String(url).trim())
+    if (!m || /^[\d.]+$/.test(m[2])) return url
+    if (!cache.has(m[2])) cache.set(m[2], lookup(m[2]).catch(() => null))
+    const ip = await cache.get(m[2])
+    return ip ? m[1] + ip + m[3] : url
+  }
+  return Promise.all(iceServers.map(async (s) => {
+    if (!s || s.urls == null) return s
+    const urls = Array.isArray(s.urls) ? await Promise.all(s.urls.map(pin)) : await pin(s.urls)
+    return { ...s, urls }
+  }))
+}
+
 export class WebRTCManager {
   /**
    * @param {object} opts

package/vault/vendor/vault/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/vault@0.82.1 (dotrino-vault/lib/src/{index,enroll,protocol,passwordLogins,loginClient,b64}.js).
+Copia vendorizada de @dotrino/vault@0.84.0 (dotrino-vault/lib/src/{index,enroll,protocol,passwordLogins,loginClient,b64}.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

@@ -30,7 +30,7 @@
  * `docs/pairing-protocol.md`).
  */
 import { verifyDeviceSig, pubkeyId, commitCode } from '@dotrino/identity/capabilities'
-import { verifyContinuity, canSeal, DEVICE_CAPS } from '@dotrino/identity/acta'
+import { verifyContinuity, canSeal, DEVICE_CAPS, VAULT_CN } from '@dotrino/identity/acta'
 
 /** Un token de emparejamiento vale 5 min. */
 export const PAIRING_TTL_MS = 5 * 60 * 1000
@@ -169,12 +169,16 @@ export function createEnrollDesk ({
    *                       el código, igual que hacía `caps` después.
    */
   async function startPairing ({ scope = defaultScope, ttlMs = defaultTtlMs, label = '', mode = 'join', account = '', caps = null } = {}) {
+    // El nombre de la propia bóveda no es un servicio: su llave firma con el perfil cerrado
+    // y no puede abrir ningún cajón. Un servicio que entrara con ese nombre tampoco podría.
+    if (scopeToCn(scope) === VAULT_CN) throw Object.assign(new Error(`"${VAULT_CN}" is the vault's own name: a service cannot use it`), { code: 'reserved-cn' })
     if (caps != null) {
       if (!Array.isArray(caps)) throw Object.assign(new Error('caps must be a list'), { code: 'bad-caps' })
       const cn = scopeToCn(scope)
-      const bad = caps.filter((c) => !(DEVICE_CAPS.includes(c) || (c === 'secrets' && cn)))
+      const bad = caps.filter((c) => !DEVICE_CAPS.includes(c))
       if (bad.length) throw Object.assign(new Error('unknown permission(s): ' + bad.join(', ')), { code: 'bad-caps' })
-      if (!caps.length) throw Object.assign(new Error('the pairing grants no permission'), { code: 'empty-scope' })
+      // Un servicio puede entrar sin ningún permiso: su cajón lo abre el CN.
+      if (!caps.length && !cn) throw Object.assign(new Error('the pairing grants no permission'), { code: 'empty-scope' })
       caps = [...new Set(caps)]
     }
     pending.clear() // uno a la vez: una sesión nueva supersede a la anterior
@@ -378,13 +382,14 @@ export function createEnrollDesk ({
       throw Object.assign(new Error('this vault cannot add devices to the account record: no certificate was issued'), { code: 'admit-unavailable' })
     }
     // PERMISOS, no tipos (2026-08-22): las capacidades son las del scope ENTERO. Un
-    // cajón (`secrets:<ns>`) suma `secrets` y fija el CN; no borra lo demás — un bot
-    // con `sign,secrets:eco` firma como aparato del acta Y lee solo su cajón.
+    // cajón (`secrets:<ns>`) fija el CN, que es lo que lo abre —no hay permiso aparte
+    // (dueño, 2026-10-13)—, y no borra lo demás: un bot con `sign,secrets:eco` firma como
+    // aparato del acta Y lee solo su cajón.
     // Si quien emparejó ELIGIÓ los permisos (`startPairing({ caps })`), entran esos y en
     // esta misma acta; si no, los que da el scope.
     const cn = scopeToCn(pend.scope)
-    const caps = [...new Set([...(pend.caps || scopeToCaps(pend.scope)), ...(cn ? ['secrets'] : [])])]
-    if (!caps.length) {
+    const caps = [...new Set(pend.caps || scopeToCaps(pend.scope))]
+    if (!caps.length && !cn) {
       throw Object.assign(new Error('the pairing scope grants no permission: no certificate was issued'), { code: 'empty-scope' })
     }
 

package/vault/vendor/vault/index.js

@@ -217,7 +217,10 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
       deviceId: x.sub ? await deviceIdOf(x.sub) : null, sub: x.sub || null,
       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) })
+    // La cadena de selladores va con la lista (como en el daemon): es lo que un aparato de
+    // Node necesita para firmar a nombre de la cuenta de forma que un extraño lo compruebe.
+    const sealerChain = await identity.sealerChain?.().catch(() => null) || null
+    send(from, { type: MSG.DEVICES_RESULT, devices, revoked: (revoked || []).map((r) => r.nonce || r), sealerChain })
     // ¿el que consulta es una máquina revocada que reapareció? → re-emite el REVOKED firmado.
     // Se busca en `revokedCerts`: desde que `issued` solo trae lo vigente, los retirados
     // ya no están ahí y este aviso dejaba de dispararse (se caía en silencio).