@dotrino/identity 0.114.1 → 0.116.0

package/vault/vendor/vault/core/approvals.js

@@ -0,0 +1,204 @@
+/**
+ * PEDIDOS DE APROBACIÓN Y CONCESIONES (puro: sin red ni disco).
+ *
+ * Un aparato marcado con `approval on` no recibe claves privadas solo por tener el cert: el
+ * vault apunta el pedido, avisa a los aparatos con `approve` (el teléfono), y solo su firma
+ * libera los secretos. Lo que nadie aprueba vence solo a los 5 min.
+ *
+ * Lo que se guarda de cada pedido es lo justo para contestar después: el cajón, quién pide,
+ * su llave efímera `ek` (a la que se sella la respuesta) y **qué comando está corriendo y
+ * desde dónde**. Nunca un valor.
+ *
+ * LA CONCESIÓN POR COMANDO (dueño, 2026-09-11). Antes no había ventana: cada petición era un
+ * pedido, y para un servicio bien hecho eso era una por arranque. Dejó de alcanzar en cuanto
+ * los pedidos empezaron a decir QUÉ comando piden: si el dueño ya dijo que sí a ese comando
+ * exacto desde esa carpeta exacta, volver a timbrarle por lo mismo es ruido. Así que aprobar
+ * concede **una hora, contada desde el último uso** — o sea que un servicio que sigue
+ * pidiendo la mantiene viva indefinidamente, que es lo que se pidió. Lo que la corta: que
+ * cambie el comando o la carpeta (otra huella, otro pedido), una hora entera sin usarla,
+ * revocarla a mano, o reiniciar la bóveda (viven en memoria y no se escriben en ningún
+ * sitio: un permiso que sobrevive a un reinicio es un permiso que nadie recuerda haber dado).
+ *
+ * SIN COMANDO NO HAY CONCESIÓN. Un pedido que no dice qué está corriendo —porque vino de
+ * otra máquina por el proxio, donde mandarlo en claro filtraría las rutas del dueño— no
+ * tiene huella con la que emparejarse, y entonces se pide aprobación cada vez. No se
+ * inventa una huella «vacía» que valdría para todo: eso sería exactamente un repliegue.
+ *
+ * Y PARA EL GESTOR DE CONTRASEÑAS ESO ES LO QUE SE QUIERE, no una carencia que arreglar
+ * (dueño, 2026-09-11: «para el gestor de contraseñas es perfecto»). La extensión es un
+ * navegador hablando por el proxio, no un proceso con línea de comandos, así que nunca va a
+ * traer huella — y así cada acceso a una credencial vuelve a pasar por tu mano, que es la
+ * protección por la que esto existe. No se le busque un sustituto del comando para que
+ * entre en la ventana.
+ */
+import { commandFingerprint } from '../procContext.js'
+
+const rnd = () => [...crypto.getRandomValues(new Uint8Array(8))].map((b) => b.toString(16).padStart(2, '0')).join('')
+
+/** Separador de la llave compuesta. Es un byte que no puede aparecer en un cajón ni en una pubkey. */
+const SEP = String.fromCharCode(0)
+
+/**
+ * LO QUE DURA UN PEDIDO SIN CONTESTAR, y por qué son dos números y no uno.
+ *
+ * CINCO MINUTOS es lo correcto para un COMANDO: hay un proceso bloqueado esperando, y
+ * aprobar media hora más tarde entregaría claves a algo cuyo contexto ya cambió — la
+ * carpeta, el comando o la máquina pueden ser otros. Que caduque rápido es la protección.
+ *
+ * UNA ACTUALIZACIÓN no se parece en nada (dueño, 2026-09-20): no hay nadie esperando, y
+ * caducar no protege de nada — solo significa que mañana se vuelve a pedir y se vuelve a
+ * perder, porque mirar el teléfono puede tardar horas. Un pedido que nunca llega a tiempo
+ * es una función que no existe.
+ *
+ * Por eso el plazo es DEL PEDIDO y no de la mesa. Quien pide dice cuánto aguanta lo suyo.
+ */
+export const PENDING_TTL_MS = 5 * 60 * 1000
+/**
+ * Y el de una actualización: un día. Cuadra con que la bóveda mire una vez al día — pedir
+ * otra vez reemplaza el pedido anterior del mismo cajón y aparato, así que siempre hay
+ * exactamente uno vivo, en vez de una cola de avisos caducados.
+ */
+export const UPDATE_TTL_MS = 24 * 60 * 60 * 1000
+/** Lo que dura una concesión SIN USARSE. Cada uso la vuelve a poner en una hora. */
+export const GRANT_TTL_MS = 60 * 60 * 1000
+
+export function createApprovals ({ now = Date.now, pendingTtlMs = PENDING_TTL_MS } = {}) {
+  /** id → { id, ns, device, deviceId, label, ek, ctx, ts, exp, from } */
+  const pending = new Map()
+  /**
+   * EL CONTEXTO VA EN LA LISTA, Y QUIEN LA SACA POR LA RED LO ENVUELVE.
+   *
+   * `ctx` es el comando y el path del dueño: por el mostrador local y en la consola de su
+   * propia máquina se enseña tal cual, pero al teléfono viaja por el proxio y ahí va dentro
+   * de un sobre (`handleApproval`). Si mañana aparece otro sitio que publique esta lista,
+   * esto es lo que hay que recordar.
+   */
+  // `kind` dice QUÉ se pide: `read` (llevarse las claves, lo de siempre) o `write` (guardar
+  // variables). La pantalla del teléfono no puede decir «pide tus claves» a una escritura.
+  const publicOf = (p) => ({ id: p.id, ns: p.ns, kind: p.kind, deviceId: p.deviceId, label: p.label, ts: p.ts, exp: p.exp, ctx: p.ctx || null })
+
+  return {
+    /** Apunta un pedido. Uno por cajón y aparato: pedir otra vez reemplaza al anterior. */
+    /**
+     * `from` es POR DÓNDE ENTRÓ la pregunta. La respuesta llega más tarde —cuando alguien
+     * apruebe— y tiene que volver por el mismo sitio: desde que la bóveda atiende también
+     * por un socket local, mandarla siempre por el proxio la dejaba en el vacío.
+     */
+    request ({ ns, device, deviceId, label = '', ek, ctx = null, from = null, ttlMs = null, kind = 'read' }) {
+      // Pedir las claves otra vez reemplaza al pedido anterior: es la misma pregunta. Una
+      // ESCRITURA no: cada una lleva su propio valor, y reemplazarla tiraría la anterior
+      // sin que nadie dijera que no.
+      if (kind !== 'write') for (const [id, p] of pending) if (p.kind !== 'write' && p.ns === ns && p.device === device) pending.delete(id)
+      const ts = now()
+      // `ttlMs` lo pone quien pide: una actualización aguanta un día y un comando cinco
+      // minutos, y la mesa no tiene por qué saber cuál es cuál (ver `PENDING_TTL_MS`).
+      const p = { id: rnd(), ns, kind, device, deviceId, label, ek, ctx, ts, exp: ts + (ttlMs || pendingTtlMs), from }
+      pending.set(p.id, p)
+      return publicOf(p)
+    },
+    /** Los pedidos vivos, sin la `ek` (no hace falta fuera de aquí). */
+    list () { this.sweep(); return [...pending.values()].map(publicOf) },
+    /** Saca un pedido para resolverlo (aprobar o denegar). `null` si no existe o venció. */
+    take (id) {
+      this.sweep()
+      const p = pending.get(id)
+      if (p) pending.delete(id)
+      return p || null
+    },
+    /** Tira lo vencido; devuelve los pedidos que vencieron, para anotarlos. */
+    sweep () {
+      const t = now(); const gone = []
+      for (const [id, p] of pending) if (p.exp <= t) { pending.delete(id); gone.push(publicOf(p)) }
+      return gone
+    }
+  }
+}
+
+/**
+ * LAS CONCESIONES VIVAS: «este comando, desde esta carpeta, ya está aprobado».
+ *
+ * La llave es cajón + aparato + huella del comando. Nada de esto se escribe en disco.
+ */
+export function createGrants ({ now = Date.now, ttlMs = GRANT_TTL_MS } = {}) {
+  /** key → { id, ns, device, deviceId, fp, ctx, by, grantedAt, lastAt, exp, uses } */
+  const grants = new Map()
+  const keyOf = (ns, device, fp) => ns + SEP + device + SEP + fp
+  const publicOf = (g) => ({
+    id: g.id, ns: g.ns, deviceId: g.deviceId, fp: g.fp, ctx: g.ctx,
+    by: g.by, grantedAt: g.grantedAt, lastAt: g.lastAt, exp: g.exp, uses: g.uses
+  })
+
+  const api = {
+    /**
+     * Anota que este comando quedó aprobado. Devuelve la concesión, o `null` si el pedido no
+     * traía comando: sin huella no hay nada que recordar, y el próximo pedido volverá a
+     * timbrar. Que eso se diga en el log es cosa de quien llama.
+     */
+    grant ({ ns, device, deviceId = null, ctx = null, by = null }) {
+      const fp = commandFingerprint(ctx)
+      if (!fp) return null
+      const t = now()
+      const g = { id: rnd(), ns, device, deviceId, fp, ctx, by, grantedAt: t, lastAt: t, exp: t + ttlMs, uses: 0 }
+      grants.set(keyOf(ns, device, fp), g)
+      return publicOf(g)
+    },
+    /**
+     * ¿Está este comando ya aprobado? Si lo está, **la concesión se estira**: la hora cuenta
+     * desde el último uso, no desde que se dio. Devuelve la concesión (ya refrescada) o `null`.
+     */
+    allows ({ ns, device, ctx }) {
+      api.sweep()
+      const fp = commandFingerprint(ctx)
+      if (!fp) return null
+      const g = grants.get(keyOf(ns, device, fp))
+      if (!g) return null
+      const t = now()
+      g.lastAt = t
+      g.exp = t + ttlMs
+      g.uses += 1
+      return publicOf(g)
+    },
+    /** Las concesiones vivas. */
+    list () { api.sweep(); return [...grants.values()].map(publicOf) },
+    /** Corta una por su id. `true` si existía. */
+    revoke (id) {
+      for (const [k, g] of grants) if (g.id === id) { grants.delete(k); return true }
+      return false
+    },
+    /** Corta todas, o las de un cajón / un aparato. Devuelve cuántas se fueron. */
+    revokeAll ({ ns = null, device = null } = {}) {
+      let n = 0
+      for (const [k, g] of grants) {
+        if (ns && g.ns !== ns) continue
+        if (device && g.device !== device) continue
+        grants.delete(k); n++
+      }
+      return n
+    },
+    /** Tira lo vencido; devuelve lo que se fue, para anotarlo. */
+    sweep () {
+      const t = now(); const gone = []
+      for (const [k, g] of grants) if (g.exp <= t) { grants.delete(k); gone.push(publicOf(g)) }
+      return gone
+    }
+  }
+  return api
+}
+
+/**
+ * ¿SE LLEVÓ UNA LIMPIEZA AL ÚLTIMO QUE APROBABA? Devuelve los aprobadores que se fueron si
+ * antes había alguno y ahora no queda ninguno; si no, una lista vacía.
+ *
+ * Una cuenta SIN aprobadores puede ser legítima (todo desatendido, se actualiza sola), así
+ * que el aviso no es «no hay aprobadores»: es «LOS HABÍA y acabas de perder el último».
+ *
+ * @param {string[]} before  llaves con `approve` antes
+ * @param {string[]} after   llaves con `approve` después
+ * @param {string[]} removed llaves que salieron del acta
+ */
+export function lastApproverGone (before, after, removed) {
+  if (!before.length || after.length) return []
+  return removed.filter((pub) => before.includes(pub))
+}
+
+export default { createApprovals, createGrants, lastApproverGone, PENDING_TTL_MS, UPDATE_TTL_MS, GRANT_TTL_MS }

