@dotrino/identity 0.117.1 → 0.118.0

package/package.json

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

package/vault/acta.js

@@ -105,7 +105,7 @@ const conCampoSellador = (acta) => Number(acta?.v) < V_SIN_CAMPO_SELLADOR
  * el rol de master, que no se delega. Así un dispositivo con `admin` robado hace daño
  * acotado y **reversible** (se le revoca), en vez de poder dejarte fuera de tu cuenta.
  */
-export const CAPS = Object.freeze(['sign', 'store', 'read', 'admin', 'approve', 'passwords', 'passkeys', 'sealer', 'unattended', 'replica'])
+export const CAPS = Object.freeze(['sign', 'store', 'read', 'admin', 'approve', 'passwords', 'sealer', 'unattended', 'replica'])
 
 /** Capacidades de un DISPOSITIVO (sin CN): acceso a todo lo del usuario. */
 /**
@@ -119,14 +119,12 @@ export const CAPS = Object.freeze(['sign', 'store', 'read', 'admin', 'approve',
  * pedirle algo a la bóveda es exactamente lo que decide el acta — tener dos registros
  * de lo mismo obliga a acordarse de los dos al quitar un aparato.
  *
- * `passkeys` es ABRIR LA PRIVADA DE UNA PASSKEY. Una passkey no se parece a una
- * contraseña: es una llave privada que firma el reto de un sitio, y si se copia sirve
- * **hasta que la borres en cada sitio** donde la registraste — no hay nada que «cambiar».
- * Por eso su envoltura solo se le hace a quien tenga `passwords` **y** esto
- * (`dotrino-passmanager/docs/sealed-passwords.md` §2.8).
- *
- * Sin `passwords` no significa nada: la passkey vive en una entrada de contraseñas. Y una
- * SESIÓN no lo lleva nunca, como `passwords` (`session.js`).
+ * Y `passwords` cubre TAMBIÉN LAS PASSKEYS (dueño, 2026-10-16: «realmente deberían ser uno
+ * solo»). Hasta la 0.117 había un `passkeys` aparte para abrir la privada de una passkey;
+ * se fusionó en este. Un acta vieja que todavía lo nombre sigue valiendo: un permiso
+ * desconocido se ignora (ver `checkShape`), y al siguiente cambio del acta desaparece.
+ * Lo que distingue una passkey es la POLÍTICA de la bóveda, no un permiso: añadirla es
+ * directo, reemplazarla o borrarla pide aprobación (`@dotrino/passmanager`).
  *
  * `replica` es REPARTIR, NO DECIDIR. Un replicador no tiene maestra: guarda el acta y los
  * sobres —que ya vienen sellados a su destinatario, así que tampoco puede abrirlos— y los
@@ -151,7 +149,7 @@ export const CAPS = Object.freeze(['sign', 'store', 'read', 'admin', 'approve',
  * de la cuenta, se ve en la pantalla de permisos como los demás, y se quita quitándolo —
  * sin acordarse de un segundo registro escondido.
  */
-export const DEVICE_CAPS = Object.freeze(['sign', 'store', 'read', 'admin', 'approve', 'passwords', 'passkeys', 'sealer', 'unattended', 'replica'])
+export const DEVICE_CAPS = Object.freeze(['sign', 'store', 'read', 'admin', 'approve', 'passwords', 'sealer', 'unattended', 'replica'])
 
 /**
  * Lo que recibe un dispositivo recién emparejado. `admin` **no está**: no se

package/vault/session.js

@@ -57,7 +57,7 @@ export const SESSION_SCOPES = Object.freeze(['id:whoami', 'vault:store'])
  * blanca a propósito: si mañana alguien añade un alcance a `SESSION_SCOPES` sin pensarlo,
  * esto sigue cortando lo que no puede pasar.
  */
-export const SESSION_FORBIDDEN = Object.freeze(['secrets', 'admin', 'approve', 'sealer', 'passwords', 'passkeys', 'unattended', 'replica'])
+export const SESSION_FORBIDDEN = Object.freeze(['secrets', 'admin', 'approve', 'sealer', 'passwords', 'unattended', 'replica'])
 
 /** Qué capacidad del acta hace falta para conceder cada alcance de sesión. */
 const SCOPE_NEEDS = Object.freeze({ 'id:whoami': null, 'vault:store': 'store' })

