@dotrino/identity 0.65.1 → 0.67.0

package/package.json

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

package/vault/acta.js

@@ -37,7 +37,7 @@
 import { canonicalStringify } from './core.js'
 import { signWithDevice, verifyDeviceSig, pubkeyId } from './capabilities.js'
 
-export const ACTA_V = 2
+export const ACTA_V = 3
 
 /**
  * Versiones de acta que se ACEPTAN al leer. La 1 sigue entrando porque una v1 en el disco
@@ -46,7 +46,22 @@ export const ACTA_V = 2
  * asciende sola: el acta siguiente que selle la maestra ya sale v2 (ver `applyChanges`).
  * La única diferencia es la llave de sellado (§8.9), que en una v1 simplemente no hay.
  */
-const ACTA_LEIBLES = Object.freeze([1, 2])
+/**
+ * v3 quita `acta.sealer` (dueño, 2026-08-31: «SEAL es el nuevo master»): sellar es un
+ * permiso y nada más.
+ *
+ * Las anteriores SE SIGUEN LEYENDO, y no por nostalgia: dejar de hacerlo dejaría sin abrir
+ * TODAS las cuentas que existen hoy —cada una tendría que rehacerse aparato por aparato—
+ * cuando lo único que hace falta es traducir el campo a un permiso al leerlas. Un acta
+ * vieja no se puede reescribir (está firmada), así que se lee tal cual y `canSeal` la
+ * entiende; la PRIMERA vez que esa cuenta cambie algo, la nueva sale ya en v3 y el campo
+ * desaparece solo.
+ */
+const ACTA_LEIBLES = Object.freeze([1, 2, 3])
+/** Desde esta versión, sellar es solo un permiso y no hay campo `sealer`. */
+const V_SIN_CAMPO_SELLADOR = 3
+/** ¿Este acta es de las viejas, con el campo? */
+const conCampoSellador = (acta) => Number(acta?.v) < V_SIN_CAMPO_SELLADOR
 
 /**
  * Lista CERRADA de capacidades.
@@ -182,26 +197,20 @@ export async function memberId (pub) {
  */
 export const sealersOf = (acta, renounces = []) => {
   if (!acta) return []
-  const extra = (acta.members || [])
-    .filter((m) => m.pub !== acta.sealer && memberCan(acta, m.pub, 'sealer', renounces))
+  const porPermiso = (acta.members || [])
+    .filter((m) => memberCan(acta, m.pub, 'sealer', renounces))
     .map((m) => m.pub)
-  return [acta.sealer, ...extra]
+  // Acta vieja: el que estaba en el campo sellaba SIN tener el permiso. Se traduce al
+  // leerla, que es la única forma —está firmada y no se puede reescribir—.
+  if (conCampoSellador(acta) && acta.sealer && !porPermiso.includes(acta.sealer)) {
+    return [acta.sealer, ...porPermiso]
+  }
+  return porPermiso
 }
 
 /** ¿Puede `pub` sellar la siguiente acta de este perfil? */
 export const canSeal = (acta, pub, renounces = []) =>
