@dotrino/vault 0.9.0 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vault",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Usa ESTE dispositivo (navegador) como bóveda/CA del ecosistema Dotrino: atiende enrolamientos por el proxy y firma certificados de delegación a tus máquinas. Incluye el cliente de SERVICIO (Node): un proyecto se enrola una vez y jala sus credenciales del vault en vez del .env (`import '@dotrino/vault/config'`).",
   "type": "module",
   "main": "src/index.js",

package/src/enroll.js

@@ -42,6 +42,10 @@ export const DEVICE_TTL_MS = 30 * 24 * 60 * 60 * 1000
 export const MSG_ENROLL = 'vault.enroll'
 export const MSG_ENROLL_CHALLENGE = 'vault.enroll.challenge'
 export const MSG_ENROLLED = 'vault.enrolled'
+// --- camino A: la cuenta del aparato pasa a vivir en la bóveda ---
+export const MSG_ENROLL_ADOPT = 'vault.enroll.adopt'
+export const MSG_ACTA_SEALED = 'vault.acta.sealed'
+export const MSG_ACTA_ADOPTED = 'vault.acta.adopted'
 export const MSG_REVOKED = 'vault.revoked'
 export const MSG_ERROR = 'vault.error'
 
@@ -63,12 +67,22 @@ export function scopeToCn (scope) {
   return null
 }
 