package/vault/vendor/vault/core/blocked.js

@@ -0,0 +1,68 @@
+/**
+ * LOS APARATOS BLOQUEADOS: la lista que un aprobador decide y solo la bóveda deshace.
+ *
+ * Un agente (la terminal, por ahora) reporta un INCIDENTE cuando un aparato de la cuenta se
+ * equivoca de clave tres veces seguidas. El aprobador lo ve en su teléfono y elige: bloquear
+ * o ignorar. Bloquear NO es revocar: el aparato sigue en el acta —no hace falta la maestra, y
+ * la bóveda vive cerrada—, pero la bóveda deja de atenderle y los agentes, que reciben esta
+ * lista con el acta, le cierran la puerta. Se deshace aquí (`dotrino-vault unblock <ID>`) o
+ * desde la consola de administración; un aprobador solo bloquea.
+ *
+ * Va en el disco cifrado en reposo como las contraseñas: es parte del mapa de la cuenta.
+ * Se carga UNA vez: un archivo que existe y no se puede leer NO es «nadie bloqueado» — se
+ * lanza, y la bóveda no arranca con una lista que no puede saber.
+ */
+
+export const BLOCKED_FILE = 'blocked.json'
+
+const fail = (code, message) => Object.assign(new Error(message), { code })
+
+/**
+ * @param {{ disk: object, now?: () => number }} opts
+ */
+export function openBlocked ({ disk, now = Date.now }) {
+  const file = BLOCKED_FILE
+  const atRest = disk.atRest
+  /** pub → { deviceId, label, since, by, reason } */
+  let items = load()
+
+  function load () {
+    let raw
+    try { raw = disk.read(file) } catch (e) {
+      throw fail('blocked-unreadable', `cannot read ${BLOCKED_FILE}: ${e.message}`)
+    }
+    if (raw == null) return new Map()
+    let d
+    try { d = JSON.parse(atRest.decrypt(raw)) } catch (e) { throw fail('blocked-unreadable', `${BLOCKED_FILE} cannot be opened: ${e.message}`) }
+    if (d?.v !== 1 || !d.items || typeof d.items !== 'object') throw fail('blocked-unreadable', `${BLOCKED_FILE} has an unknown shape`)
+    return new Map(Object.entries(d.items))
+  }
+
+  function save () {
+    disk.write(file, atRest.encrypt(JSON.stringify({ v: 1, items: Object.fromEntries(items) })))
+  }
+
+  const publicOf = (pub, b) => ({ pub, deviceId: b.deviceId || null, label: b.label || '', since: b.since, by: b.by || null, reason: b.reason || null })
+
+  return {
+    has: (pub) => items.has(pub),
+    pubs: () => [...items.keys()],
+    list: () => [...items].map(([pub, b]) => publicOf(pub, b)),
+    /** Bloquea. Devuelve la entrada; si ya estaba, la que había (no se pisa el «desde cuándo»). */
+    block ({ pub, deviceId = null, label = '', by = null, reason = null }) {
+      if (typeof pub !== 'string' || !pub) throw fail('bad-pub', 'block: a device key is required')
+      if (items.has(pub)) return publicOf(pub, items.get(pub))
+      const b = { deviceId, label, since: now(), by, reason }
+      items.set(pub, b)
+      save()
+      return publicOf(pub, b)
+    },
+    /** Desbloquea. `true` si estaba. */
+    unblock (pub) {
+      if (!items.has(pub)) return false
+      items.delete(pub)
+      save()
+      return true
+    }
+  }
+}

