@dotrino/identity 0.119.0 → 0.120.0

package/README.md

@@ -246,6 +246,22 @@ Lo que hace que esto no sea una llave maestra de repuesto:
 Diseño y hacia dónde va (inicio de sesión y federación):
 [`dotrino-vault/docs/inicio-de-sesion.md`](../dotrino-vault/docs/inicio-de-sesion.md).
 
+### Canal de sesión de los agentes remotos (0.120.0+)
+
+```js
+import { makeEphemeral, deriveKey, seal, open } from '@dotrino/identity/channel'
+```
+
+ECDH P-256 efímero → HKDF → AES-256-GCM: las dos puntas acuerdan una llave de sesión y la
+usan para muchos mensajes. Lo usa `@dotrino/remote-agent` (antes vivía allí). Para un sobre
+suelto hacia una llave, `wrapForMember`/`openWrap` de `@dotrino/identity/content`.
+
+### Huella de una llave
+
+`keyLabel(pub)` de `@dotrino/identity/keyid` da `AB12-CD34`, la que se enseña en todo el
+ecosistema. Úsala en vez de recortar `pubkeyId` a mano. Desde 0.120.0 una llave ilegible
+LANZA (antes devolvía `''`); sin llave sigue siendo `''`.
+
 ### Backup / migración
 
 - `id.exportIdentity()` → blob JSON con `privateJwk` (ECDSA), `encPrivateJwk` (ECDH), `me`, `peers`. **Sensible** — el host app es responsable de guardarlo de manera segura.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.119.0",
+  "version": "0.120.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",
@@ -34,6 +34,9 @@
     "./content": {
       "import": "./vault/content.js"
     },
+    "./channel": {
+      "import": "./vault/channel.js"
+    },
     "./assertion": {
       "import": "./vault/assertion.js"
     },

package/vault/acta.js

@@ -35,7 +35,7 @@
  * Módulo PURO: sin kv, sin red, sin disco. Cripto de `./capabilities.js`.
  */
 import { canonicalStringify } from './core.js'
-import { signWithDevice, verifyDeviceSig, verifyDelegation, pubkeyId } from './capabilities.js'
+import { signWithDevice, verifyDeviceSig, verifyDelegation, keyLabel } from './capabilities.js'
 import { cleanMachine } from './machine.js'
 export { cleanMachine }
 
@@ -368,8 +368,8 @@ export async function verifySealerLinkChain (chain, { expectedProfileId = null }
 
 /** Id legible de un miembro (mismo formato que el deviceId del emparejamiento). */
 export async function memberId (pub) {
-  const id = (await pubkeyId(pub)).slice(0, 8).toUpperCase()
-  return id.slice(0, 4) + '-' + id.slice(4, 8)
+  if (!pub) throw new Error('memberId: missing key')
+  return keyLabel(pub)
 }
 
 /** ¿Esta acta es un traspaso? (la firmó uno y nombra master a otro) */

package/vault/channel.js

@@ -0,0 +1,77 @@
+/**
+ * channel.js — canal cifrado punto a punto entre el dispositivo enlazado y un agente
+ * remoto del ecosistema Dotrino (lo usa `@dotrino/remote-agent`; antes vivía allí). Isomórfico: usa WebCrypto
+ * (`globalThis.crypto.subtle`), disponible tanto en el navegador (PWA) como en
+ * Node ≥ 18.
+ *
+ * NO reimplementa la identidad ni la firma del ecosistema: la AUTORIZACIÓN la da
+ * el vault (cert de dispositivo verificado con `@dotrino/identity/capabilities`
+ * → cadena hasta la maestra). Este módulo solo levanta un secreto de sesión
+ * efímero (ECDH P-256 → HKDF → AES-256-GCM) para que el relay de transporte
+ * (`proxy.dotrino.com`) vea únicamente texto cifrado. La identidad de las dos
+ * puntas ya la garantizan las firmas del vault que envuelven las claves efímeras.
+ *
+ * Distinto de `content.js` a propósito: aquí la llave es de SESIÓN (se acuerda una vez
+ * y cifra muchos mensajes, con HKDF y la pública en raw), allí cada sobre lleva su
+ * efímera. El `info` de HKDF conserva su nombre: es parte del cable, y lo hablan también
+ * los puertos nativos de `dotrino-native`.
+ */
+
+const subtle = () => globalThis.crypto.subtle
+
+const b64 = {
+  enc (buf) {
+    const b = new Uint8Array(buf)
+    let s = ''
+    for (let i = 0; i < b.length; i++) s += String.fromCharCode(b[i])
+    return btoa(s)
+  },
+  dec (str) {
+    const bin = atob(str)
+    const out = new Uint8Array(bin.length)
+    for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i)
+    return out
+  }
+}
+
+/** Genera un par ECDH P-256 efímero. Devuelve la pub en raw (base64) + privada. */
+export async function makeEphemeral () {
+  const kp = await subtle().generateKey({ name: 'ECDH', namedCurve: 'P-256' }, false, ['deriveBits'])
+  const raw = await subtle().exportKey('raw', kp.publicKey)
+  return { privateKey: kp.privateKey, pub: b64.enc(raw) }
+}
+
+/**
+ * Deriva la clave AES-256-GCM de la sesión a partir de la privada propia y la
+ * pub efímera (base64 raw) del otro extremo. `salt` liga la clave a la sesión.
+ */
+export async function deriveKey (privateKey, otherPubB64, salt) {
+  const otherPub = await subtle().importKey(
+    'raw', b64.dec(otherPubB64), { name: 'ECDH', namedCurve: 'P-256' }, false, []
+  )
+  const bits = await subtle().deriveBits({ name: 'ECDH', public: otherPub }, privateKey, 256)
+  const hkdfKey = await subtle().importKey('raw', bits, 'HKDF', false, ['deriveKey'])
+  return subtle().deriveKey(
+    { name: 'HKDF', hash: 'SHA-256', salt: new TextEncoder().encode(salt), info: new TextEncoder().encode('dotrino-remote-agent-e2e') },
+    hkdfKey,
+    { name: 'AES-GCM', length: 256 },
+    false,
+    ['encrypt', 'decrypt']
+  )
+}
+
+/** Cifra un objeto JSON → sobre { iv, ct } (ambos base64). */
+export async function seal (key, obj) {
+  const iv = globalThis.crypto.getRandomValues(new Uint8Array(12))
+  const pt = new TextEncoder().encode(JSON.stringify(obj))
+  const ct = await subtle().encrypt({ name: 'AES-GCM', iv }, key, pt)
+  return { iv: b64.enc(iv), ct: b64.enc(ct) }
+}
+
+/** Descifra un sobre { iv, ct } → objeto JSON. Lanza si el tag GCM no valida. */
+export async function open (key, env) {
+  const pt = await subtle().decrypt({ name: 'AES-GCM', iv: b64.dec(env.iv) }, key, b64.dec(env.ct))
+  return JSON.parse(new TextDecoder().decode(pt))
+}
+
+export { b64 }

