@dotrino/identity 0.107.2 → 0.109.0

package/README.md

@@ -19,6 +19,24 @@ Identidad de usuario y rating de peers compartidos entre las apps de Dotrino. Fu
 
 Como todas las apps cargan el vault desde el mismo origin, comparten el mismo `localStorage` aunque ellas estén en orígenes distintos. **Las claves privadas nunca salen del vault** — las apps reciben firmas (de la ECDSA) y plaintext descifrado (de la ECDH) pero nunca las llaves.
 
+## Dónde vive la identidad: web, Android, iOS
+
+Uso para el usuario: [El navegador y las apps instaladas](https://wiki.dotrino.com/empezar/navegador-y-apps/) (wiki). Portada: [id.dotrino.com](https://id.dotrino.com/).
+
+«Identidad Dotrino» es un **concepto** con tres implementaciones. Solo en Android es una app:
+
+| Plataforma | Dónde están las llaves y los perfiles | Quién los comparte |
+|---|---|---|
+| **Navegador** | este paquete: el iframe `id.dotrino.com` (localStorage + IndexedDB de ese navegador, llaves WebCrypto no extraíbles) | todas las apps abiertas **en ese navegador** |
+| **Android nativo** | la app **`com.dotrino.identity`** (Keystore), servicio con permiso de nivel firma | las apps nativas firmadas con la misma llave de Play |
+| **iOS nativo** | **no hay app**: llavero `P7G853375S.com.dotrino.shared` + App Group `group.com.dotrino`, dentro de cada app | las apps del equipo `P7G853375S` |
+
+**El navegador y lo nativo NO se ven, en ninguna dirección.** Chrome no puede enlazar el servicio de `com.dotrino.identity` (exige la firma de Play) y Safari no entra en los grupos del equipo; ninguna app nativa puede leer el almacén de un navegador. El WebView de una app nativa tampoco es el navegador: su iframe `id.dotrino.com` guarda en lo nativo por el puente (`window.DotrinoIdentityKeys`, `nativeStore.js`), no en Chrome ni en Safari.
+
+Para la cuenta son **dos aparatos distintos del acta** (el navegador y el conjunto de apps nativas del teléfono). Se unen como cualquier par de aparatos: emparejando con la bóveda («Adoptar un perfil», `vault.dotrino.com/d`) o entrando con dirección y contraseña. No existe ni se construye un puente para copiar perfiles de un lado a otro. Detalle nativo en `dotrino-native/docs/DISENO.md` §2.
+
+`id.dotrino.com/` tiene dos papeles: dentro de un iframe es la bóveda (carga `vault.js`); abierta directo es la portada (no carga `vault.js`, para no tomar el candado del modo «este dispositivo es bóveda»).
+
 ## Instalación
 
 ```bash
@@ -84,6 +102,7 @@ Inicializa el iframe y resuelve cuando el vault está listo.
 
 - `id.getPeer(publickey)`
 - `id.setNickname(publickey, nickname)`
+- `id.setBlocked(publickey, blocked)` — **bloquear** (0.108): privado, no se firma ni se publica; viaja con tus contactos (`peer.blocked`) a tu bóveda y tus aparatos. Cada app que recibe mensajes lo respeta.
 - `id.setRating(publickey, rating, notes?)` — produce un envelope firmado y lo guarda como `peer.myRating` (rating 0–5).
 - `id.mergeEndorsements(subject, [signedRatings], askerPubkey?)` — para web-of-trust: valida firmas, dedupea por `(ratedBy, subject)`, cap 50.
 - `id.getRatingsForSubject(subject)` → `{ mine, endorsements }` para responder a un `RATING_QUERY`.

package/package.json

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

package/src/index.d.ts

@@ -65,6 +65,9 @@ export interface PeerInfo {
   queryStats?: QueryStats
   firstSeen?: number
   lastSeen?: number
+  /** You blocked them (private, never published). */
+  blocked?: boolean
+  changedAt?: number
 }
 
 export interface Challenge {
@@ -106,6 +109,8 @@ export class Identity {
   verifyResponse (response: ChallengeResponse): Promise<VerifyResult>
   getPeer (publickey: string): Promise<PeerInfo | null>
   setNickname (publickey: string, nickname: string): Promise<PeerInfo>
+  /** Private block: not signed, not published; travels with your contacts. */
+  setBlocked (publickey: string, blocked: boolean): Promise<PeerInfo>
   setRating (publickey: string, rating: number, notes?: string): Promise<PeerInfo>
   listPeers (): Promise<PeerInfo[]>
   forgetPeer (publickey: string): Promise<void>
@@ -182,9 +187,9 @@ export class Identity {
    * abierto: viaja sellado a la llave de cifrado de este aparato y se descifra aquí dentro.
    * `ctxError` si no se pudo abrir; sin ninguno de los dos, el pedido no dijo qué corría.
    */
-  vaultApprovals (op: 'approvals' | 'approve' | 'deny', args?: { id?: string; profile?: string }): Promise<any>
+  vaultApprovals (op: 'approvals' | 'approve' | 'deny', args?: { id?: string; profile?: string; notify?: boolean }): Promise<any>
   /** Los pedidos de TODAS las cuentas de este dispositivo que aprueban, sin cambiar la activa. */
-  vaultApprovalsAll (): Promise<Array<{ profile: string; name: string; current: boolean; items: ApprovalRequest[]; error?: string }>>
+  vaultApprovalsAll (args?: { notify?: boolean }): Promise<Array<{ profile: string; name: string; current: boolean; items: ApprovalRequest[]; error?: string }>>
   canApproveVault (): Promise<boolean>
   getVaultCert (): Promise<any>
   onVault (handler: (payload: any) => void): () => void

package/src/index.js

@@ -209,6 +209,11 @@ export class Identity {
     return this._call('getPeer', { publickey })
   }
 
+  /** Bloquear (o desbloquear) a alguien: privado, viaja con tus contactos y no se publica. */
+  async setBlocked (publickey, blocked) {
+    return this._call('setBlocked', { publickey, blocked })
+  }
+
   async setNickname (publickey, nickname) {
     return this._call('setNickname', { publickey, nickname })
   }
@@ -471,6 +476,10 @@ export class Identity {
    * PEDIDOS DE APROBACIÓN de la bóveda (cajones con `approval`): `op` = `approvals` ·
    * `approve` · `deny` (estos dos con `{ id }`). Requiere `vault:approve` en el cert.
    *
+   * `args.notify` (solo con `approvals`): `true`/`false` según a este aparato le lleguen los
+   * avisos de pedidos. La bóveda lo apunta, y para actualizarse solo pide permiso si hay un
+   * aprobador que pueda enterarse. No pasarlo no cambia lo ya dicho.
+   *
    * `args.profile` apunta a OTRA cuenta de este dispositivo (la que diga
    * `vaultApprovalsAll`); sin él es la activa.
    */
@@ -489,8 +498,8 @@ export class Identity {
    *
    * Aprobar uno de otra cuenta: `vaultApprovals('approve', { id, profile })`.
    */
-  async vaultApprovalsAll () {
-    return this._call('vaultApprovalsAll', {}, 30000)
+  async vaultApprovalsAll (args) {
+    return this._call('vaultApprovalsAll', args || {}, 30000)
   }
 
   /** Registra el token de push de la app nativa (FCM/APNs) bajo la llave de este aparato. */

package/src/node.js

@@ -166,6 +166,7 @@ export class Identity {
   }
   getPeer (publickey) { return this._h('getPeer', { publickey }) }
   setNickname (publickey, nickname) { return this._h('setNickname', { publickey, nickname }) }
+  setBlocked (publickey, blocked) { return this._h('setBlocked', { publickey, blocked }) }
   setRating (publickey, rating, notes) { return this._h('setRating', { publickey, rating, notes }) }
   listPeers () { return this._h('listPeers') }
   forgetPeer (publickey) { return this._h('forgetPeer', { publickey }) }
@@ -262,7 +263,7 @@ export class Identity {
   getVaultCert () { return this._h('getVaultCert') }
   vaultApprovals (op, args) { return this._h('vaultApprovals', { op, ...(args || {}) }) }
   /** Los pedidos de TODAS las cuentas que aprueban, sin cambiar la activa. */
-  vaultApprovalsAll () { return this._h('vaultApprovalsAll') }
+  vaultApprovalsAll (args) { return this._h('vaultApprovalsAll', args || {}) }
   onVault (handler) { return this.on('vault', handler) }
   // Multi-perfil por dispositivo (crear/cambiar reinicializa con el nuevo perfil activo).
   listProfiles () { return this._h('listProfiles') }

package/vault/capabilities.js

@@ -27,27 +27,12 @@ const ECDSA = { name: 'ECDSA', namedCurve: 'P-256' }
 const ECDH = { name: 'ECDH', namedCurve: 'P-256' }
 const SIGN = { name: 'ECDSA', hash: { name: 'SHA-256' } }
 
-/**
- * HASTA CUÁNDO SE ACEPTA UN PAPEL DEL MODELO VIEJO — **2026-10-01**, y se quita ese día.
- *
- * Los certificados de antes de 0.73 llevaban `exp` y no `seq`. Al pasar la bóveda al modelo
- * del acta, TODOS los aparatos ya enrolados se quedaban fuera de golpe (`shape`) y sin forma
- * de volver: el mostrador de renovación los rechazaba por lo mismo. Diez máquinas —los dos
- * proxios, los nodes de contenido, el bot— habrían necesitado re-enrolarse a mano, con TTY
- * en los dos lados.
- *
- * Así que se aceptan, con dos frenos y ninguna concesión de fondo:
- *   · hasta su PROPIO vencimiento, que sigue valiendo (el más lejano es 2026-09-30);
- *   · y en ningún caso pasado este tope.
- * Además el mostrador los cruza con el acta igual que a los nuevos, así que un papel viejo
- * no autoriza nada que el acta de hoy no autorice.
- *
- * Se apaga solo por partida doble: ninguna bóveda 0.73+ puede EMITIR uno de estos
- * (`signDelegationWith` solo escribe `seq`), así que cuando el último caduque esta rama es
- * inalcanzable. **Y aun así se borra en la fecha**, porque un repliegue sin fecha no es una
- * migración: es un agujero (`CLAUDE.md`).
+/*
+ * EL MODELO VIEJO YA NO ENTRA. Los papeles de antes de 0.73 llevaban `exp` y no `seq`; se
+ * aceptaron hasta el 2026-10-01 por un repliegue de migración declarado y con fecha, y esa
+ * fecha pasó: se quitó (2026-10-05). Un papel sin `seq` se rechaza con `legacy-cert-retirado`,
+ * el mismo código que daba el repliegue al caducar, así que quien lo comprueba no cambia.
  */
-export const LEGACY_CERTS_UNTIL = Date.parse('2026-10-01T00:00:00Z')
 
 const enc = (s) => new TextEncoder().encode(s)
 
@@ -252,9 +237,8 @@ export async function verifyDelegation ({ cert, expectedScope, expectedSub, acta
   const { v, iss, sub, scope, iat, seq, nonce, sig } = cert
   if (v !== 1 || typeof iss !== 'string' || typeof sub !== 'string' || typeof sig !== 'string') return { ok: false, reason: 'shape' }
   if (typeof iat !== 'number' || (typeof scope !== 'string' && !Array.isArray(scope))) return { ok: false, reason: 'shape' }
-  // ¿ES UN PAPEL DEL MODELO VIEJO? Llevaba `exp` y no `seq` (ver `LEGACY_CERTS_UNTIL`).
-  const legado = typeof seq !== 'number'
-  if (legado && typeof cert.exp !== 'number') return { ok: false, reason: 'shape' }
+  // UN PAPEL DEL MODELO VIEJO (con `exp`, sin `seq`) ya no vale: el repliegue se retiró.
+  if (typeof seq !== 'number') return { ok: false, reason: typeof cert.exp === 'number' ? 'legacy-cert-retirado' : 'shape' }
   if (!(await rawVerify(iss, enc(canonicalStringify(delegationBody(cert))), sig))) return { ok: false, reason: 'bad-signature' }
   // EL ACTA MANDA, Y NO HAY RELOJ (dueño, 2026-08-31). El papel no vence: dice «una
   // selladora de este perfil, mirando el acta nº `seq`, avaló esta llave». Lo que puede
@@ -280,19 +264,7 @@ export async function verifyDelegation ({ cert, expectedScope, expectedSub, acta
   // estaba apagado: vuelve, su papel ya no vale, y renovarlo exige una selladora ABIERTA.
   // O sea que un cambio de acta te obligaría a abrir la bóveda para que tus aparatos
   // volvieran — justo lo que se acaba de quitar de en medio.
-  if (!legado && seq > actaSeq) return { ok: false, reason: 'acta-vieja' }
-  // REPLIEGUE DE MIGRACIÓN, declarado y con fecha (ver `LEGACY_CERTS_UNTIL`). Un papel del
-  // modelo viejo se sigue aceptando, pero SOLO hasta su propio vencimiento: no se le regala
-  // ni un día. No hay nada que decidir sobre el acta que nombra, porque no nombra ninguna.
-  //
-  // Lo que NO se relaja, y es lo que hace que esto no sea un agujero: quien lo emitió tiene
-  // que poder sellar (abajo), y el mostrador cruza igual con el acta (`memberCanScope`). Un
-  // papel viejo no autoriza nada que el acta de hoy no autorice; lo único que compra es
-  // seguir hablando mientras su máquina se actualiza.
-  if (legado) {
-    if (Date.now() > cert.exp) return { ok: false, reason: 'expired' }
-    if (Date.now() > LEGACY_CERTS_UNTIL) return { ok: false, reason: 'legacy-cert-retirado' }
-  }
+  if (seq > actaSeq) return { ok: false, reason: 'acta-vieja' }
   // Y QUIEN LO EMITIÓ TIENE QUE PODER SELLAR. No se compara contra «la maestra»: cualquiera
   // que el acta nombre sellador emite papeles válidos — si no, la segunda bóveda podría
   // invalidar todos los certificados al sellar y luego no poder dar los nuevos.
@@ -304,7 +276,7 @@ export async function verifyDelegation ({ cert, expectedScope, expectedSub, acta
       : (revoked instanceof Set ? revoked.has(nonce) : !!revoked[nonce])
     if (isRev) return { ok: false, reason: 'revoked' }
   }
-  return { ok: true, iss, sub, scope, iat, seq: legado ? null : seq, nonce, legacy: legado || undefined }
+  return { ok: true, iss, sub, scope, iat, seq, nonce }
 }
 
 /**

package/vault/core.js

@@ -18,7 +18,7 @@
  * vault, compartida por todos los runtimes.
  */
 
-import { signDelegationWith, LEGACY_CERTS_UNTIL } from './capabilities.js'
+import { signDelegationWith } from './capabilities.js'
 import * as Acta from './acta.js'
 import * as Content from './content.js'
 import { syncPeers, stampOf } from './peerSync.js'
@@ -1015,14 +1015,13 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
    * el vault y hay un aparato expirado debe quitarlo del acta en una nueva acta»*).
    *
    * Muerto es un aparato cuyo papel no tiene vuelta atrás: todos los certificados que ESTA
-   * bóveda le dio son del modelo viejo (sin `seq`) y ya no valen — vencidos, o pasado
-   * `LEGACY_CERTS_UNTIL`, que los retira a todos. Renovar tampoco lo salva: la renovación
+   * bóveda le dio son del modelo viejo (sin `seq`), que ya no vale desde que se retiró su
+   * repliegue (2026-10-01). Renovar tampoco lo salva: la renovación
    * viaja firmada con ese mismo papel, y la bóveda lo rechaza (`unauthorized: expired`).
    * Hasta ahora se quedaban en el acta para siempre, como miembros que nadie podía usar.
    *
    * Lo que NO se toca, porque no hay datos para juzgarlo:
    *   · un miembro sin certificados de esta bóveda (se los pudo dar otra);
-   *   · un papel viejo sin `exp` antes del corte;
    *   · esta misma llave.
    *
    * Todo sale en UNA acta: las bajas y la clave de contenido nueva van en el mismo sello,
@@ -1041,8 +1040,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
       if (!porSub.has(d.sub)) porSub.set(d.sub, [])
       porSub.get(d.sub).push(d)
     }
-    const muerto = (d) => typeof d.seq !== 'number' &&
-      (now > LEGACY_CERTS_UNTIL || (typeof d.exp === 'number' && now > d.exp))
+    const muerto = (d) => typeof d.seq !== 'number'
     const muertos = [...porSub]
       .filter(([sub, ds]) => sub !== publickeyJwkStr && ds.every(muerto))
       .map(([sub, ds]) => ({ pub: sub, label: ds[0]?.label || '' }))
@@ -1383,13 +1381,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
       // él se va la última razón por la que la maestra tenía que estar disponible sin nadie
       // delante. Renovar pasa a ocurrir justo cuando ya hay una selladora abierta, porque
       // cambiar el acta ES tenerla abierta.
-      // Y LA MIGRACIÓN: un papel del modelo viejo (sin `seq`) que todavía vale se cambia por
-      // uno nuevo. Sin esto moría en su fecha aunque el aparato se usara a diario, y ya no
-      // tenía arreglo — el teléfono que aprueba se quedó así el 2026-09-22. Caduca sola: a
-      // partir de `LEGACY_CERTS_UNTIL` no queda ningún papel viejo que valga.
-      const legadoVivo = typeof v.cert.seq !== 'number' && typeof v.cert.exp === 'number' &&
-        now < v.cert.exp && now < LEGACY_CERTS_UNTIL
-      if (!legadoVivo && !certDesfasadoDelActa()) return
+      if (!certDesfasadoDelActa()) return
       if (now - renewLastTry < RENEW_RETRY_MS) return
       renovarCert().catch(() => {}) // best-effort: el cert vigente sigue sirviendo mientras tanto
     } catch (_) {}
@@ -1461,6 +1453,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
         if (b.contactNotes !== undefined) merged.contactNotes = b.contactNotes
         if (b.encryptionPubkey) merged.encryptionPubkey = b.encryptionPubkey
         if (typeof b.rating === 'number') merged.rating = b.rating
+        if (typeof b.blocked === 'boolean') merged.blocked = b.blocked
       }
       merged.firstSeen = Math.min(a.firstSeen || aSeen || Date.now(), b.firstSeen || bSeen || Date.now())
       merged.lastSeen = Math.max(aSeen, bSeen)
@@ -1984,6 +1977,18 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
       return p[publickey] || null
     },
 
+    /**
+     * BLOQUEAR a alguien (dueño, 2026-10-05): un indicador PRIVADO, aparte de la calificación.
+     * No se firma ni se publica —no es una opinión sobre esa persona, es tu decisión de no
+     * recibirla—, viaja con el libro de contactos a tu bóveda y a tus aparatos, y lo respeta
+     * cada app que recibe mensajes (el messenger, el primero). Desbloquear deja `false` y no
+     * borra el campo: así el cambio también llega a los demás aparatos.
+     */
+    async setBlocked ({ publickey, blocked }) {
+      if (!publickey) throw new Error('publickey required')
+      return upsertPeer(publickey, { blocked: !!blocked, changedAt: Date.now() })
+    },
+
     async setNickname ({ publickey, nickname }) {
       return upsertPeer(publickey, { nickname: String(nickname || '').slice(0, 40) })
     },
@@ -2396,14 +2401,17 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
       if (e.id === currentPid) { me = { ...(me || {}), nickname: e.name }; saveMe(me) }
       return { id: e.id, name: e.name }
     },
+    /**
+     * BORRAR UNA CUENTA, también la activa y también la única (dueño, 2026-10-05): borrar tu
+     * cuenta desde la app es un derecho del usuario, y la App Store lo exige (norma 5.1.1(v)).
+     * La alerta es de la INTERFAZ, que pregunta antes. Si era la activa, `current` dice cuál
+     * queda, y la app tiene que RECARGAR; si no queda ninguna, el arranque estrena una nueva
+     * y vacía (ver `purgeProfile`).
+     */
     async deleteProfile ({ id } = {}) {
-      const list = loadProfiles()
-      // El freno es de la INTERFAZ: el botón «Borrar» de la página de perfiles no puede
-      // dejarte sin ninguna de un clic. La expulsión no pasa por aquí (ver `purgeProfile`):
-      // ahí sí se va la última, porque no es un descuido sino que te echaron.
-      if (list.length <= 1) throw new Error('cannot delete the only profile')
-      if (!list.find((p) => p.id === id)) throw new Error('profile does not exist')
-      return purgeProfile(id)
+      if (!loadProfiles().find((p) => p.id === id)) throw new Error('profile does not exist')
+      const wasCurrent = id === currentPid
+      return { ...(await purgeProfile(id)), wasCurrent }
     },
 
     // ----- ENTRAR CON USUARIO Y CONTRASEÑA -----
@@ -3049,12 +3057,12 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
      * `profile` apunta a OTRA cuenta de este mismo dispositivo (ver `vaultApprovalsAll`):
      * sin él es la activa, como siempre.
      */
-    async vaultApprovals ({ op, id, profile = null } = {}) {
+    async vaultApprovals ({ op, id, profile = null, notify } = {}) {
       if (profile && profile !== currentPid) return approvalsDeOtroPerfil(profile, { op, id })
       const v = loadVaultCert(); const device = loadVaultDevice()
       if (!v?.cert || !device) throw new Error('this device is not paired with a vault')
       maybeRenewVaultCert()
-      const ask = (cert) => remoteApproval({ master: v.master, proxy: v.proxy, device, cert, op, id, onRevoked: wipeVaultLink })
+      const ask = (cert) => remoteApproval({ master: v.master, proxy: v.proxy, device, cert, op, id, notify, onRevoked: wipeVaultLink })
       try {
         let r
         try { r = await ask(v.cert) } catch (e) {
@@ -3096,7 +3104,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
      * @returns {Promise<Array<{ profile, name, items, error? }>>} una entrada por cuenta que
      *   aprueba — con sus pedidos, o con el motivo por el que no se pudo preguntar.
      */
-    async vaultApprovalsAll () {
+    async vaultApprovalsAll ({ notify } = {}) {
       // La activa sí se pone al día: es la única en la que esta pantalla puede escribir.
       try { maybeRenewVaultCert() } catch (_) {}
       const perfiles = loadProfiles()
@@ -3111,7 +3119,9 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
         }
         if (!device) return { ...base, items: [], error: 'no-key' }
         try {
-          const r = await remoteApproval({ master: v.master, proxy: v.proxy, device, cert: v.cert, op: 'approvals' })
+          // `notify` habla de la cuenta ACTIVA: los avisos se suscriben bajo SU llave. De las
+          // demás no se dice nada, que no es lo mismo que decir que no.
+          const r = await remoteApproval({ master: v.master, proxy: v.proxy, device, cert: v.cert, op: 'approvals', ...(p.id === currentPid ? { notify } : {}) })
           const items = Array.isArray(r?.items) ? await abrirContextos(r.items, p.id) : []
           return { ...base, items }
         } catch (e) {

package/vault/index.html

@@ -1,24 +1,155 @@
 <!DOCTYPE html>
-<html lang="en">
+<html lang="es">
 <head>
   <meta charset="UTF-8">
-  <title>Dotrino Identity Vault</title>
-  <meta name="robots" content="noindex,nofollow">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover">
+  <!-- Esta página tiene DOS papeles según cómo se abra:
+       · en un iframe (lo normal): es la bóveda de identidad de todas las apps. Carga
+         vault.js y no enseña nada.
+       · abierta directo: es la portada que explica qué es Identidad Dotrino. NO carga
+         vault.js (una pestaña de portada no debe tomar el candado del modo «este
+         dispositivo es bóveda» ni atender a nadie), y carga el topbar y GoatCounter, que
+         dentro del iframe sobrarían (contarían cada arranque de cada app). -->
+  <script>if (window.top !== window) document.documentElement.classList.add('embedded')</script>
+  <title>Identidad Dotrino — tu llave y tus perfiles, en tu aparato</title>
+  <meta name="description" content="La identidad de Dotrino: una llave y tus perfiles que viven en tu aparato y comparten todas las apps de Dotrino. Cómo funciona en el navegador, en Android y en iPhone.">
+  <link rel="canonical" href="https://id.dotrino.com/">
+  <link rel="icon" type="image/png" href="icon-192.png">
+  <link rel="apple-touch-icon" href="icon-192.png">
+  <meta name="theme-color" content="#0a3570">
+  <meta property="og:type" content="website">
+  <meta property="og:locale" content="es_ES">
+  <meta property="og:locale:alternate" content="en_US">
+  <meta property="og:site_name" content="Dotrino">
+  <meta property="og:title" content="Identidad Dotrino">
+  <meta property="og:description" content="Tu llave y tus perfiles viven en tu aparato y los comparten todas las apps de Dotrino. En el navegador, en Android y en iPhone.">
+  <meta property="og:url" content="https://id.dotrino.com/">
+  <meta property="og:image" content="https://id.dotrino.com/og.jpg">
+  <meta property="og:image:width" content="1200">
+  <meta property="og:image:height" content="630">
+  <meta name="twitter:card" content="summary_large_image">
+  <meta name="twitter:title" content="Identidad Dotrino">
+  <meta name="twitter:description" content="Tu llave y tus perfiles viven en tu aparato y los comparten todas las apps de Dotrino.">
+  <meta name="twitter:image" content="https://id.dotrino.com/og.jpg">
+  <script type="application/ld+json">
+  {
+    "@context": "https://schema.org",
+    "@type": "WebApplication",
+    "name": "Identidad Dotrino",
+    "url": "https://id.dotrino.com/",
+    "description": "La identidad compartida de las apps de Dotrino: una llave y tus perfiles que viven en tu aparato.",
+    "applicationCategory": "SecurityApplication",
+    "operatingSystem": "Web, Android, iOS",
+    "offers": { "@type": "Offer", "price": "0", "priceCurrency": "USD" },
+    "publisher": { "@type": "Organization", "name": "Dotrino", "url": "https://dotrino.com/" }
+  }
+  </script>
   <style>
-    body { font-family: system-ui, sans-serif; padding: 1rem; color: #444; background: #fafafa; }
-    code { background: #eee; padding: 2px 6px; border-radius: 3px; }
+    :root {
+      --brand: #0a3570;
+      --accent: #00658c;
+      --bg: #f6f8fb;
+      --panel: #ffffff;
+      --ink: #14213d;
+      --muted: #5a6478;
+      --line: #dfe5ee;
+      --warn-bg: #fff7e6;
+      --warn-line: #f0c36d;
+      --dotrino-topbar-bg: rgba(255, 255, 255, .92);
+      --dotrino-topbar-border: var(--line);
+      --dotrino-topbar-text: var(--ink);
+      --dotrino-topbar-muted: var(--muted);
+      --dotrino-topbar-accent: var(--accent);
+    }
+    * { box-sizing: border-box; }
+    html, body { margin: 0; padding: 0; }
+    body {
+      background: var(--bg); color: var(--ink);
+      font: 16px/1.6 system-ui, -apple-system, Segoe UI, Roboto, sans-serif;
+      -webkit-text-size-adjust: 100%;
+    }
+    html.embedded body { background: transparent; }
+    html.embedded #home { display: none; }
+    a { color: var(--accent); }
+    .wrap { max-width: 860px; margin: 0 auto; padding: 28px 20px 80px; }
+    h1 { color: var(--brand); font-size: clamp(30px, 6vw, 42px); line-height: 1.15; margin: 8px 0 10px; }
+    h2 { color: var(--brand); font-size: 22px; margin: 40px 0 12px; }
+    h3 { margin: 0 0 6px; font-size: 18px; }
+    .lead { font-size: 19px; color: var(--muted); max-width: 640px; }
+    .cards { display: grid; gap: 14px; grid-template-columns: repeat(auto-fit, minmax(230px, 1fr)); }
+    .card { background: var(--panel); border: 1px solid var(--line); border-radius: 14px; padding: 18px; }
+    .card p { margin: 6px 0; }
+    .tag { display: inline-block; font-size: 12px; font-weight: 600; color: var(--accent); text-transform: uppercase; letter-spacing: .04em; }
+    .warn { background: var(--warn-bg); border: 1px solid var(--warn-line); border-radius: 14px; padding: 18px 20px; }
+    .warn p { margin: 8px 0; }
+    ul { padding-left: 20px; }
+    footer { margin-top: 48px; color: var(--muted); font-size: 14px; }
+    html[lang="en"] [data-lang="es"] { display: none; }
+    html:not([lang="en"]) [data-lang="en"] { display: none; }
   </style>
 </head>
 <body>
-  <h1>Dotrino — Identity Vault</h1>
-  <p>This page is the cross-app storage for Dotrino identities.
-     It is meant to be embedded as an invisible iframe by the apps.</p>
-  <p>Stored in <code>localStorage</code> on this origin:</p>
-  <ul>
-    <li>Your ECDSA P-256 keypair (private key never leaves this page).</li>
-    <li>Nicknames and ratings of peers you've met.</li>
-  </ul>
-  <p>Source: <a href="https://github.com/imdotrino/dotrino-identity" target="_blank" rel="noopener">github.com/imdotrino/dotrino-identity</a></p>
+  <div id="home">
+    <dotrino-topbar profile
+      brand="Identidad"
+      icon="icon-192.png"
+      no-back
+      support-repo="imdotrino/dotrino-identity"
+      support-discord="https://discord.gg/D648uq7cth"></dotrino-topbar>
+
+    <main class="wrap">
+      <h1>Identidad Dotrino</h1>
+      <p class="lead" data-lang="es">Tu llave y tus perfiles. Viven en tu aparato, no se registran en ningún lado y los comparten todas las apps de Dotrino.</p>
+      <p class="lead" data-lang="en">Your key and your profiles. They live on your device, aren't registered anywhere, and every Dotrino app shares them.</p>
+
+      <h2 data-lang="es">Dónde vive, según dónde uses Dotrino</h2>
+      <h2 data-lang="en">Where it lives, depending on where you use Dotrino</h2>
+      <div class="cards">
+        <section class="card">
+          <span class="tag" data-lang="es">Navegador</span><span class="tag" data-lang="en">Browser</span>
+          <h3 data-lang="es">Se crea sola</h3><h3 data-lang="en">It creates itself</h3>
+          <p data-lang="es">La primera vez que abres una app de Dotrino, tu navegador crea tu llave. Todas las apps que abras <b>en ese navegador</b> la comparten.</p>
+          <p data-lang="en">The first time you open a Dotrino app, your browser creates your key. Every app you open <b>in that browser</b> shares it.</p>
+        </section>
+        <section class="card">
+          <span class="tag">Android</span>
+          <h3 data-lang="es">Una app: Identidad Dotrino</h3><h3 data-lang="en">An app: Dotrino Identity</h3>
+          <p data-lang="es">Las apps de Dotrino instaladas desde Google Play guardan tus llaves y perfiles en la app <b>Identidad Dotrino</b>. No se abre ni hace nada sola: está ahí para que las demás la compartan. Las apps que la necesitan te avisan si falta.</p>
+          <p data-lang="en">Dotrino apps installed from Google Play keep your keys and profiles in the <b>Dotrino Identity</b> app. You don't open it and it does nothing on its own: it's there so the others can share it. The apps that need it tell you if it's missing.</p>
+          <p><a href="https://play.google.com/apps/internaltest/4699800053552003281" rel="noopener"><span data-lang="es">Identidad Dotrino en Google Play (beta)</span><span data-lang="en">Dotrino Identity on Google Play (beta)</span></a></p>
+        </section>
+        <section class="card">
+          <span class="tag" data-lang="es">iPhone y iPad</span><span class="tag" data-lang="en">iPhone and iPad</span>
+          <h3 data-lang="es">No es una app, pero existe</h3><h3 data-lang="en">Not an app, but it's there</h3>
+          <p data-lang="es">En iPhone <b>no hay app de Identidad Dotrino, ni hace falta</b>. Apple deja que las apps de un mismo fabricante compartan un espacio guardado, y ahí cada app de Dotrino guarda tus perfiles para las demás. No hay nada que instalar.</p>
+          <p data-lang="en">On iPhone <b>there is no Dotrino Identity app, and none is needed</b>. Apple lets apps from the same maker share a saved space, and each Dotrino app keeps your profiles there for the others. There's nothing to install.</p>
+        </section>
+      </div>
+
+      <h2 data-lang="es">El navegador y las apps instaladas no se ven</h2>
+      <h2 data-lang="en">The browser and installed apps don't see each other</h2>
+      <div class="warn">
+        <p data-lang="es"><b>Los perfiles de tu navegador no aparecen en las apps instaladas desde la tienda, y los de las apps instaladas no aparecen en el navegador.</b> El teléfono no deja que uno mire dentro del otro. Pasa igual en Android y en iPhone.</p>
+        <p data-lang="en"><b>Your browser's profiles don't show up in apps installed from the store, and the installed apps' profiles don't show up in the browser.</b> The phone doesn't let one look inside the other. It's the same on Android and iPhone.</p>
+        <p data-lang="es">Para usar el mismo perfil en los dos, se conectan a tu bóveda como dos aparatos de tu cuenta, o se inicia sesión con tu dirección y tu contraseña. Si no haces nada, cada lado sigue con su propia cuenta y todo funciona igual.</p>
+        <p data-lang="en">To use the same profile in both, connect them to your vault as two devices of your account, or sign in with your address and password. If you do nothing, each side keeps its own account and everything works the same.</p>
+        <p><a data-lang="es" href="https://wiki.dotrino.com/empezar/navegador-y-apps/">Cómo usar el mismo perfil en los dos</a><a data-lang="en" href="https://wiki.dotrino.com/en/empezar/navegador-y-apps/">How to use the same profile in both</a></p>
+      </div>
+
+      <h2 data-lang="es">Más</h2>
+      <h2 data-lang="en">More</h2>
+      <ul>
+        <li><a href="https://profile.dotrino.com/"><span data-lang="es">Administrar tus perfiles</span><span data-lang="en">Manage your profiles</span></a></li>
+        <li><a data-lang="es" href="https://wiki.dotrino.com/empezar/identidad/">Tu identidad y tus perfiles</a><a data-lang="en" href="https://wiki.dotrino.com/en/empezar/identidad/">Your identity and your profiles</a></li>
+        <li><a data-lang="es" href="https://wiki.dotrino.com/empezar/otros-dispositivos/">Usar tu cuenta en otros dispositivos</a><a data-lang="en" href="https://wiki.dotrino.com/en/empezar/otros-dispositivos/">Use your account on other devices</a></li>
+      </ul>
+
+      <footer>
+        <p>MIT · <a href="https://github.com/imdotrino/dotrino-identity">imdotrino/dotrino-identity</a> · <span data-lang="es">parte de</span><span data-lang="en">part of</span> <a href="https://dotrino.com/">Dotrino</a></p>
+      </footer>
+    </main>
+  </div>
+
   <!-- Transporte self-hosted (vendorizado): el emparejamiento de dispositivos importa
        @dotrino/proxy-client de forma perezosa; este import map lo resuelve sin CDN. -->
   <script type="importmap">
@@ -33,6 +164,21 @@
     "@dotrino/identity/content": "./content.js"
   } }
   </script>
-  <script type="module" src="./vault.js"></script>
+  <script type="module">
+    if (window.top !== window) {
+      import('./vault.js')
+    } else {
+      // Portada. Analítica cookieless autohosteada (GoatCounter); no cuenta en localhost/LAN.
+      window.goatcounter = { path: (p) => location.hostname + p }
+      const goat = document.createElement('script')
+      goat.async = true
+      goat.dataset.goatcounter = 'https://goat.dotrino.com/count'
+      goat.src = 'https://goat.dotrino.com/count.js'
+      document.head.appendChild(goat)
+      // Por CDN el topbar va SIEMPRE con `+esm` (CONVENCIONES §5). Pone el idioma en
+      // <html lang>, que es de lo que cuelgan los bloques [data-lang].
+      import('https://cdn.jsdelivr.net/npm/@dotrino/topbar@0.12/+esm')
+    }
+  </script>
 </body>
 </html>

package/vault/remote.js

@@ -452,11 +452,16 @@ export async function requestAdmin ({ master, proxy, device, cert, op, onRevoked
  * `vault:approve` — que, como `admin`, no se recibe al emparejar: se concede a mano.
  * La bóveda contesta un cuerpo firmado por la maestra (`{ op, items | ok }`).
  */
-export async function requestApproval ({ master, proxy, device, cert, op, id, onRevoked } = {}) {
+export async function requestApproval ({ master, proxy, device, cert, op, id, notify, onRevoked } = {}) {
+  // `notify`: al pedir la lista, este aparato dice si le llegan los avisos. La bóveda lo
+  // apunta y es lo que mira para saber si hay a quién pedirle permiso antes de actualizarse.
+  // Solo va si quien llama lo SABE (true o false): no decir nada no cambia lo ya dicho.
+  const data = id ? { op, id } : { op }
+  if (op === 'approvals' && typeof notify === 'boolean') data.notify = notify
   const res = await vaultRpc({
     master, proxy, device, cert, onRevoked,
     sendType: MSG.SECRETS, okType: MSG.SECRETS_RESULT,
-    data: id ? { op, id } : { op }
+    data
   })
   return res.body
 }

package/vault/robots.txt

@@ -0,0 +1,3 @@
+User-agent: *
+Allow: /
+Sitemap: https://id.dotrino.com/sitemap.xml

package/vault/sitemap.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+  <url><loc>https://id.dotrino.com/</loc></url>
+</urlset>

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

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/proxy-client@0.26.0 (dotrino-proxy-client/src/{index,client,signature,canonical,sealing,encpub,webrtc}.js).
+Copia vendorizada de @dotrino/proxy-client@0.30.1 (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

@@ -2,6 +2,7 @@ import { buildSignedChannel, getPublicKeyJwk, signData, samePubkey } from './sig
 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 { TrafficStats, utf8Length, registerTransport, unregisterTransport } from './stats.js'
 
 /**
  * Error con un `code` estable.
@@ -46,6 +47,20 @@ function errorCon (mensaje, code) {
  *   - 'reconnecting'      (attempt, max)
  *   - 'reconnect_failed'  (attempts)
  */
+const APP_RE = /^[a-z0-9][a-z0-9-]{0,31}$/
+
+/**
+ * Valida un nombre de app (`messenger`, `vault`…). Lo que no tiene forma LANZA: un nombre mal
+ * escrito haría que el timbre no sonara nunca en esa app, y eso no se ve.
+ */
+function checkApp (app) {
+  if (app == null) return null
+  if (typeof app !== 'string' || !APP_RE.test(app)) {
+    throw Object.assign(new Error(`app: "${app}" is not a valid app name (a-z, 0-9, -; up to 32)`), { code: 'bad-app' })
+  }
+  return app
+}
+
 export class WebSocketProxyClient {
   constructor (options = {}) {
     this.url = options.url || 'wss://proxy.dotrino.com'
@@ -69,6 +84,18 @@ export class WebSocketProxyClient {
     this.requireSealed = options.requireSealed === true
     this.myEncPrivateKey = options.myEncPrivateKey || null
 
+    /**
+     * QUÉ APP ES ESTA (websocket-proxy ≥ 1.4.0). En un teléfono varias apps hablan con la
+     * MISMA llave (el perfil del teléfono), y el proxio necesita saber a cuál despertar y a
+     * cuál entregarle la cola: sin esto, la última en suscribirse se llevaba todos los
+     * timbres y la primera en conectarse, los mensajes de todas. Es ruteo, no contenido.
+     *
+     * Se dice al identificarse (solo baja lo suyo de la cola), al suscribirse al timbre (solo
+     * suena con lo suyo) y quien le escribe lo marca con `sendByPubkey(…, { app })`.
+     * Sin `app`, como antes: recibe todo.
+     */
+    this.app = checkApp(options.app)
+
     /**
      * MI llave de cifrado, la pública. Con ella puesta, `identify` anuncia al proxio
      * —firmado— que esta identidad se abre por aquí, y cualquiera que sepa mi pubkey puede
@@ -154,6 +181,7 @@ export class WebSocketProxyClient {
     this._pending = new Map() // messageId -> { resolve, reject, timer }
     this._nextId = 1
     this._tokenWatch = new Map() // messageId -> { token, sobre, peerPubkey, timer }
+    this._traffic = new TrafficStats()
 
     this._rtc = this.enableWebRTC ? new WebRTCManager({
       getSelfToken: () => this.token,
@@ -166,6 +194,8 @@ export class WebSocketProxyClient {
         if (event === 'webrtc_close') this._rtcTried?.delete(args[0])
         this._emit(event, ...args)
       },
+      count: (dir, token, bytes, route) =>
+        this._traffic.peer(dir, route, { token, pubkey: this._tokenPubkeys.get(token) || null }, bytes),
       config: this.iceServers ? { iceServers: this.iceServers } : null
     }) : null
     // QUIÉN PUEDE HACERTE NEGOCIAR UN CANAL DIRECTO. Sin política, cualquiera que sepa
@@ -203,6 +233,7 @@ export class WebSocketProxyClient {
 
   close () {
     this.autoReconnect = false
+    unregisterTransport(this)
     if (this._reconnectTimer) {
       clearTimeout(this._reconnectTimer)
       this._reconnectTimer = null
@@ -257,6 +288,17 @@ export class WebSocketProxyClient {
     // 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
+
+    // La APP también, por la misma razón (el singleton): si se perdiera, esta app ni sonaría
+    // con lo suyo ni se llevaría solo su cola. Se fija una vez; otra distinta después es que
+    // dos apps comparten el cliente de la página, y eso es un error, no algo que resolver aquí.
+    if (options.app != null) {
+      const app = checkApp(options.app)
+      if (this.app && this.app !== app) {
+        throw Object.assign(new Error(`app: this client is already "${this.app}", not "${app}"`), { code: 'app-conflict' })
+      }
+      this.app = app
+    }
   }
 
   on (event, handler) {
@@ -503,6 +545,27 @@ export class WebSocketProxyClient {
     this.send(tokens, sobre)
   }
 
+  /**
+   * Mandar POR TOKEN algo que la app YA CIFRÓ por su cuenta (un canal de sesión propio,
+   * como el de `@dotrino/remote-agent`), con la misma red que `sendSealedTo`: sube al
+   * canal directo si lo hay, y si el token murió el mismo mensaje sale por `peerPubkey`
+   * y se avisa con `token_gone`.
+   *
+   * Existe porque `sendByPubkey` NUNCA sube de escalón —la cola es del proxio— y `send`
+   * a secas pierde en silencio lo que va a un token que ya no existe. Con `requireSealed`
+   * se niega igual que los demás: esto no abre una puerta para ir en claro.
+   *
+   * @param {string} token
+   * @param {any} payload
+   * @param {{ peerPubkey:string }} opts
+   */
+  sendToOrQueue (token, payload, { peerPubkey } = /** @type {any} */ ({})) {
+    if (!token || !peerPubkey) {
+      throw errorCon('sendToOrQueue: needs the token and whose it is (peerPubkey)', 'no-peer-identity')
+    }
+    this._sendToTokenOrQueue(token, payload, peerPubkey)
+  }
+
   /**
    * UN TOKEN MUERTO NO SE TRAGA EL MENSAJE. Un token es una conexión, y cuando la otra punta
    * reinicia la app su token deja de existir; la app que lo tenía apuntado sigue mandando ahí
@@ -765,9 +828,15 @@ export class WebSocketProxyClient {
     }
     if (opts.ephemeral) msg.ephemeral = true
     if (opts.quiet) msg.quiet = true
+    // A QUÉ APP va (ruteo): el proxio timbra y entrega solo a esa app de ese aparato.
+    const app = checkApp(opts.app)
+    if (app) msg.app = app
     this._sendRaw(msg)
   }
 
+  /** `{ app }` para lo firmado (suscribirse al timbre), o nada si esta conexión no dijo cuál. */
+  _appField () { return this.app ? { app: this.app } : {} }
+
   /**
    * Pedir una CITA: el código corto que una persona lee, dicta o escanea para
    * emparejarse con esta conexión.
@@ -858,6 +927,7 @@ export class WebSocketProxyClient {
   identify ({ data, signature, cert, acta, sign }) {
     if (!data || !signature) throw new Error('identify requires {data, signature}')
     const msg = { type: 'identify', data, signature }
+    if (this.app) msg.app = this.app
     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.
@@ -1019,7 +1089,7 @@ export class WebSocketProxyClient {
       })
     }
     const subJson = typeof sub.toJSON === 'function' ? sub.toJSON() : sub
-    const data = { op: 'push-subscribe', publickey: publicKey, subscription: JSON.stringify(subJson), ts: Date.now() }
+    const data = { op: 'push-subscribe', publickey: publicKey, subscription: JSON.stringify(subJson), ts: Date.now(), ...this._appField() }
     const signature = await normalizeSignature(sign, data)
     await this._request({ type: 'push-subscribe', data, signature }, 'push-subscribed')
     return sub
@@ -1033,7 +1103,7 @@ export class WebSocketProxyClient {
    */
   async registerPushToken ({ publicKey, sign, token, kind = 'fcm' } = {}) {
     if (!publicKey || typeof sign !== 'function' || !token) throw new Error('registerPushToken requires { publicKey, sign, token }')
-    const data = { op: 'push-subscribe', publickey: publicKey, subscription: JSON.stringify({ kind, token }), ts: Date.now() }
+    const data = { op: 'push-subscribe', publickey: publicKey, subscription: JSON.stringify({ kind, token }), ts: Date.now(), ...this._appField() }
     const signature = await normalizeSignature(sign, data)
     await this._request({ type: 'push-subscribe', data, signature }, 'push-subscribed')
     return { kind, token }
@@ -1058,7 +1128,7 @@ export class WebSocketProxyClient {
       } catch (_) { /* best-effort local */ }
     }
     if (publicKey && typeof sign === 'function') {
-      const data = { op: 'push-unsubscribe', publickey: publicKey, ts: Date.now() }
+      const data = { op: 'push-unsubscribe', publickey: publicKey, ts: Date.now(), ...this._appField() }
       const signature = await normalizeSignature(sign, data)
       await this._request({ type: 'push-unsubscribe', data, signature }, 'push-unsubscribed')
     }
@@ -1145,6 +1215,7 @@ export class WebSocketProxyClient {
   // ---------- internals ----------
 
   _open () {
+    registerTransport(this)
     const ws = new WebSocket(this.url)
     this.ws = ws
     // `ws !== this.ws` ⇒ es un socket que ya abandonamos (p.ej. por heartbeat
@@ -1159,6 +1230,7 @@ export class WebSocketProxyClient {
     ws.addEventListener('message', (ev) => {
       if (ws !== this.ws) return
       this._noteActivity()           // cualquier frame entrante prueba que está vivo
+      this._traffic.frame('in', utf8Length(ev.data))
       this._handleFrame(ev.data)
     })
     ws.addEventListener('error', (err) => {
@@ -1224,7 +1296,7 @@ export class WebSocketProxyClient {
   _heartbeatTick () {
     if (!this._connected || !this.ws) return
     if (this._hbDeadTimer) return // ya hay un ping en vuelo esperando respuesta
-    try { this.ws.send(JSON.stringify({ type: 'ping' })) }
+    try { const ping = JSON.stringify({ type: 'ping' }); this.ws.send(ping); this._traffic.frame('out', ping.length) }
     catch (_) { this._onHeartbeatDead(); return }
     this._hbDeadTimer = setTimeout(() => this._onHeartbeatDead(), this.heartbeatTimeout)
   }
@@ -1301,6 +1373,7 @@ export class WebSocketProxyClient {
         if (typeof message === 'string') {
           try { parsed = JSON.parse(message) } catch (_) { parsed = null }
         }
+        this._traffic.peer('in', 'proxy', { token: from || null, pubkey: from_publickey || this._tokenPubkeys.get(from) || null }, utf8Length(message))
         if (this._rtc && parsed && parsed.t === RTC_TAG) {
           this._rtc.handleIncoming(from, parsed)
           break
@@ -1395,7 +1468,65 @@ export class WebSocketProxyClient {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
       throw errorCon('WebSocket not connected', 'NOT_CONNECTED')
     }
-    this.ws.send(JSON.stringify(frame))
+    const texto = JSON.stringify(frame)
+    this.ws.send(texto)
+    this._countOut(frame, texto)
+  }
+
+  /** Cuenta un frame que sale por el proxio, y a quién iba. */
+  _countOut (frame, texto) {
+    this._traffic.frame('out', utf8Length(texto))
+    if (typeof frame.message !== 'string') return
+    const bytes = utf8Length(frame.message)
+    for (const token of Array.isArray(frame.to) ? frame.to : []) {
+      this._traffic.peer('out', 'proxy', { token, pubkey: this._tokenPubkeys.get(token) || null }, bytes)
+    }
+    for (const pubkey of Array.isArray(frame.to_publickey) ? frame.to_publickey : []) {
+      this._traffic.peer('out', 'proxy', { pubkey }, bytes)
+    }
+  }
+
+  /**
+   * ESTADÍSTICAS DE RED: cuánto entró y salió, por conexión, y por qué camino.
+   *
+   * `route` es por dónde va AHORA cada conexión: `proxy`, `connecting` (por el proxio
+   * mientras se negocia WebRTC), `direct` o `turn` (WebRTC, sin o con relevo), `webrtc`
+   * (canal abierto sin poder saber cuál) o `failed` (WebRTC no salió: sigue por el proxio).
+   * Los bytes van separados por el camino por el que pasaron de verdad.
+   *
+   * Los bytes son de payload (UTF-8), no del cable: las cabeceras de TLS/DTLS no se ven
+   * desde aquí.
+   */
+  async stats () {
+    const t = this._traffic
+    const routes = this._rtc ? await this._rtc.describe() : new Map()
+    const peers = [...t.peers.values()].map((p) => {
+      const pubkey = p.pubkey || (p.token && this._tokenPubkeys.get(p.token)) || null
+      const rtc = p.token ? routes.get(p.token) : null
+      return {
+        token: p.token,
+        pubkey,
+        route: rtc && rtc !== 'failed' && rtc !== 'connecting' ? rtc : (rtc || 'proxy'),
+        bytesIn: { ...p.bytesIn },
+        bytesOut: { ...p.bytesOut },
+        msgsIn: p.msgsIn,
+        msgsOut: p.msgsOut,
+        firstAt: p.firstAt,
+        lastAt: p.lastAt
+      }
+    }).sort((a, b) => b.lastAt - a.lastAt)
+    return {
+      url: this.url,
+      app: this.app,
+      node: this.node || null,
+      token: this.token,
+      publickey: this.myPublickey,
+      connected: this._connected,
+      webrtc: !!this._rtc,
+      since: t.since,
+      proxy: { ...t.proxy },
+      peers
+    }
   }
 
   _request (frame, expectedType, channelKey) {

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

@@ -10,6 +10,9 @@ export {
   buildEncPubStatement, readEncPubStatement,
 } from './encpub.js'
 
+export { listTransports, routeOf } from './stats.js'
+export { logStats, formatStats } from './stats-log.js'
+
 import { WebSocketProxyClient } from './client.js'
 
 let _singleton = null

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

@@ -0,0 +1,96 @@
+/**
+ * LAS ESTADÍSTICAS DE RED, AL LOG. Para lo que no tiene pantalla: un daemon, un agente, un
+ * servicio bajo pm2.
+ *
+ * En el navegador las enseña el topbar (su modal de red lee el registro de clientes). Un
+ * proceso de Node no tiene dónde, así que «¿esto va por WebRTC o sigue dando la vuelta por
+ * el proxio?» solo se contestaba con una prueba en contenedores. Esto escribe lo mismo que
+ * pinta el modal, una línea cada tanto, con el `log` que el servicio ya usa.
+ *
+ * Lee el MISMO registro que el topbar (`listTransports`), así que el servicio no le pasa
+ * sus clientes: los que haya en el proceso, salen.
+ *
+ * Tres cosas a propósito:
+ *  - Solo escribe si algo cambió. Un servicio quieto no llena el log de líneas iguales.
+ *  - Los contadores son ACUMULADOS desde `since`: dos líneas se restan, y una sola ya dice
+ *    si hubo tráfico directo alguna vez.
+ *  - De la otra punta solo sale el TOKEN, que es efímero. La pubkey no: con quién habla
+ *    una máquina es justo lo que no se deja escrito en un disco.
+ */
+import { listTransports, PATHS } from './stats.js'
+
+const sum = (peers, dir) => {
+  const t = { proxy: 0, direct: 0, turn: 0, webrtc: 0 }
+  for (const p of peers) for (const k of PATHS) t[k] += p[dir][k]
+  return t
+}
+
+const pairs = (prefix, o) => PATHS.map((k) => `${prefix}.${k}=${o[k]}`).join(' ')
+
+/**
+ * Las líneas de UN cliente, a partir de lo que devuelve `client.stats()`.
+ * La primera es el resumen; después, una por conexión.
+ *
+ * @param {object} s lo que devuelve `client.stats()` (`TransportStats` en los tipos)
+ * @param {{ label?: string }} [opts]
+ * @returns {string[]}
+ */
+export function formatStats (s, opts = {}) {
+  const tag = opts.label ? `[net] ${opts.label}` : '[net]'
+  const routes = {}
+  for (const p of s.peers) routes[p.route] = (routes[p.route] || 0) + 1
+  const routeList = Object.keys(routes).sort().map((r) => `${r}=${routes[r]}`).join(',') || 'none'
+  const lines = [
+    `${tag} url=${s.url} connected=${s.connected ? 'yes' : 'no'} webrtc=${s.webrtc ? 'on' : 'off'}` +
+    ` ws.in=${s.proxy.bytesIn} ws.out=${s.proxy.bytesOut}` +
+    ` ${pairs('in', sum(s.peers, 'bytesIn'))} ${pairs('out', sum(s.peers, 'bytesOut'))}` +
+    ` peers=${s.peers.length} routes=${routeList}`
+  ]
+  for (const p of s.peers) {
+    lines.push(
+      `${tag}   peer=${p.token || 'by-key'} route=${p.route}` +
+      ` ${pairs('in', p.bytesIn)} ${pairs('out', p.bytesOut)} msgs.in=${p.msgsIn} msgs.out=${p.msgsOut}`
+    )
+  }
+  return lines
+}
+
+/**
+ * Escribe las estadísticas de todos los clientes del proceso cada `everyMs`, si cambiaron.
+ *
+ * @param {{ log?: (line: string) => void, everyMs?: number, label?: string }} [opts]
+ * @returns {{ stop: () => Promise<void>, flush: () => Promise<void> }}
+ *   `flush` escribe ya (si cambió algo); `stop` escribe una última vez y para.
+ */
+export function logStats (opts = {}) {
+  const log = opts.log || ((line) => console.log(line))
+  const everyMs = opts.everyMs || 5 * 60 * 1000
+  /** cliente → lo último que se escribió de él */
+  const last = new WeakMap()
+
+  const flush = async () => {
+    for (const client of listTransports()) {
+      if (typeof client.stats !== 'function') continue
+      let lines
+      try {
+        lines = formatStats(await client.stats(), opts)
+      } catch (e) {
+        // No poder leer NO es «no hubo tráfico»: se dice, para que no parezca silencio.
+        lines = [`${opts.label ? `[net] ${opts.label}` : '[net]'} could not read stats: ${e?.message || e}`]
+      }
+      const text = lines.join('\n')
+      if (last.get(client) === text) continue
+      last.set(client, text)
+      for (const line of lines) log(line)
+    }
+  }
+
+  const timer = setInterval(() => { flush() }, everyMs)
+  // El log no puede ser lo que mantiene vivo un proceso que ya terminó.
+  if (typeof timer.unref === 'function') timer.unref()
+
+  return {
+    flush,
+    stop: async () => { clearInterval(timer); await flush() }
+  }
+}

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

@@ -0,0 +1,144 @@
+/**
+ * CUÁNTO TRÁFICO Y POR DÓNDE. Contadores del transporte, por conexión.
+ *
+ * Existe para poder VER la regla del camino más directo (CLAUDE.md, «el transporte SIEMPRE
+ * prefiere el camino más directo»): sin números, «el segundo mensaje ya no toca el proxio»
+ * solo se podía comprobar con una prueba en contenedores. Con esto lo enseña cualquier app
+ * (el topbar tiene un modal que lo pinta).
+ *
+ * Se cuentan los BYTES DEL PAYLOAD que pasa por este cliente (UTF-8), no los del cable:
+ * las cabeceras de TCP, TLS, DTLS o SCTP no las ve JavaScript. Para el proxio se cuenta el
+ * frame entero; por conexión, lo que iba dirigido a ella.
+ *
+ * Los caminos:
+ *   proxy    por el proxio (incluye la señalización de WebRTC y el saludo)
+ *   direct   WebRTC sin relevo
+ *   turn     WebRTC por un relevo TURN
+ *   webrtc   WebRTC sin saber todavía cuál de los dos (getStats no contestó)
+ */
+
+/** Longitud en bytes UTF-8 de un string, sin reservar un buffer por mensaje. */
+export function utf8Length (s) {
+  if (typeof s !== 'string') {
+    if (s && typeof s.byteLength === 'number') return s.byteLength
+    if (s && typeof s.size === 'number') return s.size
+    return 0
+  }
+  let n = 0
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i)
+    if (c < 0x80) n += 1
+    else if (c < 0x800) n += 2
+    else if (c >= 0xd800 && c <= 0xdbff && i + 1 < s.length) { n += 4; i++ } // par sustituto
+    else n += 3
+  }
+  return n
+}
+
+export const PATHS = ['proxy', 'direct', 'turn', 'webrtc']
+
+const ceros = () => ({ proxy: 0, direct: 0, turn: 0, webrtc: 0 })
+
+export class TrafficStats {
+  constructor () {
+    this.since = Date.now()
+    this.proxy = { bytesIn: 0, bytesOut: 0, framesIn: 0, framesOut: 0 }
+    /** clave (`t:<token>` | `k:<pubkey>`) → contadores de esa conexión */
+    this.peers = new Map()
+  }
+
+  /** Un frame entero del WebSocket del proxio. */
+  frame (dir, bytes) {
+    if (dir === 'in') { this.proxy.bytesIn += bytes; this.proxy.framesIn++ } else { this.proxy.bytesOut += bytes; this.proxy.framesOut++ }
+  }
+
+  /**
+   * Un mensaje dirigido a (o venido de) una conexión.
+   * @param {'in'|'out'} dir
+   * @param {'proxy'|'direct'|'turn'|'webrtc'} path
+   * @param {{ token?: string|null, pubkey?: string|null }} who
+   * @param {number} bytes
+   */
+  peer (dir, path, who, bytes) {
+    const key = who.token ? `t:${who.token}` : who.pubkey ? `k:${who.pubkey}` : null
+    if (!key) return
+    let p = this.peers.get(key)
+    if (!p) {
+      p = { token: who.token || null, pubkey: who.pubkey || null, bytesIn: ceros(), bytesOut: ceros(), msgsIn: 0, msgsOut: 0, firstAt: Date.now(), lastAt: 0 }
+      this.peers.set(key, p)
+    }
+    if (who.pubkey && !p.pubkey) p.pubkey = who.pubkey
+    if (dir === 'in') { p.bytesIn[path] += bytes; p.msgsIn++ } else { p.bytesOut[path] += bytes; p.msgsOut++ }
+    p.lastAt = Date.now()
+  }
+}
+
+/**
+ * POR DÓNDE VA UN CANAL ABIERTO: `direct` o `turn`, según el par de candidatos que ICE
+ * eligió. Si cualquiera de las dos puntas es `relay`, hay un TURN en medio.
+ *
+ * `null` si no se puede saber (la implementación no tiene getStats, o aún no hay par
+ * elegido). No se adivina: «no lo sé» se enseña como tal.
+ *
+ * @param {any} pc RTCPeerConnection
+ * @returns {Promise<'direct'|'turn'|null>}
+ */
+export async function routeOf (pc) {
+  if (!pc || typeof pc.getStats !== 'function') return null
+  let report
+  try { report = await pc.getStats() } catch (_) { return null }
+  if (!report || typeof report.forEach !== 'function') return null
+  const byId = new Map()
+  report.forEach((s) => { if (s && s.id) byId.set(s.id, s) })
+  let pair = null
+  // El par vigente lo dice el transporte; si no, el que está nominado y funcionando.
+  for (const s of byId.values()) {
+    if (s.type === 'transport' && s.selectedCandidatePairId) { pair = byId.get(s.selectedCandidatePairId) || null; break }
+  }
+  if (!pair) {
+    for (const s of byId.values()) {
+      if (s.type === 'candidate-pair' && (s.selected || (s.nominated && s.state === 'succeeded'))) { pair = s; break }
+    }
+  }
+  if (!pair) return null
+  const local = byId.get(pair.localCandidateId)
+  const remote = byId.get(pair.remoteCandidateId)
+  if (!local && !remote) return null
+  const tipo = (c) => c && (c.candidateType || c.type)
+  return tipo(local) === 'relay' || tipo(remote) === 'relay' ? 'turn' : 'direct'
+}
+
+/**
+ * LOS CLIENTES VIVOS DE ESTA PÁGINA, para quien quiera enseñarlos sin que la app lo
+ * cablee (el topbar). Va en `globalThis` con un Symbol.for, no en una variable del módulo:
+ * una app puede llevar dos copias de este paquete (la suya y la de otro pilar), y las dos
+ * tienen que verse.
+ */
+const REGISTRY = Symbol.for('dotrino.transports')
+
+function registry () {
+  if (!globalThis[REGISTRY]) globalThis[REGISTRY] = new Set()
+  return globalThis[REGISTRY]
+}
+
+function avisar () {
+  if (typeof globalThis.dispatchEvent === 'function' && typeof Event === 'function') {
+    try { globalThis.dispatchEvent(new Event('dotrino-transports')) } catch (_) {}
+  }
+}
+
+export function registerTransport (client) {
+  const r = registry()
+  if (r.has(client)) return
+  r.add(client)
+  avisar()
+}
+
+export function unregisterTransport (client) {
+  if (registry().delete(client)) avisar()
+}
+
+/** Los clientes registrados en esta página (o proceso). */
+export function listTransports () {
+  return [...registry()]
+}

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

@@ -12,6 +12,8 @@
  * the "polite" one (rolls back on collision).
  */
 
+import { routeOf, utf8Length } from './stats.js'
+
 export const DEFAULT_ICE_SERVERS = [
   { urls: 'stun:stun.l.google.com:19302' },
   { urls: 'stun:stun1.l.google.com:19302' },
@@ -82,6 +84,8 @@ export class WebRTCManager {
    * @param {(from: string, parsed: any, meta: any) => void} opts.deliverMessage forwards
    *        an incoming P2P payload as if it had arrived via the proxy
    * @param {(event: string, ...args: any[]) => void} opts.emit
+   * @param {(dir: 'in'|'out', token: string, bytes: number, route: 'direct'|'turn'|'webrtc') => void} [opts.count]
+   *        cuenta el tráfico que va por el canal (ver stats.js)
    * @param {{iceServers?: any[]}} [opts.config]
    */
   constructor (opts) {
@@ -90,6 +94,7 @@ export class WebRTCManager {
     this.signalSend = opts.signalSend
     this.deliverMessage = opts.deliverMessage
     this.emit = opts.emit
+    this.count = typeof opts.count === 'function' ? opts.count : null
     this.iceServers = (opts.config && opts.config.iceServers) || DEFAULT_ICE_SERVERS
     this.peers = new Map() // remoteToken -> PeerState
   }
@@ -128,6 +133,7 @@ export class WebRTCManager {
     if (peer.dc && peer.dc.readyState === 'open') {
       try {
         peer.dc.send(payloadString)
+        this.count?.('out', to, utf8Length(payloadString), peer.route || 'webrtc')
         return true
       } catch (_) {
         return false
@@ -168,6 +174,27 @@ export class WebRTCManager {
     if (Array.isArray(list) && list.length) this.iceServers = list
   }
 
+  /** Pregunta a ICE por dónde va el canal y lo apunta en `peer.route`. */
+  async probeRoute (peer) {
+    const r = await routeOf(peer.pc)
+    if (r) peer.route = r
+    return peer.route || null
+  }
+
+  /**
+   * El estado de cada canal, para las estadísticas: `connecting` mientras se negocia,
+   * `direct`/`turn`/`webrtc` con el canal abierto, `failed` si no salió.
+   */
+  async describe () {
+    const out = new Map()
+    for (const peer of this.peers.values()) {
+      const open = !!(peer.dc && peer.dc.readyState === 'open')
+      if (open) { try { await this.probeRoute(peer) } catch (_) {} }
+      out.set(peer.remote, open ? (peer.route || 'webrtc') : peer.failed ? 'failed' : peer.negotiating ? 'connecting' : null)
+    }
+    return out
+  }
+
   isOpen (to) {
     const p = this.peers.get(to)
     return !!(p && p.dc && p.dc.readyState === 'open')
@@ -253,6 +280,8 @@ export class WebRTCManager {
   _attachDC (peer, dc) {
     peer.dc = dc
     dc.onopen = () => {
+      // Por dónde salió: directo o por TURN. Por detrás, sin retrasar a nadie.
+      this.probeRoute(peer).catch(() => {})
       this.emit('webrtc_open', peer.remote)
       const waiters = peer.openWaiters
       peer.openWaiters = []
@@ -267,6 +296,7 @@ export class WebRTCManager {
     dc.onmessage = (ev) => {
       let parsed = null
       const raw = ev.data
+      this.count?.('in', peer.remote, utf8Length(raw), peer.route || 'webrtc')
       if (typeof raw === 'string') {
         try { parsed = JSON.parse(raw) } catch (_) { parsed = null }
       }

package/vault/vendor/vault/VERSION.txt

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

@@ -103,6 +103,13 @@ export const MSG = Object.freeze({
   // una forma de echar a alguien de su cuenta.
   LOGIN_CLOSE: 'vault.login.close',           // aparato → vault: { data:{op,user,sid,publickey,ts}, signature }
   LOGIN_CLOSED: 'vault.login.closed',         // vault → aparato: { ok }
+  // INCIDENTE: un agente de la cuenta (la terminal) avisa de que OTRO aparato de la cuenta
+  // se equivocó de clave tres veces seguidas. La bóveda lo apunta como un pedido más
+  // (`kind: 'incident'`), timbra a quien aprueba, y el aprobador bloquea o ignora. Bloquear
+  // no toca el acta: es una lista de la bóveda (`blocked.json`) que viaja a los agentes con
+  // `vault.devices.result` (`blocked`) y se deshace con `dotrino-vault unblock <ID>`.
+  INCIDENT: 'vault.incident',                 // agente → vault: { data:{op:'incident',kind,about,tries,publickey,ts}, signature, cert }
+  INCIDENT_RESULT: 'vault.incident.result',   // vault → agente: { id, approvers, blocked }
   ERROR: 'vault.error'                        // vault → dispositivo: { error }
 })