@dotrino/identity 0.95.0 → 0.96.0

package/package.json

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

package/src/index.js

@@ -591,6 +591,28 @@ export class Identity {
   /** Borra un perfil y sus datos (no el único). */
   async deleteProfile (id) { return this._call('deleteProfile', { id }) }
 
+  // ----- entrar con usuario y contraseña (`temporary-access.md`) -----
+
+  /**
+   * ENTRAR en un aparato de tu cuenta desde un navegador que no te conoce, con la dirección
+   * `nombre@AB12-CD34-EF56` y su contraseña. Devuelve `{ id, name, address, user, sid,
+   * volatile }` y la app debe **recargar**: este navegador pasa a ser ese aparato.
+   *
+   * `remember: false` (lo normal en un equipo prestado) deja la cuenta en MEMORIA —se va al
+   * cerrar o recargar la pestaña y no toca el disco de esa máquina—; `true` la guarda como
+   * cualquier otra de este navegador, con la llave no extraíble, hasta que salgas.
+   *
+   * La contraseña no sale de aquí: se comprueba con OPAQUE, que no la manda ni deja
+   * adivinarla. Los errores llegan con su `code`: `login-failed` (dirección o contraseña),
+   * `too-many-tries` (con `waitMs`), `no-vault` (ninguna bóveda encendida en esa dirección).
+   */
+  async loginWithPassword ({ address, password, remember = false, label = '', proxyUrl = null } = {}) {
+    return this._call('loginWithPassword', { address, password, remember, label, proxyUrl }, 60000)
+  }
+
+  /** SALIR del inicio de sesión con contraseña (el activo, o el que digas). Recargar después. */
+  async logoutLogin (id = null) { return this._call('logoutLogin', { id }, 30000) }
+
   /**
    * Merge endorsements (signed ratings from third parties) about a subject
    * into the local peer book. Returns { merged, total }.

package/vault/core.js

@@ -38,12 +38,15 @@ export const ACTA_HISTORY_STORAGE = 'dotrino.identity.acta.history' // últimas
 export const PENDING_JOIN_STORAGE = 'dotrino.identity.pendingJoin'  // «nací para adoptar la cuenta de otro»
 export const RENOUNCE_STORAGE = 'dotrino.identity.renounced'        // renuncias propias aún no absorbidas por el master
 export const GRANTS_STORAGE = 'dotrino.identity.grants'             // qué le concediste a cada origen (permiso por origen)
+export const LOGIN_STORAGE = 'dotrino.identity.login'               // se entró con usuario y contraseña: { user, address, sid, … }
 // Multi-perfil por dispositivo: lista de perfiles + el activo. Cada perfil tiene su propio
 // namespace `dotrino.identity.p.<id>.<suffix>` para TODAS las claves de arriba (keypair, me, etc.).
 export const PROFILES_STORAGE = 'dotrino.identity.profiles' // [{ id, name, pubkey }]
 export const CURRENT_STORAGE = 'dotrino.identity.current'   // id del perfil activo
 
 const NONCE_TTL_MS = 5 * 60 * 1000
+/** El proxio del ecosistema. No hay otro: quien quiera el suyo lo dice al llamar. */
+const DEFAULT_PROXY = 'wss://proxy.dotrino.com'
 
 // ----- crypto helpers (puros) -----
 
@@ -192,11 +195,54 @@ function sanitizeProfilePatch (patch = {}) {
  *
  * Si no se inyecta, no se concede nada nuevo: sin forma de preguntar, la respuesta es no.
  */
-export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, keyStore = null, sessionKv = null, removeAccountOnExpulsion = true, keyLock = null, askConsent = null }) {
+export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null, keyStore: hostKeyStore = null, sessionKv = null, removeAccountOnExpulsion = true, keyLock = null, askConsent = null }) {
   const {
     initPeerStorage, loadPeers, savePeers, setPeersDirect, upsertPeer, onDirty
   } = peers
 
+  // ----- CUENTAS DE PASO: entrar en un equipo que NO es tuyo -----
+  //
+  // Una cuenta de paso es la que se abre con usuario y contraseña SIN marcar «Recordar»
+  // (`temporary-access.md` §3.4). No es una cuenta de este navegador: es de ESTA PESTAÑA, y
+  // desaparece —entera, con su llave— en cuanto la pestaña se va.
+  //
+  // Lo primero que se intentó fue tenerla solo en memoria, que suena mejor y no sirve: el
+  // iframe de identidad muere con cada navegación, así que entrar y pulsar el primer enlace
+  // te dejaba fuera otra vez. Así que se guarda como cualquier otra —la llave, `CryptoKey`
+  // NO EXTRAÍBLE en IndexedDB, nunca en claro— y lo que cambia es QUIÉN la ve y CUÁNTO dura:
+  //
+  //   · **no entra en la lista de perfiles del disco**, así que ninguna otra pestaña la ve
+  //     ni puede cambiarse a ella; la lista de esta pestaña la lleva en memoria;
+  //   · **no toca el puntero del perfil activo**: al cerrar, este navegador vuelve a la
+  //     cuenta que tenía, sin haberse enterado;
+  //   · **la reclama la pestaña** (`sessionStorage`, que es por pestaña y sobrevive a
+  //     navegar) y la mantiene viva un latido cada 20 s;
+  //   · **el primer arranque que vea una sin latido la borra**, con sus llaves.
+  //
+  // Lo que eso NO tapa, dicho claro: si el navegador se cierra de golpe y nadie vuelve a
+  // abrir Dotrino en esa máquina, la llave se queda ahí —cifrada y no extraíble— hasta que
+  // alguien lo haga, y ese alguien la borra antes de poder usarla. Salir la borra en el acto.
+  const VOLATILE_STORAGE = 'dotrino.identity.volatile'        // { <pid>: último latido }
+  const VOLATILE_CLAIM = 'dotrino.identity.volatile.claim'    // en sessionKv: la de ESTA pestaña
+  const VOLATILE_STALE_MS = 90_000
+  const VOLATILE_BEAT_MS = 20_000
+  const volatilePids = new Set()
+  let volatileProfiles = []
+  let volatileBeat = null
+  const rawKv = hostKv
+  const keyStore = hostKeyStore
+
+  const loadVolatile = () => { try { return JSON.parse(hostKv.getItem(VOLATILE_STORAGE) || '{}') || {} } catch (_) { return {} } }
+  const saveVolatile = (m) => hostKv.setItem(VOLATILE_STORAGE, JSON.stringify(m))
+  const beatVolatile = (pid) => { const m = loadVolatile(); m[pid] = Date.now(); saveVolatile(m) }
+  const keepBeating = (pid) => {
+    if (volatileBeat) clearInterval(volatileBeat)
+    beatVolatile(pid)
+    volatileBeat = setInterval(() => beatVolatile(pid), VOLATILE_BEAT_MS)
+    // En el navegador, que el latido no impida cerrar nada.
+    try { volatileBeat.unref?.() } catch (_) {}
+  }
+
   // ----- multi-perfil: kv SCOPEADO por el perfil activo -----
   // Todas las claves `dotrino.identity.*` (keypair, me, nonces, delegations, vault.*) se
   // namespacean transparentemente bajo `dotrino.identity.p.<currentPid>.*`. Las dos claves
@@ -210,8 +256,16 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     setItem: (k, v) => rawKv.setItem(_scoped(k), v),
     removeItem: (k) => rawKv.removeItem(_scoped(k))
   }
