@dotrino/identity 0.118.0 → 0.120.0

package/README.md

@@ -246,6 +246,22 @@ Lo que hace que esto no sea una llave maestra de repuesto:
 Diseño y hacia dónde va (inicio de sesión y federación):
 [`dotrino-vault/docs/inicio-de-sesion.md`](../dotrino-vault/docs/inicio-de-sesion.md).
 
+### Canal de sesión de los agentes remotos (0.120.0+)
+
+```js
+import { makeEphemeral, deriveKey, seal, open } from '@dotrino/identity/channel'
+```
+
+ECDH P-256 efímero → HKDF → AES-256-GCM: las dos puntas acuerdan una llave de sesión y la
+usan para muchos mensajes. Lo usa `@dotrino/remote-agent` (antes vivía allí). Para un sobre
+suelto hacia una llave, `wrapForMember`/`openWrap` de `@dotrino/identity/content`.
+
+### Huella de una llave
+
+`keyLabel(pub)` de `@dotrino/identity/keyid` da `AB12-CD34`, la que se enseña en todo el
+ecosistema. Úsala en vez de recortar `pubkeyId` a mano. Desde 0.120.0 una llave ilegible
+LANZA (antes devolvía `''`); sin llave sigue siendo `''`.
+
 ### Backup / migración
 
 - `id.exportIdentity()` → blob JSON con `privateJwk` (ECDSA), `encPrivateJwk` (ECDH), `me`, `peers`. **Sensible** — el host app es responsable de guardarlo de manera segura.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.118.0",
+  "version": "0.120.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",
@@ -34,6 +34,9 @@
     "./content": {
       "import": "./vault/content.js"
     },
+    "./channel": {
+      "import": "./vault/channel.js"
+    },
     "./assertion": {
       "import": "./vault/assertion.js"
     },

package/src/index.js