-/** Token aleatorio de 128 bits en hex. */
-export function randToken () {
-  const b = crypto.getRandomValues(new Uint8Array(16))
+/**
+ * Token aleatorio en hex (16 bytes = 128 bits por defecto).
+ *
+ * El emparejamiento pide 12 (96 bits): son de un solo uso, valen 5 minutos y hay
+ * UNA sesión viva a la vez, así que adivinarlo es 2^95 intentos contra una bóveda
+ * que además exige el código de 6 dígitos. A cambio, cada byte de menos son ~1,4
+ * caracteres menos en el QR — y el QR se mide en filas de terminal.
+ */
+export function randToken (bytes = 16) {
+  const b = crypto.getRandomValues(new Uint8Array(bytes))
   return [...b].map((x) => x.toString(16).padStart(2, '0')).join('')
 }
 
+/** Tamaño del token/nonce de una sesión de emparejamiento (ver `randToken`). */
+const PAIR_TOKEN_BYTES = 12
+
 /** deviceId legible (p. ej. `C440-AC0E`) a partir de una pubkey JWK. */
 export async function deviceIdOf (pub) {
   const id = (await pubkeyId(pub)).slice(0, 8).toUpperCase()
@@ -94,8 +108,11 @@ export async function deviceIdOf (pub) {
 export function createEnrollDesk ({
   identity, iss, proxy, send, sendByPubkey,
   audit = () => {}, log = () => {},
-  onChallenge = () => {}, onPendingChange = () => {},
-  defaultScope = ['vault:sign'], defaultTtlMs = DEVICE_TTL_MS
+  onChallenge = () => {}, onPendingChange = () => {}, onAdopted = () => {},
+  defaultScope = ['vault:sign'], defaultTtlMs = DEVICE_TTL_MS,
+  // Camino A: lo que ESTA bóveda le manda al aparato para que la meta en su acta. `encPub`
+  // es su llave de CIFRADO — sin ella entra mandando pero sin poder leer el contenido.
+  encPub = null, vaultLabel = ''
 } = {}) {
   if (!identity) throw new Error('createEnrollDesk: falta identity')
   if (!iss) throw new Error('createEnrollDesk: falta iss (pubkey de la maestra)')
@@ -126,8 +143,8 @@ export function createEnrollDesk ({
    */
   function startPairing ({ scope = defaultScope, ttlMs = defaultTtlMs, label = '', mode = 'join', account = '' } = {}) {
     pending.clear() // uno a la vez: una sesión nueva supersede a la anterior
-    const token = randToken()
-    const sn = randToken()
+    const token = randToken(PAIR_TOKEN_BYTES)
+    const sn = randToken(PAIR_TOKEN_BYTES)
     const acct = String(account || '').slice(0, 40)
     pending.set(token, { token, exp: Date.now() + PAIRING_TTL_MS, scope, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
     return { token, qr: { v: 2, iss, proxy, token, sn, m: mode, ...(acct ? { acct } : {}) }, expiresInMs: PAIRING_TTL_MS }
@@ -162,6 +179,17 @@ export function createEnrollDesk ({
       return reply(from, { type: MSG_ERROR, error: 'token de emparejamiento inválido o expirado' })
     }
     if (d.sn !== pend.sn) return reply(from, { type: MSG_ERROR, error: 'sesión inválida' })
+    // V7 · la INTENCIÓN viaja firmada y tiene que coincidir con el modo con el que ESTA
+    // bóveda abrió el emparejamiento. Es lo que garantiza que lo que pasa es lo que el
+    // humano vio anunciado en las dos pantallas, y no algo que se decidió a mitad de camino.
+    const intent = d.intent || 'join'
+    if (intent !== 'join' && intent !== 'adopt') {
+      return reply(from, { type: MSG_ERROR, error: 'intención desconocida: ' + intent })
+    }
+    if (intent !== (pend.mode || 'join')) {
+      audit('rejected', { what: 'enroll', reason: 'intent-mismatch' })
+      return reply(from, { type: MSG_ERROR, error: `este emparejamiento se abrió para «${pend.mode || 'join'}» y el dispositivo pidió «${intent}»` })
+    }
     if (!isFresh(d)) {
       audit('rejected', { what: 'enroll', reason: 'stale' })
       return reply(from, { type: MSG_ERROR, error: 'petición vencida: ts fuera de la ventana ±5 min (posible replay, o el reloj del dispositivo está desfasado)' })
@@ -198,9 +226,12 @@ export function createEnrollDesk ({
     }
     pend.from = from // la bóveda NO conoce el código: lo aprende cuando lo tipeas
     if (d.label) pend.label = String(d.label).slice(0, 60)
+    // Camino A: de qué cuenta estamos hablando. Se guarda para poder comprobar, cuando
+    // llegue el acta sellada, que es la que este dispositivo dijo que iba a entregar.
+    if (intent === 'adopt' && typeof d.profileId === 'string') pend.profileId = d.profileId
 
     reply(from, { type: MSG_ENROLL_CHALLENGE, deviceId })
-    fire(onChallenge, { deviceId, scope: pend.scope, label: pend.label || '' })
+    fire(onChallenge, { deviceId, scope: pend.scope, label: pend.label || '', mode: pend.mode || 'join' })
     fire(onPendingChange)
     return { deviceId }
   }
@@ -236,6 +267,20 @@ export function createEnrollDesk ({
       throw new Error('el código no coincide con el que muestra el dispositivo: no se emitió ningún certificado. Vuelve a mirarlo y prueba otra vez.')
     }
 
+    // CAMINO A · aquí la bóveda no entrega un cert: entrega SU IDENTIDAD para que el
+    // aparato la meta en el acta de la cuenta que le está pasando. El código de vuelta es
+    // la misma defensa de siempre, en el otro sentido: el aparato solo hace caso a una
+    // bóveda que demuestre que un humano la aprobó.
+    if ((pend.mode || 'join') === 'adopt') {
+      audit('adopt-approve', { device: pend.deviceId, profile: pend.profileId || null })
+      pend.state = 'AWAITING_ACTA'
+      pend.approvedAt = Date.now()
+      reply(pend.from, { type: MSG_ENROLL_ADOPT, code, pub: iss, encPub: encPub || null, label: vaultLabel || '' })
+      log('[vault] adopción aprobada para %s: esperando el acta sellada', pend.deviceId)
+      fire(onPendingChange)
+      return { ok: true, deviceId: pend.deviceId, adopting: true }
+    }
+
     const { cert } = await identity.signDelegation(pend.dpub, pend.scope, { ttlMs: pend.ttlMs, label: pend.label })
 
     // Aprobar un emparejamiento ES admitir al dispositivo en el perfil: el cert es la
@@ -263,6 +308,60 @@ export function createEnrollDesk ({
     return { ok: true, deviceId: pend.deviceId, cert }
   }
 
+  /**
+   * CAMINO A · paso 6: llega el acta que el aparato acaba de sellar, con la bóveda dentro
+   * como miembro, la clave de contenido envuelta para ella y el mando ya traspasado.
+   *
+   * Lo que se comprueba antes de guardar nada (y por qué):
+   *   · que el sellador sea ESTA bóveda — si no, no es un traspaso, es un acta ajena;
+   *   · que la selle el aparato que estaba en este emparejamiento — cierra que un tercero
+   *     que vea pasar el mensaje cuele la suya;
+   *   · que sea la cuenta que ese aparato declaró al enrolarse (`profileId`) — cierra el
+   *     cambiazo de cuenta entre el anuncio que leyó el humano y lo que llega después.
+   *
+   * Adoptar la cuenta de otro solo procede sobre un perfil que **nació para eso** (la marca
+   * de `prepareForAdoption`). Es la misma regla del navegador: sin la marca, adoptar sería
+   * pisar una cuenta con datos, y eso no puede pasar por accidente.
+   */
+  async function handleActaSealed (from, p) {
+    const acta = p?.acta
+    const pend = [...pending.values()].find((x) => x.state === 'AWAITING_ACTA' && (x.from === from || x.dpub))
+    if (!pend) return reply(from, { type: MSG_ERROR, error: 'no hay ninguna adopción esperando un acta' })
+    if (!acta || typeof acta !== 'object') return reply(from, { type: MSG_ERROR, error: 'acta ausente o ilegible' })
+    if (acta.sealer !== iss) {
+      audit('rejected', { what: 'adopt', reason: 'not-sealer' })
+      return reply(from, { type: MSG_ERROR, error: 'esa acta no nombra a esta bóveda como quien manda' })
+    }
+    if (acta.sealedBy !== pend.dpub) {
+      audit('rejected', { what: 'adopt', reason: 'sealed-by-other' })
+      return reply(from, { type: MSG_ERROR, error: 'esa acta no la selló el dispositivo de este emparejamiento' })
+    }
+    if (pend.profileId && acta.profileId !== pend.profileId) {
+      audit('rejected', { what: 'adopt', reason: 'other-profile' })
+      return reply(from, { type: MSG_ERROR, error: 'esa acta es de otra cuenta distinta a la que anunció el dispositivo' })
+    }
+
+    try {
+      const r = await identity.joinProfile(acta)
+      if (!r?.joined) throw new Error(r?.reason || 'no se pudo adoptar')
+      audit('adopt', { device: pend.deviceId, profile: acta.profileId, seq: acta.seq })
+      // El acta que vuelve es la que la bóveda tiene guardada: el aparato la adopta y los
+      // dos quedan en la misma versión.
+      const mia = (await identity.profileActa?.())?.acta || acta
+      reply(pend.from, { type: MSG_ACTA_ADOPTED, code: p.code, acta: mia })
+      pend.state = 'DONE'
+      pending.delete(pend.token)
+      fire(onPendingChange)
+      fire(onAdopted, { deviceId: pend.deviceId, profileId: acta.profileId, seq: mia.seq })
+      log('[vault] cuenta adoptada del dispositivo %s (perfil %s)', pend.deviceId, acta.profileId?.slice(0, 12))
+      return { ok: true, adopted: true, profileId: acta.profileId, seq: mia.seq }
+    } catch (e) {
+      log('[vault] no se pudo adoptar la cuenta: %s', e.message)
+      reply(pend.from, { type: MSG_ERROR, error: 'la bóveda no pudo adoptar la cuenta: ' + e.message })
+      return { ok: false, error: e.message }
+    }
+  }
+
   /** Rechaza un enrolamiento pendiente. */
   function reject (deviceId) {
     const pend = deviceId
@@ -300,7 +399,7 @@ export function createEnrollDesk ({
   }
 
   return {
-    startPairing, stopPairing, handleEnroll, approve, reject,
+    startPairing, stopPairing, handleEnroll, handleActaSealed, approve, reject,
     listPending, findPending, emitRevoke, revoke,
     get pendingCount () { return pending.size }
   }

package/src/invite.js

@@ -1,65 +1,310 @@
 /**
  * invite.js — la invitación de emparejamiento: cómo se escribe y cómo se lee.
  *
- * Un emparejamiento viaja de dos maneras, y cada una quiere una codificación
- * distinta:
+ * Una invitación viaja de dos maneras —un QR que se escanea y un código que se
+ * copia y se pega— y **las dos quieren lo mismo: que sea CORTA**. En un QR cada
+ * carácter son módulos, y los módulos son filas y columnas de terminal; en un
+ * código pegable, cada carácter es una oportunidad de que alguien lo corte mal.
  *
- *   · **El QR / el enlace** → JSON CRUDO (`j`). Nadie lo lee con los ojos y cada
- *     carácter cuenta: el base64 infla el payload un 33 % y eso son módulos de más
- *     en el QR (~8 columnas y 4 filas de terminal). Va crudo.
- *   · **El código que se copia y se pega** → base64url (`b`). Ahí sí lo manipula
- *     una persona: una sola palabra sin comillas, llaves ni espacios, que sobrevive
- *     a un doble clic, a un chat y a un campo de texto.
+ * Por eso el formato vigente es **`c` (compacto)**: los datos van en BINARIO y el
+ * binario en base64url. Nada de JSON. Un JSON con la llave maestra dentro pesa
+ * ~340 caracteres (la llave es una JWK *serializada como string*, con sus comillas
+ * escapadas: 182 de esos 340 son ella sola); el mismo contenido en binario son ~75
+ * bytes → **~100 caracteres**. Medido en la práctica: el QR pasó de 69 módulos
+ * (77×39 en la terminal) a 41 (49×25), y el código pegable de 458 caracteres a 101.
  *
- * Para que el lector no tenga que ADIVINAR cuál de las dos le llegó, el payload
- * empieza por una **marca de formato** de un carácter (`j` o `b`). Sin marca se
- * asume el formato viejo (base64url, y si no, JSON), solo por compatibilidad con
- * los enlaces que ya salieron.
+ * De dónde sale el ahorro, en orden de importancia:
+ *   · **La llave `iss`** (182 → 44 chars). Una pubkey P-256 son dos coordenadas de
+ *     32 bytes; en el QR va el **punto comprimido** de 33 bytes (SEC1: `02`/`03`
+ *     según la paridad de `y`, seguido de `x`) y el lector recupera `y` resolviendo
+ *     la curva. La JWK se rearma con una PLANTILLA (el índice va en la cabecera)
+ *     para que la string vuelva **byte a byte** igual: el proxy direcciona por esa
+ *     string exacta, así que una coma de más rompe el enrutamiento.
+ *   · **`token` y `sn`** (34+34 → 16+16 bytes): eran hexadecimal, que gasta dos
+ *     caracteres por byte.
+ *   · **`proxy`** (33 → 0): si es el del ecosistema no viaja; se sobreentiende.
+ *   · **`m` y `v`**: dos campos de JSON → dos grupos de bits de la cabecera.
  *
- * GOTCHA que justifica la mitad de este archivo: el JSON crudo lleva `{`, `}` y
- * `"`, que **no son legales en una URI**. Al abrir el enlace, el navegador los
- * percent-codifica (`%22`…), así que lo que llega a `location.hash` NO es el JSON
- * que se emitió. Medido en un navegador real (2026-07-28). Por eso se
- * `decodeURIComponent` antes de parsear: sin eso, el QR daba «ese código no vale».
+ * SEGURIDAD DEL AHORRO: `encodeInvite` **comprueba el viaje de vuelta** antes de
+ * entregar la forma compacta — decodifica lo que acaba de codificar y exige que sea
+ * idéntico al original. Si algo no encaja (una JWK con otra forma, un campo nuevo,
+ * un `token` que no es hex), devuelve la forma larga en base64. Así una llave rara
+ * no rompe un emparejamiento: como mucho lo hace más grande.
+ *
+ * Formatos que se leen (el primer carácter dice cuál es):
+ *   · `c` — compacto binario+base64url. **El que se emite hoy**, para el QR y para
+ *           el código pegable: es a la vez el más corto y una sola palabra sin
+ *           comillas ni llaves, que sobrevive a un doble clic y a un chat.
+ *   · `b` — base64url del JSON. Forma larga, de reserva.
+ *   · `j` — JSON crudo. Solo para leer enlaces ya emitidos.
+ *   · sin marca — anterior a la marca de formato (base64url, o JSON).
+ *
+ * GOTCHA que justifica el `decodeURIComponent`: el JSON crudo lleva `{`, `}` y `"`,
+ * que **no son legales en una URI**. Al abrir el enlace, el navegador los
+ * percent-codifica (`%22`…), así que lo que llega a `location.hash` NO es lo que se
+ * emitió. Medido en un navegador real (2026-07-28). El formato compacto no tiene
+ * ese problema —base64url ya es seguro en una URL—, pero `j` sigue por ahí.
  */
 
 export const FMT_JSON = 'j'
 export const FMT_B64 = 'b'
+export const FMT_COMPACT = 'c'
+
+/** El proxy del ecosistema: si es este, no viaja en la invitación compacta. */
+export const DEFAULT_PROXY = 'wss://proxy.dotrino.com'
+
+/**
+ * La base del enlace del QR. Corta a propósito (`/d#v=` en vez de
+ * `/dispositivos#vault=`): son 15 caracteres menos dentro del QR, y ahí los
+ * caracteres se pagan en módulos. `vault.dotrino.com/dispositivos` sigue
+ * funcionando —es la ruta que la gente ya tiene— y `parseInvite` lee las dos.
+ */
+export const PAIR_URL = 'https://vault.dotrino.com/d#v='
+
+// ---------------------------------------------------------------------------
+// Conversiones (sin dependencias: esto corre en el navegador, en Node y dentro
+// del binario SEA)
+// ---------------------------------------------------------------------------
+
+const B64_STD = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
 
-const b64urlEncode = (s) => {
-  const bytes = new TextEncoder().encode(s)
-  let bin = ''
-  for (const b of bytes) bin += String.fromCharCode(b)
-  const raw = typeof btoa === 'function' ? btoa(bin) : Buffer.from(s, 'utf8').toString('base64')
-  return raw.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
+function bytesToB64url (bytes) {
+  let out = ''
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes[i]; const b = bytes[i + 1]; const c = bytes[i + 2]
+    out += B64_STD[a >> 2]
+    out += B64_STD[((a & 3) << 4) | ((b ?? 0) >> 4)]
+    if (b === undefined) break
+    out += B64_STD[((b & 15) << 2) | ((c ?? 0) >> 6)]
+    if (c === undefined) break
+    out += B64_STD[c & 63]
+  }
+  return out.replace(/\+/g, '-').replace(/\//g, '_')
 }
 
-const b64urlDecode = (s) => {
-  const b = s.replace(/-/g, '+').replace(/_/g, '/')
-  const pad = b + '='.repeat((4 - b.length % 4) % 4)
-  if (typeof atob === 'function') {
-    const bin = atob(pad)
-    const bytes = Uint8Array.from(bin, (c) => c.charCodeAt(0))
-    return new TextDecoder().decode(bytes)
+function b64urlToBytes (s) {
+  const clean = String(s).replace(/-/g, '+').replace(/_/g, '/').replace(/[^A-Za-z0-9+/]/g, '')
+  const out = []
+  let acc = 0; let bits = 0
+  for (const ch of clean) {
+    const v = B64_STD.indexOf(ch)
+    if (v < 0) return null
+    acc = (acc << 6) | v; bits += 6
+    if (bits >= 8) { bits -= 8; out.push((acc >> bits) & 0xff) }
   }
-  return Buffer.from(pad, 'base64').toString('utf8')
+  return Uint8Array.from(out)
 }
 
-/** El payload marcado, listo para meter en el `#fragment` o para copiar y pegar. */
-export function encodeInvite (qr, fmt = FMT_B64) {
+const utf8 = (s) => new TextEncoder().encode(s)
+const fromUtf8 = (b) => new TextDecoder().decode(b)
+
+/**
+ * `token` y `sn` son hexadecimal. Caben en la invitación en dos tamaños —12 o 16
+ * bytes— porque el hexadecimal gasta dos caracteres por byte y en un QR eso se
+ * paga: 12 bytes (96 bits, lo que emite hoy `startPairing`) son 11 caracteres
+ * menos que 16, y esos 11 caracteres son la diferencia entre que quepa un nombre
+ * de cuenta normal o que el QR suba una versión entera.
+ */
+const hexLen = (s) => (typeof s === 'string' && /^[0-9a-f]+$/.test(s) && (s.length === 24 || s.length === 32)) ? s.length / 2 : 0
+const hexToBytes = (s) => Uint8Array.from(s.match(/../g).map((h) => parseInt(h, 16)))
+const bytesToHex = (b) => [...b].map((x) => x.toString(16).padStart(2, '0')).join('')
+
+const b64urlEncodeStr = (s) => bytesToB64url(utf8(s))
+const b64urlDecodeStr = (s) => { const b = b64urlToBytes(s); return b ? fromUtf8(b) : null }
+
+// ---------------------------------------------------------------------------
+// La llave maestra: JWK ⇄ punto comprimido de la curva P-256
+// ---------------------------------------------------------------------------
+
+/**
+ * Las formas de JWK que existen en el ecosistema. `JSON.stringify` de una JWK
+ * conserva el orden en que la exportó cada WebCrypto, y **ese orden es parte de la
+ * identidad**: el proxy direcciona por la string exacta. Por eso no se «normaliza»
+ * la JWK —eso cambiaría la dirección de la bóveda—, se rearma tal cual con la
+ * plantilla que le toca. El índice viaja en la cabecera (2 bits, hasta 4 formas).
+ */
+const JWK_TEMPLATES = [
+  // 0 — WebCrypto de Node (el daemon del PC): key_ops, ext, kty, x, y, crv
+  (x, y) => `{"key_ops":["verify"],"ext":true,"kty":"EC","x":"${x}","y":"${y}","crv":"P-256"}`,
+  // 1 — WebCrypto de navegador (Chrome/Firefox/Safari, alfabético): crv, ext, key_ops, kty, x, y
+  (x, y) => `{"crv":"P-256","ext":true,"key_ops":["verify"],"kty":"EC","x":"${x}","y":"${y}"}`,
+]
+
+// Parámetros de la curva P-256 (FIPS 186-4). `a` es −3.
+const P256_P = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffffn
+const P256_B = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604bn
+
+const modPow = (base, exp, m) => {
+  let r = 1n; let b = base % m
+  while (exp > 0n) { if (exp & 1n) r = (r * b) % m; b = (b * b) % m; exp >>= 1n }
+  return r
+}
+
+const bytesToBig = (b) => { let n = 0n; for (const x of b) n = (n << 8n) | BigInt(x); return n }
+const bigToBytes32 = (n) => { const out = new Uint8Array(32); for (let i = 31; i >= 0; i--) { out[i] = Number(n & 0xffn); n >>= 8n } return out }
+
+/** Coordenada de una JWK: base64url de 32 bytes exactos, o `null`. */
+function coordBytes (s) {
+  if (typeof s !== 'string' || !/^[A-Za-z0-9_-]{43}$/.test(s)) return null
+  const b = b64urlToBytes(s)
+  return b && b.length === 32 ? b : null
+}
+
+/**
+ * `iss` (JWK serializada) → `{ tpl, point }` con el punto comprimido de 33 bytes, o
+ * `null` si la llave no tiene una forma conocida (entonces la invitación va larga).
+ */
+function packPubkey (iss) {
+  if (typeof iss !== 'string') return null
+  let jwk
+  try { jwk = JSON.parse(iss) } catch { return null }
+  if (!jwk || jwk.kty !== 'EC' || jwk.crv !== 'P-256') return null
+  const xb = coordBytes(jwk.x); const yb = coordBytes(jwk.y)
+  if (!xb || !yb) return null
+
+  const tpl = JWK_TEMPLATES.findIndex((f) => f(jwk.x, jwk.y) === iss)
+  if (tpl < 0) return null // forma desconocida: no se puede rearmar igual → larga
+
+  const point = new Uint8Array(33)
+  point[0] = 2 + (yb[31] & 1) // 02 = y par, 03 = y impar
+  point.set(xb, 1)
+  return { tpl, point }
+}
+
+/** Punto comprimido + plantilla → la `iss` original (o `null` si el punto no es de la curva). */
+function unpackPubkey (point, tpl) {
+  const template = JWK_TEMPLATES[tpl]
+  if (!template || point.length !== 33 || (point[0] !== 2 && point[0] !== 3)) return null
+
+  const x = bytesToBig(point.subarray(1))
+  if (x >= P256_P) return null
+  // y² = x³ − 3x + b (mod p). Con p ≡ 3 (mod 4) la raíz es y = (y²)^((p+1)/4).
+  const y2 = (((x * x) % P256_P) * x - 3n * x + P256_B) % P256_P
+  const rhs = (y2 + P256_P) % P256_P
+  let y = modPow(rhs, (P256_P + 1n) / 4n, P256_P)
+  if ((y * y) % P256_P !== rhs) return null // x no está en la curva
+  if ((y & 1n) !== BigInt(point[0] & 1)) y = P256_P - y
+
+  return template(bytesToB64url(point.subarray(1)), bytesToB64url(bigToBytes32(y)))
+}
+
+// ---------------------------------------------------------------------------
+// El formato compacto
+// ---------------------------------------------------------------------------
+
+/**
+ * Cabecera (1 byte):
+ *   bits 0-2  versión del protocolo (`qr.v`, hoy 2)
+ *   bit  3    modo: 0 = `join` · 1 = `adopt`
+ *   bits 4-5  plantilla de la JWK (índice en `JWK_TEMPLATES`)
+ *   bit  6    lleva proxy propio (si no, el del ecosistema)
+ *   bit  7    `token`/`sn` de 12 bytes (si 0, de 16)
+ *
+ * Cuerpo: punto comprimido (33) ‖ token (n) ‖ sn (n) ‖ len+`acct` ‖ [len+`proxy`]
+ */
+const MODES = ['join', 'adopt']
+
+function compactEncode (qr) {
+  if (!qr || typeof qr !== 'object') return null
+  const v = qr.v
+  if (!Number.isInteger(v) || v < 0 || v > 7) return null
+  const mode = MODES.indexOf(qr.m)
+  if (mode < 0) return null
+  const n = hexLen(qr.token)
+  if (!n || hexLen(qr.sn) !== n) return null
+
+  const pub = packPubkey(qr.iss)
+  if (!pub || pub.tpl > 3) return null
+
+  const acct = utf8(String(qr.acct || ''))
+  if (acct.length > 255) return null
+  const ownProxy = qr.proxy && qr.proxy !== DEFAULT_PROXY
+  const proxy = ownProxy ? utf8(String(qr.proxy)) : null
+  if (proxy && proxy.length > 255) return null
+
+  // Un campo que no se sepa escribir se perdería en silencio: eso NO se hace.
+  const known = new Set(['v', 'iss', 'proxy', 'token', 'sn', 'm', 'acct'])
+  if (Object.keys(qr).some((k) => !known.has(k))) return null
+
+  const head = v | (mode << 3) | (pub.tpl << 4) | (ownProxy ? 0x40 : 0) | (n === 12 ? 0x80 : 0)
+  const out = [head, ...pub.point, ...hexToBytes(qr.token), ...hexToBytes(qr.sn), acct.length, ...acct]
+  if (proxy) out.push(proxy.length, ...proxy)
+  return bytesToB64url(Uint8Array.from(out))
+}
+
+function compactDecode (text) {
+  const b = b64urlToBytes(text)
+  const n = (b && (b[0] & 0x80)) ? 12 : 16
+  if (!b || b.length < 35 + n * 2) return null
+  const head = b[0]
+
+  const iss = unpackPubkey(b.subarray(1, 34), (head >> 4) & 3)
+  if (!iss) return null
+
+  let i = 34
+  const token = bytesToHex(b.subarray(i, i + n)); i += n
+  const sn = bytesToHex(b.subarray(i, i + n)); i += n
+  const acctLen = b[i]; i += 1
+  if (i + acctLen > b.length) return null
+  const acct = acctLen ? fromUtf8(b.subarray(i, i + acctLen)) : ''
+  i += acctLen
+
+  let proxy = DEFAULT_PROXY
+  if (head & 0x40) {
+    if (i >= b.length) return null
+    const n = b[i]; i += 1
+    if (i + n > b.length) return null
+    proxy = fromUtf8(b.subarray(i, i + n)); i += n
+  }
+  if (i !== b.length) return null // sobran bytes: no es lo que creemos que es
+
+  // Mismo orden de campos que `startPairing`, para que las dos formas serialicen igual.
+  return { v: head & 7, iss, proxy, token, sn, m: MODES[(head >> 3) & 1], ...(acct ? { acct } : {}) }
+}
+
+// ---------------------------------------------------------------------------
+// API
+// ---------------------------------------------------------------------------
+
+/** Comparación por contenido, sin depender del orden de las claves. */
+const canon = (o) => JSON.stringify(Object.keys(o).sort().map((k) => [k, o[k]]))
+
+/**
+ * El payload marcado, listo para meter en el `#fragment` o para copiar y pegar.
+ *
+ * Por defecto **compacto**, que es lo más corto y a la vez pegable. Se cae a la
+ * forma larga (`b`) sola, sin avisar, si el compacto no reproduce el original
+ * exactamente: más vale un QR grande que uno que no empareja.
+ */
+export function encodeInvite (qr, fmt = FMT_COMPACT) {
   const json = JSON.stringify(qr)
-  return fmt === FMT_JSON ? FMT_JSON + json : FMT_B64 + b64urlEncode(json)
+  if (fmt === FMT_JSON) return FMT_JSON + json
+  if (fmt === FMT_COMPACT) {
+    const c = compactEncode(qr)
+    // El viaje de vuelta se comprueba SIEMPRE: es barato (una vez por
+    // emparejamiento) y es lo que permite comprimir sin jugarse el enrolamiento.
+    if (c) { const back = compactDecode(c); if (back && canon(back) === canon(qr)) return FMT_COMPACT + c }
+  }
+  return FMT_B64 + b64urlEncodeStr(json)
 }
 
-/** Una URL sin percent-encodear rompe el `#`: el fragmento se corta ahí. */
+/** El enlace del QR: `https://vault.dotrino.com/d#v=<invitación>`. */
+export function inviteUrl (qr) { return PAIR_URL + encodeInvite(qr) }
+
+/**
+ * Corta el `#fragment` de una URL. `#vault=` es la forma larga histórica y `#v=` la
+ * corta de hoy; se prueba la larga primero porque `#vault=` empieza por `#v`.
+ */
 const cutFragment = (text) => {
-  const i = text.indexOf('#vault=')
-  return i >= 0 ? text.slice(i + 7) : text
+  const long = text.indexOf('#vault=')
+  if (long >= 0) return text.slice(long + 7)
+  const short = text.indexOf('#v=')
+  return short >= 0 ? text.slice(short + 3) : text
 }
 
 /**
- * Lee una invitación venga como venga: URL con `#vault=…`, el código suelto, con
- * marca de formato o sin ella (formatos viejos). Devuelve el objeto del QR o
+ * Lee una invitación venga como venga: URL con `#v=`/`#vault=`, el código suelto,
+ * con marca de formato o sin ella (formatos viejos). Devuelve el objeto del QR o
  * `null` — nunca lanza, porque del otro lado hay alguien pegando texto a mano.
  */
 export function parseInvite (text) {
@@ -75,13 +320,15 @@ export function parseInvite (text) {
 
   const marca = payload[0]
   const resto = payload.slice(1)
-  if (marca === FMT_JSON) return parse(undoUrl(resto)) || parse(resto)
-  if (marca === FMT_B64) { try { return parse(b64urlDecode(resto)) } catch { return null } }
+  if (marca === FMT_COMPACT) { const o = compactDecode(resto); if (o) return o }
+  if (marca === FMT_JSON) { const o = parse(undoUrl(resto)) || parse(resto); if (o) return o }
+  if (marca === FMT_B64) { const s = b64urlDecodeStr(resto); const o = s && parse(s); if (o) return o }
 
   // --- sin marca: formatos anteriores a la marca de formato (compatibilidad) ---
   const crudo = undoUrl(payload)
   if (crudo.trimStart().startsWith('{')) return parse(crudo)
-  try { return parse(b64urlDecode(payload)) } catch { return null }
+  const s = b64urlDecodeStr(payload)
+  return s ? parse(s) : null
 }
 
-export default { encodeInvite, parseInvite, FMT_JSON, FMT_B64 }
+export default { encodeInvite, inviteUrl, parseInvite, FMT_JSON, FMT_B64, FMT_COMPACT, PAIR_URL, DEFAULT_PROXY }

package/src/protocol.js

@@ -20,6 +20,13 @@ export const MSG = Object.freeze({
   ENROLL: 'vault.enroll',                     // dispositivo → vault: { data, signature }
   ENROLL_CHALLENGE: 'vault.enroll.challenge', // vault → dispositivo: { deviceId, sas }
   ENROLLED: 'vault.enrolled',                 // vault → dispositivo (tras aprobar): { cert, iss, sas }
+  // Camino A (la cuenta del aparato pasa a vivir en la bóveda): en vez de un cert, la
+  // bóveda manda QUIÉN es para que el aparato la admita, le envuelva la clave de
+  // contenido y le traspase el mando; el aparato devuelve el acta sellada y la bóveda
+  // responde con la definitiva. Ver docs/vinculacion-de-cuentas.md §2.
+  ENROLL_ADOPT: 'vault.enroll.adopt',         // vault → dispositivo: { code, pub, encPub, label }
+  ACTA_SEALED: 'vault.acta.sealed',           // dispositivo → vault: { acta, code }
+  ACTA_ADOPTED: 'vault.acta.adopted',         // vault → dispositivo: { acta }
   REVOKED: 'vault.revoked',                   // vault → dispositivo: { body:{op,sub,nonce,iat,exp}, signature }
   SIGN: 'vault.sign',                         // dispositivo → vault: { data, signature, cert }
   SIGNED: 'vault.signed',                     // vault → dispositivo: { signature, publickey, device }