package/vault/vendor/vault/core/browserDisk.js

@@ -0,0 +1,109 @@
+/**
+ * EL DISCO DE LA BÓVEDA EN EL NAVEGADOR (pestaña y extensión).
+ *
+ * El núcleo lee y escribe de forma síncrona (`./disk.js`), y en el navegador el único
+ * almacén que aguanta es IndexedDB, que es asíncrono. Así que al abrir se cargan TODOS los
+ * archivos del perfil a memoria, y cada escritura se guarda por detrás. Son una docena de
+ * archivos pequeños: caben de sobra.
+ *
+ * NADA EN CLARO EN EL DISCO. Cada archivo se guarda cifrado con AES-GCM bajo una llave que
+ * se crea aquí NO EXTRAÍBLE y vive en la misma base: el navegador la puede usar y nadie la
+ * puede leer, que es lo más parecido que hay en un navegador a la llave ligada a la máquina
+ * del binario. Por eso el cifrado en reposo del núcleo (`atRest`) aquí no hace nada: lo hace
+ * el almacén entero, archivo por archivo.
+ *
+ * LO QUE NO PROMETE, dicho: una escritura que no llegó a IndexedDB antes de cerrar la
+ * pestaña se pierde. Se guarda en cuanto se escribe (sin esperar a juntar), y `flush()`
+ * espera a que todo esté guardado.
+ */
+import { memoryDisk } from './disk.js'
+
+const STORE = 'files'
+const KEY_ID = '\u0000key'
+
+function idb (req) {
+  return new Promise((resolve, reject) => {
+    req.onsuccess = () => resolve(req.result)
+    req.onerror = () => reject(req.error)
+  })
+}
+
+function openDb (name) {
+  const req = indexedDB.open(name, 1)
+  req.onupgradeneeded = () => { req.result.createObjectStore(STORE) }
+  return idb(req)
+}
+
+const tx = (db, mode) => db.transaction(STORE, mode).objectStore(STORE)
+
+/**
+ * @param {string} name  la base de este perfil (`dotrino-vault.<perfil>`)
+ * @returns {Promise<object>} un disco (`./disk.js`) con `flush()` y `close()`
+ */
+export async function openBrowserDisk (name) {
+  if (typeof indexedDB === 'undefined') throw Object.assign(new Error('this browser has no IndexedDB: the vault cannot keep anything here'), { code: 'no-indexeddb' })
+  const db = await openDb(name)
+
+  let key = await idb(tx(db, 'readonly').get(KEY_ID))
+  if (!key) {
+    key = await crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt'])
+    await idb(tx(db, 'readwrite').put(key, KEY_ID))
+  }
+
+  // Todo a memoria. Un archivo que está y no se abre NO se salta: el núcleo decidiría con
+  // un archivo vacío (una lista de bloqueados vacía, un acta sin cajones), y eso es justo
+  // el repliegue que no se pone. Se para y se dice cuál.
+  const files = new Map()
+  const names = await idb(tx(db, 'readonly').getAllKeys())
+  for (const n of names) {
+    if (n === KEY_ID) continue
+    const rec = await idb(tx(db, 'readonly').get(n))
+    try {
+      const plain = await crypto.subtle.decrypt({ name: 'AES-GCM', iv: rec.iv }, key, rec.ct)
+      files.set(n, new TextDecoder().decode(plain))
+    } catch (e) {
+      throw Object.assign(new Error(`vault storage: ${n} cannot be opened (${e?.message || e})`), { code: 'disk-unreadable', file: n })
+    }
+  }
+
+  // Las escrituras van en orden y una detrás de otra: la última manda.
+  let queue = Promise.resolve()
+  let lastError = null
+  const persist = (n) => {
+    queue = queue.then(async () => {
+      if (!files.has(n)) { await idb(tx(db, 'readwrite').delete(n)); return }
+      const iv = crypto.getRandomValues(new Uint8Array(12))
+      const ct = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, key, new TextEncoder().encode(files.get(n)))
+      await idb(tx(db, 'readwrite').put({ iv, ct }, n))
+    }).catch((e) => {
+      lastError = e
+      console.error(`[vault] could not save ${n} in this browser: ${e?.message || e}`)
+    })
+  }
+
+  // LA LLAVE DE LA MÁQUINA (`machineKey`): 32 bytes al azar, creados una vez. Es con lo que
+  // el núcleo cierra lo que tiene que abrirse con el perfil cerrado; aquí vale lo que vale
+  // este almacén, igual que en el binario vale lo que vale su disco.
+  const MACHINE = 'machine.key'
+  if (!files.has(MACHINE)) {
+    const raw = crypto.getRandomValues(new Uint8Array(32))
+    let s = ''; for (const b of raw) s += String.fromCharCode(b)
+    files.set(MACHINE, btoa(s))
+    persist(MACHINE)
+  }
+  const machineKey = () => Uint8Array.from(atob(files.get(MACHINE)), (c) => c.charCodeAt(0))
+
+  const disk = memoryDisk({ files, machineKey, onChange: persist })
+  return {
+    ...disk,
+    name,
+    /** Espera a que lo escrito esté en IndexedDB. Lanza si algo no se pudo guardar. */
+    async flush () {
+      await queue
+      if (lastError) { const e = lastError; lastError = null; throw e }
+    },
+    close () { try { db.close() } catch (_) {} }
+  }
+}
+
+export default { openBrowserDisk }