-  !!acta && (pub === acta.sealer || memberCan(acta, pub, 'sealer', renounces))
-
-/**
- * El acta la firmó alguien DISTINTO del sellador que ella misma nombra.
- *
- * ⚠️ Desde el multivault esto ya NO significa «es un traspaso», y confundirlo costó un
- * desempate mal resuelto: cuando sella la segunda bóveda, el acta sigue nombrando
- * sellador a la primera y la firma la segunda, así que esto da `true` sin que nadie
- * traspase nada. Es condición NECESARIA de un traspaso, no suficiente — lo que lo
- * distingue es que un traspaso CAMBIA a quién nombra (ver `canAdopt`).
- */
-export const isHandover = (acta) => !!acta && acta.sealer !== acta.sealedBy
+  !!acta && (memberCan(acta, pub, 'sealer', renounces) || (conCampoSellador(acta) && pub === acta.sealer))
 
 /**
  * Acta de génesis: un perfil recién nacido tiene UN miembro (esta llave), que además es el
@@ -213,11 +222,10 @@ export function genesisActa ({ pub, encPub = null, sealPub = null, label = '', n
   return {
     v: ACTA_V,
     profileId: pub,
-    sealer: pub,
     sealedBy: pub,
     seq: 1,
     prev: null,
-    members: [{ pub, encPub, label: String(label || '').slice(0, 60), cn: null, caps: [...PAIRED_CAPS], addedAt: now, cert: null }],
+    members: [{ pub, encPub, label: String(label || '').slice(0, 60), cn: null, caps: [...PAIRED_CAPS, 'sealer'], addedAt: now, cert: null }],
     revoked: [],
     renounced: [],
     // Llavero del contenido: una entrada por generación, con la clave del perfil ENVUELTA
@@ -239,7 +247,10 @@ export function genesisActa ({ pub, encPub = null, sealPub = null, label = '', n
 export function checkShape (acta) {
   if (!acta || typeof acta !== 'object') return 'no-acta'
   if (!ACTA_LEIBLES.includes(acta.v)) return 'version'
-  if (!isPub(acta.profileId) || !isPub(acta.sealer) || !isPub(acta.sealedBy)) return 'shape'
+  if (!isPub(acta.profileId) || !isPub(acta.sealedBy)) return 'shape'
+  // 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 (!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'
@@ -279,7 +290,10 @@ export function checkShape (acta) {
   }
   }
   if (new Set(acta.members.map((m) => m.pub)).size !== acta.members.length) return 'miembro-duplicado'
-  if (!acta.members.some((m) => m.pub === acta.sealer)) return 'sealer-no-es-miembro'
+  // 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 (!acta.members.some((m) => m.caps.includes('sign'))) return 'sin-firmante'
   return null
 }
@@ -436,7 +450,6 @@ export async function applyChanges (acta, changes, { by, now = Date.now(), sealP
       case 'remove': {
         const i = next.members.findIndex((m) => m.pub === ch.pub)
         if (i < 0) throw new Error('remove: that member is not in the record')
-        if (next.members[i].pub === next.sealer) throw new Error('remove: cannot remove the master; hand the sealing over first')
         // Quitar al miembro se lleva su permiso de sellar: no hay lista aparte que limpiar.
         const fuera = next.members.splice(i, 1)[0]
         // Sus envolturas se van con él: sin ellas no puede abrir ninguna generación. (El
@@ -447,11 +460,6 @@ export async function applyChanges (acta, changes, { by, now = Date.now(), sealP
         })
         break
       }
-      case 'handover': {
-        if (!find(ch.to)) throw new Error('handover: the new master must be a member (admit them in the same change)')
-        next.sealer = ch.to
-        break
-      }
       case 'keyring': {
         // Generación NUEVA de la clave de contenido (al rotar: expulsar a alguien).
         const g = ch.generation
@@ -493,8 +501,31 @@ export async function applyChanges (acta, changes, { by, now = Date.now(), sealP
   if (!next.members.some((m) => m.caps.includes('sign'))) {
     throw new Error('the change would leave the profile with no member able to sign')
   }
-  if (!next.members.some((m) => m.pub === next.sealer)) {
-    throw new Error('the change would leave the record with no master')
+  // ASCENDER DE UNA VIEJA: el que sellaba por el CAMPO pasa a sellar por el PERMISO. Es
+  // toda la migración, y va aquí porque este es el momento en que la cuenta escribe su
+  // primera v3 — el acta vieja no se puede tocar, está firmada.
+  if (conCampoSellador(acta) && acta.sealer) {
+    const m = next.members.find((x) => x.pub === acta.sealer)
+    if (m && !m.caps.includes('sealer')) m.caps = cleanCaps([...m.caps, 'sealer'])
+    // Y el campo se va con la vieja: la nueva es v3 y en v3 no existe.
+    delete next.sealer
+  }
+  if (!sealersOf(next).length) {
+    throw new Error('the change would leave the record with nobody able to seal it')
+  }
+  // EL DOBLE FILTRO (dueño, 2026-08-31): un acta nueva tiene que pasar el filtro de la
+  // ANTERIOR —quién podía sellar, arriba— y también el de LA QUE SE VA A FIRMAR. Si no
+  // pasa los dos, no se firma.
+  //
+  // Lo que cierra: un sellador que se quita a sí mismo el permiso en la misma acta que
+  // firma. Es absurdo —se firma con una autoridad que uno acaba de retirarse— y no tiene
+  // vuelta atrás: deshacerlo requeriría sellar, que es justo lo que se acaba de perder.
+  //
+  // Y por qué aquí y no con una marca de «traspaso»: mirando el acta SOLA, ceder el mando
+  // y quitarse el permiso se ven igual. Con las dos actas delante no hay ambigüedad, y las
+  // dos veces que esto importa —construirla, y adoptar una ajena— se tienen las dos.
+  if (!canSeal(next, by)) {
+    throw new Error('the change would leave whoever seals it unable to seal: a record must pass the filter of the one it replaces AND its own')
   }
   return next
 }
@@ -578,6 +609,31 @@ export function memberCanSign (acta, pub, ns = null) {
   return ns != null && m.cn === ns
 }
 
+/**
+ * ¿PUEDE ESTE MIEMBRO LO QUE PIDE EL SCOPE? La misma pregunta para todos los mostradores.
+ *
+ * El certificado dice a qué se comprometió la bóveda cuando conectó el aparato; el ACTA
+ * dice lo que puede hoy. Y no coinciden: cambiar los permisos sella el acta pero NO
+ * reemite ni revoca el papel, que vive hasta 30 días. Quitarle `lee` a un aparato y que
+ * siguiera leyendo un mes es el mismo fallo que estaba en `sign`, en cada mostrador que
+ * se olvidara de preguntar.
+ *
+ * Por eso esto existe y por eso traduce el SCOPE (el idioma del certificado) a la
+ * capacidad (el idioma del acta): así el guardia se pone UNA vez, junto a la verificación
+ * de la cadena, y un mostrador nuevo lo hereda en lugar de tener que acordarse.
+ *
+ * Devuelve `false` ante un scope que no reconoce: si aparece uno nuevo, lo que toca es
+ * añadirlo aquí, no que se cuele por no estar en la lista.
+ */
+export function memberCanScope (acta, pub, scope) {
+  if (!acta || typeof scope !== 'string') return false
+  const secretos = /^vault:secrets:([a-z0-9-]{1,32})$/.exec(scope)
+  if (secretos) return memberCanReadSecrets(acta, pub, secretos[1])
+  if (scope === 'vault:sign') return memberCanSign(acta, pub)
+  const cap = Object.keys(CAP_SCOPE).find((c) => CAP_SCOPE[c] === scope)
+  return cap ? memberCan(acta, pub, cap) : false
+}
+
 export function memberCanReadSecrets (acta, pub, ns) {
   const m = (acta?.members || []).find((x) => x.pub === pub)
   if (!m || !m.cn) return false
@@ -736,21 +792,11 @@ export async function canAdopt ({ candidate, current }) {
     // 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' }
-    // UN TRASPASO ES EL QUE CAMBIA A QUIÉN NOMBRA, no el que firma otro. Con una sola
-    // bóveda daba igual —solo un traspaso podía firmar sin ser el sellador—, pero con dos
-    // la segunda firma sin serlo cada vez que sella, y entonces TODA acta suya se leía
-    // como un traspaso y ganaba el desempate por la puerta de atrás.
-    //
-    // Las dos ramas salen del mismo padre, así que comparar a quién nombra cada una
-    // resuelve los tres casos: si nombran al mismo (dos coselladores trabajando), no hay
-    // traspaso y decide el hash; si una nombra a otro, esa es la que traspasa y gana; y
-    // si las dos traspasan a destinos distintos, vuelven a empatar y decide el hash,
-    // que es lo que §2.4.1 ya decía.
-    const mismoSellador = candidate.sealer === current.sealer
-    const canT = isHandover(candidate) && !mismoSellador
-    const curT = isHandover(current) && !mismoSellador
-    if (canT && !curT) return { adopt: true, reason: 'traspaso-gana' }
-    if (!canT && curT) return { adopt: false, reason: 'traspaso-gana' }
+    // 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' }
   }
 
@@ -758,9 +804,9 @@ export async function canAdopt ({ candidate, current }) {
 }
 
 export default {
-  ACTA_V, CAPS, CAP_SCOPE, genesisActa, actaBody, actaHash, memberId, checkShape, isHandover,
+  ACTA_V, CAPS, CAP_SCOPE, genesisActa, actaBody, actaHash, memberId, checkShape,
   sealActa, verifyActa, applyChanges, makeRenounce, verifyRenounce,
   makeContinuity, verifyContinuity,
   cardBody, makeProfileCard, verifyProfileCard, canAdoptCard, sealersOf, canSeal,
-  effectiveCaps, memberCan, memberCanSign, memberCanReadSecrets, memberScopes, isService, capScope, isValidCn, canAdopt
+  effectiveCaps, memberCan, memberCanSign, memberCanScope, memberCanReadSecrets, memberScopes, isService, capScope, isValidCn, canAdopt
 }

package/vault/core.js

@@ -540,7 +540,12 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   const saveRenounces = (l) => kv.setItem(RENOUNCE_STORAGE, JSON.stringify(l))
 
   /** ¿Es ESTE dispositivo el master (el único que puede sellar)? */
-  const amMaster = () => loadActa()?.sealer === publickeyJwkStr
+  /**
+   * ¿PUEDO SELLAR? Antes era «¿soy el master?» y miraba un campo. Con sellar convertido en
+   * permiso, la pregunta correcta es esta — y su respuesta puede ser «sí» en más de un
+   * aparato a la vez, que es justo el punto del multivault.
+   */
+  const amMaster = () => Acta.canSeal(loadActa(), publickeyJwkStr, loadRenounces())
 
   /**
    * Quien sella SOBRES (la bóveda) pone aquí una función que estrena una llave de sellado
@@ -571,7 +576,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     const sealed = await seal(next)
     pushHistory(acta) // la que deja de ser vigente entra en la ventana de retención
     saveActa(sealed)
-    emitVault({ phase: 'acta', seq: sealed.seq, sealer: sealed.sealer })
+    emitVault({ phase: 'acta', seq: sealed.seq, sealedBy: sealed.sealedBy })
     return sealed
   }
 
@@ -697,7 +702,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     // retener; guardarla aquí solo mezclaría dos cuentas en la misma ventana (§1.3).
     kv.setItem(ACTA_HISTORY_STORAGE, '[]')
     clearPendingJoin()
-    emitVault({ phase: 'acta', seq: candidate.seq, sealer: candidate.sealer, joined: true })
+    emitVault({ phase: 'acta', seq: candidate.seq, sealedBy: candidate.sealedBy, joined: true })
     return { joined: true, profileId: candidate.profileId, seq: candidate.seq }
   }
 
@@ -763,7 +768,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     const r = await Acta.canAdopt({ candidate, current })
     if (!r.adopt) return { adopted: false, reason: r.reason, seq: current?.seq ?? null }
     saveActa(candidate)
-    emitVault({ phase: 'acta', seq: candidate.seq, sealer: candidate.sealer, adopted: r.reason })
+    emitVault({ phase: 'acta', seq: candidate.seq, sealedBy: candidate.sealedBy, adopted: r.reason })
     const sigoDentro = (candidate.members || []).some((m) => m?.pub === publickeyJwkStr)
     if (!sigoDentro) {
       console.warn('[identity] the new record no longer lists this device: removing the account')
@@ -1025,7 +1030,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   async function askIfStillAMember () {
     try {
       const acta = loadActa()
-      if (!acta || acta.sealer === publickeyJwkStr) return          // no hay cuenta ajena que confirmar: mando yo
+      if (!acta || Acta.canSeal(acta, publickeyJwkStr)) return       // sello yo: no hay cuenta ajena que confirmar
       // El acta que ya tengo no me nombra: no hace falta preguntar nada, el acta manda y va
       // firmada. (Normalmente esto lo resuelve `adoptActa` al recibirla.)
       if (!(acta.members || []).some((m) => m?.pub === publickeyJwkStr)) {
@@ -1035,7 +1040,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const v = loadVaultCert()
       if (v?.cert && loadVaultDevice()) return                      // con papel, ya lo comprueba el camino normal
       const r = await remoteCheck({
-        master: acta.sealer,
+        master: Acta.sealersOf(acta)[0] || null,
         proxy: v?.proxy || 'wss://proxy.dotrino.com',
         device: { publickey: publickeyJwkStr, privateKey: keypair.privateKey },
         onRevoked: wipeVaultLink
@@ -1493,7 +1498,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
 
     async profileMembers () {
       const acta = loadActa()
-      if (!acta) return { members: [], profileId: null, seq: 0, sealer: null }
+      if (!acta) return { members: [], profileId: null, seq: 0, sealers: [] }
       const pend = loadRenounces()
       const members = await Promise.all(acta.members.map(async (m) => ({
         pub: m.pub,
@@ -1504,7 +1509,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
         caps: Acta.effectiveCaps(acta, m.pub, pend),
         addedAt: m.addedAt || null,
         isMe: m.pub === publickeyJwkStr,
-        isMaster: m.pub === acta.sealer,
+        isMaster: Acta.canSeal(acta, m.pub),
         // La llave de CIFRADO del miembro y, derivado, si se le puede envolver algo.
         // Sale en la proyección porque sin ella ninguna interfaz (CLI, TUI, consola)
         // puede decir «a este aparato no se le puede escribir», y ese silencio es
@@ -1512,7 +1517,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
         encPub: m.encPub || null,
         canSeal: !!m.encPub
       })))
-      return { members, profileId: acta.profileId, seq: acta.seq, sealer: acta.sealer, updatedAt: acta.updatedAt }
+      return { members, profileId: acta.profileId, seq: acta.seq, sealers: Acta.sealersOf(acta), updatedAt: acta.updatedAt }
     },
 
     async myMembership () {
@@ -1523,7 +1528,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
         inProfile: !!m,
         profileId: acta.profileId,
         seq: acta.seq,
-        isMaster: acta.sealer === publickeyJwkStr,
+        isMaster: Acta.canSeal(acta, publickeyJwkStr),
         caps: Acta.effectiveCaps(acta, publickeyJwkStr, loadRenounces()),
         id: m ? await Acta.memberId(m.pub) : null
       }
@@ -1590,12 +1595,24 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      * sellador tiene que ser miembro para poder serlo, y así no hay ventana intermedia.
      * Cubre igual dispositivo → bóveda y bóveda → bóveda (mudarse de PC).
      */
+    /**
+     * CEDER EL MANDO = CONCEDER `sella`. Ya no hay traspaso: sellar es un permiso, así que
+     * «pasarle el mando a otro» es dárselo, y punto. Lo que ANTES hacía esto —dejar de
+     * poder sellar uno mismo, en el mismo acto— ya no se puede: nadie se quita el sello a
+     * sí mismo (dejaría un acta que él firma sin poder firmarla). Si quieres salir, se lo
+     * pides al otro cuando ya pueda sellar.
+     */
     async handoverMaster ({ to, member = null } = {}) {
       const changes = []
-      if (member) changes.push({ op: 'admit', member: { ...member, pub: to } })
-      changes.push({ op: 'handover', to })
+      const acta0 = loadActa()
+      if (member) changes.push({ op: 'admit', member: { ...member, pub: to, caps: [...(member.caps || []), 'sealer'] } })
+      else {
+        const m = (acta0?.members || []).find((x) => x.pub === to)
+        if (!m) throw new Error('handover: the new sealer must be a member (admit them in the same change)')
+        changes.push({ op: 'caps', pub: to, caps: [...new Set([...(m.caps || []), 'sealer'])] })
+      }
       const acta = await sealChanges(changes)
-      return { ok: true, seq: acta.seq, sealer: acta.sealer }
+      return { ok: true, seq: acta.seq, sealers: Acta.sealersOf(acta) }
     },
 
     /**
@@ -1606,6 +1623,13 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     async renounceCaps ({ caps } = {}) {
       const acta = loadActa()
       if (!acta) throw new Error('this profile has no record yet')
+      // SELLAR NO SE RENUNCIA. Es la misma auto-amputación que el acta ya impide, por otra
+      // puerta: la renuncia es unilateral y no pasa por nadie, así que sin esto un
+      // sellador podría dejarse —o dejar a la cuenta— sin nadie que pueda volver a sellar,
+      // y eso no tiene marcha atrás. Que te lo quite otro sellador, que sí puede.
+      if ((Array.isArray(caps) ? caps : [caps]).includes('sealer')) {
+        throw new Error('sealing cannot be renounced: ask another sealer to take it from you')
+      }
       const record = await Acta.makeRenounce({ member: publickeyJwkStr, caps, privateKey: keypair.privateKey })
       const pend = loadRenounces().filter((r) => r.member !== publickeyJwkStr)
       pend.push(record)
@@ -1735,7 +1759,11 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       // hasta ella: en los dos casos, mandarla es tirar cientos de KB por el transporte.
       if (!mine) return { chain: [], window: ACTA_WINDOW }
       // Puede dar el salto él solo: el sellador no cambió.
-      if (cur.sealedBy === mine.sealer) return { chain: [], window: ACTA_WINDOW }
+      // Si quien selló la última YA podía sellar en el acta que tiene el otro, el salto lo
+      // da él solo: no hace falta mandarle los eslabones. Antes esto comparaba contra el
+      // campo `sealer`; ahora se le pregunta al permiso, que es lo mismo con un solo
+      // sellador y lo correcto con varios.
+      if (Acta.canSeal(mine, cur.sealedBy)) return { chain: [], window: ACTA_WINDOW }
       const all = [...hist.filter((a) => a.seq > sinceSeq), cur]
       return { chain: all.sort((a, b) => a.seq - b.seq), window: ACTA_WINDOW }
     },