@dotrino/identity 0.114.1 → 0.116.0

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'

package/vault/vendor/passmanager/match.js

@@ -0,0 +1,137 @@
+// Emparejamiento de una entrada con el sitio que el usuario tiene delante.
+//
+// Es la pieza de la que depende la seguridad del autocompletado: emparejar de más
+// entrega una credencial al sitio equivocado. Por eso todo se compara por ETIQUETAS
+// de dominio, nunca por sufijo de cadena — `evil-salesforce.com` termina en
+// `salesforce.com` como texto y no tiene nada que ver con él.
+
+// Sufijos públicos de dos etiquetas más comunes. NO es la Public Suffix List entera
+// (son miles de reglas y varios cientos de KB); es la aproximación que cubre el caso
+// real. Deuda anotada: cargar la PSL de verdad cuando el autocompletado esté maduro.
+// Mientras tanto un sufijo desconocido solo hace el emparejamiento MÁS estricto, que
+// es el lado seguro por el que fallar.
+const TWO_LABEL_SUFFIXES = new Set([
+  'co.uk', 'org.uk', 'ac.uk', 'gov.uk', 'me.uk', 'net.uk', 'sch.uk',
+  'com.au', 'net.au', 'org.au', 'edu.au', 'gov.au', 'id.au',
+  'com.br', 'net.br', 'org.br', 'gov.br',
+  'com.ec', 'net.ec', 'org.ec', 'gob.ec', 'edu.ec', 'fin.ec', 'med.ec',
+  'com.ar', 'net.ar', 'org.ar', 'gob.ar', 'edu.ar',
+  'com.mx', 'net.mx', 'org.mx', 'gob.mx', 'edu.mx',
+  'com.co', 'net.co', 'org.co', 'gov.co', 'edu.co',
+  'co.jp', 'ne.jp', 'or.jp', 'ac.jp', 'go.jp',
+  'com.cn', 'net.cn', 'org.cn', 'gov.cn', 'edu.cn',
+  'co.nz', 'net.nz', 'org.nz', 'govt.nz',
+  'co.za', 'org.za', 'net.za',
+  'com.tr', 'com.tw', 'com.hk', 'com.sg', 'com.my', 'com.pe', 'com.uy',
+  'com.ve', 'com.py', 'com.bo', 'com.do', 'com.gt', 'com.pa', 'com.pl',
+  'com.es', 'com.pt', 'com.ua', 'com.ru', 'com.vn', 'com.ph',
+])
+
+/** Extrae el host de una URL o de algo que ya es un host. Devuelve '' si no vale. */
+export function hostOf (input) {
+  if (typeof input !== 'string') return ''
+  let s = input.trim().toLowerCase()
+  if (!s) return ''
+  if (!s.includes('://')) s = 'https://' + s
+  let u
+  try { u = new URL(s) } catch { return '' }
+  // Solo esquemas web: un `javascript:` o un `file:` no tienen sitio con el que emparejar.
+  if (u.protocol !== 'https:' && u.protocol !== 'http:') return ''
+  return u.hostname.replace(/\.$/, '')
+}
+
+/** Dominio registrable (eTLD+1 aproximado). Para una IP o un host raro, el host tal cual. */
+export function registrableDomain (host) {
+  if (!host) return ''
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(host) || host.includes(':')) return host
+  const parts = host.split('.')
+  if (parts.length <= 2) return host
+  const lastTwo = parts.slice(-2).join('.')
+  if (TWO_LABEL_SUFFIXES.has(lastTwo)) return parts.slice(-3).join('.')
+  return lastTwo
+}
+
+/** ¿`host` es igual a `base` o un subdominio suyo? Compara por etiquetas. */
+export function isSameOrSubdomainOf (host, base) {
+  if (!host || !base) return false
+  if (host === base) return true
+  return host.endsWith('.' + base)
+}
+
+export const MATCH = {
+  EXACT: 3,
+  SUBDOMAIN: 2,
+  /** Sin sitios: sirve en cualquier parte, y por eso va la última. */
+  ANY: 0.5,
+  NONE: 0,
+}
+
+// `DOMAIN` (mismo dominio registrable) EXISTIÓ y se quitó el 2026-08-29, porque hacía
+// justo lo que un gestor de contraseñas no puede hacer: con `pass.dotrino.com` guardado,
+// `r.dotrino.com` recibía sus credenciales — dos servicios distintos que solo comparten
+// el dominio de arriba (lo vio el dueño: *«en r.dotrino.com me salen records de
+// pass.dotrino.com»*).
+//
+// Se puso para el caso «el subdominio cambió y la clave es la misma», pero para eso no
+// hacía falta: guardar el dominio a secas (`empresa.com`) YA cubre todos sus subdominios
+// por la vía de SUBDOMAIN, y traerse la cuenta de otro dominio ya tiene su camino
+// explícito —buscarla (§4.1)—, que además lo decide una persona en vez de la máquina.
+//
+// Lo único que aportaba era el sentido contrario: un subdominio GUARDADO emparejando con
+// sus hermanos y con el dominio padre. Y ese sentido es exactamente la fuga.
+
+/**
+ * Compara UN patrón de `sites` con el host actual.
+ * Patrones admitidos: `ejemplo.com`, `*.ejemplo.com`, o una URL entera.
+ *
+ * Un patrón cubre **el host y lo que cuelga de él**, nunca hacia arriba ni hacia los
+ * lados: `empresa.com` vale en `login.empresa.com`, pero `login.empresa.com` NO vale en
+ * `otra.empresa.com`. Por eso el comodín casi nunca hace falta — un dominio a secas ya
+ * trae sus subdominios— y por eso `*.x` y `x` cubren hoy lo mismo.
+ */
+export function matchSite (pattern, currentHost) {
+  if (!currentHost) return MATCH.NONE
+  let p = String(pattern || '').trim().toLowerCase()
+  if (!p) return MATCH.NONE
+
+  let wildcard = false
+  if (p.startsWith('*.')) { wildcard = true; p = p.slice(2) }
+
+  const base = hostOf(p)
+  if (!base) return MATCH.NONE
+
+  if (wildcard) return isSameOrSubdomainOf(currentHost, base) ? MATCH.SUBDOMAIN : MATCH.NONE
+  if (currentHost === base) return MATCH.EXACT
+  if (isSameOrSubdomainOf(currentHost, base)) return MATCH.SUBDOMAIN
+  // Y nada más. Un hermano NO empareja: ver la nota de `MATCH`.
+  return MATCH.NONE
+}
+
+/**
+ * Mejor nivel de emparejamiento de una entrada con la URL actual.
+ *
+ * **Una entrada SIN sitios sirve en cualquier parte.** Es como se dice «esto no es de
+ * un dominio»: el correo o la cédula valen en todas partes, la contraseña del banco
+ * no. No hace falta un tipo aparte para eso, y así hay una sola regla que mantener.
+ * Empareja siempre por debajo de lo que sí es de este sitio.
+ */
+export function matchEntry (entry, url) {
+  const host = hostOf(url)
+  if (!host) return MATCH.NONE
+  if (!entry?.sites?.length) return MATCH.ANY
+  let best = MATCH.NONE
+  for (const s of entry?.sites || []) {
+    const m = matchSite(s, host)
+    if (m > best) best = m
+    if (best === MATCH.EXACT) break
+  }
+  return best
+}
+
+/** Entradas que sirven para esta URL, de mejor a peor emparejamiento. */
+export function findForUrl (entries, url) {
+  return (entries || [])
+    .map(e => ({ entry: e, match: matchEntry(e, url) }))
+    .filter(x => x.match > MATCH.NONE)
+    .sort((a, b) => b.match - a.match || (b.entry.updatedAt || 0) - (a.entry.updatedAt || 0))
+}