package/vault/vendor/vault/core/commKey.js

@@ -0,0 +1,68 @@
+/**
+ * commKey.js — LA LLAVE DE COMUNICACIÓN de esta bóveda.
+ *
+ * La maestra tiene dos trabajos y ninguno más: **sellar el acta y reenvolver los sobres**
+ * (dueño, 2026-08-31). Hablar por la red no es suyo. Todo lo demás —identificarse ante el
+ * proxio, firmar lo que se sirve— lo hace esta llave, y **su autoridad la dice el acta**,
+ * donde entra como un miembro más.
+ *
+ * Por qué eso importa y no es un rodeo: mientras la maestra fuera la que se identificaba,
+ * no podía vivir bajo llave — `identify` firma en cada conexión y en cada reconexión, así
+ * que una bóveda cerrada no habría existido en la red. Sacándola de ahí, la maestra solo
+ * sale con el perfil abierto y el candado deja de ser una bandera.
+ *
+ * Tres propiedades, y las tres son a propósito:
+ *
+ *   · **Firmar no es leer.** No abre ningún valor. Por eso puede vivir cifrada en reposo
+ *     con la llave de la máquina y usarse SIN la frase — que es lo que hace que la bóveda
+ *     siga sirviendo con el candado echado.
+ *   · **ESTABLE.** No rota con cada acta, al revés que la vieja `sealPub`: es un miembro,
+ *     y un miembro no cambia de llave cada vez que se toca el acta. Rota cuando se decide,
+ *     como cualquier aparato.
+ *   · **Acotada por `cn`.** Entra con `cn: 'vault'`, así que el acta la trata como un
+ *     SERVICIO: `memberCanSign` sin cajón le dice que no. Puede hablar por la bóveda, no
+ *     firmar por la persona. Si alguien se lleva el disco, se lleva eso y nada más.
+ */
+import { readJson, writeJson } from './disk.js'
+import { signWithDevice } from '@dotrino/identity/capabilities'
+
+/** El `cn` con el que entra en el acta. Es un servicio del perfil, no un aparato tuyo. */
+export const COMM_CN = 'vault'
+/** Lo que puede: firmar (acotado por su `cn`). Nada de leer, guardar ni sellar. */
+export const COMM_CAPS = Object.freeze(['sign'])
+
+/** Abre (o estrena) la llave de comunicación del perfil. */
+export function openCommKey (disk) {
+  const file = 'commkey.json'
+  let data = readJson(disk, file, null)
+  if (!data || typeof data !== 'object' || !data.pub) data = null
+
+  return {
+    /** La pública, o `null` si todavía no se ha estrenado. */
+    pub: () => data?.pub || null,
+
+    /**
+     * Estrena la llave si no existe y devuelve su pública. Idempotente: llamarla dos veces
+     * NO cambia de llave — cambiarla dejaría al acta nombrando una que ya no tenemos y a la
+     * bóveda sin poder identificarse hasta el siguiente sellado.
+     */
+    async ensure () {
+      if (data?.pub) return data.pub
+      const pair = await crypto.subtle.generateKey({ name: 'ECDSA', namedCurve: 'P-256' }, true, ['sign', 'verify'])
+      const pub = JSON.stringify(await crypto.subtle.exportKey('jwk', pair.publicKey))
+      const priv = await crypto.subtle.exportKey('jwk', pair.privateKey)
+      data = { v: 1, pub, priv, createdAt: Date.now() }
+      writeJson(disk, file, data)
+      return pub
+    },
+
+    /** Firma un cuerpo. `null` si aún no hay llave (no se estrena una al vuelo: ver `ensure`). */
+    async sign (body) {
+      if (!data?.priv) return null
+      const { signature } = await signWithDevice({ privateJwk: data.priv, publickey: data.pub, data: body })
+      return signature
+    }
+  }
+}
+
+export default { openCommKey, COMM_CN, COMM_CAPS }