-  const loadProfiles = () => { try { return JSON.parse(rawKv.getItem(PROFILES_STORAGE) || '[]') || [] } catch { return [] } }
-  const saveProfiles = (list) => rawKv.setItem(PROFILES_STORAGE, JSON.stringify(list))
+  const loadProfiles = () => {
+    let list = []
+    try { list = JSON.parse(hostKv.getItem(PROFILES_STORAGE) || '[]') || [] } catch { list = [] }
+    return volatileProfiles.length ? [...list, ...volatileProfiles] : list
+  }
+  /** Lo volátil se queda en memoria; al disco va solo el resto. */
+  const saveProfiles = (list) => {
+    if (volatilePids.size) volatileProfiles = list.filter((p) => volatilePids.has(p.id))
+    hostKv.setItem(PROFILES_STORAGE, JSON.stringify(list.filter((p) => !volatilePids.has(p.id))))
+  }
 
   // ----- la MARCA de «este perfil nació para adoptar la cuenta de una bóveda» -----
   // Unirse a otra cuenta borra la que este perfil tenía, así que no puede pasar por
@@ -489,8 +543,11 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
    */
   async function openProfileInMemory (pid) {
     currentPid = pid
-    rawKv.setItem(CURRENT_STORAGE, pid)
-    await peers.setProfile?.(pid)
+    // Una cuenta volátil no deja rastro: si escribiera aquí, al cerrar la pestaña el
+    // puntero señalaría a una cuenta que ya no existe y las demás pestañas verían cambiar
+    // la suya sin haber tocado nada.
+    if (!volatilePids.has(pid)) rawKv.setItem(CURRENT_STORAGE, pid)
+    await peers.setProfile?.(pid, { volatile: volatilePids.has(pid) })
     await initPeerStorage()
     keypair = await loadOrCreateKeypair(); publickeyJwkStr = JSON.stringify(keypair.publicJwk)
     encKeypair = await loadOrCreateEncKeypair(); encPublickeyJwkStr = JSON.stringify(encKeypair.publicJwk)
@@ -636,7 +693,11 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   async function purgeProfile (id) {
     const list = loadProfiles().filter((p) => p.id !== id)
     saveProfiles(list)
-    for (const s of ['keypair', 'enc-keypair', 'me', 'nonces', 'delegations', 'revocations', 'vault.device', 'vault.cert', 'acta', 'renounced']) {
+    // TODO lo que escribe una cuenta. Faltaban tres —el historial de actas, lo que le
+    // concediste a cada aplicación y la marca de haber entrado con contraseña—, y en una
+    // cuenta de paso eso no es basura: es rastro en un equipo que no es tuyo.
+    for (const s of ['keypair', 'enc-keypair', 'me', 'nonces', 'delegations', 'revocations',
+      'vault.device', 'vault.cert', 'acta', 'acta.history', 'renounced', 'grants', 'login', 'pendingJoin']) {
       rawKv.removeItem(`dotrino.identity.p.${id}.${s}`)
     }
     // …y sus CryptoKeys no extractables del keyStore (IndexedDB).
@@ -935,6 +996,152 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     return { gen, sinLlave }
   }
 
+  // ----- ENTRAR CON USUARIO Y CONTRASEÑA (`temporary-access.md` §3.4) -----
+  //
+  // Lo que llega de `@dotrino/vault/login-client` es un APARATO entero: sus dos llaves
+  // privadas, el papel que firmó la bóveda y el acta. Aquí se le da sitio en este navegador
+  // como una cuenta más, y desde ese momento este navegador ES ese aparato: firma con su
+  // llave y lo que puede lo dice el acta, igual que una máquina enrolada.
+  //
+  // No se parece a `createProfile` en lo importante: ahí nace una llave nueva, aquí se
+  // ADOPTA una que ya existe y ya está en el acta. Por eso las llaves se escriben ANTES de
+  // abrir la cuenta — si se abriera primero, `loadOrCreateKeypair` estrenaría una llave que
+  // esa cuenta no reconoce y el aparato quedaría fuera de su propio perfil.
+
+  /** Lo que quedó anotado de un inicio de sesión con contraseña, para cerrarlo o enseñarlo. */
+  const loginMetaOf = (pid) => {
+    try {
+      const raw = pid === currentPid
+        ? kv.getItem(LOGIN_STORAGE)
+        : rawKv.getItem(`dotrino.identity.p.${pid}.login`)
+      return raw ? JSON.parse(raw) : null
+    } catch (_) { return null }
+  }
+
+  const deviceIdDe = async (pub) => (await pubkeyIdOf(pub)).slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2')
+
+  /**
+   * @param {object} entrada  lo que devuelve `loginWithPassword` del pilar
+   * @param {boolean} remember  `false` = cuenta VOLÁTIL (se va con la pestaña)
+   */
+  async function adoptLogin (entrada, { remember = false, proxy = null } = {}) {
+    // LO MÍNIMO QUE ESTA CASA TIENE QUE COMPROBAR ANTES DE ADOPTAR NADA. Quien entró ya
+    // verificó la conversación entera (OPAQUE, la dirección, el papel); esto es otra cosa y
+    // es suya: que la llave que se va a instalar SEA de esta cuenta. Sin ello, el navegador
+    // se quedaría con una identidad que ningún acta reconoce — y sin forma de notarlo.
+    const v = await Acta.verifyActa({ acta: entrada?.acta })
+    if (!v.ok) throw Object.assign(new Error('the account record does not verify: ' + v.reason), { code: 'bad-acta' })
+    if (!(entrada.acta.members || []).some((m) => m?.pub === entrada.publickey)) {
+      throw Object.assign(new Error('that key is not a member of the account record'), { code: 'not-a-member' })
+    }
+
+    const pid = 'p' + crypto.randomUUID().slice(0, 8)
+    const veniaDe = currentPid
+    if (!remember) {
+      volatilePids.add(pid)
+      try { sessionKv?.setItem(VOLATILE_CLAIM, pid) } catch (_) {}
+      keepBeating(pid)   // mientras esta pestaña viva, nadie la barre
+    }
+    currentPid = pid     // desde aquí, `kv` escribe en el namespace de la cuenta nueva
+
+    try {
+      // Las públicas se toman TAL CUAL las escribe el acta: es la cadena exacta con la que
+      // esa llave es miembro, y una que se re-serialice distinta deja de coincidir.
+      //
+      // `key_ops` se quita: dice para qué la generó QUIEN la creó (la llave de cifrado nace
+      // con `deriveBits` a secas), y aquí hace falta además `deriveKey`. Es lo mismo que ya
+      // se hace al generar una propia — quién puede hacer qué con esta llave lo decide esta
+      // casa, no una etiqueta que viajó dentro del paquete.
+      const sinTopes = (jwk) => { const { key_ops: _o, ...resto } = jwk || {}; return resto }
+      await adoptJwkPair('sign', KEY_STORAGE, sinTopes(entrada.keys.sign), JSON.parse(entrada.publickey))
+      if (entrada.keys.enc && entrada.encPublickey) {
+        await adoptJwkPair('enc', ENC_KEY_STORAGE, sinTopes(entrada.keys.enc), JSON.parse(entrada.encPublickey))
+      }
+      saveActa(entrada.acta)
+      kv.setItem(ACTA_HISTORY_STORAGE, '[]')
+      kv.setItem(VAULT_DEVICE_STORAGE, JSON.stringify({ useIdentityKey: true, publickey: entrada.publickey }))
+      kv.setItem(VAULT_CERT_STORAGE, JSON.stringify({
+        cert: entrada.cert, master: entrada.iss, proxy: proxy || DEFAULT_PROXY,
+        deviceId: await deviceIdDe(entrada.publickey), pairedAt: Date.now()
+      }))
+      kv.setItem(LOGIN_STORAGE, JSON.stringify({
+        user: entrada.user, address: entrada.address, code: entrada.code, sid: entrada.sid,
+        vault: entrada.iss, proxy: proxy || DEFAULT_PROXY, volatile: !remember, at: Date.now()
+      }))
+
+      await openProfileInMemory(pid)   // carga las llaves recién adoptadas; no estrena ninguna
+      if (publickeyJwkStr !== entrada.publickey) {
+        throw Object.assign(new Error('the adopted key is not the one the record names'), { code: 'bad-keys' })
+      }
+      me = { publickey: publickeyJwkStr, encryptionPubkey: encPublickeyJwkStr, nickname: entrada.user }
+      saveMe(me)
+      const list = loadProfiles()
+      list.push({ id: pid, name: entrada.user, pubkey: publickeyJwkStr })
+      saveProfiles(list)
+      emitVault({ phase: 'login', address: entrada.address, volatile: !remember })
+      return { id: pid, name: entrada.user, address: entrada.address, user: entrada.user, sid: entrada.sid, volatile: !remember }
+    } catch (e) {
+      // NADA DE MEDIAS CUENTAS: si algo falla, no se queda una identidad a medio adoptar en
+      // este navegador. Se deshace y se vuelve a donde estabas.
+      try { await purgeProfile(pid) } catch (_) {}
+      forgetVolatile(pid)
+      if (veniaDe && loadProfiles().some((x) => x.id === veniaDe)) await openProfileInMemory(veniaDe)
+      throw e
+    }
+  }
+
+  /** Deja de tener por nuestra una cuenta de paso: ni en la lista, ni reclamada, ni latiendo. */
+  function forgetVolatile (pid) {
+    volatilePids.delete(pid)
+    volatileProfiles = volatileProfiles.filter((x) => x.id !== pid)
+    const m = loadVolatile()
+    if (m[pid]) { delete m[pid]; saveVolatile(m) }
+    try { if (sessionKv?.getItem(VOLATILE_CLAIM) === pid) sessionKv.removeItem(VOLATILE_CLAIM) } catch (_) {}
+    if (volatileBeat) { clearInterval(volatileBeat); volatileBeat = null }
+  }
+
+  /** Borra una cuenta de paso —con sus llaves— y vuelve a la que este navegador tenía. */
+  async function dropVolatile (pid) {
+    forgetVolatile(pid)
+    await purgeProfile(pid)
+    const list = loadProfiles()
+    const back = hostKv.getItem(CURRENT_STORAGE)
+    const destino = list.find((x) => x.id === back) || list[0]
+    if (destino) await openProfileInMemory(destino.id)
+    return { ok: true, current: destino?.id || null }
+  }
+
+  /**
+   * SALIR: se le dice a la bóveda que suelte la plaza y se borra la cuenta de aquí.
+   *
+   * Avisar es «mejor esfuerzo» —con la bóveda apagada, salir de este equipo no puede quedarse
+   * colgado esperándola—, pero borrar la cuenta de este navegador no lo es: eso pasa siempre.
+   * 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' }
+    let client = null
+    try {
+      const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
+      const { closeLogin } = await import('@dotrino/vault/login-client')
+      const { vaultChannel } = await import('@dotrino/vault/password-logins')
+      client = new WebSocketProxyClient({ url: meta.proxy || DEFAULT_PROXY, enableWebRTC: false, autoReconnect: false })
+      await client.connect()
+      // El token de la bóveda cambia con cada reconexión suya, así que se vuelve a mirar el
+      // canal en vez de guardarlo: el de hace una hora ya no es de nadie.
+      for (const token of await client.list(vaultChannel(meta.code))) {
+        const r = await closeLogin({
+          transport: client, token, user: meta.user, sid: meta.sid,
+          publickey: publickeyJwkStr, privateKey: keypair?.privateKey
+        })
+        if (r.ok) return r
+      }
+      return { ok: false, reason: 'no-vault' }
+    } catch (e) {
+      return { ok: false, reason: e?.code || 'no-answer' }
+    } finally { try { client?.close() } catch (_) {} }
+  }
+
   /**
    * UNIRSE a la cuenta de la bóveda con la que te acabas de emparejar (camino B de
    * `dotrino-vault/docs/vinculacion-de-cuentas.md`). NO es adoptar una versión nueva de TU
@@ -1538,7 +1745,10 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   // nada que lea datos o firme).
   const LOCK_EXEMPT = new Set([
     'profileLockStatus', 'unlockProfile', 'listProfiles', 'currentProfile',
-    'switchProfile', 'createProfile',
+    // Entrar con usuario y contraseña abre OTRA cuenta: que la de aquí esté bajo llave no
+    // tiene nada que ver, y exigir abrirla primero dejaría fuera a quien viene a entrar en
+    // la suya desde un equipo prestado.
+    'switchProfile', 'createProfile', 'loginWithPassword',
     'profileActa', 'profileMembers', 'myMembership', 'isMaster', 'sealerChain'
   ])
 
@@ -2029,7 +2239,14 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
           vault = !!v?.cert
           approve = vault && (v.cert.scope || []).includes('vault:approve')
         } catch (_) {}
-        return { id: p.id, name: p.name || '', pubkey: p.pubkey || null, avatar, current: p.id === currentPid, pendingJoin: !!p.pendingJoin, vault, approve }
+        // Un inicio de sesión con contraseña se enseña como lo que es: el menú del botón de
+        // perfil pone su «Salir» al lado, que es lo único que lo cierra desde aquí.
+        const login = loginMetaOf(p.id)
+        return {
+          id: p.id, name: p.name || '', pubkey: p.pubkey || null, avatar, current: p.id === currentPid,
+          pendingJoin: !!p.pendingJoin, vault, approve,
+          ...(login ? { login: { user: login.user, address: login.address, volatile: !!login.volatile } } : {})
+        }
       })
     },
     async currentProfile () {
@@ -2060,6 +2277,14 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     },
     async switchProfile ({ id } = {}) {
       if (!loadProfiles().find((p) => p.id === id)) throw new Error('profile does not exist')
+      // Una cuenta volátil no puede ser «la activa» de este navegador: vive en la memoria de
+      // esta pestaña y no sobreviviría a la recarga que viene justo después.
+      if (volatilePids.has(id)) {
+        throw Object.assign(new Error('that account only lives in this tab'), { code: 'volatile-profile' })
+      }
+      // Y cambiarse DESDE una volátil es dejarla: se suelta la plaza en la bóveda en vez de
+      // dejar un inicio de sesión abierto sin nadie dentro.
+      if (volatilePids.has(currentPid)) { try { await handlers.logoutLogin({}) } catch (_) {} }
       rawKv.setItem(CURRENT_STORAGE, id) // la app recarga la página → re-init con el nuevo perfil
       return { id }
     },
@@ -2080,6 +2305,53 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       return purgeProfile(id)
     },
 
+    // ----- ENTRAR CON USUARIO Y CONTRASEÑA -----
+
+    /**
+     * ENTRAR en un aparato de tu cuenta desde un navegador que no te conoce, con
+     * `nombre@AB12-CD34-EF56` y la contraseña. Al volver, ESTE navegador es ese aparato y la
+     * app tiene que RECARGAR, como con cualquier cambio de cuenta.
+     *
+     * `remember: false` (lo normal en un equipo prestado) deja la cuenta en MEMORIA: se va
+     * al cerrar o recargar esta pestaña, y el disco de esa máquina queda como estaba. Con
+     * `true` se guarda como cualquier otra cuenta de este navegador —la llave como
+     * `CryptoKey` no extraíble, nunca en claro— hasta que salgas.
+     *
+     * La contraseña NO viaja: lo que viaja son los mensajes de OPAQUE, que no la llevan ni
+     * dejan adivinarla (`@dotrino/vault/login-client`).
+     */
+    async loginWithPassword ({ address, password, remember = false, label = '', proxyUrl = null } = {}) {
+      const url = proxyUrl || DEFAULT_PROXY
+      const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
+      const { loginWithPassword: entrar } = await import('@dotrino/vault/login-client')
+      const client = new WebSocketProxyClient({ url, enableWebRTC: false, autoReconnect: false })
+      await client.connect()
+      let entrada
+      try {
+        entrada = await entrar({ transport: client, address, password, label })
+      } finally { try { client.close() } catch (_) {} }
+      return adoptLogin(entrada, { remember, proxy: url })
+    },
+
+    /**
+     * SALIR del inicio de sesión con contraseña: se le dice a la bóveda que suelte la plaza
+     * y la cuenta desaparece de este navegador. Sin `id`, el activo.
+     */
+    async logoutLogin ({ id = null } = {}) {
+      const pid = id || currentPid
+      const meta = loginMetaOf(pid)
+      if (!meta) throw Object.assign(new Error('that account was not entered with a password'), { code: 'not-a-login' })
+      if (pid !== currentPid) throw Object.assign(new Error('switch to that account before leaving it'), { code: 'not-current' })
+      const avisado = await closeLoginOn(meta)
+      if (volatilePids.has(pid)) {
+        const r = await dropVolatile(pid)   // borra la cuenta entera, llaves incluidas
+        return { ok: true, told: avisado.ok, current: r.current }
+      }
+      const r = await purgeProfile(pid)
+      if (r.current && r.current !== pid) await openProfileInMemory(r.current)
+      return { ok: true, told: avisado.ok, current: r.current }
+    },
+
     // ----- ACTA DE PERFIL -----
     // Quién es de este perfil y qué puede hacer cada uno. Solo el master sella; los demás
     // adoptan. Ver `dotrino-vault/docs/acta-de-perfil.md`.
@@ -3009,7 +3281,38 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       rawKv.setItem(CURRENT_STORAGE, currentPid)
     }
   }
