@dotrino/identity 0.121.0 → 0.121.2

package/package.json

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

package/vault/remote.js

@@ -109,13 +109,27 @@ async function redeemCode (client, code) {
   return r.instance
 }
 
+/**
+ * ¿LO DICE MI BÓVEDA, DE ESTA SESIÓN? Lo que va a la cuenta lo reciben todas sus bóvedas y
+ * cualquiera que lo vea pasar puede contestar. Un reto o un error solo cuentan firmados con la
+ * maestra de la invitación (`iss`) y con el `sn` de esta sesión (2026-10-18: sin esto, un
+ * `vault.error` de cualquiera tumbaba el alta). Mismo contrato que `fromMyVault` en
+ * `@dotrino/vault/service`.
+ */
+async function fromMyVault (p, qr) {
+  const b = p?.signed
+  if (!p?.vsig || !b || typeof b !== 'object' || !qr?.iss) return false
+  if (b.iss !== qr.iss || b.sn !== qr.sn || b.type !== p.type) return false
+  try { return await verifyDeviceSig({ publickey: qr.iss, data: b, signature: p.vsig }) } catch (_) { return false }
+}
+
 /** «¿Quién eres?» del QR corto: devuelve `{ iss, proxy, acct, m }` de la bóveda. */
 async function askVault (client, qr) {
   const target = await redeemCode(client, qr.conn)
   return new Promise((resolve, reject) => {
     const off = client.on('message', (_from, p) => {
+      // Un error aquí no se puede verificar (aún no se sabe quién es la bóveda): no cuenta.
       if (p?.type === MSG.HELLO_OK) { done(); verifyHello(p, qr.sn).then((b) => resolve({ iss: b.iss, proxy: b.proxy || qr.proxy, acct: b.acct || '', m: b.m || qr.m }), reject) }
-      else if (p?.type === MSG.ERROR) { done(); reject(new Error(p.error)) }
     })
     const t = setTimeout(() => { done(); reject(new Error('the vault did not answer: that code may have expired')) }, 15000)
     const done = () => { off(); clearTimeout(t) }
@@ -179,8 +193,9 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', conti
 
     const enrolled = new Promise((resolve, reject) => {
       let sellando = false
-      const off = client.on('message', (_from, p) => {
+      const off = client.on('message', async (_from, p) => {
         if (!p || typeof p !== 'object') return
+        if ((p.type === MSG.ENROLL_CHALLENGE || p.type === MSG.ERROR) && !await fromMyVault(p, qr)) return
         if (p.type === MSG.ENROLL_CHALLENGE) { try { onChallenge?.({ deviceId, code }) } catch (_) {} }
         // El vault ECHA el código que tipeaste; aceptamos SOLO si coincide con el que generamos.
         // (Un código distinto = un vault que no lo conoce → lo ignoramos y seguimos esperando.)

package/vault/vendor/passmanager/VERSION.txt

@@ -1,3 +1,3 @@
-Copia vendorizada de @dotrino/passmanager@0.18.4 (dotrino-passmanager/lib/src/{crypto,fields,generate,import,index,match,model,pubkey,sealed/convert,sealed/device,sealed/entry,sealed/index,sealed/keys,sealed/recovery,sealed/store,session-cache,totp,transport/protocol,transport/proxy,transport/sealed,vault/approval,vault/errors,vault/guard,vault/interface,vault/local,vault/remote,vault/responder,vault/sealed-local,vault/sealed-responder,vault/sealed,webauthn}.js).
+Copia vendorizada de @dotrino/passmanager@0.18.5 (dotrino-passmanager/lib/src/{crypto,fields,generate,import,index,match,model,pubkey,sealed/convert,sealed/device,sealed/entry,sealed/index,sealed/keys,sealed/recovery,sealed/store,session-cache,totp,transport/protocol,transport/proxy,transport/sealed,vault/approval,vault/errors,vault/guard,vault/interface,vault/local,vault/remote,vault/responder,vault/sealed-local,vault/sealed-responder,vault/sealed,webauthn}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 El sobre de las contraseñas, el mismo que usan el binario y la extensión. Importa @dotrino/identity/content.

package/vault/vendor/passmanager/generate.js

@@ -65,7 +65,7 @@ export function generatePassword ({
 /** Frase de varias palabras, más fácil de dictar o teclear a mano. */
 export function generatePassphrase (words, { count = 4, separator = '-' } = {}) {
   if (!Array.isArray(words) || words.length < 16) {
-    throw new Error('generatePassphrase: hace falta una lista de palabras')
+    throw new Error('generatePassphrase: a word list is required')
   }
   return Array.from({ length: Math.max(2, count) }, () => words[randomBelow(words.length)])
     .join(separator)

package/vault/vendor/passmanager/import.js

@@ -111,7 +111,7 @@ export function fromBitwardenCsv (text) {
 export function fromBitwardenJson (json) {
   const data = typeof json === 'string' ? JSON.parse(json) : json
   if (data?.encrypted) {
-    const e = new Error('el export de Bitwarden está cifrado: expórtalo sin cifrar')
+    const e = new Error('the Bitwarden export is encrypted: export it unencrypted')
     e.code = 'encrypted-export'
     throw e
   }
@@ -136,7 +136,7 @@ export function fromBitwardenJson (json) {
  */
 export function importAuto (text) {
   const t = String(text || '').trim()
-  if (!t) return { format: 'vacío', entries: [] }
+  if (!t) return { format: 'empty', entries: [] }
 
   if (t.startsWith('{')) return { format: 'bitwarden-json', entries: fromBitwardenJson(t) }
 
@@ -150,7 +150,7 @@ export function importAuto (text) {
   if (head.includes('name') && head.includes('url') && head.includes('password')) {
     return { format: 'chrome-csv', entries: fromChromeCsv(t) }
   }
-  const e = new Error('no reconozco el formato del archivo')
+  const e = new Error('unrecognized file format')
   e.code = 'unknown-format'
   throw e
 }

package/vault/vendor/passmanager/totp.js

@@ -13,7 +13,7 @@ export function base32Decode (input) {
   const out = []
   for (const ch of s) {
     const idx = B32.indexOf(ch)
-    if (idx === -1) throw new Error('base32: carácter inválido')
+    if (idx === -1) throw new Error('base32: invalid character')
     value = (value << 5) | idx
     bits += 5
     if (bits >= 8) {
@@ -38,12 +38,12 @@ export function normalizeOtpauth (input, label = 'dotrino') {
 /** Parsea `otpauth://totp/Emisor:cuenta?secret=...&digits=6&period=30&algorithm=SHA1`. */
 export function parseOtpauth (uri) {
   const u = new URL(normalizeOtpauth(uri))
-  if (u.protocol !== 'otpauth:') throw new Error('otpauth: esquema inválido')
+  if (u.protocol !== 'otpauth:') throw new Error('otpauth: invalid scheme')
   const type = u.hostname.toLowerCase()
-  if (type !== 'totp' && type !== 'hotp') throw new Error('otpauth: tipo no soportado')
+  if (type !== 'totp' && type !== 'hotp') throw new Error('otpauth: unsupported type')
   const q = u.searchParams
   const secret = q.get('secret')
-  if (!secret) throw new Error('otpauth: falta secret')
+  if (!secret) throw new Error('otpauth: missing secret')
 
   const label = decodeURIComponent(u.pathname.replace(/^\//, ''))
   const [maybeIssuer, account] = label.includes(':') ? label.split(/:(.+)/) : [null, label]
@@ -74,7 +74,7 @@ const HASHES = { SHA1: 'SHA-1', SHA256: 'SHA-256', SHA512: 'SHA-512' }
 
 async function hotp (secretBytes, counter, digits, algorithm) {
   const hash = HASHES[algorithm]
-  if (!hash) throw new Error('otp: algoritmo no soportado: ' + algorithm)
+  if (!hash) throw new Error('otp: unsupported algorithm: ' + algorithm)
 
   const buf = new ArrayBuffer(8)
   const view = new DataView(buf)

package/vault/vendor/passmanager/transport/proxy.js

@@ -77,7 +77,7 @@ export class ProxyTransport {
         this.pending.delete(rid)
         // No es "no hay nadie": es que nadie contestó. Suele ser el teléfono sin
         // que nadie lo mire, y el código lo distingue para poder decirlo bien.
-        reject(new VaultError(CODES.APPROVAL_TIMEOUT, 'nadie respondió a tiempo'))
+        reject(new VaultError(CODES.APPROVAL_TIMEOUT, 'nobody replied in time'))
       }, this.timeoutMs)
 
       this.pending.set(rid, { resolve, reject, timer })
@@ -94,7 +94,7 @@ export class ProxyTransport {
           // «no tengo la llave del otro lado» y «se cayó la red» se vieran igual desde
           // arriba, y son cosas distintas: una se arregla enlazando, la otra esperando.
           if (e instanceof VaultError) return reject(e)
-          reject(new VaultError(e?.code || CODES.UNREACHABLE, e?.message || 'no se pudo enviar'))
+          reject(new VaultError(e?.code || CODES.UNREACHABLE, e?.message || 'could not send'))
         })
     })
   }
@@ -103,7 +103,7 @@ export class ProxyTransport {
   close (code = CODES.UNREACHABLE) {
     for (const [rid, p] of this.pending) {
       clearTimeout(p.timer)
-      p.reject(new VaultError(code, 'transporte cerrado'))
+      p.reject(new VaultError(code, 'transport closed'))
       this.pending.delete(rid)
     }
   }

package/vault/vendor/passmanager/vault/guard.js

@@ -64,7 +64,7 @@ export class GuardedVault {
 
     if (pedidasPrivadas.length) {
       const ok = await this.gate.allow({ op: 'get', payload: { id, keys: pedidasPrivadas } })
-      if (!ok) throw new VaultError(CODES.NOT_APPROVED, 'no aprobado')
+      if (!ok) throw new VaultError(CODES.NOT_APPROVED, 'not approved')
     }
     return projectEntry(open, keys)
   }

package/vault/vendor/passmanager/vault/local.js

@@ -38,7 +38,7 @@ export class LocalVault {
   }
 
   #requireKey () {
-    if (!this.key) throw new VaultError(CODES.LOCKED, 'la bóveda está cerrada')
+    if (!this.key) throw new VaultError(CODES.LOCKED, 'the vault is locked')
   }
 
   async #all () {
@@ -73,13 +73,13 @@ export class LocalVault {
   async get (id) {
     this.#requireKey()
     const entry = (await this.#all()).find(e => e.id === id)
-    if (!entry) throw new VaultError(CODES.NOT_FOUND, 'no hay ninguna entrada con ese id')
+    if (!entry) throw new VaultError(CODES.NOT_FOUND, 'there is no entry with that id')
     return openEntry(this.key, entry)
   }
 
   async put (plain) {
     this.#requireKey()
-    if (this.readOnly) throw new VaultError(CODES.READ_ONLY, 'esta copia solo puede leer')
+    if (this.readOnly) throw new VaultError(CODES.READ_ONLY, 'this copy is read-only')
     const sealed = await sealEntry(this.key, plain)
     const all = await this.#all()
     const i = all.findIndex(e => e.id === sealed.id)
@@ -122,10 +122,10 @@ export class LocalVault {
    */
   async patch (id, changes = {}) {
     this.#requireKey()
-    if (this.readOnly) throw new VaultError(CODES.READ_ONLY, 'esta copia solo puede leer')
+    if (this.readOnly) throw new VaultError(CODES.READ_ONLY, 'this copy is read-only')
     const all = await this.#all()
     const i = all.findIndex(e => e.id === id)
-    if (i < 0) throw new VaultError(CODES.NOT_FOUND, 'no hay ninguna entrada con ese id')
+    if (i < 0) throw new VaultError(CODES.NOT_FOUND, 'there is no entry with that id')
 
     const base = await openEntry(this.key, all[i])
     // La fusión vive en `model.js` y la comparten esta bóveda y la sellada: no es un
@@ -199,10 +199,10 @@ export class LocalVault {
 
   async remove (id) {
     this.#requireKey()
-    if (this.readOnly) throw new VaultError(CODES.READ_ONLY, 'esta copia solo puede leer')
+    if (this.readOnly) throw new VaultError(CODES.READ_ONLY, 'this copy is read-only')
     const all = await this.#all()
     const rest = all.filter(e => e.id !== id)
-    if (rest.length === all.length) throw new VaultError(CODES.NOT_FOUND, 'no hay ninguna entrada con ese id')
+    if (rest.length === all.length) throw new VaultError(CODES.NOT_FOUND, 'there is no entry with that id')
     await this.store.set(KEY, rest)
   }
 

package/vault/vendor/passmanager/vault/remote.js

@@ -70,7 +70,7 @@ export class RemoteVault {
   }
 
   async list () {
-    throw new VaultError(CODES.NO_KEY, 'una bóveda remota no lista: pide de a una')
+    throw new VaultError(CODES.NO_KEY, 'a remote vault does not list: ask one at a time')
   }
 
   async #request (op, payload) {
@@ -79,7 +79,7 @@ export class RemoteVault {
     } catch (e) {
       // El transporte puede fallar de muchas formas; hacia arriba solo hay códigos.
       if (e instanceof VaultError) throw e
-      throw new VaultError(e?.code || CODES.UNREACHABLE, e?.message || 'no hay bóveda al otro lado')
+      throw new VaultError(e?.code || CODES.UNREACHABLE, e?.message || 'no vault on the other side')
     }
   }
 }

package/vault/vendor/passmanager/vault/responder.js

@@ -124,7 +124,7 @@ export class VaultResponder {
     // 1. ¿Es un aparato que conozco? Si no, ni se le contesta qué falló.
     if (!fromPubkey || !this.isAllowed(fromPubkey)) {
       this.onRequest({ ...record, outcome: 'denied' })
-      return this.#send(fromPubkey, replyError(msg.rid, CODES.DENIED, 'aparato no autorizado'))
+      return this.#send(fromPubkey, replyError(msg.rid, CODES.DENIED, 'device not authorized'))
     }
 
     // 2. `list` no está en la lista, y esa ausencia es el diseño: si un aparato
@@ -132,11 +132,11 @@ export class VaultResponder {
     const esAdmin = ADMIN_OPS.includes(msg.op)
     if (!REMOTE_OPS.includes(msg.op) && !esAdmin) {
       this.onRequest({ ...record, outcome: 'denied' })
-      return this.#send(fromPubkey, replyError(msg.rid, CODES.DENIED, 'operación no permitida en remoto'))
+      return this.#send(fromPubkey, replyError(msg.rid, CODES.DENIED, 'operation not allowed remotely'))
     }
     if (esAdmin && !this.admin) {
       this.onRequest({ ...record, outcome: 'denied' })
-      return this.#send(fromPubkey, replyError(msg.rid, CODES.DENIED, 'esta bóveda no se administra en remoto'))
+      return this.#send(fromPubkey, replyError(msg.rid, CODES.DENIED, 'this vault is not managed remotely'))
     }
 
     try {
@@ -149,7 +149,7 @@ export class VaultResponder {
         const ok = await this.approve({ op: msg.op, payload, pubkey: fromPubkey, admin: true })
         if (!ok) {
           this.onRequest({ ...record, outcome: 'refused' })
-          return this.#send(fromPubkey, replyError(msg.rid, CODES.NOT_APPROVED, 'no aprobado'))
+          return this.#send(fromPubkey, replyError(msg.rid, CODES.NOT_APPROVED, 'not approved'))
         }
         const result = msg.op === 'devices'
           ? await this.admin.devices()
@@ -162,7 +162,7 @@ export class VaultResponder {
         const ok = await this.gate.allow({ op: msg.op, payload, pubkey: fromPubkey })
         if (!ok) {
           this.onRequest({ ...record, outcome: 'refused' })
-          return this.#send(fromPubkey, replyError(msg.rid, CODES.NOT_APPROVED, 'no aprobado'))
+          return this.#send(fromPubkey, replyError(msg.rid, CODES.NOT_APPROVED, 'not approved'))
         }
       }
 

package/vault/vendor/passmanager/vault/sealed-local.js

@@ -144,10 +144,10 @@ export class SealedLocalVault {
     let got
     try { got = await this.sealed.get(id, { pub: this.readerPub, keys }) }
     catch (e) {
-      if (e?.code === 'not-found') throw new VaultError(CODES.NOT_FOUND, 'no hay ninguna entrada con ese id')
+      if (e?.code === 'not-found') throw new VaultError(CODES.NOT_FOUND, 'there is no entry with that id')
       // «no me la envolvieron a mí» no es «no existe», y confundirlas manda a buscar el
       // problema al sitio equivocado.
-      if (e?.code === 'not-yours') throw new VaultError(CODES.NOT_ALLOWED, 'esta punta no tiene llave para esa entrada')
+      if (e?.code === 'not-yours') throw new VaultError(CODES.NOT_ALLOWED, 'this end has no key for that entry')
       throw e
     }
     return openSealedEntry({ got, openSealed: this.openSealed })

package/vault/vendor/passmanager/vault/sealed.js

@@ -64,12 +64,12 @@ export class SealedVault {
   forget () { this._keys = null; this._recipients = null }
 
   async #request (op, payload) {
-    if (!SEALED_OPS.includes(op)) throw new VaultError(CODES.NOT_ALLOWED, 'operación desconocida: ' + op)
+    if (!SEALED_OPS.includes(op)) throw new VaultError(CODES.NOT_ALLOWED, 'unknown operation: ' + op)
     try {
       return await this.transport.request(op, payload)
     } catch (e) {
       if (e instanceof VaultError) throw e
-      throw new VaultError(e?.code || CODES.UNREACHABLE, e?.message || 'no hay bóveda al otro lado')
+      throw new VaultError(e?.code || CODES.UNREACHABLE, e?.message || 'no vault on the other side')
     }
   }
 
@@ -194,7 +194,7 @@ export class SealedVault {
   async patch (id, changes = {}) {
     const [keys, recipients] = await Promise.all([this.keys(), this.recipients()])
     const actual = await this.#viewById(id)
-    if (!actual) throw new VaultError(CODES.NOT_FOUND, 'no hay ninguna entrada con ese id')
+    if (!actual) throw new VaultError(CODES.NOT_FOUND, 'there is no entry with that id')
 
     const values = {}
     const drop = []

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

@@ -1,4 +1,4 @@
-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).
+Copia vendorizada de @dotrino/proxy-client@0.38.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

@@ -270,9 +270,9 @@ export class WebSocketProxyClient {
 
   /** Corta en seco todo lo que esperaba respuesta, con su motivo. */
   _rejectAllPending (error) {
-    const pendientes = [...this._pending.values()]
+    const pending = [...this._pending.values()]
     this._pending.clear()
-    for (const entry of pendientes) {
+    for (const entry of pending) {
       clearTimeout(entry.timer)
       entry.reject(error)
     }
@@ -432,7 +432,11 @@ export class WebSocketProxyClient {
   async list (channelName) {
     const channel = await buildSignedChannel(channelName)
     const res = await this._request({ type: 'list', channel }, 'channel_list', 'channel')
-    return res.tokens || []
+    const tokens = res.tokens || []
+    // Vacío pero con una bóveda despertándose detrás (websocket-proxy ≥ 1.7.0): quien lista
+    // puede esperar unos segundos en vez de concluir que no hay nadie.
+    if (res.waking) tokens.waking = true
+    return tokens
   }
 
   /** Alias for list() to ease migration from older clients. */
@@ -533,8 +537,8 @@ export class WebSocketProxyClient {
     // Y SE RESUELVEN TODAS ANTES DE MANDAR NADA. Enviar a los que se pudo y fallar por el
     // resto deja a la app creyendo que el mensaje salió, con la mitad de la sala sin él y
     // 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) {
+    const keys = await Promise.all(list.map(async (pk) => [pk, await this.encPubOf(pk)]))
+    for (const [pk, encPub] of keys) {
       const sealPiece = await this._sealerFor(m.bin, encPub, pk)
       for (const piece of pieces) this._sendByPubkeyRaw([pk], await sealPiece(piece), opts)
     }
@@ -582,10 +586,10 @@ export class WebSocketProxyClient {
     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 }
+      const envelope = await sealPiece(m.bin ? m.whole : payload)
+      if (tokens.length === 1 && peerPubkey) { this._sendToTokenOrQueue(tokens[0], envelope, peerPubkey); return }
       // Por `send`, no por `_sendRaw`: así sigue prefiriendo el canal directo si lo hay.
-      this.send(tokens, sobre)
+      this.send(tokens, envelope)
       return
     }
     // Por el proxio en vivo hay tope (parts.js): lo que pasa de él solo sale por canal
@@ -601,9 +605,9 @@ export class WebSocketProxyClient {
     // 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)
+      const envelope = await sealPiece(piece)
+      if (tokens.length === 1 && peerPubkey) await this._sendPiece(tokens[0], envelope, peerPubkey, queueFallback, relayFallback)
+      else this.send(tokens, envelope)
     }
   }
 
@@ -632,13 +636,13 @@ export class WebSocketProxyClient {
    * 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
+  async _sendPiece (token, envelope, peerPubkey, queueFallback, relayFallback = true) {
+    if (this._rtc && await this._rtc.sendDirect(token, this._wire(envelope))) return
     if (!relayFallback) {
       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 })
+    if (envelope instanceof Uint8Array) this._needBinaryProxy()
+    this._sendToTokenOrQueue(token, envelope, peerPubkey, { queueFallback, skipDirect: true })
     await new Promise((r) => setTimeout(r, 20))
   }
 
@@ -674,16 +678,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, { queueFallback = true, skipDirect = false } = {}) {
-    if (this.requireSealed && !this._isSealed(sobre)) {
+  _sendToTokenOrQueue (token, envelope, peerPubkey, { queueFallback = true, skipDirect = false } = {}) {
+    if (this.requireSealed && !this._isSealed(envelope)) {
       throw errorWithCode('requireSealed: refusing to send a directed message in the clear — use sendSealedTo()', 'unsealed')
     }
-    const messageStr = this._wire(sobre)
+    const messageStr = this._wire(envelope)
     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, queueFallback })
+    this._tokenWatch.set(id, { token, envelope, peerPubkey, timer, queueFallback })
     try {
       this._sendRaw({ to: [token], message: messageStr, id })
     } catch (e) {
@@ -707,7 +711,7 @@ export class WebSocketProxyClient {
       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 }) }
+    try { this._sendByPubkeyRaw([w.peerPubkey], w.envelope) } catch (e) { this._emit('error', { type: 'client', error: e.message, code: e.code || null }) }
   }
 
   // ---------- el saludo: de quién es este token ----------
@@ -896,16 +900,16 @@ export class WebSocketProxyClient {
     if (typeof publickey !== 'string' || !publickey) {
       throw errorWithCode('encPubOf: missing publickey', 'encpub-shape')
     }
-    const cacheada = this._encPubs.get(publickey)
-    if (cacheada) return cacheada
+    const cached = this._encPubs.get(publickey)
+    if (cached) return cached
     // Una pregunta en vuelo por llave: una sala de ocho manda ocho mensajes a la vez y
     // preguntaría ocho veces por lo mismo.
-    const enVuelo = this._encPubInflight.get(publickey)
-    if (enVuelo) return enVuelo
-    const promesa = this._lookupEncPub(publickey)
+    const inflight = this._encPubInflight.get(publickey)
+    if (inflight) return inflight
+    const promise = this._lookupEncPub(publickey)
       .finally(() => this._encPubInflight.delete(publickey))
-    this._encPubInflight.set(publickey, promesa)
-    return promesa
+    this._encPubInflight.set(publickey, promise)
+    return promise
   }
 
   async _lookupEncPub (publickey) {
@@ -913,13 +917,13 @@ export class WebSocketProxyClient {
     // ya la tiene en la mano y firmada por el master: preguntársela a un servidor sería
     // dar la vuelta para llegar a lo que ya está aquí.
     if (this.encPubResolver) {
-      const propia = await this.encPubResolver(publickey)
-      if (propia) {
-        if (!isEncPub(propia)) {
+      const own = await this.encPubResolver(publickey)
+      if (own) {
+        if (!isEncPub(own)) {
           throw errorWithCode('encPubResolver returned something that is not a P-256 public JWK', 'encpub-unverified')
         }
-        this._encPubs.set(publickey, propia)
-        return propia
+        this._encPubs.set(publickey, own)
+        return own
       }
     }
     // SI EL PROXIO DICE QUE NO SABE DE ESTO, se dice con su propio código en vez de
@@ -927,7 +931,7 @@ export class WebSocketProxyClient {
     // que esto existiera y no se sabe: se pregunta igual, y contesta la pregunta.
     if (Array.isArray(this.caps) && !this.caps.includes('encpub')) {
       throw errorWithCode(
-        `este proxio (${this.url}) no sirve llaves de cifrado: hace falta websocket-proxy >= 1.1.0`,
+        `this proxy (${this.url}) does not serve encryption keys: it needs websocket-proxy >= 1.1.0`,
         'no-encpub-support')
     }
     const res = await this._request({ type: 'enc-lookup', publickeys: [publickey] }, 'enc-lookup')
@@ -1145,8 +1149,8 @@ export class WebSocketProxyClient {
     // conexión, y por eso este sobre no necesita otro. Lo que le faltaba era decir a quién
     // se lo estamos dando.
     const data = { op: 'identify', aud: this.audience, publickey, token: this.token, ts: Date.now() }
-    const firmado = await sign(data)
-    const signature = typeof firmado === 'string' ? firmado : firmado?.signature
+    const signed = await sign(data)
+    const signature = typeof signed === 'string' ? signed : signed?.signature
     // «No pude firmar» y «se cayó la red» son cosas distintas, y se distinguen por el
     // `code`: la bóveda usa esto para saber si su llave de comunicación firma todavía, y
     // tragarse un fallo de red como si fuera lo primero la mandaría al camino equivocado.
@@ -1229,7 +1233,7 @@ export class WebSocketProxyClient {
    * @returns {Promise<boolean>} true si TURN quedó activo.
    */
   async enableTurn ({ publicKey, sign } = {}) {
-    if (!this._rtc) throw new Error('WebRTC está deshabilitado en este cliente')
+    if (!this._rtc) throw new Error('WebRTC is disabled in this client')
     if (this._turnTimer) {
       clearTimeout(this._turnTimer)
       this._turnTimer = null
@@ -1316,17 +1320,17 @@ export class WebSocketProxyClient {
    */
   async enablePush ({ publicKey, sign, vapidPublicKey, registration, swPath, swScope } = {}) {
     if (typeof navigator === 'undefined' || !('serviceWorker' in navigator)) {
-      throw new Error('Service Worker no soportado en este entorno')
+      throw new Error('Service Worker is not supported in this environment')
     }
     if (typeof PushManager === 'undefined') {
-      throw new Error('Push API no soportada en este navegador')
+      throw new Error('the Push API is not supported in this browser')
     }
     if (!publicKey || typeof sign !== 'function') {
       throw new Error('enablePush requires { publicKey, sign }')
     }
     if (!vapidPublicKey) {
       const cfg = await this.getPushConfig()
-      if (!cfg.enabled || !cfg.vapidPublicKey) throw new Error('El proxy no tiene Web Push habilitado')
+      if (!cfg.enabled || !cfg.vapidPublicKey) throw new Error('the proxy does not have Web Push enabled')
       vapidPublicKey = cfg.vapidPublicKey
     }
     let reg
@@ -1367,6 +1371,29 @@ export class WebSocketProxyClient {
     return { kind, token }
   }
 
+  /**
+   * DESPIÉRTAME AQUÍ: el timbre de una bóveda que no vive conectada (la de una Lambda). Si
+   * llega algo para la PERSONA de este acta y no hay nadie suyo conectado, el proxio guarda el
+   * mensaje en la cola de siempre y hace un POST a `url`; la bóveda arranca, se identifica y
+   * recibe lo encolado.
+   *
+   * Lo firma la llave que habla por la bóveda (su llave de comunicación), no la maestra, y el
+   * `acta` es lo que prueba que esa llave es de la cuenta: el timbre se guarda para la cuenta
+   * (`profileId`), que es a quien le escriben los servicios.
+   *
+   * `channel` (opcional): el canal donde la buscan quienes no saben su llave —quien entra con
+   * usuario y contraseña—. Listarlo vacío también la despierta (`list()` devuelve `waking`).
+   *
+   * @param {{ publicKey:string, sign:Function, url:string, acta:object, channel?:string }} opts
+   */
+  async registerWake ({ publicKey, sign, url, acta, channel } = {}) {
+    if (!publicKey || typeof sign !== 'function' || !url || !acta) throw errorWithCode('registerWake requires { publicKey, sign, url, acta }', 'bad-args')
+    const data = { op: 'push-subscribe', publickey: publicKey, subscription: JSON.stringify({ kind: 'wake', url, ...(channel ? { channel } : {}) }), ts: Date.now() }
+    const signature = await normalizeSignature(sign, data)
+    const r = await this._request({ type: 'push-subscribe', data, signature, acta }, 'push-subscribed')
+    return { kind: 'wake', url, profile: r?.publickey || null }
+  }
+
   /**
    * Desactivar Web Push: cancela la PushSubscription local y la borra del proxy.
    * @param {Object} opts
@@ -1540,8 +1567,8 @@ export class WebSocketProxyClient {
       // `_reconnectAttempts` vuelve a 0 al abrir, así que esto NO convierte un `connect()`
       // inicial fallido en un bucle de fondo: ahí vale 0 y la promesa se rechaza como
       // siempre.
-      const reintentando = this._reconnectAttempts > 0
-      if ((wasConnected || reintentando) && this.autoReconnect) {
+      const retrying = this._reconnectAttempts > 0
+      if ((wasConnected || retrying) && this.autoReconnect) {
         this._scheduleReconnect()
       }
     })
@@ -1776,14 +1803,14 @@ export class WebSocketProxyClient {
       this._countOut(frame, bytes)
       return
     }
-    const texto = JSON.stringify(frame)
-    this.ws.send(texto)
-    this._countOut(frame, texto)
+    const text = JSON.stringify(frame)
+    this.ws.send(text)
+    this._countOut(frame, text)
   }
 
   /** Cuenta un frame que sale por el proxio, y a quién iba. */
-  _countOut (frame, texto) {
-    this._traffic.frame('out', utf8Length(texto))
+  _countOut (frame, text) {
+    this._traffic.frame('out', utf8Length(text))
     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 : []) {
@@ -1897,7 +1924,7 @@ export class WebSocketProxyClient {
 async function normalizeSignature (sign, data) {
   const out = await sign(data)
   const sig = typeof out === 'string' ? out : (out && out.signature)
-  if (!sig) throw new Error('sign() debe devolver una firma base64 (string o {signature})')
+  if (!sig) throw new Error('sign() must return a base64 signature (a string or {signature})')
   return sig
 }
 

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

@@ -67,8 +67,8 @@ export async function buildEncPubStatement ({ publickey, encPub, sign } = /** @t
   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
+  const signed = await sign(data)
+  const signature = typeof signed === 'string' ? signed : signed?.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 errorWithCode('buildEncPubStatement: sign() returned no signature', 'no-signature')