@@ -601,6 +601,20 @@ export class Identity {
   /** Cambia la contraseña: hace falta la vieja, y lo que estuviera abierto se cierra. */
   async selfVaultLoginPasswd (opts) { return this._call('selfVaultLoginPasswd', opts || {}, 60000) }
 
+  // ----- el RESPALDO, cuando la bóveda es ESTA pestaña (solo desde la consola) -----
+  //
+  // Bóveda abierta y origen de la consola (`vault.dotrino.com`): cualquier otro recibe
+  // `code: 'not-the-console'`. El archivo vuelve YA CIFRADO con la contraseña dada.
+
+  /** Los cajones que hay: `[{ owner, count, device? }]`. */
+  async selfVaultBackupDrawers () { return this._call('selfVaultBackupDrawers', {}, 30000) }
+  /** Exporta todo (`drawers: null`) o esos cajones. Devuelve `{ file, summary }`. */
+  async selfVaultBackupExport (opts) { return this._call('selfVaultBackupExport', opts || {}, 120000) }
+  /** El plan de importar `file` (qué es nuevo, igual o choca). No escribe nada. */
+  async selfVaultBackupPlan (opts) { return this._call('selfVaultBackupPlan', opts || {}, 120000) }
+  /** Importa. Con un choque sin decidir lanza `BACKUP_CONFLICTS` y no escribe nada. */
+  async selfVaultBackupImport (opts) { return this._call('selfVaultBackupImport', opts || {}, 120000) }
+
   /** Cierra un inicio de sesión abierto (sin `sid`, todos los de ese usuario). */
   async selfVaultLoginClose (opts) { return this._call('selfVaultLoginClose', opts || {}) }
 

package/vault/acta.js

@@ -35,7 +35,7 @@
  * Módulo PURO: sin kv, sin red, sin disco. Cripto de `./capabilities.js`.
  */
 import { canonicalStringify } from './core.js'
-import { signWithDevice, verifyDeviceSig, verifyDelegation, pubkeyId } from './capabilities.js'
+import { signWithDevice, verifyDeviceSig, verifyDelegation, keyLabel } from './capabilities.js'
 import { cleanMachine } from './machine.js'
 export { cleanMachine }
 
@@ -368,8 +368,8 @@ export async function verifySealerLinkChain (chain, { expectedProfileId = null }
 
 /** Id legible de un miembro (mismo formato que el deviceId del emparejamiento). */
 export async function memberId (pub) {
-  const id = (await pubkeyId(pub)).slice(0, 8).toUpperCase()
-  return id.slice(0, 4) + '-' + id.slice(4, 8)
+  if (!pub) throw new Error('memberId: missing key')
+  return keyLabel(pub)
 }
 
 /** ¿Esta acta es un traspaso? (la firmó uno y nombra master a otro) */

package/vault/channel.js

@@ -0,0 +1,77 @@
+/**
+ * channel.js — canal cifrado punto a punto entre el dispositivo enlazado y un agente
+ * remoto del ecosistema Dotrino (lo usa `@dotrino/remote-agent`; antes vivía allí). Isomórfico: usa WebCrypto
+ * (`globalThis.crypto.subtle`), disponible tanto en el navegador (PWA) como en
+ * Node ≥ 18.
+ *
+ * NO reimplementa la identidad ni la firma del ecosistema: la AUTORIZACIÓN la da
+ * el vault (cert de dispositivo verificado con `@dotrino/identity/capabilities`
+ * → cadena hasta la maestra). Este módulo solo levanta un secreto de sesión
+ * efímero (ECDH P-256 → HKDF → AES-256-GCM) para que el relay de transporte
+ * (`proxy.dotrino.com`) vea únicamente texto cifrado. La identidad de las dos
+ * puntas ya la garantizan las firmas del vault que envuelven las claves efímeras.
+ *
+ * Distinto de `content.js` a propósito: aquí la llave es de SESIÓN (se acuerda una vez
+ * y cifra muchos mensajes, con HKDF y la pública en raw), allí cada sobre lleva su
+ * efímera. El `info` de HKDF conserva su nombre: es parte del cable, y lo hablan también
+ * los puertos nativos de `dotrino-native`.
+ */
+
+const subtle = () => globalThis.crypto.subtle
+
+const b64 = {
+  enc (buf) {
+    const b = new Uint8Array(buf)
+    let s = ''
+    for (let i = 0; i < b.length; i++) s += String.fromCharCode(b[i])
+    return btoa(s)
+  },
+  dec (str) {
+    const bin = atob(str)
+    const out = new Uint8Array(bin.length)
+    for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i)
+    return out
+  }
+}
+
+/** Genera un par ECDH P-256 efímero. Devuelve la pub en raw (base64) + privada. */
+export async function makeEphemeral () {
+  const kp = await subtle().generateKey({ name: 'ECDH', namedCurve: 'P-256' }, false, ['deriveBits'])
+  const raw = await subtle().exportKey('raw', kp.publicKey)
+  return { privateKey: kp.privateKey, pub: b64.enc(raw) }
+}
+
+/**
+ * Deriva la clave AES-256-GCM de la sesión a partir de la privada propia y la
+ * pub efímera (base64 raw) del otro extremo. `salt` liga la clave a la sesión.
+ */
+export async function deriveKey (privateKey, otherPubB64, salt) {
+  const otherPub = await subtle().importKey(
+    'raw', b64.dec(otherPubB64), { name: 'ECDH', namedCurve: 'P-256' }, false, []
+  )
+  const bits = await subtle().deriveBits({ name: 'ECDH', public: otherPub }, privateKey, 256)
+  const hkdfKey = await subtle().importKey('raw', bits, 'HKDF', false, ['deriveKey'])
+  return subtle().deriveKey(
+    { name: 'HKDF', hash: 'SHA-256', salt: new TextEncoder().encode(salt), info: new TextEncoder().encode('dotrino-remote-agent-e2e') },
+    hkdfKey,
+    { name: 'AES-GCM', length: 256 },
+    false,
+    ['encrypt', 'decrypt']
+  )
+}
+
+/** Cifra un objeto JSON → sobre { iv, ct } (ambos base64). */
+export async function seal (key, obj) {
+  const iv = globalThis.crypto.getRandomValues(new Uint8Array(12))
+  const pt = new TextEncoder().encode(JSON.stringify(obj))
+  const ct = await subtle().encrypt({ name: 'AES-GCM', iv }, key, pt)
+  return { iv: b64.enc(iv), ct: b64.enc(ct) }
+}
+
+/** Descifra un sobre { iv, ct } → objeto JSON. Lanza si el tag GCM no valida. */
+export async function open (key, env) {
+  const pt = await subtle().decrypt({ name: 'AES-GCM', iv: b64.dec(env.iv) }, key, b64.dec(env.ct))
+  return JSON.parse(new TextDecoder().decode(pt))
+}
+
+export { b64 }

package/vault/core.js

@@ -23,7 +23,7 @@ import * as Acta from './acta.js'
 import * as Content from './content.js'
 import { syncPeers, stampOf } from './peerSync.js'
 import { assertionBody, cleanScopes, claimsAllowed, ASSERTION_DEFAULT_TTL_MS, ASSERTION_MAX_TTL_MS } from './assertion.js'
-import { pubkeyId as pubkeyIdOf, signWithDevice } from './capabilities.js'
+import { pubkeyId as pubkeyIdOf, signWithDevice, keyLabel } from './capabilities.js'
 import { enrollDevice as remoteEnroll, requestSign as remoteSign, requestStore as remoteStore, requestDevices as remoteDevices, requestRenew as remoteRenew, requestAdmin as remoteAdmin, requestApproval as remoteApproval, requestRenounce as remoteRenounce, checkMembership as remoteCheck, registerLocalVault } from './remote.js'
 
 export const KEY_STORAGE = 'dotrino.identity.keypair'
@@ -1128,7 +1128,7 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
     } catch (_) { return null }
   }
 