-  await peers.setProfile?.(currentPid)
+  // ----- CUENTAS DE PASO: barrer las abandonadas y recuperar la de ESTA pestaña -----
+  //
+  // Va después de elegir el perfil activo y antes de abrir ninguna llave: si esta pestaña
+  // reclama una, es ESA la que se abre, y las que nadie mantiene vivas se van antes de que
+  // nada las pueda usar.
+  {
+    const vivas = loadVolatile()
+    const reclamada = (() => { try { return sessionKv?.getItem(VOLATILE_CLAIM) || null } catch (_) { return null } })()
+    const ahora = Date.now()
+    let cambio = false
+    for (const [pid, visto] of Object.entries(vivas)) {
+      if (pid === reclamada || (ahora - visto) < VOLATILE_STALE_MS) continue
+      try { await purgeProfile(pid) }
+      catch (e) { console.warn('[identity] could not sweep an abandoned walk-in account:', e?.message || e) }
+      delete vivas[pid]; cambio = true
+    }
+    if (cambio) saveVolatile(vivas)
+
+    const sigueAhi = reclamada && vivas[reclamada] && rawKv.getItem(`dotrino.identity.p.${reclamada}.login`)
+    if (sigueAhi) {
+      volatilePids.add(reclamada)
+      let suyo = null
+      try { suyo = JSON.parse(rawKv.getItem(`dotrino.identity.p.${reclamada}.me`) || 'null') } catch (_) {}
+      volatileProfiles = [{ id: reclamada, name: suyo?.nickname || '', pubkey: suyo?.publickey || null }]
+      currentPid = reclamada
+      keepBeating(reclamada)
+    } else if (reclamada) {
+      try { sessionKv?.removeItem(VOLATILE_CLAIM) } catch (_) {}
+    }
+  }
+
+  await peers.setProfile?.(currentPid, { volatile: volatilePids.has(currentPid) })
 
   keypair = await loadOrCreateKeypair()
   publickeyJwkStr = JSON.stringify(keypair.publicJwk)
