@dotrino/identity 0.117.2 → 0.119.0

package/vault/vendor/roadmap/manifests.js

@@ -8,7 +8,7 @@
 export const MANIFESTS = Object.freeze({
   "dotrino": {
     "manifest": "dotrino",
-    "seq": 28,
+    "seq": 29,
     "issued": "2026-10-15",
     "note": "Registro comun de compatibilidad del ecosistema. Se edita a mano en este repo y se consulta con @dotrino/roadmap. Rangos: ver @dotrino/compat/ranges (x.y.z, >= > <= <, «a - b», «*», o una lista que es un O).",
     "products": {
@@ -31,7 +31,7 @@ export const MANIFESTS = Object.freeze({
       "identity": {
         "repo": "imdotrino/dotrino-identity",
         "npm": "@dotrino/identity",
-        "current": "0.117.1",
+        "current": "0.118.0",
         "protocol": 1,
         "requires": {}
       },
@@ -47,11 +47,11 @@ export const MANIFESTS = Object.freeze({
       },
       "messenger": {
         "repo": "imdotrino/dotrino-messenger",
-        "current": "0.8.0",
+        "current": "0.8.1",
         "protocol": 2,
         "requires": {
           "identity": ">=0.117.0",
-          "proxy-client": ">=0.35.0",
+          "proxy-client": ">=0.36.1",
           "store": ">=0.12.3",
           "proxy": "1.6.1+"
         }
@@ -107,19 +107,19 @@ export const MANIFESTS = Object.freeze({
       },
       "proxy": {
         "repo": "imdotrino/dotrino-proxy",
-        "current": "1.6.1",
+        "current": "1.6.3",
         "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+"
         }
       },
       "proxy-client": {
         "repo": "imdotrino/dotrino-proxy-client",
         "npm": "@dotrino/proxy-client",
-        "current": "0.35.0",
+        "current": "0.36.1",
         "protocol": 2,
         "requires": {
           "identity": ">=0.53.0",
@@ -129,25 +129,25 @@ export const MANIFESTS = Object.freeze({
       "remote-agent": {
         "repo": "imdotrino/dotrino-remote-agent",
         "npm": "@dotrino/remote-agent",
-        "current": "0.19.1",
+        "current": "0.20.1",
         "protocol": 1,
         "requires": {
-          "identity": ">=0.115.0",
+          "identity": ">=0.117.2",
           "vault": ">=0.85.0",
-          "proxy-client": ">=0.30.0",
+          "proxy-client": ">=0.36.1",
           "vaultd": ">=0.154.0"
         }
       },
       "terminal-agent": {
         "repo": "imdotrino/dotrino-terminal",
         "npm": "@dotrino/terminal-agent",
-        "current": "0.47.4",
+        "current": "0.48.0",
         "protocol": 2,
         "requires": {
-          "remote-agent": ">=0.18.3",
-          "identity": ">=0.116.0",
-          "vault": ">=0.86.0",
-          "proxy-client": ">=0.31.1",
+          "remote-agent": ">=0.20.1",
+          "identity": ">=0.117.2",
+          "vault": ">=0.87.0",
+          "proxy-client": ">=0.36.1",
           "vaultd": ">=0.142.0"
         }
       },
@@ -169,7 +169,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 +179,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.29",
         "protocol": 1,
         "requires": {
           "compat": "0.4.0+"
@@ -250,32 +251,32 @@ export const MANIFESTS = Object.freeze({
       "vault": {
         "repo": "imdotrino/dotrino-vault",
         "npm": "@dotrino/vault",
-        "current": "0.86.0",
+        "current": "0.89.0",
         "protocol": 1,
         "requires": {
           "vaultd": ">=0.105.0",
-          "proxy-client": "0.24.0+",
-          "identity": ">=0.116.0",
+          "proxy-client": ">=0.36.1",
+          "identity": ">=0.118.0",
           "opaque": ">=0.1.0",
           "compat": ">=0.4.0",
-          "roadmap": ">=0.4.13",
-          "passmanager": ">=0.17.0",
+          "roadmap": ">=0.4.26",
+          "passmanager": ">=0.18.4",
           "store": ">=0.11.0"
         }
       },
       "vaultd": {
         "repo": "imdotrino/dotrino-vault",
         "npm": "@dotrino/vaultd",
-        "current": "0.157.0",
+        "current": "0.161.0",
         "protocol": 1,
         "requires": {
-          "identity": ">=0.116.0",
-          "proxy-client": ">=0.30.1",
+          "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,11 +291,11 @@ export const MANIFESTS = Object.freeze({
       "passmanager": {
         "repo": "imdotrino/dotrino-passmanager",
         "npm": "@dotrino/passmanager",
-        "current": "0.17.0",
+        "current": "0.18.4",
         "protocol": 1,
         "requires": {
-          "identity": ">=0.61.0",
-          "proxy-client": ">=0.13.0"
+          "identity": ">=0.117.2",
+          "proxy-client": ">=0.36.1"
         }
       },
       "passmanager-android": {
@@ -303,7 +304,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 +318,19 @@ export const MANIFESTS = Object.freeze({
       },
       "passmanager-extension": {
         "repo": "imdotrino/dotrino-passmanager",
-        "current": "0.49.1",
+        "current": "0.53.4",
         "protocol": 1,
         "requires": {
-          "identity": ">=0.116.0",
-          "proxy-client": ">=0.32.2",
-          "vault": ">=0.86.0",
-          "proxy": "1.1.0+"
+          "identity": ">=0.118.0",
+          "proxy-client": ">=0.36.1",
+          "vault": ">=0.88.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,17 +340,41 @@ 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"
         }
       }
     },
     "broken": [
+      {
+        "product": "passmanager-extension",
+        "versions": "0.50.0",
+        "why": "la página que pide una passkey decía ella misma de qué sitio era (rpId y origen salían del mensaje, no del remitente): un sitio cualquiera podía pedir la firma de la passkey de otro sitio guardada en Dotrino",
+        "fix": "sube a la extensión 0.51.0 (se actualiza sola desde pass.dotrino.com/app)"
+      },
+      {
+        "product": "passmanager-extension",
+        "versions": "0.49.1",
+        "why": "la página que pide una passkey decía ella misma de qué sitio era (rpId y origen salían del mensaje, no del remitente): un sitio cualquiera podía pedir la firma de la passkey de otro sitio guardada en Dotrino",
+        "fix": "sube a la extensión 0.51.0 (se actualiza sola desde pass.dotrino.com/app)"
+      },
+      {
+        "product": "passmanager-extension",
+        "versions": "0.49.0",
+        "why": "la página que pide una passkey decía ella misma de qué sitio era (rpId y origen salían del mensaje, no del remitente): un sitio cualquiera podía pedir la firma de la passkey de otro sitio guardada en Dotrino",
+        "fix": "sube a la extensión 0.51.0 (se actualiza sola desde pass.dotrino.com/app)"
+      },
+      {
+        "product": "passmanager-extension",
+        "versions": "0.48.4",
+        "why": "la página que pide una passkey decía ella misma de qué sitio era (rpId y origen salían del mensaje, no del remitente): un sitio cualquiera podía pedir la firma de la passkey de otro sitio guardada en Dotrino",
+        "fix": "sube a la extensión 0.51.0 (se actualiza sola desde pass.dotrino.com/app)"
+      },
       {
         "product": "terminal-agent",
         "versions": "0.46.4",
@@ -802,6 +828,21 @@ export const MANIFESTS = Object.freeze({
         "versions": "1.6.0",
         "why": "pasa a base64 los mensajes binarios para cruzar la malla, y una parte de 768 KB así pasa de la trama de 1 MB del otro nodo: el enlace se cae en cada reconexión al reenviarla y todo lo que va detrás entre los dos nodos se queda atascado",
         "fix": "websocket-proxy 1.6.1"
+      },
+      {
+        "product": "proxy-client",
+        "versions": "0.36.0",
+        "why": "por token frena los bytes por lo recordado de la identidad (que puede ser de antes de que el otro se actualizara), y no solo por lo que dijo esa conexión en su saludo",
+        "fix": "@dotrino/proxy-client 0.36.1"
+      },
+      {
+        "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/vault/VERSION.txt

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

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

@@ -5,4 +5,4 @@
  * si no coincide con la del paquete: una versión anunciada que no es la que corre es peor
  * que no anunciar ninguna.
  */
-export const LIB_VERSION = '0.86.1'
+export const LIB_VERSION = '0.90.0'