package/vault/vendor/passmanager/VERSION.txt

@@ -1,3 +1,3 @@
-Copia vendorizada de @dotrino/passmanager@0.17.0 (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.1 (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/sealed/entry.js

@@ -78,7 +78,7 @@ export async function sealEntry ({ plain, main, passkeys = null, keys }) {
     if (e.webauthn.privateKey) {
       if (!passkeys?.cek || typeof passkeys.gen !== 'number') {
         throw Object.assign(
-          new Error('this entry carries a passkey: it needs its own generation, wrapped only to devices with `passkeys`'),
+          new Error('this entry carries a passkey: it needs its own generation'),
           { code: 'passkeys-generation-missing' })
       }
       fields[PASSKEY_FIELD] = await sealV(passkeys.cek, passkeys.gen, e.webauthn.privateKey)

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

@@ -38,8 +38,9 @@ export class SealedStore {
    * @param {object} store  `{ get(k), set(k, v) }`
    * @param {object} opts
    *   `recipients(kind)` → `[{ pub, encPub }]` quién DEBE tener envoltura. `kind` es
-   *     `'main'` (los aparatos con `passwords`) o `'passkeys'` (los que además tienen
-   *     `passkeys`). Lo pone quien conoce el acta: esta pieza no la lee.
+   *     `'main'` o `'passkeys'` (la generación aparte de la privada de una passkey). Desde
+   *     2026-10-16 las dos son los aparatos con `passwords`: el permiso `passkeys` se fusionó
+   *     en ese. Lo pone quien conoce el acta: esta pieza no la lee.
    *   `verifyAuthor({ body, author })` → ¿la firmó quien dice, y puede escribir? Lo
    *     contesta quien tiene el acta. **No es opcional**: sin ella, cualquiera que llegue
    *     al almacén podría dejar una entrada a nombre de otro, y la bóveda no puede mirar
@@ -97,13 +98,12 @@ export class SealedStore {
         'the wraps must include the recovery one (#recovery), or this entry could never be handed out again')
     }
     const deben = (await this.recipients(kind)).filter((m) => m?.encPub).map((m) => m.pub)
-    // NADIE A QUIEN ENVOLVÉRSELA NO ES «CERO DESTINATARIOS», ES UN ERROR. Guardar una
-    // passkey que ningún aparato puede abrir la deja viva solo para la frase del perfil: no
-    // se pierde, pero no sirve, y el usuario se entera el día que la necesita. Se dice
-    // ahora, con un código que explica qué falta.
-    if (kind === 'passkeys' && !deben.length) {
+    // Una passkey no se guarda para NADIE: sin aparatos que puedan abrirla y sin copia de
+    // recuperación, se perdería entera. Con la copia basta: quien reciba el permiso después
+    // la recibe al re-repartir (`rewrapAll`).
+    if (kind === 'passkeys' && !deben.length && !wraps[RECOVERY]) {
       throw new SealedError('no-passkeys-device',
-        'no device in the account record can open passkeys: grant `passkeys` to one (`dotrino-vault caps <ID> +passkeys`) before saving it')
+        'nobody could ever open this passkey: no device has `passwords` and the account has no recovery copy')
     }
     const hay = Object.keys(wraps).filter((k) => k !== RECOVERY)
     if (!same(deben, hay)) {
@@ -127,7 +127,7 @@ export class SealedStore {
     // reparte una llave que nadie va a usar.
     if (llevaPasskey && !tienePasskeys) {
       throw new SealedError('passkeys-generation-missing',
-        'this entry carries a passkey: it needs its own wraps, only for devices with `passkeys`')
+        'this entry carries a passkey: it needs its own wraps (its own generation)')
     }
     if (!llevaPasskey && tienePasskeys) {
       throw new SealedError('passkeys-generation-unused', 'there is no passkey in this entry to wrap')
@@ -225,7 +225,7 @@ export class SealedStore {
     if (passkeys) await this.#checkWraps('passkeys', passkeys.wraps)
     if (fields[PASSKEY_FIELD] && !passkeys) {
       throw new SealedError('passkeys-generation-missing',
-        'that patch carries a passkey: it needs its own wraps, only for devices with `passkeys`')
+        'that patch carries a passkey: it needs its own wraps (its own generation)')
     }
 
     const s = await this.#state()
@@ -343,6 +343,12 @@ export class SealedStore {
     return s.entries.find((e) => e.id === id)?.priv || []
   }
 
+  /** ¿Esa entrada lleva una passkey? La bóveda lo sabe sin abrir nada: por su huella `wa`. */
+  async hasPasskey (id) {
+    const s = await this.#state()
+    return !!s.entries.find((e) => e.id === id)?.wa
+  }
+
   async remove (id) {
     const s = await this.#state()
     const antes = s.entries.length

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

@@ -119,8 +119,25 @@ export class SealedResponder {
     }
   }
 
+  /**
+   * ¿CAMBIA O QUITA UNA PASSKEY QUE YA ESTÁ? Añadir es directo y no pregunta; reemplazarla o
+   * borrarla, sí — como las variables de `dotrino-env` (dueño, 2026-10-16). Una passkey
+   * borrada o pisada deja a alguien fuera de un sitio, y no hay forma de deshacerlo.
+   *
+   * Subir el contador al entrar NO es reemplazar: cambia la vista, no la llave.
+   */
+  async replacesPasskey (op, payload) {
+    if (op === 'pm2.remove') return this.store.hasPasskey(payload?.id)
+    if (op === 'pm2.put') return this.store.hasPasskey(payload?.entry?.id)
+    if (op === 'pm2.patch') {
+      return !!payload?.fields?.[PASSKEY_FIELD] || (payload?.drop || []).includes(PASSKEY_FIELD)
+    }
+    return false
+  }
+
   async #needsApproval (op, payload, pubkey) {
-    return await this.needsApproval(pubkey) && await this.wantsPrivate(op, payload)
+    if (!await this.needsApproval(pubkey)) return false
+    return await this.wantsPrivate(op, payload) || await this.replacesPasskey(op, payload)
   }
 
   async #run (op, payload = {}, pubkey) {

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

@@ -262,7 +262,11 @@ export class SealedVault {
         fields: actual.fieldKeys.some((k) => !FIXED.includes(k)),
         webauthn: actual.hasWebauthn
       },
-      ...(actual.webauthn ? { webauthn: actual.webauthn } : {})
+      // El contador de la passkey sube en cada firma y vive en la vista: cambiarlo no toca
+      // la llave, así que no es reemplazarla (no pide aprobación).
+      ...(actual.webauthn
+        ? { webauthn: Number.isInteger(changes.signCount) ? { ...actual.webauthn, signCount: changes.signCount } : actual.webauthn }
+        : {})
     }
     const idx = sites ? await Promise.all(sites.map((s) => siteIndex(keys.kidx, s))) : null
     const parche = await buildSealedPatch({

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

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

@@ -24,6 +24,13 @@ import { pack, unpack, hasBinary, encodeFrame, decodeFrame } from './binpack.js'
  * proxio ya tiene atada a esta conexión desde `identify`. Nada del usuario viaja aquí.
  */
 const HELLO_TAG = '__cc_hello__'
+/**
+ * Lo que este cliente entiende, y lo dice en el saludo (0.36.0). Hoy una cosa: `binary`, las
+ * tramas con bytes (binpack.js). Quien saluda sin decirlo es anterior y no las entiende, así
+ * que no se le mandan: se lanza `peer-no-binary` y la app lo enseña. La idea del dueño es que
+ * todo pase a binario con el tiempo, y esta lista es por donde se sabrá quién ya puede.
+ */
+const SPEAKS = ['binary']
 
 function errorCon (mensaje, code) {
   const e = /** @type {Error & { code: string }} */ (new Error(mensaje))
@@ -136,6 +143,10 @@ export class WebSocketProxyClient {
      * son de nadie.
      */
     this._tokenPubkeys = new Map()
+    // Lo que dijo entender cada token en su saludo, y cada identidad (para lo que va por
+    // pubkey). Sin saludo no se sabe, y entonces no se frena nada.
+    this._tokenSpeaks = new Map()
+    this._pubkeySpeaks = new Map()
     this._helloSent = new Set()
 
     /** Mi propia identidad en el cable, la que `identify` dejó atada a este token. */
@@ -518,8 +529,9 @@ export class WebSocketProxyClient {
     if (m.len > queueMax) {
       throw errorCon(`sendSealed: ${m.len} ${m.bin ? 'bytes' : 'chars'} is more than can wait in the proxy (${queueMax}); send it by token while both ends are connected`, 'too-big-for-queue')
     }
-    // Por pubkey todo va por el proxio: si no admite bytes, se dice antes de mandar nada.
-    if (m.bin) this._needBinaryProxy()
+    // Por pubkey todo va por el proxio: si no admite bytes, se dice antes de mandar nada. Y
+    // si alguno de los destinatarios dijo que no los entiende, tampoco.
+    if (m.bin) { this._needBinaryProxy(); this._needPeerBinary(list) }
     const partSize = m.bin ? PROXY_PART_BYTES : PROXY_PART_CHARS
     const pieces = m.len <= partSize ? [m.bin ? m.whole : payload]
       : m.bin ? splitBinParts(m.whole, partSize) : splitParts(m.whole, partSize)
@@ -579,6 +591,9 @@ export class WebSocketProxyClient {
     const size = m.bin ? (direct ? DIRECT_PART_BYTES : PROXY_PART_BYTES) : (direct ? DIRECT_PART_CHARS : PROXY_PART_CHARS)
     const relayMax = m.bin ? RELAY_MAX_BYTES : RELAY_MAX_CHARS
     const queueMax = m.bin ? QUEUE_MAX_BYTES : QUEUE_MAX_CHARS
+    // Por token decide lo que dijo ESA conexión: lo recordado de la identidad puede ser de una
+    // versión que ya se actualizó.
+    if (m.bin) this._needPeerBinary(tokens)
     if (m.bin && !direct) this._needBinaryProxy()
     const sealPiece = await this._sealerFor(m.bin, peerEncPub, peerPubkey)
     if (m.len <= size) {
@@ -718,7 +733,8 @@ export class WebSocketProxyClient {
    * Un token es una dirección del proxio y no dice de quién es, así que sin esto no hay
    * a quién sellarle: una sala de desconocidos se queda muda o —lo que pasaba— hablando
    * en claro. El saludo lleva SOLO mi llave pública, la misma que el proxio ya tiene
-   * atada a esta conexión desde `identify`; no hay nada del usuario dentro y por eso no
+   * atada a esta conexión desde `identify`, y lo que este cliente entiende (`SPEAKS`, que es
+   * lo mismo para todos los de esta versión); no hay nada del usuario dentro y por eso no
    * necesita sobre.
    *
    * Quien lo recibe contesta el suyo una vez, así que basta con que salude UNA de las
@@ -737,7 +753,7 @@ export class WebSocketProxyClient {
     for (const t of tokens) {
       if (!t || t === this.token) continue
       this._helloSent.add(t)
-      this._proxySendOne(t, { t: HELLO_TAG, publickey: this.myPublickey })
+      this._proxySendOne(t, { t: HELLO_TAG, publickey: this.myPublickey, speaks: SPEAKS })
     }
   }
 
@@ -748,9 +764,34 @@ export class WebSocketProxyClient {
 
   /** Olvidar un token (se fue, o se quiere volver a preguntar). Sin argumento, todos. */
   forgetToken (token) {
-    if (token == null) { this._tokenPubkeys.clear(); this._helloSent.clear(); return }
+    if (token == null) { this._tokenPubkeys.clear(); this._helloSent.clear(); this._tokenSpeaks.clear(); return }
     this._tokenPubkeys.delete(token)
     this._helloSent.delete(token)
+    this._tokenSpeaks.delete(token)
+  }
+
+  /**
+   * ¿Entiende esto la otra punta? `true` o `false` si lo dijo en su saludo, y `null` si
+   * todavía no ha saludado (no se sabe). Acepta un token o una pubkey.
+   * @param {string} who
+   * @param {string} [feature]
+   * @returns {boolean|null}
+   */
+  speaks (who, feature = 'binary') {
+    let set = this._tokenSpeaks.get(who) || this._pubkeySpeaks.get(who)
+    if (!set) {
+      for (const [pk, s] of this._pubkeySpeaks) if (samePubkey(pk, who)) { set = s; break }
+    }
+    return set ? set.has(feature) : null
+  }
+
+  /** Antes de mandar bytes: si alguno dijo que no los entiende, no sale nada y se dice. */
+  _needPeerBinary (targets) {
+    for (const t of targets) {
+      if (t && this.speaks(t, 'binary') === false) {
+        throw errorCon('the other side does not take binary messages (it needs @dotrino/proxy-client >= 0.36.0)', 'peer-no-binary')
+      }
+    }
   }
 
   _onHello (from, msg) {
@@ -764,6 +805,9 @@ export class WebSocketProxyClient {
       return
     }
     this._tokenPubkeys.set(from, msg.publickey)
+    const speaks = new Set(Array.isArray(msg.speaks) ? msg.speaks.filter((x) => typeof x === 'string').slice(0, 32) : [])
+    this._tokenSpeaks.set(from, speaks)
+    this._pubkeySpeaks.set(msg.publickey, speaks)
     // Contestar UNA vez: el saludo queda simétrico sin rebotar para siempre.
     if (!this._helloSent.has(from) && this.myPublickey) this.helloTo(from)
     this._emit('peer_identity', from, msg.publickey)

package/vault/vendor/roadmap/VERSION.txt

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

package/vault/vendor/roadmap/manifests.js

@@ -8,7 +8,7 @@
 export const MANIFESTS = Object.freeze({
   "dotrino": {
     "manifest": "dotrino",
-    "seq": 27,
+    "seq": 29,
     "issued": "2026-10-15",
     "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": {
@@ -31,7 +31,7 @@ export const MANIFESTS = Object.freeze({
       "identity": {
         "repo": "imdotrino/dotrino-identity",
         "npm": "@dotrino/identity",
-        "current": "0.116.0",
+        "current": "0.117.2",
         "protocol": 1,
         "requires": {}
       },
@@ -47,13 +47,13 @@ export const MANIFESTS = Object.freeze({
       },
       "messenger": {
         "repo": "imdotrino/dotrino-messenger",
-        "current": "0.7.0",
+        "current": "0.8.1",
         "protocol": 2,
         "requires": {
-          "identity": ">=0.108.0",
-          "proxy-client": ">=0.34.0",
+          "identity": ">=0.117.0",
+          "proxy-client": ">=0.36.1",
           "store": ">=0.12.3",
-          "proxy": "1.5.2+"
+          "proxy": "1.6.1+"
         }
       },
       "messenger-android": {
@@ -107,7 +107,7 @@ export const MANIFESTS = Object.freeze({
       },
       "proxy": {
         "repo": "imdotrino/dotrino-proxy",
-        "current": "1.5.2",
+        "current": "1.6.1",
         "protocol": 2,
         "requires": {
           "vault": ">=0.86.0",
@@ -119,7 +119,7 @@ export const MANIFESTS = Object.freeze({
       "proxy-client": {
         "repo": "imdotrino/dotrino-proxy-client",
         "npm": "@dotrino/proxy-client",
-        "current": "0.34.0",
+        "current": "0.36.1",
         "protocol": 2,
         "requires": {
           "identity": ">=0.53.0",
@@ -129,25 +129,25 @@ export const MANIFESTS = Object.freeze({
       "remote-agent": {
         "repo": "imdotrino/dotrino-remote-agent",
         "npm": "@dotrino/remote-agent",
-        "current": "0.19.1",
+        "current": "0.20.1",
         "protocol": 1,
         "requires": {
-          "identity": ">=0.115.0",
+          "identity": ">=0.117.2",
           "vault": ">=0.85.0",
-          "proxy-client": ">=0.30.0",
+          "proxy-client": ">=0.36.1",
           "vaultd": ">=0.154.0"
         }
       },
       "terminal-agent": {
         "repo": "imdotrino/dotrino-terminal",
         "npm": "@dotrino/terminal-agent",
-        "current": "0.47.4",
+        "current": "0.48.0",
         "protocol": 2,
         "requires": {
-          "remote-agent": ">=0.18.3",
-          "identity": ">=0.116.0",
-          "vault": ">=0.86.0",
-          "proxy-client": ">=0.31.1",
+          "remote-agent": ">=0.20.1",
+          "identity": ">=0.117.2",
+          "vault": ">=0.87.0",
+          "proxy-client": ">=0.36.1",
           "vaultd": ">=0.142.0"
         }
       },
@@ -250,12 +250,12 @@ export const MANIFESTS = Object.freeze({
       "vault": {
         "repo": "imdotrino/dotrino-vault",
         "npm": "@dotrino/vault",
-        "current": "0.86.0",
+        "current": "0.87.0",
         "protocol": 1,
         "requires": {
           "vaultd": ">=0.105.0",
-          "proxy-client": "0.24.0+",
-          "identity": ">=0.116.0",
+          "proxy-client": ">=0.36.1",
+          "identity": ">=0.117.2",
           "opaque": ">=0.1.0",
           "compat": ">=0.4.0",
           "roadmap": ">=0.4.13",
@@ -266,11 +266,11 @@ export const MANIFESTS = Object.freeze({
       "vaultd": {
         "repo": "imdotrino/dotrino-vault",
         "npm": "@dotrino/vaultd",
-        "current": "0.157.0",
+        "current": "0.159.0",
         "protocol": 1,
         "requires": {
-          "identity": ">=0.116.0",
-          "proxy-client": ">=0.30.1",
+          "identity": ">=0.117.2",
+          "proxy-client": ">=0.36.1",
           "store": ">=0.11.0",
           "passmanager": ">=0.17.0",
           "compat": ">=0.4.0",
@@ -290,11 +290,11 @@ export const MANIFESTS = Object.freeze({
       "passmanager": {
         "repo": "imdotrino/dotrino-passmanager",
         "npm": "@dotrino/passmanager",
-        "current": "0.17.0",
+        "current": "0.18.0",
         "protocol": 1,
         "requires": {
-          "identity": ">=0.61.0",
-          "proxy-client": ">=0.13.0"
+          "identity": ">=0.117.2",
+          "proxy-client": ">=0.36.1"
         }
       },
       "passmanager-android": {
@@ -317,12 +317,12 @@ export const MANIFESTS = Object.freeze({
       },
       "passmanager-extension": {
         "repo": "imdotrino/dotrino-passmanager",
-        "current": "0.49.1",
+        "current": "0.51.1",
         "protocol": 1,
         "requires": {
-          "identity": ">=0.116.0",
-          "proxy-client": ">=0.32.2",
-          "vault": ">=0.86.0",
+          "identity": ">=0.117.2",
+          "proxy-client": ">=0.36.1",
+          "vault": ">=0.87.0",
           "proxy": "1.1.0+"
         }
       },
@@ -349,6 +349,30 @@ export const MANIFESTS = Object.freeze({
       }
     },
     "broken": [
+      {
+        "product": "passmanager-extension",
+        "versions": "0.50.0",
+        "why": "la página que pide una passkey decía ella misma de qué sitio era (rpId y origen salían del mensaje, no del remitente): un sitio cualquiera podía pedir la firma de la passkey de otro sitio guardada en Dotrino",
+        "fix": "sube a la extensión 0.51.0 (se actualiza sola desde pass.dotrino.com/app)"
+      },
+      {
+        "product": "passmanager-extension",
+        "versions": "0.49.1",
+        "why": "la página que pide una passkey decía ella misma de qué sitio era (rpId y origen salían del mensaje, no del remitente): un sitio cualquiera podía pedir la firma de la passkey de otro sitio guardada en Dotrino",
+        "fix": "sube a la extensión 0.51.0 (se actualiza sola desde pass.dotrino.com/app)"
+      },
+      {
+        "product": "passmanager-extension",
+        "versions": "0.49.0",
+        "why": "la página que pide una passkey decía ella misma de qué sitio era (rpId y origen salían del mensaje, no del remitente): un sitio cualquiera podía pedir la firma de la passkey de otro sitio guardada en Dotrino",
+        "fix": "sube a la extensión 0.51.0 (se actualiza sola desde pass.dotrino.com/app)"
+      },
+      {
+        "product": "passmanager-extension",
+        "versions": "0.48.4",
+        "why": "la página que pide una passkey decía ella misma de qué sitio era (rpId y origen salían del mensaje, no del remitente): un sitio cualquiera podía pedir la firma de la passkey de otro sitio guardada en Dotrino",
+        "fix": "sube a la extensión 0.51.0 (se actualiza sola desde pass.dotrino.com/app)"
+      },
       {
         "product": "terminal-agent",
         "versions": "0.46.4",
@@ -796,6 +820,18 @@ export const MANIFESTS = Object.freeze({
         "versions": "1.9.0",
         "why": "no tiene UI propia: sus tres superficies son iframes a messenger.dotrino.com con ?embed=, y el soporte de ese modo (puente de identidad, espejo de conversaciones, cola de salida, aviso de DM) se quitó del messenger después de la 0.1.0; la PWA servida siempre es la última, así que el panel se inventa una cuenta en cada sitio y no recibe nada",
         "fix": "no hay versión que funcione: hay que elegir el camino del README de dotrino-messenger-extension (extensión autónoma con los pilares, o un modo embed del ecosistema)"
+      },
+      {
+        "product": "proxy",
+        "versions": "1.6.0",
+        "why": "pasa a base64 los mensajes binarios para cruzar la malla, y una parte de 768 KB así pasa de la trama de 1 MB del otro nodo: el enlace se cae en cada reconexión al reenviarla y todo lo que va detrás entre los dos nodos se queda atascado",
+        "fix": "websocket-proxy 1.6.1"
+      },
+      {
+        "product": "proxy-client",
+        "versions": "0.36.0",
+        "why": "por token frena los bytes por lo recordado de la identidad (que puede ser de antes de que el otro se actualizara), y no solo por lo que dijo esa conexión en su saludo",
+        "fix": "@dotrino/proxy-client 0.36.1"
       }
     ]
   }

package/vault/vendor/vault/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/vault@0.86.1 (dotrino-vault/lib/src/{admin,b64,browser,core/approvals,core/blocked,core/browserDisk,core/commKey,core/disk,core/libVersion,core/machines,core/notices,core/notifiable,core/passwords,core/sealKey,core/sealer,core/sealers,core/secretsStore,core/sha256,core/store,core/subacta,core/threadStore,core/transport,core/vault,enroll,index,loginClient,passwordLogins,procContext,protocol,revocation,sealed}.js).
+Copia vendorizada de @dotrino/vault@0.88.0 (dotrino-vault/lib/src/{admin,b64,browser,core/approvals,core/blocked,core/browserDisk,core/commKey,core/disk,core/libVersion,core/machines,core/notices,core/notifiable,core/passwords,core/sealKey,core/sealer,core/sealers,core/secretsStore,core/sha256,core/store,core/subacta,core/threadStore,core/transport,core/vault,enroll,index,loginClient,passwordLogins,procContext,protocol,revocation,sealed}.js).
 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.86.0'
+export const LIB_VERSION = '0.88.0'

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

@@ -23,7 +23,6 @@ import { SealedStore, SealedResponder } from '@dotrino/passmanager'
 import { verifyDeviceSig } from '@dotrino/identity/capabilities'
 
 export const PASSWORDS_CAP = 'passwords'
-export const PASSKEYS_CAP = 'passkeys'
 
 /**
  * @param {object} opts

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

@@ -311,14 +311,14 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
    * eso se filtran explícitamente aquí, que es donde se construye la lista, y no en quien la
    * consume (`sealed-passwords.md` §2.1).
    *
-   * `main` son los aparatos con `contraseñas`; `passkeys`, los que además pueden abrir la
-   * privada de una passkey (§2.8). Un miembro sin llave de cifrado no puede recibir nada: se
+   * `main` y `passkeys` (la generación aparte de la privada de una passkey) son los MISMOS:
+   * los aparatos con `contraseñas`. Hubo un permiso `passkeys` aparte y se fusionó en ese
+   * (dueño, 2026-10-16: «realmente deberían ser uno solo»); `kind` se queda por el formato. Un miembro sin llave de cifrado no puede recibir nada: se
    * queda fuera y se ve en `incompleteMembers`.
    */
   const noEsLaBoveda = (pub) => pub !== master && pub !== commKey.pub()
-  const passwordRecipients = (kind = 'main') => (actaCache?.members || [])
+  const passwordRecipients = (_kind = 'main') => (actaCache?.members || [])
     .filter((m) => m.encPub && noEsLaBoveda(m.pub) && Acta.memberCan(actaCache, m.pub, 'passwords'))
-    .filter((m) => kind !== 'passkeys' || Acta.memberCan(actaCache, m.pub, 'passkeys'))
     .map((m) => ({ pub: m.pub, encPub: m.encPub }))
 
   /**