package/vault/core.js

@@ -23,7 +23,7 @@ import * as Acta from './acta.js'
 import * as Content from './content.js'
 import { syncPeers, stampOf } from './peerSync.js'
 import { assertionBody, cleanScopes, claimsAllowed, ASSERTION_DEFAULT_TTL_MS, ASSERTION_MAX_TTL_MS } from './assertion.js'
-import { pubkeyId as pubkeyIdOf, signWithDevice } from './capabilities.js'
+import { pubkeyId as pubkeyIdOf, signWithDevice, keyLabel } from './capabilities.js'
 import { enrollDevice as remoteEnroll, requestSign as remoteSign, requestStore as remoteStore, requestDevices as remoteDevices, requestRenew as remoteRenew, requestAdmin as remoteAdmin, requestApproval as remoteApproval, requestRenounce as remoteRenounce, checkMembership as remoteCheck, registerLocalVault } from './remote.js'
 
 export const KEY_STORAGE = 'dotrino.identity.keypair'
@@ -1128,7 +1128,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
     } catch (_) { return null }
   }
 
-  const deviceIdDe = async (pub) => (await pubkeyIdOf(pub)).slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2')
+  const deviceIdDe = keyLabel
 
   /**
    * @param {object} entrada  lo que devuelve `loginWithPassword` del pilar

package/vault/keyid.js

@@ -32,10 +32,9 @@ export async function pubkeyId (publicJwkStr) {
  */
 export async function keyLabel (publicJwkStr) {
   if (!publicJwkStr) return ''
-  try {
-    const id = (await pubkeyId(publicJwkStr)).slice(0, 8).toUpperCase()
-    return id.slice(0, 4) + '-' + id.slice(4, 8)
-  } catch (_) { return '' }
+  // Una llave que no se puede leer LANZA: un '' callado se pintaba como «sin aparato».
+  const id = (await pubkeyId(publicJwkStr)).slice(0, 8).toUpperCase()
+  return id.slice(0, 4) + '-' + id.slice(4, 8)
 }
 
 export default { pubkeyId, keyLabel }

package/vault/remote.js

@@ -13,7 +13,7 @@
  * No reimplementa cripto: usa `@dotrino/identity/capabilities`. Transporte:
  * `@dotrino/proxy-client` (importado perezosamente; solo se carga al emparejar).
  */