@@ -3097,6 +3400,13 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       return { locked: !keypair?.privateKey }
     },
     sync,
+    /**
+     * Adoptar un aparato que acaba de entrar con usuario y contraseña. Lo normal es llamar
+     * al handler `loginWithPassword`, que primero HABLA con la bóveda; esto es solo la
+     * segunda mitad —instalar lo que salió de ahí—, y vive en el objeto del núcleo (no en
+     * `handlers`) porque ninguna aplicación tiene por qué poder instalar una identidad.
+     */
+    adoptLogin,
     onSyncStatus (fn) { if (sync) sync.onStatus(fn) },
     onVaultEvent (fn) { vaultListeners.add(fn); return () => vaultListeners.delete(fn) }
   }

package/vault/index.html

@@ -26,6 +26,7 @@
     "@dotrino/proxy-client": "./vendor/proxy-client/index.js",
     "@dotrino/vault": "./vendor/vault/index.js",
     "@dotrino/vault/password-logins": "./vendor/vault/passwordLogins.js",
+    "@dotrino/vault/login-client": "./vendor/vault/loginClient.js",
     "@dotrino/opaque": "./vendor/opaque/src/index.js",
     "@dotrino/identity/capabilities": "./capabilities.js",
     "@dotrino/identity/acta": "./acta.js",

