@dotrino/identity 0.115.0 → 0.117.0

package/vault/vendor/passmanager/crypto.js

@@ -0,0 +1,167 @@
+// Cifrado de las entradas de la bóveda.
+//
+// Una CEK (AES-GCM 256) por bóveda, con la que se cifra cada entrada por separado.
+// Quién tiene la CEK es lo que define la confianza de cada aparato (DISENO §3): al
+// vault y a la app nativa se les envuelve; a la extensión, no.
+//
+// El envoltorio de la CEK a cada miembro NO se hace aquí: eso es `wrapForMember` de
+// @dotrino/identity/content, que ya está escrito y probado. Este módulo es solo el
+// tramo simétrico.
+
+const enc = new TextEncoder()
+const dec = new TextDecoder()
+
+/** WebCrypto del entorno (navegador, service worker o Node ≥ 20). */
+function subtle () {
+  const c = globalThis.crypto
+  if (!c?.subtle) throw new Error('webcrypto unavailable')
+  return c.subtle
+}
+
+function randomBytes (n) {
+  const b = new Uint8Array(n)
+  globalThis.crypto.getRandomValues(b)
+  return b
+}
+
+export function toBase64 (bytes) {
+  let s = ''
+  for (const b of bytes) s += String.fromCharCode(b)
+  return btoa(s)
+}
+
+export function fromBase64 (b64) {
+  const s = atob(b64)
+  const out = new Uint8Array(s.length)
+  for (let i = 0; i < s.length; i++) out[i] = s.charCodeAt(i)
+  return out
+}
+
+/** Genera una CEK nueva. Extraíble: hay que poder envolverla para cada aparato. */
+export async function makeVaultKey () {
+  return subtle().generateKey({ name: 'AES-GCM', length: 256 }, true, ['encrypt', 'decrypt'])
+}
+
+export async function exportVaultKey (key) {
+  return new Uint8Array(await subtle().exportKey('raw', key))
+}
+
+export async function importVaultKey (raw) {
+  return subtle().importKey('raw', raw, { name: 'AES-GCM' }, true, ['encrypt', 'decrypt'])
+}
+
+/**
+ * Cifra un valor con la CEK. Devuelve `{ iv, ct }` en base64, para que una entrada
+ * cifrada siga siendo JSON serializable tal cual.
+ *
+ * `aad` ata el criptograma a su sitio: se pasa el id de la entrada y el campo, así
+ * que un criptograma movido de una entrada a otra (o de `secret` a `totp`) no abre.
+ */
+export async function sealValue (key, plaintext, aad) {
+  const iv = randomBytes(12)
+  const params = { name: 'AES-GCM', iv }
+  if (aad) params.additionalData = enc.encode(aad)
+  const ct = await subtle().encrypt(params, key, enc.encode(plaintext))
+  return { iv: toBase64(iv), ct: toBase64(new Uint8Array(ct)) }
+}
+
+export async function openValue (key, sealed, aad) {
+  if (!sealed || typeof sealed.iv !== 'string' || typeof sealed.ct !== 'string') {
+    throw new Error('sealed value malformed')
+  }
+  const params = { name: 'AES-GCM', iv: fromBase64(sealed.iv) }
+  if (aad) params.additionalData = enc.encode(aad)
+  const pt = await subtle().decrypt(params, key, fromBase64(sealed.ct))
+  return dec.decode(pt)
+}
+
+/** Etiqueta AAD de un campo. Un solo sitio para que sellar y abrir no se desalineen. */
+export function fieldTag (entryId, field) {
+  return `dotrino-passmanager/v1/${entryId}/${field}`
+}
+
+// --- Contraseña maestra ------------------------------------------------------
+//
+// Solo para el caso en que la bóveda vive en el propio aparato y no hay nadie más
+// que la custodie (la extensión antes del paso 2, DISENO §8). Cuando responde el
+// vault o el teléfono, la CEK llega envuelta y esto no se usa.
+
+const KDF_ITERATIONS = 600_000 // recomendación OWASP para PBKDF2-SHA256
+
+export function makeSalt () {
+  return randomBytes(16)
+}
+
+/**
+ * Deriva la CEK de una contraseña maestra.
+ *
+ * `extractable` existe por MV3: el service worker de la extensión se duerme, y un
+ * `CryptoKey` no sobrevive a `chrome.storage.session` (que serializa a JSON, no
+ * clona). Para no pedir la contraseña cada pocos minutos hay que poder exportar la
+ * clave y guardarla en memoria de sesión. Es un compromiso consciente y acotado a la
+ * extensión: donde no haga falta, se deriva no extraíble.
+ */
+export async function deriveKeyFromPassword (password, salt, iterations = KDF_ITERATIONS, extractable = false) {
+  const material = await subtle().importKey(
+    'raw', enc.encode(String(password)), 'PBKDF2', false, ['deriveKey'])
+  return subtle().deriveKey(
+    { name: 'PBKDF2', salt, iterations, hash: 'SHA-256' },
+    material,
+    { name: 'AES-GCM', length: 256 },
+    extractable,
+    ['encrypt', 'decrypt'],
+  )
+}
+
+/**
+ * Verificador de contraseña: un valor sellado con la propia clave derivada. No es un
+ * hash de la contraseña — es una prueba de que la clave abre la bóveda, que es lo que
+ * de verdad importa.
+ */
+export async function makeVerifier (key) {
+  return sealValue(key, 'dotrino-passmanager', 'verifier')
+}
+
+export async function checkVerifier (key, verifier) {
+  try {
+    return (await openValue(key, verifier, 'verifier')) === 'dotrino-passmanager'
+  } catch {
+    return false
+  }
+}
+
+// --- comparar sin abrir -------------------------------------------------------
+//
+// Para decir «esto que escribiste ya está guardado igual» hace falta comparar con lo
+// guardado, y abrir la entrada es una autorización (DISENO §3.3.2). La bóveda manda
+// entonces un **resumen** de cada campo: quien pregunta hashea lo que tiene delante y
+// compara los resúmenes.
+//
+// **Un solo método para todos los campos**, públicos y privados (dueño, 2026-08-29):
+// dos formas de comparar según qué campo sea son dos comportamientos que se separan y
+// acaban diciendo cosas distintas.
+//
+// El resumen va con un **nonce nuevo en cada respuesta**, así que no es una huella
+// estable: no vale para reconocer la misma contraseña entre dos respuestas, ni para
+// guardar una tabla y consultarla más tarde. Y el nombre del campo entra en el HMAC, así
+// que un resumen tampoco sirve para comparar contra otro campo.
+
+/** Un nonce nuevo, para UNA respuesta. No se guarda en ninguna parte. */
+export function makeNonce () {
+  return toBase64(randomBytes(16))
+}
+
+/**
+ * El hasheador de una respuesta. Se importa la llave UNA vez y se hashean todos los
+ * campos con ella: importar por campo multiplica el coste de un `find` sin ganar nada.
+ */
+export async function fieldHasher (nonce) {
+  const key = await subtle().importKey(
+    'raw', fromBase64(nonce), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign'])
+  return async (name, value) => {
+    const sig = await subtle().sign('HMAC', key, enc.encode(name + ' ' + value))
+    // 128 bits: de sobra para que dos valores distintos no colisionen en la práctica, y
+    // la mitad de bytes que mandar el SHA-256 entero.
+    return toBase64(new Uint8Array(sig).slice(0, 16))
+  }
+}

package/vault/vendor/passmanager/fields.js

@@ -0,0 +1,183 @@
+// Campos sueltos para rellenar formularios: correo, teléfono, dirección, cédula, lo
+// que sea. Son del usuario y no de un sitio concreto.
+//
+// Dos ideas, y las dos son deliberadamente simples:
+//
+// 1. **Los campos son libres.** Una lista de `{ label, value, kind }`, no un formulario
+//    fijo. Cada quien guarda lo que necesita rellenar, y puede tener varios juegos —
+//    la dirección de casa y la del trabajo son dos entradas, no dos campos.
+//
+// 2. **Cross-domain es no tener sitios**, no un tipo aparte. Una entrada sin `sites`
+//    sirve en cualquier parte; con `sites`, solo ahí. Eso vale para cualquier tipo de
+//    entrada, y así no hay dos reglas de emparejamiento que mantener.
+//
+// `kind` es opcional y solo sirve para el relleno automático: dice QUÉ ES el dato
+// (un correo, un teléfono), para poder ponerlo en el hueco que le corresponde. Sin
+// `kind`, el campo se guarda y se copia igual — solo no se rellena solo.
+
+/** Clases de dato que el relleno automático sabe colocar. */
+export const KINDS = [
+  'email', 'tel', 'given-name', 'family-name', 'full-name',
+  'street-address', 'city', 'region', 'postal-code', 'country',
+  'organization', 'birthday', 'id-number', 'other',
+]
+
+/** Tokens de `autocomplete` del estándar HTML. Cuando el sitio los declara, mandan. */
+export const AUTOCOMPLETE_BY_KIND = {
+  email: ['email'],
+  tel: ['tel', 'tel-national', 'tel-local'],
+  'given-name': ['given-name'],
+  'family-name': ['family-name'],
+  'full-name': ['name'],
+  'street-address': ['street-address', 'address-line1'],
+  city: ['address-level2'],
+  region: ['address-level1'],
+  'postal-code': ['postal-code'],
+  country: ['country', 'country-name'],
+  organization: ['organization'],
+  birthday: ['bday'],
+}
+
+/** Pistas por nombre/id/etiqueta, para los sitios que no declaran `autocomplete`. */
+export const HINTS_BY_KIND = {
+  email: ['email', 'correo', 'e-mail', 'mail'],
+  tel: ['phone', 'telefono', 'teléfono', 'celular', 'movil', 'móvil', 'mobile', 'tel'],
+  'given-name': ['firstname', 'first-name', 'first_name', 'givenname', 'nombre', 'nombres', 'fname'],
+  'family-name': ['lastname', 'last-name', 'last_name', 'surname', 'apellido', 'apellidos', 'lname'],
+  'full-name': ['fullname', 'full-name', 'nombrecompleto'],
+  'street-address': ['address', 'direccion', 'dirección', 'street', 'calle', 'domicilio'],
+  city: ['city', 'ciudad', 'localidad'],
+  region: ['state', 'province', 'provincia', 'region', 'estado'],
+  'postal-code': ['zip', 'zipcode', 'postal', 'postcode'],
+  country: ['country', 'pais', 'país'],
+  organization: ['company', 'empresa', 'organization', 'organizacion'],
+  'id-number': ['cedula', 'cédula', 'dni', 'nif', 'rut', 'curp', 'documento'],
+}
+
+/**
+ * Normaliza la lista de campos de una entrada.
+ *
+ * `private` marca lo que **solo sale de la bóveda con confirmación** (dueño,
+ * 2026-08-28). Es la distinción que ya existía entre lo público y lo privado de un
+ * registro, ahora dicha campo a campo: el teléfono que rellenas en veinte sitios no
+ * pide lo mismo que el número de tu documento.
+ */
+export function normalizeFields (fields) {
+  if (!Array.isArray(fields)) return []
+  return fields
+    .filter(f => f && (f.label || f.value))
+    .map(f => ({
+      label: String(f.label || '').trim(),
+      value: String(f.value ?? ''),
+      kind: KINDS.includes(f.kind) ? f.kind : undefined,
+      ...(f.private ? { private: true } : {}),
+    }))
+}
+
+/** ¿Esta entrada sirve en cualquier sitio? Sin sitios, sí. */
+export function isCrossDomain (entry) {
+  return !entry?.sites?.length
+}
+
+/** El primer campo de esa clase. */
+export function fieldOfKind (entry, kind) {
+  return (entry?.fields || []).find(f => f.kind === kind) || null
+}
+
+/** Un valor por etiqueta, para cuando se sabe qué se busca. */
+export function fieldValue (entry, label) {
+  const f = (entry?.fields || []).find(x => x.label === label)
+  return f ? f.value : ''
+}
+
+/**
+ * CÓMO SE LLAMA un campo para decir si dos son «el mismo».
+ *
+ * La clase si se reconoce, y si no la etiqueta que le puso el sitio. Vive aquí porque la
+ * usan las dos puntas —la página, al mirar un formulario, y la bóveda, al decir qué
+ * lleva una entrada— y dos ideas distintas de qué es el mismo campo serían un campo
+ * duplicado en cada guardado. Su gemela para el DOM está en `extension/src/detect.js`,
+ * que corre donde no llega esta librería; `offers.test.mjs` comprueba que dicen lo mismo.
+ */
+export function fieldKey (f = {}) {
+  if (f.kind) return f.kind
+  const l = String(f.label || '').trim()
+  return l ? `label:${l}` : 'other'
+}
+
+/**
+ * LO QUE NO SALE SIN AUTORIZACIÓN, pase lo que pase.
+ *
+ * La contraseña, el código de dos pasos, las notas y la llave de una passkey son privados
+ * por lo que son, no por una marca: nadie los guarda para enseñarlos. El resto de campos
+ * lo decide su marca `private` (§4.2), y el usuario es quien la pone al guardar.
+ *
+ * El **usuario** no está aquí a propósito: es el nombre visible de la entrada (§5), ya
+ * viaja en la vista pública, y pedir permiso para escribirlo en el formulario donde lo
+ * acabas de teclear no protege nada.
+ */
+export const ALWAYS_PRIVATE = ['secret', 'totp', 'notes', 'webauthn']
+
+/** Las claves privadas de una entrada abierta: las de arriba, más las marcadas. */
+export function privateKeysOf (open = {}) {
+  const out = new Set()
+  for (const k of ALWAYS_PRIVATE) if (open[k]) out.add(k)
+  const campos = (() => {
+    if (Array.isArray(open.fields)) return open.fields
+    try { return JSON.parse(open.fields || '[]') } catch { return [] }
+  })()
+  for (const f of campos) if (f?.private && f?.value) out.add(fieldKey(f))
+  return out
+}
+
+/**
+ * TODOS los campos de una entrada abierta, como pares `{ key, value }`.
+ *
+ * Es la lista canónica de «qué lleva dentro»: el usuario, la contraseña, el código de dos
+ * pasos y cada campo libre, **sin distinguir público de privado**. Esa distinción decide
+ * qué se ENSEÑA (§4.2), no qué existe, y mezclar las dos preguntas fue lo que hizo falta
+ * separar el 2026-08-29.
+ */
+export function entryFieldValues (open = {}) {
+  const out = []
+  const add = (key, value) => {
+    if (!value) return
+    if (out.some(f => f.key === key)) return
+    out.push({ key, value: String(value) })
+  }
+  add('username', open.username)
+  add('secret', open.secret)
+  add('totp', open.totp)
+  const campos = (() => {
+    if (Array.isArray(open.fields)) return open.fields
+    try { return JSON.parse(open.fields || '[]') } catch { return [] }
+  })()
+  for (const f of campos) if (f?.value) add(fieldKey(f), f.value)
+  return out
+}
+
+/**
+ * LO MISMO, MÁS LAS NOTAS. Solo para los resúmenes (§4.0.2).
+ *
+ * Las notas no están en `entryFieldValues` a propósito: eso es «qué se puede rellenar en
+ * un formulario», y una nota no se rellena en ninguna parte. Pero sí se **edita** en el
+ * gestor, y para decir ahí si lo escrito cambia algo hace falta su resumen como el de
+ * cualquier otro campo. Un método de comparación, no dos (dueño, 2026-08-29).
+ */
+export function entryDigestValues (open = {}) {
+  const out = entryFieldValues(open)
+  if (open.notes && !out.some(f => f.key === 'notes')) out.push({ key: 'notes', value: String(open.notes) })
+  return out
+}
+
+/**
+ * QUÉ CAMPOS lleva una entrada abierta, por su nombre y sin un solo valor.
+ *
+ * Es lo que permite ofrecer «rellenar el número de socio» sin abrir nada: lo calcula
+ * quien tiene la CEK y viaja en la vista pública (§4.0.2). Los NOMBRES no son los
+ * valores — de la misma familia que `sites`, que ya va en claro para poder emparejar con
+ * la página, y bastante menos que ellos.
+ */
+export function entryFieldKeys (open = {}) {
+  return entryFieldValues(open).map(f => f.key)
+}

package/vault/vendor/passmanager/generate.js

@@ -0,0 +1,74 @@
+// Generador de contraseñas.
+//
+// Un gestor que no genera contraseñas obliga a inventárselas, y ahí es donde la gente
+// repite la de siempre. Es parte del producto, no un extra.
+//
+// Toda la aleatoriedad sale de `crypto.getRandomValues`, y la elección de carácter se
+// hace SIN sesgo: `% alphabet.length` reparte de más los primeros caracteres cuando el
+// alphabet no divide a 256, y en un generador de contraseñas eso es exactamente lo que
+// no se quiere. Se descartan los valores que caen fuera del último bloque completo.
+
+const MINUS = 'abcdefghijkmnopqrstuvwxyz'    // sin la ele
+const MAYUS = 'ABCDEFGHJKLMNPQRSTUVWXYZ'     // sin la I ni la O
+const DIGITOS = '23456789'                   // sin el cero ni el uno
+const SIMBOLOS = '!#$%&*+-=?@_'
+const AMBIGUOS = 'lIO01'
+
+/** Un entero en [0, max) sin sesgo. */
+function randomBelow (max) {
+  const limite = Math.floor(256 / max) * max
+  const b = new Uint8Array(1)
+  for (;;) {
+    globalThis.crypto.getRandomValues(b)
+    if (b[0] < limite) return b[0] % max
+  }
+}
+
+function pick (alphabet) {
+  return alphabet[randomBelow(alphabet.length)]
+}
+
+/** Baraja en su sitio (Fisher-Yates), para que los obligatorios no queden al principio. */
+function shuffle (arr) {
+  for (let i = arr.length - 1; i > 0; i--) {
+    const j = randomBelow(i + 1)
+    ;[arr[i], arr[j]] = [arr[j], arr[i]]
+  }
+  return arr
+}
+
+/**
+ * @param {object} opts
+ *   `length`      size (por defecto 20)
+ *   `upper`/`digits`/`symbols`  incluir mayúsculas, números, símbolos
+ *   `ambiguous`   incluir los caracteres que se confunden al leer (l, I, O, 0, 1)
+ */
+export function generatePassword ({
+  length = 20, upper = true, digits = true, symbols = true, ambiguous = false,
+} = {}) {
+  const groups = [ambiguous ? MINUS + 'l' : MINUS]
+  if (upper) groups.push(ambiguous ? MAYUS + 'IO' : MAYUS)
+  if (digits) groups.push(ambiguous ? DIGITOS + '01' : DIGITOS)
+  if (symbols) groups.push(SIMBOLOS)
+
+  const alphabet = groups.join('')
+  const min = Math.max(groups.length, 4)
+  const size = Math.max(min, Math.min(256, Math.floor(length) || 20))
+
+  // Uno de cada grupo pedido, para que «con números» signifique que HAY un número y no
+  // que podría haberlo. El resto, del alphabet entero.
+  const chars = groups.map(g => pick(g))
+  while (chars.length < size) chars.push(pick(alphabet))
+  return shuffle(chars).join('')
+}
+
+/** Frase de varias palabras, más fácil de dictar o teclear a mano. */
+export function generatePassphrase (words, { count = 4, separator = '-' } = {}) {
+  if (!Array.isArray(words) || words.length < 16) {
+    throw new Error('generatePassphrase: hace falta una lista de palabras')
+  }
+  return Array.from({ length: Math.max(2, count) }, () => words[randomBelow(words.length)])
+    .join(separator)
+}
+
+export { AMBIGUOS }

package/vault/vendor/passmanager/import.js

@@ -0,0 +1,156 @@
+// Importar desde otros gestores. Sin esto nadie migra, por bueno que sea el resto
+// (DISENO §8, paso 1).
+//
+// Devuelve entradas EN CLARO, listas para `sealEntry`. Esta función no cifra ni
+// guarda: quien importa es quien tiene la CEK, y es él quien decide.
+
+import { normalizeSites } from './model.js'
+import { hostOf } from './match.js'
+
+/** CSV con comillas, comas y saltos de línea dentro de campo (RFC 4180). */
+export function parseCsv (text) {
+  const rows = []
+  let row = []
+  let field = ''
+  let quoted = false
+  const s = String(text || '').replace(/^/, '')
+
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i]
+    if (quoted) {
+      if (c === '"') {
+        if (s[i + 1] === '"') { field += '"'; i++ } else { quoted = false }
+      } else field += c
+      continue
+    }
+    if (c === '"') { quoted = true; continue }
+    if (c === ',') { row.push(field); field = ''; continue }
+    if (c === '\r') continue
+    if (c === '\n') { row.push(field); rows.push(row); row = []; field = ''; continue }
+    field += c
+  }
+  if (field !== '' || row.length) { row.push(field); rows.push(row) }
+  return rows.filter(r => r.some(v => v !== ''))
+}
+
+function csvObjects (text) {
+  const rows = parseCsv(text)
+  if (!rows.length) return []
+  const head = rows[0].map(h => h.trim().toLowerCase())
+  return rows.slice(1).map(r => {
+    const o = {}
+    head.forEach((h, i) => { o[h] = r[i] ?? '' })
+    return o
+  })
+}
+
+function sitesFrom (...urls) {
+  const out = []
+  for (const u of urls.flat()) {
+    const h = hostOf(u)
+    if (h) out.push(h)
+  }
+  return normalizeSites(out)
+}
+
+function entryFrom ({ title, sites, username, secret, totp, notes }) {
+  return {
+    type: 'login',
+    title: String(title || '').trim() || (sites[0] || 'sin nombre'),
+    sites,
+    username: String(username || ''),
+    secret: String(secret || ''),
+    totp: String(totp || ''),
+    notes: String(notes || ''),
+  }
+}
+
+/** Chrome / Edge: `name,url,username,password,note`. */
+export function fromChromeCsv (text) {
+  return csvObjects(text)
+    .map(o => entryFrom({
+      title: o.name,
+      sites: sitesFrom(o.url),
+      username: o.username,
+      secret: o.password,
+      notes: o.note || o.notes,
+    }))
+    .filter(e => e.secret || e.username)
+}
+
+/** 1Password: `Title,Url,Username,Password,OTPAuth,Favorite,Archived,Tags,Notes`. */
+export function from1PasswordCsv (text) {
+  return csvObjects(text)
+    .map(o => entryFrom({
+      title: o.title,
+      sites: sitesFrom(o.url, o.urls),
+      username: o.username,
+      secret: o.password,
+      totp: o.otpauth,
+      notes: o.notes,
+    }))
+    .filter(e => e.secret || e.username)
+}
+
+/** Bitwarden CSV (`login_uri`, `login_username`, `login_password`, `login_totp`). */
+export function fromBitwardenCsv (text) {
+  return csvObjects(text)
+    .filter(o => !o.type || o.type === 'login')
+    .map(o => entryFrom({
+      title: o.name,
+      sites: sitesFrom((o.login_uri || '').split(',')),
+      username: o.login_username,
+      secret: o.login_password,
+      totp: o.login_totp,
+      notes: o.notes,
+    }))
+    .filter(e => e.secret || e.username)
+}
+
+/** Bitwarden JSON (export sin cifrar). */
+export function fromBitwardenJson (json) {
+  const data = typeof json === 'string' ? JSON.parse(json) : json
+  if (data?.encrypted) {
+    const e = new Error('el export de Bitwarden está cifrado: expórtalo sin cifrar')
+    e.code = 'encrypted-export'
+    throw e
+  }
+  return (data?.items || [])
+    .filter(it => it.type === 1 && it.login)
+    .map(it => entryFrom({
+      title: it.name,
+      sites: sitesFrom((it.login.uris || []).map(u => u.uri)),
+      username: it.login.username,
+      secret: it.login.password,
+      totp: it.login.totp,
+      notes: it.notes,
+    }))
+}
+
+/**
+ * Detecta el formato por su cabecera y lo importa. Es lo que consume la UI: el
+ * usuario suelta el archivo y no tiene por qué saber qué formato es.
+ *
+ * `1pux` (el export nativo de 1Password) NO entra: es un zip. Se descomprime en la
+ * UI y se le pasa aquí el JSON de dentro.
+ */
+export function importAuto (text) {
+  const t = String(text || '').trim()
+  if (!t) return { format: 'vacío', entries: [] }
+
+  if (t.startsWith('{')) return { format: 'bitwarden-json', entries: fromBitwardenJson(t) }
+
+  const head = (parseCsv(t)[0] || []).map(h => h.trim().toLowerCase())
+  if (head.includes('login_password') || head.includes('login_username')) {
+    return { format: 'bitwarden-csv', entries: fromBitwardenCsv(t) }
+  }
+  if (head.includes('otpauth') || (head.includes('title') && head.includes('url'))) {
+    return { format: '1password-csv', entries: from1PasswordCsv(t) }
+  }
+  if (head.includes('name') && head.includes('url') && head.includes('password')) {
+    return { format: 'chrome-csv', entries: fromChromeCsv(t) }
+  }
+  const e = new Error('no reconozco el formato del archivo')
+  e.code = 'unknown-format'
+  throw e
+}