-import { makeDeviceKey, signWithDevice, verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from './capabilities.js'
+import { makeDeviceKey, signWithDevice, verifyDeviceSig, makePairingCode, commitCode, keyLabel } from './capabilities.js'
 import { checkVaultReply } from './acta.js'
 import { cleanMachine, browserMachine } from './machine.js'
 
@@ -146,7 +146,7 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', conti
     // identidad (P) como `device` → el cert delega tu identidad y hay UNA sola (signData/
     // identify/cert son la misma P).
     const dev = device || await makeDeviceKey({ label })
-    const deviceId = (await pubkeyId(dev.publickey)).slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2')
+    const deviceId = await keyLabel(dev.publickey)
     // El DISPOSITIVO genera el código y manda solo su COMPROMISO (no el código). El vault
     // aprende el código únicamente cuando vos lo tipeás en el PC → aprobar exige tener el dispositivo.
     const code = makePairingCode()

package/vault/vault.js

@@ -13,7 +13,7 @@ import {
   initPeerStorage, loadPeers, savePeers, setPeersDirect, upsertPeer, onDirty
 } from './peerStore.js'
 import { createIdentityCore } from './core.js'
-import { pubkeyId } from './capabilities.js'
+import { keyLabel } from './capabilities.js'
 import { withExternalKeys, appBridge } from './externalKeys.js'
 import { nativeBackends } from './nativeStore.js'
 import { useBackend as usePeerBackend } from './peerStore.js'
@@ -320,7 +320,7 @@ import { useBackend as usePeerBackend } from './peerStore.js'
         if (!bySub.has(x.sub) || (x.exp || 0) > (bySub.get(x.sub).exp || 0)) bySub.set(x.sub, x)
       }
       const devices = await Promise.all([...bySub.values()].map(async (x) => ({
-        deviceId: (await pubkeyId(x.sub)).slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2'),
+        deviceId: await keyLabel(x.sub),
         sub: x.sub, label: x.label || '', scope: x.scope, exp: x.exp, nonce: x.nonce
       })))
       return { devices, revoked: (revoked || []).map((r) => r.nonce || r) }

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

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