package/vault/peerStore.js

@@ -32,12 +32,23 @@ let _idb = null
 let _writeChain = Promise.resolve()
 let _markDirty = null
 let _pid = null
+/**
+ * La cuenta abierta es VOLÁTIL (se entró con usuario y contraseña sin «Recordar»): sus
+ * contactos viven en memoria y no se escriben en ninguna parte. Dejar el libro de contactos
+ * de alguien en el disco de un equipo prestado sería justo lo que esa forma de entrar
+ * promete no hacer.
+ */
+let _volatile = false
 
 /** Registra el callback que marca el estado como "sucio" para el sync. */
 export function onDirty (fn) { _markDirty = fn }
 
 /** Multi-perfil: namespacea el peer book por perfil. El core lo llama antes de initPeerStorage. */
-export function setProfile (pid) { _pid = pid || null }
+export function setProfile (pid, { volatile: esVolatil = false } = {}) {
+  _pid = pid || null
+  _volatile = !!esVolatil
+  if (_volatile) _peers = {}   // se entra sin contactos y se sale sin dejarlos
+}
 function peersKey () { return _pid ? `peers.${_pid}.v1` : IDB_PEERS_KEY }
 
 /** Migración: copia el peer book VIEJO (pre-multi-perfil, sin namespace) al perfil `pid`. */