-  const deviceIdDe = async (pub) => (await pubkeyIdOf(pub)).slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2')
+  const deviceIdDe = keyLabel
 
   /**
    * @param {object} entrada  lo que devuelve `loginWithPassword` del pilar

package/vault/index.html

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

package/vault/keyid.js

@@ -32,10 +32,9 @@ export async function pubkeyId (publicJwkStr) {
  */
 export async function keyLabel (publicJwkStr) {
   if (!publicJwkStr) return ''
-  try {
-    const id = (await pubkeyId(publicJwkStr)).slice(0, 8).toUpperCase()
-    return id.slice(0, 4) + '-' + id.slice(4, 8)
-  } catch (_) { return '' }
+  // Una llave que no se puede leer LANZA: un '' callado se pintaba como «sin aparato».
+  const id = (await pubkeyId(publicJwkStr)).slice(0, 8).toUpperCase()
+  return id.slice(0, 4) + '-' + id.slice(4, 8)
 }
 
 export default { pubkeyId, keyLabel }

package/vault/remote.js

@@ -13,7 +13,7 @@
  * No reimplementa cripto: usa `@dotrino/identity/capabilities`. Transporte:
  * `@dotrino/proxy-client` (importado perezosamente; solo se carga al emparejar).
  */
-import { makeDeviceKey, signWithDevice, verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from './capabilities.js'
+import { makeDeviceKey, signWithDevice, verifyDeviceSig, makePairingCode, commitCode, keyLabel } from './capabilities.js'
 import { checkVaultReply } from './acta.js'
 import { cleanMachine, browserMachine } from './machine.js'
 
@@ -146,7 +146,7 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', conti
     // identidad (P) como `device` → el cert delega tu identidad y hay UNA sola (signData/
     // identify/cert son la misma P).
     const dev = device || await makeDeviceKey({ label })
-    const deviceId = (await pubkeyId(dev.publickey)).slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2')
+    const deviceId = await keyLabel(dev.publickey)
     // El DISPOSITIVO genera el código y manda solo su COMPROMISO (no el código). El vault
     // aprende el código únicamente cuando vos lo tipeás en el PC → aprobar exige tener el dispositivo.
     const code = makePairingCode()

package/vault/vault.js

@@ -13,7 +13,7 @@ import {
   initPeerStorage, loadPeers, savePeers, setPeersDirect, upsertPeer, onDirty
 } from './peerStore.js'
 import { createIdentityCore } from './core.js'
-import { pubkeyId } from './capabilities.js'
+import { keyLabel } from './capabilities.js'
 import { withExternalKeys, appBridge } from './externalKeys.js'
 import { nativeBackends } from './nativeStore.js'
 import { useBackend as usePeerBackend } from './peerStore.js'
@@ -320,7 +320,7 @@ import { useBackend as usePeerBackend } from './peerStore.js'
         if (!bySub.has(x.sub) || (x.exp || 0) > (bySub.get(x.sub).exp || 0)) bySub.set(x.sub, x)
       }
       const devices = await Promise.all([...bySub.values()].map(async (x) => ({
-        deviceId: (await pubkeyId(x.sub)).slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2'),
+        deviceId: await keyLabel(x.sub),
         sub: x.sub, label: x.label || '', scope: x.scope, exp: x.exp, nonce: x.nonce
       })))
       return { devices, revoked: (revoked || []).map((r) => r.nonce || r) }
@@ -469,6 +469,45 @@ import { useBackend as usePeerBackend } from './peerStore.js'
         }
       }
       return { ...r, deviceId: fila?.deviceId || null }
