@dotrino/identity 0.118.0 → 0.120.0

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

@@ -28,6 +28,7 @@
  */
 import { canonicalStringify } from './canonical.js'
 import { verifyData, samePubkey } from './signature.js'
+import { errorWithCode } from './errors.js'
 
 export const ENCPUB_V = 1
 
@@ -54,17 +55,6 @@ export function isEncPub (v) {
   }
 }
 
-/**
- * @param {string} mensaje
- * @param {string} code
- * @returns {Error & { code: string }}
- */
-function errorCon (mensaje, code) {
-  const e = /** @type {Error & { code: string }} */ (new Error(mensaje))
-  e.code = code
-  return e
-}
-
 /**
  * Firma el anuncio con lo que firma la identidad (`identity.signData`, o la llave local
  * del cliente). No genera llaves ni cifra nada: solo dice de quién es la que ya tienes.
@@ -73,15 +63,15 @@ function errorCon (mensaje, code) {
  * @returns {Promise<{data:any, signature:string}>}
  */
 export async function buildEncPubStatement ({ publickey, encPub, sign } = /** @type {any} */ ({})) {
-  if (typeof publickey !== 'string' || !publickey) throw errorCon('buildEncPubStatement: missing publickey', 'encpub-shape')
-  if (!isEncPub(encPub)) throw errorCon('buildEncPubStatement: encPub is not a P-256 public JWK', 'encpub-shape')
-  if (typeof sign !== 'function') throw errorCon('buildEncPubStatement: missing sign(data)', 'encpub-shape')
+  if (typeof publickey !== 'string' || !publickey) throw errorWithCode('buildEncPubStatement: missing publickey', 'encpub-shape')
+  if (!isEncPub(encPub)) throw errorWithCode('buildEncPubStatement: encPub is not a P-256 public JWK', 'encpub-shape')
+  if (typeof sign !== 'function') throw errorWithCode('buildEncPubStatement: missing sign(data)', 'encpub-shape')
   const data = encPubBody({ publickey, encPub })
   const firmado = await sign(data)
   const signature = typeof firmado === 'string' ? firmado : firmado?.signature
   // «No pude firmar» no es «se cayó la red», y aquí es donde se separan: quien llama
   // decide una cosa u otra según el `code`, nunca según la frase.
-  if (typeof signature !== 'string') throw errorCon('buildEncPubStatement: sign() returned no signature', 'no-signature')
+  if (typeof signature !== 'string') throw errorWithCode('buildEncPubStatement: sign() returned no signature', 'no-signature')
   return { data, signature }
 }
 
