@dotrino/identity 0.121.3 → 0.121.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.121.3",
+  "version": "0.121.4",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -387,7 +387,7 @@ export class Identity {
    * Une ESTE perfil a la cuenta de otro (la de una bóveda). No es adoptar una versión nueva
    * de la tuya: esta llave pasa a ser de OTRA cuenta y deja de tener la suya, así que solo
    * procede sobre un perfil creado con `{ forVault: true }`. Si no, devuelve
-   * `{ joined: false, reason: 'perfil-con-datos' }` y no escribe nada.
+   * `{ joined: false, reason: 'profile-has-data' }` y no escribe nada.
    */
   async joinProfile (acta) { return this._call('joinProfile', { acta }) }
   /** Marca este perfil como nacido para ADOPTAR la cuenta de otro (camino A). */

package/vault/acta.js

@@ -289,38 +289,38 @@ export const sealerLinkOf = (acta) => (acta?.sealerChanged && acta?.sealerLink)
  */
 export function checkSealerLink (acta) {
   const l = acta?.sealerLink
-  if (!l) return acta?.sealerChanged && acta?.v >= 5 ? 'eslabon-ausente' : null
-  if (l.v !== SEALER_LINK_V) return 'eslabon-version'
-  if (typeof l.sig !== 'string') return 'eslabon-sin-firma'
-  if (l.profileId !== acta.profileId) return 'eslabon-otro-perfil'
+  if (!l) return acta?.sealerChanged && acta?.v >= 5 ? 'link-missing' : null
+  if (l.v !== SEALER_LINK_V) return 'link-version'
+  if (typeof l.sig !== 'string') return 'link-unsigned'
+  if (l.profileId !== acta.profileId) return 'link-other-profile'
   // EL ACTA VIGENTE ARRASTRA EL ÚLTIMO ESLABÓN, que casi nunca es de ella: los selladores
   // cambian poquísimo y las actas cambian con cada emparejamiento. Así que solo cuando
   // ESTA acta es el eslabón se le exige que coincida en `seq` y en quién lo firmó; si lo
   // hereda, basta con que venga de antes.
   if (acta.sealerChanged) {
-    if (l.seq !== acta.seq) return 'eslabon-otro-seq'
-    if (l.by !== acta.sealedBy) return 'eslabon-otro-sellador'
+    if (l.seq !== acta.seq) return 'link-other-seq'
+    if (l.by !== acta.sealedBy) return 'link-other-sealer'
   } else if (!(l.seq < acta.seq)) {
-    return 'eslabon-del-futuro'
+    return 'link-from-future'
   }
   // Y en los dos casos tiene que DECIR LO MISMO que el acta sobre quién sella: si no
   // cambiaron, el heredado los sigue describiendo. Esto es lo que impide que el acta y su
   // eslabón cuenten cosas distintas — que es todo el punto de meterlo dentro.
   const dice = [...(l.sealers || [])].slice().sort().join('|')
   const segunElActa = sealersOf(acta).slice().sort().join('|')
-  if (dice !== segunElActa) return 'eslabon-no-cuadra'
+  if (dice !== segunElActa) return 'link-mismatch'
   return null
 }
 
 /** Firma del eslabón por quien sella. Se hace ANTES de firmar el acta que lo lleva. */
 export async function verifySealerLink (link) {
-  if (!link || link.v !== SEALER_LINK_V) return { ok: false, reason: 'eslabon-version' }
-  if (!isPub(link.profileId) || !isPub(link.by)) return { ok: false, reason: 'eslabon-forma' }
-  if (!Array.isArray(link.sealers) || !link.sealers.length || !link.sealers.every(isPub)) return { ok: false, reason: 'eslabon-selladores' }
-  if (typeof link.seq !== 'number' || link.seq < 1) return { ok: false, reason: 'eslabon-seq' }
-  if (typeof link.sig !== 'string') return { ok: false, reason: 'eslabon-sin-firma' }
+  if (!link || link.v !== SEALER_LINK_V) return { ok: false, reason: 'link-version' }
+  if (!isPub(link.profileId) || !isPub(link.by)) return { ok: false, reason: 'link-shape' }
+  if (!Array.isArray(link.sealers) || !link.sealers.length || !link.sealers.every(isPub)) return { ok: false, reason: 'link-sealers' }
+  if (typeof link.seq !== 'number' || link.seq < 1) return { ok: false, reason: 'link-seq' }
+  if (typeof link.sig !== 'string') return { ok: false, reason: 'link-unsigned' }
   const ok = await verifyDeviceSig({ publickey: link.by, data: sealerLinkBody(link), signature: link.sig })
-  return ok ? { ok: true } : { ok: false, reason: 'eslabon-firma-invalida' }
+  return ok ? { ok: true } : { ok: false, reason: 'link-invalid-signature' }
 }
 
 /**
@@ -338,29 +338,29 @@ export async function verifySealerLink (link) {
  * aceptando a un sellador retirado; para eso está mirar el registro, no más firmas.
  */
 export async function verifySealerLinkChain (chain, { expectedProfileId = null } = {}) {
-  if (!Array.isArray(chain) || !chain.length) return { ok: false, reason: 'cadena-vacia' }
+  if (!Array.isArray(chain) || !chain.length) return { ok: false, reason: 'empty-chain' }
   const [raiz] = chain
   // La misma regla que en `verifySealerChain`: la raíz la ancla la llave del perfil, no el
   // número 1 (una cuenta puede haber perdido su génesis; ver allí).
-  if (!Number.isInteger(raiz?.seq) || raiz.seq < 1) return { ok: false, reason: 'no-empieza-en-genesis' }
-  if (raiz.by !== raiz.profileId) return { ok: false, reason: 'genesis-no-autofirmado' }
-  if (expectedProfileId != null && raiz.profileId !== expectedProfileId) return { ok: false, reason: 'otro-perfil' }
+  if (!Number.isInteger(raiz?.seq) || raiz.seq < 1) return { ok: false, reason: 'no-genesis' }
+  if (raiz.by !== raiz.profileId) return { ok: false, reason: 'genesis-not-self-signed' }
+  if (expectedProfileId != null && raiz.profileId !== expectedProfileId) return { ok: false, reason: 'other-profile' }
   const vr = await verifySealerLink(raiz)
   if (!vr.ok) return { ok: false, reason: 'genesis:' + vr.reason }
 
   for (let i = 1; i < chain.length; i++) {
     const previo = chain[i - 1]
     const actual = chain[i]
-    if (actual?.profileId !== raiz.profileId) return { ok: false, reason: `eslabon-${i}:otro-perfil` }
-    if (!(actual.seq > previo.seq)) return { ok: false, reason: `eslabon-${i}:seq-no-crece` }
+    if (actual?.profileId !== raiz.profileId) return { ok: false, reason: `link-${i}:other-profile` }
+    if (!(actual.seq > previo.seq)) return { ok: false, reason: `link-${i}:seq-not-increasing` }
     const v = await verifySealerLink(actual)
-    if (!v.ok) return { ok: false, reason: `eslabon-${i}:` + v.reason }
+    if (!v.ok) return { ok: false, reason: `link-${i}:` + v.reason }
     const a = actual.prev
     if (!a || a.seq !== previo.seq || a.hash !== await sealerLinkHash(previo)) {
-      return { ok: false, reason: `eslabon-${i}:no-encadena` }
+      return { ok: false, reason: `link-${i}:not-chained` }
     }
     // Y lo que da la autoridad: quien lo firmó podía sellar SEGÚN EL ESLABÓN ANTERIOR.
-    if (!previo.sealers.includes(actual.by)) return { ok: false, reason: `eslabon-${i}:sellador-no-autorizado` }
+    if (!previo.sealers.includes(actual.by)) return { ok: false, reason: `link-${i}:unauthorized-sealer` }
   }
   const ultimo = chain[chain.length - 1]
   return { ok: true, profileId: raiz.profileId, seq: ultimo.seq, sealers: [...ultimo.sealers] }
@@ -473,7 +473,7 @@ export function checkShape (acta) {
   if (acta.chainUrl != null && !isChainUrl(acta.chainUrl)) return 'chainurl'
   // El campo solo existe —y solo se exige— en las viejas.
   if (conCampoSellador(acta) && !isPub(acta.sealer)) return 'shape'
-  if (!conCampoSellador(acta) && acta.sealer != null) return 'sealer-no-va-en-v3'
+  if (!conCampoSellador(acta) && acta.sealer != null) return 'sealer-not-in-v3'
   if (!Number.isInteger(acta.seq) || acta.seq < 1) return 'seq'
   if (acta.seq > 1 && typeof acta.prev !== 'string') return 'prev'
   if (!Array.isArray(acta.members) || acta.members.length === 0) return 'members'
@@ -507,7 +507,7 @@ export function checkShape (acta) {
     // El CN es la frontera: un SERVICIO solo puede abrir su propio cajón, y un
     // DISPOSITIVO no tiene cajón que abrir. Que no se pueda escribir un acta que
     // mezcle las dos cosas es lo que hace que el límite sea real y no una costumbre.
-    if (m.cn != null && !isValidCn(m.cn)) return 'cn-invalido'
+    if (m.cn != null && !isValidCn(m.cn)) return 'invalid-cn'
     // La llave de cifrado: por ahora se valida la FORMA y solo si viene. NO se exige
     // todavía, aunque el destino sea exigírsela a quien recibe secretos.
     //
@@ -516,27 +516,27 @@ export function checkShape (acta) {
     // entró sin ella —que son todas las anteriores a esto— y el vault dejaría de
     // arrancar en vez de avisar. Primero los servicios registran su llave (op
     // `encpub`), y cuando no quede ninguno sin ella se aprieta aquí.
-    if (m.encPub != null && !isEncPub(m.encPub)) return 'encpub-invalido'
+    if (m.encPub != null && !isEncPub(m.encPub)) return 'invalid-encpub'
   }
   // LA LLAVE DE SELLADO Y SU REGISTRO. `sealPub` puede no estar (un perfil que no sella
   // secretos), pero si está tiene que decir DESDE QUÉ acta manda: sin `sealSince` no se
   // puede decidir con qué llave verificar un sobre viejo.
   if (acta.v >= 2) {
   if (acta.sealPub != null) {
-    if (!isPub(acta.sealPub)) return 'sealpub-invalido'
+    if (!isPub(acta.sealPub)) return 'invalid-sealpub'
     if (!Number.isInteger(acta.sealSince) || acta.sealSince < 1 || acta.sealSince > acta.seq) return 'sealsince'
   } else if (acta.sealSince) return 'sealsince'
   if (!Array.isArray(acta.sealKeys)) return 'sealkeys'
   for (const k of acta.sealKeys) {
-    if (!isPub(k?.pub)) return 'sealkey-invalida'
-    if (!Number.isInteger(k.from) || !Number.isInteger(k.to) || k.from < 1 || k.to < k.from) return 'sealkey-rango'
+    if (!isPub(k?.pub)) return 'invalid-sealkey'
+    if (!Number.isInteger(k.from) || !Number.isInteger(k.to) || k.from < 1 || k.to < k.from) return 'sealkey-range'
   }
   }
-  if (new Set(acta.members.map((m) => m.pub)).size !== acta.members.length) return 'miembro-duplicado'
+  if (new Set(acta.members.map((m) => m.pub)).size !== acta.members.length) return 'duplicate-member'
   // SIN NADIE QUE SELLE, el acta está muerta: no habría forma de volver a cambiarla nunca.
   // Es el hermano del cierre de `sign`, y sustituye a «el sellador tiene que ser miembro»
   // ahora que sellar es solo un permiso y los permisos ya son de miembros por definición.
-  if (!sealersOf(acta).length) return 'sin-sellador'
+  if (!sealersOf(acta).length) return 'no-sealer'
   // La cadena de selladores: el génesis es el ancla (`null`); cualquier otra apunta a un
   // eslabón anterior. Sin `hash` no se puede encadenar nada, así que se exige la forma.
   if (acta.sealerAnchor != null) {
@@ -549,7 +549,7 @@ export function checkShape (acta) {
   // inválida. Lo que sostiene la cadena no es el ancla sino que **cada eslabón lo selle
   // alguien a quien el anterior autorizaba**; el ancla añade que no se pueda empalmar un
   // eslabón de otra rama, y se comprueba cuando viene (ver `verifySealerChain`).
-  if (!acta.members.some((m) => m.caps.includes('sign'))) return 'sin-firmante'
+  if (!acta.members.some((m) => m.caps.includes('sign'))) return 'no-signer'
   return null
 }
 
@@ -627,20 +627,20 @@ export async function verifySignedBy (args = {}) {
     return { ok: false, reason: 'shape' }
   }
   const c = await verifySealerChain(chain, { expectedProfileId })
-  if (!c.ok) return { ok: false, reason: 'cadena:' + c.reason }
+  if (!c.ok) return { ok: false, reason: 'chain:' + c.reason }
   const cabeza = chain[chain.length - 1]
   // Quien firmó tiene que ser miembro CON `sign` en el acta vigente de esa cadena. Si le
   // quitaste el permiso, sus firmas dejan de contar en cuanto se ve un acta más nueva.
   // Un SERVICIO (miembro con `cn`) solo firma dentro de su cajón: quien verifica dice cuál
   // con `ns` (el directorio de nombres acepta lo firmado por su aparato `names`, no por
   // cualquier servicio de la cuenta). Sin `ns`, un servicio nunca pasa, como siempre.
-  if (!memberCanSign(cabeza, publickey, ns)) return { ok: false, reason: 'firmante-no-autorizado' }
-  if (!(await verifyDeviceSig({ publickey, data, signature }))) return { ok: false, reason: 'firma-invalida' }
+  if (!memberCanSign(cabeza, publickey, ns)) return { ok: false, reason: 'unauthorized-signer' }
+  if (!(await verifyDeviceSig({ publickey, data, signature }))) return { ok: false, reason: 'invalid-signature' }
   return { ok: true, profileId: c.profileId, seq: c.seq, signer: publickey }
 }
 
 export async function verifySealerChain (chain, { expectedProfileId = null } = {}) {
-  if (!Array.isArray(chain) || !chain.length) return { ok: false, reason: 'cadena-vacia' }
+  if (!Array.isArray(chain) || !chain.length) return { ok: false, reason: 'empty-chain' }
   const [raiz] = chain
 
   // EL ANCLA ES LA LLAVE DEL PERFIL, NO EL NÚMERO 1 (dueño, 2026-10-14). La raíz vale si
@@ -651,18 +651,18 @@ export async function verifySealerChain (chain, { expectedProfileId = null } = {
   // perfil fabrica un génesis alterno igual que un acta posterior, y contra eso la capa es
   // el registro público. Lo que sí sostiene la cadena —que cada eslabón lo firmó alguien a
   // quien el anterior autorizaba— sigue intacto.
-  if (!Number.isInteger(raiz.seq) || raiz.seq < 1) return { ok: false, reason: 'no-empieza-en-genesis' }
-  if (raiz.sealedBy !== raiz.profileId) return { ok: false, reason: 'genesis-no-autofirmado' }
-  if (expectedProfileId != null && raiz.profileId !== expectedProfileId) return { ok: false, reason: 'otro-perfil' }
+  if (!Number.isInteger(raiz.seq) || raiz.seq < 1) return { ok: false, reason: 'no-genesis' }
+  if (raiz.sealedBy !== raiz.profileId) return { ok: false, reason: 'genesis-not-self-signed' }
+  if (expectedProfileId != null && raiz.profileId !== expectedProfileId) return { ok: false, reason: 'other-profile' }
   const vr = await verifyActa({ acta: raiz })
   if (!vr.ok) return { ok: false, reason: 'genesis:' + vr.reason }
 
   for (let i = 1; i < chain.length; i++) {
     const previo = chain[i - 1]
     const actual = chain[i]
-    if (actual.profileId !== raiz.profileId) return { ok: false, reason: 'otro-perfil' }
+    if (actual.profileId !== raiz.profileId) return { ok: false, reason: 'other-profile' }
     const v = await verifyActa({ acta: actual })
-    if (!v.ok) return { ok: false, reason: `eslabon-${i}:` + v.reason }
+    if (!v.ok) return { ok: false, reason: `link-${i}:` + v.reason }
     // Encadena con el anterior: mismo `seq` y mismo hash. Sin el hash bastaría con
     // acertar un número para colar un eslabón de otra rama.
     // El ancla, SI viene: fija que este eslabón sale del anterior y no de otra rama. Una
@@ -670,10 +670,10 @@ export async function verifySealerChain (chain, { expectedProfileId = null } = {
     // abajo — que es lo que de verdad impide falsificarla.
     const a = actual.sealerAnchor
     if (a && (a.seq !== previo.seq || a.hash !== await actaHash(previo))) {
-      return { ok: false, reason: `eslabon-${i}:no-encadena` }
+      return { ok: false, reason: `link-${i}:not-chained` }
     }
     // Y lo que da la autoridad: quien la selló tenía permiso SEGÚN EL ESLABÓN ANTERIOR.
-    if (!canSeal(previo, actual.sealedBy)) return { ok: false, reason: `eslabon-${i}:sellador-no-autorizado` }
+    if (!canSeal(previo, actual.sealedBy)) return { ok: false, reason: `link-${i}:unauthorized-sealer` }
   }
   const ultima = chain[chain.length - 1]
   return { ok: true, profileId: raiz.profileId, seq: ultima.seq, sealers: sealersOf(ultima) }
@@ -682,10 +682,10 @@ export async function verifySealerChain (chain, { expectedProfileId = null } = {
 export async function verifyActa ({ acta, expectedProfileId } = {}) {
   const shape = checkShape(acta)
   if (shape) return { ok: false, reason: shape }
-  if (typeof acta.sig !== 'string') return { ok: false, reason: 'sin-firma' }
-  if (expectedProfileId != null && acta.profileId !== expectedProfileId) return { ok: false, reason: 'otro-perfil' }
+  if (typeof acta.sig !== 'string') return { ok: false, reason: 'unsigned' }
+  if (expectedProfileId != null && acta.profileId !== expectedProfileId) return { ok: false, reason: 'other-profile' }
   const ok = await verifyDeviceSig({ publickey: acta.sealedBy, data: actaBody(acta), signature: acta.sig })
-  if (!ok) return { ok: false, reason: 'firma-invalida' }
+  if (!ok) return { ok: false, reason: 'invalid-signature' }
   // El eslabón va DENTRO y la firma de arriba lo cubre, pero eso solo prueba que está ahí.
   // Que diga lo mismo que el acta es lo que hace verdad «ya está validado dentro».
   const mal = checkSealerLink(acta)
@@ -720,21 +720,21 @@ export async function verifyActa ({ acta, expectedProfileId } = {}) {
  * @returns {Promise<{ok:true}|{ok:false, reason:string}>}
  */
 export async function checkVaultReply ({ acta, cert, vault, sub, scope = null, justSealed = false } = {}) {
-  if (!acta) return { ok: false, reason: 'sin-acta' }
-  if (!isPub(vault)) return { ok: false, reason: 'sin-boveda' }
+  if (!acta) return { ok: false, reason: 'no-record' }
+  if (!isPub(vault)) return { ok: false, reason: 'no-vault-key' }
   // Para QUÉ llave es el papel no es opcional: sin ella `verifyDelegation` no lo mira, y un
   // papel emitido para otra llave pasaría por bueno.
-  if (!isPub(sub)) return { ok: false, reason: 'sin-llave-del-aparato' }
+  if (!isPub(sub)) return { ok: false, reason: 'no-device-key' }
   const v = await verifyActa({ acta })
-  if (!v.ok) return { ok: false, reason: 'acta:' + v.reason }
-  if (!canSeal(acta, vault)) return { ok: false, reason: 'boveda-no-sella' }
-  if (justSealed && !samePubkey(acta.sealedBy, vault)) return { ok: false, reason: 'acta-de-otra-selladora' }
-  if (!cert || !samePubkey(cert.iss, vault)) return { ok: false, reason: 'papel-de-otra-llave' }
+  if (!v.ok) return { ok: false, reason: 'record:' + v.reason }
+  if (!canSeal(acta, vault)) return { ok: false, reason: 'vault-not-sealer' }
+  if (justSealed && !samePubkey(acta.sealedBy, vault)) return { ok: false, reason: 'record-from-other-sealer' }
+  if (!cert || !samePubkey(cert.iss, vault)) return { ok: false, reason: 'cert-from-other-key' }
   const d = await verifyDelegation({
     cert, expectedSub: sub, actaSeq: acta.seq, sealers: sealersOf(acta),
     ...(scope ? { expectedScope: scope } : {})
   })
-  if (!d.ok) return { ok: false, reason: 'papel:' + d.reason }
+  if (!d.ok) return { ok: false, reason: 'cert:' + d.reason }
   return { ok: true }
 }
 
@@ -1213,16 +1213,16 @@ export async function verifyProfileCard (card) {
  *     anterior — así nadie te cuela dispositivos ajenos en el perfil de tu contacto,
  *     y nunca se retrocede a una versión vieja.
  * Si el master cambió legítimamente (traspaso), la tarjeta nueva la firma el entrante y
- * hay que re-confirmarla: se devuelve `master-cambiado` para que la app lo diga en vez de
+ * hay que re-confirmarla: se devuelve `master-changed` para que la app lo diga en vez de
  * aceptarlo en silencio.
  */
 export async function canAdoptCard ({ card, current }) {
-  if (!(await verifyProfileCard(card))) return { adopt: false, reason: 'firma-invalida' }
-  if (current && current.profileId !== card.profileId) return { adopt: false, reason: 'otro-perfil' }
-  if (!current) return { adopt: true, reason: 'primera-vez' }
-  if (card.seq < current.seq) return { adopt: false, reason: 'seq-menor' }
-  if (card.sealedBy !== current.sealedBy) return { adopt: false, reason: 'master-cambiado' }
-  return { adopt: true, reason: card.seq > current.seq ? 'seq-mayor' : 'igual' }
+  if (!(await verifyProfileCard(card))) return { adopt: false, reason: 'invalid-signature' }
+  if (current && current.profileId !== card.profileId) return { adopt: false, reason: 'other-profile' }
+  if (!current) return { adopt: true, reason: 'first-time' }
+  if (card.seq < current.seq) return { adopt: false, reason: 'lower-seq' }
+  if (card.sealedBy !== current.sealedBy) return { adopt: false, reason: 'master-changed' }
+  return { adopt: true, reason: card.seq > current.seq ? 'higher-seq' : 'same' }
 }
 
 // ----- continuidad: unir una identidad que ya existía -----
@@ -1270,19 +1270,19 @@ export async function verifyContinuity (record) {
 export async function canAdopt ({ candidate, current }) {
   const v = await verifyActa({ acta: candidate, expectedProfileId: current?.profileId })
   if (!v.ok) return { adopt: false, reason: v.reason }
-  if (!current) return { adopt: true, reason: 'sin-acta-previa' }
+  if (!current) return { adopt: true, reason: 'no-previous-record' }
 
   if (candidate.seq > current.seq) {
-    if (!canSeal(current, candidate.sealedBy)) return { adopt: false, reason: 'sellador-no-autorizado' }
+    if (!canSeal(current, candidate.sealedBy)) return { adopt: false, reason: 'unauthorized-sealer' }
     if (candidate.seq === current.seq + 1 && candidate.prev !== await actaHash(current)) {
-      return { adopt: false, reason: 'no-encadena' }
+      return { adopt: false, reason: 'not-chained' }
     }
-    return { adopt: true, reason: 'seq-mayor' }
+    return { adopt: true, reason: 'higher-seq' }
   }
 
   if (candidate.seq === current.seq) {
     const [hCan, hCur] = [await actaHash(candidate), await actaHash(current)]
-    if (hCan === hCur) return { adopt: false, reason: 'misma-acta' }
+    if (hCan === hCur) return { adopt: false, reason: 'same-record' }
     // A igual `seq`, con multivault, las dos ramas pueden venir de selladores DISTINTOS y
     // ser las dos legítimas. Antes era imposible y se rechazaba de plano; ahora se
     // desempata con las reglas de abajo, que ya estaban escritas.
@@ -1294,16 +1294,16 @@ export async function canAdopt ({ candidate, current }) {
     // correcta es por el acta PADRE, que aquí no se tiene; tener el mismo `sealedBy` es
     // exactamente lo que dice que las dos salieron de ella.
     const mismoFirmante = candidate.sealedBy === current.sealedBy
-    if (!mismoFirmante && !canSeal(current, candidate.sealedBy)) return { adopt: false, reason: 'otro-sellador' }
+    if (!mismoFirmante && !canSeal(current, candidate.sealedBy)) return { adopt: false, reason: 'other-sealer' }
     // SOLO QUEDA EL HASH. Antes había una regla más —«gana la que traspasa»— que existía
     // para arbitrar el campo `sealer`: dos ramas que cedían el mando a destinos distintos.
     // Ese campo ya no existe (dueño, 2026-08-31: «SEAL es el nuevo master»), y con él se
     // va la regla y la ambigüedad que arrastraba: `sealer !== sealedBy` significaba
     // «traspaso» con un solo master y dejó de significarlo con varios selladores.
-    return hCan < hCur ? { adopt: true, reason: 'desempate-hash' } : { adopt: false, reason: 'desempate-hash' }
+    return hCan < hCur ? { adopt: true, reason: 'hash-tiebreak' } : { adopt: false, reason: 'hash-tiebreak' }
   }
 
-  return { adopt: false, reason: 'seq-menor' }
+  return { adopt: false, reason: 'lower-seq' }
 }
 
 export default {

package/vault/assertion.js

@@ -145,31 +145,31 @@ export async function verifyAssertion (assertion, opts = {}) {
   if (!Array.isArray(a.scopes) || (a.claims != null && typeof a.claims !== 'object')) return { ok: false, reason: 'shape' }
   if (typeof a.signature !== 'string' || typeof a.publickey !== 'string') return { ok: false, reason: 'shape' }
 
-  if (a.aud !== audience.trim()) return { ok: false, reason: 'otro-destinatario' }
-  if (a.nonce !== nonce) return { ok: false, reason: 'otro-reto' }
+  if (a.aud !== audience.trim()) return { ok: false, reason: 'other-audience' }
+  if (a.nonce !== nonce) return { ok: false, reason: 'other-nonce' }
 
-  if (a.exp <= a.iat) return { ok: false, reason: 'vigencia-invalida' }
+  if (a.exp <= a.iat) return { ok: false, reason: 'invalid-lifetime' }
   // El TOPE lo comprueba quien recibe. Si no, el emisor decide solo cuánto dura su
   // credencial y el tope no es un tope.
-  if (a.exp - a.iat > ASSERTION_MAX_TTL_MS) return { ok: false, reason: 'vigencia-excesiva' }
+  if (a.exp - a.iat > ASSERTION_MAX_TTL_MS) return { ok: false, reason: 'lifetime-too-long' }
   // Y el vencimiento se juzga SIN margen: el margen es para el arranque (relojes que
   // difieren), no para seguir aceptando lo que ya venció.
-  if (a.exp <= now) return { ok: false, reason: 'vencida' }
-  if (a.iat > now + maxSkewMs) return { ok: false, reason: 'del-futuro' }
+  if (a.exp <= now) return { ok: false, reason: 'expired' }
+  if (a.iat > now + maxSkewMs) return { ok: false, reason: 'from-future' }
 
-  if (a.scopes.some((s) => !SCOPES.includes(s))) return { ok: false, reason: 'alcance-desconocido' }
+  if (a.scopes.some((s) => !SCOPES.includes(s))) return { ok: false, reason: 'unknown-scope' }
   const permitido = claimsAllowed(a.scopes)
-  if (Object.keys(a.claims || {}).some((k) => !permitido.has(k))) return { ok: false, reason: 'claim-sin-alcance' }
+  if (Object.keys(a.claims || {}).some((k) => !permitido.has(k))) return { ok: false, reason: 'claim-without-scope' }
 
   // Y lo de siempre: que la firma sea de alguien a quien el acta de esa cadena autoriza a
   // firmar por esta identidad. Es la misma comprobación que para cualquier contenido
   // firmado; aquí no se inventa una cripto aparte.
   const v = await verifySignedBy({ data: bodyOf(a), signature: a.signature, publickey: a.publickey, chain: a.chain, expectedProfileId })
-  if (!v.ok) return { ok: false, reason: 'firma:' + v.reason }
+  if (!v.ok) return { ok: false, reason: 'signature:' + v.reason }
   // A NOMBRE DE QUIÉN dice ir, contra a nombre de quién va de verdad. Sin esto una prueba
   // podría afirmar ser de otro perfil y la firma seguiría cuadrando: diría la verdad sobre
   // quién la firmó y una mentira sobre de quién es.
-  if (a.sub !== v.profileId) return { ok: false, reason: 'otro-sujeto' }
+  if (a.sub !== v.profileId) return { ok: false, reason: 'other-subject' }
 
   return { ok: true, profileId: v.profileId, signer: v.signer, seq: v.seq, scopes: [...a.scopes], claims: { ...(a.claims || {}) }, aud: a.aud, exp: a.exp }
 }
@@ -200,18 +200,18 @@ export async function verifySignedFor (args = {}) {
   const { data, signature, publickey, chain, audience, expectedProfileId = null, ns = null, now = Date.now(), maxSkewMs = ASSERTION_MAX_SKEW_MS } = args
   if (typeof audience !== 'string' || !audience.trim()) return { ok: false, reason: 'no-audience' }
   if (!data || typeof data !== 'object') return { ok: false, reason: 'shape' }
-  if (typeof data.aud !== 'string' || !data.aud) return { ok: false, reason: 'sin-destinatario' }
-  if (data.aud !== audience.trim()) return { ok: false, reason: 'otro-destinatario' }
+  if (typeof data.aud !== 'string' || !data.aud) return { ok: false, reason: 'no-aud' }
+  if (data.aud !== audience.trim()) return { ok: false, reason: 'other-audience' }
   if (data.exp != null) {
     if (!Number.isFinite(data.exp)) return { ok: false, reason: 'shape' }
-    if (data.exp <= now) return { ok: false, reason: 'vencida' }
+    if (data.exp <= now) return { ok: false, reason: 'expired' }
   }
   if (data.iat != null) {
     if (!Number.isFinite(data.iat)) return { ok: false, reason: 'shape' }
-    if (data.iat > now + maxSkewMs) return { ok: false, reason: 'del-futuro' }
+    if (data.iat > now + maxSkewMs) return { ok: false, reason: 'from-future' }
   }
   const v = await verifySignedBy({ data, signature, publickey, chain, expectedProfileId, ns })
-  if (!v.ok) return { ok: false, reason: 'firma:' + v.reason }
+  if (!v.ok) return { ok: false, reason: 'signature:' + v.reason }
   return { ok: true, profileId: v.profileId, signer: v.signer, seq: v.seq, aud: data.aud }
 }
 

package/vault/capabilities.js

@@ -30,7 +30,7 @@ const SIGN = { name: 'ECDSA', hash: { name: 'SHA-256' } }
 /*
  * EL MODELO VIEJO YA NO ENTRA. Los papeles de antes de 0.73 llevaban `exp` y no `seq`; se
  * aceptaron hasta el 2026-10-01 por un repliegue de migración declarado y con fecha, y esa
- * fecha pasó: se quitó (2026-10-05). Un papel sin `seq` se rechaza con `legacy-cert-retirado`,
+ * fecha pasó: se quitó (2026-10-05). Un papel sin `seq` se rechaza con `legacy-cert-retired`,
  * el mismo código que daba el repliegue al caducar, así que quien lo comprueba no cambia.
  */
 
@@ -238,7 +238,7 @@ export async function verifyDelegation ({ cert, expectedScope, expectedSub, acta
   if (v !== 1 || typeof iss !== 'string' || typeof sub !== 'string' || typeof sig !== 'string') return { ok: false, reason: 'shape' }
   if (typeof iat !== 'number' || (typeof scope !== 'string' && !Array.isArray(scope))) return { ok: false, reason: 'shape' }
   // UN PAPEL DEL MODELO VIEJO (con `exp`, sin `seq`) ya no vale: el repliegue se retiró.
-  if (typeof seq !== 'number') return { ok: false, reason: typeof cert.exp === 'number' ? 'legacy-cert-retirado' : 'shape' }
+  if (typeof seq !== 'number') return { ok: false, reason: typeof cert.exp === 'number' ? 'legacy-cert-retired' : 'shape' }
   if (!(await rawVerify(iss, enc(canonicalStringify(delegationBody(cert))), sig))) return { ok: false, reason: 'bad-signature' }
   // EL ACTA MANDA, Y NO HAY RELOJ (dueño, 2026-08-31). El papel no vence: dice «una
   // selladora de este perfil, mirando el acta nº `seq`, avaló esta llave». Lo que puede
@@ -264,7 +264,7 @@ export async function verifyDelegation ({ cert, expectedScope, expectedSub, acta
   // estaba apagado: vuelve, su papel ya no vale, y renovarlo exige una selladora ABIERTA.
   // O sea que un cambio de acta te obligaría a abrir la bóveda para que tus aparatos
   // volvieran — justo lo que se acaba de quitar de en medio.
-  if (seq > actaSeq) return { ok: false, reason: 'acta-vieja' }
+  if (seq > actaSeq) return { ok: false, reason: 'stale-record' }
   // Y QUIEN LO EMITIÓ TIENE QUE PODER SELLAR. No se compara contra «la maestra»: cualquiera
   // que el acta nombre sellador emite papeles válidos — si no, la segunda bóveda podría
   // invalidar todos los certificados al sellar y luego no poder dar los nuevos.

package/vault/core.js

@@ -408,7 +408,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
    */
   async function sealMasterKey () {
     const raw = kv.getItem(KEY_STORAGE)
-    if (!raw || !keyLock?.seal) return { ok: false, reason: 'sin-candado' }
+    if (!raw || !keyLock?.seal) return { ok: false, reason: 'no-lock' }
     const guardado = JSON.parse(raw)
     if (guardado.sealed) return { ok: true, already: true }
     await guardarPar(KEY_STORAGE, guardado.privateJwk, guardado.publicJwk)
@@ -1253,7 +1253,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
    * La plaza que quede abierta allí se cierra desde la consola, y así está dicho en el diseño.
    */
   async function closeLoginOn (meta) {
-    if (!meta?.user || !meta?.sid) return { ok: false, reason: 'sin-inicio-de-sesion' }
+    if (!meta?.user || !meta?.sid) return { ok: false, reason: 'no-login' }
     let client = null
     try {
       const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
@@ -1292,9 +1292,9 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
    */
   async function joinProfile (candidate) {
     const v = await Acta.verifyActa({ acta: candidate })
-    if (!v.ok) return { joined: false, reason: 'acta-invalida:' + v.reason }
+    if (!v.ok) return { joined: false, reason: 'invalid-record:' + v.reason }
     if (!candidate.members.some((m) => m.pub === publickeyJwkStr)) {
-      return { joined: false, reason: 'no-soy-miembro' }
+      return { joined: false, reason: 'not-a-member' }
     }
     const current = loadActa()
 
@@ -1307,7 +1307,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
     if (current && !isPendingJoin()) {
       return {
         joined: false,
-        reason: 'perfil-con-datos',
+        reason: 'profile-has-data',
         profileId: current.profileId,
         seq: current.seq,
         members: current.members.length
@@ -1347,7 +1347,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
     kv.setItem(VAULT_DEVICE_STORAGE, JSON.stringify({ useIdentityKey: true, publickey: publickeyJwkStr }))
     kv.setItem(VAULT_CERT_STORAGE, JSON.stringify({ cert: res.cert, master: res.master, proxy: res.proxy, deviceId: res.deviceId, pairedAt: Date.now() }))
     // Conectarse a una bóveda es ENTRAR A SU CUENTA: el acta viene con el cert.
-    const unido = res.acta ? await joinProfile(res.acta) : { joined: false, reason: 'sin-acta' }
+    const unido = res.acta ? await joinProfile(res.acta) : { joined: false, reason: 'no-record' }
     emitVault({ phase: 'paired', deviceId: res.deviceId, master: res.master, join: unido })
     // LA LLAVE ES DEL CHIP DEL TELÉFONO (app de Android): la app guarda la cuenta para su
     // pantalla nativa de Pedidos, con el MISMO papel. Así el teléfono es un solo aparato en
@@ -1380,7 +1380,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
       const r = await adoptActa(a)
       if (r.adopted) last = r
     }
-    return last || { adopted: false, reason: 'nada-que-adoptar', seq: loadActa()?.seq ?? null }
+    return last || { adopted: false, reason: 'nothing-to-adopt', seq: loadActa()?.seq ?? null }
   }
 
   /**
@@ -1416,7 +1416,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
   // Ya no hay ventana de caducidad: el papel no vence. Lo único que obliga a pedir uno
   // nuevo es que el ACTA diga algo distinto de lo que lleva escrito.
   /** Rechazos de la bóveda que se arreglan con un papel nuevo (el mismo juego que la app nativa). */
-  const PAPER_REASONS = new Set(['scope', 'acta-vieja', 'untrusted-issuer', 'expired', 'legacy-cert-retirado', 'no-acta'])
+  const PAPER_REASONS = new Set(['scope', 'stale-record', 'untrusted-issuer', 'expired', 'legacy-cert-retired', 'no-acta'])
   const RENEW_RETRY_MS = 60 * 60 * 1000 // si falla (vault apagado), no insistir >1 vez/hora
   let renewLastTry = 0
   /**
@@ -2328,7 +2328,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
       // selladora de ESTE perfil, mirando ESTA acta, avaló esta llave», y sin acta no se
       // puede decir ninguna de las dos cosas.
       const acta = loadActa()
-      if (!acta) throw Object.assign(new Error('this profile has no record to issue against'), { code: 'sin-acta' })
+      if (!acta) throw Object.assign(new Error('this profile has no record to issue against'), { code: 'no-record' })
       // `iss` se FUERZA a la propia maestra: el usuario no puede emitir cert para otro emisor.
       const cert = await signDelegationWith(masterKey(), publickeyJwkStr, { sub, scope, iat, seq: acta.seq, nonce: nonce || crypto.randomUUID() })
       const store = loadDelegations()
@@ -3024,11 +3024,11 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
       // La bóveda devuelve el acta ya sellada por ella (y con los certs re-emitidos): se
       // adopta por las reglas de siempre (§2.4.1) — encaja porque el sellador es el que
       // este mismo aparato nombró hace un momento.
-      // `misma-acta` = la bóveda guardó exactamente la que este aparato acababa de sellar
+      // `same-record` = la bóveda guardó exactamente la que este aparato acababa de sellar
       // y no la cambió. No hay nada que adoptar, y es justo lo que se esperaba: el
       // traspaso ya iba dentro de esa acta.
       const r = await adoptActa(res.acta)
-      const ok = r.adopted || r.reason === 'misma-acta'
+      const ok = r.adopted || r.reason === 'same-record'
       emitVault({ phase: 'adopted', master: res.master, seq: res.acta?.seq, ok })
       if (!ok) throw new Error('the vault returned a record that does not fit: ' + r.reason)
       return { ok: true, adopted: true, profileId: mine.profileId, seq: r.seq ?? res.acta?.seq, master: res.master, deviceId: res.deviceId }

package/vault/session.js

@@ -117,39 +117,39 @@ export async function verifySession (paper, { chain, expectedProfileId = null, o
   if (!isStr(p.sid) || !isStr(p.s) || !isStr(p.by) || !isStr(p.origin) || !isStr(p.sig)) return { ok: false, reason: 'shape' }
   if (!Number.isFinite(p.iat) || !Number.isFinite(p.exp) || !Array.isArray(p.scopes)) return { ok: false, reason: 'shape' }
 
-  if (p.exp <= p.iat) return { ok: false, reason: 'vigencia-invalida' }
-  if (p.exp - p.iat > SESSION_MAX_TTL_MS) return { ok: false, reason: 'vigencia-excesiva' }
-  if (p.exp <= now) return { ok: false, reason: 'vencida' }
-  if (p.iat > now + maxSkewMs) return { ok: false, reason: 'del-futuro' }
+  if (p.exp <= p.iat) return { ok: false, reason: 'invalid-lifetime' }
+  if (p.exp - p.iat > SESSION_MAX_TTL_MS) return { ok: false, reason: 'lifetime-too-long' }
+  if (p.exp <= now) return { ok: false, reason: 'expired' }
+  if (p.iat > now + maxSkewMs) return { ok: false, reason: 'from-future' }
 
   // DÓNDE vale. Un papel para una aplicación no vale en otra: el origen va firmado dentro.
-  if (origin != null && p.origin !== String(origin).trim()) return { ok: false, reason: 'otro-origen' }
+  if (origin != null && p.origin !== String(origin).trim()) return { ok: false, reason: 'other-origin' }
 
-  if (p.scopes.some((s) => !SESSION_SCOPES.includes(s))) return { ok: false, reason: 'alcance-desconocido' }
-  if (p.scopes.some((s) => SESSION_FORBIDDEN.includes(s))) return { ok: false, reason: 'alcance-prohibido' }
+  if (p.scopes.some((s) => !SESSION_SCOPES.includes(s))) return { ok: false, reason: 'unknown-scope' }
+  if (p.scopes.some((s) => SESSION_FORBIDDEN.includes(s))) return { ok: false, reason: 'forbidden-scope' }
 
   // EL ACTA MANDA, y por eso hace falta: dice si el aparato que respalda sigue siendo del
   // perfil y qué puede. Sin ella no se juzga, en vez de dar por bueno lo que diga el papel.
   const c = await verifySealerChain(chain, { expectedProfileId })
-  if (!c.ok) return { ok: false, reason: 'cadena:' + c.reason }
+  if (!c.ok) return { ok: false, reason: 'chain:' + c.reason }
   const acta = chain[chain.length - 1]
 
   // PRIMERO, ¿ES DE LA CASA? Y en este orden a propósito: si al aparato lo quitaron, el
   // motivo tiene que decir eso y no «le falta un permiso», que manda a mirar al sitio
   // equivocado. Es además el invariante que hace barata la revocación — quitar un aparato
   // se lleva sus sesiones sin avisar a nadie ni perseguir papeles.
-  if (!(acta.members || []).some((m) => m?.pub === p.by)) return { ok: false, reason: 'aparato-no-es-del-perfil' }
+  if (!(acta.members || []).some((m) => m?.pub === p.by)) return { ok: false, reason: 'device-not-in-profile' }
 
   // Y DESPUÉS, NUNCA AMPLÍA: cada alcance exige que el aparato que firmó lo tenga HOY. Se
   // comprueba aquí y no solo al emitir, porque quien emite es precisamente quien podría
   // mentir — y porque el acta de hoy puede haberle quitado lo que tenía ayer.
   for (const s of p.scopes) {
     const cap = SCOPE_NEEDS[s]
-    if (cap && !memberCan(acta, p.by, cap)) return { ok: false, reason: 'aparato-sin-' + cap }
+    if (cap && !memberCan(acta, p.by, cap)) return { ok: false, reason: 'device-lacks-' + cap }
   }
 
   const { sig, ...body } = p
-  if (!(await verifyDeviceSig({ publickey: p.by, data: body, signature: sig }))) return { ok: false, reason: 'firma-invalida' }
+  if (!(await verifyDeviceSig({ publickey: p.by, data: body, signature: sig }))) return { ok: false, reason: 'invalid-signature' }
 
   return { ok: true, profileId: c.profileId, seq: c.seq, sid: p.sid, s: p.s, by: p.by, origin: p.origin, scopes: [...p.scopes], exp: p.exp }
 }
@@ -164,8 +164,8 @@ export async function verifySessionSigned ({ data, signature, session, chain, sc
   if (!data || !isStr(signature)) return { ok: false, reason: 'shape' }
   const v = await verifySession(session, { chain, expectedProfileId, origin, now })
   if (!v.ok) return v
-  if (scope && !v.scopes.includes(scope)) return { ok: false, reason: 'fuera-de-alcance' }
-  if (!(await verifyDeviceSig({ publickey: v.s, data, signature }))) return { ok: false, reason: 'firma-invalida' }
+  if (scope && !v.scopes.includes(scope)) return { ok: false, reason: 'out-of-scope' }
+  if (!(await verifyDeviceSig({ publickey: v.s, data, signature }))) return { ok: false, reason: 'invalid-signature' }
   return { ok: true, profileId: v.profileId, sid: v.sid, scopes: v.scopes, exp: v.exp }
 }
 

package/vault/sessionFlow.js

@@ -81,18 +81,18 @@ export async function openSession ({ transport, sessionPubkey, encPub, origin, s
   return await new Promise((resolve, reject) => {
     let listo = false
     const fin = (fn, arg) => { if (!listo) { listo = true; clearTimeout(reloj); off?.(); fn(arg) } }
-    const reloj = setTimeout(() => fin(reject, Object.assign(new Error('nadie abrió la sesión a tiempo'), { code: 'session-timeout' })), timeoutMs)
+    const reloj = setTimeout(() => fin(reject, Object.assign(new Error('openSession: nobody granted the session in time'), { code: 'session-timeout' })), timeoutMs)
     const off = transport.on('message', async (_from, payload, meta) => {
       const p = typeof payload === 'string' ? (() => { try { return JSON.parse(payload) } catch (_) { return null } })() : payload
       if (!p || p.sid !== sid) return
-      if (p.op === SESSION_OP.DENY) return fin(reject, Object.assign(new Error('la sesión no se concedió'), { code: 'session-denied' }))
+      if (p.op === SESSION_OP.DENY) return fin(reject, Object.assign(new Error('openSession: the session was denied'), { code: 'session-denied' }))
       if (p.op !== SESSION_OP.GRANT) return
       // NO SE ACEPTA LO QUE VENGA EN CLARO. El sellado es del pilar del transporte; aquí
       // solo se comprueba que llegó sellado, que es lo que la app puede saber.
       if (meta && meta.sealed === false) return
       const v = await verifySession(p.paper, { chain: p.chain, origin: origin.trim() })
-      if (!v.ok) return fin(reject, Object.assign(new Error('el papel de sesión no vale: ' + v.reason), { code: 'session-invalid' }))
-      if (p.paper.s !== sessionPubkey) return fin(reject, Object.assign(new Error('el papel es para otra llave'), { code: 'session-invalid' }))
+      if (!v.ok) return fin(reject, Object.assign(new Error('openSession: the session paper does not verify: ' + v.reason), { code: 'session-invalid' }))
+      if (p.paper.s !== sessionPubkey) return fin(reject, Object.assign(new Error('openSession: the session paper is for another key'), { code: 'session-invalid' }))
       fin(resolve, { paper: p.paper, chain: p.chain, profileId: v.profileId, sid, scopes: v.scopes, exp: v.exp })
     })
   })
@@ -109,7 +109,7 @@ export async function openSession ({ transport, sessionPubkey, encPub, origin, s
  */
 export async function grantSession ({ transport, invite, by, sign, chain, scopes, ttlMs = SESSION_DEFAULT_TTL_MS, now = Date.now() } = {}) {
   const inv = parseInvite(invite)
-  if (!inv) throw new Error('grantSession: invitación ilegible')
+  if (!inv) throw Object.assign(new Error('grantSession: unreadable invite'), { code: 'bad-invite' })
   if (typeof by !== 'string' || !by) throw new Error('grantSession: by (this device pubkey) required')
   if (typeof sign !== 'function') throw new Error('grantSession: sign(body) required')
   if (!Array.isArray(chain) || !chain.length) throw new Error('grantSession: chain required')
@@ -123,7 +123,7 @@ export async function grantSession ({ transport, invite, by, sign, chain, scopes
 /** Decir que no, en vez de dejar al otro mirando una pantalla que no avanza. */
 export async function denySession ({ transport, invite } = {}) {
   const inv = parseInvite(invite)
-  if (!inv) throw new Error('denySession: invitación ilegible')
+  if (!inv) throw Object.assign(new Error('denySession: unreadable invite'), { code: 'bad-invite' })
   await enviar(transport, inv, { op: SESSION_OP.DENY, sid: inv.sid })
 }
 
@@ -144,7 +144,7 @@ async function enviar (transport, inv, payload) {
   }
   // Sin llave de cifrado del otro lado no se puede sellar. Se dice en vez de mandarlo en
   // claro por su cuenta: quien llama decide si eso le vale.
-  if (!inv.encPub) throw Object.assign(new Error('sessionFlow: la invitación no trae encPub; no se puede sellar'), { code: 'unsealed' })
+  if (!inv.encPub) throw Object.assign(new Error('sessionFlow: the invite carries no encPub; cannot seal'), { code: 'unsealed' })
   return transport.sendByPubkey(inv.s, payload)
 }
 

package/vault/vendor/roadmap/VERSION.txt

@@ -1,3 +1,3 @@
-Copia vendorizada de @dotrino/roadmap@0.4.33 (dotrino-roadmap/src/{index,manifests}.js).
+Copia vendorizada de @dotrino/roadmap@0.4.35 (dotrino-roadmap/src/{index,manifests}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 El registro de versiones rotas que viaja con cada versión. Importa @dotrino/compat/ranges.

package/vault/vendor/roadmap/manifests.js

@@ -8,8 +8,8 @@
 export const MANIFESTS = Object.freeze({
   "dotrino": {
     "manifest": "dotrino",
-    "seq": 31,
-    "issued": "2026-10-16",
+    "seq": 32,
+    "issued": "2026-10-18",
     "note": "Registro comun de compatibilidad del ecosistema. Se edita a mano en este repo y se consulta con @dotrino/roadmap. Rangos: ver @dotrino/compat/ranges (x.y.z, >= > <= <, «a - b», «*», o una lista que es un O).",
     "products": {
       "compat": {
@@ -31,7 +31,7 @@ export const MANIFESTS = Object.freeze({
       "identity": {
         "repo": "imdotrino/dotrino-identity",
         "npm": "@dotrino/identity",
-        "current": "0.121.2",
+        "current": "0.121.3",
         "protocol": 1,
         "requires": {
           "proxy-client": ">=0.13.1"
@@ -101,7 +101,7 @@ export const MANIFESTS = Object.freeze({
       "profile": {
         "repo": "imdotrino/dotrino-profile",
         "npm": "@dotrino/profile",
-        "current": "0.20.2",
+        "current": "0.20.3",
         "protocol": 1,
         "requires": {
           "identity": ">=0.33.0"
@@ -131,7 +131,7 @@ export const MANIFESTS = Object.freeze({
       "remote-agent": {
         "repo": "imdotrino/dotrino-remote-agent",
         "npm": "@dotrino/remote-agent",
-        "current": "0.22.1",
+        "current": "0.22.2",
         "protocol": 1,
         "requires": {
           "identity": ">=0.120.0",
@@ -193,10 +193,10 @@ export const MANIFESTS = Object.freeze({
       "content": {
         "repo": "imdotrino/dotrino-content",
         "npm": "@dotrino/content",
-        "current": "0.6.6",
+        "current": "0.6.7",
         "protocol": 1,
         "requires": {
-          "remote-agent": ">=0.22.0",
+          "remote-agent": ">=0.22.2",
           "identity": ">=0.120.0",
           "vault": ">=0.87.0",
           "proxy-client": ">=0.36.1"