@dotrino/identity 0.120.0 → 0.121.1

package/package.json

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

package/vault/originPolicy.js

@@ -0,0 +1,65 @@
+/**
+ * QUIÉN PUEDE PEDIR QUÉ al iframe de identidad, por el origen que pone el navegador.
+ *
+ * El iframe habla con todo el ecosistema (`*.dotrino.com`, el espejo de GitHub y, en desarrollo,
+ * localhost y la red local). Eso está bien para firmar, cifrar o leer el perfil: es para lo que
+ * está. Pero hay pedidos que deciden QUIÉN ES de tu cuenta o se llevan la llave, y esos no los
+ * puede hacer cualquier página que se cargue en esos orígenes. Regla del dueño (2026-10-18):
+ * **ningún aparato entra a una cuenta sin invitación**, y una app cualquiera llamando a
+ * `admitMember` es justo eso.
+ *
+ * Esos pedidos solo los atiende la CONSOLA: `vault.dotrino.com` y `profile.dotrino.com`. Los
+ * orígenes locales valen únicamente si el propio iframe corre en local (desarrollo y pruebas):
+ * en producción, una página de localhost de tu máquina no administra tu cuenta.
+ */
+const LOCAL = /^https?:\/\/(localhost|127\.0\.0\.1|192\.168\.\d{1,3}\.\d{1,3}|10\.\d{1,3}\.\d{1,3}\.\d{1,3}|172\.(1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3})(:\d+)?$/
+const CONSOLE = /^https:\/\/(vault|profile)\.dotrino\.com$/
+
+/**
+ * Lo que solo pide la consola: entrar y salir del acta, cambiar permisos, la llave en crudo,
+ * borrar un perfil, la bóveda de esta pestaña (sus emparejamientos, sus altas con contraseña,
+ * sus respaldos) y la contraseña del perfil.
+ */
+export const CONSOLE_ONLY = Object.freeze([
+  'admitMember', 'removeMember', 'setCaps', 'setCapsMany', 'setLabel', 'setMemberEncPub', 'handoverMaster',
+  'renounceCaps', 'absorbRenounce', 'adoptActa', 'adoptActaChain', 'joinProfile', 'rotateSealKey', 'setSealKeyProvider',
+  'revokeDevice', 'vaultPair', 'vaultAdopt', 'vaultUnpair', 'prepareForAdoption', 'setSelfVault',
+  'exportIdentity', 'importIdentity', 'deleteProfile', 'setProfilePassword', 'removeProfilePassword',
+  'selfVaultPairing', 'selfVaultApprove', 'selfVaultLoginAdd',
+  'selfVaultBackupDrawers', 'selfVaultBackupExport', 'selfVaultBackupPlan', 'selfVaultBackupImport'
+])
+
+/** Además de la consola, quién más puede pedir uno de esos (su herramienta lo necesita). */
+const ALSO = Object.freeze({
+  // El gestor de contraseñas vuelve a envolver sus llaves para los aparatos que entran.
+  rewrapFor: /^https:\/\/pass\.dotrino\.com$/
+})
+
+export function originPolicy ({ selfOrigin }) {
+  const selfIsLocal = LOCAL.test(String(selfOrigin || ''))
+  const isConsole = (origin) => CONSOLE.test(String(origin || '')) || (selfIsLocal && LOCAL.test(String(origin || '')))
+  const only = new Set(CONSOLE_ONLY)
+
+  /**
+   * Lanza `console-only` si `origin` no puede pedir `method` con estos parámetros. Lo demás pasa.
+   * `me` es la llave pública del perfil activo (para el certificado de uno mismo).
+   */
+  function check (method, params, origin, { me = null } = {}) {
+    if (isConsole(origin)) return
+    const deny = (why) => { throw Object.assign(new Error(`${method}: ${why}`), { code: 'console-only' }) }
+    if (only.has(method)) deny('only the vault console (vault.dotrino.com, profile.dotrino.com) can ask for this')
+    if (ALSO[method] && !ALSO[method].test(String(origin || ''))) deny('this origin cannot ask for this')
+    if (method === 'signDelegation') {
+      // Un certificado con poder sobre la bóveda (`vault:*`) es meter un aparato: eso es de la
+      // consola, con su invitación. Una app sí firma lo suyo (geo: los aparatos de here) y su
+      // propio certificado (`sub` = el perfil: el de terminal y el de ia).
+      const scopes = Array.isArray(params?.scope) ? params.scope : [params?.scope]
+      const vaultPower = scopes.some((s) => typeof s !== 'string' || s.startsWith('vault:'))
+      if (vaultPower && !(me && params?.sub === me)) deny('a certificate with vault powers is issued from the vault console, with an invitation')
+    }
+  }
+
+  return { check, isConsole }
+}
+
+export default { originPolicy, CONSOLE_ONLY }

