@dotrino/identity 0.116.0 → 0.117.1

package/package.json

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

package/vault/content.js

@@ -133,6 +133,33 @@ export async function encryptWithCek ({ cek, gen, plaintext }) {
   return { gen, iv: b64(iv), ct: b64(ct) }
 }
 
+/**
+ * Cifra BYTES con una clave simétrica, y devuelve bytes: `{ iv, ct }` como `Uint8Array`.
+ *
+ * Es la hermana binaria de `encryptWithCek`, para lo que no tiene por qué pasar por texto:
+ * un archivo de 5 MB cifrado y en base64 ocupa 6,7 MB, y si además iba dentro de un JSON en
+ * base64, 8,9 MB. Así viaja con lo que ocupa. Lo usa el transporte para los mensajes con
+ * archivos: el archivo se cifra con una CEK nueva y solo la CEK pasa por el sellado de
+ * siempre (`wrapForMember`, o la bóveda).
+ *
+ * @param {{ cek: string, bytes: Uint8Array }} o
+ * @returns {Promise<{ iv: Uint8Array, ct: Uint8Array }>}
+ */
+export async function encryptBytesWithCek ({ cek, bytes }) {
+  if (!(bytes instanceof Uint8Array)) throw new Error('encryptBytesWithCek: bytes must be a Uint8Array')
+  const k = await subtle.importKey('raw', fromB64(cek), { name: 'AES-GCM' }, false, ['encrypt'])
+  const iv = globalThis.crypto.getRandomValues(new Uint8Array(12))
+  const ct = new Uint8Array(await subtle.encrypt({ name: 'AES-GCM', iv }, k, bytes))
+  return { iv, ct }
+}
+
+/** El inverso de `encryptBytesWithCek`. Lanza si los bytes no son de esa clave o se tocaron. */
+export async function decryptBytesWithCek ({ cek, iv, ct }) {
+  if (!(iv instanceof Uint8Array) || !(ct instanceof Uint8Array)) throw new Error('decryptBytesWithCek: iv and ct must be Uint8Array')
+  const k = await subtle.importKey('raw', fromB64(cek), { name: 'AES-GCM' }, false, ['decrypt'])
+  return new Uint8Array(await subtle.decrypt({ name: 'AES-GCM', iv }, k, ct))
+}
+
 /** Cierra con la LLAVE DE LA CUENTA (generación `gen`): el sobre lleva la marca. */
 export async function sealAccount ({ cek, gen, plaintext }) {
   if (!Number.isInteger(gen) || gen < 1) throw new Error('sealAccount: the account key generation starts at 1')
@@ -243,5 +270,5 @@ export async function resealStale (value, { gen, reseal, now = Date.now() }) {
 
 export default {
   makeContentKey, wrapForMember, openWrap, makeGeneration, myContentKey,
-  encryptWithCek, sealAccount, decryptWithCek, decryptWithKeyring, CEK_ENVELOPE, isCekEnvelope, isLegacyCekEnvelope, LEGACY_UNMARKED_UNTIL, resealStale
+  encryptWithCek, encryptBytesWithCek, decryptBytesWithCek, sealAccount, decryptWithCek, decryptWithKeyring, CEK_ENVELOPE, isCekEnvelope, isLegacyCekEnvelope, LEGACY_UNMARKED_UNTIL, resealStale
 }

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

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

@@ -0,0 +1,140 @@
+/**
+ * BYTES QUE VIAJAN COMO BYTES (0.35.0).
+ *
+ * Hasta aquí un archivo viajaba dos veces en base64: la app lo metía en base64 en el JSON
+ * del mensaje (×1,33), el sellado cifraba ese JSON y lo volvía a pasar a base64 (×1,33), y
+ * el resultado iba como texto. Medido: 1,78 veces el tamaño del archivo en el cable.
+ *
+ * Ahora una app puede poner `Uint8Array` dentro de lo que manda, y el pilar lo lleva tal
+ * cual: lo empaqueta (`pack`), lo cifra como bytes y lo manda en una trama BINARIA, al
+ * proxio y al canal directo. Lo que no lleva bytes sale exactamente como antes, en texto:
+ * así las piezas que no saben de esto (las apps nativas, las versiones anteriores) siguen
+ * hablando con todos para lo de siempre.
+ *
+ * Dos formatos, y los dos son de este archivo para que no haya una segunda copia:
+ *
+ *   · EL PAQUETE (`pack`/`unpack`): un objeto con bytes dentro.
+ *       [0xB1][u32 largo del JSON][JSON][bytes, uno detrás de otro]
+ *     Cada `Uint8Array` del objeto queda en el JSON como `{"__dotrino_bin":[desde,largo]}`.
+ *
+ *   · LA TRAMA (`encodeFrame`/`decodeFrame`): lo que va por el WebSocket del proxio.
+ *       [0x01][u32 largo de la cabecera][cabecera JSON][cuerpo]
+ *     La cabecera es la trama de texto de siempre sin `message`; el cuerpo es el `message`.
+ *     El proxio lee la cabecera para enrutar y no mira el cuerpo, que va sellado.
+ */
+
+export const BIN_TAG = '__dotrino_bin'
+const PACK_MAGIC = 0xB1
+const FRAME_VERSION = 0x01
+
+const enc = new TextEncoder()
+const dec = new TextDecoder()
+
+function withCode (message, code) {
+  return Object.assign(new Error(message), { code })
+}
+
+/** Bytes, sin importar de qué vista vengan (`Buffer`, `ArrayBuffer`, `Uint8Array`). */
+export function asBytes (v) {
+  if (v instanceof Uint8Array) return v
+  if (v instanceof ArrayBuffer) return new Uint8Array(v)
+  if (ArrayBuffer.isView(v)) return new Uint8Array(v.buffer, v.byteOffset, v.byteLength)
+  return null
+}
+
+/** ¿Lleva bytes este valor, a cualquier profundidad? Es lo que decide texto o binario. */
+export function hasBinary (v) {
+  if (v instanceof Uint8Array || v instanceof ArrayBuffer) return true
+  if (Array.isArray(v)) return v.some(hasBinary)
+  if (v && typeof v === 'object') {
+    for (const k in v) if (hasBinary(v[k])) return true
+  }
+  return false
+}
+
+/** Un objeto con bytes dentro → un solo `Uint8Array`. */
+export function pack (obj) {
+  const blobs = []
+  let off = 0
+  const json = JSON.stringify(obj, function (k, v) {
+    // `this[k]` es el valor antes de `toJSON`: un Buffer de Node se convertiría en
+    // `{ type: 'Buffer', data: [...] }` y aquí lo queremos como bytes.
+    const b = asBytes(this[k])
+    if (!b) return v
+    blobs.push(b)
+    const ref = { [BIN_TAG]: [off, b.byteLength] }
+    off += b.byteLength
+    return ref
+  })
+  const head = enc.encode(json)
+  const out = new Uint8Array(5 + head.length + off)
+  out[0] = PACK_MAGIC
+  new DataView(out.buffer).setUint32(1, head.length)
+  out.set(head, 5)
+  let p = 5 + head.length
+  for (const b of blobs) { out.set(b, p); p += b.byteLength }
+  return out
+}
+
+export const isPacked = (b) => b instanceof Uint8Array && b.length >= 5 && b[0] === PACK_MAGIC
+
+/**
+ * Un paquete → el objeto, con sus bytes como `Uint8Array` (vistas sobre `bytes`, sin copiar).
+ * Lanza con `code: 'bad-pack'` si no es un paquete o una referencia se sale de él.
+ */
+export function unpack (bytes) {
+  const b = asBytes(bytes)
+  if (!isPacked(b)) throw withCode('not a packed message', 'bad-pack')
+  const len = new DataView(b.buffer, b.byteOffset, b.byteLength).getUint32(1)
+  if (5 + len > b.length) throw withCode('packed message is shorter than its header says', 'bad-pack')
+  const area = b.subarray(5 + len)
+  let obj
+  try { obj = JSON.parse(dec.decode(b.subarray(5, 5 + len))) } catch (_) { throw withCode('packed message header is not JSON', 'bad-pack') }
+  const revive = (v) => {
+    if (Array.isArray(v)) return v.map(revive)
+    if (!v || typeof v !== 'object') return v
+    const ref = v[BIN_TAG]
+    if (ref !== undefined) {
+      if (!Array.isArray(ref) || ref.length !== 2 || !Number.isInteger(ref[0]) || !Number.isInteger(ref[1]) ||
+          ref[0] < 0 || ref[1] < 0 || ref[0] + ref[1] > area.length) {
+        throw withCode('packed message points outside itself', 'bad-pack')
+      }
+      return area.subarray(ref[0], ref[0] + ref[1])
+    }
+    const out = {}
+    for (const k of Object.keys(v)) out[k] = revive(v[k])
+    return out
+  }
+  return revive(obj)
+}
+
+/** Une varios trozos de bytes en uno. */
+export function concatBytes (list) {
+  const out = new Uint8Array(list.reduce((a, b) => a + b.byteLength, 0))
+  let p = 0
+  for (const b of list) { out.set(b, p); p += b.byteLength }
+  return out
+}
+
+/** La trama binaria del proxio: la cabecera de texto de siempre, y el `message` en crudo. */
+export function encodeFrame (header, body) {
+  const head = enc.encode(JSON.stringify(header))
+  const out = new Uint8Array(5 + head.length + body.byteLength)
+  out[0] = FRAME_VERSION
+  new DataView(out.buffer).setUint32(1, head.length)
+  out.set(head, 5)
+  out.set(body, 5 + head.length)
+  return out
+}
+
+/** El inverso: `{ header, body }`. Lanza con `code: 'bad-frame'` si no es una trama válida. */
+export function decodeFrame (data) {
+  const b = asBytes(data)
+  if (!b || b.length < 5 || b[0] !== FRAME_VERSION) throw withCode('not a binary frame of a known version', 'bad-frame')
+  const len = new DataView(b.buffer, b.byteOffset, b.byteLength).getUint32(1)
+  if (5 + len > b.length) throw withCode('binary frame is shorter than its header says', 'bad-frame')
+  let header
+  try { header = JSON.parse(dec.decode(b.subarray(5, 5 + len))) } catch (_) { throw withCode('binary frame header is not JSON', 'bad-frame') }
+  if (!header || typeof header !== 'object' || Array.isArray(header)) throw withCode('binary frame header is not an object', 'bad-frame')
+  return { header, body: b.subarray(5 + len) }
+}

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

@@ -1,8 +1,10 @@
 import { buildSignedChannel, getPublicKeyJwk, signData, samePubkey } from './signature.js'
-import { seal, open, isSealed } from './sealing.js'
+import { seal, open, isSealed, isBinSealed, BIN_SEALED, makeMessageKey, encryptBytes, decryptBytes } from './sealing.js'
 import { buildEncPubStatement, readEncPubStatement, isEncPub } from './encpub.js'
 import { WebRTCManager, RTC_TAG, DEFAULT_ICE_SERVERS, loadNodePeerConnection, resolvePeerConnection, pinTurnToIPv4 } from './webrtc.js'
 import { TrafficStats, utf8Length, registerTransport, unregisterTransport } from './stats.js'
+import { splitParts, splitBinParts, isPart, Reassembler, DIRECT_PART_CHARS, PROXY_PART_CHARS, QUEUE_MAX_CHARS, RELAY_MAX_CHARS, DIRECT_PART_BYTES, PROXY_PART_BYTES, QUEUE_MAX_BYTES, RELAY_MAX_BYTES } from './parts.js'
+import { pack, unpack, hasBinary, encodeFrame, decodeFrame } from './binpack.js'
 
 /**
  * Error con un `code` estable.
@@ -186,7 +188,15 @@ export class WebSocketProxyClient {
     this._handlers = new Map()
     this._pending = new Map() // messageId -> { resolve, reject, timer }
     this._nextId = 1
-    this._tokenWatch = new Map() // messageId -> { token, sobre, peerPubkey, timer }
+    this._tokenWatch = new Map() // messageId -> { token, sobre, peerPubkey, timer, queueFallback }
+    // Mensajes grandes que llegan en partes (parts.js). Uno que se queda a medias se DICE:
+    // con él se pierde el mensaje entero, y eso no puede pasar callado.
+    this._parts = new Reassembler({
+      onExpire: (info) => this._emit('error', { type: 'parts_incomplete', code: 'parts-incomplete', ...info })
+    })
+    // Las CEK de los mensajes con bytes ya abiertas, por su sobre: todas las partes de un
+    // mensaje traen la misma, y abrirla es una vuelta a la bóveda. Pocas: un mensaje vivo.
+    this._msgKeys = new Map()
     this._traffic = new TrafficStats()
 
     this._rtc = this.enableWebRTC ? new WebRTCManager({
@@ -335,7 +345,7 @@ export class WebSocketProxyClient {
         'unsealed')
     }
     const tokens = Array.isArray(to) ? to : [to]
-    const messageStr = typeof payload === 'string' ? payload : JSON.stringify(payload)
+    const messageStr = this._wire(payload)
     if (!this._rtc) {
       this._sendRaw({ to: tokens, message: messageStr })
       return
@@ -501,10 +511,23 @@ export class WebSocketProxyClient {
    */
   async sendSealed (toPubkeys, payload, { peerEncPub, ...opts } = {}) {
     const list = Array.isArray(toPubkeys) ? toPubkeys : [toPubkeys]
+    // Por pubkey el mensaje puede quedarse ESPERANDO en el proxio, y ahí se deja como mucho
+    // 8 MB de archivo (parts.js). Lo que pasa de eso no se manda: se dice, y la app decide.
+    const m = this._measure(payload)
+    const queueMax = m.bin ? QUEUE_MAX_BYTES : QUEUE_MAX_CHARS
+    if (m.len > queueMax) {
+      throw errorCon(`sendSealed: ${m.len} ${m.bin ? 'bytes' : 'chars'} is more than can wait in the proxy (${queueMax}); send it by token while both ends are connected`, 'too-big-for-queue')
+    }
+    // Por pubkey todo va por el proxio: si no admite bytes, se dice antes de mandar nada.
+    if (m.bin) this._needBinaryProxy()
+    const partSize = m.bin ? PROXY_PART_BYTES : PROXY_PART_CHARS
+    const pieces = m.len <= partSize ? [m.bin ? m.whole : payload]
+      : m.bin ? splitBinParts(m.whole, partSize) : splitParts(m.whole, partSize)
     // Con la llave puesta a mano se respeta tal cual: quien la pasa está diciendo que ya
     // sabe de quién es (se emparejaron), y un sobre vale para todos los destinatarios.
     if (peerEncPub) {
-      this._sendByPubkeyRaw(list, await this._seal(payload, peerEncPub, list.length === 1 ? list[0] : undefined), opts)
+      const sealPiece = await this._sealerFor(m.bin, peerEncPub, list.length === 1 ? list[0] : undefined)
+      for (const piece of pieces) this._sendByPubkeyRaw(list, await sealPiece(piece), opts)
       return
     }
     // Sin ella, se averigua. UNA ENVOLTURA POR DESTINATARIO: cada uno tiene su llave, así
@@ -515,7 +538,8 @@ export class WebSocketProxyClient {
     // sin forma de saber cuál mitad.
     const llaves = await Promise.all(list.map(async (pk) => [pk, await this.encPubOf(pk)]))
     for (const [pk, encPub] of llaves) {
-      this._sendByPubkeyRaw([pk], await this._seal(payload, encPub, pk), opts)
+      const sealPiece = await this._sealerFor(m.bin, encPub, pk)
+      for (const piece of pieces) this._sendByPubkeyRaw([pk], await sealPiece(piece), opts)
     }
   }
 
@@ -547,10 +571,75 @@ export class WebSocketProxyClient {
       peerEncPub = await this.encPubOf(peerPubkey)
     }
     if (!peerPubkey && tokens.length === 1) peerPubkey = this.pubkeyOfToken(tokens[0]) || undefined
-    const sobre = await this._seal(payload, peerEncPub, peerPubkey)
-    if (tokens.length === 1 && peerPubkey) { this._sendToTokenOrQueue(tokens[0], sobre, peerPubkey); return }
-    // Por `send`, no por `_sendRaw`: así sigue prefiriendo el canal directo si lo hay.
-    this.send(tokens, sobre)
+    // Por token los dos están conectados y NO HAY TOPE (parts.js): lo que no cabe en un
+    // mensaje del camino que toca sale en partes. El tamaño de parte lo decide el camino
+    // de ahora: el canal directo admite mucho menos por mensaje que el proxio.
+    const m = this._measure(payload)
+    const direct = tokens.length === 1 && !!this._rtc?.isOpen(tokens[0])
+    const size = m.bin ? (direct ? DIRECT_PART_BYTES : PROXY_PART_BYTES) : (direct ? DIRECT_PART_CHARS : PROXY_PART_CHARS)
+    const relayMax = m.bin ? RELAY_MAX_BYTES : RELAY_MAX_CHARS
+    const queueMax = m.bin ? QUEUE_MAX_BYTES : QUEUE_MAX_CHARS
+    if (m.bin && !direct) this._needBinaryProxy()
+    const sealPiece = await this._sealerFor(m.bin, peerEncPub, peerPubkey)
+    if (m.len <= size) {
+      const sobre = await sealPiece(m.bin ? m.whole : payload)
+      if (tokens.length === 1 && peerPubkey) { this._sendToTokenOrQueue(tokens[0], sobre, peerPubkey); return }
+      // Por `send`, no por `_sendRaw`: así sigue prefiriendo el canal directo si lo hay.
+      this.send(tokens, sobre)
+      return
+    }
+    // Por el proxio en vivo hay tope (parts.js): lo que pasa de él solo sale por canal
+    // directo. Se pide el canal para que el siguiente intento lo encuentre abierto.
+    if (!direct && m.len > relayMax) {
+      this._upgradeDirect(tokens)
+      throw errorCon(`sendSealedTo: ${m.len} ${m.bin ? 'bytes' : 'chars'} is more than goes through the proxy live (${relayMax}); it needs a direct channel`, 'too-big-for-relay')
+    }
+    // Si el token muere a mitad, lo que quede se iría a la cola por pubkey; solo se permite
+    // si el mensaje entero cabe ahí. Si no, se dice (`too-big-for-queue`), no se deja.
+    const queueFallback = m.len <= queueMax
+    // Y si el canal directo se cae a mitad, el resto va por el proxio en vivo solo si el
+    // mensaje entero cabe por ahí; si no, se para y se dice (`direct-lost`).
+    const relayFallback = m.len <= relayMax
+    for (const piece of (m.bin ? splitBinParts(m.whole, size) : splitParts(m.whole, size))) {
+      const sobre = await sealPiece(piece)
+      if (tokens.length === 1 && peerPubkey) await this._sendPiece(tokens[0], sobre, peerPubkey, queueFallback, relayFallback)
+      else this.send(tokens, sobre)
+    }
+  }
+
+  /**
+   * POR DÓNDE LE LLEGA AHORA un mensaje a este token: `socket` (la otra punta en esta
+   * máquina), `direct` (WebRTC sin nadie en medio), `turn` (WebRTC por el relevo, que no puede
+   * leer lo que pasa), `proxy` (en vivo por el proxio) u `offline` (no hay conexión: por
+   * pubkey quedaría esperando en el proxio). Cada camino tiene su tope (parts.js), y para eso
+   * existe esto: que la app lo enseñe antes de que el usuario intente algo que no cabe.
+   * `webrtc` es un canal directo abierto del que todavía no se sabe si va por TURN.
+   * @param {string|null} token
+   * @returns {Promise<'socket'|'direct'|'turn'|'webrtc'|'proxy'|'offline'>}
+   */
+  async routeTo (token) {
+    if (!this._connected) return 'offline'
+    if (!token) return 'offline'
+    if (this._rtc?.isOpen(token)) {
+      const peer = this._rtc.peers.get(token)
+      try { return (await this._rtc.probeRoute(peer)) || 'webrtc' } catch (_) { return 'webrtc' }
+    }
+    return 'proxy'
+  }
+
+  /**
+   * Una parte por token: por el canal directo esperando a que vacíe su búfer (sin eso, un
+   * archivo grande lo desborda y el navegador cierra el canal), o por el proxio en vivo con
+   * una pausa corta entre partes, para no chocar con su límite de mensajes por segundo.
+   */
+  async _sendPiece (token, sobre, peerPubkey, queueFallback, relayFallback = true) {
+    if (this._rtc && await this._rtc.sendDirect(token, this._wire(sobre))) return
+    if (!relayFallback) {
+      throw errorCon('the direct channel closed in the middle of a message too big for the proxy', 'direct-lost')
+    }
+    if (sobre instanceof Uint8Array) this._needBinaryProxy()
+    this._sendToTokenOrQueue(token, sobre, peerPubkey, { queueFallback, skipDirect: true })
+    await new Promise((r) => setTimeout(r, 20))
   }
 
   /**
@@ -585,16 +674,16 @@ export class WebSocketProxyClient {
    * `token_gone` para que la app deje de usar ese token. No bloquea a nadie: se manda ya y
    * el arreglo, si hace falta, llega detrás.
    */
-  _sendToTokenOrQueue (token, sobre, peerPubkey) {
+  _sendToTokenOrQueue (token, sobre, peerPubkey, { queueFallback = true, skipDirect = false } = {}) {
     if (this.requireSealed && !this._isSealed(sobre)) {
       throw errorCon('requireSealed: refusing to send a directed message in the clear — use sendSealedTo()', 'unsealed')
     }
-    const messageStr = JSON.stringify(sobre)
-    if (this._rtc && this._rtc.trySend(token, messageStr)) return
+    const messageStr = this._wire(sobre)
+    if (!skipDirect && this._rtc && this._rtc.trySend(token, messageStr)) return
     const id = `msg_${this._nextId++}`
     const timer = setTimeout(() => this._tokenWatch.delete(id), 15000)
     timer.unref?.()
-    this._tokenWatch.set(id, { token, sobre, peerPubkey, timer })
+    this._tokenWatch.set(id, { token, sobre, peerPubkey, timer, queueFallback })
     try {
       this._sendRaw({ to: [token], message: messageStr, id })
     } catch (e) {
@@ -613,6 +702,11 @@ export class WebSocketProxyClient {
     this._tokenWatch.delete(data.id)
     if (!Array.isArray(data.failed) || !data.failed.includes(w.token)) return
     this._emit('token_gone', w.token, w.peerPubkey)
+    // Una parte de un mensaje que no cabe en la cola no se deja en el proxio (parts.js).
+    if (!w.queueFallback) {
+      this._emit('error', { type: 'client', error: 'the peer left in the middle of a message too big to wait in the proxy', code: 'too-big-for-queue', peerPubkey: w.peerPubkey })
+      return
+    }
     try { this._sendByPubkeyRaw([w.peerPubkey], w.sobre) } catch (e) { this._emit('error', { type: 'client', error: e.message, code: e.code || null }) }
   }
 
@@ -683,6 +777,62 @@ export class WebSocketProxyClient {
       : seal(payload, peerEncPub)
   }
 
+  /**
+   * Quién sella las piezas de UN mensaje hacia UN destinatario. Con bytes (sealing.js): una
+   * CEK para el mensaje entero, sellada una vez con el sellado de siempre, y cada pieza
+   * cifrada como bytes con ella. Sin bytes, el sobre de texto de siempre por pieza.
+   */
+  async _sealerFor (bin, peerEncPub, peerPubkey) {
+    if (!bin) return (piece) => this._seal(piece, peerEncPub, peerPubkey)
+    const cek = await makeMessageKey()
+    const k = await this._seal({ cek }, peerEncPub, peerPubkey)
+    return async (bytes) => {
+      const { iv, ct } = await encryptBytes(cek, bytes)
+      return pack({ bv: BIN_SEALED, k, iv, ct })
+    }
+  }
+
+  /** Lo que mide un mensaje para sus topes: su paquete si lleva bytes, su JSON si no. */
+  _measure (payload) {
+    if (hasBinary(payload)) {
+      const whole = pack(payload)
+      return { bin: true, whole, len: whole.byteLength }
+    }
+    const whole = JSON.stringify(payload)
+    return { bin: false, whole, len: whole.length }
+  }
+
+  /** Cómo va por el cable: los bytes tal cual, el texto tal cual, y un objeto en JSON (o empaquetado, si lleva bytes). */
+  _wire (payload) {
+    if (typeof payload === 'string' || payload instanceof Uint8Array) return payload
+    if (hasBinary(payload)) return pack(payload)
+    return JSON.stringify(payload)
+  }
+
+  /** Un mensaje con bytes por el proxio necesita uno que admita tramas binarias (websocket-proxy ≥ 1.6.0). */
+  _needBinaryProxy () {
+    if (!Array.isArray(this.caps) || !this.caps.includes('binary')) {
+      throw errorCon('this proxy does not take binary frames (it needs websocket-proxy >= 1.6.0)', 'no-binary-support')
+    }
+  }
+
+  /** La CEK de un mensaje con bytes, abriendo su sobre una vez por mensaje. */
+  _openMessageKey (k, meta) {
+    const id = JSON.stringify(k)
+    let p = this._msgKeys.get(id)
+    if (!p) {
+      p = (async () => {
+        const o = this.sealing ? await this.sealing.open(k, meta) : await open(k, this.myEncPrivateKey)
+        if (!o || typeof o.cek !== 'string') throw errorCon('the sealed key of a message has no key inside', 'bad-pack')
+        return o.cek
+      })()
+      this._msgKeys.set(id, p)
+      if (this._msgKeys.size > 64) this._msgKeys.delete(this._msgKeys.keys().next().value)
+      p.catch(() => this._msgKeys.delete(id))
+    }
+    return p
+  }
+
   // ---------- llaves de cifrado ajenas ----------
 
   /**
@@ -779,6 +929,11 @@ export class WebSocketProxyClient {
   }
 
   _isSealed (msg) {
+    if (msg instanceof Uint8Array) {
+      let env
+      try { env = unpack(msg) } catch (_) { return false }
+      return isBinSealed(env) && this._isSealed(env.k)
+    }
     return this.sealing ? this.sealing.isSealed(msg) : isSealed(msg)
   }
 
@@ -801,6 +956,33 @@ export class WebSocketProxyClient {
    * into the app.
    */
   async _deliver (from, payload, meta) {
+    // BYTES (binpack.js): un paquete. Si es un sobre binario se abre aquí; si no, es un
+    // objeto con bytes sin sellar, y decide `requireSealed` igual que con el texto.
+    if (payload instanceof Uint8Array) {
+      let env
+      try { env = unpack(payload) } catch (e) {
+        this._emit('error', { type: 'bad_pack', from, code: e.code || 'bad-pack', error: e })
+        return
+      }
+      if (isBinSealed(env)) {
+        if (!this.sealing && !this.myEncPrivateKey) {
+          this._emit('error', { type: 'unsealed', reason: 'no_encryption_key', from })
+          return
+        }
+        let opened
+        try {
+          if (!this._isSealed(env.k)) throw errorCon('the key of a sealed message is not sealed', 'bad-pack')
+          opened = unpack(await decryptBytes(await this._openMessageKey(env.k, meta), env))
+        } catch (e) {
+          this._emit('error', { type: 'undecipherable', from, error: e })
+          return
+        }
+        const senderEncPub = this.sealing?.senderOf?.(env.k) || null
+        this._handOpened(from, opened, { ...meta, sealed: true, ...(senderEncPub ? { senderEncPub } : {}) })
+        return
+      }
+      payload = env
+    }
     if (this._isSealed(payload)) {
       if (!this.sealing && !this.myEncPrivateKey) {
         this._emit('error', { type: 'unsealed', reason: 'no_encryption_key', from })
@@ -813,7 +995,7 @@ export class WebSocketProxyClient {
         // Quién selló (la llave de cifrado), si el sobre lo dice: es lo que autentica al
         // remitente, porque solo quien tiene esa privada pudo armarlo.
         const senderEncPub = this.sealing?.senderOf?.(payload) || null
-        this._emit('message', from, opened, { ...meta, sealed: true, ...(senderEncPub ? { senderEncPub } : {}) })
+        this._handOpened(from, opened, { ...meta, sealed: true, ...(senderEncPub ? { senderEncPub } : {}) })
       } catch (e) {
         // Sealed to somebody else, or tampered with. Staying quiet is the point.
         this._emit('error', { type: 'undecipherable', from, error: e })
@@ -828,11 +1010,24 @@ export class WebSocketProxyClient {
     this._emit('message', from, payload, { ...meta, sealed: false })
   }
 
+  /** Lo ya abierto a la app: entero, o a rearmar si es una parte (parts.js). */
+  _handOpened (from, opened, fullMeta) {
+    if (isPart(opened)) {
+      // Se agrupa por quien selló: solo esa llave pudo armar cada parte.
+      let whole
+      try { whole = this._parts.add(fullMeta.senderEncPub || fullMeta.fromPubkey || from || '', opened) }
+      catch (e) { this._emit('error', { type: 'bad_part', from, code: e.code || 'bad-part', error: e }); return }
+      if (whole !== null) this._emit('message', from, whole, { ...fullMeta, parts: opened.__dotrino_part.n })
+      return
+    }
+    this._emit('message', from, opened, fullMeta)
+  }
+
   _sendByPubkeyRaw (toPubkeys, payload, opts = {}) {
     const list = Array.isArray(toPubkeys) ? toPubkeys : [toPubkeys]
     const msg = {
       to_publickey: list,
-      message: typeof payload === 'string' ? payload : JSON.stringify(payload)
+      message: this._wire(payload)
     }
     if (opts.ephemeral) msg.ephemeral = true
     if (opts.quiet) msg.quiet = true
@@ -1258,6 +1453,9 @@ export class WebSocketProxyClient {
       try { prev.close() } catch (_) {}
     }
     const ws = new WebSocket(this.url)
+    // Las tramas binarias (binpack.js) llegan como ArrayBuffer: un Blob obligaría a leerlas
+    // de forma asíncrona y desordenaría lo que llega detrás.
+    try { ws.binaryType = 'arraybuffer' } catch (_) {}
     this.ws = ws
     const openTimer = this.connectTimeout > 0 ? setTimeout(() => this._onConnectTimeout(ws), this.connectTimeout) : null
     openTimer?.unref?.()
@@ -1395,9 +1593,20 @@ export class WebSocketProxyClient {
 
   _handleFrame (raw) {
     let data
-    try { data = JSON.parse(raw) } catch (e) {
-      this._emit('error', { type: 'parse_error', error: e })
-      return
+    if (typeof raw === 'string') {
+      try { data = JSON.parse(raw) } catch (e) {
+        this._emit('error', { type: 'parse_error', error: e })
+        return
+      }
+    } else {
+      // Trama binaria: la cabecera de siempre y el `message` en crudo.
+      try {
+        const { header, body } = decodeFrame(raw)
+        data = { ...header, message: body }
+      } catch (e) {
+        this._emit('error', { type: 'parse_error', code: e.code || 'bad-frame', error: e })
+        return
+      }
     }
     const { type } = data
     switch (type) {
@@ -1530,6 +1739,14 @@ export class WebSocketProxyClient {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
       throw errorCon('WebSocket not connected', 'NOT_CONNECTED')
     }
+    if (frame.message instanceof Uint8Array) {
+      this._needBinaryProxy()
+      const { message, ...header } = frame
+      const bytes = encodeFrame(header, message)
+      this.ws.send(bytes)
+      this._countOut(frame, bytes)
+      return
+    }
     const texto = JSON.stringify(frame)
     this.ws.send(texto)
     this._countOut(frame, texto)
@@ -1538,7 +1755,7 @@ export class WebSocketProxyClient {
   /** 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
+    if (typeof frame.message !== 'string' && !(frame.message instanceof Uint8Array)) 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)

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

@@ -11,6 +11,8 @@ export {
 } from './encpub.js'
 
 export { listTransports, routeOf } from './stats.js'
+export { PART_TAG, DIRECT_PART_CHARS, PROXY_PART_CHARS, QUEUE_MAX_CHARS, RELAY_MAX_CHARS, DIRECT_PART_BYTES, PROXY_PART_BYTES, QUEUE_MAX_BYTES, RELAY_MAX_BYTES } from './parts.js'
+export { pack, unpack, hasBinary, encodeFrame, decodeFrame } from './binpack.js'
 export { logStats, formatStats, netReport, splitPeers } from './stats-log.js'
 
 import { WebSocketProxyClient } from './client.js'

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

@@ -0,0 +1,157 @@
+/**
+ * MENSAJES GRANDES, EN PARTES (0.33.0).
+ *
+ * Un mensaje dirigido tiene techo en cada camino: el canal directo (WebRTC) rechaza lo que
+ * pasa de 64 KiB hacia libwebrtc y la trama del proxio es de 1 MB. Antes, lo que no cabía
+ * en el canal directo se iba callado por el proxio (y llegaba desordenado), y lo que no
+ * cabía en la trama no salía. Ahora el pilar parte el mensaje y la otra punta lo rearma:
+ * la app manda y recibe un objeto entero, como siempre.
+ *
+ * La regla del dueño (2026-10-15), que es lo que decide los topes:
+ *   - por el canal directo (WebRTC, también por TURN) NO HAY TOPE;
+ *   - por el proxio EN VIVO (los dos conectados, sin canal directo), como mucho 25 MB de
+ *     archivo: cada parte cruza el VPS dos veces, y uno de 25 MB ya son ~90 MB de tráfico.
+ *     Más que eso lanza `too-big-for-relay`, y sale cuando haya canal directo;
+ *   - lo que se queda ESPERANDO en el proxio (por pubkey, el otro desconectado) es como
+ *     mucho 8 MB de archivo: una foto de teléfono pesa 2-5 MB, y con 1 MB (lo primero que se
+ *     pensó) casi ninguna habría podido esperar. Lo que pasa de ahí no se deja en el proxio:
+ *     se lanza `too-big-for-queue`.
+ *
+ * Cada parte va SELLADA por su cuenta (el pilar sella cada una como cualquier mensaje), así
+ * que el proxio no ve ni el contenido ni cuántas partes son de qué. El rearmado agrupa por la
+ * llave que selló: nadie más puede colar una parte en el mensaje de otro.
+ */
+
+import { pack, unpack, concatBytes } from './binpack.js'
+
+export const PART_TAG = '__dotrino_part'
+
+/** Parte por el canal directo: por debajo de los 64 KiB que acepta libwebrtc, ya sellada. */
+export const DIRECT_PART_CHARS = 40 * 1024
+/** Parte por el proxio: sellada (×1,37) cabe holgada en la trama de 1 MB. */
+export const PROXY_PART_CHARS = 512 * 1024
+/**
+ * Lo más que se deja esperando en el proxio. Se mide sobre el JSON del mensaje: 8 MB de
+ * archivo en base64 ocupan ~10,7 MB, y se deja margen para lo que va alrededor.
+ */
+export const QUEUE_MAX_CHARS = 11 * 1024 * 1024
+/** Lo más que pasa por el proxio EN VIVO: 25 MB de archivo son ~33,4 MB en base64. */
+export const RELAY_MAX_CHARS = 34 * 1024 * 1024
+
+/**
+ * LOS MISMOS TOPES PARA UN MENSAJE CON BYTES (0.35.0), medidos sobre su paquete (binpack.js),
+ * que ocupa lo que el archivo más unos pocos bytes: 8 MB y 25 MB de archivo, con 64 KB de
+ * margen para el texto que va alrededor (nombre, tipo, pie de foto).
+ */
+export const QUEUE_MAX_BYTES = 8 * 1024 * 1024 + 64 * 1024
+export const RELAY_MAX_BYTES = 25 * 1024 * 1024 + 64 * 1024
+/**
+ * Parte binaria por el canal directo: bajo los 64 KiB de libwebrtc, con sitio para el sobre
+ * de la llave, que la bóveda envuelve para cada aparato del destinatario.
+ */
+export const DIRECT_PART_BYTES = 48 * 1024
+/** Parte binaria por el proxio: cabe en su trama de 1 MB con la cabecera y el sobre. */
+export const PROXY_PART_BYTES = 768 * 1024
+
+/** Rearmado: lo que se acepta guardar a medias, y cuánto se espera a la parte siguiente. */
+const RECV_MAX_CHARS = 512 * 1024 * 1024
+const RECV_IDLE_MS = 5 * 60 * 1000
+const MAX_PARTS = 1 << 20
+
+/** El id de un mensaje en partes: al azar, para que dos mensajes no se mezclen. */
+export function partId () {
+  const b = new Uint8Array(12)
+  globalThis.crypto.getRandomValues(b)
+  return Array.from(b, (x) => x.toString(16).padStart(2, '0')).join('')
+}
+
+/** Las partes (ya como objetos para sellar) de un JSON de `json.length` > `size`. */
+export function splitParts (json, size) {
+  const n = Math.ceil(json.length / size)
+  const id = partId()
+  const out = []
+  for (let i = 0; i < n; i++) out.push({ [PART_TAG]: { id, i, n }, d: json.slice(i * size, (i + 1) * size) })
+  return out
+}
+
+/**
+ * Las partes de un paquete de `bytes.length` > `size`, cada una ya empaquetada (lista para
+ * cifrar como bytes). El rearmado une los trozos y desempaqueta el resultado.
+ */
+export function splitBinParts (bytes, size) {
+  const n = Math.ceil(bytes.byteLength / size)
+  const id = partId()
+  const out = []
+  for (let i = 0; i < n; i++) out.push(pack({ [PART_TAG]: { id, i, n }, d: bytes.subarray(i * size, (i + 1) * size) }))
+  return out
+}
+
+export const isPart = (o) => !!(o && typeof o === 'object' && o[PART_TAG])
+
+/**
+ * Rearma los mensajes. `add` devuelve el mensaje entero cuando llega la última parte, `null`
+ * mientras falten, y lanza con `code` si la parte no vale (se dice: una parte mala no puede
+ * desaparecer en silencio, porque el mensaje entero se pierde con ella).
+ */
+export class Reassembler {
+  constructor ({ onExpire = () => {} } = {}) {
+    this._open = new Map()
+    this._chars = 0
+    this._onExpire = onExpire
+  }
+
+  /** @param {string} sender quién selló (agrupa) @param {any} part */
+  add (sender, part) {
+    const p = part[PART_TAG]
+    const d = part.d
+    if (!p || typeof p.id !== 'string' || p.id.length > 64 ||
+        !Number.isInteger(p.n) || !Number.isInteger(p.i) || p.n < 2 || p.n > MAX_PARTS ||
+        p.i < 0 || p.i >= p.n || (typeof d !== 'string' && !(d instanceof Uint8Array))) {
+      throw Object.assign(new Error('malformed message part'), { code: 'bad-part' })
+    }
+    const key = `${sender}|${p.id}`
+    let a = this._open.get(key)
+    if (!a) {
+      a = { n: p.n, bin: d instanceof Uint8Array, got: new Array(p.n), count: 0, chars: 0, timer: null }
+      this._open.set(key, a)
+    }
+    if (a.n !== p.n || a.bin !== (d instanceof Uint8Array)) {
+      this._drop(key)
+      throw Object.assign(new Error('message parts disagree on their count or kind'), { code: 'bad-part' })
+    }
+    if (a.got[p.i] === undefined) {
+      if (this._chars + d.length > RECV_MAX_CHARS) {
+        this._drop(key)
+        throw Object.assign(new Error('too much of a message in parts is pending'), { code: 'parts-too-big' })
+      }
+      // Una copia: `d` es una vista sobre la trama entera, y guardarla retendría la trama.
+      a.got[p.i] = a.bin ? d.slice() : d
+      a.count++
+      a.chars += d.length
+      this._chars += d.length
+    }
+    if (a.timer) clearTimeout(a.timer)
+    if (a.count === a.n) {
+      this._drop(key)
+      try { return a.bin ? unpack(concatBytes(a.got)) : JSON.parse(a.got.join('')) }
+      catch (_) { throw Object.assign(new Error('a message in parts did not join into a message'), { code: 'bad-part' }) }
+    }
+    a.timer = setTimeout(() => {
+      const missing = a.n - a.count
+      this._drop(key)
+      this._onExpire({ id: p.id, parts: a.n, missing })
+    }, RECV_IDLE_MS)
+    a.timer.unref?.()
+    return null
+  }
+
+  _drop (key) {
+    const a = this._open.get(key)
+    if (!a) return
+    if (a.timer) clearTimeout(a.timer)
+    this._chars -= a.chars
+    this._open.delete(key)
+  }
+
+  clear () { for (const k of [...this._open.keys()]) this._drop(k) }
+}

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

@@ -164,3 +164,45 @@ export function identitySealing (identity, { app = 'dotrino' } = {}) {
     isSealed: (m) => !!m && m.app === app && !!m.sealed,
   }
 }
+
+/**
+ * SELLAR BYTES (0.35.0). Un archivo no pasa por el sellado de texto —que lo volvería a
+ * base64—: se cifra con una CEK nueva (`encryptBytesWithCek` de `@dotrino/identity/content`,
+ * AES-GCM) y lo que se sella con el sellado de siempre es SOLO la CEK. Así la bóveda del
+ * navegador ve una llave de 44 caracteres y no los megas, y no hay cripto nueva: la misma
+ * envoltura de siempre más el AES-GCM del pilar de identidad.
+ *
+ * El sobre binario es un paquete (`binpack.js`) con `{ bv: 1, k, iv, ct }`:
+ *   · `k`  el sobre de siempre (del sellado propio o de la bóveda) con `{ cek }` dentro
+ *   · `iv`, `ct`  los bytes cifrados, como bytes
+ *
+ * Una CEK vale para todas las partes de un mensaje (cada parte con su `iv`, que es lo que
+ * AES-GCM exige), así que la bóveda sella una vez por mensaje y no una por parte.
+ */
+export const BIN_SEALED = 1
+
+export function isBinSealed (env) {
+  return !!env && env.bv === BIN_SEALED && !!env.k && typeof env.k === 'object' &&
+    env.iv instanceof Uint8Array && env.ct instanceof Uint8Array
+}
+
+/** Una CEK nueva para un mensaje con bytes. */
+export async function makeMessageKey () {
+  const { makeContentKey } = await crypto_()
+  if (typeof makeContentKey !== 'function') throw errorCon('sealing bytes needs @dotrino/identity >= 0.117.0', 'no-bytes-sealing')
+  return makeContentKey()
+}
+
+/** Cifra `bytes` con la CEK y devuelve los campos del sobre (`iv`, `ct`). */
+export async function encryptBytes (cek, bytes) {
+  const { encryptBytesWithCek } = await crypto_()
+  if (typeof encryptBytesWithCek !== 'function') throw errorCon('sealing bytes needs @dotrino/identity >= 0.117.0', 'no-bytes-sealing')
+  return encryptBytesWithCek({ cek, bytes })
+}
+
+/** Descifra el `ct` de un sobre binario con su CEK ya abierta. */
+export async function decryptBytes (cek, env) {
+  const { decryptBytesWithCek } = await crypto_()
+  if (typeof decryptBytesWithCek !== 'function') throw errorCon('opening bytes needs @dotrino/identity >= 0.117.0', 'no-bytes-sealing')
+  return decryptBytesWithCek({ cek, iv: env.iv, ct: env.ct })
+}

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

@@ -192,6 +192,29 @@ export class WebRTCManager {
     return false
   }
 
+  /**
+   * Mandar por el canal directo ESPERANDO a que su búfer baje. Para las partes de un
+   * mensaje grande: soltarlas todas de golpe desborda el búfer del canal, el navegador lo
+   * cierra y el resto se pierde. Devuelve false si el canal no está (o se cerró), y quien
+   * llama sigue por el proxio.
+   */
+  async sendDirect (to, payloadString, highWater = 1024 * 1024) {
+    const peer = this.peers.get(to)
+    const dc = peer && peer.dc
+    if (!dc || dc.readyState !== 'open') return false
+    while (dc.bufferedAmount > highWater) {
+      await new Promise((r) => setTimeout(r, 15))
+      if (dc.readyState !== 'open') return false
+    }
+    try {
+      dc.send(payloadString)
+      this.count?.('out', to, utf8Length(payloadString), peer.route || 'webrtc')
+      return true
+    } catch (_) {
+      return false
+    }
+  }
+
   /** Optional: explicitly preconnect to a peer. */
   connect (to) {
     const peer = this._ensurePeer(to)
@@ -328,6 +351,8 @@ export class WebRTCManager {
 
   _attachDC (peer, dc) {
     peer.dc = dc
+    // Los bytes como ArrayBuffer: un Blob se lee de forma asíncrona y desordenaría las partes.
+    try { dc.binaryType = 'arraybuffer' } catch (_) {}
     dc.onopen = () => {
       // Por dónde salió: directo o por TURN. Por detrás, sin retrasar a nadie.
       this.probeRoute(peer).catch(() => {})
@@ -344,10 +369,13 @@ export class WebRTCManager {
     }
     dc.onmessage = (ev) => {
       let parsed = null
-      const raw = ev.data
+      let 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 }
+      } else if (raw instanceof ArrayBuffer) {
+        // Un mensaje con bytes (binpack.js). En Node llega ya como Buffer, que es un Uint8Array.
+        raw = new Uint8Array(raw)
       }
       this.deliverMessage(peer.remote, parsed ?? raw, { raw, timestamp: Date.now(), via: 'webrtc' })
     }

package/vault/vendor/roadmap/VERSION.txt

@@ -1,3 +1,3 @@
-Copia vendorizada de @dotrino/roadmap@0.4.13 (dotrino-roadmap/src/{index,manifests}.js).
+Copia vendorizada de @dotrino/roadmap@0.4.17 (dotrino-roadmap/src/{index,manifests}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 El registro de versiones rotas que viaja con cada versión. Importa @dotrino/compat/ranges.

package/vault/vendor/roadmap/manifests.js

@@ -31,7 +31,7 @@ export const MANIFESTS = Object.freeze({
       "identity": {
         "repo": "imdotrino/dotrino-identity",
         "npm": "@dotrino/identity",
-        "current": "0.115.0",
+        "current": "0.116.0",
         "protocol": 1,
         "requires": {}
       },
@@ -47,13 +47,13 @@ export const MANIFESTS = Object.freeze({
       },
       "messenger": {
         "repo": "imdotrino/dotrino-messenger",
-        "current": "0.5.2",
+        "current": "0.7.0",
         "protocol": 2,
         "requires": {
           "identity": ">=0.108.0",
-          "proxy-client": ">=0.28.0",
+          "proxy-client": ">=0.34.0",
           "store": ">=0.12.3",
-          "proxy": "1.1.0+"
+          "proxy": "1.5.2+"
         }
       },
       "messenger-android": {
@@ -107,18 +107,19 @@ export const MANIFESTS = Object.freeze({
       },
       "proxy": {
         "repo": "imdotrino/dotrino-proxy",
-        "current": "1.4.9",
+        "current": "1.5.2",
         "protocol": 2,
         "requires": {
-          "vault": ">=0.79.0",
-          "identity": ">=0.99.0",
-          "proxy-client": ">=0.23.1"
+          "vault": ">=0.86.0",
+          "identity": ">=0.116.0",
+          "proxy-client": ">=0.23.1",
+          "content": "0.5.3+"
         }
       },
       "proxy-client": {
         "repo": "imdotrino/dotrino-proxy-client",
         "npm": "@dotrino/proxy-client",
-        "current": "0.32.2",
+        "current": "0.34.0",
         "protocol": 2,
         "requires": {
           "identity": ">=0.53.0",
@@ -128,11 +129,11 @@ export const MANIFESTS = Object.freeze({
       "remote-agent": {
         "repo": "imdotrino/dotrino-remote-agent",
         "npm": "@dotrino/remote-agent",
-        "current": "0.19.0",
+        "current": "0.19.1",
         "protocol": 1,
         "requires": {
-          "identity": ">=0.112.0",
-          "vault": ">=0.64.0",
+          "identity": ">=0.115.0",
+          "vault": ">=0.85.0",
           "proxy-client": ">=0.30.0",
           "vaultd": ">=0.154.0"
         }
@@ -140,12 +141,12 @@ export const MANIFESTS = Object.freeze({
       "terminal-agent": {
         "repo": "imdotrino/dotrino-terminal",
         "npm": "@dotrino/terminal-agent",
-        "current": "0.47.1",
+        "current": "0.47.4",
         "protocol": 2,
         "requires": {
           "remote-agent": ">=0.18.3",
-          "identity": ">=0.92.0",
-          "vault": ">=0.79.0",
+          "identity": ">=0.116.0",
+          "vault": ">=0.86.0",
           "proxy-client": ">=0.31.1",
           "vaultd": ">=0.142.0"
         }
@@ -168,7 +169,7 @@ export const MANIFESTS = Object.freeze({
       },
       "terminal-desktop": {
         "repo": "imdotrino/dotrino-terminal",
-        "current": "0.2.72",
+        "current": "0.2.74",
         "protocol": 1,
         "requires": {
           "terminal-agent": ">=0.37.0"
@@ -189,31 +190,31 @@ export const MANIFESTS = Object.freeze({
       "content": {
         "repo": "imdotrino/dotrino-content",
         "npm": "@dotrino/content",
-        "current": "0.5.1",
+        "current": "0.5.3",
         "protocol": 1,
         "requires": {
           "remote-agent": ">=0.13.0",
-          "identity": ">=0.92.0",
-          "vault": ">=0.79.0",
+          "identity": ">=0.116.0",
+          "vault": ">=0.86.0",
           "proxy-client": ">=0.23.1"
         }
       },
       "sealers": {
         "repo": "imdotrino/dotrino-sealers",
         "npm": "@dotrino/sealers",
-        "current": "0.9.1",
+        "current": "0.9.2",
         "protocol": 1,
         "requires": {
           "remote-agent": ">=0.13.0",
-          "identity": ">=0.92.0",
-          "vault": ">=0.75.0",
+          "identity": ">=0.116.0",
+          "vault": ">=0.86.0",
           "proxy-client": ">=0.23.1"
         }
       },
       "roadmap": {
         "repo": "imdotrino/dotrino-roadmap",
         "npm": "@dotrino/roadmap",
-        "current": "0.4.8",
+        "current": "0.4.14",
         "protocol": 1,
         "requires": {
           "compat": "0.4.0+"
@@ -249,28 +250,32 @@ export const MANIFESTS = Object.freeze({
       "vault": {
         "repo": "imdotrino/dotrino-vault",
         "npm": "@dotrino/vault",
-        "current": "0.85.0",
+        "current": "0.86.0",
         "protocol": 1,
         "requires": {
           "vaultd": ">=0.105.0",
           "proxy-client": "0.24.0+",
-          "identity": ">=0.115.0",
-          "opaque": ">=0.1.0"
+          "identity": ">=0.116.0",
+          "opaque": ">=0.1.0",
+          "compat": ">=0.4.0",
+          "roadmap": ">=0.4.13",
+          "passmanager": ">=0.17.0",
+          "store": ">=0.11.0"
         }
       },
       "vaultd": {
         "repo": "imdotrino/dotrino-vault",
         "npm": "@dotrino/vaultd",
-        "current": "0.155.0",
+        "current": "0.157.0",
         "protocol": 1,
         "requires": {
-          "identity": ">=0.115.0",
+          "identity": ">=0.116.0",
           "proxy-client": ">=0.30.1",
           "store": ">=0.11.0",
           "passmanager": ">=0.17.0",
           "compat": ">=0.4.0",
           "opaque": ">=0.1.0",
-          "roadmap": ">=0.3.19"
+          "roadmap": ">=0.4.13"
         }
       },
       "verifier": {
@@ -312,12 +317,12 @@ export const MANIFESTS = Object.freeze({
       },
       "passmanager-extension": {
         "repo": "imdotrino/dotrino-passmanager",
-        "current": "0.48.4",
+        "current": "0.49.1",
         "protocol": 1,
         "requires": {
-          "identity": ">=0.109.0",
-          "proxy-client": ">=0.30.4",
-          "vault": ">=0.82.1",
+          "identity": ">=0.116.0",
+          "proxy-client": ">=0.32.2",
+          "vault": ">=0.86.0",
           "proxy": "1.1.0+"
         }
       },
@@ -333,11 +338,11 @@ export const MANIFESTS = Object.freeze({
       },
       "social-bot": {
         "repo": "imdotrino/dotrino-social-bot",
-        "current": "0.2.0",
+        "current": "0.2.1",
         "protocol": 1,
         "requires": {
-          "vault": ">=0.75.0",
-          "identity": ">=0.92.0",
+          "vault": ">=0.86.0",
+          "identity": ">=0.116.0",
           "proxy-client": ">=0.23.1",
           "remote-agent": ">=0.13.0"
         }

package/vault/vendor/vault/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/vault@0.86.0 (dotrino-vault/lib/src/{admin,b64,browser,core/approvals,core/blocked,core/browserDisk,core/commKey,core/disk,core/libVersion,core/machines,core/notices,core/notifiable,core/passwords,core/sealKey,core/sealer,core/sealers,core/secretsStore,core/sha256,core/store,core/subacta,core/threadStore,core/transport,core/vault,enroll,index,loginClient,passwordLogins,procContext,protocol,revocation,sealed}.js).
+Copia vendorizada de @dotrino/vault@0.86.1 (dotrino-vault/lib/src/{admin,b64,browser,core/approvals,core/blocked,core/browserDisk,core/commKey,core/disk,core/libVersion,core/machines,core/notices,core/notifiable,core/passwords,core/sealKey,core/sealer,core/sealers,core/secretsStore,core/sha256,core/store,core/subacta,core/threadStore,core/transport,core/vault,enroll,index,loginClient,passwordLogins,procContext,protocol,revocation,sealed}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 browser.js es la bóveda de esta pestaña: el MISMO núcleo que el binario (core/), con
 el disco en IndexedDB. Importa @dotrino/{compat,roadmap,passmanager,store/core} y