@@ -98,21 +88,21 @@ export async function buildEncPubStatement ({ publickey, encPub, sign } = /** @t
  */
 export async function readEncPubStatement (statement, { publickey } = /** @type {any} */ ({})) {
   if (typeof publickey !== 'string' || !publickey) {
-    throw errorCon('readEncPubStatement: missing the publickey to check against', 'encpub-shape')
+    throw errorWithCode('readEncPubStatement: missing the publickey to check against', 'encpub-shape')
   }
   const data = statement?.data
   const signature = statement?.signature
-  if (!data || typeof signature !== 'string') throw errorCon('encpub statement: malformed', 'encpub-unverified')
-  if (data.v !== ENCPUB_V || data.op !== 'encpub') throw errorCon('encpub statement: not an encpub announcement', 'encpub-unverified')
-  if (data.aud !== ENCPUB_AUD) throw errorCon('encpub statement: wrong audience', 'encpub-unverified')
+  if (!data || typeof signature !== 'string') throw errorWithCode('encpub statement: malformed', 'encpub-unverified')
+  if (data.v !== ENCPUB_V || data.op !== 'encpub') throw errorWithCode('encpub statement: not an encpub announcement', 'encpub-unverified')
+  if (data.aud !== ENCPUB_AUD) throw errorWithCode('encpub statement: wrong audience', 'encpub-unverified')
   // `samePubkey` y no `===`: un JWK serializado no es canónico y la misma llave escrita
   // por dos piezas distintas da dos strings distintos.
-  if (!samePubkey(data.publickey, publickey)) throw errorCon('encpub statement: announces another identity', 'encpub-unverified')
-  if (!isEncPub(data.encpub)) throw errorCon('encpub statement: not a P-256 public JWK', 'encpub-unverified')
+  if (!samePubkey(data.publickey, publickey)) throw errorWithCode('encpub statement: announces another identity', 'encpub-unverified')
+  if (!isEncPub(data.encpub)) throw errorWithCode('encpub statement: not a P-256 public JWK', 'encpub-unverified')
   // Se verifica con la llave que ANUNCIA el sobre, que ya se comprobó que es la misma que
   // la pedida: así el texto firmado y la llave que lo comprueba salen del mismo sitio.
   if (!(await verifyData(data.publickey, data, signature))) {
-    throw errorCon('encpub statement: bad signature — the key is not bound to that identity', 'encpub-unverified')
+    throw errorWithCode('encpub statement: bad signature — the key is not bound to that identity', 'encpub-unverified')
   }
   return data.encpub
 }

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

@@ -0,0 +1,15 @@
+/**
+ * Error con un `code` estable.
+ *
+ * El contrato es el CODE, no la frase: comprobar por el texto cruza procesos y
+ * se rompe en silencio en cuanto alguien lo reescribe o lo traduce.
+ *
+ * @param {string} message
+ * @param {string} code
+ * @returns {Error & { code: string }}
+ */
+export function errorWithCode (message, code) {
+  const e = /** @type {Error & { code: string }} */ (new Error(message))
+  e.code = code
+  return e
+}

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

@@ -15,14 +15,9 @@
  * second, older copy of a pillar inside every consumer.
  */
 
-const ECDH = { name: 'ECDH', namedCurve: 'P-256' }
+import { errorWithCode } from './errors.js'
 
-/** Un error con `code`: quien llama decide por el código, nunca por la frase. */
-function errorCon (mensaje, code) {
-  const e = /** @type {Error & { code: string }} */ (new Error(mensaje))
-  e.code = code
-  return e
-}
+const ECDH = { name: 'ECDH', namedCurve: 'P-256' }
 
 const VERSION = 1
 
@@ -137,7 +132,7 @@ export function identitySealing (identity, { app = 'dotrino' } = {}) {
 
   return {
     async seal (msg, peerEncPub, { publickey } = {}) {
-      if (!peerEncPub) throw errorCon('no encryption key for the other side', 'unsealed')
+      if (!peerEncPub) throw errorWithCode('no encryption key for the other side', 'unsealed')
       // Destinatarios como OBJETOS, y CON SU `publickey`: `encrypt` expande cada uno a
       // todos los aparatos de esa persona por su tarjeta de perfil, y la tarjeta se busca
       // por la pubkey. Sin ella el sobre solo lo abría el aparato que anunció la llave, y
@@ -149,7 +144,7 @@ export function identitySealing (identity, { app = 'dotrino' } = {}) {
       // VACÍO: cifrado de verdad, y que no abre nadie. Eso no es un sobre, es un mensaje
       // perdido con cara de enviado.
       if (!sealed || !sealed.wrap || Object.keys(sealed.wrap).length === 0) {
-        throw errorCon('identitySealing: the vault wrapped the message for nobody', 'unsealed')
+        throw errorWithCode('identitySealing: the vault wrapped the message for nobody', 'unsealed')
       }
       return { app, sealed, from: await myEncPub() }
     },
@@ -189,20 +184,20 @@ export function isBinSealed (env) {
 /** Una CEK nueva para un mensaje con bytes. */
 export async function makeMessageKey () {
   const { makeContentKey } = await crypto_()
-  if (typeof makeContentKey !== 'function') throw errorCon('sealing bytes needs @dotrino/identity >= 0.117.0', 'no-bytes-sealing')
+  if (typeof makeContentKey !== 'function') throw errorWithCode('sealing bytes needs @dotrino/identity >= 0.117.0', 'no-bytes-sealing')
   return makeContentKey()
 }
 
 /** Cifra `bytes` con la CEK y devuelve los campos del sobre (`iv`, `ct`). */
 export async function encryptBytes (cek, bytes) {
   const { encryptBytesWithCek } = await crypto_()
-  if (typeof encryptBytesWithCek !== 'function') throw errorCon('sealing bytes needs @dotrino/identity >= 0.117.0', 'no-bytes-sealing')
+  if (typeof encryptBytesWithCek !== 'function') throw errorWithCode('sealing bytes needs @dotrino/identity >= 0.117.0', 'no-bytes-sealing')
   return encryptBytesWithCek({ cek, bytes })
 }
 
 /** Descifra el `ct` de un sobre binario con su CEK ya abierta. */
 export async function decryptBytes (cek, env) {
   const { decryptBytesWithCek } = await crypto_()
-  if (typeof decryptBytesWithCek !== 'function') throw errorCon('opening bytes needs @dotrino/identity >= 0.117.0', 'no-bytes-sealing')
+  if (typeof decryptBytesWithCek !== 'function') throw errorWithCode('opening bytes needs @dotrino/identity >= 0.117.0', 'no-bytes-sealing')
   return decryptBytesWithCek({ cek, iv: env.iv, ct: env.ct })
 }

package/vault/vendor/roadmap/VERSION.txt

@@ -1,3 +1,3 @@
-Copia vendorizada de @dotrino/roadmap@0.4.20 (dotrino-roadmap/src/{index,manifests}.js).
+Copia vendorizada de @dotrino/roadmap@0.4.30 (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,8 +8,8 @@
 export const MANIFESTS = Object.freeze({
   "dotrino": {
     "manifest": "dotrino",
-    "seq": 29,
-    "issued": "2026-10-15",
+    "seq": 30,
+    "issued": "2026-10-16",
     "note": "Registro comun de compatibilidad del ecosistema. Se edita a mano en este repo y se consulta con @dotrino/roadmap. Rangos: ver @dotrino/compat/ranges (x.y.z, >= > <= <, «a - b», «*», o una lista que es un O).",
     "products": {
       "compat": {
@@ -22,18 +22,20 @@ export const MANIFESTS = Object.freeze({
       "env": {
         "repo": "imdotrino/dotrino-vault",
         "npm": "@dotrino/env",
-        "current": "0.85.0",
+        "current": "0.90.1",
         "protocol": 1,
         "requires": {
-          "vault": ">=0.70.0"
+          "vault": ">=0.90.1"
         }
       },
       "identity": {
         "repo": "imdotrino/dotrino-identity",
         "npm": "@dotrino/identity",
-        "current": "0.117.2",
+        "current": "0.119.0",
         "protocol": 1,
-        "requires": {}
+        "requires": {
+          "proxy-client": ">=0.13.1"
+        }
       },
       "lobby": {
         "repo": "imdotrino/dotrino-lobby",
@@ -107,12 +109,12 @@ export const MANIFESTS = Object.freeze({
       },
       "proxy": {
         "repo": "imdotrino/dotrino-proxy",
-        "current": "1.6.1",
+        "current": "1.6.4",
         "protocol": 2,
         "requires": {
-          "vault": ">=0.86.0",
-          "identity": ">=0.116.0",
-          "proxy-client": ">=0.23.1",
+          "vault": ">=0.87.0",
+          "identity": ">=0.117.2",
+          "proxy-client": ">=0.36.1",
           "content": "0.5.3+"
         }
       },
@@ -169,7 +171,7 @@ export const MANIFESTS = Object.freeze({
       },
       "terminal-desktop": {
         "repo": "imdotrino/dotrino-terminal",
-        "current": "0.2.74",
+        "current": "0.2.77",
         "protocol": 1,
         "requires": {
           "terminal-agent": ">=0.37.0"
@@ -179,42 +181,43 @@ export const MANIFESTS = Object.freeze({
         "repo": "imdotrino/dotrino-ia",
         "npm": "@dotrino/ia-agent",
         "deprecated": "2026-10-07: retired, replaced by terminal-agent (dotrino-terminal)",
-        "current": "0.8.1",
+        "current": "0.9.0",
         "protocol": 1,
         "requires": {
-          "remote-agent": ">=0.13.0",
-          "identity": ">=0.92.0",
-          "vault": ">=0.75.0"
+          "remote-agent": ">=0.20.1",
+          "identity": ">=0.117.2",
+          "vault": ">=0.87.0",
+          "proxy-client": ">=0.36.1"
         }
       },
       "content": {
         "repo": "imdotrino/dotrino-content",
         "npm": "@dotrino/content",
-        "current": "0.5.3",
+        "current": "0.6.0",
         "protocol": 1,
         "requires": {
-          "remote-agent": ">=0.13.0",
-          "identity": ">=0.116.0",
-          "vault": ">=0.86.0",
-          "proxy-client": ">=0.23.1"
+          "remote-agent": ">=0.20.1",
+          "identity": ">=0.117.2",
+          "vault": ">=0.87.0",
+          "proxy-client": ">=0.36.1"
         }
       },
       "sealers": {
         "repo": "imdotrino/dotrino-sealers",
         "npm": "@dotrino/sealers",
-        "current": "0.9.2",
+        "current": "0.10.0",
         "protocol": 1,
         "requires": {
-          "remote-agent": ">=0.13.0",
-          "identity": ">=0.116.0",
-          "vault": ">=0.86.0",
-          "proxy-client": ">=0.23.1"
+          "remote-agent": ">=0.20.1",
+          "identity": ">=0.117.2",
+          "vault": ">=0.87.0",
+          "proxy-client": ">=0.36.1"
         }
       },
       "roadmap": {
         "repo": "imdotrino/dotrino-roadmap",
         "npm": "@dotrino/roadmap",
-        "current": "0.4.14",
+        "current": "0.4.30",
         "protocol": 1,
         "requires": {
           "compat": "0.4.0+"
@@ -250,32 +253,32 @@ export const MANIFESTS = Object.freeze({
       "vault": {
         "repo": "imdotrino/dotrino-vault",
         "npm": "@dotrino/vault",
-        "current": "0.87.0",
+        "current": "0.90.1",
         "protocol": 1,
         "requires": {
           "vaultd": ">=0.105.0",
           "proxy-client": ">=0.36.1",
-          "identity": ">=0.117.2",
+          "identity": ">=0.118.0",
           "opaque": ">=0.1.0",
           "compat": ">=0.4.0",
-          "roadmap": ">=0.4.13",
-          "passmanager": ">=0.17.0",
-          "store": ">=0.11.0"
+          "roadmap": ">=0.4.26",
+          "passmanager": ">=0.18.4",
+          "store": ">=0.12.3"
         }
       },
       "vaultd": {
         "repo": "imdotrino/dotrino-vault",
         "npm": "@dotrino/vaultd",
-        "current": "0.159.0",
+        "current": "0.162.1",
         "protocol": 1,
         "requires": {
-          "identity": ">=0.117.2",
+          "identity": ">=0.118.0",
           "proxy-client": ">=0.36.1",
           "store": ">=0.11.0",
-          "passmanager": ">=0.17.0",
+          "passmanager": ">=0.18.4",
           "compat": ">=0.4.0",
           "opaque": ">=0.1.0",
-          "roadmap": ">=0.4.13"
+          "roadmap": ">=0.4.26"
         }
       },
       "verifier": {
@@ -290,7 +293,7 @@ export const MANIFESTS = Object.freeze({
       "passmanager": {
         "repo": "imdotrino/dotrino-passmanager",
         "npm": "@dotrino/passmanager",
-        "current": "0.18.0",
+        "current": "0.18.4",
         "protocol": 1,
         "requires": {
           "identity": ">=0.117.2",
@@ -303,7 +306,7 @@ export const MANIFESTS = Object.freeze({
         "protocol": 1,
         "requires": {
           "proxy": "1.1.0+",
-          "vaultd": ">=0.125.0"
+          "vaultd": ">=0.160.2"
         }
       },
       "passmanager-ios": {
@@ -317,18 +320,19 @@ export const MANIFESTS = Object.freeze({
       },
       "passmanager-extension": {
         "repo": "imdotrino/dotrino-passmanager",
-        "current": "0.51.1",
+        "current": "0.54.0",
         "protocol": 1,
         "requires": {
-          "identity": ">=0.117.2",
+          "identity": ">=0.118.0",
           "proxy-client": ">=0.36.1",
-          "vault": ">=0.87.0",
-          "proxy": "1.1.0+"
+          "vault": ">=0.90.0",
+          "proxy": "1.1.0+",
+          "vaultd": ">=0.160.2"
         }
       },
       "app": {
         "repo": "imdotrino/dotrino-app",
-        "current": "0.4.21",
+        "current": "0.4.22",
         "protocol": 1,
         "requires": {
           "proxy": "1.4.7+",
@@ -338,13 +342,13 @@ export const MANIFESTS = Object.freeze({
       },
       "social-bot": {
         "repo": "imdotrino/dotrino-social-bot",
-        "current": "0.2.1",
+        "current": "0.3.0",
         "protocol": 1,
         "requires": {
-          "vault": ">=0.86.0",
-          "identity": ">=0.116.0",
-          "proxy-client": ">=0.23.1",
-          "remote-agent": ">=0.13.0"
+          "vault": ">=0.87.0",
+          "identity": ">=0.117.2",
+          "proxy-client": ">=0.36.1",
+          "remote-agent": ">=0.20.1"
         }
       }
     },
@@ -832,6 +836,15 @@ export const MANIFESTS = Object.freeze({
         "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"
+      },
+      {
+        "product": "vaultd",
+        "versions": [
+          "0.160.0",
+          "0.160.1"
+        ],
+        "why": "la bóveda recordaba el sí de aprobación por aparato: después de aprobar un borrado, o de leer una contraseña, ese aparato podía borrar o pisar una passkey sin que se pidiera nada ni le llegara aviso a nadie",
+        "fix": "sube a @dotrino/vaultd 0.160.2"
       }
     ]
   }

package/vault/vendor/store/VERSION.txt

@@ -1,3 +1,3 @@
-Copia vendorizada de @dotrino/store/core@0.12.3 (dotrino-store/store/{core}.js).
+Copia vendorizada de @dotrino/store/core@0.12.4 (dotrino-store/store/{core}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 Las reglas del almacén (lápidas, páginas): las mismas en el store y en la bóveda.

package/vault/vendor/vault/VERSION.txt

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

@@ -0,0 +1,244 @@
+/**
+ * EL RESPALDO DE LA BÓVEDA: un archivo cifrado con una contraseña, con lo que hay en los
+ * cajones y en la bóveda de contraseñas. Diseño: `docs/respaldo.md`.
+ *
+ * QUÉ LLEVA Y QUÉ NO (dueño, 2026-10-16: «como las llaves son de dispositivo, solo se
+ * respalda el contenido de sobres y cajones»):
+ *
+ *   · SÍ: los VALORES de cada cajón (`ns:<scope>`, `dev:<aparato>`, el perfil `@me`) y las
+ *     entradas de la bóveda de contraseñas, abiertos y vueltos a cerrar con la contraseña
+ *     del respaldo.
+ *   · NO: ninguna llave. Ni la maestra, ni la de comunicación, ni las de los aparatos, ni
+ *     el acta. Una llave es de su aparato; quien restaura en otra bóveda la reparte con sus
+ *     propias llaves, a los aparatos de SU acta.
+ *   · NO: el histórico. Un respaldo es lo vigente.
+ *
+ * Por qué los valores en claro (dentro del archivo cifrado) y no los sobres tal cual: los
+ * sobres van envueltos a los aparatos de ESTA cuenta y a su copia de recuperación. En otra
+ * bóveda no los abre nadie, y mover un cajón de una bóveda a otra es la mitad de lo que esto
+ * tiene que hacer.
+ *
+ * LAS DOS PUNTAS EXIGEN LA BÓVEDA ABIERTA. Exportar es leer —lo que guarda la frase—, e
+ * importar compara con lo que ya hay, que también es leer.
+ *
+ * CONFLICTOS. Importar NUNCA pisa en silencio: primero se hace un PLAN (`planImport`) que
+ * dice, valor por valor, qué es nuevo, qué es igual y qué choca. Si algo choca y quien
+ * importa no dijo qué hacer, no se escribe NADA y se devuelve la lista (`BACKUP_CONFLICTS`).
+ * Las dos respuestas posibles son `keep` (se queda lo de la bóveda) y `replace` (gana el
+ * respaldo), para todo de una vez o para cada choque.
+ *
+ * El cifrado del archivo es el de `@dotrino/passmanager` (PBKDF2-SHA256 600 000 + AES-GCM):
+ * corre igual en el navegador y en Node, así que lo que exporta una versión de la bóveda lo
+ * abre cualquiera de las otras (regla de las tres versiones).
+ */
+import { deriveKeyFromPassword, makeSalt, makeVerifier, checkVerifier, sealValue, openValue, toBase64, fromBase64 } from '@dotrino/passmanager'
+
+export const BACKUP_FORMAT = 'dotrino-vault-backup'
+export const BACKUP_VERSION = 1
+/** El nombre del cajón de las contraseñas en un respaldo. No choca con un `ns:`/`dev:`. */
+export const PASSWORDS_DRAWER = 'passwords'
+/** Mínimo de la contraseña del respaldo: el archivo se ataca fuera de línea, sin freno. */
+export const BACKUP_PWD_MIN = 12
+const KDF_ITERATIONS = 600_000
+const AAD = 'dotrino-vault-backup/v1'
+
+const coded = (message, code, extra = {}) => Object.assign(new Error(message), { code, ...extra })
+
+// --- el archivo ----------------------------------------------------------------
+
+/**
+ * CIERRA un respaldo con su contraseña. Devuelve el objeto que se escribe al archivo.
+ * Lo único en claro es el formato y la fecha: ni los nombres de los cajones salen.
+ */
+export async function sealBackup (payload, password) {
+  if (typeof password !== 'string' || password.length < BACKUP_PWD_MIN) {
+    throw coded(`the backup password must be at least ${BACKUP_PWD_MIN} characters`, 'WEAK_PASSWORD')
+  }
+  const salt = makeSalt()
+  const key = await deriveKeyFromPassword(password, salt, KDF_ITERATIONS)
+  return {
+    format: BACKUP_FORMAT,
+    v: BACKUP_VERSION,
+    createdAt: payload.createdAt,
+    kdf: { name: 'PBKDF2-SHA256', iterations: KDF_ITERATIONS, salt: toBase64(salt) },
+    verifier: await makeVerifier(key),
+    box: await sealValue(key, JSON.stringify(payload), AAD)
+  }
+}
+
+/**
+ * ABRE un respaldo. Distingue «no es un respaldo», «esa contraseña no es» y «está roto»,
+ * porque se arreglan de formas distintas.
+ */
+export async function openBackup (file, password) {
+  if (!file || file.format !== BACKUP_FORMAT) throw coded('this is not a vault backup file', 'NOT_A_BACKUP')
+  if (file.v !== BACKUP_VERSION) throw coded(`unknown backup version v${file.v}: update the vault`, 'BACKUP_VERSION')
+  if (file.kdf?.name !== 'PBKDF2-SHA256' || !file.kdf.salt || !file.kdf.iterations) {
+    throw coded('the backup file has no usable key derivation', 'BACKUP_CORRUPT')
+  }
+  const key = await deriveKeyFromPassword(String(password || ''), fromBase64(file.kdf.salt), file.kdf.iterations)
+  if (!(await checkVerifier(key, file.verifier))) throw coded('that password does not open this backup', 'WRONG_PASSWORD')
+  let payload
+  try { payload = JSON.parse(await openValue(key, file.box, AAD)) } catch (_) {
+    throw coded('the backup opens but its content cannot be read', 'BACKUP_CORRUPT')
+  }
+  if (!Array.isArray(payload?.drawers)) throw coded('the backup has no drawers', 'BACKUP_CORRUPT')
+  return payload
+}
+
+// --- qué cajones -----------------------------------------------------------------
+
+/**
+ * ¿Entra este cajón? `selected` es la lista que pidió quien exporta o importa (`null` =
+ * todos). Vale el dueño entero (`ns:proxy`, `dev:<pub>`, `passwords`) y `@me` como atajo.
+ */
+export function wants (selected, owner) {
+  if (!selected || !selected.length) return true
+  return selected.some((s) => s === owner || (s === '@me' && owner === 'ns:@me'))
+}
+
+/** Valida que todo lo pedido exista: pedir un cajón que no está no es «nada que hacer». */
+export function assertSelected (selected, available) {
+  if (!selected || !selected.length) return
+  const missing = selected.filter((s) => !available.some((o) => wants([s], o)))
+  if (missing.length) throw coded(`no such drawer: ${missing.join(', ')}`, 'NO_SUCH_DRAWER', { missing })
+}
+
+// --- importar: el plan -----------------------------------------------------------
+
+/** Lo que identifica un valor dentro de un plan: `<cajón destino> <clave>`. */
+export const itemRef = (owner, key) => `${owner} ${key}`
+
+/**
+ * EL PLAN DE IMPORTACIÓN. Puro: no lee ni escribe nada, recibe lo que hay.
+ *
+ * @param {object} payload el respaldo ya abierto
+ * @param {object} o
+ *   `selected`  qué cajones del respaldo (`null` = todos)
+ *   `map`       `{ <cajón del respaldo>: <cajón destino> }` para moverlo de nombre o de
+ *               aparato. Sin entrada, va al mismo nombre.
+ *   `current`   `{ <cajón destino>: { KEY: {value, public} } | null }` lo que ya hay
+ *   `devices`   pubs de los aparatos del acta de destino: un `dev:` solo entra si su
+ *               aparato existe aquí
+ *   `passwords` `{ entries: [...] }` lo que ya hay en la bóveda de contraseñas, abierto
+ */
+export function planImport (payload, { selected = null, map = {}, current = {}, devices = [], passwords = null } = {}) {
+  const available = payload.drawers.map((d) => d.owner)
+  assertSelected(selected, available)
+  const withDevice = new Set(devices)
+  const plan = { drawers: [], counts: { new: 0, same: 0, conflict: 0, skipped: 0 } }
+  for (const d of payload.drawers) {
+    if (!wants(selected, d.owner)) continue
+    const to = map[d.owner] || d.owner
+    if (d.owner === PASSWORDS_DRAWER) {
+      plan.drawers.push(planPasswords(d, passwords, plan.counts))
+      continue
+    }
+    const out = { from: d.owner, to, label: d.label || null, status: 'ok', items: [] }
+    if (to.startsWith('dev:') && !withDevice.has(to.slice(4))) {
+      // EL APARATO NO ESTÁ EN ESTA CUENTA. No se guarda «por si acaso»: un cajón de aparato
+      // sin aparato no lo lee nadie, y reaparecería solo si un día entra esa llave. Se dice,
+      // y se puede mover a otro aparato con `map`.
+      out.status = 'no-device'
+      plan.counts.skipped += Object.keys(d.vars || {}).length
+      plan.drawers.push(out)
+      continue
+    }
+    const have = current[to] || {}
+    for (const [key, v] of Object.entries(d.vars || {})) {
+      const existing = have[key]
+      const status = !existing ? 'new' : (existing.value === v.value ? 'same' : 'conflict')
+      plan.counts[status]++
+      out.items.push({ key, status, public: !!v.public, ...(existing ? { currentPublic: !!existing.public } : {}) })
+    }
+    plan.drawers.push(out)
+  }
+  return plan
+}
+
+/**
+ * Lo que dice que una entrada de contraseñas es «la misma» que otra: el mismo id, o los
+ * mismos sitios y el mismo usuario (una credencial por sitio y usuario).
+ */
+const sitesKey = (e) => [...(e.sites || [])].map((s) => String(s).toLowerCase()).sort().join(' ')
+const whoKey = (e) => `${sitesKey(e)}\u0000${String(e.username || '').toLowerCase()}\u0000${e.sites?.length ? '' : String(e.title || '')}`
+/** Lo que se compara para decir «igual»: el contenido, sin fechas. */
+export const entryContent = (e) => JSON.stringify({
+  type: e.type || 'login', title: e.title || '', sites: [...(e.sites || [])].sort(),
+  name: e.name || '', username: e.username || '', secret: e.secret || '', totp: e.totp || '',
+  notes: e.notes || '', fields: e.fields || '[]', webauthn: e.webauthn || null
+})
+
+function planPasswords (d, passwords, counts) {
+  const out = { from: PASSWORDS_DRAWER, to: PASSWORDS_DRAWER, status: 'ok', items: [] }
+  if (!passwords) {
+    // Sin bóveda de contraseñas en el destino no hay con quién comparar ni dónde guardar:
+    // se dice. No se inventa una llave de perfil a medias.
+    out.status = 'no-passwords'
+    counts.skipped += (d.entries || []).length
+    return out
+  }
+  const byId = new Map(passwords.entries.map((e) => [e.id, e]))
+  const byWho = new Map(passwords.entries.map((e) => [whoKey(e), e]))
+  for (const e of d.entries || []) {
+    const existing = byId.get(e.id) || byWho.get(whoKey(e)) || null
+    const status = !existing ? 'new' : (entryContent(existing) === entryContent(e) ? 'same' : 'conflict')
+    counts[status]++
+    out.items.push({ key: e.id, title: e.title || (e.sites || [])[0] || '', username: e.username || '', status, ...(existing ? { currentId: existing.id } : {}) })
+  }
+  return out
+}
+
+/**
+ * LA DECISIÓN DE CADA CHOQUE. `onConflict` vale para todos; `decisions` (por `itemRef`) manda
+ * sobre él. Si queda alguno sin decidir, se para con la lista entera: importar a medias y
+ * descubrir el resto después es peor que no importar.
+ */
+export function resolvePlan (plan, { onConflict = null, decisions = {} } = {}) {
+  if (onConflict && onConflict !== 'keep' && onConflict !== 'replace') {
+    throw coded(`unknown conflict policy "${onConflict}" (use keep or replace)`, 'BAD_POLICY')
+  }
+  const pending = []
+  for (const d of plan.drawers) {
+    for (const it of d.items) {
+      if (it.status !== 'conflict') continue
+      const r = decisions[itemRef(d.to, it.key)] || onConflict
+      if (r !== 'keep' && r !== 'replace') { pending.push({ drawer: d.to, key: it.key, ...(it.title ? { title: it.title } : {}) }); continue }
+      it.resolution = r
+    }
+  }
+  if (pending.length) {
+    throw coded(`${pending.length} conflict(s) without a decision: nothing was imported`, 'BACKUP_CONFLICTS', { conflicts: pending, plan })
+  }
+  return plan
+}
+
+/**
+ * LO QUE HAY QUE ESCRIBIR, ya resuelto: `[{ to, key, value, public }]` para los cajones y
+ * `[{ entry, replaces }]` para las contraseñas. Lo `same` y lo `keep` no se tocan.
+ *
+ * La VISIBILIDAD: si lo que había era privado, se queda privado aunque el respaldo diga
+ * público. Hacer público un secreto no puede colarse en una importación (es la misma regla
+ * de `PrivateStaysPrivate`), y se anota para decirlo.
+ */
+export function writesOf (plan, payload) {
+  const vars = []
+  const entries = []
+  const byOwner = new Map(payload.drawers.map((d) => [d.owner, d]))
+  for (const d of plan.drawers) {
+    if (d.status !== 'ok') continue
+    const src = byOwner.get(d.from)
+    for (const it of d.items) {
+      if (it.status === 'same' || (it.status === 'conflict' && it.resolution !== 'replace')) continue
+      if (d.from === PASSWORDS_DRAWER) {
+        const entry = src.entries.find((e) => e.id === it.key)
+        entries.push({ entry, replaces: it.status === 'conflict' ? it.currentId : null })
+        continue
+      }
+      const v = src.vars[it.key]
+      const keptPrivate = it.currentPublic === false && !!v.public
+      vars.push({ to: d.to, key: it.key, value: v.value, public: keptPrivate ? false : !!v.public, ...(keptPrivate ? { keptPrivate: true } : {}) })
+    }
+  }
+  return { vars, entries }
+}