+    },
+
+    // ----- EL RESPALDO (`dotrino-vault/docs/respaldo.md`), cuando la bóveda es ESTA pestaña -----
+    //
+    // Exportar e importar, con la bóveda abierta (lo comprueba el núcleo: `VAULT_LOCKED`).
+    // Y SOLO DESDE LA CONSOLA: este iframe atiende a cualquier `*.dotrino.com`, y quien exporta
+    // elige la contraseña del respaldo — o sea, puede leerlo todo. Un fallo en cualquiera de
+    // las apps no puede convertirse en sacar los secretos de la cuenta.
+    // El archivo se cierra AQUÍ: a la consola le llega ya cifrado.
+    selfVaultBackupDrawers: async ({ __origin } = {}) => {
+      soloConsola(__origin)
+      return pidaDaemon().backupDrawers()
+    },
+    selfVaultBackupExport: async ({ drawers = null, password, __origin } = {}) => {
+      soloConsola(__origin)
+      const { sealBackup } = await import('@dotrino/vault/backup')
+      const { payload, summary } = await pidaDaemon().exportBackup({ drawers })
+      return { file: await sealBackup(payload, password), summary }
+    },
+    selfVaultBackupPlan: async ({ file, password, drawers = null, map = {}, __origin } = {}) => {
+      soloConsola(__origin)
+      const { openBackup } = await import('@dotrino/vault/backup')
+      return pidaDaemon().planBackupImport(await openBackup(file, password), { drawers, map })
+    },
+    selfVaultBackupImport: async ({ file, password, drawers = null, map = {}, onConflict = null, decisions = {}, __origin } = {}) => {
+      soloConsola(__origin)
+      const { openBackup } = await import('@dotrino/vault/backup')
+      return pidaDaemon().importBackup(await openBackup(file, password), { drawers, map, onConflict, decisions })
+    }
+  }
+
+  /**
+   * ¿ES LA CONSOLA? `vault.dotrino.com`, o un origen de desarrollo (localhost / LAN privada),
+   * que es donde se prueba. Lo demás del ecosistema no puede pedir un respaldo.
+   */
+  const CONSOLE_ORIGIN = /^(https:\/\/vault\.dotrino\.com|https?:\/\/(localhost|127\.0\.0\.1|192\.168\.\d{1,3}\.\d{1,3}|10\.\d{1,3}\.\d{1,3}\.\d{1,3}|172\.(1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3})(:\d+)?)$/
+  function soloConsola (origin) {
+    if (!CONSOLE_ORIGIN.test(String(origin || ''))) {
+      throw Object.assign(new Error('only the vault console (vault.dotrino.com) can back up or restore'), { code: 'not-the-console' })
     }
   }
 

package/vault/vendor/passmanager/VERSION.txt

