@dotrino/identity 0.115.0 → 0.116.0

package/vault/remote.js

@@ -281,11 +281,53 @@ function vaultError (p) {
   return e
 }
 
-async function vaultRpc ({ master, proxy, device, cert, acta = null, sendType, okType, data, onRevoked, timeoutMs = 15000 }) {
-  if (!master || !proxy || !(device?.privateJwk || device?.privateKey || typeof device?.sign === 'function') || !cert) throw new Error('missing pairing data')
+/**
+ * LA BÓVEDA DE ESTE MISMO NAVEGADOR, sin dar la vuelta por el proxio.
+ *
+ * Cuando esta pestaña o esta extensión ES la bóveda (`@dotrino/vault`, `startBrowserVault`),
+ * lo que el aparato le pide a su bóveda —administrar, aprobar, firmar— va directo al núcleo
+ * que corre aquí. Es el mostrador local del binario en el navegador: el MISMO protocolo, la
+ * misma firma y el mismo certificado, comprobados igual. Alcanzar el atajo no autoriza nada.
+ *
+ * `open(onReply)` → `{ send(payload), close() }`. Lo registra quien levanta la bóveda.
+ */
+const localVaults = new Map()
+export function registerLocalVault (master, open) {
+  if (typeof master !== 'string' || typeof open !== 'function') throw new Error('registerLocalVault: master and open are required')
+  localVaults.set(master, open)
+  return () => { if (localVaults.get(master) === open) localVaults.delete(master) }
+}
+
+/** Un cliente con la forma del del proxio que habla con la bóveda local. */
+function localClient (open) {
+  const handlers = new Set()
+  const chan = open((reply) => { for (const h of [...handlers]) { try { h('local', reply) } catch (_) {} } })
+  return {
+    connect: async () => {},
+    identifyAs: async () => {},
+    on (ev, fn) {
+      if (ev !== 'message') return () => {}
+      handlers.add(fn)
+      return () => handlers.delete(fn)
+    },
+    sendByPubkey (_to, payload) { chan.send(payload) },
+    close () { handlers.clear(); chan.close() }
+  }
+}
+
+/** El cliente para hablar con `master`: el local si esa bóveda corre aquí, y si no el del proxio. */
+async function clientFor (proxy, master) {
+  const open = master ? localVaults.get(master) : null
+  if (open) return localClient(open)
   const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
   const client = new WebSocketProxyClient({ url: proxy, enableWebRTC: false, autoReconnect: false })
   await client.connect()
+  return client
+}
+
+async function vaultRpc ({ master, proxy, device, cert, acta = null, sendType, okType, data, onRevoked, timeoutMs = 15000 }) {
+  if (!master || !proxy || !(device?.privateJwk || device?.privateKey || typeof device?.sign === 'function') || !cert) throw new Error('missing pairing data')
+  const client = await clientFor(proxy, master)
   try {
     try { await identifyAsDevice(client, device, { cert, acta }) } catch (_) { /* sin identify seguimos: solo perdemos la cola */ }
     const signed = { ...data, publickey: device.publickey, ts: Date.now(), ...(cleanMachine(device.machine) ? { machine: cleanMachine(device.machine) } : {}) }
@@ -336,9 +378,7 @@ async function vaultRpc ({ master, proxy, device, cert, acta = null, sendType, o
  */
 export async function checkMembership ({ master, proxy, device, onRevoked, timeoutMs = 12000 } = {}) {
   if (!master || !proxy || !(device?.privateJwk || device?.privateKey || typeof device?.sign === 'function')) throw new Error('missing device data')
-  const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
-  const client = new WebSocketProxyClient({ url: proxy, enableWebRTC: false, autoReconnect: false })
-  await client.connect()
+  const client = await clientFor(proxy, master)
   try {
     // Identificarse hace además que el proxy entregue lo ENCOLADO (un aviso de cuando
     // estaba apagado, si todavía está dentro de las 24 h).

package/vault/vault.js

@@ -185,9 +185,9 @@ import { useBackend as usePeerBackend } from './peerStore.js'
   core.onSyncStatus((p) => broadcast('sync', p))
   core.onVaultEvent((p) => broadcast('vault', p))
 
-  // ---- Modo SELF: este navegador actúa como bóveda (daemon device-vault) ----
-  // startDeviceVault convierte la identidad P en CA: atiende enrolamientos y consultas
-  // de revocación por el proxy. Solo UN iframe por origin es el daemon activo
+  // ---- Modo SELF: este navegador actúa como bóveda ----
+  // Corre la MISMA bóveda que el binario (`startBrowserVault`): emparejar, firmar, cajones,
+  // aprobaciones, consola remota, inicios de sesión. Solo UN iframe por origin es el activo
   // (navigator.locks): la pestaña VISIBLE sostiene el lock; al pasar a background lo
   // libera y otra pestaña visible lo toma. Así varias apps abiertas no compiten.
   const SELF_FLAG = 'dotrino.self-vault.enabled' // persistido en localStorage (kv)
@@ -208,79 +208,47 @@ import { useBackend as usePeerBackend } from './peerStore.js'
       return /^wss?:\/\//.test(p || '') ? p : null
     } catch (_) { return null }
   })()
-  let daemon = null           // handle de startDeviceVault cuando ESTE iframe es el activo
+  let daemon = null           // la bóveda (`startBrowserVault`) cuando ESTE iframe es el activo
   let _lockResolver = null    // resolver del callback del lock (libera al resolverlo)
 
-  // Adaptador: startDeviceVault exige identity.{me.publickey, signData, signDelegation,
-  // listDelegations, revokeDelegation}; el core los expone vía handlers + getter me.
-  // `admitMember`/`profileActa` son opcionales para el mostrador de enrolamiento, pero sin
-  // ellos aprobar emitiría el cert SIN meter al dispositivo en el acta: se pasan también.
-  const selfIdentity = {
-    get me () { return core.me },
-    signData: (data) => handlers.signData({ data }),
-    signDelegation: (sub, scope, opts) => handlers.signDelegation({ sub, scope, ...(opts || {}) }),
-    listDelegations: () => handlers.listDelegations({}),
-    revokeDelegation: (nonce) => handlers.revokeDelegation({ nonce }),
-    revokeDevice: (sub) => handlers.revokeDevice({ sub }),
-    admitMember: (m) => handlers.admitMember(m),
-    profileActa: () => handlers.profileActa({}),
-    // Camino A (`mode: 'adopt'`): la bóveda se queda con la cuenta que trae el aparato,
-    // y para eso tiene que poder ENTRAR en su acta. Sin esto, adoptar fallaba con un
-    // «no es una función» en vez de con un error del protocolo.
-    joinProfile: (acta) => handlers.joinProfile({ acta })
-  }
+  // La dirección `nombre@AB12-CD34-EF56` sale del acta de la cuenta.
+  const selfIdentity = { profileActa: () => handlers.profileActa({}) }
 
   /**
-   * EL ESCRITORIO DE LOS INICIOS DE SESIÓN CON CONTRASEÑA, con el almacén de este navegador.
-   *
-   * La bóveda no decide dónde se guarda nada: en el navegador no hay archivos, así que el
-   * estado lo pone quien la monta —esto—. Sin escritorio la pestaña contesta
-   * `logins-unavailable`, que es distinto de «contraseña incorrecta» y por eso se ve.
-   *
-   * Cuelga del PERFIL ACTIVO: los inicios de sesión son de una cuenta, no de este
-   * navegador, y dos cuentas en el mismo equipo no comparten usuarios.
-   *
-   * Se carga solo aquí, y no arriba, porque arrastra el OPAQUE en WASM (~270 KB): el
-   * iframe lo cargan las ~30 apps del ecosistema y solo esta pestaña es bóveda.
-   *
-   * Lo que guarda aguanta lo mismo que el disco del daemon: con una copia de este
-   * `localStorage` se pueden probar contraseñas sin límite contra el registro de OPAQUE.
-   * Lo único que aguanta ahí es que la contraseña sea larga (`temporary-access.md` §4).
+   * LOS INICIOS DE SESIÓN QUE ESTA PESTAÑA GUARDABA ANTES de correr la bóveda entera. Ahora
+   * viven en el almacén de la bóveda (IndexedDB cifrado, uno por perfil); lo de antes se le
+   * pasa una vez y se borra de aquí. Si está y no parsea, REVIENTA a propósito: tomarlo por
+   * vacío perdería los inicios de sesión de la cuenta sin que nadie se enterara.
    */
-  async function makeLoginDesk () {
-    const { createLoginDesk } = await import('@dotrino/vault/password-logins')
+  async function legacyLogins () {
     const { id: pid } = await handlers.currentProfile()
-    if (!pid) throw new Error('no profile: password logins belong to an account')
+    if (!pid) return null
     const key = `dotrino.identity.p.${pid}.self-vault.logins`
-    return createLoginDesk({
-      load: () => {
-        const raw = kv.getItem(key)
-        // Si está y no parsea, REVIENTA aquí a propósito: devolver `null` haría nacer el
-        // escritorio vacío, y el primer guardado se llevaría por delante todos los inicios
-        // de sesión de esta cuenta sin que nadie se enterara.
-        return raw ? JSON.parse(raw) : null
-      },
-      save: (s) => kv.setItem(key, JSON.stringify(s))
-    })
+    const raw = kv.getItem(key)
+    if (!raw) return null
+    return { state: JSON.parse(raw), drop: () => kv.removeItem(key) }
   }
 
   async function startSelfDaemon () {
     if (daemon) return
     try {
-      // Import dinámico: aísla fallos del vendor del arranque del vault (cargado por
-      // todas las apps). El import map de index.html resuelve @dotrino/vault.
-      const { startDeviceVault } = await import('@dotrino/vault')
-      daemon = await startDeviceVault(selfIdentity, {
+      // LA MISMA BÓVEDA QUE EL BINARIO (`@dotrino/vault/browser`): el núcleo entero, con el
+      // disco en IndexedDB. Import dinámico: el iframe lo cargan las ~30 apps y solo esta
+      // pestaña es bóveda; además aísla un fallo del vendor del arranque de la identidad.
+      const { startBrowserVault } = await import('@dotrino/vault/browser')
+      daemon = await startBrowserVault({
+        core,
         ...(selfProxyUrl ? { proxyUrl: selfProxyUrl } : {}),
-        logins: await makeLoginDesk()
+        legacyLogins,
+        onPendingChange: () => broadcast('selfVault', { pending: daemon ? daemon.listPending() : [] }),
+        log: (...a) => console.log(...a)
       })
-      daemon.onPendingChange(() => broadcast('selfVault', { pending: daemon.listPending() }))
       broadcast('selfVault', { running: true })
     } catch (e) { daemon = null; broadcast('selfVault', { error: e?.message || String(e) }) }
   }
   function stopSelfDaemon () {
     if (!daemon) return
-    try { daemon.close() } catch {}
+    try { daemon.close()?.catch?.(() => {}) } catch {}
     daemon = null
     broadcast('selfVault', { running: false })
   }
@@ -340,6 +308,9 @@ import { useBackend as usePeerBackend } from './peerStore.js'
     // agentes siempre, sin depender de qué pestaña sostenga el lock del daemon.
     listVaultDevices: async () => {
       if (kv.getItem(SELF_FLAG) !== '1') return handlers.listVaultDevices({})
+      // Con la bóveda encendida en ESTA pestaña, la lista sale de ella (por el camino
+      // local): trae lo mismo que la del binario. Sin ella encendida, se lee lo guardado.
+      if (daemon) return handlers.listVaultDevices({})
       const { issued, revoked } = await handlers.listDelegations({})
       const now = Date.now()
       const bySub = new Map()
@@ -491,7 +462,7 @@ import { useBackend as usePeerBackend } from './peerStore.js'
     selfVaultLoginRemove: async ({ user } = {}) => {
       const d = pidaDaemon()
       const fila = d.listLogins().find((x) => x.user === user)
-      const r = d.removeLogin({ user })
+      const r = await d.removeLogin({ user })
       if (r?.ok && fila?.pub) {
         try { await handlers.revokeDevice({ sub: fila.pub }) } catch (e) {
           throw Object.assign(new Error(`the login is gone but its key is still in the record: ${e.message}`), { code: 'revoke-failed' })

package/vault/vendor/compat/VERSION.txt

@@ -0,0 +1,3 @@
+Copia vendorizada de @dotrino/compat@0.4.0 (dotrino-compat/src/{advisory,index,ranges}.js).
+NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
+Qué versión es cada pieza y si pueden hablar (CONVENCIONES §14).

package/vault/vendor/compat/advisory.js

@@ -0,0 +1,141 @@
+/**
+ * advisory.js — EL AVISO A LA RED: «actualiza estos componentes».
+ *
+ * Punto 3 del dueño (2026-09-04): *«como desarrolladores vemos que una versión falla o es
+ * incompatible con otra, tenemos un método de avisar a la red que debe actualizar tales o
+ * tales componentes»*.
+ *
+ * QUIÉN LO FIRMA, y esto es lo que lo ordena todo: **los que desarrollan**. La
+ * compatibilidad es política del CÓDIGO, no de la cuenta (decidido el mismo día), así que
+ * el ancla de confianza —la pública que valida el aviso— **viaja dentro de la build**. No
+ * hay lista de confianza que se pueda cambiar a distancia: para cambiar en quién confías
+ * hay que instalar otra versión, que es exactamente lo que significa «política del código».
+ *
+ * CÓMO VIAJA: por la red que ya existe, de boca en boca. Cada pieza le pasa a la siguiente
+ * el aviso más nuevo que tenga. **No hay servidor de avisos ni consulta a Dotrino**: nadie
+ * llama a casa, nada depende de que un servicio nuestro esté encendido, y no hay un sitio
+ * donde se vea quién tiene qué versión.
+ *
+ * LO QUE ESTO ES, dicho sin adornos: un aviso firmado por nosotros puede dejar sin trabajar
+ * a una versión instalada en la máquina de otro. Es lo que se pidió y es el precio de que
+ * un fallo detectado hoy frene hoy. Lo que lo acota:
+ *
+ *   · **Solo hacia adelante** (`seq`): un aviso viejo no se puede reproducir para deshacer
+ *     uno nuevo.
+ *   · **Un aviso nuevo REEMPLAZA la lista entera**, así que un aviso equivocado se corrige
+ *     con otro aviso. Si solo pudiera sumar, una equivocación sería para siempre.
+ *   · **No concede nada.** Lo que la build trae marcado como roto sigue roto aunque el
+ *     aviso no lo mencione: quitar por la red lo que el código afirma sería justo el
+ *     agujero (`CLAUDE.md`, «nada de repliegues»).
+ *   · **Se ve.** El administrador enseña el aviso y su fecha. Un freno que no se explica
+ *     es otro silencio, que es de lo que venimos huyendo.
+ */
+
+/**
+ * JSON canónico (claves ordenadas, recursivo). Es una COPIA deliberada del de
+ * `@dotrino/proxy-client`: este paquete no depende de nadie —lo importan las ~30 apps y el
+ * proxio— y la firma tiene que dar los mismos bytes en las dos puntas. Si algún día
+ * cambian, cambian los dos: hay un test que compara la salida contra la del pilar.
+ */
+export function canonicalStringify (value) {
+  if (value === null || typeof value !== 'object') return JSON.stringify(value)
+  if (Array.isArray(value)) return '[' + value.map(canonicalStringify).join(',') + ']'
+  const keys = Object.keys(value).sort()
+  return '{' + keys.map((k) => JSON.stringify(k) + ':' + canonicalStringify(value[k])).join(',') + '}'
+}
+
+const enc = (s) => new TextEncoder().encode(s)
+const b64 = (buf) => {
+  const b = new Uint8Array(buf)
+  let s = ''
+  for (let i = 0; i < b.length; i++) s += String.fromCharCode(b[i])
+  return btoa(s)
+}
+const fromB64 = (str) => {
+  const bin = atob(str)
+  const out = new Uint8Array(bin.length)
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i)
+  return out
+}
+
+/** El cuerpo que se firma: todo menos la firma. */
+export const advisoryBody = (a) => {
+  const { sig, ...body } = a || {}
+  return body
+}
+
+/** ¿Tiene forma de aviso? No dice si es de fiar, solo si se puede juzgar. */
+export function isAdvisory (a) {
+  return !!a && a.op === 'compat.advisory' && Number.isInteger(a.seq) && a.seq >= 0 &&
+    typeof a.issued === 'number' && Array.isArray(a.broken) && typeof a.sig === 'string' &&
+    a.broken.every((b) => b && typeof b.product === 'string' && Array.isArray(b.versions) &&
+      b.versions.every((v) => typeof v === 'string'))
+}
+
+/**
+ * FIRMA un aviso. Lo corre quien publica, no quien lo recibe: aquí está para que el
+ * formato lo defina un solo sitio y no dos implementaciones que se separan.
+ */
+export async function signAdvisory ({ seq, broken, privateJwk, issued = Date.now() }) {
+  const body = { op: 'compat.advisory', seq, issued, broken }
+  const key = await globalThis.crypto.subtle.importKey(
+    'jwk', privateJwk, { name: 'ECDSA', namedCurve: 'P-256' }, false, ['sign'])
+  const sig = await globalThis.crypto.subtle.sign(
+    { name: 'ECDSA', hash: 'SHA-256' }, key, enc(canonicalStringify(body)))
+  return { ...body, sig: b64(sig) }
+}
+
+/**
+ * ¿Lo firmó la llave de release que trae MI build? `publickey` es un JWK en texto, igual
+ * que en el resto del ecosistema.
+ */
+export async function verifyAdvisory ({ advisory, publickey }) {
+  if (!isAdvisory(advisory) || typeof publickey !== 'string') return false
+  try {
+    const key = await globalThis.crypto.subtle.importKey(
+      'jwk', JSON.parse(publickey), { name: 'ECDSA', namedCurve: 'P-256' }, false, ['verify'])
+    return await globalThis.crypto.subtle.verify(
+      { name: 'ECDSA', hash: 'SHA-256' }, key, fromB64(advisory.sig),
+      enc(canonicalStringify(advisoryBody(advisory))))
+  } catch (_) { return false }
+}
+
+/**
+ * ¿ME QUEDO CON EL QUE LLEGA? Solo hacia adelante y solo si lo firma quien yo digo.
+ * Devuelve el aviso vigente (el nuevo o el que ya tenía) y por qué.
+ */
+export async function adoptAdvisory ({ current, incoming, publickey }) {
+  if (!isAdvisory(incoming)) return { advisory: current || null, adopted: false, reason: 'no-es-un-aviso' }
+  if (current && incoming.seq <= current.seq) {
+    return { advisory: current, adopted: false, reason: 'no-es-mas-nuevo' }
+  }
+  if (!(await verifyAdvisory({ advisory: incoming, publickey }))) {
+    return { advisory: current || null, adopted: false, reason: 'firma-invalida' }
+  }
+  return { advisory: incoming, adopted: true, reason: current ? 'mas-nuevo' : 'primero' }
+}
+
+/**
+ * LA LISTA DE ROTAS QUE VALE HOY: la del código MÁS la del aviso.
+ *
+ * Se suman, no se sustituyen: el aviso puede añadir lo que se descubrió después de esta
+ * build, pero **no puede quitar** lo que esta build ya afirma. Que la red pudiera
+ * desmarcar algo que el código da por roto sería el repliegue de manual.
+ */
+export function brokenNow ({ baked = [], advisory = null } = {}) {
+  return advisory && isAdvisory(advisory) ? [...baked, ...advisory.broken] : [...baked]
+}
+
+/** Lo que el administrador enseña del aviso vigente (§14: se ve, no se esconde). */
+export function advisorySummary (advisory) {
+  if (!isAdvisory(advisory)) return null
+  return {
+    seq: advisory.seq,
+    issued: advisory.issued,
+    components: advisory.broken.map((b) => ({
+      product: b.product, versions: b.versions, why: b.why || null, fix: b.fix || null
+    }))
+  }
+}
+
+export default { signAdvisory, verifyAdvisory, adoptAdvisory, brokenNow, isAdvisory, advisoryBody, advisorySummary, canonicalStringify }

package/vault/vendor/compat/index.js

@@ -0,0 +1,188 @@
+/**
+ * @dotrino/compat — QUÉ VERSIÓN ERES, Y SI PODEMOS TRABAJAR.
+ *
+ * EL PROBLEMA QUE VIENE A RESOLVER, dicho con los tres casos que costaron días:
+ *
+ *   · El apagón del 1-2 de septiembre: endurecer la bóveda dejó mudos a `content`, a los
+ *     selladores y al bot social durante un día entero. Ningún fallo era un error: eran
+ *     reintentos cada 60 segundos contra alguien que ya no les entendía.
+ *   · `@dotrino/env` pedía `^0.33.2` con la librería en 0.60: enrolar contestaba
+ *     `invalid cert: no-acta`, que es verdad y no es la causa. La causa era la versión.
+ *   · La bóveda se quedó MUDA tres días porque su respuesta pasaba el tope del proxio: el
+ *     socket moría con un 1009 y no lo decía nadie.
+ *
+ * Los tres son el mismo fallo: **una incompatibilidad se manifiesta como SILENCIO**. El
+ * que llama no sabe si el otro está apagado, ocupado o hablando otro idioma, así que
+ * reintenta para siempre — y el que atiende no sabe que le están hablando.
+ *
+ * Aquí no hay red, ni disco, ni cripto: son funciones puras. Decidir es de este módulo;
+ * anunciar y refunfuñar es de quien lo usa. Y por eso no tiene dependencias — lo importan
+ * los ~30 PWA, los daemons y el proxio, y un pilar dentro de otro se cuela anidado a cada
+ * consumidor (ver `PENDIENTES.md`, «pilar anidado»).
+ */
+
+/** Lo que responde `check`. El `code` es lo que se compara; el texto puede cambiar. */
+import { satisfies } from './ranges.js'
+
+export const OK = 'ok'
+export const INCOMPATIBLE_PROTOCOL = 'incompatible-protocol'
+export const BROKEN_PEER = 'broken-peer'
+export const UNDECLARED = 'undeclared'
+
+/**
+ * ESTO INFORMA, NO BLOQUEA (dueño, 2026-09-04, corrigiendo el punto 3 del mismo día:
+ * *«quizás el aviso de incompatibilidad no debería ser bloqueante, pero sí visible»*).
+ *
+ * Y es mejor diseño, por cuatro razones que conviene tener escritas para no volver atrás:
+ *
+ *   · **No hay interruptor remoto.** Un aviso que solo informa se puede firmar y repartir
+ *     sin que nadie pueda dejar a otro sin bóveda desde fuera.
+ *   · **No hay trampa de orden.** Si bloqueara, el día que una pieza empieza a comprobar
+ *     dejaría de hablar con todas las que aún no anuncian: habría que desplegar en un orden
+ *     exacto. Informando se enciende donde sea y cuando sea.
+ *   · **Falla del lado seguro.** Bloquear es código nuevo decidiendo si algo funciona: un
+ *     rango mal escrito o una errata en un manifiesto pasaría de aviso falso a caída real.
+ *   · **Es lo que dicen los tres incidentes.** En el apagón del 1-2 de septiembre, en el
+ *     `^0.33.2` y en la bóveda muda, lo que faltó fue ENTERARSE, no parar. Parar no habría
+ *     arreglado ninguno.
+ *
+ * Lo que se pierde y se dice: un par realmente incompatible sigue medio funcionando. Pero
+ * medio funcionando **con un cartel que explica por qué** es otra cosa — y lo que no cuadra
+ * falla solo, con el aviso pegado al error (`annotate`).
+ *
+ * Quien consuma esto **no debe** convertir un `compatible: false` en un «no atiendo». Si
+ * algún día se decide bloquear, se decide arriba y se escribe allí, no aquí.
+ */
+
+/** ¿Tiene forma de anuncio? No dice si es compatible, solo si se puede juzgar. */
+export function isDeclaration (d) {
+  return !!d && typeof d.product === 'string' && d.product.length > 0 &&
+    typeof d.version === 'string' && d.version.length > 0 &&
+    Number.isInteger(d.protocol) &&
+    Array.isArray(d.speaks) && d.speaks.length > 0 && d.speaks.every(Number.isInteger)
+}
+
+/** Lo que se pone en el sobre firmado de `identify`. Corto, porque viaja en cada conexión. */
+export function declare ({ product, version, protocol, speaks }) {
+  if (!Number.isInteger(protocol)) throw new Error('compat: protocol must be an integer')
+  const habla = speaks && speaks.length ? [...new Set(speaks)].sort((a, b) => a - b) : [protocol]
+  if (!habla.includes(protocol)) throw new Error('compat: speaks must include protocol')
+  const d = { product: String(product), version: String(version), protocol, speaks: habla }
+  if (!isDeclaration(d)) throw new Error('compat: incomplete declaration')
+  return d
+}
+
+/**
+ * ¿ESTE PAR ESTÁ EN LA LISTA DE ROTAS?
+ *
+ * `versions` acepta lo mismo que un rango del manifiesto (`ranges.js`): una versión
+ * exacta, un `>=`, un intervalo `a - b`, o una lista que es un O. El dueño pidió rangos
+ * para los manifiestos (2026-09-04) y aquí se usa el MISMO comparador, no otro: dos formas
+ * de decir «esta versión entra» acaban discrepando, y esa discrepancia no hace ruido.
+ *
+ * Lo que no se entiende no coincide — no marca roto y tampoco absuelve: solo no dice nada.
+ */
+export function isBroken (lista, { product, version }) {
+  for (const b of lista || []) {
+    if (b?.product !== product) continue
+    if (satisfies(version, b.versions)) return b
+  }
+  return null
+}
+
+/**
+ * ¿ESTA PAREJA CUADRA?
+ *
+ * Devuelve un DICTAMEN, no un permiso: `compatible` dice si cuadran, y nadie debe usarlo
+ * para dejar de atender (ver arriba). Se enseña, se registra y se le pega a los errores.
+ *
+ * **JUZGA EL QUE ENTRA** (dueño, 2026-09-04): *«el que define si es compatible o no es la
+ * versión que entra, ya que la versión antigua de un producto no tiene idea con qué es o no
+ * compatible»*. Exacto: una build de hace tres meses no sabe nada de lo que vino después.
+ * Así que esto NO es simétrico — miro si YO te entiendo y si TÚ estás en mi lista de rotas;
+ * lo que tú creas de mí no entra en la cuenta.
+ *
+ * Y de ahí sale por qué avisar es la otra mitad: si el viejo no puede juzgar, tampoco puede
+ * enterarse solo. El que ve la incompatibilidad es el único que puede decírselo.
+ *
+ * @param {object} o.mine     mi declaración
+ * @param {object} o.theirs   la del otro (o null si no dijo nada)
+ * @param {Array}  [o.broken] mi lista de rotas (la del código más la del aviso de la red)
+ * @returns {{compatible:boolean, code:string, reason:string, peer:object|null}}
+ */
+export function check ({ mine, theirs, broken = [] } = {}) {
+  if (!isDeclaration(mine)) throw new Error('compat: my own declaration is not valid')
+
+  if (!isDeclaration(theirs)) {
+    return {
+      compatible: false,
+      code: UNDECLARED,
+      peer: null,
+      reason: 'the other side does not say what it is or which version it runs'
+    }
+  }
+
+  const roto = isBroken(broken, theirs)
+  if (roto) {
+    return {
+      compatible: false,
+      code: BROKEN_PEER,
+      peer: theirs,
+      reason: `${theirs.product} ${theirs.version} is known to be broken: ${roto.why || 'no reason recorded'}` +
+        (roto.fix ? ` — ${roto.fix}` : '')
+    }
+  }
+
+  if (!mine.speaks.includes(theirs.protocol)) {
+    return {
+      compatible: false,
+      code: INCOMPATIBLE_PROTOCOL,
+      peer: theirs,
+      reason: `${mine.product} ${mine.version} speaks protocol ${mine.speaks.join(', ')} and ` +
+        `${theirs.product} ${theirs.version} speaks ${theirs.protocol}: update ${theirs.product}`
+    }
+  }
+
+  return { compatible: true, code: OK, peer: theirs, reason: '' }
+}
+
+/**
+ * PEGA EL AVISO AL ERROR QUE YA OCURRE, y esto es lo que de verdad ahorra el día perdido.
+ *
+ * El caso real: `@dotrino/env` pedía `^0.33.2` con la librería en 0.60, y enrolar contestaba
+ * `invalid cert: no-acta`. Es verdad y no es la causa — la causa era la versión, y encontrarlo
+ * costó horas. Con esto el mismo error sale:
+ *
+ *   invalid cert: no-acta — heads up: vault 0.33.2 against vaultd 0.106.2 …
+ *
+ * El mensaje original no se toca: se le añade detrás. Nadie que empareje por texto se rompe
+ * si compara por prefijo, y quien compare por `code` no se entera (ver «los errores son un
+ * contrato»).
+ */
+export function annotate (message, verdict) {
+  if (!verdict || verdict.compatible !== false) return message
+  return `${message} — heads up: ${verdict.reason}`
+}
+
+/**
+ * EL AVISO QUE SE MANDA CUANDO NO SE PUEDE TRABAJAR (punto 3 del dueño: «se comunican,
+ * pero solo para alertar la incompatibilidad»).
+ *
+ * Lleva las dos declaraciones porque el que lo recibe suele ser el que NO sabe que está
+ * roto —es el viejo—, así que hay que decirle qué es él, qué somos nosotros y qué hacer.
+ * Sin esto el rechazo sería otro silencio, que es de lo que venimos huyendo.
+ */
+export function incompatibleNotice ({ mine, theirs, verdict }) {
+  return {
+    op: 'incompatible',
+    code: verdict.code,
+    reason: verdict.reason,
+    mine: { product: mine.product, version: mine.version, protocol: mine.protocol, speaks: mine.speaks },
+    yours: theirs && isDeclaration(theirs)
+      ? { product: theirs.product, version: theirs.version, protocol: theirs.protocol }
+      : null,
+    fix: 'update the older side; nothing here will work until the two versions match'
+  }
+}
+
+export default { declare, check, isBroken, isDeclaration, incompatibleNotice, annotate, OK, INCOMPATIBLE_PROTOCOL, BROKEN_PEER, UNDECLARED }

package/vault/vendor/compat/ranges.js

@@ -0,0 +1,93 @@
+/**
+ * ranges.js — RANGOS DE VERSIONES, acotados a lo que el ecosistema usa de verdad.
+ *
+ * El dueño pidió que los manifiestos digan **qué rangos son compatibles con qué**
+ * (2026-09-04), así que hace falta comparar versiones. Mi objeción de la mañana seguía en
+ * pie —un comparador de semver mal escrito es peor que no tenerlo, porque falla en silencio
+ * y del lado que no toca— y la respuesta no es no tenerlo, es acotarlo:
+ *
+ *   · **`x.y.z` y nada más.** Sin prereleases, sin `+build`, sin `^` ni `~`. Todas las
+ *     versiones del ecosistema tienen esa forma; no se inventa soporte para lo que no hay.
+ *   · **Lo que no se entiende NO pasa.** Un rango con una forma rara devuelve `false`, no
+ *     «bueno, adelante». Es la regla de siempre: si falta lo que hace falta para decidir,
+ *     se para.
+ *
+ * Formas admitidas, y son todas:
+ *
+ *     "0.106.2"              exacta
+ *     "0.106.0+"             ABIERTO hacia arriba: de esa en adelante
+ *     ">=0.106.0"            lo mismo, en el otro idioma. También >  <=  <
+ *     "0.100.0 - 0.106.2"    intervalo, extremos incluidos
+ *     "0.100.0 - *"          abierto por el extremo de arriba
+ *     "*"                    cualquiera
+ *     [">=0.5.0", "0.4.2"]   una lista es un O
+ */
+
+const PARTES = /^(\d+)\.(\d+)\.(\d+)$/
+
+/** `[major, minor, patch]`, o `null` si no tiene la forma. */
+export function parseVersion (v) {
+  const m = PARTES.exec(String(v || '').trim())
+  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null
+}
+
+/** -1, 0 o 1. Lanza si alguna no tiene forma: comparar basura no puede dar un resultado. */
+export function compareVersions (a, b) {
+  const x = parseVersion(a)
+  const y = parseVersion(b)
+  if (!x || !y) throw new Error(`compat: cannot compare versions "${a}" and "${b}"`)
+  for (let i = 0; i < 3; i++) {
+    if (x[i] !== y[i]) return x[i] < y[i] ? -1 : 1
+  }
+  return 0
+}
+
+const OPS = [
+  ['>=', (c) => c >= 0],
+  ['<=', (c) => c <= 0],
+  ['>', (c) => c > 0],
+  ['<', (c) => c < 0]
+]
+
+/**
+ * ¿`version` cae dentro de `range`?
+ * @param {string} version
+ * @param {string|string[]} range
+ * @returns {boolean} `false` también cuando el rango no se entiende
+ */
+export function satisfies (version, range) {
+  if (Array.isArray(range)) return range.some((r) => satisfies(version, r))
+  if (typeof range !== 'string') return false
+  const r = range.trim()
+  if (!r) return false
+  if (r === '*') return true
+  if (!parseVersion(version)) return false
+
+  // ABIERTO HACIA ARRIBA: «0.106.0+» es «de esa en adelante». Es la forma que más se usa
+  // en un manifiesto —«esto y lo que venga»— y se lee mejor que `>=` cuando hay veinte
+  // líneas seguidas (dueño, 2026-09-04).
+  if (r.endsWith('+')) {
+    try { return compareVersions(version, r.slice(0, -1).trim()) >= 0 } catch (_) { return false }
+  }
+
+  const guion = r.split(' - ')
+  if (guion.length === 2) {
+    const desde = guion[0].trim()
+    const hasta = guion[1].trim()
+    try {
+      if (compareVersions(version, desde) < 0) return false
+      // El extremo de arriba también puede quedar abierto: «0.100.0 - *».
+      return hasta === '*' ? true : compareVersions(version, hasta) <= 0
+    } catch (_) { return false }
+  }
+
+  for (const [signo, cumple] of OPS) {
+    if (r.startsWith(signo)) {
+      try { return cumple(compareVersions(version, r.slice(signo.length).trim())) } catch (_) { return false }
+    }
+  }
+
+  try { return compareVersions(version, r) === 0 } catch (_) { return false }
+}
+
+export default { parseVersion, compareVersions, satisfies }

package/vault/vendor/opaque/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/opaque@0.1.0 (dotrino-opaque/{src/index,build/opaque,build/wasm-bytes}.js).
+Copia vendorizada de @dotrino/opaque@0.1.0 (dotrino-opaque/{build/opaque,build/wasm-bytes,src/index}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 src/index.js importa ../build/{opaque,wasm-bytes}.js, así que la copia CONSERVA
 esas dos carpetas: aplanarla rompería el import relativo.

package/vault/vendor/passmanager/VERSION.txt

@@ -0,0 +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).
+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.