package/vault/vendor/vault/core/disk.js

@@ -0,0 +1,65 @@
+/**
+ * EL DISCO DE UNA BÓVEDA, el mismo para el binario y para el navegador.
+ *
+ * La bóveda guarda una docena de archivos pequeños (`vault.json`, `secrets.json`,
+ * `blocked.json`, la bitácora…) y los lee y escribe de forma SÍNCRONA: se consultan por
+ * cada mensaje que entra, y convertir cada lectura en un `await` cambiaría el orden en que
+ * pasan las cosas en todo el núcleo. Por eso el disco es una interfaz síncrona, y quien
+ * monta la bóveda pone la suya:
+ *
+ *   · el binario, archivos de verdad bajo el directorio del perfil (`src/disk.js`);
+ *   · el navegador, una copia en memoria que se guarda cifrada en IndexedDB por detrás
+ *     (`./browserDisk.js`).
+ *
+ * Interfaz (nombres relativos al perfil, nunca rutas):
+ *
+ *   read(name)          → el texto, o `null` si no existe. Otro fallo LANZA: un archivo
+ *                         que está y no se puede leer no es un archivo vacío.
+ *   write(name, text)   → reemplaza entero, de golpe (a medio escribir no queda nada).
+ *   append(name, text)  → añade al final.
+ *   exists(name), remove(name), rename(from, to), size(name)
+ *   atRest              → `{ encrypt(text), decrypt(text) }`, síncronos: el cifrado en
+ *                         reposo de ESTE disco. En el binario va ligado a la máquina; en el
+ *                         navegador el cifrado lo hace el almacén entero y aquí no se toca.
+ *   machineKey()        → 32 bytes: la llave de la máquina (`kekFor`). Es con lo que se
+ *                         cierra lo que tiene que abrirse con el perfil cerrado.
+ */
+
+/** Lee un JSON cifrado en reposo. Lo que no está o no se puede leer devuelve `fallback`. */
+export function readJson (disk, name, fallback) {
+  try {
+    const raw = disk.read(name)
+    if (raw == null) return fallback
+    return JSON.parse(disk.atRest.decrypt(raw))
+  } catch (_) { return fallback }
+}
+
+/** Escribe un JSON cifrado en reposo, entero y de golpe. */
+export function writeJson (disk, name, obj) {
+  disk.write(name, disk.atRest.encrypt(JSON.stringify(obj, null, 2)))
+}
+
+/**
+ * Un disco en memoria, sin nada detrás. Es la base del del navegador (que lo vuelca a
+ * IndexedDB) y el de las pruebas. `files` es un `Map` nombre → texto.
+ */
+export function memoryDisk ({ files = new Map(), atRest = null, machineKey = null, onChange = () => {} } = {}) {
+  const key = machineKey || (() => { throw Object.assign(new Error('this disk has no machine key'), { code: 'no-machine-key' }) })
+  return {
+    files,
+    read: (name) => (files.has(name) ? files.get(name) : null),
+    write: (name, text) => { files.set(name, String(text)); onChange(name) },
+    append: (name, text) => { files.set(name, (files.get(name) || '') + String(text)); onChange(name) },
+    exists: (name) => files.has(name),
+    remove: (name) => { if (files.delete(name)) onChange(name) },
+    rename: (from, to) => {
+      if (!files.has(from)) throw Object.assign(new Error(`rename: ${from} does not exist`), { code: 'ENOENT' })
+      files.set(to, files.get(from)); files.delete(from); onChange(from); onChange(to)
+    },
+    size: (name) => (files.has(name) ? new TextEncoder().encode(files.get(name)).length : 0),
+    atRest: atRest || { encrypt: (t) => t, decrypt: (t) => t },
+    machineKey: key
+  }
+}
+
+export default { readJson, writeJson, memoryDisk }

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

