@dotrino/identity 0.115.0 → 0.116.0

package/vault/vendor/vault/core/notifiable.js

@@ -0,0 +1,73 @@
+/**
+ * QUÉ APROBADORES PUEDEN RECIBIR UN AVISO: lo dice cada uno, y caduca.
+ *
+ * Un aparato con `approve` que no recibe avisos es un aprobador solo en el papel: el pedido
+ * no le suena y solo lo ve si abre la app por su cuenta.
+ *
+ * Así que el aprobador lo declara: al pedir su lista de pedidos (`op: 'approvals'`, que ya
+ * manda firmado cada vez que se abre) dice `notify: true` si tiene los avisos encendidos.
+ * Aquí se apunta CUÁNDO lo dijo por última vez, y vale `NOTIFIABLE_TTL_MS`: una app que se
+ * desinstala deja de renovarlo.
+ *
+ * NO DECIDE NADA: SE ENSEÑA (dueño, 2026-10-08). Un día decidió si la bóveda pedía permiso
+ * para actualizarse —sin nadie que lo hubiera dicho, se actualizaba sola— y se quitó: era
+ * una condición más, y el silencio de un aprobador abría la puerta. Quién aprueba lo dice
+ * el acta y nada más; los avisos salen a todos los que tienen `approve`, lo hayan dicho o
+ * no. Esto sirve para VER a cuál no le está sonando el pedido (`members`, `status`, la
+ * consola).
+ *
+ * Y NO SE LE PREGUNTA AL PROXIO, que es quien guarda las suscripciones: es la pieza de la
+ * que el diseño no se fía, y creerle sería dejarle decidir cuándo no hace falta permiso.
+ *
+ * Cifrado en reposo como lo demás. Un archivo que existe y no se puede leer NO es «nadie
+ * puede recibir avisos»: se lanza.
+ */
+
+export const NOTIFIABLE_FILE = 'notifiable.json'
+/** Cuánto vale un «puedo recibir avisos» sin renovarse. */
+export const NOTIFIABLE_TTL_MS = 30 * 24 * 60 * 60 * 1000
+
+const fail = (code, message) => Object.assign(new Error(message), { code })
+
+/**
+ * @param {{ disk: object, now?: () => number }} opts
+ */
+export function openNotifiable ({ disk, now = Date.now }) {
+  const file = NOTIFIABLE_FILE
+  const atRest = disk.atRest
+  /** pub → ms de la última vez que dijo que sí */
+  const items = load()
+
+  function load () {
+    let raw
+    try { raw = disk.read(file) } catch (e) {
+      throw fail('notifiable-unreadable', `cannot read ${NOTIFIABLE_FILE}: ${e.message}`)
+    }
+    if (raw == null) return new Map()
+    let d
+    try { d = JSON.parse(atRest.decrypt(raw)) } catch (e) { throw fail('notifiable-unreadable', `${NOTIFIABLE_FILE} cannot be opened: ${e.message}`) }
+    if (d?.v !== 1 || !d.items || typeof d.items !== 'object') throw fail('notifiable-unreadable', `${NOTIFIABLE_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 aprobador. `true` lo apunta (o lo renueva); `false` lo quita
+     * ya, sin esperar a que caduque. Cualquier otra cosa no dice nada y no cambia nada: un
+     * cliente viejo, que no manda el campo, no borra lo que dijo uno nuevo.
+     */
+    declare (pub, canNotify) {
+      if (typeof pub !== 'string' || !pub) throw fail('bad-pub', 'declare: a device key is required')
+      if (canNotify === true) { items.set(pub, now()); save() } else if (canNotify === false && items.delete(pub)) save()
+    },
+    /** Cuándo lo dijo por última vez, o `null` si nunca o si ya caducó. */
+    since (pub) {
+      const t = items.get(pub)
+      return typeof t === 'number' && now() - t < NOTIFIABLE_TTL_MS ? t : null
+    }
+  }
+}

package/vault/vendor/vault/core/passwords.js

@@ -0,0 +1,125 @@
+/**
+ * LA BÓVEDA DE CONTRASEÑAS del dueño, atendida por el vault — Y QUE EL VAULT NO PUEDE LEER.
+ *
+ * Hasta 0.122 esto tenía una llave propia (`passwordsKey()`) guardada **dentro del mismo
+ * archivo que las entradas**, cifrada con la llave de la máquina. O sea: el demonio con el
+ * perfil CERRADO seguía descifrando contraseñas, y cualquiera con una copia del disco las
+ * leía todas. Era el mismo esquema que tuvo la maestra hasta que se selló.
+ *
+ * Ahora la bóveda es un cartero también para las contraseñas
+ * (`dotrino-passmanager/docs/sealed-passwords.md`): guarda sobres dirigidos a los aparatos
+ * y envolturas que no puede abrir. Lo que sí hace, y es lo que sostiene el modelo:
+ *
+ *   · dice A QUIÉN hay que envolver cada llave —sale del acta, y **la bóveda nunca está en
+ *     esa lista**: ni su maestra, ni su llave de comunicación;
+ *   · comprueba que quien escribe sea un aparato del acta con `passwords`, por su firma;
+ *   · filtra por destinatario al entregar, y decide si hace falta un dedo encima.
+ *
+ * Lo que SIGUE igual: el protocolo es de a una credencial, `list` no existe en remoto, y la
+ * aprobación es la misma del resto del vault (`caps +aprueba`).
+ */
+
+import { SealedStore, SealedResponder } from '@dotrino/passmanager'
+import { verifyDeviceSig } from '@dotrino/identity/capabilities'
+
+export const PASSWORDS_CAP = 'passwords'
+export const PASSKEYS_CAP = 'passkeys'
+
+/**
+ * @param {object} opts
+ *   `client`      cliente del proxio del vault, ya identificado
+ *   `store`       `{ get(k), set(k,v) }` donde viven los sobres
+ *   `members(kind)`  → `[{ pub, encPub }]` a quién envolverle cada llave (`main`/`passkeys`),
+ *                  SIN la bóveda. Lo pone `vault.js`, que es quien lee el acta.
+ *   `recoveryPub()`  la pública de la copia de recuperación (la que abre la frase)
+ *   `canWrite(pubkey)`  ¿ese aparato puede ESCRIBIR contraseñas? (acta: `passwords`)
+ *   `isAllowed(pubkey)` ¿puede pedir? — lo decide el acta, no esto
+ *   `encPubOf(pubkey)`  su llave de cifrado, para sellarle la respuesta
+ *   `needsApproval(pubkey)`  (async) si ese aparato tiene que pedir aprobación (`unattended`)
+ *   `approve({ pubkey, op })`  pide el visto bueno (el teléfono) y espera
+ *   `audit(op, info)`  la bitácora del vault
+ */
+export function createPasswordDesk (opts = {}) {
+  const {
+    client, store,
+    members = () => [],
+    recoveryPub = () => null,
+    canWrite = () => false,
+    isAllowed = () => false,
+    encPubOf = () => null,
+    needsApproval = () => true,
+    approve = async () => false,
+    audit = () => {},
+    log = () => {},
+  } = opts
+
+  const sealed = new SealedStore(store, {
+    recipients: (kind) => members(kind),
+    /**
+     * ¿LA FIRMÓ QUIEN DICE, Y PUEDE ESCRIBIR? Es lo único que la bóveda puede comprobar
+     * sobre una entrada cuyo contenido no ve. Las dos mitades importan: la firma ata el
+     * sobre a una llave, y el acta dice si esa llave tiene algo que hacer aquí.
+     */
+    verifyAuthor: async ({ body, author }) => {
+      if (!canWrite(author?.pub)) return false
+      return verifyDeviceSig({ publickey: author.pub, data: body, signature: author.sig })
+    },
+  })
+
+  const responder = new SealedResponder({
+    client,
+    store: sealed,
+    recipients: async () => ({
+      recoveryPub: recoveryPub(),
+      main: await members('main'),
+      passkeys: await members('passkeys'),
+    }),
+    isAllowed,
+    encPubOf,
+    // Dos condiciones, y las dos tienen que darse: que ese APARATO esté marcado para
+    // aprobar, y que lo que pide sea PRIVADO. Rellenar un nombre no es sacar un secreto, y
+    // pedir permiso para todo enseña a decir que sí sin mirar.
+    needsApproval: async (pubkey) => await needsApproval(pubkey),
+    approve,
+    onRequest: (r) => {
+      // La bitácora NO lleva qué credencial se pidió: eso es contenido del usuario.
+      audit('passwords', { op: r.op, outcome: r.outcome, device: (r.from || '').slice(0, 24) })
+      if (r.outcome !== 'ok') log(`[vault] passwords: ${r.op} ${r.outcome}`)
+    },
+  })
+
+  return {
+    start () { responder.start(); return this },
+    stop () { responder.stop() },
+    /**
+     * EL CANDADO DEL PERFIL YA NO PINTA NADA AQUÍ, y eso es la noticia: esta bóveda no
+     * tiene ninguna llave que cerrar. Se conserva el método porque quien lo llama no tiene
+     * por qué saberlo, y porque decirlo en la bitácora ayuda a entender el cambio.
+     */
+    lock () { audit('passwords.lock', { sealed: true }) },
+    unlock () {},
+    /** Para la consola local y las pruebas. Aquí tampoco se abre nada. */
+    sealed,
+    responder,
+  }
+}
+
+/**
+ * CONVERTIR LO QUE HAY (§2.7). Es un acto único y es **segundo trabajo de la maestra**: se
+ * hace al ABRIR la bóveda, que es cuando la frase está a mano y hay con qué reescribirlo
+ * todo.
+ *
+ * El trabajo está en `@dotrino/passmanager/sealed` y no aquí, porque lo hacen las CUATRO
+ * bóvedas: esta, la pestaña, la de dentro de la extensión y `passmanager serve`. Cuatro
+ * copias serían cuatro formas sutilmente distintas de reescribir lo mismo, y la que se
+ * quedara atrás no fallaría al convertir — fallaría al leerlo otra bóveda, meses después.
+ *
+ * Lo que sí es de aquí: `dropOldKey`, porque dónde vive la llave vieja lo sabe cada una.
+ */
+export async function convertPasswords ({ store, sealed, cek, recipients, author, dropOldKey, log = () => {} } = {}) {
+  const { convertToSealed } = await import('@dotrino/passmanager/sealed')
+  return convertToSealed({
+    store, sealed, cek, recipients, author, dropOldKey,
+    log: (m) => log('[vault] ' + m)
+  })
+}

package/vault/vendor/vault/core/sealKey.js

@@ -0,0 +1,77 @@
+/**
+ * La LLAVE DE SELLADO de esta bóveda: con ella FIRMA los sobres de los secretos, para
+ * que se sepa que salieron de aquí. Diseño: `docs/secretos-sellados.md` §8.8 y §8.9.
+ *
+ * Tres cosas que la hacen distinta de todo lo demás que hay en este directorio:
+ *
+ *   · **Firmar no es leer.** Esta llave 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
+ *     justo lo que hace posible administrar sin contraseña.
+ *   · **Su autoridad la da el ACTA**, que la nombra (`sealPub`) y que sella únicamente
+ *     la maestra. Ella no se autoriza a sí misma.
+ *   · **Rota con el acta.** Cada acta nueva puede estrenar una, así que aquí se guarda
+ *     un puñado: la vigente para firmar, y las anteriores porque un sobre se firmó con
+ *     la que mandaba entonces y hay que poder seguir firmando… no, seguir
+ *     **identificando** cuál era. Verificar se hace con la pública que dice el acta.
+ *
+ * No guarda ninguna correspondencia con `seq`: quién mandaba y cuándo lo dice el acta
+ * (`sealKeys` con su tramo). Aquí solo están las privadas, indexadas por su pública.
+ */
+import { readJson, writeJson } from './disk.js'
+import { signWithDevice } from '@dotrino/identity/capabilities'
+
+/**
+ * Cuántas llaves anteriores se conservan. Firmar solo usa la vigente; las viejas se
+ * guardan por si hay que re-firmar algo sellado con ellas (recoger el histórico), y
+ * porque tirarlas no ahorra nada: son cuatro líneas de JSON.
+ */
+const MAX_KEYS = 8
+
+/** Abre (o estrena) el llavero de sellado del perfil. */
+export function openSealKeys (disk) {
+  const file = 'sealkeys.json'
+  const data = readJson(disk, file, null) || { v: 1, keys: [] }
+  if (!Array.isArray(data.keys)) data.keys = []
+
+  const save = () => writeJson(disk, file, data)
+  const find = (pub) => data.keys.find((k) => k.pub === pub) || null
+
+  return {
+    /** La pública de la llave vigente (la última estrenada), o `null` si no hay ninguna. */
+    current: () => data.keys[data.keys.length - 1]?.pub || null,
+
+    /** ¿Tenemos la privada de esta pública? Es lo que decide si podemos firmar por ella. */
+    has: (pub) => !!find(pub),
+
+    /**
+     * Estrena una llave y devuelve su PÚBLICA, para que el acta la nombre. La privada
+     * se queda aquí; no sale de esta máquina ni viaja a ninguna parte.
+     *
+     * Es lo que se le pasa a `identity.setSealKeyProvider`, así que se llama una vez
+     * por acta sellada.
+     */
+    async mint () {
+      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.keys.push({ pub, priv, createdAt: Date.now() })
+      if (data.keys.length > MAX_KEYS) data.keys = data.keys.slice(-MAX_KEYS)
+      save()
+      return pub
+    },
+
+    /**
+     * Firma un cuerpo con la llave que el acta nombra. Devuelve `null` si esa llave no es
+     * nuestra —el disco se restauró, o el acta la puso otro master—: entonces el sobre
+     * sale SIN firma, que es peor que firmado pero mucho mejor que no poder guardar.
+     */
+    async sign (sealPub, body) {
+      const k = sealPub ? find(sealPub) : null
+      if (!k) return null
+      const { signature } = await signWithDevice({ privateJwk: k.priv, publickey: k.pub, data: body })
+      return signature
+    }
+  }
+}
+
+export default { openSealKeys }

package/vault/vendor/vault/core/sealer.js

@@ -0,0 +1,172 @@
+/**
+ * El SELLADOR: lo único de los secretos que toca criptografía.
+ *
+ * `secretsStore.js` guarda la forma y las reglas y no sabe cifrar; le inyecta este
+ * puerto y le pide sobres. Así el store se prueba con un sellador falso y este archivo
+ * se lee entero de una sentada.
+ *
+ * QUÉ HACE. Cada cajón (un namespace, o el cajón propio de un aparato) tiene una CEK
+ * AES-256-GCM. Las variables privadas se cifran con ella. La CEK viaja de dos formas,
+ * y esa dualidad es todo el diseño:
+ *
+ *   · **hacia los miembros** — envuelta a la llave de cifrado (`encPub`) de cada
+ *     aparato que deba leer ese cajón, con ECDH efímero: quien abre solo necesita su
+ *     propia privada. Es lo que va en el llavero del archivo y lo que viaja al agente.
+ *   · **hacia quien administra** — en la COPIA MAESTRA, cifrada con la llave derivada
+ *     de la contraseña del perfil. Es lo que permite sellar una variable nueva o
+ *     re-envolver la CEK a un aparato que entra.
+ *
+ * Y hay una tercera forma que NO existe a propósito: **la CEK nunca se envuelve a la
+ * llave de esta bóveda**. Si se hiciera, el daemon podría abrir todo por su cuenta y
+ * esto no valdría nada — que es exactamente la situación de la que venimos.
+ *
+ * La contraseña no está en el disco, así que una copia del disco no abre las privadas.
+ * Lo que sí abre es todo lo demás; los límites honestos están en
+ * `docs/secretos-sellados.md` §3 y conviene leerlos antes de confiar de más.
+ */
+import {
+  makeContentKey, makeGeneration, encryptWithCek, decryptWithCek, wrapForMember, openWrap
+} from '@dotrino/identity/content'
+
+const b64 = (b) => { let s = ''; for (const x of new Uint8Array(b)) s += String.fromCharCode(x); return btoa(s) }
+const un64 = (s) => Uint8Array.from(atob(s), (c) => c.charCodeAt(0))
+/** AES-256-GCM con WebCrypto: el mismo en Node y en el navegador. */
+const aesKey = (raw, uses) => crypto.subtle.importKey('raw', raw, { name: 'AES-GCM' }, false, uses)
+
+/** La copia maestra va cifrada con AES-256-GCM bajo la llave derivada de la contraseña. */
+const MASTER_V = 1
+
+/** Se pidió abrir la copia maestra sin llave, o con la equivocada. */
+export class WrongPassword extends Error {
+  constructor (msg = 'wrong password') {
+    super(msg)
+    this.code = 'WRONG_PASSWORD'
+  }
+}
+
+function assertKey (adminKey) {
+  if (!(adminKey instanceof Uint8Array) || adminKey.length !== 32) {
+    throw new WrongPassword('the derived key is missing or malformed (32 bytes expected)')
+  }
+}
+
+/**
+ * Crea el sellador. No guarda estado ni recuerda la contraseña: cada operación recibe
+ * la llave derivada y la suelta. Que no se cachee es la mitad del valor de todo esto —
+ * una llave que se queda en memoria para siempre deja el disco protegido y la máquina
+ * igual de expuesta que antes.
+ */
+export function makeSealer () {
+  return {
+    /**
+     * Abre la copia maestra: `{ "ns:<ns>": cek, "dev:<pub>": cek }`. Un `blob` vacío
+     * devuelve un mapa vacío — es el primer arranque, no un error.
+     */
+    async openMaster (blob, adminKey) {
+      assertKey(adminKey)
+      if (!blob) return {}
+      if (blob.v !== MASTER_V) throw new Error(`master copy: unknown format v${blob.v}`)
+      try {
+        // WebCrypto quiere la etiqueta pegada al final del cifrado; en disco van aparte.
+        const ct = un64(blob.ct); const tag = un64(blob.tag)
+        const both = new Uint8Array(ct.length + tag.length); both.set(ct); both.set(tag, ct.length)
+        const plain = await crypto.subtle.decrypt({ name: 'AES-GCM', iv: un64(blob.iv) }, await aesKey(adminKey, ['decrypt']), both)
+        return JSON.parse(new TextDecoder().decode(plain))
+      } catch (_) {
+        // El tag de AES-GCM ES el verificador: si no cuadra, la contraseña no era.
+        // Por eso no hace falta guardar aparte un verificador de la contraseña, que
+        // sería un camino más barato para atacarla desde una copia del disco.
+        throw new WrongPassword()
+      }
+    },
+
+    async sealMaster (obj, adminKey) {
+      assertKey(adminKey)
+      const iv = crypto.getRandomValues(new Uint8Array(12))
+      const both = new Uint8Array(await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, await aesKey(adminKey, ['encrypt']), new TextEncoder().encode(JSON.stringify(obj))))
+      return { v: MASTER_V, iv: b64(iv), ct: b64(both.subarray(0, both.length - 16)), tag: b64(both.subarray(both.length - 16)) }
+    },
+
+    /** La CEK de un cajón, creándola si es la primera variable que entra ahí. */
+    async cekFor (master, owner) {
+      if (!master[owner]) master[owner] = await makeContentKey()
+      return master[owner]
+    },
+
+    /** Una CEK NUEVA para el cajón, tirando la anterior. Rotar es esto. */
+    async newCek (master, owner) {
+      master[owner] = await makeContentKey()
+      return master[owner]
+    },
+
+    /** Cifra un valor con la CEK del cajón. */
+    async encrypt (cek, plaintext, gen = 0) {
+      const { iv, ct } = await encryptWithCek({ cek, gen, plaintext })
+      return { iv, ct }
+    },
+
+    /** Descifra con la CEK que corresponda al cajón. Solo lo usa quien administra. */
+    async decrypt (master, envelope, owner) {
+      const cek = master[owner]
+      if (!cek) throw new Error(`master copy: no key for drawer ${owner}`)
+      return decryptWithCek({ cek, envelope })
+    },
+
+    /**
+     * Una CEK NUEVA, sin llavero de por medio. Es lo que usa cada escritura desde v5: la
+     * bóveda no puede reutilizar la de antes porque **no puede abrir ninguna envoltura
+     * para recuperarla** — sellar es una capacidad pública, abrir no. Una generación por
+     * escritura es la consecuencia, no un capricho (§8.7).
+     */
+    async newKey () {
+      return makeContentKey()
+    },
+
+    /**
+     * El par de RECUPERACIÓN: su pública se guarda en claro —para poder envolverle sin
+     * saber nada— y su privada va sellada bajo la frase. Es la copia que se abre el día
+     * que no queda ningún aparato, y la que abre la TUI cuando el dueño pide ver un valor.
+     */
+    async makeRecoveryPair () {
+      const pair = await crypto.subtle.generateKey({ name: 'ECDH', namedCurve: 'P-256' }, true, ['deriveKey', 'deriveBits'])
+      return {
+        pub: JSON.stringify(await crypto.subtle.exportKey('jwk', pair.publicKey)),
+        priv: await crypto.subtle.exportKey('jwk', pair.privateKey)
+      }
+    },
+
+    /** Envuelve una CEK a UNA pública suelta (la de recuperación, que no es un miembro). */
+    async wrapForKey (cek, encPub) {
+      return wrapForMember({ cek, memberEncPub: encPub })
+    },
+
+    /**
+     * Abre una envoltura con una privada ECDH **en JWK**. Lo hace quien PUEDE leer.
+     *
+     * La privada llega como JWK porque así se guarda (sellada bajo la frase, en un JSON),
+     * y `openWrap` quiere una `CryptoKey`: importarla es el puente, y va aquí porque este
+     * es el único archivo que toca criptografía.
+     */
+    async openWrapWith (privJwk, wrap) {
+      const key = await crypto.subtle.importKey('jwk', privJwk, { name: 'ECDH', namedCurve: 'P-256' }, false, ['deriveBits'])
+      return openWrap({ wrap, myEncPrivateKey: key })
+    },
+
+    /** Descifra un sobre con la CEK ya abierta. */
+    async openValue (cek, envelope) {
+      return decryptWithCek({ cek, envelope })
+    },
+
+    /**
+     * Envuelve la CEK a cada miembro. Los que no tengan llave de cifrado salen en
+     * `sinLlave` en vez de reventar: quien administra tiene que poder VERLO, porque el
+     * síntoma sería un servicio arrancando sin configuración y sin decir por qué.
+     */
+    async wrapFor (cek, members) {
+      const { generation, sinLlave } = await makeGeneration({ members, cek })
+      return { wraps: generation.wraps, sinLlave }
+    }
+  }
+}
+
+export default { makeSealer, WrongPassword }

package/vault/vendor/vault/core/sealers.js

@@ -0,0 +1,159 @@
+/**
+ * sealers.js — depositar la cadena de selladores en el registro público.
+ *
+ * POR QUÉ ESTO EXISTE. Un acta que alguien guardó el año pasado no puede responder la única
+ * pregunta que importa al leer una firma vieja: *la llave que firmó esto, ¿sigue pudiendo
+ * sellar?* Si a una bóveda le quitaron el permiso, quien tenga el acta vieja no se entera
+ * nunca — y seguiría creyéndole. El registro es el sitio donde mirar.
+ *
+ * QUÉ SE MANDA: los ESLABONES (`sealerLinkOf`), nunca las actas. Y un eslabón no es un acta
+ * recortada: es un documento propio de ocho campos, firmado aparte y metido DENTRO del acta
+ * antes de firmarla (identity >= 0.72). Costó una vuelta descubrirlo — la primera cadena que
+ * llegó al registro se fue con los `label` y los `cn` de cada aparato, porque «un eslabón»
+ * era un acta entera. Un acta lleva el inventario de tu casa: no se publica, ni recortada.
+ *
+ * POR QUÉ SIN SELLAR, y no es un descuido (§4.1 pide sellar los mensajes dirigidos): lo que
+ * viaja aquí va a acabar en un repo PÚBLICO, que es su propósito. Es el mismo caso que los
+ * canales `publish`/`list` del proxio, exentos por la misma razón: no hay nada que ocultar.
+ * Y no filtra de más — quién lo manda ya lo sabe el proxio por el `identify`. Sellarlo,
+ * además, obligaría a conocer la llave de cifrado del testigo, y depositar tiene que poder
+ * hacerlo cualquiera sin pedirle nada a nadie.
+ *
+ * Va por `sendByPubkey` y no por `send`: al testigo se le conoce por su pubkey, y así lo
+ * depositado entra en la cola de 24 h del proxio si estuviera caído.
+ *
+ * CUÁNDO: al arrancar y después de cada acta. Publicar de más no cuesta nada (el registro
+ * contesta «ya estaba») y así no hay que llevar la cuenta de qué se depositó — un estado
+ * que se desincroniza en cuanto se restaura un disco.
+ */
+import * as Acta from '@dotrino/identity/acta'
+import { verifyDelegation } from '@dotrino/identity/capabilities'
+
+export const OP = 'sealers.publish'
+
+/**
+ * LA IDENTIDAD DEL TESTIGO DE DOTRINO — no su aparato (dueño, 2026-08-31: «¿no me puedes
+ * quemar un device en el código?»).
+ *
+ * Tenía razón y era el mismo fallo que ya costó caro con el `nodeId` del proxio: la pubkey
+ * de un APARATO muere en cuanto lo revocas o lo re-enrolas, y todo lo que la tuviera
+ * apuntada se queda hablando con una dirección muerta. Lo que no cambia nunca es la
+ * IDENTIDAD: el `profileId` es el nombre de la cuenta y es para siempre.
+ *
+ * Así que aquí va la identidad, y el aparato se DESCUBRE: el testigo se anuncia en el canal
+ * con su cert, y se acepta al que traiga uno emitido por esta identidad. Re-enrolarlo da un
+ * cert nuevo de la misma identidad y todo sigue solo; revocarlo lo saca del acta y su
+ * anuncio deja de valer.
+ *
+ * Y nadie configura nada: esto es una dirección pública, como `wss://proxy.dotrino.com`.
+ */
+export const DOTRINO_REGISTRY_ID = "{\"key_ops\":[\"verify\"],\"ext\":true,\"kty\":\"EC\",\"x\":\"McyhKieRw_Jcl3TY9EvLovL-ALzGoWqMOrfnFjT7XpA\",\"y\":\"V7tfpDWN37tPnhXnIFUlMaTepcTzzxPWTj_72PkpKPw\",\"crv\":\"P-256\"}"
+
+/** El canal donde el testigo se anuncia (ver `@dotrino/sealers`). */
+export const CANAL = 'dotrino.sealers'
+
+/** Se le pregunta a cada anunciado quién es; contesta con su cert (ver `@dotrino/sealers`). */
+export const WHOIS = 'sealers.whois'
+
+export function startSealersPublisher ({ identity, client, log = console.log, registryId = DOTRINO_REGISTRY_ID, canal = CANAL } = {}) {
+  if (!registryId) return () => {}
+
+  /** Una respuesta a `sealers.whois`, o null si no contesta a tiempo. */
+  function preguntarQuienEs (token, timeoutMs = 8000) {
+    return new Promise((resolve) => {
+      const fin = (v) => { try { off() } catch (_) {} ; clearTimeout(t); resolve(v) }
+      const off = client.on('message', (_f, p) => { if (p?.op === WHOIS + '.result') fin(p) })
+      const t = setTimeout(() => fin(null), timeoutMs)
+      t.unref?.()
+      try { client.send(token, { op: WHOIS }) } catch (_) { fin(null) }
+    })
+  }
+
+  /**
+   * ¿A QUIÉN LE MANDO ESTO? Al que esté anunciado en el canal y demuestre ser de la
+   * IDENTIDAD que llevamos en el código.
+   *
+   * El canal dice DÓNDE mirar y nada más: `list` del proxio devuelve tokens sueltos — el
+   * `extraData` del `publish` no vuelve, comprobado contra el servidor. Así que a cada uno
+   * se le pregunta quién es (`sealers.whois`) y contesta con su cert. Que el cert venga del
+   * propio testigo y no del anuncio es además mejor: llega fresco.
+   *
+   * Sin comprobar el cert, cualquiera se anuncia ahí y se queda con los depósitos. No
+   * filtraría nada —el eslabón es público— pero se los tragaría EN SILENCIO, que es peor
+   * que un error.
+   */
+  async function testigo () {
+    let tokens
+    try { tokens = await client.list(canal) } catch (_) { return null }
+    for (const token of tokens || []) {
+      const r = await preguntarQuienEs(token)
+      const cert = r?.cert
+      if (!cert?.sub || cert.iss !== registryId) continue
+      // AQUÍ SOMOS EXTRAÑOS: no tenemos el acta del registro, así que no podemos preguntarle
+      // quién sella. Lo que sí tenemos es su `profileId` quemado en el código —inmutable, a
+      // diferencia de la dirección de un aparato— y eso es lo que se ancla: aceptamos un
+      // papel firmado POR ESA LLAVE, para el acta que él diga.
+      //
+      // Es exactamente la misma fuerza que antes (`cert.iss === registryId` + firma válida),
+      // dicho con la forma nueva. Y tiene un límite que conviene decir: si el registro
+      // llegara a tener una SEGUNDA selladora, sus papeles no entrarían por aquí hasta que
+      // presente su cadena de eslabones — que es, con gracia, justo lo que este registro
+      // publica.
+      const v = await verifyDelegation({
+        cert, expectedSub: cert.sub, actaSeq: cert.seq, sealers: [registryId]
+      }).catch(() => ({ ok: false }))
+      if (v?.ok) return cert.sub
+    }
+    return null
+  }
+
+  let ultima = null
+
+  let avisadoDeOtroTestigo = false
+
+  async function publicar (motivo) {
+    let actas
+    try { actas = await identity.sealerChain?.() } catch (_) { return }
+    if (!Array.isArray(actas)) return
+
+    // SI LA CUENTA DECLARÓ SU PROPIO TESTIGO, no se deposita en el de Dotrino. No es que
+    // hacerlo filtre algo —el eslabón es público— sino que el `chainUrl` del génesis es la
+    // forma que tiene una cuenta de decir dónde vive su cadena, y decidir por ella sería
+    // exactamente lo que ese campo existe para impedir. Se dice una vez y se calla.
+    const genesis = actas[0]
+    if (genesis?.chainUrl && registryId === DOTRINO_REGISTRY_ID) {
+      if (!avisadoDeOtroTestigo) {
+        avisadoDeOtroTestigo = true
+        log(`[sealers] this account names its own registry (${genesis.chainUrl}): not depositing into Dotrino's`)
+      }
+      return
+    }
+    // De cada acta sale su eslabón, y las que no cambiaron el sellador no dan ninguno.
+    const chain = actas.map((a) => Acta.sealerLinkOf(a)).filter(Boolean)
+    // Una cuenta de una sola bóveda no tiene nada que refrescar: su conjunto de selladores
+    // no puede cambiar. El registro la rechazaría, así que ni se molesta en mandarla.
+    // Una cuenta anterior a identity 0.72 tampoco tiene eslabones, y es el mismo caso: no
+    // aparece en el registro hasta que selle un acta nueva.
+    if (chain.length < 2) return
+
+    const cabeza = chain[chain.length - 1]?.seq
+    if (cabeza === ultima) return
+    try {
+      const a = await testigo()
+      if (!a) { log('[sealers] no witness announced in ' + canal + ': the chain stays for the next time'); return }
+      await client.sendByPubkey(a, { op: OP, chain })
+      ultima = cabeza
+      log(`[sealers] chain up to #${cabeza} deposited (${motivo})`)
+    } catch (e) {
+      // Que no se pueda depositar no rompe nada de lo que la bóveda hace: el registro es
+      // una comodidad para terceros, no una dependencia. Se reintenta en la próxima acta.
+      log('[sealers] could not deposit the chain:', e.message)
+    }
+  }
+
+  publicar('startup').catch(() => {})
+  const off = identity.onVault?.((e) => { if (e?.phase === 'acta') publicar(`record #${e.seq}`).catch(() => {}) })
+  return () => { try { off?.() } catch (_) {} }
+}
+
+export default { startSealersPublisher, OP, DOTRINO_REGISTRY_ID, CANAL }