@@ -91,6 +102,7 @@ function readLocalPeers () {
 export async function initPeerStorage () {
   try { if (typeof navigator !== 'undefined' && navigator.storage?.persist) await navigator.storage.persist() }
   catch (_) { /* best-effort */ }
+  if (_volatile) { _peers = {}; return _peers }
   try {
     _idb = await openIdb()
     const stored = await idbGet(_idb, peersKey()) // peer book DEL perfil activo (namespaceado)
@@ -106,6 +118,7 @@ export async function initPeerStorage () {
 }
 
 function persistPeers () {
+  if (_volatile) return _writeChain   // cuenta volátil: en memoria y en ningún disco
   const key = peersKey()
   if (_fallback || !_idb) {
     try { localStorage.setItem(key, JSON.stringify(_peers)) }
@@ -147,5 +160,5 @@ export function upsertPeer (publickey, patch) {
 // Sólo para tests: resetea el estado del módulo (y cierra la conexión IDB).
 export function _resetForTest () {
   try { if (_idb && _idb.close) _idb.close() } catch (_) {}
-  _peers = {}; _fallback = false; _idb = null; _writeChain = Promise.resolve(); _markDirty = null; _pid = null
+  _peers = {}; _fallback = false; _idb = null; _writeChain = Promise.resolve(); _markDirty = null; _pid = null; _volatile = false
 }

package/vault/vendor/proxy-client/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/proxy-client@0.22.0 (dotrino-proxy-client/src/{index,client,signature,canonical,sealing,encpub,webrtc}.js).
+Copia vendorizada de @dotrino/proxy-client@0.23.1 (dotrino-proxy-client/src/{index,client,signature,canonical,sealing,encpub,webrtc}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 sealing.js resuelve @dotrino/identity/content de forma PEREZOSA (= ../../content.js
 por el import map): solo se carga si de verdad se sella algo.

package/vault/vendor/proxy-client/client.js

@@ -1124,7 +1124,23 @@ export class WebSocketProxyClient {
       // tienen autoReconnect=false (puesto por close()), así que este guard no
       // filtra desconexiones pedidas por la app. Sin esto, un restart del proxy
       // deja a clientes de larga duración (bots, apps abiertas) zombis para siempre.
-      if (wasConnected && this.autoReconnect) {
+      //
+      // Y TAMBIÉN CUANDO EL INTENTO NI LLEGÓ A ABRIRSE (`reintentando`). Ese era el
+      // agujero, y costó 36 horas de bóveda muda el 2026-09-16: un socket que falla al
+      // conectar cierra con `_connected` en false, así que con solo `wasConnected` no se
+      // programaba el siguiente intento. O sea que el cliente hacía UN reintento —el de
+      // la caída— y si ese caía en un momento en que la red seguía mal, se rendía para
+      // siempre, en silencio y con `maxReconnectAttempts` en 100000. Justo el caso normal:
+      // cuando se cae la red, el primer reintento a los pocos segundos tampoco encuentra a
+      // nadie.
+      //
+      // Los eventos que se veían: `disconnect reconnecting#1 disconnect` y nada más.
+      //
+      // `_reconnectAttempts` vuelve a 0 al abrir, así que esto NO convierte un `connect()`
+      // inicial fallido en un bucle de fondo: ahí vale 0 y la promesa se rechaza como
+      // siempre.
+      const reintentando = this._reconnectAttempts > 0
+      if ((wasConnected || reintentando) && this.autoReconnect) {
         this._scheduleReconnect()
       }
     })
@@ -1178,6 +1194,12 @@ export class WebSocketProxyClient {
     this._reconnectAttempts++
     this._emit('reconnecting', this._reconnectAttempts, this.maxReconnectAttempts)
     this._reconnectTimer = setTimeout(() => this._open(), this.reconnectDelay)
+    // UN REINTENTO PENDIENTE NO MANTIENE VIVO EL PROCESO. Desde que se reintenta de verdad
+    // —antes la cadena se cortaba sola al primer fallo—, este temporizador basta para que un
+    // programa de Node que se olvidó de cerrar el cliente no termine nunca. Lo de siempre:
+    // esto es mantenimiento de fondo, y quién se va es decisión de la app. En el navegador
+    // `unref` no existe y no hace falta.
+    this._reconnectTimer.unref?.()
   }
 
   _handleFrame (raw) {

package/vault/vendor/vault/VERSION.txt

@@ -1,7 +1,9 @@
-Copia vendorizada de @dotrino/vault@0.66.0 (dotrino-vault/lib/src/{index,enroll,protocol,passwordLogins,b64}.js).
+Copia vendorizada de @dotrino/vault@0.67.0 (dotrino-vault/lib/src/{index,enroll,protocol,passwordLogins,loginClient,b64}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 index.js importa ./enroll.js y ./protocol.js (relativos, van en esta misma copia),
 @dotrino/identity/{capabilities,acta} (= ../../{capabilities,acta}.js) y
 @dotrino/proxy-client (= ../proxy-client/), todos por el import map de index.html.
 passwordLogins.js es el aparato que se abre con usuario y contraseña: lo carga
 vault.js SOLO cuando esta pestaña es bóveda, porque arrastra el OPAQUE en WASM.
+loginClient.js es la otra mitad —el que ENTRA con esa contraseña— y lo carga core.js
+solo al entrar, por lo mismo: arrastra el OPAQUE.

package/vault/vendor/vault/index.js

@@ -31,6 +31,10 @@ import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS, FRESH_WINDOW_MS } from './
 // Las constantes del protocolo salen del MISMO módulo que usa el daemon: si la lista
 // local se queda corta, el dispositivo deja de handle mensajes sin que nadie lo note.
 import { MSG, SCOPE } from './protocol.js'
+// El canal donde se anuncia esta cuenta y la huella que lo nombra: la MISMA pieza que usa
+// el daemon y que lee quien entra con usuario y contraseña. Un canal que se escriba distinto
+// en cada bóveda no es el mismo canal.
+import { vaultChannel, accountFingerprint } from './passwordLogins.js'
 
 const SIGN_SCOPE = SCOPE.SIGN
 const RENEW_TTL_MS = DEVICE_TTL_MS             // la renovación extiende la misma ventana (30 días)
@@ -100,10 +104,35 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
   })()
 
   const selfCert = await getSelfCert()
+
+  /**
+   * ANUNCIARSE EN EL CANAL DE LA CUENTA, igual que el daemon del PC (`src/transport.js`).
+   *
+   * Sin esto, una bóveda-pestaña no existe para quien entra con usuario y contraseña: ese
+   * equipo no tiene ninguna llave, solo el código de la dirección, y el canal es lo único
+   * que puede convertirlo en «con quién hablo». Faltaba, así que quien tenía su bóveda solo
+   * en una pestaña no era encontrable por dirección — y la pestaña sí sabe atender el
+   * inicio de sesión desde que existe `logins`.
+   *
+   * Va DESPUÉS de identificarse y en cada token nuevo, porque el canal guarda el token y el
+   * token cambia con cada reconexión. Y no bloquea el arranque: una bóveda que no consigue
+   * anunciarse sigue sirviendo a sus aparatos, que es casi todo lo que hace.
+   */
+  const announce = async () => {
+    if (!logins || !client.token || typeof client.publish !== 'function') return
+    try {
+      const canal = vaultChannel(await accountFingerprint(identity))
+      await client.publish(canal)
+    } catch (e) {
+      console.warn('[device-vault] could not announce this account on the proxy:', e?.message || e)
+    }
+  }
+
   const identify = async () => {
     if (!client.token) return
     // El sobre lo arma el pilar (`identifyAs`), que le pone el destinatario.
     await client.identifyAs({ publickey: iss, sign: (d) => identity.signData(d), cert: selfCert })
+    await announce()
   }
   await identify()
   client.on('token', () => identify().catch(() => {}))

package/vault/vendor/vault/loginClient.js

@@ -0,0 +1,216 @@
+/**
+ * ENTRAR CON USUARIO Y CONTRASEÑA — EL LADO DEL QUE ENTRA.
+ *
+ * La otra mitad de `passwordLogins.js`: allí está la bóveda que atiende, aquí el equipo
+ * prestado que llega sin ninguna llave y solo con una dirección escrita a mano. Diseño en
+ * `dotrino-passmanager/docs/temporary-access.md` §3.2.
+ *
+ *     nombre@AB12-CD34-EF56 + contraseña
+ *     lista el canal del código         ──►  las bóvedas de esa cuenta que estén encendidas
+ *     OPAQUE (inicio)                  ◄──►  comprueba sin ver la contraseña
+ *     abre el paquete de llaves        ◄──   { sid, blob, cert, iss, acta }
+ *     desde aquí es un aparato del acta
+ *
+ * **Vive en el pilar y no en la página** porque lo van a hacer tres sitios distintos —la
+ * pantalla de `profile.dotrino.com`, la extensión del gestor y cualquier app que ofrezca
+ * entrar— y una dirección que se lea distinto, o una comprobación que uno se salte, no es
+ * la misma puerta. Aquí no se abre ninguna conexión: el transporte se INYECTA, como en
+ * `@dotrino/identity/session-flow`.
+ *
+ * QUÉ SE COMPRUEBA, Y EN QUÉ ORDEN (importa):
+ *
+ *   1. **OPAQUE autentica a las DOS partes.** Una bóveda falsa no tiene tu registro, así
+ *      que no puede armar una respuesta que cuadre: `loginFinish` revienta en ESTE lado y
+ *      la contraseña no se le ha dicho a nadie. Por eso mandarle el primer mensaje a un
+ *      desconocido del canal no cuenta nada — es el único orden posible, porque el canal
+ *      solo da tokens y un token no dice de quién es.
+ *   2. **El acta tiene que ser de la cuenta que escribiste**: `pubkeyId(acta.profileId)`
+ *      empieza por el código de la dirección. Esto es lo que ata la respuesta a TU cuenta
+ *      y no a otra bóveda que también sepa contestar.
+ *   3. **El papel y el acta se sostienen entre sí** (`checkVaultReply`).
+ *   4. **La llave que acaba de salir del paquete es la del papel**: se firma un reto y se
+ *      verifica contra `cert.sub`. Sin esto, una bóveda podría devolver el paquete de otro.
+ *
+ * Si algo de eso falla, se PARA con un `code` propio. No hay repliegue: entrar «a medias»
+ * en una cuenta es peor que no entrar.
+ */
+import { client as opaque } from '@dotrino/opaque'
+import { pubkeyId, verifyDeviceSig, signWithDevice } from '@dotrino/identity/capabilities'
+import { checkVaultReply } from '@dotrino/identity/acta'
+import { MSG } from './protocol.js'
+import { accountCode, parseLoginAddress, vaultChannel, openDeviceKeys } from './passwordLogins.js'
+
+const err = (code, message, extra = {}) => Object.assign(new Error(message), { code, ...extra })
+
+/** Cuánto se espera a que una bóveda conteste antes de probar con la siguiente. */
+export const REPLY_TIMEOUT_MS = 15_000
+
+/**
+ * Escucha UNA respuesta de un token concreto. El `off` se suelta siempre —también al
+ * agotarse la espera—: un oyente que se queda pegado hace que el segundo intento vea la
+ * respuesta del primero.
+ */
+function waitFor (transport, from, match, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let listo = false
+    const fin = (fn, arg) => { if (!listo) { listo = true; clearTimeout(reloj); quitar(); fn(arg) } }
+    const reloj = setTimeout(() => fin(reject, err('no-answer', 'the vault did not answer in time')), timeoutMs)
+    const oyente = (quien, payload) => {
+      if (from && quien !== from) return
+      const p = typeof payload === 'string' ? parseJson(payload) : payload
+      if (p && match(p)) fin(resolve, p)
+    }
+    const off = transport.on('message', oyente)
+    const quitar = () => {
+      if (typeof off === 'function') return off()
+      transport.off?.('message', oyente)
+    }
+  })
+}
+
+const parseJson = (s) => { try { return JSON.parse(s) } catch (_) { return null } }
+
+/**
+ * ENTRAR. Devuelve el aparato entero —sus llaves privadas, su papel y el acta— para que
+ * quien llama decida dónde vive eso: en el navegador lo adopta `@dotrino/identity` como una
+ * cuenta más; en la extensión, su propio almacén.
+ *
+ * @param {object} opts
+ * @param {object} opts.transport  cliente de `@dotrino/proxy-client` ya conectado. NO hace
+ *   falta identificarse: quien entra todavía no tiene con qué.
+ * @param {string} opts.address    `nombre@AB12-CD34-EF56`, tal como lo teclea una persona.
+ * @param {string} opts.password
+ * @param {string} [opts.label]    de dónde se entra («el cyber de la esquina»): es lo que
+ *   el dueño va a leer en su consola para decidir si cerrarlo.
+ * @returns {Promise<{user:string,address:string,code:string,sid:string,cert:object,
+ *   iss:string,acta:object,vaultToken:string,publickey:string,encPublickey:(string|null),
+ *   keys:{sign:object,enc:(object|null)}}>}
+ */
+export async function loginWithPassword ({ transport, address, password, label = '', timeoutMs = REPLY_TIMEOUT_MS } = {}) {
+  if (!transport || typeof transport.on !== 'function' || typeof transport.send !== 'function') {
+    throw err('no-transport', 'loginWithPassword: a connected transport is required')
+  }
+  if (typeof password !== 'string' || !password) throw err('no-password', 'loginWithPassword: password required')
+  const { user, code, address: dir } = parseLoginAddress(address)
+
+  const tokens = await transport.list(vaultChannel(code))
+  if (!tokens.length) {
+    throw err('no-vault', 'no vault is answering for that address right now: turn yours on, or check the address')
+  }
+
+  // De una en una, y parando en cuanto la contraseña resulte estar mal: cada intento GASTA
+  // uno del freno en la bóveda que lo atiende (`passwordLogins.js`), así que repartir el
+  // mismo error entre las réplicas solo sirve para bloquearse en todas a la vez.
+  let ultimo = null
+  for (const token of tokens) {
+    try {
+      return await unIntento({ transport, token, user, code, dir, password, label, timeoutMs })
+    } catch (e) {
+      // Se para: son cosas del que entra, y probar con otra bóveda no las arregla.
+      if (e?.code === 'login-failed' || e?.code === 'too-many-tries' || e?.code === 'wrong-account' ||
+          e?.code === 'bad-blob' || e?.code === 'bad-keys' || e?.code === 'bad-reply') throw e
+      ultimo = e   // «esa no atiende inicios de sesión», «no contestó»: quizá la siguiente sí
+    }
+  }
+  throw ultimo || err('no-vault', 'none of the vaults on that address could let you in')
+}
+
+async function unIntento ({ transport, token, user, code, dir, password, label, timeoutMs }) {
+  const start = opaque.loginStart({ password })
+  transport.send(token, { type: MSG.LOGIN_START, user, request: start.request })
+  const r1 = await waitFor(transport, token, (p) => p.type === MSG.LOGIN_RESPONSE || p.type === MSG.ERROR, timeoutMs)
+  if (r1.type === MSG.ERROR) throw deVuelta(r1)
+
+  let fin
+  try {
+    fin = opaque.loginFinish({ state: start.state, response: r1.response, password })
+  } catch (_) {
+    // OPAQUE comprueba a las dos partes: aquí se sabe que el otro lado NO conoce el
+    // registro de este usuario. Contraseña equivocada, usuario que no existe o una bóveda
+    // que no es la tuya — y son el mismo error a propósito, porque distinguirlos diría
+    // desde fuera qué usuarios hay.
+    throw err('login-failed', 'wrong address or password')
+  }
+
+  transport.send(token, { type: MSG.LOGIN_FINISH, lid: r1.lid, finalization: fin.finalization, label })
+  const ok = await waitFor(transport, token, (p) => p.type === MSG.LOGIN_OK || p.type === MSG.ERROR, timeoutMs)
+  if (ok.type === MSG.ERROR) throw deVuelta(ok)
+
+  const acta = ok.acta
+  const cert = ok.cert
+  if (!acta || !cert?.sub) throw err('bad-reply', 'the vault let you in without saying which account this is')
+
+  // 2. ¿ES LA CUENTA QUE ESCRIBISTE? Es la única comprobación que ata todo esto a lo que la
+  //    persona tecleó: el canal no prueba nada y el acta viene de quien contesta.
+  if (accountCode((await pubkeyId(acta.profileId)).slice(0, 16)) !== code) {
+    throw err('wrong-account', 'that vault serves a different account than the address says')
+  }
+  // 3. El papel lo firmó esa bóveda, esa bóveda puede sellar esta acta, y el papel vale
+  //    según ella. Una sola llamada, la misma que usa el enrolamiento.
+  const v = await checkVaultReply({ acta, cert, vault: ok.iss, sub: cert.sub })
+  if (!v.ok) throw err('bad-reply', 'the vault reply does not hold together: ' + v.reason)
+
+  const keys = await openDeviceKeys(fin.exportKey, ok.blob)   // `bad-blob` si no es el paquete
+  if (!keys?.sign) throw err('bad-blob', 'the key package does not carry a signing key')
+
+  // 4. La llave que salió del paquete tiene que SER la del papel. Se prueba firmando.
+  const reto = { op: 'login.proof', sub: cert.sub, sid: ok.sid, ts: Date.now() }
+  const { signature } = await signWithDevice({ privateJwk: keys.sign, data: reto })
+  if (!(await verifyDeviceSig({ publickey: cert.sub, data: reto, signature }))) {
+    throw err('bad-keys', 'the keys in the package are not the ones this certificate is for')
+  }
+
+  const member = (acta.members || []).find((m) => m?.pub === cert.sub)
+  if (!member) throw err('bad-reply', 'that certificate names a key the account record does not list')
+
+  return {
+    user,
+    address: dir,
+    code,
+    sid: ok.sid,
+    cert,
+    iss: ok.iss,
+    acta,
+    vaultToken: token,
+    publickey: cert.sub,
+    // La pública de CIFRADO la dice el acta, no el paquete: es lo que los demás miran para
+    // envolverle un secreto a este aparato, y tiene que ser la misma que ellos ven.
+    encPublickey: member.encPub || null,
+    caps: [...(member.caps || [])],
+    keys: { sign: keys.sign, enc: keys.enc || null }
+  }
+}
+
+/** Un error de la bóveda con su `code` intacto: `too-many-tries` se arregla esperando. */
+function deVuelta (p) {
+  const code = p.code || 'login-error'
+  const e = err(code, p.error || 'the vault refused the login')
+  if (typeof p.waitMs === 'number') e.waitMs = p.waitMs
+  return e
+}
+
+/**
+ * SALIR. Va firmado con la llave que acabas de abrir —cerrar el inicio de sesión de otro
+ * sería echarlo de su cuenta— y es lo que suelta la plaza en la bóveda; lo que se borre en
+ * este navegador es cosa de quien llama.
+ *
+ * Es «mejor esfuerzo» a propósito: si la bóveda está apagada, salir de este equipo no puede
+ * quedarse bloqueado esperándola. La sesión sigue abierta allí hasta que se cierre desde la
+ * consola, y eso ya está dicho en el diseño (§3.2).
+ */
+export async function closeLogin ({ transport, token, user, sid, publickey, privateJwk, privateKey, timeoutMs = REPLY_TIMEOUT_MS } = {}) {
+  if (!transport || typeof transport.send !== 'function') throw err('no-transport', 'closeLogin: transport required')
+  if (!token || !user || !sid || !publickey) throw err('bad-input', 'closeLogin: token, user, sid and publickey are required')
+  const data = { op: 'login.close', publickey, user, sid, ts: Date.now() }
+  const { signature } = await signWithDevice({ privateJwk, privateKey, publickey, data })
+  transport.send(token, { type: MSG.LOGIN_CLOSE, data, signature })
+  try {
+    const r = await waitFor(transport, token, (p) => p.type === MSG.LOGIN_CLOSED || p.type === MSG.ERROR, timeoutMs)
+    if (r.type === MSG.ERROR) return { ok: false, reason: r.code || 'login-error' }
+    return { ok: !!r.ok }
+  } catch (e) {
+    return { ok: false, reason: e?.code || 'no-answer' }
+  }
+}
+
+export default { loginWithPassword, closeLogin, REPLY_TIMEOUT_MS }

package/vault/vendor/vault/passwordLogins.js

@@ -25,6 +25,7 @@
  * final, porque hace falta la identidad que firma.
  */
 import { server as opaque, suiteId } from '@dotrino/opaque'
+import { pubkeyId } from '@dotrino/identity/capabilities'
 import { deviceIdOf, scopeToCaps, scopeToCn } from './enroll.js'
 import { SCOPE } from './protocol.js'
 import { bytesToB64url, b64urlToBytes } from './b64.js'
@@ -53,6 +54,43 @@ export function accountCode (fingerprint) {
 }
 export const loginAddress = (user, fingerprint) => `${user}@${accountCode(fingerprint)}`
 
+/**
+ * LA HUELLA DE LA CUENTA, que es de la CUENTA y no de la bóveda que la atiende.
+ *
+ * Sale del `profileId` del acta —la llave del génesis, la que no cambia nunca—, y por eso
+ * la dirección sobrevive a que la bóveda se mude, se replique o adopte la cuenta de otro
+ * aparato. Derivarla de la llave de la bóveda daba una dirección distinta en cada réplica
+ * y ninguna en la segunda bóveda de un multivault.
+ *
+ * Es la MISMA cuenta para todas las bóvedas de esa cuenta, que es justo lo que hace que el
+ * canal las junte a todas.
+ */
+export async function accountFingerprint (identity) {
+  const pid = (await identity?.profileActa?.().catch(() => null))?.acta?.profileId
+  if (!pid) throw err('no-acta', 'this vault has no account record yet: there is no address to build')
+  return (await pubkeyId(pid)).slice(0, 16)
+}
+
+/**
+ * Lee `nombre@AB12-CD34-EF56`. Es lo que TECLEA una persona en un equipo prestado, así que
+ * se le perdona el formato —mayúsculas, espacios, guiones de más o de menos— pero no el
+ * contenido: el código son 12 dígitos hexadecimales, ni uno más ni uno menos.
+ *
+ * Lo que NO se perdona tiene su razón: un código corto de menos no es «casi» la dirección,
+ * es otra cuenta con la que se colisiona antes, y aceptarlo sería quitarle los bits que lo
+ * atan a tu cuenta (§3.2 de `temporary-access.md`).
+ */
+export function parseLoginAddress (address) {
+  const raw = String(address || '').trim()
+  const at = raw.lastIndexOf('@')
+  if (at <= 0) throw err('bad-address', 'an address looks like name@AB12-CD34-EF56')
+  const user = raw.slice(0, at).trim().toLowerCase()
+  const hex = raw.slice(at + 1).replace(/[^0-9a-fA-F]/g, '').toUpperCase()
+  if (!isValidUser(user)) throw err('bad-user', 'a user name is lowercase letters, digits, dot, dash or underscore (1-32)')
+  if (hex.length !== ACCOUNT_CODE_HEX) throw err('bad-address', `the account code is ${ACCOUNT_CODE_HEX} hex digits: AB12-CD34-EF56`)
+  return { user, code: accountCode(hex), address: `${user}@${accountCode(hex)}` }
+}
+
 /**
  * EL CANAL DONDE SE ANUNCIA CADA BÓVEDA DE ESA CUENTA, réplicas incluidas.
  *