@@ -0,0 +1,8 @@
+/**
+ * LA VERSIÓN DE `@dotrino/vault`, escrita aquí porque el navegador no puede leer el
+ * `package.json`. Con esta se anuncia la bóveda de la pestaña y de la extensión
+ * (`@dotrino/compat`). Una prueba (`test/version-del-navegador.test.mjs`) para el release
+ * 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.0'

package/vault/vendor/vault/core/machines.js

@@ -0,0 +1,66 @@
+/**
+ * DÓNDE CORRE CADA APARATO, según lo último que dijo (`@dotrino/identity/machine`).
+ *
+ * El acta guarda lo que el aparato dijo AL EMPAREJARSE, y eso no cambia sin una firma de la
+ * maestra. Aquí va lo que dice en cada pedido firmado: así un aparato que entró antes de que
+ * existiera el campo aparece con su máquina en cuanto se actualiza y habla, y uno que cambió
+ * de sistema sale al día. La lista enseña esto primero y, si no hay, lo del acta.
+ *
+ * NO DECIDE NADA: se enseña. Lo dice el propio aparato, dentro de lo que firma; nadie más lo
+ * puede escribir por él, pero tampoco prueba nada.
+ *
+ * Cifrado en reposo como lo demás. Un archivo que existe y no se puede leer se lanza.
+ */
+import { cleanMachine, sameMachine } from '@dotrino/identity/machine'
+
+export const MACHINES_FILE = 'machines.json'
+
+const fail = (code, message) => Object.assign(new Error(message), { code })
+
+/**
+ * @param {{ disk: object, now?: () => number }} opts
+ */
+export function openMachines ({ disk, now = Date.now }) {
+  const file = MACHINES_FILE
+  const atRest = disk.atRest
+  /** pub → { kind, os, name, at } */
+  const items = load()
+
+  function load () {
+    let raw
+    try { raw = disk.read(file) } catch (e) {
+      throw fail('machines-unreadable', `cannot read ${MACHINES_FILE}: ${e.message}`)
+    }
+    if (raw == null) return new Map()
+    let d
+    try { d = JSON.parse(atRest.decrypt(raw)) } catch (e) { throw fail('machines-unreadable', `${MACHINES_FILE} cannot be opened: ${e.message}`) }
+    if (d?.v !== 1 || !d.items || typeof d.items !== 'object') throw fail('machines-unreadable', `${MACHINES_FILE} has an unknown shape`)
+    return new Map(Object.entries(d.items))
+  }
+
+  function save () {
+    disk.write(file, atRest.encrypt(JSON.stringify({ v: 1, items: Object.fromEntries(items) })))
+  }
+
+  return {
+    /**
+     * Lo que acaba de decir un aparato. Solo se escribe si cambió: casi todos los pedidos
+     * repiten lo de siempre, y reescribir el archivo en cada uno sería disco para nada.
+     * Lo que no tiene forma de máquina no borra lo que ya había.
+     */
+    note (pub, raw) {
+      if (typeof pub !== 'string' || !pub) throw fail('bad-pub', 'note: a device key is required')
+      const m = cleanMachine(raw)
+      if (!m) return false
+      if (sameMachine(items.get(pub), m)) return false
+      items.set(pub, { ...m, at: now() })
+      save()
+      return true
+    },
+    /** Lo último que dijo, o `null` si nunca dijo nada. */
+    of (pub) {
+      const m = items.get(pub)
+      return m ? { ...m } : null
+    }
+  }
+}