@@ -1,3 +1,3 @@
-Copia vendorizada de @dotrino/passmanager@0.18.1 (dotrino-passmanager/lib/src/{crypto,fields,generate,import,index,match,model,pubkey,sealed/convert,sealed/device,sealed/entry,sealed/index,sealed/keys,sealed/recovery,sealed/store,session-cache,totp,transport/protocol,transport/proxy,transport/sealed,vault/approval,vault/errors,vault/guard,vault/interface,vault/local,vault/remote,vault/responder,vault/sealed-local,vault/sealed-responder,vault/sealed,webauthn}.js).
+Copia vendorizada de @dotrino/passmanager@0.18.4 (dotrino-passmanager/lib/src/{crypto,fields,generate,import,index,match,model,pubkey,sealed/convert,sealed/device,sealed/entry,sealed/index,sealed/keys,sealed/recovery,sealed/store,session-cache,totp,transport/protocol,transport/proxy,transport/sealed,vault/approval,vault/errors,vault/guard,vault/interface,vault/local,vault/remote,vault/responder,vault/sealed-local,vault/sealed-responder,vault/sealed,webauthn}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 El sobre de las contraseñas, el mismo que usan el binario y la extensión. Importa @dotrino/identity/content.

package/vault/vendor/passmanager/model.js

@@ -324,6 +324,10 @@ export function mergePatch (base, changes = {}) {
     ...(changes.totp !== undefined ? { totp: changes.totp } : {}),
     ...(changes.notes !== undefined ? { notes: changes.notes } : {}),
     ...vaciados,
+    // El contador de una passkey sube en cada firma: cambiarlo no toca la llave.
+    ...(Number.isInteger(changes.signCount) && base.webauthn
+      ? { webauthn: { ...base.webauthn, signCount: changes.signCount } }
+      : {}),
     sites,
     fields: quedan,
     id: base.id,

package/vault/vendor/passmanager/vault/approval.js

@@ -11,6 +11,12 @@
 //   · una NEGATIVA no queda recordada como aprobación: la siguiente vuelve a preguntar
 //   · dos peticiones a la vez producen UN aviso, no dos
 //   · lo aprobado vive en memoria y muere con la bóveda: no se guarda en ninguna parte
+//   · y además CADUCA: una hora deslizante, como dotrino-env (dueño, 2026-10-16). Cada uso
+//     la renueva; una hora sin usarla y se vuelve a preguntar. Antes duraba hasta reiniciar
+//     la bóveda, o sea días, y un sí de la mañana servía para todo lo de la semana.
+
+/** Cuánto vale un sí sin usarse: una hora, deslizante. */
+export const GRANT_TTL_MS = 60 * 60 * 1000
 
 export class ApprovalGate {
   /**
@@ -22,27 +28,49 @@ export class ApprovalGate {
    *      aprobación es del aparato y no de cada credencial.
    *   `remember`  si un sí vale para los siguientes. En `false` la puerta sigue
    *      juntando las simultáneas, pero cada petición nueva vuelve a preguntar.
+   *   `ttlMs`  cuánto vale un sí sin usarse (deslizante: cada uso lo renueva). Una hora.
+   *   `now`  el reloj, para las pruebas.
    */
-  constructor ({ ask, scope, remember = true } = {}) {
+  constructor ({ ask, scope, remember = true, ttlMs = GRANT_TTL_MS, now = Date.now } = {}) {
     this.ask = ask || (async () => false)
     this.scope = scope || (() => null)
     this.remember = remember !== false
-    this._granted = new Set()
+    this.ttlMs = ttlMs
+    this.now = now
+    this._granted = new Map()   // llave → cuándo se usó por última vez
     this._asking = new Map()
   }
 
-  /** ¿Pasa? Pregunta si hace falta, y recuerda el sí si le toca recordarlo. */
+  /** ¿Sigue vivo el sí de esa llave? Si sí, se renueva (deslizante); si caducó, se olvida. */
+  #fresh (key) {
+    const last = this._granted.get(key)
+    if (last == null) return false
+    if (this.now() - last > this.ttlMs) { this._granted.delete(key); return false }
+    this._granted.set(key, this.now())
+    return true
+  }
+
+  /**
+   * ¿Pasa? Pregunta si hace falta, y recuerda el sí si le toca recordarlo.
+   *
+   * `req.remember === false`: ESTA petición pregunta siempre, y su sí no vale para las
+   * siguientes. Es la de lo que no se deshace (borrar o pisar una passkey): que el sí a
+   * leer, o a borrar otra cosa, la dejara pasar es borrar sin que nadie lo vea
+   * (pasó el 2026-10-16: un borrado aprobado dejó pasar el siguiente sin aviso).
+   */
   async allow (req = {}) {
     const key = this.scope(req)
-    if (this.remember && key != null && this._granted.has(key)) return true
+    const remember = this.remember && req.remember !== false
+    if (remember && key != null && this.#fresh(key)) return true
 
     // Dos pestañas abriendo el mismo sitio no deben hacer sonar el teléfono dos veces.
-    const junta = key == null ? `${req.op || ''}:${req.payload?.id || ''}` : String(key)
+    // Lo que pregunta siempre se junta solo con la MISMA petición, no con todo el aparato.
+    const junta = key == null || !remember ? `${key ?? ''}:${req.op || ''}:${req.payload?.id || ''}` : String(key)
     if (this._asking.has(junta)) return this._asking.get(junta)
 
     const p = Promise.resolve(this.ask(req))
       .then(ok => {
-        if (ok && this.remember && key != null) this._granted.add(key)
+        if (ok && remember && key != null) this._granted.set(key, this.now())
         return !!ok
       })
       .finally(() => this._asking.delete(junta))
@@ -52,7 +80,8 @@ export class ApprovalGate {
   }
 
   granted (key) {
-    return this._granted.has(key)
+    const last = this._granted.get(key)
+    return last != null && this.now() - last <= this.ttlMs
   }
 
   /** Retirar lo aprobado sin apagar la bóveda. Sin argumento, todo. */

package/vault/vendor/passmanager/vault/sealed-responder.js

@@ -107,7 +107,11 @@ export class SealedResponder {
         // `allow`, no `ask`: es el que RECUERDA el sí y junta las simultáneas. `ask` es la
         // función cruda de preguntar, y usarla directamente hacía sonar el teléfono en cada
         // petición — que es como se enseña a aprobar sin mirar.
-        const ok = await this.gate.allow({ op, payload, pubkey })
+        //
+        // Salvo borrar o pisar una passkey: eso no se deshace, así que pregunta CADA vez y
+        // ningún sí anterior del aparato lo cubre.
+        const remember = !(await this.replacesPasskey(op, payload))
+        const ok = await this.gate.allow({ op, payload, pubkey, remember })
         if (!ok) { anota('rejected'); return this.#send(from, pubkey, replyError(rid, CODES.NOT_APPROVED, 'not approved on the trusted device')) }
       }
       const result = await this.#run(op, payload, pubkey)

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

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/proxy-client@0.36.1 (dotrino-proxy-client/src/{binpack,canonical,client,encpub,index,parts,sealing,signature,stats-log,stats,webrtc}.js).
+Copia vendorizada de @dotrino/proxy-client@0.36.2 (dotrino-proxy-client/src/{binpack,canonical,client,encpub,errors,index,parts,sealing,signature,stats-log,stats,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

@@ -5,17 +5,8 @@ import { WebRTCManager, RTC_TAG, DEFAULT_ICE_SERVERS, loadNodePeerConnection, re
 import { TrafficStats, utf8Length, registerTransport, unregisterTransport } from './stats.js'
 import { splitParts, splitBinParts, isPart, Reassembler, DIRECT_PART_CHARS, PROXY_PART_CHARS, QUEUE_MAX_CHARS, RELAY_MAX_CHARS, DIRECT_PART_BYTES, PROXY_PART_BYTES, QUEUE_MAX_BYTES, RELAY_MAX_BYTES } from './parts.js'
 import { pack, unpack, hasBinary, encodeFrame, decodeFrame } from './binpack.js'
+import { errorWithCode } from './errors.js'
 
-/**
- * Error con un `code` estable.
- *
- * El contrato es el CODE, no la frase: comprobar por el texto cruza procesos y
- * se rompe en silencio en cuanto alguien lo reescribe o lo traduce.
- *
- * @param {string} mensaje
- * @param {string} code
- * @returns {Error & { code: string }}
- */
 /**
  * EL SALUDO: «este token es de esta identidad».
  *
@@ -32,12 +23,6 @@ const HELLO_TAG = '__cc_hello__'
  */
 const SPEAKS = ['binary']
 
-function errorCon (mensaje, code) {
-  const e = /** @type {Error & { code: string }} */ (new Error(mensaje))
-  e.code = code
-  return e
-}
-
 /**
  * Dotrino WebSocket proxy client.
  * Minimal API: connection + token + messages + channels (publish/list/count/disconnect)
@@ -280,7 +265,7 @@ export class WebSocketProxyClient {
     // las peticiones pendientes). Sin esto, quien esperaba un `publish` se comía
     // los 10 s completos del timeout para enterarse de algo que ya se sabía, y
     // el temporizador mantenía vivo el proceso en Node ese rato.
-    this._rejectAllPending(errorCon('Connection closed', 'CONNECTION_CLOSED'))
+    this._rejectAllPending(errorWithCode('Connection closed', 'CONNECTION_CLOSED'))
   }
 
   /** Corta en seco todo lo que esperaba respuesta, con su motivo. */
@@ -351,7 +336,7 @@ export class WebSocketProxyClient {
     // abierto es no guardar ninguno: la app manda por donde le sale y el proxio lo lee
     // igual. Para sellar por token está `sendSealedTo`.
     if (this.requireSealed && !this._isSealed(payload)) {
-      throw errorCon(
+      throw errorWithCode(
         'requireSealed: refusing to send a directed message in the clear — use sendSealedTo()',
         'unsealed')
     }
@@ -527,7 +512,7 @@ export class WebSocketProxyClient {
     const m = this._measure(payload)
     const queueMax = m.bin ? QUEUE_MAX_BYTES : QUEUE_MAX_CHARS
     if (m.len > queueMax) {
-      throw errorCon(`sendSealed: ${m.len} ${m.bin ? 'bytes' : 'chars'} is more than can wait in the proxy (${queueMax}); send it by token while both ends are connected`, 'too-big-for-queue')
+      throw errorWithCode(`sendSealed: ${m.len} ${m.bin ? 'bytes' : 'chars'} is more than can wait in the proxy (${queueMax}); send it by token while both ends are connected`, 'too-big-for-queue')
     }
     // Por pubkey todo va por el proxio: si no admite bytes, se dice antes de mandar nada. Y
     // si alguno de los destinatarios dijo que no los entiende, tampoco.
@@ -576,7 +561,7 @@ export class WebSocketProxyClient {
       // solo sobre solo lo abriría una—, así que ahí se exige decirlo.
       if (!peerPubkey && tokens.length === 1) peerPubkey = this.pubkeyOfToken(tokens[0])
       if (!peerPubkey) {
-        throw errorCon(
+        throw errorWithCode(
           'sendSealedTo: nobody has said whose this token is — greet it (helloTo) or pass peerPubkey',
           'no-peer-identity')
       }
@@ -607,7 +592,7 @@ export class WebSocketProxyClient {
     // directo. Se pide el canal para que el siguiente intento lo encuentre abierto.
     if (!direct && m.len > relayMax) {
       this._upgradeDirect(tokens)
-      throw errorCon(`sendSealedTo: ${m.len} ${m.bin ? 'bytes' : 'chars'} is more than goes through the proxy live (${relayMax}); it needs a direct channel`, 'too-big-for-relay')
+      throw errorWithCode(`sendSealedTo: ${m.len} ${m.bin ? 'bytes' : 'chars'} is more than goes through the proxy live (${relayMax}); it needs a direct channel`, 'too-big-for-relay')
     }
     // Si el token muere a mitad, lo que quede se iría a la cola por pubkey; solo se permite
     // si el mensaje entero cabe ahí. Si no, se dice (`too-big-for-queue`), no se deja.
@@ -650,7 +635,7 @@ export class WebSocketProxyClient {
   async _sendPiece (token, sobre, peerPubkey, queueFallback, relayFallback = true) {
     if (this._rtc && await this._rtc.sendDirect(token, this._wire(sobre))) return
     if (!relayFallback) {
-      throw errorCon('the direct channel closed in the middle of a message too big for the proxy', 'direct-lost')
+      throw errorWithCode('the direct channel closed in the middle of a message too big for the proxy', 'direct-lost')
     }
     if (sobre instanceof Uint8Array) this._needBinaryProxy()
     this._sendToTokenOrQueue(token, sobre, peerPubkey, { queueFallback, skipDirect: true })
@@ -673,7 +658,7 @@ export class WebSocketProxyClient {
    */
   sendToOrQueue (token, payload, { peerPubkey } = /** @type {any} */ ({})) {
     if (!token || !peerPubkey) {
-      throw errorCon('sendToOrQueue: needs the token and whose it is (peerPubkey)', 'no-peer-identity')
+      throw errorWithCode('sendToOrQueue: needs the token and whose it is (peerPubkey)', 'no-peer-identity')
     }
     this._sendToTokenOrQueue(token, payload, peerPubkey)
   }
@@ -691,7 +676,7 @@ export class WebSocketProxyClient {
    */
   _sendToTokenOrQueue (token, sobre, peerPubkey, { queueFallback = true, skipDirect = false } = {}) {
     if (this.requireSealed && !this._isSealed(sobre)) {
-      throw errorCon('requireSealed: refusing to send a directed message in the clear — use sendSealedTo()', 'unsealed')
+      throw errorWithCode('requireSealed: refusing to send a directed message in the clear — use sendSealedTo()', 'unsealed')
     }
     const messageStr = this._wire(sobre)
     if (!skipDirect && this._rtc && this._rtc.trySend(token, messageStr)) return
@@ -747,7 +732,7 @@ export class WebSocketProxyClient {
    */
   helloTo (to) {
     if (!this.myPublickey) {
-      throw errorCon('helloTo: identify first — a greeting with no identity says nothing', 'not-identified')
+      throw errorWithCode('helloTo: identify first — a greeting with no identity says nothing', 'not-identified')
     }
     const tokens = Array.isArray(to) ? to : [to]
     for (const t of tokens) {
@@ -789,7 +774,7 @@ export class WebSocketProxyClient {
   _needPeerBinary (targets) {
     for (const t of targets) {
       if (t && this.speaks(t, 'binary') === false) {
-        throw errorCon('the other side does not take binary messages (it needs @dotrino/proxy-client >= 0.36.0)', 'peer-no-binary')
+        throw errorWithCode('the other side does not take binary messages (it needs @dotrino/proxy-client >= 0.36.0)', 'peer-no-binary')
       }
     }
   }
@@ -815,7 +800,7 @@ export class WebSocketProxyClient {
 
   /** Sella con lo que haya: la bóveda de la app (`sealing`) o las primitivas del pilar. */
   async _seal (payload, peerEncPub, peerPubkey) {
-    if (!peerEncPub) throw errorCon('seal: missing peerEncPub', 'unsealed')
+    if (!peerEncPub) throw errorWithCode('seal: missing peerEncPub', 'unsealed')
     return this.sealing
       ? this.sealing.seal(payload, peerEncPub, { publickey: peerPubkey })
       : seal(payload, peerEncPub)
@@ -856,7 +841,7 @@ export class WebSocketProxyClient {
   /** Un mensaje con bytes por el proxio necesita uno que admita tramas binarias (websocket-proxy ≥ 1.6.0). */
   _needBinaryProxy () {
     if (!Array.isArray(this.caps) || !this.caps.includes('binary')) {
-      throw errorCon('this proxy does not take binary frames (it needs websocket-proxy >= 1.6.0)', 'no-binary-support')
+      throw errorWithCode('this proxy does not take binary frames (it needs websocket-proxy >= 1.6.0)', 'no-binary-support')
     }
   }
 
@@ -867,7 +852,7 @@ export class WebSocketProxyClient {
     if (!p) {
       p = (async () => {
         const o = this.sealing ? await this.sealing.open(k, meta) : await open(k, this.myEncPrivateKey)
-        if (!o || typeof o.cek !== 'string') throw errorCon('the sealed key of a message has no key inside', 'bad-pack')
+        if (!o || typeof o.cek !== 'string') throw errorWithCode('the sealed key of a message has no key inside', 'bad-pack')
         return o.cek
       })()
       this._msgKeys.set(id, p)
@@ -909,7 +894,7 @@ export class WebSocketProxyClient {
    */
   async encPubOf (publickey) {
     if (typeof publickey !== 'string' || !publickey) {
-      throw errorCon('encPubOf: missing publickey', 'encpub-shape')
+      throw errorWithCode('encPubOf: missing publickey', 'encpub-shape')
     }
     const cacheada = this._encPubs.get(publickey)
     if (cacheada) return cacheada
@@ -931,7 +916,7 @@ export class WebSocketProxyClient {
       const propia = await this.encPubResolver(publickey)
       if (propia) {
         if (!isEncPub(propia)) {
-          throw errorCon('encPubResolver returned something that is not a P-256 public JWK', 'encpub-unverified')
+          throw errorWithCode('encPubResolver returned something that is not a P-256 public JWK', 'encpub-unverified')
         }
         this._encPubs.set(publickey, propia)
         return propia
@@ -941,7 +926,7 @@ export class WebSocketProxyClient {
     // esperar diez segundos a un timeout. Un proxio que no manda `caps` es de antes de
     // que esto existiera y no se sabe: se pregunta igual, y contesta la pregunta.
     if (Array.isArray(this.caps) && !this.caps.includes('encpub')) {
-      throw errorCon(
+      throw errorWithCode(
         `este proxio (${this.url}) no sirve llaves de cifrado: hace falta websocket-proxy >= 1.1.0`,
         'no-encpub-support')
     }
@@ -950,7 +935,7 @@ export class WebSocketProxyClient {
     // la app puede tener el mismo JWK escrito de otra forma.
     const statement = (res.keys || []).find((k) => samePubkey(k?.data?.publickey, publickey))
     if (!statement) {
-      throw errorCon('no encryption key announced for that identity — it cannot be sealed to yet', 'no-encpub')
+      throw errorWithCode('no encryption key announced for that identity — it cannot be sealed to yet', 'no-encpub')
     }
     // AQUÍ ES DONDE EL PROXIO DEJA DE IMPORTAR: la firma se comprueba contra la pubkey a
     // la que vamos a escribir. Si cambió la llave por la suya, esto lanza.
@@ -1015,7 +1000,7 @@ export class WebSocketProxyClient {
         }
         let opened
         try {
-          if (!this._isSealed(env.k)) throw errorCon('the key of a sealed message is not sealed', 'bad-pack')
+          if (!this._isSealed(env.k)) throw errorWithCode('the key of a sealed message is not sealed', 'bad-pack')
           opened = unpack(await decryptBytes(await this._openMessageKey(env.k, meta), env))
         } catch (e) {
           this._emit('error', { type: 'undecipherable', from, error: e })
@@ -1567,7 +1552,7 @@ export class WebSocketProxyClient {
     if (ws !== this.ws || this._connected) return
     this.ws = null   // a partir de acá, los eventos tardíos de `ws` se ignoran
     try { ws.close() } catch (_) {}
-    const err = errorCon(`could not open the connection to ${this.url} in ${Math.round(this.connectTimeout / 1000)}s`, 'CONNECT_TIMEOUT')
+    const err = errorWithCode(`could not open the connection to ${this.url} in ${Math.round(this.connectTimeout / 1000)}s`, 'CONNECT_TIMEOUT')
     this._emit('error', { type: 'connect_timeout', error: err })
     if (this._connectReject) {
       this._connectReject(err)
@@ -1781,7 +1766,7 @@ export class WebSocketProxyClient {
 
   _sendRaw (frame) {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      throw errorCon('WebSocket not connected', 'NOT_CONNECTED')
+      throw errorWithCode('WebSocket not connected', 'NOT_CONNECTED')
     }
     if (frame.message instanceof Uint8Array) {
       this._needBinaryProxy()
@@ -1860,7 +1845,7 @@ export class WebSocketProxyClient {
       const out = { ...frame, id }
       const timer = setTimeout(() => {
         this._pending.delete(id)
-        reject(errorCon(`Timeout waiting for ${expectedType}`, 'REQUEST_TIMEOUT'))
+        reject(errorWithCode(`Timeout waiting for ${expectedType}`, 'REQUEST_TIMEOUT'))
       }, 10000)
       this._pending.set(id, { resolve, reject, timer, expectedType, channelKey })
       try {
@@ -1891,7 +1876,7 @@ export class WebSocketProxyClient {
     this._pending.delete(id)
     // Con su `code`: quien llama distingue los casos por él, no por la frase (que el proxio
     // puede cambiar o traducir). Antes se perdía aquí y solo quedaba comparar el texto.
-    const e = errorCon(data.error || 'Server error', data.code || null)
+    const e = errorWithCode(data.error || 'Server error', data.code || null)
     // «Ahora no» (429) y cuánto esperar, cuando el proxio lo dice.
     if (data.status) e.status = data.status
     if (data.retry_after_ms) e.retryAfterMs = data.retry_after_ms