@dotrino/identity 0.114.1 → 0.116.0

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.

package/vault/vendor/passmanager/crypto.js

@@ -0,0 +1,167 @@
+// Cifrado de las entradas de la bóveda.
+//
+// Una CEK (AES-GCM 256) por bóveda, con la que se cifra cada entrada por separado.
+// Quién tiene la CEK es lo que define la confianza de cada aparato (DISENO §3): al
+// vault y a la app nativa se les envuelve; a la extensión, no.
+//
+// El envoltorio de la CEK a cada miembro NO se hace aquí: eso es `wrapForMember` de
+// @dotrino/identity/content, que ya está escrito y probado. Este módulo es solo el
+// tramo simétrico.
+
+const enc = new TextEncoder()
+const dec = new TextDecoder()
+
+/** WebCrypto del entorno (navegador, service worker o Node ≥ 20). */
+function subtle () {
+  const c = globalThis.crypto
+  if (!c?.subtle) throw new Error('webcrypto unavailable')
+  return c.subtle
+}
+
+function randomBytes (n) {
+  const b = new Uint8Array(n)
+  globalThis.crypto.getRandomValues(b)
+  return b
+}
+
+export function toBase64 (bytes) {
+  let s = ''
+  for (const b of bytes) s += String.fromCharCode(b)
+  return btoa(s)
+}
+
+export function fromBase64 (b64) {
+  const s = atob(b64)
+  const out = new Uint8Array(s.length)
+  for (let i = 0; i < s.length; i++) out[i] = s.charCodeAt(i)
+  return out
+}
+
+/** Genera una CEK nueva. Extraíble: hay que poder envolverla para cada aparato. */
+export async function makeVaultKey () {
+  return subtle().generateKey({ name: 'AES-GCM', length: 256 }, true, ['encrypt', 'decrypt'])
+}
+
+export async function exportVaultKey (key) {
+  return new Uint8Array(await subtle().exportKey('raw', key))
+}
+
+export async function importVaultKey (raw) {
+  return subtle().importKey('raw', raw, { name: 'AES-GCM' }, true, ['encrypt', 'decrypt'])
+}
+
+/**
+ * Cifra un valor con la CEK. Devuelve `{ iv, ct }` en base64, para que una entrada
+ * cifrada siga siendo JSON serializable tal cual.
+ *
+ * `aad` ata el criptograma a su sitio: se pasa el id de la entrada y el campo, así
+ * que un criptograma movido de una entrada a otra (o de `secret` a `totp`) no abre.
+ */
+export async function sealValue (key, plaintext, aad) {
+  const iv = randomBytes(12)
+  const params = { name: 'AES-GCM', iv }
+  if (aad) params.additionalData = enc.encode(aad)
+  const ct = await subtle().encrypt(params, key, enc.encode(plaintext))
+  return { iv: toBase64(iv), ct: toBase64(new Uint8Array(ct)) }
+}
+
+export async function openValue (key, sealed, aad) {
+  if (!sealed || typeof sealed.iv !== 'string' || typeof sealed.ct !== 'string') {
+    throw new Error('sealed value malformed')
+  }
+  const params = { name: 'AES-GCM', iv: fromBase64(sealed.iv) }
+  if (aad) params.additionalData = enc.encode(aad)
+  const pt = await subtle().decrypt(params, key, fromBase64(sealed.ct))
+  return dec.decode(pt)
+}
+
+/** Etiqueta AAD de un campo. Un solo sitio para que sellar y abrir no se desalineen. */
+export function fieldTag (entryId, field) {
+  return `dotrino-passmanager/v1/${entryId}/${field}`
+}
+
+// --- Contraseña maestra ------------------------------------------------------
+//
+// Solo para el caso en que la bóveda vive en el propio aparato y no hay nadie más
+// que la custodie (la extensión antes del paso 2, DISENO §8). Cuando responde el
+// vault o el teléfono, la CEK llega envuelta y esto no se usa.
+
+const KDF_ITERATIONS = 600_000 // recomendación OWASP para PBKDF2-SHA256
+
+export function makeSalt () {
+  return randomBytes(16)
+}
+
+/**
+ * Deriva la CEK de una contraseña maestra.
+ *
+ * `extractable` existe por MV3: el service worker de la extensión se duerme, y un
+ * `CryptoKey` no sobrevive a `chrome.storage.session` (que serializa a JSON, no
+ * clona). Para no pedir la contraseña cada pocos minutos hay que poder exportar la
+ * clave y guardarla en memoria de sesión. Es un compromiso consciente y acotado a la
+ * extensión: donde no haga falta, se deriva no extraíble.
+ */
+export async function deriveKeyFromPassword (password, salt, iterations = KDF_ITERATIONS, extractable = false) {
+  const material = await subtle().importKey(
+    'raw', enc.encode(String(password)), 'PBKDF2', false, ['deriveKey'])
+  return subtle().deriveKey(
+    { name: 'PBKDF2', salt, iterations, hash: 'SHA-256' },
+    material,
+    { name: 'AES-GCM', length: 256 },
+    extractable,
+    ['encrypt', 'decrypt'],
+  )
+}
+
+/**
+ * Verificador de contraseña: un valor sellado con la propia clave derivada. No es un
+ * hash de la contraseña — es una prueba de que la clave abre la bóveda, que es lo que
+ * de verdad importa.
+ */
+export async function makeVerifier (key) {
+  return sealValue(key, 'dotrino-passmanager', 'verifier')
+}
+
+export async function checkVerifier (key, verifier) {
+  try {
+    return (await openValue(key, verifier, 'verifier')) === 'dotrino-passmanager'
+  } catch {
+    return false
+  }
+}
+
+// --- comparar sin abrir -------------------------------------------------------
+//
+// Para decir «esto que escribiste ya está guardado igual» hace falta comparar con lo
+// guardado, y abrir la entrada es una autorización (DISENO §3.3.2). La bóveda manda
+// entonces un **resumen** de cada campo: quien pregunta hashea lo que tiene delante y
+// compara los resúmenes.
+//
+// **Un solo método para todos los campos**, públicos y privados (dueño, 2026-08-29):
+// dos formas de comparar según qué campo sea son dos comportamientos que se separan y
+// acaban diciendo cosas distintas.
+//
+// El resumen va con un **nonce nuevo en cada respuesta**, así que no es una huella
+// estable: no vale para reconocer la misma contraseña entre dos respuestas, ni para
+// guardar una tabla y consultarla más tarde. Y el nombre del campo entra en el HMAC, así
+// que un resumen tampoco sirve para comparar contra otro campo.
+
+/** Un nonce nuevo, para UNA respuesta. No se guarda en ninguna parte. */
+export function makeNonce () {
+  return toBase64(randomBytes(16))
+}
+
+/**
+ * El hasheador de una respuesta. Se importa la llave UNA vez y se hashean todos los
+ * campos con ella: importar por campo multiplica el coste de un `find` sin ganar nada.
+ */
+export async function fieldHasher (nonce) {
+  const key = await subtle().importKey(
+    'raw', fromBase64(nonce), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign'])
+  return async (name, value) => {
+    const sig = await subtle().sign('HMAC', key, enc.encode(name + ' ' + value))
+    // 128 bits: de sobra para que dos valores distintos no colisionen en la práctica, y
+    // la mitad de bytes que mandar el SHA-256 entero.
+    return toBase64(new Uint8Array(sig).slice(0, 16))
+  }
+}