package/vault/vendor/passmanager/index.js

@@ -0,0 +1,27 @@
+export * from './crypto.js'
+export * from './model.js'
+export * from './match.js'
+export * from './fields.js'
+export * from './generate.js'
+// Los importadores son parte de la API: sin esto una app tenía que ir al subpath, y
+// eso se descubre cuando ya está escrito el import.
+export * from './import.js'
+export * from './pubkey.js'
+export * from './totp.js'
+export { LocalVault } from './vault/local.js'
+// Las contraseñas SELLADAS por aparato viven en `./sealed/` y se importan por su subpath
+// (`@dotrino/passmanager/sealed`), que es lo que arrastra la cripto de los sobres. Aquí solo
+// las dos puntas del protocolo, que es lo que cablea cada bóveda y cada aparato.
+export { SealedVault } from './vault/sealed.js'
+export { SealedResponder } from './vault/sealed-responder.js'
+export { SealedLocalVault } from './vault/sealed-local.js'
+export { SealedStore, SealedError } from './sealed/store.js'
+export { RemoteVault } from './vault/remote.js'
+export { VaultResponder } from './vault/responder.js'
+export { GuardedVault } from './vault/guard.js'
+export { ApprovalGate } from './vault/approval.js'
+export { SessionCache } from './session-cache.js'
+export { ProxyTransport } from './transport/proxy.js'
+export * from './transport/protocol.js'
+export * from './transport/sealed.js'
+export { VaultError, CODES } from './vault/errors.js'