@dotrino/identity 0.77.0 → 0.79.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.77.0",
+  "version": "0.79.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",
@@ -39,6 +39,7 @@
     "LICENSE"
   ],
   "scripts": {
+    "vendor": "node vendor.mjs",
     "test": "node --test \"test/*.test.js\" \"test/*.test.mjs\"",
     "type-check": "tsc --noEmit"
   },

package/src/index.js

@@ -343,6 +343,15 @@ export class Identity {
   async openContent (envelope) { return this._call('openContent', { envelope }) }
   /** Rota la clave de contenido (corta el acceso al contenido FUTURO de quien ya no está). */
   async rotateContentKey () { return this._call('rotateContentKey') }
+  /**
+   * Abre un sobre de un CAJÓN DE SECRETOS con la envoltura dirigida a este aparato.
+   *
+   * Distinto de `openContent`, que usa el llavero del perfil: aquí la envoltura llega suelta
+   * y la privada de cifrado de este dispositivo —que nunca sale del iframe— la abre. Es lo
+   * que le permite a quien administra LEER una variable pública sin teclear ninguna
+   * contraseña, y solo las que la bóveda le haya envuelto.
+   */
+  async openSealedValue ({ wrap, envelope } = {}) { return this._call('openSealedValue', { wrap, envelope }) }
 
   // ----- Emparejar ESTE navegador/dispositivo con el vault del usuario (Fase 1) -----
 

package/vault/acta.js

@@ -103,7 +103,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', 'secrets', 'admin', 'approve', 'passwords', 'sealer', 'unattended'])
+export const CAPS = Object.freeze(['sign', 'store', 'read', 'secrets', 'admin', 'approve', 'passwords', 'sealer', 'unattended', 'replica'])
 
 /** Capacidades de un DISPOSITIVO (sin CN): acceso a todo lo del usuario. */
 /**
@@ -117,6 +117,15 @@ export const CAPS = Object.freeze(['sign', 'store', 'read', 'secrets', 'admin',
  * 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.
  *
+ * `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
+ * entrega cuando la bóveda no está. Firma su respuesta con su propia llave de aparato, y
+ * es este permiso el que hace que un cliente la acepte como respondedor.
+ *
+ * Lo que NO le concede, y por eso es estrecho: no sella actas, no emite certificados, no
+ * abre nada. Un replicador comprometido cuesta disponibilidad, no confidencialidad.
+ * Diseño: `dotrino-vault/docs/replicas.md` §8.bis.
+ *
  * `unattended` es RECIBIR CLAVES PRIVADAS SIN QUE NADIE APRUEBE. Sin él, la bóveda no
  * entrega nada hasta que un aparato con `approve` lo firme — una vez por arranque del
  * servicio, no por petición.
@@ -131,7 +140,7 @@ export const CAPS = Object.freeze(['sign', 'store', 'read', 'secrets', 'admin',
  * 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', 'sealer', 'unattended'])
+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
@@ -158,19 +167,16 @@ export const isValidCn = (cn) => typeof cn === 'string' && /^[a-z0-9-]{1,32}$/.t
  * scope de secretos «de todos».
  */
 export function capScope (cap, cn = null) {
-  if (cap === 'sign') return 'vault:sign'
-  if (cap === 'store') return 'vault:store'
-  if (cap === 'read') return 'vault:read'
-  if (cap === 'admin') return 'vault:admin'
-  if (cap === 'approve') return 'vault:approve'
-  if (cap === 'passwords') return 'vault:passwords'
-  if (cap === 'sealer') return 'vault:sealer'
+  // SALE DE `CAP_SCOPE`, no de una cadena de `if` escrita a mano. Esto era lo segundo: la
+  // lista de arriba y esta se escribían por separado, así que un permiso nuevo entraba en
+  // una y no en la otra y se quedaba sin scope en silencio. Ya pasó con `sealer`,
+  // `unattended` y `secrets`; con `replica` se cortó aquí.
   if (cap === 'secrets') return isValidCn(cn) ? 'vault:secrets:' + cn : null
-  return null
+  return CAP_SCOPE[cap] || null
 }
 
 /** Compat: el mapa directo, para las capacidades de dispositivo. */
-export const CAP_SCOPE = Object.freeze({ sign: 'vault:sign', store: 'vault:store', read: 'vault:read', admin: 'vault:admin', approve: 'vault:approve', passwords: 'vault:passwords', sealer: 'vault:sealer' })
+export const CAP_SCOPE = Object.freeze({ sign: 'vault:sign', store: 'vault:store', read: 'vault:read', admin: 'vault:admin', approve: 'vault:approve', passwords: 'vault:passwords', sealer: 'vault:sealer', replica: 'vault:replica' })
 
 const enc = (s) => new TextEncoder().encode(s)
 const hex = (buf) => [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, '0')).join('')