package/vault/vendor/vault/core/notices.js

@@ -0,0 +1,71 @@
+/**
+ * LO QUE LA BÓVEDA TIENE QUE CONTARLE A QUIEN APRUEBA, y que no es un pedido.
+ *
+ * Son dos, de la bóveda o de uno de sus aparatos: «me actualicé» y «hay versión nueva y
+ * necesita permisos de administrador: instálala a mano» (`update-needs-root`). (`ev: 'updated'`, dueño 2026-10-08: «las actualizaciones, que se
+ * envíe una notificación de que ocurrieron a los aprobadores»). Sale como aviso por el
+ * proxio, pero el timbre de una app nativa llega VACÍO —lo leen Google y Apple—, así que la
+ * app pregunta por su lista (`op: 'approvals'`) y lo lee de aquí, en `notices`.
+ *
+ * Caduca a las 24 h: es una noticia, no un registro (eso es la bitácora).
+ *
+ * Cifrado en reposo como lo demás. Un archivo que existe y no se puede leer se LANZA: callar
+ * sería decir «no pasó nada» de algo que sí pasó.
+ */
+
+export const NOTICES_FILE = 'notices.json'
+/** Cuánto se sigue contando un aviso. */
+export const NOTICE_TTL_MS = 24 * 60 * 60 * 1000
+/** Los avisos que existen. */
+export const NOTICE_EVS = ['updated', 'update-needs-root']
+
+const fail = (code, message) => Object.assign(new Error(message), { code })
+
+/**
+ * @param {{ disk: object, now?: () => number }} opts
+ */
+export function openNotices ({ disk, now = Date.now }) {
+  const file = NOTICES_FILE
+  const atRest = disk.atRest
+  let items = load()
+
+  function load () {
+    if (!disk.exists(file)) return []
+    try {
+      const d = JSON.parse(atRest.decrypt(disk.read(file)))
+      if (!d || !Array.isArray(d.items)) throw new Error('not a list')
+      return d.items.filter((n) => n && typeof n.id === 'string' && typeof n.ts === 'number')
+    } catch (e) { throw fail('notices-unreadable', `${NOTICES_FILE} cannot be read: ${e.message}`) }
+  }
+
+  function save () {
+    disk.write(file, atRest.encrypt(JSON.stringify({ v: 1, items })))
+  }
+
+  const alive = (n) => now() - n.ts < NOTICE_TTL_MS
+
+  return {
+    /**
+     * Apunta un aviso y lo devuelve tal como viaja. `ev`: `updated` (se actualizó) o
+     * `update-needs-root` (hay versión nueva y hay que instalarla a mano, con permisos de
+     * administrador). `product`: qué (`@dotrino/vaultd` es la propia bóveda);
+     * `deviceId`/`label`: el aparato, si fue uno.
+     */
+    add (ev, { version, from = null, product = '@dotrino/vaultd', deviceId = null, label = null }) {
+      if (!NOTICE_EVS.includes(ev)) throw fail('bad-notice', `unknown notice: ${ev}`)
+      if (typeof version !== 'string' || !version) throw fail('bad-notice', `${ev}: a version is required`)
+      if (typeof product !== 'string' || !product) throw fail('bad-notice', `${ev}: a product is required`)
+      const n = {
+        id: [...crypto.getRandomValues(new Uint8Array(8))].map((b) => b.toString(16).padStart(2, '0')).join(''), ev, product, version, from: typeof from === 'string' ? from : null,
+        ...(typeof deviceId === 'string' && deviceId ? { deviceId, label: typeof label === 'string' ? label : '' } : {}),
+        ts: now()
+      }
+      items = [...items.filter(alive), n]
+      save()
+      return n
+    },
+    updated (o) { return this.add('updated', o) },
+    /** Los avisos vivos, del más viejo al más nuevo. */
+    list () { return items.filter(alive).map((n) => ({ ...n })) }
+  }
+}