package/vault/vault.js

@@ -14,6 +14,7 @@ import {
 } from './peerStore.js'
 import { createIdentityCore } from './core.js'
 import { keyLabel } from './capabilities.js'
+import { originPolicy } from './originPolicy.js'
 import { withExternalKeys, appBridge } from './externalKeys.js'
 import { nativeBackends } from './nativeStore.js'
 import { useBackend as usePeerBackend } from './peerStore.js'
@@ -151,6 +152,7 @@ import { useBackend as usePeerBackend } from './peerStore.js'
   })
 
   const { handlers } = core
+  const policy = originPolicy({ selfOrigin: window.location.origin })
 
   // ---- Control de ORIGEN (crítico): la identidad solo habla con el ecosistema. ----
   // Sin esto, CUALQUIER web podía embeber este iframe y llamar `exportIdentity`
@@ -537,6 +539,9 @@ import { useBackend as usePeerBackend } from './peerStore.js'
     const handler = selfHandlers[method] || handlers[method]
     if (!handler) return reply({ error: `Unknown method: ${method}` })
     try {
+      // LO QUE DECIDE QUIÉN ES DE LA CUENTA solo lo pide la consola (`originPolicy.js`): una app
+      // del ecosistema firma y cifra, pero no mete aparatos ni se lleva la llave.
+      policy.check(method, params, event.origin, { me: (await handlers.getMe().catch(() => null))?.publickey || null })
       // EL ORIGEN LO PONE EL IFRAME, no quien llama: va pisado a propósito. Es el único
       // dato que la aplicación no puede falsificar —el navegador lo garantiza— y de él
       // depende a quién se le concedió qué.

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')

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

@@ -37,7 +37,7 @@ export function utf8Length (s) {
 
 export const PATHS = ['proxy', 'direct', 'turn', 'webrtc']
 
-const ceros = () => ({ proxy: 0, direct: 0, turn: 0, webrtc: 0 })
+const zeros = () => ({ proxy: 0, direct: 0, turn: 0, webrtc: 0 })
 
 export class TrafficStats {
   constructor () {
@@ -64,7 +64,7 @@ export class TrafficStats {
     if (!key) return
     let p = this.peers.get(key)
     if (!p) {
-      p = { token: who.token || null, pubkey: who.pubkey || null, bytesIn: ceros(), bytesOut: ceros(), msgsIn: 0, msgsOut: 0, firstAt: Date.now(), lastAt: 0 }
+      p = { token: who.token || null, pubkey: who.pubkey || null, bytesIn: zeros(), bytesOut: zeros(), msgsIn: 0, msgsOut: 0, firstAt: Date.now(), lastAt: 0 }
       this.peers.set(key, p)
     }
     if (who.pubkey && !p.pubkey) p.pubkey = who.pubkey
@@ -104,8 +104,8 @@ export async function routeOf (pc) {
   const local = byId.get(pair.localCandidateId)
   const remote = byId.get(pair.remoteCandidateId)
   if (!local && !remote) return null
-  const tipo = (c) => c && (c.candidateType || c.type)
-  return tipo(local) === 'relay' || tipo(remote) === 'relay' ? 'turn' : 'direct'
+  const typeOf = (c) => c && (c.candidateType || c.type)
+  return typeOf(local) === 'relay' || typeOf(remote) === 'relay' ? 'turn' : 'direct'
 }
 
 /**
@@ -121,7 +121,7 @@ function registry () {
   return globalThis[REGISTRY]
 }
 
-function avisar () {
+function notify () {
   if (typeof globalThis.dispatchEvent === 'function' && typeof Event === 'function') {
     try { globalThis.dispatchEvent(new Event('dotrino-transports')) } catch (_) {}
   }
@@ -131,11 +131,11 @@ export function registerTransport (client) {
   const r = registry()
   if (r.has(client)) return
   r.add(client)
-  avisar()
+  notify()
 }
 
 export function unregisterTransport (client) {
-  if (registry().delete(client)) avisar()
+  if (registry().delete(client)) notify()
 }
 
 /** Los clientes registrados en esta página (o proceso). */

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

@@ -48,13 +48,13 @@ const RTC_TAG = '__cc_rtc__'
  * es el escalón 4, que siempre funciona.
  */
 let _PC = null
-let _PCBuscado = false
+let _PCLookedUp = false
 
-export function setPeerConnection (impl) { _PC = impl; _PCBuscado = true }
+export function setPeerConnection (impl) { _PC = impl; _PCLookedUp = true }
 
 export function resolvePeerConnection () {
-  if (_PCBuscado) return _PC
-  _PCBuscado = true
+  if (_PCLookedUp) return _PC
+  _PCLookedUp = true
   if (typeof globalThis.RTCPeerConnection === 'function') { _PC = globalThis.RTCPeerConnection; return _PC }
   return _PC
 }
@@ -64,15 +64,15 @@ export function resolvePeerConnection () {
  * llama una vez al arrancar, no en medio de una negociación.
  */
 export async function loadNodePeerConnection () {
-  if (_PCBuscado && _PC) return _PC
-  if (typeof globalThis.RTCPeerConnection === 'function') { _PC = globalThis.RTCPeerConnection; _PCBuscado = true; return _PC }
-  for (const nombre of ['@dotrino/webrtc', 'werift']) {
+  if (_PCLookedUp && _PC) return _PC
+  if (typeof globalThis.RTCPeerConnection === 'function') { _PC = globalThis.RTCPeerConnection; _PCLookedUp = true; return _PC }
+  for (const name of ['@dotrino/webrtc', 'werift']) {
     try {
-      const w = await import(nombre)
-      if (typeof w?.RTCPeerConnection === 'function') { _PC = w.RTCPeerConnection; _PCBuscado = true; return _PC }
+      const w = await import(name)
+      if (typeof w?.RTCPeerConnection === 'function') { _PC = w.RTCPeerConnection; _PCLookedUp = true; return _PC }
     } catch (_) { /* no está: se prueba el siguiente, y si no, el proxio (escalón 4) */ }
   }
-  _PCBuscado = true
+  _PCLookedUp = true
   return _PC
 }
 

package/vault/vendor/roadmap/VERSION.txt

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

@@ -80,10 +80,10 @@ export function meets (m, { product, peer, version }) {
   if (!productOf(m, product)) {
     return { ok: false, reason: `the registry does not know "${product}"` }
   }
-  const rango = requirementFor(m, product, peer)
-  if (rango == null) return { ok: true, reason: '' }
-  if (satisfies(version, rango)) return { ok: true, reason: '' }
-  return { ok: false, reason: `${product} needs ${peer} ${rango} and this one is ${version}` }
+  const range = requirementFor(m, product, peer)
+  if (range == null) return { ok: true, reason: '' }
+  if (satisfies(version, range)) return { ok: true, reason: '' }
+  return { ok: false, reason: `${product} needs ${peer} ${range} and this one is ${version}` }
 }
 
 /** La lista de rotas del registro, lista para pasarla a `check` de `@dotrino/compat`. */

package/vault/vendor/roadmap/manifests.js

@@ -8,7 +8,7 @@
 export const MANIFESTS = Object.freeze({
   "dotrino": {
     "manifest": "dotrino",
-    "seq": 30,
+    "seq": 31,
     "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": {
@@ -22,16 +22,16 @@ export const MANIFESTS = Object.freeze({
       "env": {
         "repo": "imdotrino/dotrino-vault",
         "npm": "@dotrino/env",
-        "current": "0.90.1",
+        "current": "0.91.1",
         "protocol": 1,
         "requires": {
-          "vault": ">=0.90.1"
+          "vault": ">=0.91.1"
         }
       },
       "identity": {
         "repo": "imdotrino/dotrino-identity",
         "npm": "@dotrino/identity",
-        "current": "0.119.0",
+        "current": "0.120.0",
         "protocol": 1,
         "requires": {
           "proxy-client": ">=0.13.1"
@@ -40,7 +40,7 @@ export const MANIFESTS = Object.freeze({
       "lobby": {
         "repo": "imdotrino/dotrino-lobby",
         "npm": "@dotrino/lobby",
-        "current": "0.10.2",
+        "current": "0.10.4",
         "protocol": 2,
         "requires": {
           "proxy-client": ">=0.22.0",
@@ -85,7 +85,7 @@ export const MANIFESTS = Object.freeze({
       "notifications": {
         "repo": "imdotrino/dotrino-notifications",
         "npm": "@dotrino/notifications",
-        "current": "0.6.0",
+        "current": "0.7.1",
         "protocol": 2,
         "requires": {
           "proxy-client": ">=0.20.0"
@@ -101,7 +101,7 @@ export const MANIFESTS = Object.freeze({
       "profile": {
         "repo": "imdotrino/dotrino-profile",
         "npm": "@dotrino/profile",
-        "current": "0.20.1",
+        "current": "0.20.2",
         "protocol": 1,
         "requires": {
           "identity": ">=0.33.0"
@@ -109,7 +109,7 @@ export const MANIFESTS = Object.freeze({
       },
       "proxy": {
         "repo": "imdotrino/dotrino-proxy",
-        "current": "1.6.4",
+        "current": "1.7.0",
         "protocol": 2,
         "requires": {
           "vault": ">=0.87.0",
@@ -121,7 +121,7 @@ export const MANIFESTS = Object.freeze({
       "proxy-client": {
         "repo": "imdotrino/dotrino-proxy-client",
         "npm": "@dotrino/proxy-client",
-        "current": "0.36.1",
+        "current": "0.38.2",
         "protocol": 2,
         "requires": {
           "identity": ">=0.53.0",
@@ -131,10 +131,10 @@ export const MANIFESTS = Object.freeze({
       "remote-agent": {
         "repo": "imdotrino/dotrino-remote-agent",
         "npm": "@dotrino/remote-agent",
-        "current": "0.20.1",
+        "current": "0.22.1",
         "protocol": 1,
         "requires": {
-          "identity": ">=0.117.2",
+          "identity": ">=0.120.0",
           "vault": ">=0.85.0",
           "proxy-client": ">=0.36.1",
           "vaultd": ">=0.154.0"
@@ -163,7 +163,7 @@ export const MANIFESTS = Object.freeze({
       },
       "terminal-android": {
         "repo": "imdotrino/dotrino-terminal",
-        "current": "0.13.2",
+        "current": "0.13.4",
         "protocol": 1,
         "requires": {
           "terminal-agent": ">=0.37.0"
@@ -193,11 +193,11 @@ export const MANIFESTS = Object.freeze({
       "content": {
         "repo": "imdotrino/dotrino-content",
         "npm": "@dotrino/content",
-        "current": "0.6.0",
+        "current": "0.6.6",
         "protocol": 1,
         "requires": {
-          "remote-agent": ">=0.20.1",
-          "identity": ">=0.117.2",
+          "remote-agent": ">=0.22.0",
+          "identity": ">=0.120.0",
           "vault": ">=0.87.0",
           "proxy-client": ">=0.36.1"
         }
@@ -205,7 +205,7 @@ export const MANIFESTS = Object.freeze({
       "sealers": {
         "repo": "imdotrino/dotrino-sealers",
         "npm": "@dotrino/sealers",
-        "current": "0.10.0",
+        "current": "0.10.1",
         "protocol": 1,
         "requires": {
           "remote-agent": ">=0.20.1",
@@ -217,7 +217,7 @@ export const MANIFESTS = Object.freeze({
       "roadmap": {
         "repo": "imdotrino/dotrino-roadmap",
         "npm": "@dotrino/roadmap",
-        "current": "0.4.30",
+        "current": "0.4.32",
         "protocol": 1,
         "requires": {
           "compat": "0.4.0+"
@@ -226,7 +226,7 @@ export const MANIFESTS = Object.freeze({
       "store": {
         "repo": "imdotrino/dotrino-store",
         "npm": "@dotrino/store",
-        "current": "0.12.3",
+        "current": "0.12.4",
         "protocol": 1,
         "requires": {
           "identity": ">=0.91.0",
@@ -243,7 +243,7 @@ export const MANIFESTS = Object.freeze({
       "topbar": {
         "repo": "imdotrino/dotrino-topbar",
         "npm": "@dotrino/topbar",
-        "current": "0.16.1",
+        "current": "0.16.2",
         "protocol": 1,
         "requires": {
           "identity": ">=0.96.1",
@@ -253,11 +253,11 @@ export const MANIFESTS = Object.freeze({
       "vault": {
         "repo": "imdotrino/dotrino-vault",
         "npm": "@dotrino/vault",
-        "current": "0.90.1",
+        "current": "0.91.1",
         "protocol": 1,
         "requires": {
           "vaultd": ">=0.105.0",
-          "proxy-client": ">=0.36.1",
+          "proxy-client": ">=0.38.0",
           "identity": ">=0.118.0",
           "opaque": ">=0.1.0",
           "compat": ">=0.4.0",
@@ -269,11 +269,11 @@ export const MANIFESTS = Object.freeze({
       "vaultd": {
         "repo": "imdotrino/dotrino-vault",
         "npm": "@dotrino/vaultd",
-        "current": "0.162.1",
+        "current": "0.163.4",
         "protocol": 1,
         "requires": {
           "identity": ">=0.118.0",
-          "proxy-client": ">=0.36.1",
+          "proxy-client": ">=0.38.0",
           "store": ">=0.11.0",
           "passmanager": ">=0.18.4",
           "compat": ">=0.4.0",
@@ -284,7 +284,7 @@ export const MANIFESTS = Object.freeze({
       "verifier": {
         "repo": "imdotrino/dotrino-verifier",
         "npm": "@dotrino/verifier",
-        "current": "0.3.0",
+        "current": "0.3.1",
         "protocol": 1,
         "requires": {
           "identity": "0.87.0+"
@@ -293,7 +293,7 @@ export const MANIFESTS = Object.freeze({
       "passmanager": {
         "repo": "imdotrino/dotrino-passmanager",
         "npm": "@dotrino/passmanager",
-        "current": "0.18.4",
+        "current": "0.18.5",
         "protocol": 1,
         "requires": {
           "identity": ">=0.117.2",
@@ -340,6 +340,16 @@ export const MANIFESTS = Object.freeze({
           "identity": ">=0.110.1"
         }
       },
+      "app-ios": {
+        "repo": "imdotrino/dotrino-app",
+        "current": "0.4.13",
+        "protocol": 1,
+        "requires": {
+          "proxy": "1.4.7+",
+          "vaultd": ">=0.114.0",
+          "identity": ">=0.110.1"
+        }
+      },
       "social-bot": {
         "repo": "imdotrino/dotrino-social-bot",
         "current": "0.3.0",
@@ -845,6 +855,17 @@ export const MANIFESTS = Object.freeze({
         ],
         "why": "la bóveda recordaba el sí de aprobación por aparato: después de aprobar un borrado, o de leer una contraseña, ese aparato podía borrar o pisar una passkey sin que se pidiera nada ni le llegara aviso a nadie",
         "fix": "sube a @dotrino/vaultd 0.160.2"
+      },
+      {
+        "product": "content",
+        "versions": [
+          "0.6.1",
+          "0.6.2",
+          "0.6.3",
+          "0.6.4"
+        ],
+        "why": "el paquete no traía lib/cid.js, que lib/public.js importa: el node no arranca (ERR_MODULE_NOT_FOUND)",
+        "fix": "sube a @dotrino/content 0.6.6"
       }
     ]
   }

package/vault/vendor/vault/VERSION.txt

@@ -1,4 +1,4 @@
-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).
+Copia vendorizada de @dotrino/vault@0.91.1 (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.2'
+export const LIB_VERSION = '0.91.1'

package/vault/vendor/vault/core/secretsStore.js

@@ -525,14 +525,14 @@ export function openSecretsStore (disk, { sealer = null, recipients = null, sign
       const [kind, k] = splitOwner(owner)
       const bag = kind === 'ns' ? data.ns : data.dev
       const g = (bag[k]?.keyring || []).find((x) => x.gen === gen)
-      if (!g) throw new Error(`putWrap: no existe la generación ${gen} de ${owner}`)
+      if (!g) throw new Error(`putWrap: generation ${gen} of ${owner} does not exist`)
       if (!wrap?.epk || !wrap?.iv || !wrap?.ct) throw new Error('putWrap: envoltura mal formada')
       // SOLO AÑADE, NUNCA PISA. Quien re-envuelve es un servicio, y un servicio no
       // administra: si pudiera reemplazar una envoltura existente podría dejar sin leer
       // a otro miembro —o a quien administra— con una envoltura basura, y eso es
       // denegación de servicio disfrazada de reparto. Reemplazar es cosa de la bóveda,
       // por el camino de escribir (que estrena generación entera).
-      if (g.wraps?.[memberPub]) throw new Error(`putWrap: ${memberPub.slice(0, 12)}… ya tiene envoltura de la generación ${gen}`)
+      if (g.wraps?.[memberPub]) throw new Error(`putWrap: ${memberPub.slice(0, 12)}… already has a wrap for generation ${gen}`)
       g.wraps = { ...(g.wraps || {}), [memberPub]: wrap }
       save()
       return true

package/vault/vendor/vault/core/transport.js

@@ -36,7 +36,7 @@ export async function masterPubkeyOf (identity) {
  * @param {string} [opts.url] URL del proxy (default wss://proxy.dotrino.com).
  * @returns {Promise<{ client, token:string, identify():Promise<void> }>}
  */
-export async function createTransport ({ identity, url = DEFAULT_PROXY, commKey = null, log = () => {}, makeClient = null, announce = null, recheckMs = 60_000, patienceMs = 5 * 60_000, reannounceMs = 10 * 60_000 }) {
+export async function createTransport ({ identity, url = DEFAULT_PROXY, commKey = null, log = () => {}, makeClient = null, announce = null, wakeUrl = null, recheckMs = 60_000, patienceMs = 5 * 60_000, reannounceMs = 10 * 60_000 }) {
   // Import dinámico DESPUÉS de instalar los globals que el paquete usa.
   // `WebSocketProxyClient` (la clase) y NO el helper `getWebSocketProxyClient`:
   // ese es un SINGLETON de proceso, y con multi-perfil el vault necesita una
@@ -182,6 +182,25 @@ export async function createTransport ({ identity, url = DEFAULT_PROXY, commKey
     }
   }
 
+  /**
+   * DESPIÉRTAME AQUÍ (una bóveda que no vive conectada, `lambda/`). Si la plataforma da una
+   * URL, se registra en el proxio con la llave de comunicación y el acta, para que llame a esa
+   * URL cuando llegue algo para la cuenta y no haya nadie suyo conectado. Va pegado a
+   * `identify` por lo mismo que el anuncio: el acta puede haber cambiado. Si falla, se dice:
+   * lo que se pierde es que la despierten, y eso no se puede callar.
+   */
+  const registerWake = async () => {
+    if (!wakeUrl || !identificado) return
+    const comm = commKey?.pub?.() || null
+    if (!comm || !actaVista) { log('[vault] cannot register the wake URL: no communication key in the record yet'); return }
+    try {
+      await client.registerWake({ publicKey: comm, sign: (d) => commKey.sign(d), url: wakeUrl, acta: actaVista, channel: announce || undefined })
+      log('[vault] wake URL registered on the proxy')
+    } catch (e) {
+      log(`[vault] could not register the wake URL (${e.code || ''} ${e.message}) — the proxy will not wake this vault`)
+    }
+  }
+
   let reintento = null
   let fallos = 0
   const identifyWithRetry = async () => {
@@ -189,6 +208,7 @@ export async function createTransport ({ identity, url = DEFAULT_PROXY, commKey
     try {
       await identify()
       await announceAccount()
+      await registerWake()
       if (fallos) log(`[vault] identified on the proxy after ${fallos + 1} attempt(s)`)
       fallos = 0
     } catch (e) {

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

@@ -80,6 +80,8 @@ const MAX_REPLY_BYTES = 768 * 1024
  *   readProcContext(pid)  lo que el sistema dice de un proceso; `null` si no se puede mirar
  *   openLocalDesk({ name, onMessage, channels, maxBytes, log })  el atajo en la misma máquina
  *   makeClient        quién crea el cliente del proxio (opcional)
+ *   wakeUrl           la URL que despierta a esta bóveda si no vive conectada (opcional, `lambda/`)
+ *   onActivity()      llega un mensaje del proxio (opcional; la Lambda mide con esto su inactividad)
  *   noticeGroupMs     cuánto se agrupan los avisos de cambio
  *   opaque            el servidor de OPAQUE, si no vale el del paquete (opcional)
  *   servePasswords    `false`: el almacén de contraseñas lo atiende quien monta la bóveda,
@@ -492,7 +494,7 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
   // ninguna llave y solo sabe la dirección `nombre@AB12-CD34-EF56`— pueda encontrar a quien
   // la atiende. Lo construye la pieza compartida, porque quien lo busca es la extensión.
   const { client, identify: reidentificar, isIdentified } = await createTransport({
-    identity, url: proxyUrl, commKey, log, announce: vaultChannel(fp), makeClient: platform.makeClient || null
+    identity, url: proxyUrl, commKey, log, announce: vaultChannel(fp), makeClient: platform.makeClient || null, wakeUrl: platform.wakeUrl || null
   })
 
   // El registro público de cadenas de selladores: deposita, si hay a dónde, los eslabones
@@ -2189,7 +2191,12 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
     reply(from, { type: MSG.INCIDENT_RESULT, id: pend.id, approvers, blocked: false })
   }
 
-  client.on('message', (from, payload) => onMessage(from, payload))
+  client.on('message', (from, payload) => {
+    // Quien monta la bóveda puede querer saber que hay trabajo (la Lambda se apaga cuando
+    // deja de haberlo). Es un aviso, no decide nada.
+    try { platform.onActivity?.() } catch (_) {}
+    onMessage(from, payload)
+  })
 
   // EL MOSTRADOR LOCAL, siempre que se pueda. Si no se puede abrir (un sistema sin sockets
   // de archivo, un directorio de solo lectura) se dice y se sigue: los servicios usan el

package/vault/vendor/vault/loginClient.js

@@ -44,6 +44,8 @@ const err = (code, message, extra = {}) => Object.assign(new Error(message), { c
 
 /** Cuánto se espera a que una bóveda conteste antes de probar con la siguiente. */
 export const REPLY_TIMEOUT_MS = 15_000
+/** Lo que se espera a una bóveda que se está despertando: arrancar en frío y conectarse. */
+export const WAKE_WAIT_MS = 30_000
 
 /**
  * Escucha UNA respuesta de un token concreto. El `off` se suelta siempre —también al
@@ -98,7 +100,14 @@ export async function loginWithPassword ({ transport, address, password, label =
   if (typeof password !== 'string' || !password) throw err('no-password', 'loginWithPassword: password required')
   const { user, code, address: dir } = parseLoginAddress(address)
 
-  const tokens = await transport.list(vaultChannel(code))
+  let tokens = await transport.list(vaultChannel(code))
+  // UNA BÓVEDA QUE DUERME (la de una Lambda): el proxio la está despertando y lo dice. Se
+  // espera a que se anuncie en vez de contestar que esa cuenta no existe.
+  const hasta = Date.now() + WAKE_WAIT_MS
+  while (!tokens.length && tokens.waking && Date.now() < hasta) {
+    await new Promise((resolve) => setTimeout(resolve, 2000))
+    tokens = await transport.list(vaultChannel(code))
+  }
   if (!tokens.length) {
     throw err('no-vault', 'no vault is answering for that address right now: turn yours on, or check the address')
   }

package/vault/vendor/vault/passwordLogins.js

@@ -24,8 +24,8 @@
  * binario, `lib/src/index.js` en la pestaña—. Lo único que no es puro es `registerLogin`, al
  * final, porque hace falta la identidad que firma.
  */
-import { server as opaquePorDefecto, suiteId as suitePorDefecto } from '@dotrino/opaque'
-import { pubkeyId } from '@dotrino/identity/capabilities'
+import { server as opaquePorDefecto, client as opaqueClientePorDefecto, suiteId as suitePorDefecto } from '@dotrino/opaque'
+import { pubkeyId, makeDeviceKey, makeDeviceEncKey } from '@dotrino/identity/capabilities'
 import { DEVICE_CAPS, capScope } from '@dotrino/identity/acta'
 import { deviceIdOf } from './enroll.js'
 import { bytesToB64url, b64urlToBytes } from './b64.js'
@@ -448,6 +448,29 @@ export function createLoginDesk ({ load, save, now = () => Date.now(), opaque =
  *   `caps`     los PERMISOS del acta que lleva el aparato, cualquiera de `DEVICE_CAPS`;
  *              por defecto firmar, leer y guardar
  */
+/**
+ * DAR DE ALTA UN USUARIO, DEL LADO DE QUIEN TIENE LA CONTRASEÑA: el registro OPAQUE se
+ * termina aquí y las llaves del aparato nacen aquí y salen ya cerradas. La bóveda solo ve
+ * `begin`/`finish`, que es su mitad; quien llama decide por dónde llegan (el canal local de
+ * la CLI, o la propia bóveda en el arranque de una Lambda).
+ *
+ * @param {object} opts
+ *   `begin(req)`  → `{ response }`   (`register-begin` de la bóveda)
+ *   `finish(req)` → lo que devuelva  (`register-finish` de la bóveda)
+ */
+export async function createPasswordLogin ({ user, password, label, caps, begin, finish, opaque = opaqueClientePorDefecto } = {}) {
+  if (!isValidUser(user)) throw Object.assign(new Error('invalid user name'), { code: 'bad-user' })
+  if (typeof password !== 'string' || !password) throw Object.assign(new Error('a password is required'), { code: 'no-password' })
+  const start = opaque.registrationStart({ password })
+  const begun = await begin({ user, request: start.request })
+  // La bóveda contesta con su mitad; el registro se termina AQUÍ, con la contraseña.
+  const fin = opaque.registrationFinish({ state: start.state, response: begun.response, password })
+  const device = await makeDeviceKey({ label })
+  const enc = await makeDeviceEncKey()
+  const blob = await sealDeviceKeys(fin.exportKey, { sign: device.privateJwk, enc: enc.privateJwk })
+  return finish({ user, upload: fin.upload, pub: device.publickey, encPub: enc.publickey, label, blob, caps })
+}
+
 export async function registerLogin ({
   identity, logins, user, upload, pub, encPub = null, label = '', blob,
   caps = ['sign', 'read', 'store'], scope, replace = false