@@ -5,17 +5,8 @@ import { WebRTCManager, RTC_TAG, DEFAULT_ICE_SERVERS, loadNodePeerConnection, re
 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'
+import { errorWithCode } from './errors.js'
 
-/**
- * Error con un `code` estable.
- *
- * El contrato es el CODE, no la frase: comprobar por el texto cruza procesos y
- * se rompe en silencio en cuanto alguien lo reescribe o lo traduce.
- *
- * @param {string} mensaje
- * @param {string} code
- * @returns {Error & { code: string }}
- */
 /**
  * EL SALUDO: «este token es de esta identidad».
  *
@@ -32,12 +23,6 @@ const HELLO_TAG = '__cc_hello__'
  */
 const SPEAKS = ['binary']
 
-function errorCon (mensaje, code) {
-  const e = /** @type {Error & { code: string }} */ (new Error(mensaje))
-  e.code = code
-  return e
-}
-
 /**
  * Dotrino WebSocket proxy client.
  * Minimal API: connection + token + messages + channels (publish/list/count/disconnect)
@@ -280,7 +265,7 @@ export class WebSocketProxyClient {
     // las peticiones pendientes). Sin esto, quien esperaba un `publish` se comía
     // los 10 s completos del timeout para enterarse de algo que ya se sabía, y
     // el temporizador mantenía vivo el proceso en Node ese rato.
-    this._rejectAllPending(errorCon('Connection closed', 'CONNECTION_CLOSED'))
+    this._rejectAllPending(errorWithCode('Connection closed', 'CONNECTION_CLOSED'))
   }
 
   /** Corta en seco todo lo que esperaba respuesta, con su motivo. */
@@ -351,7 +336,7 @@ export class WebSocketProxyClient {
     // abierto es no guardar ninguno: la app manda por donde le sale y el proxio lo lee
     // igual. Para sellar por token está `sendSealedTo`.
     if (this.requireSealed && !this._isSealed(payload)) {
-      throw errorCon(
+      throw errorWithCode(
         'requireSealed: refusing to send a directed message in the clear — use sendSealedTo()',
         'unsealed')
     }
@@ -527,7 +512,7 @@ export class WebSocketProxyClient {
     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')
+      throw errorWithCode(`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. Y
     // si alguno de los destinatarios dijo que no los entiende, tampoco.
@@ -576,7 +561,7 @@ export class WebSocketProxyClient {
       // solo sobre solo lo abriría una—, así que ahí se exige decirlo.
       if (!peerPubkey && tokens.length === 1) peerPubkey = this.pubkeyOfToken(tokens[0])
       if (!peerPubkey) {
-        throw errorCon(
+        throw errorWithCode(
           'sendSealedTo: nobody has said whose this token is — greet it (helloTo) or pass peerPubkey',
           'no-peer-identity')
       }
@@ -607,7 +592,7 @@ export class WebSocketProxyClient {
     // 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')
+      throw errorWithCode(`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.
@@ -650,7 +635,7 @@ export class WebSocketProxyClient {
   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')
+      throw errorWithCode('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 })
@@ -673,7 +658,7 @@ export class WebSocketProxyClient {
    */
   sendToOrQueue (token, payload, { peerPubkey } = /** @type {any} */ ({})) {
     if (!token || !peerPubkey) {
-      throw errorCon('sendToOrQueue: needs the token and whose it is (peerPubkey)', 'no-peer-identity')
+      throw errorWithCode('sendToOrQueue: needs the token and whose it is (peerPubkey)', 'no-peer-identity')
     }
     this._sendToTokenOrQueue(token, payload, peerPubkey)
   }
@@ -691,7 +676,7 @@ export class WebSocketProxyClient {
    */
   _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')
+      throw errorWithCode('requireSealed: refusing to send a directed message in the clear — use sendSealedTo()', 'unsealed')
     }
     const messageStr = this._wire(sobre)
     if (!skipDirect && this._rtc && this._rtc.trySend(token, messageStr)) return
@@ -747,7 +732,7 @@ export class WebSocketProxyClient {
    */
   helloTo (to) {
     if (!this.myPublickey) {
-      throw errorCon('helloTo: identify first — a greeting with no identity says nothing', 'not-identified')
+      throw errorWithCode('helloTo: identify first — a greeting with no identity says nothing', 'not-identified')
     }
     const tokens = Array.isArray(to) ? to : [to]
     for (const t of tokens) {
@@ -789,7 +774,7 @@ export class WebSocketProxyClient {
   _needPeerBinary (targets) {
     for (const t of targets) {
       if (t && this.speaks(t, 'binary') === false) {
-        throw errorCon('the other side does not take binary messages (it needs @dotrino/proxy-client >= 0.36.0)', 'peer-no-binary')
+        throw errorWithCode('the other side does not take binary messages (it needs @dotrino/proxy-client >= 0.36.0)', 'peer-no-binary')
       }
     }
   }
@@ -815,7 +800,7 @@ export class WebSocketProxyClient {
 
   /** Sella con lo que haya: la bóveda de la app (`sealing`) o las primitivas del pilar. */
   async _seal (payload, peerEncPub, peerPubkey) {
-    if (!peerEncPub) throw errorCon('seal: missing peerEncPub', 'unsealed')
+    if (!peerEncPub) throw errorWithCode('seal: missing peerEncPub', 'unsealed')
     return this.sealing
       ? this.sealing.seal(payload, peerEncPub, { publickey: peerPubkey })
       : seal(payload, peerEncPub)
@@ -856,7 +841,7 @@ export class WebSocketProxyClient {
   /** 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')
+      throw errorWithCode('this proxy does not take binary frames (it needs websocket-proxy >= 1.6.0)', 'no-binary-support')
     }
   }
 
@@ -867,7 +852,7 @@ export class WebSocketProxyClient {
     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')
+        if (!o || typeof o.cek !== 'string') throw errorWithCode('the sealed key of a message has no key inside', 'bad-pack')
         return o.cek
       })()
       this._msgKeys.set(id, p)
@@ -909,7 +894,7 @@ export class WebSocketProxyClient {
    */
   async encPubOf (publickey) {
     if (typeof publickey !== 'string' || !publickey) {
-      throw errorCon('encPubOf: missing publickey', 'encpub-shape')
+      throw errorWithCode('encPubOf: missing publickey', 'encpub-shape')
     }
     const cacheada = this._encPubs.get(publickey)
     if (cacheada) return cacheada
@@ -931,7 +916,7 @@ export class WebSocketProxyClient {
       const propia = await this.encPubResolver(publickey)
       if (propia) {
         if (!isEncPub(propia)) {
-          throw errorCon('encPubResolver returned something that is not a P-256 public JWK', 'encpub-unverified')
+          throw errorWithCode('encPubResolver returned something that is not a P-256 public JWK', 'encpub-unverified')
         }
         this._encPubs.set(publickey, propia)
         return propia
@@ -941,7 +926,7 @@ export class WebSocketProxyClient {
     // esperar diez segundos a un timeout. Un proxio que no manda `caps` es de antes de
     // que esto existiera y no se sabe: se pregunta igual, y contesta la pregunta.
     if (Array.isArray(this.caps) && !this.caps.includes('encpub')) {
-      throw errorCon(
+      throw errorWithCode(
         `este proxio (${this.url}) no sirve llaves de cifrado: hace falta websocket-proxy >= 1.1.0`,
         'no-encpub-support')
     }
@@ -950,7 +935,7 @@ export class WebSocketProxyClient {
     // la app puede tener el mismo JWK escrito de otra forma.
     const statement = (res.keys || []).find((k) => samePubkey(k?.data?.publickey, publickey))
     if (!statement) {
-      throw errorCon('no encryption key announced for that identity — it cannot be sealed to yet', 'no-encpub')
+      throw errorWithCode('no encryption key announced for that identity — it cannot be sealed to yet', 'no-encpub')
     }
     // AQUÍ ES DONDE EL PROXIO DEJA DE IMPORTAR: la firma se comprueba contra la pubkey a
     // la que vamos a escribir. Si cambió la llave por la suya, esto lanza.
@@ -1015,7 +1000,7 @@ export class WebSocketProxyClient {
         }
         let opened
         try {
-          if (!this._isSealed(env.k)) throw errorCon('the key of a sealed message is not sealed', 'bad-pack')
+          if (!this._isSealed(env.k)) throw errorWithCode('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 })
@@ -1567,7 +1552,7 @@ export class WebSocketProxyClient {
     if (ws !== this.ws || this._connected) return
     this.ws = null   // a partir de acá, los eventos tardíos de `ws` se ignoran
     try { ws.close() } catch (_) {}
-    const err = errorCon(`could not open the connection to ${this.url} in ${Math.round(this.connectTimeout / 1000)}s`, 'CONNECT_TIMEOUT')
+    const err = errorWithCode(`could not open the connection to ${this.url} in ${Math.round(this.connectTimeout / 1000)}s`, 'CONNECT_TIMEOUT')
     this._emit('error', { type: 'connect_timeout', error: err })
     if (this._connectReject) {
       this._connectReject(err)
@@ -1781,7 +1766,7 @@ export class WebSocketProxyClient {
 
   _sendRaw (frame) {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      throw errorCon('WebSocket not connected', 'NOT_CONNECTED')
+      throw errorWithCode('WebSocket not connected', 'NOT_CONNECTED')
     }
     if (frame.message instanceof Uint8Array) {
       this._needBinaryProxy()
@@ -1860,7 +1845,7 @@ export class WebSocketProxyClient {
       const out = { ...frame, id }
       const timer = setTimeout(() => {
         this._pending.delete(id)
-        reject(errorCon(`Timeout waiting for ${expectedType}`, 'REQUEST_TIMEOUT'))
+        reject(errorWithCode(`Timeout waiting for ${expectedType}`, 'REQUEST_TIMEOUT'))
       }, 10000)
       this._pending.set(id, { resolve, reject, timer, expectedType, channelKey })
       try {
@@ -1891,7 +1876,7 @@ export class WebSocketProxyClient {
     this._pending.delete(id)
     // Con su `code`: quien llama distingue los casos por él, no por la frase (que el proxio
     // puede cambiar o traducir). Antes se perdía aquí y solo quedaba comparar el texto.
-    const e = errorCon(data.error || 'Server error', data.code || null)
+    const e = errorWithCode(data.error || 'Server error', data.code || null)
     // «Ahora no» (429) y cuánto esperar, cuando el proxio lo dice.
     if (data.status) e.status = data.status
     if (data.retry_after_ms) e.retryAfterMs = data.retry_after_ms

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

@@ -28,6 +28,7 @@
  */
 import { canonicalStringify } from './canonical.js'
 import { verifyData, samePubkey } from './signature.js'
+import { errorWithCode } from './errors.js'
 
 export const ENCPUB_V = 1
 
@@ -54,17 +55,6 @@ export function isEncPub (v) {
   }
 }
 
-/**
- * @param {string} mensaje
- * @param {string} code
- * @returns {Error & { code: string }}
- */
-function errorCon (mensaje, code) {
-  const e = /** @type {Error & { code: string }} */ (new Error(mensaje))
-  e.code = code
-  return e
-}
-
 /**
  * Firma el anuncio con lo que firma la identidad (`identity.signData`, o la llave local
  * del cliente). No genera llaves ni cifra nada: solo dice de quién es la que ya tienes.
@@ -73,15 +63,15 @@ function errorCon (mensaje, code) {
  * @returns {Promise<{data:any, signature:string}>}
  */
 export async function buildEncPubStatement ({ publickey, encPub, sign } = /** @type {any} */ ({})) {
-  if (typeof publickey !== 'string' || !publickey) throw errorCon('buildEncPubStatement: missing publickey', 'encpub-shape')
-  if (!isEncPub(encPub)) throw errorCon('buildEncPubStatement: encPub is not a P-256 public JWK', 'encpub-shape')
-  if (typeof sign !== 'function') throw errorCon('buildEncPubStatement: missing sign(data)', 'encpub-shape')
+  if (typeof publickey !== 'string' || !publickey) throw errorWithCode('buildEncPubStatement: missing publickey', 'encpub-shape')
+  if (!isEncPub(encPub)) throw errorWithCode('buildEncPubStatement: encPub is not a P-256 public JWK', 'encpub-shape')
+  if (typeof sign !== 'function') throw errorWithCode('buildEncPubStatement: missing sign(data)', 'encpub-shape')
   const data = encPubBody({ publickey, encPub })
   const firmado = await sign(data)
   const signature = typeof firmado === 'string' ? firmado : firmado?.signature
   // «No pude firmar» no es «se cayó la red», y aquí es donde se separan: quien llama
   // decide una cosa u otra según el `code`, nunca según la frase.
-  if (typeof signature !== 'string') throw errorCon('buildEncPubStatement: sign() returned no signature', 'no-signature')
+  if (typeof signature !== 'string') throw errorWithCode('buildEncPubStatement: sign() returned no signature', 'no-signature')
   return { data, signature }
 }
 
@@ -98,21 +88,21 @@ export async function buildEncPubStatement ({ publickey, encPub, sign } = /** @t
  */
 export async function readEncPubStatement (statement, { publickey } = /** @type {any} */ ({})) {
   if (typeof publickey !== 'string' || !publickey) {
-    throw errorCon('readEncPubStatement: missing the publickey to check against', 'encpub-shape')
+    throw errorWithCode('readEncPubStatement: missing the publickey to check against', 'encpub-shape')
   }
   const data = statement?.data
   const signature = statement?.signature
-  if (!data || typeof signature !== 'string') throw errorCon('encpub statement: malformed', 'encpub-unverified')
-  if (data.v !== ENCPUB_V || data.op !== 'encpub') throw errorCon('encpub statement: not an encpub announcement', 'encpub-unverified')
-  if (data.aud !== ENCPUB_AUD) throw errorCon('encpub statement: wrong audience', 'encpub-unverified')
+  if (!data || typeof signature !== 'string') throw errorWithCode('encpub statement: malformed', 'encpub-unverified')
+  if (data.v !== ENCPUB_V || data.op !== 'encpub') throw errorWithCode('encpub statement: not an encpub announcement', 'encpub-unverified')
+  if (data.aud !== ENCPUB_AUD) throw errorWithCode('encpub statement: wrong audience', 'encpub-unverified')
   // `samePubkey` y no `===`: un JWK serializado no es canónico y la misma llave escrita
   // por dos piezas distintas da dos strings distintos.
-  if (!samePubkey(data.publickey, publickey)) throw errorCon('encpub statement: announces another identity', 'encpub-unverified')
-  if (!isEncPub(data.encpub)) throw errorCon('encpub statement: not a P-256 public JWK', 'encpub-unverified')
+  if (!samePubkey(data.publickey, publickey)) throw errorWithCode('encpub statement: announces another identity', 'encpub-unverified')
+  if (!isEncPub(data.encpub)) throw errorWithCode('encpub statement: not a P-256 public JWK', 'encpub-unverified')
   // Se verifica con la llave que ANUNCIA el sobre, que ya se comprobó que es la misma que
   // la pedida: así el texto firmado y la llave que lo comprueba salen del mismo sitio.
   if (!(await verifyData(data.publickey, data, signature))) {
-    throw errorCon('encpub statement: bad signature — the key is not bound to that identity', 'encpub-unverified')
+    throw errorWithCode('encpub statement: bad signature — the key is not bound to that identity', 'encpub-unverified')
   }
   return data.encpub
 }

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

@@ -0,0 +1,15 @@
+/**
+ * Error con un `code` estable.
+ *
+ * El contrato es el CODE, no la frase: comprobar por el texto cruza procesos y
+ * se rompe en silencio en cuanto alguien lo reescribe o lo traduce.
+ *
+ * @param {string} message
+ * @param {string} code
+ * @returns {Error & { code: string }}
+ */
+export function errorWithCode (message, code) {
+  const e = /** @type {Error & { code: string }} */ (new Error(message))
+  e.code = code
+  return e
+}

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

@@ -15,14 +15,9 @@
  * second, older copy of a pillar inside every consumer.
  */
 
-const ECDH = { name: 'ECDH', namedCurve: 'P-256' }
+import { errorWithCode } from './errors.js'
 
-/** Un error con `code`: quien llama decide por el código, nunca por la frase. */
-function errorCon (mensaje, code) {
-  const e = /** @type {Error & { code: string }} */ (new Error(mensaje))
-  e.code = code
-  return e
-}
+const ECDH = { name: 'ECDH', namedCurve: 'P-256' }
 
 const VERSION = 1
 
@@ -137,7 +132,7 @@ export function identitySealing (identity, { app = 'dotrino' } = {}) {
 
   return {
     async seal (msg, peerEncPub, { publickey } = {}) {
-      if (!peerEncPub) throw errorCon('no encryption key for the other side', 'unsealed')
+      if (!peerEncPub) throw errorWithCode('no encryption key for the other side', 'unsealed')
       // Destinatarios como OBJETOS, y CON SU `publickey`: `encrypt` expande cada uno a
       // todos los aparatos de esa persona por su tarjeta de perfil, y la tarjeta se busca
       // por la pubkey. Sin ella el sobre solo lo abría el aparato que anunció la llave, y
@@ -149,7 +144,7 @@ export function identitySealing (identity, { app = 'dotrino' } = {}) {
       // VACÍO: cifrado de verdad, y que no abre nadie. Eso no es un sobre, es un mensaje
       // perdido con cara de enviado.
       if (!sealed || !sealed.wrap || Object.keys(sealed.wrap).length === 0) {
-        throw errorCon('identitySealing: the vault wrapped the message for nobody', 'unsealed')
+        throw errorWithCode('identitySealing: the vault wrapped the message for nobody', 'unsealed')
       }
       return { app, sealed, from: await myEncPub() }
     },
@@ -189,20 +184,20 @@ export function isBinSealed (env) {
 /** 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')
+  if (typeof makeContentKey !== 'function') throw errorWithCode('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')
+  if (typeof encryptBytesWithCek !== 'function') throw errorWithCode('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')
+  if (typeof decryptBytesWithCek !== 'function') throw errorWithCode('opening bytes needs @dotrino/identity >= 0.117.0', 'no-bytes-sealing')
   return decryptBytesWithCek({ cek, iv: env.iv, ct: env.ct })
 }

package/vault/vendor/roadmap/VERSION.txt

@@ -1,3 +1,3 @@
-Copia vendorizada de @dotrino/roadmap@0.4.29 (dotrino-roadmap/src/{index,manifests}.js).
+Copia vendorizada de @dotrino/roadmap@0.4.30 (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

@@ -8,8 +8,8 @@
 export const MANIFESTS = Object.freeze({
   "dotrino": {
     "manifest": "dotrino",
-    "seq": 29,
-    "issued": "2026-10-15",
+    "seq": 30,
+    "issued": "2026-10-16",
     "note": "Registro comun de compatibilidad del ecosistema. Se edita a mano en este repo y se consulta con @dotrino/roadmap. Rangos: ver @dotrino/compat/ranges (x.y.z, >= > <= <, «a - b», «*», o una lista que es un O).",
     "products": {
       "compat": {
@@ -22,18 +22,20 @@ export const MANIFESTS = Object.freeze({
       "env": {
         "repo": "imdotrino/dotrino-vault",
         "npm": "@dotrino/env",
-        "current": "0.85.0",
+        "current": "0.90.1",
         "protocol": 1,
         "requires": {
-          "vault": ">=0.70.0"
+          "vault": ">=0.90.1"
         }
       },
       "identity": {
         "repo": "imdotrino/dotrino-identity",
         "npm": "@dotrino/identity",
-        "current": "0.118.0",
+        "current": "0.119.0",
         "protocol": 1,
-        "requires": {}
+        "requires": {
+          "proxy-client": ">=0.13.1"
+        }
       },
       "lobby": {
         "repo": "imdotrino/dotrino-lobby",
@@ -107,7 +109,7 @@ export const MANIFESTS = Object.freeze({
       },
       "proxy": {
         "repo": "imdotrino/dotrino-proxy",
-        "current": "1.6.3",
+        "current": "1.6.4",
         "protocol": 2,
         "requires": {
           "vault": ">=0.87.0",
@@ -215,7 +217,7 @@ export const MANIFESTS = Object.freeze({
       "roadmap": {
         "repo": "imdotrino/dotrino-roadmap",
         "npm": "@dotrino/roadmap",
-        "current": "0.4.29",
+        "current": "0.4.30",
         "protocol": 1,
         "requires": {
           "compat": "0.4.0+"
@@ -251,7 +253,7 @@ export const MANIFESTS = Object.freeze({
       "vault": {
         "repo": "imdotrino/dotrino-vault",
         "npm": "@dotrino/vault",
-        "current": "0.89.0",
+        "current": "0.90.1",
         "protocol": 1,
         "requires": {
           "vaultd": ">=0.105.0",
@@ -261,13 +263,13 @@ export const MANIFESTS = Object.freeze({
           "compat": ">=0.4.0",
           "roadmap": ">=0.4.26",
           "passmanager": ">=0.18.4",
-          "store": ">=0.11.0"
+          "store": ">=0.12.3"
         }
       },
       "vaultd": {
         "repo": "imdotrino/dotrino-vault",
         "npm": "@dotrino/vaultd",
-        "current": "0.161.0",
+        "current": "0.162.1",
         "protocol": 1,
         "requires": {
           "identity": ">=0.118.0",
@@ -318,12 +320,12 @@ export const MANIFESTS = Object.freeze({
       },
       "passmanager-extension": {
         "repo": "imdotrino/dotrino-passmanager",
-        "current": "0.53.4",
+        "current": "0.54.0",
         "protocol": 1,
         "requires": {
           "identity": ">=0.118.0",
           "proxy-client": ">=0.36.1",
-          "vault": ">=0.88.0",
+          "vault": ">=0.90.0",
           "proxy": "1.1.0+",
           "vaultd": ">=0.160.2"
         }

package/vault/vendor/store/VERSION.txt

@@ -1,3 +1,3 @@
-Copia vendorizada de @dotrino/store/core@0.12.3 (dotrino-store/store/{core}.js).
+Copia vendorizada de @dotrino/store/core@0.12.4 (dotrino-store/store/{core}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 Las reglas del almacén (lápidas, páginas): las mismas en el store y en la bóveda.

package/vault/vendor/vault/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/vault@0.90.0 (dotrino-vault/lib/src/{admin,b64,browser,core/approvals,core/backup,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.90.2 (dotrino-vault/lib/src/{admin,b64,browser,core/approvals,core/backup,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

package/vault/vendor/vault/core/libVersion.js

@@ -5,4 +5,4 @@
  * si no coincide con la del paquete: una versión anunciada que no es la que corre es peor
  * que no anunciar ninguna.
  */
-export const LIB_VERSION = '0.90.0'
+export const LIB_VERSION = '0.90.2'

package/vault/vendor/vault/sealed.js

@@ -16,30 +16,13 @@
  * P-256 + AES-GCM, llaves como JWK string.
  */
 
-const subtle = globalThis.crypto.subtle
-
-function b64 (buf) {
-  const bytes = new Uint8Array(buf)
-  let s = ''
-  for (let i = 0; i < bytes.length; i++) s += String.fromCharCode(bytes[i])
-  return btoa(s)
-}
+import { wrapForMember, openWrap } from '@dotrino/identity/content'
 
-function fromB64 (str) {
-  const bin = atob(str)
-  const out = new Uint8Array(bin.length)
-  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i)
-  return out
-}
+// El sobre es el MISMO que el de las llaves de contenido de identity (ECDH P-256 efímero
+// → AES-256-GCM, `epk` en JWK): aquí solo se le mete un JSON en vez de una CEK. Antes
+// estaba escrito otra vez en este archivo, byte a byte igual.
 
-async function deriveAesKey (privateKey, publicJwkStr) {
-  const pub = await subtle.importKey(
-    'jwk', JSON.parse(publicJwkStr),
-    { name: 'ECDH', namedCurve: 'P-256' }, false, []
-  )
-  const bits = await subtle.deriveBits({ name: 'ECDH', public: pub }, privateKey, 256)
-  return subtle.importKey('raw', bits, { name: 'AES-GCM' }, false, ['encrypt', 'decrypt'])
-}
+const subtle = globalThis.crypto.subtle
 
 /**
  * Genera la llave ECDH EFÍMERA del solicitante (una por petición).
@@ -57,17 +40,7 @@ export async function makeEphemeralKey () {
  * @returns {Promise<{epk:string, iv:string, ct:string}>}
  */
 export async function seal ({ ek, payload }) {
-  const eph = await subtle.generateKey({ name: 'ECDH', namedCurve: 'P-256' }, false, ['deriveBits'])
-  const key = await deriveAesKey(eph.privateKey, ek)
-  const iv = globalThis.crypto.getRandomValues(new Uint8Array(12))
-  const pt = new TextEncoder().encode(JSON.stringify(payload))
-  const ct = await subtle.encrypt({ name: 'AES-GCM', iv }, key, pt)
-  const epkJwk = await subtle.exportKey('jwk', eph.publicKey)
-  return {
-    epk: JSON.stringify({ kty: epkJwk.kty, crv: epkJwk.crv, x: epkJwk.x, y: epkJwk.y }),
-    iv: b64(iv),
-    ct: b64(ct)
-  }
+  return wrapForMember({ cek: JSON.stringify(payload), memberEncPub: ek })
 }
 
 /**
@@ -78,7 +51,5 @@ export async function openSealed ({ privateKey, enc }) {
   if (!enc || typeof enc.epk !== 'string' || typeof enc.iv !== 'string' || typeof enc.ct !== 'string') {
     throw new Error('invalid sealed envelope')
   }
-  const key = await deriveAesKey(privateKey, enc.epk)
-  const pt = await subtle.decrypt({ name: 'AES-GCM', iv: fromB64(enc.iv) }, key, fromB64(enc.ct))
-  return JSON.parse(new TextDecoder().decode(pt))
+  return JSON.parse(await openWrap({ wrap: enc, myEncPrivateKey: privateKey }))
 }