package/vault/index.html

@@ -26,7 +26,8 @@
     "@dotrino/proxy-client": "./vendor/proxy-client/index.js",
     "@dotrino/vault": "./vendor/vault/index.js",
     "@dotrino/identity/capabilities": "./capabilities.js",
-    "@dotrino/identity/acta": "./acta.js"
+    "@dotrino/identity/acta": "./acta.js",
+    "@dotrino/identity/content": "./content.js"
   } }
   </script>
   <script type="module" src="./vault.js"></script>

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

@@ -1 +1,4 @@
-0.11.0
+Copia vendorizada de @dotrino/proxy-client@0.13.1 (dotrino-proxy-client/src/{index,client,signature,canonical,sealing,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

@@ -1,4 +1,5 @@
 import { buildSignedChannel, getPublicKeyJwk, signData } from './signature.js'
+import { seal, open, isSealed } from './sealing.js'
 import { WebRTCManager, RTC_TAG, DEFAULT_ICE_SERVERS } from './webrtc.js'
 
 /**
@@ -43,6 +44,33 @@ export class WebSocketProxyClient {
     this.enableWebRTC = options.enableWebRTC !== false
     this.iceServers = options.iceServers || null
 
+    /**
+     * Refuse to send or accept directed messages in the clear.
+     *
+     * The proxy does not encrypt payloads, so anything sensitive sent with
+     * `sendByPubkey` is readable by whoever runs the proxy. With this on:
+     *   · `sendSealed()` is the only way out — plain `sendByPubkey` throws
+     *   · unsealed directed messages are dropped and reported as 'unsealed'
+     *
+     * Off by default so existing apps keep working; public channels are unaffected
+     * either way, since they are public by design.
+     */
+    this.requireSealed = options.requireSealed === true
+    this.myEncPrivateKey = options.myEncPrivateKey || null
+
+    /**
+     * Who does the sealing. Two worlds, and only one of them holds the key:
+     *
+     *   · headless devices (a CLI, an agent) have their own encryption private key,
+     *     so `myEncPrivateKey` is enough
+     *   · browser apps do NOT: the private key lives in the vault, and they delegate
+     *     with `identity.encrypt` / `identity.decrypt`
+     *
+     * Pass `sealing: { seal(msg, peerEncPub), open(envelope), isSealed(msg) }` to
+     * plug the second case in. Without it, the built-in sealing is used.
+     */
+    this.sealing = options.sealing || null
+
     // Heartbeat de aplicación: el WebSocket del browser NO expone ping/pong de
     // protocolo, así que mandamos `{type:'ping'}` y esperamos cualquier tráfico
     // de vuelta (el server responde `pong`). Si no hay respuesta en
@@ -67,7 +95,7 @@ export class WebSocketProxyClient {
     this._rtc = this.enableWebRTC ? new WebRTCManager({
       getSelfToken: () => this.token,
       signalSend: (to, payload) => this._proxySendOne(to, payload),
-      deliverMessage: (from, parsed, meta) => this._emit('message', from, parsed, meta),
+      deliverMessage: (from, parsed, meta) => this._deliver(from, parsed, meta),
       emit: (event, ...args) => this._emit(event, ...args),
       config: this.iceServers ? { iceServers: this.iceServers } : null
     }) : null
@@ -127,6 +155,19 @@ export class WebSocketProxyClient {
     if (typeof options.autoReconnect === 'boolean') this.autoReconnect = options.autoReconnect
     if (typeof options.maxReconnectAttempts === 'number') this.maxReconnectAttempts = options.maxReconnectAttempts
     if (typeof options.reconnectDelay === 'number') this.reconnectDelay = options.reconnectDelay
+
+    // La configuración de sellado TAMBIÉN se aplica aquí. Casi todas las apps piden el
+    // cliente con `getWebSocketProxyClient()`, que es un singleton: si el primero en
+    // pedirlo no puso `requireSealed`, el que sí lo pide después se quedaba sin él y
+    // sin enterarse — la garantía perdida en silencio, que es la peor forma de
+    // perderla.
+    if (options.sealing) this.sealing = options.sealing
+    if (options.myEncPrivateKey) this.myEncPrivateKey = options.myEncPrivateKey
+
+    // Se puede ENCENDER, no apagar. Bajar la exigencia en caliente dejaría que
+    // cualquier otro módulo de la app la desactivara sin querer, y no hay ningún
+    // motivo legítimo para hacerlo a mitad de una sesión.
+    if (options.requireSealed === true) this.requireSealed = true
   }
 
   on (event, handler) {
@@ -265,7 +306,67 @@ export class WebSocketProxyClient {
    * incorrecto (reinicia negociaciones imposibles y muestra movimientos fuera de
    * contexto). NO lo uses para mensajes de chat, que sí quieren esperar.
    */
+  /**
+   * Seal a payload towards a peer's encryption key and send it. This is what an app
+   * should use for anything that is not meant for the proxy's eyes.
+   */
+  async sendSealed (toPubkeys, payload, { peerEncPub, ...opts } = {}) {
+    if (this.sealing) {
+      this._sendByPubkeyRaw(toPubkeys, await this.sealing.seal(payload, peerEncPub), opts)
+      return
+    }
+    if (!peerEncPub) throw Object.assign(new Error('sendSealed: missing peerEncPub'), { code: 'unsealed' })
+    this._sendByPubkeyRaw(toPubkeys, await seal(payload, peerEncPub), opts)
+  }
+
+  _isSealed (msg) {
+    return this.sealing ? this.sealing.isSealed(msg) : isSealed(msg)
+  }
+
   sendByPubkey (toPubkeys, payload, opts = {}) {
+    if (this.requireSealed && !this._isSealed(payload)) {
+      throw Object.assign(
+        new Error('requireSealed: refusing to send a directed message in the clear — use sendSealed()'),
+        { code: 'unsealed' })
+    }
+    this._sendByPubkeyRaw(toPubkeys, payload, opts)
+  }
+
+  /**
+   * Hands a message to the app, opening it first when it is sealed.
+   *
+   * With `requireSealed`, anything that arrives in the clear is DROPPED and reported
+   * as `{ type: 'unsealed' }`. Sealing on the way out is not enough on its own: if the
+   * receiving end still accepts plaintext, sending it that way bypasses the sealing
+   * entirely — and a peer that never read anything could still push a forged payload
+   * into the app.
+   */
+  async _deliver (from, payload, meta) {
+    if (this._isSealed(payload)) {
+      if (!this.sealing && !this.myEncPrivateKey) {
+        this._emit('error', { type: 'unsealed', reason: 'no_encryption_key', from })
+        return
+      }
+      try {
+        const opened = this.sealing
+          ? await this.sealing.open(payload, meta)
+          : await open(payload, this.myEncPrivateKey)
+        this._emit('message', from, opened, { ...meta, sealed: true })
+      } catch (e) {
+        // Sealed to somebody else, or tampered with. Staying quiet is the point.
+        this._emit('error', { type: 'undecipherable', from, error: e })
+      }
+      return
+    }
+
+    if (this.requireSealed) {
+      this._emit('error', { type: 'unsealed', reason: 'plaintext_rejected', from })
+      return
+    }
+    this._emit('message', from, payload, { ...meta, sealed: false })
+  }
+
+  _sendByPubkeyRaw (toPubkeys, payload, opts = {}) {
     const list = Array.isArray(toPubkeys) ? toPubkeys : [toPubkeys]
     const msg = {
       to_publickey: list,
@@ -713,7 +814,7 @@ export class WebSocketProxyClient {
           this._rtc.handleIncoming(from, parsed)
           break
         }
-        this._emit('message', from, parsed ?? message, {
+        this._deliver(from, parsed ?? message, {
           raw: message, timestamp, via: 'proxy',
           fromPubkey: from_publickey || null,
           queued: !!queued,

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

@@ -1,6 +1,10 @@
 export { WebSocketProxyClient } from './client.js'
 export { canonicalStringify } from './canonical.js'
-export { getPublicKeyJwk, signData, buildSignedChannel } from './signature.js'
+export { getPublicKeyJwk, signData, buildSignedChannel, setKeypairStore } from './signature.js'
+export {
+  seal, open, isSealed, makeEncKeypair, importEncPrivate, exportEncPrivate,
+  setSealingPrimitives,
+} from './sealing.js'
 
 import { WebSocketProxyClient } from './client.js'
 

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

@@ -0,0 +1,77 @@
+/**
+ * End-to-end sealing for directed messages.
+ *
+ * The proxy routes by public key but does NOT encrypt the payload: `sendByPubkey`
+ * serializes it and sends it as-is. Anything sensitive that travels this way is
+ * readable by whoever runs the proxy — which is exactly what the ecosystem promises
+ * does not happen.
+ *
+ * This is NOT new cryptography. It is `wrapForMember`/`openWrap` from
+ * `@dotrino/identity/content`, the same primitives the vault uses for sealed secrets:
+ * ephemeral ECDH P-256 against the recipient's encryption public key, plus AES-GCM.
+ * Each message carries its own ephemeral key, so there is no shared state to keep.
+ *
+ * `@dotrino/identity` is a PEER dependency on purpose: bundling it here would ship a
+ * second, older copy of a pillar inside every consumer.
+ */
+
+const ECDH = { name: 'ECDH', namedCurve: 'P-256' }
+const VERSION = 1
+
+let primitives = null
+
+async function crypto_ () {
+  if (primitives) return primitives
+  try {
+    primitives = await import('@dotrino/identity/content')
+  } catch (e) {
+    throw new Error(
+      'sealing requires @dotrino/identity (peer dependency) — install it, or pass ' +
+      'your own primitives to setSealingPrimitives()')
+  }
+  return primitives
+}
+
+/** Inject the primitives instead of resolving `@dotrino/identity` (bundlers, tests). */
+export function setSealingPrimitives (mod) {
+  primitives = mod
+}
+
+/** A durable encryption keypair for this device. Its public half goes in the pairing code. */
+export async function makeEncKeypair () {
+  const pair = await globalThis.crypto.subtle.generateKey(ECDH, true, ['deriveBits'])
+  const pub = await globalThis.crypto.subtle.exportKey('jwk', pair.publicKey)
+  return {
+    privateKey: pair.privateKey,
+    publicKey: pair.publicKey,
+    encPub: JSON.stringify({ kty: pub.kty, crv: pub.crv, x: pub.x, y: pub.y }),
+  }
+}
+
+export async function importEncPrivate (jwk) {
+  return globalThis.crypto.subtle.importKey('jwk', jwk, ECDH, true, ['deriveBits'])
+}
+
+export async function exportEncPrivate (privateKey) {
+  return globalThis.crypto.subtle.exportKey('jwk', privateKey)
+}
+
+/** Seal a message towards a peer's encryption public key. */
+export async function seal (message, peerEncPub) {
+  if (!peerEncPub) throw new Error('seal: missing peer encryption key')
+  const { wrapForMember } = await crypto_()
+  const sealed = await wrapForMember({ cek: JSON.stringify(message), memberEncPub: peerEncPub })
+  return { v: VERSION, sealed }
+}
+
+/** Open a message sealed to me. Throws if it is not mine or was tampered with. */
+export async function open (envelope, myEncPrivateKey) {
+  if (!isSealed(envelope)) throw new Error('open: not a sealed envelope')
+  if (!myEncPrivateKey) throw new Error('open: missing my encryption key')
+  const { openWrap } = await crypto_()
+  return JSON.parse(await openWrap({ wrap: envelope.sealed, myEncPrivateKey }))
+}
+
+export function isSealed (msg) {
+  return !!msg && msg.v === VERSION && !!msg.sealed?.ct && !!msg.sealed?.epk
+}

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

@@ -1,17 +1,141 @@
 /**
- * ECDSA P-256 keypair management using SubtleCrypto, persisted in localStorage as JWK.
+ * ECDSA P-256 keypair management using SubtleCrypto.
+ *
+ * Persisted in localStorage as JWK where it exists. Where it does NOT — a service
+ * worker, which is where a browser extension keeps its background logic — the pair
+ * used to be regenerated on every call and never stored, so the identity changed
+ * every time the worker went to sleep. Any peer that knows a device by its public
+ * key would see a stranger each time. IndexedDB is the fallback there: it is
+ * available in workers, and it can store the CryptoKey itself, so the private key
+ * stays non-extractable instead of being written out as a JWK.
+ *
  * Public key in JWK form is what the proxy expects in `channel.data.publickey`.
  */
 import { canonicalStringify } from './canonical.js'
 
 const STORAGE_KEY = 'dotrino.proxy-client.keypair'
+const DB_NAME = 'dotrino.proxy-client'
+const DB_STORE = 'keypair'
 
 let cachedKeypair = null
+let injectedStore = null
+let injectedExtractable = false
+
+/**
+ * Override where the keypair is kept. Takes `{ get(), set(pair) }` handling
+ * `{ privateKey, publicKey, publicJwk }`. Rarely needed: the defaults already cover
+ * pages (localStorage) and workers (IndexedDB).
+ *
+ * `extractable` matters: a store that keeps CryptoKeys as-is (IndexedDB) does not
+ * need it and is safer without, but a store that serializes to disk or to text has
+ * to export the private key as a JWK, and that throws on a non-extractable key. Pass
+ * `{ extractable: true }` for those.
+ */
+export function setKeypairStore (store, { extractable = false } = {}) {
+  injectedStore = store
+  injectedExtractable = !!extractable
+  cachedKeypair = null
+}
+
+function idb () {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(DB_NAME, 1)
+    req.onupgradeneeded = () => {
+      if (!req.result.objectStoreNames.contains(DB_STORE)) req.result.createObjectStore(DB_STORE)
+    }
+    req.onsuccess = () => resolve(req.result)
+    req.onerror = () => reject(req.error)
+  })
+}
+
+function idbRequest (db, mode, fn) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(DB_STORE, mode)
+    const req = fn(tx.objectStore(DB_STORE))
+    req.onsuccess = () => resolve(req.result)
+    req.onerror = () => reject(req.error)
+  })
+}
+
+const indexedDbStore = {
+  async get () {
+    const db = await idb()
+    try { return await idbRequest(db, 'readonly', s => s.get(STORAGE_KEY)) } finally { db.close() }
+  },
+  async set (pair) {
+    const db = await idb()
+    try { await idbRequest(db, 'readwrite', s => s.put(pair, STORAGE_KEY)) } finally { db.close() }
+  },
+}
+
+/**
+ * Is there a WORKING localStorage? Not "is it defined" — Node >= 22 exposes one that
+ * throws unless started with `--localstorage-file`, so checking for existence alone
+ * sends the keypair down a path that fails. Anything headless without a shim would
+ * crash instead of quietly falling back.
+ */
+function localStorageWorks () {
+  try {
+    if (typeof localStorage === 'undefined') return false
+    const probe = STORAGE_KEY + '.probe'
+    localStorage.setItem(probe, '1')
+    localStorage.removeItem(probe)
+    return true
+  } catch (e) {
+    return false
+  }
+}
+
+function fallbackStore () {
+  if (injectedStore) return injectedStore
+  if (!localStorageWorks() && typeof indexedDB !== 'undefined') return indexedDbStore
+  return null
+}
 
 async function loadOrCreate () {
   if (cachedKeypair) return cachedKeypair
 
-  if (typeof localStorage !== 'undefined') {
+  const store = fallbackStore()
+  if (store) {
+    try {
+      const saved = await store.get()
+      if (saved?.privateKey && saved?.publicKey) {
+        cachedKeypair = {
+          privateKey: saved.privateKey,
+          publicKey: saved.publicKey,
+          publicJwk: saved.publicJwk || await crypto.subtle.exportKey('jwk', saved.publicKey),
+        }
+        return cachedKeypair
+      }
+    } catch (e) {
+      // unreadable entry, regenerate below
+    }
+
+    // Non-extractable by default: nothing here needs to export the private key, and
+    // a CryptoKey survives structured clone, so with IndexedDB it never has to leave
+    // as a JWK. A store that serializes has to opt in via `setKeypairStore`.
+    const extractable = store === indexedDbStore ? false : injectedExtractable
+    const pair = await crypto.subtle.generateKey(
+      { name: 'ECDSA', namedCurve: 'P-256' },
+      extractable, ['sign', 'verify']
+    )
+    const publicJwk = await crypto.subtle.exportKey('jwk', pair.publicKey)
+    const entry = { privateKey: pair.privateKey, publicKey: pair.publicKey, publicJwk }
+    try {
+      await store.set(entry)
+    } catch (e) {
+      // Loud on purpose. If this fails the identity is regenerated on every start,
+      // and every peer that knows this device by its public key stops recognising
+      // it — the exact failure this whole path exists to prevent. A silent catch
+      // here means finding out days later, from the other side.
+      console.error('[proxy-client] could not persist the keypair: %s', e?.message || e)
+      console.error('[proxy-client] identity will NOT survive a restart. If the store serializes, pass { extractable: true } to setKeypairStore.')
+    }
+    cachedKeypair = entry
+    return cachedKeypair
+  }
+
+  if (localStorageWorks()) {
     const raw = localStorage.getItem(STORAGE_KEY)
     if (raw) {
       try {
@@ -40,7 +164,7 @@ async function loadOrCreate () {
   )
   const privateJwk = await crypto.subtle.exportKey('jwk', pair.privateKey)
   const publicJwk = await crypto.subtle.exportKey('jwk', pair.publicKey)
-  if (typeof localStorage !== 'undefined') {
+  if (localStorageWorks()) {
     localStorage.setItem(STORAGE_KEY, JSON.stringify({ privateJwk, publicJwk }))
   }
   cachedKeypair = { privateKey: pair.privateKey, publicKey: pair.publicKey, publicJwk }

package/vault/vendor/vault/VERSION.txt

@@ -1,6 +1,5 @@
-Copia vendorizada de @dotrino/vault@0.34.0 (lib/src/{index,enroll,protocol}.js, sin dependencias).
-El iframe de identity se sirve estatico (vanilla, sin build); asi startDeviceVault
-resuelve en el navegador sin bundler. index.js importa ./enroll.js y ./protocol.js
-(relativos, se vendorizan tambien) y @dotrino/identity/capabilities (=../../capabilities.js)
-y @dotrino/proxy-client (=../proxy-client/), ambos via el import map de index.html.
-Re-vendorizar LOS TRES archivos al subir @dotrino/vault.
+Copia vendorizada de @dotrino/vault@0.53.0 (dotrino-vault/lib/src/{index,enroll,protocol}.js).
+NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
+index.js importa ./enroll.js y ./protocol.js (relativos, van en esta misma copia),
+@dotrino/identity/{capabilities,acta} (= ../../{capabilities,acta}.js) y
+@dotrino/proxy-client (= ../proxy-client/), todos por el import map de index.html.

package/vault/vendor/vault/enroll.js

@@ -30,7 +30,7 @@
  * `docs/pairing-protocol.md`).
  */
 import { verifyDeviceSig, pubkeyId, commitCode } from '@dotrino/identity/capabilities'
-import { verifyContinuity } from '@dotrino/identity/acta'
+import { verifyContinuity, canSeal } from '@dotrino/identity/acta'
 
 /** Un token de emparejamiento vale 5 min. */
 export const PAIRING_TTL_MS = 5 * 60 * 1000
@@ -52,7 +52,7 @@ export const MSG_REVOKED = 'vault.revoked'
 export const MSG_ERROR = 'vault.error'
 
 /** Los scopes del cert se corresponden 1:1 con las capacidades del acta (§D7). */
-const SCOPE_TO_CAP = { 'vault:sign': 'sign', 'vault:store': 'store', 'vault:read': 'read', 'vault:admin': 'admin' }
+const SCOPE_TO_CAP = { 'vault:sign': 'sign', 'vault:store': 'store', 'vault:read': 'read', 'vault:admin': 'admin', 'vault:passwords': 'passwords' }
 export const scopeToCaps = (scope) =>
   (Array.isArray(scope) ? scope : [scope]).map((s) => SCOPE_TO_CAP[s]).filter(Boolean)
 
@@ -277,7 +277,12 @@ export function createEnrollDesk ({
       pend.continuity = (okC && d.continuity.member === d.dpub) ? d.continuity : null
     }
     pend.from = from // la bóveda NO conoce el código: lo aprende cuando lo tipeas
-    if (d.label) pend.label = String(d.label).slice(0, 60)
+    // EL NOMBRE QUE PUSISTE AQUÍ MANDA. El aparato manda el suyo al enrolarse, y hasta
+    // ahora pisaba siempre al de la bóveda — como el aparato usa por defecto el apodo del
+    // PERFIL, acababas con varios dispositivos llamados igual que tú y sin forma de saber
+    // cuál era cuál. Si en `pair` le diste un nombre, ese es el nombre; el del aparato
+    // sigue valiendo como propuesta cuando no dijiste nada.
+    if (d.label && !pend.label) pend.label = String(d.label).slice(0, 60)
     // Camino A: de qué cuenta estamos hablando. Se guarda para poder comprobar, cuando
     // llegue el acta sellada, que es la que este dispositivo dijo que iba a entregar.
     if (intent === 'adopt' && typeof d.profileId === 'string') pend.profileId = d.profileId
@@ -359,7 +364,7 @@ export function createEnrollDesk ({
     pend.state = 'DONE'
     pending.delete(pend.token)
     fire(onPendingChange)
-    log('[vault] device approved: %s', pend.deviceId)
+    log(`[vault] device approved: ${pend.deviceId}`)
     return { ok: true, deviceId: pend.deviceId, cert }
   }
 
@@ -383,9 +388,12 @@ export function createEnrollDesk ({
     const pend = [...pending.values()].find((x) => x.state === 'AWAITING_ACTA' && (x.from === from || x.dpub))
     if (!pend) return reply(from, { type: MSG_ERROR, error: 'no adoption awaiting a record' })
     if (!record || typeof record !== 'object') return reply(from, { type: MSG_ERROR, error: 'record missing or unreadable' })
-    if (record.sealer !== iss) {
+    // Ya no hay campo `sealer`: se le pregunta al PERMISO. Es la misma comprobación —«¿me
+    // nombra a mí la que me mandan?»— dicha en el idioma nuevo, y con varios selladores la
+    // respuesta puede ser que sí para más de uno, que es lo correcto.
+    if (!canSeal(record, iss)) {
       audit('rejected', { what: 'adopt', reason: 'not-sealer' })
-      return reply(from, { type: MSG_ERROR, error: 'that record does not name this vault as the sealer' })
+      return reply(from, { type: MSG_ERROR, error: 'that record does not let this vault seal it' })
     }
     if (record.sealedBy !== pend.dpub) {
       audit('rejected', { what: 'adopt', reason: 'sealed-by-other' })

package/vault/vendor/vault/index.js

@@ -26,13 +26,13 @@
  * No reimplementa nada del ecosistema.
  */
 import { verifyChain, verifyDeviceSig } from '@dotrino/identity/capabilities'
+import { memberCanScope, sealersOf, memberScopes } from '@dotrino/identity/acta'
 import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS, FRESH_WINDOW_MS } from './enroll.js'
 // Las constantes del protocolo salen del MISMO módulo que usa el daemon: si la lista
 // local se queda corta, el dispositivo deja de handle mensajes sin que nadie lo note.
 import { MSG, SCOPE } from './protocol.js'
 
 const SIGN_SCOPE = SCOPE.SIGN
-const SELFCERT_TTL_MS = 24 * 60 * 60 * 1000    // el self-cert P←P se regenera cada 24 h
 const RENEW_TTL_MS = DEVICE_TTL_MS             // la renovación extiende la misma ventana (30 días)
 
 /** deviceId legible (p. ej. `C440-AC0E`) desde una pubkey JWK. */
@@ -57,10 +57,24 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
 
   // ----- self-cert P ← P (para que este dispositivo pueda además actuar de cliente
   // de sus propias máquinas: lo firma la propia P y verifyChain lo acepta) -----
+  /**
+   * Con qué se juzga un papel: el acta que tiene esta bóveda. Sustituye a `trustedIssuer`,
+   * que fijaba UNA llave y por eso los papeles de una segunda selladora no valían.
+   * Sin acta van nulos y `verifyDelegation` contesta `no-acta`: no hay con qué decidir, así
+   * que no se decide que sí.
+   */
+  async function contextoActa () {
+    const acta = (await identity.profileActa?.().catch(() => null))?.acta || null
+    if (!acta) return { actaSeq: null, sealers: null }
+    return { actaSeq: acta.seq, sealers: sealersOf(acta) }
+  }
+
   let _selfCert = null
   const getSelfCert = async () => {
-    if (_selfCert && _selfCert.exp > Date.now() + 60_000) return _selfCert
-    const { cert } = await identity.signDelegation(iss, SIGN_SCOPE, { ttlMs: SELFCERT_TTL_MS })
+    // Se rehace cuando el acta cambia, no cuando pasa el tiempo: el papel ya no caduca.
+    const { actaSeq } = await contextoActa()
+    if (_selfCert && _selfCert.seq === actaSeq) return _selfCert
+    const { cert } = await identity.signDelegation(iss, SIGN_SCOPE)
     _selfCert = cert
     return cert
   }
@@ -137,13 +151,20 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
     if (typeof d.ts !== 'number' || Math.abs(Date.now() - d.ts) > FRESH_WINDOW_MS) {
       return send(from, { type: MSG.ERROR, error: 'stale request: ts outside the ±5 min window (possible replay, or the device clock is off)' })
     }
-    const chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, trustedIssuer: iss, revoked: await revocationSet() })
+    const chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, ...(await contextoActa()), revoked: await revocationSet() })
     if (!chk.ok) return send(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
     // Reusar el label del cert original (si sigue registrado en delegations).
     const { issued } = await identity.listDelegations()
     const prev = (issued || []).find((x) => x.nonce === p.cert.nonce)
-    const { cert } = await identity.signDelegation(p.cert.sub, p.cert.scope, { ttlMs: RENEW_TTL_MS, label: prev?.label || '' })
-    send(from, { type: MSG.RENEWED, cert })
+    // EL SCOPE SALE DEL ACTA, no del papel viejo: el papel dice a qué se comprometió esta
+    // bóveda al conectar el aparato; el acta, lo que puede HOY.
+    const acta = (await identity.profileActa?.().catch(() => null))?.acta || null
+    if (!acta) return send(from, { type: MSG.ERROR, error: 'unauthorized: this vault has no record to decide with' })
+    const scope = memberScopes(acta, p.cert.sub)
+    if (!scope.length) return send(from, { type: MSG.ERROR, error: 'unauthorized: the record no longer lists this device' })
+    const { cert } = await identity.signDelegation(p.cert.sub, scope, { label: prev?.label || '' })
+    // El acta viaja con el papel: sin ella quien lo recibe no puede comprobar quién lo firmó.
+    send(from, { type: MSG.RENEWED, cert, acta })
   }
 
   // Consulta de revocaciones (igual que `vault.devices` del daemon): responde la lista
@@ -153,12 +174,12 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
     const d = p?.data
     if (!d || !p.signature || !p.cert) return send(from, { type: MSG.ERROR, error: 'invalid request' })
     if (typeof d.ts !== 'number' || Math.abs(Date.now() - d.ts) > FRESH_WINDOW_MS) return
-    const chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, trustedIssuer: iss })
+    const chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, ...(await contextoActa()) })
     if (!chk.ok) return send(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
     const { issued, revoked, revokedCerts } = await identity.listDelegations()
     const devices = await Promise.all((issued || []).map(async (x) => ({
       deviceId: x.sub ? await deviceIdOf(x.sub) : null, sub: x.sub || null,
-      label: x.label || '', scope: x.scope, exp: x.exp, nonce: x.nonce
+      label: x.label || '', scope: x.scope, seq: x.seq, nonce: x.nonce
     })))
     send(from, { type: MSG.DEVICES_RESULT, devices, revoked: (revoked || []).map((r) => r.nonce || r) })
     // ¿el que consulta es una máquina revocada que reapareció? → re-emite el REVOKED firmado.
@@ -188,12 +209,23 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
     const chk = await verifyChain({
       data: d, signature: p.signature, cert: p.cert,
       ...(expectedScope ? { expectedScope } : {}),
-      trustedIssuer: iss, revoked: await revocationSet(),
+      ...(await contextoActa()), revoked: await revocationSet(),
     })
     if (!chk.ok) {
       send(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
       return null
     }
+    // EL ACTA MANDA, EL PAPEL SOLO ACOMPAÑA. Aquí y no en cada mostrador: el certificado
+    // dice a qué se comprometió esta bóveda al conectar el aparato, y el acta lo que puede
+    // HOY. Quitarle un permiso sella el acta pero no le retira el papel, que vive hasta 30
+    // días, así que sin esto seguiría entrando hasta que lo renovara.
+    if (expectedScope) {
+      const record = (await identity.profileActa?.().catch(() => null))?.acta || null
+      if (record && !memberCanScope(record, chk.device, expectedScope)) {
+        send(from, { type: MSG.ERROR, error: 'unauthorized: acta — this member no longer has that permission' })
+        return null
+      }
+    }
     return chk
   }
 
@@ -302,13 +334,14 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
    */
   async function listMachines () {
     const { issued } = await identity.listDelegations()
-    const now = Date.now()
     const bySub = new Map()
     for (const x of (issued || [])) {
-      if (!x.sub || x.revokedAt || (x.exp && x.exp <= now)) continue // revocada = fuera de la lista
+      if (!x.sub || x.revokedAt) continue                       // revocada = fuera de la lista
       if (!Array.isArray(x.scope) || !x.scope.includes(SIGN_SCOPE)) continue
       if (!x.label || x.label === 'cli') continue
-      if (!bySub.has(x.sub) || (x.exp || 0) > (bySub.get(x.sub).exp || 0)) bySub.set(x.sub, x)
+      // Se queda el papel del acta MÁS NUEVA de esa llave: ya no hay «el que vence más
+      // tarde», porque ninguno vence.
+      if (!bySub.has(x.sub) || (x.seq || 0) > (bySub.get(x.sub).seq || 0)) bySub.set(x.sub, x)
     }
     return Promise.all([...bySub.values()].map(async (x) => ({ ...x, deviceId: await deviceIdOf(x.sub) })))
   }

package/vault/vendor/vault/protocol.js

@@ -86,6 +86,10 @@ export const MSG = Object.freeze({
   // contrapartida de administrar a distancia: sin esto, un enrolamiento remoto sería
   // invisible para el resto de tus dispositivos.
   ADMIN_EVENT: 'vault.admin.event',           // vault → todos: { body:{ev,deviceId,by,ts}, signature }
+  // RÉPLICAS: la principal empuja lo que hay que servir (el acta y los sobres, que van
+  // firmados de antes y no se pueden falsificar) y la réplica acusa hasta qué `seq` tiene.
+  REPLICA_PUSH: 'vault.replica.push',         // master → réplica: { body:{seq,acta,secrets,ts}, signature }
+  REPLICA_ACK: 'vault.replica.ack',           // réplica → master: { body:{seq,ts}, signature }
   ERROR: 'vault.error'                        // vault → dispositivo: { error }
 })
 
@@ -98,7 +102,15 @@ export const SCOPE = Object.freeze({
   // NO incluye cambiar permisos, traspasar el mando ni conceder `admin`: eso es el rol
   // de master y sigue siendo local. No se empareja — se concede desde el PC.
   ADMIN: 'vault:admin',
-  APPROVE: 'vault:approve' // aprobar pedidos de secretos (cajones con `approval`); se concede a mano, como admin
+  APPROVE: 'vault:approve', // aprobar pedidos de secretos (cajones con `approval`); se concede a mano, como admin
+  // El gestor de contraseñas: pedir credenciales de la bóveda, de a una y por dominio.
+  // Nunca lista la bóveda entera. Este SÍ se empareja (`pair --scope contrasenas`): es
+  // lo primero que hace la extensión, y no tendría sentido obligar a un segundo paso.
+  PASSWORDS: 'vault:passwords',
+  // SELLAR EL ACTA: la OTRA bóveda de esta cuenta. Con esto puede admitir aparatos y
+  // cambiar permisos si la principal se pierde — que es todo el punto del multivault. Como
+  // `admin`, no se empareja: se concede a mano (`caps <ID> +sella`).
+  SEALER: 'vault:sealer'
 })
 
 /**