@dotrino/identity 0.104.1 → 0.104.2

package/package.json

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

package/vault/nativeStore.js

@@ -79,83 +79,3 @@ export async function nativeBackends (bridge) {
   return { kv, keyStore, peers, flush: () => chain }
 }
 
-const PROFILES = 'dotrino.identity.profiles'
-const CURRENT = 'dotrino.identity.current'
-const scopedKey = (pid, k) => `dotrino.identity.p.${pid}.${k}`
-
-/**
- * LOS PERFILES QUE SE QUEDARON EN LA PÁGINA pasan a la app (dueño, 2026-09-26: «todas las
- * pestañas usan el mismo perfil, pero NO es el de Dotrino que está en Pedidos»).
- *
- * Antes de `nativeStore` cada página guardaba la identidad aparte, así que la cuenta que se
- * emparejó en `vault.dotrino.com/d` quedó en el almacén de ESA página: su llave está en el
- * chip (Pedidos la usa), pero su acta, su papel y su nombre no llegaron a la app, y la app
- * estrenó un perfil vacío. Esto la trae.
- *
- * Solo se trae un perfil cuya llave VIVE en el chip (`open` contesta): uno de software no
- * cabe, y uno cuya llave ya se borró no sirve para nada. Lo que la app ya tiene no se pisa.
- * Y si el perfil activo de la app no está emparejado y el traído sí, pasa a ser el activo:
- * el vacío se inventó justo porque faltaba este.
- *
- * `page`: lo que hay en el almacén de ESTA página — `kv` (entradas del localStorage),
- * `keys` (registros del IndexedDB de llaves) y `peers` (libros de contactos).
- */
-export async function adoptPageProfiles (native, bridge, page) {
-  const mine = JSON.parse(native.kv.getItem(PROFILES) || '[]')
-  const theirs = JSON.parse(page.kv.get(PROFILES) || '[]')
-  const adopted = []
-  for (const p of theirs) {
-    if (!p?.id || mine.some((m) => m.id === p.id)) continue
-    const sign = page.keys.get(scopedKey(p.id, 'keypair'))
-    const enc = page.keys.get(scopedKey(p.id, 'enc-keypair'))
-    if (!sign?.external) continue
-    try { await bridge.call('open', { kid: sign.external }) } catch (_) { continue }
-    const prefix = `dotrino.identity.p.${p.id}.`
-    for (const [k, v] of page.kv) if (k.startsWith(prefix)) native.kv.setItem(k, v)
-    await native.keyStore.set(scopedKey(p.id, 'keypair'), sign)
-    if (enc?.external) await native.keyStore.set(scopedKey(p.id, 'enc-keypair'), enc)
-    const book = page.peers.get(`peers.${p.id}.v1`)
-    if (book) await native.peers.put(`peers.${p.id}.v1`, book)
-    mine.push(p)
-    adopted.push(p.id)
-  }
-  if (!adopted.length) return adopted
-  native.kv.setItem(PROFILES, JSON.stringify(mine))
-  const cur = native.kv.getItem(CURRENT)
-  const paired = (pid) => !!native.kv.getItem(scopedKey(pid, 'vault.cert'))
-  if (!cur || !paired(cur)) {
-    const next = adopted.find(paired)
-    if (next) native.kv.setItem(CURRENT, next)
-  }
-  console.info(`[cc-identity] adopted ${adopted.length} profile(s) from this page's storage into the app: ${adopted.join(', ')}`)
-  return adopted
-}
-
-/** Todo lo que la identidad guardó en el almacén de ESTA página (localStorage + sus dos IndexedDB). */
-export async function readPageStorage () {
-  const kv = new Map()
-  for (let i = 0; i < localStorage.length; i++) {
-    const k = localStorage.key(i)
-    if (k && k.startsWith('dotrino.identity.')) kv.set(k, localStorage.getItem(k))
-  }
-  return { kv, keys: await idbAll('dotrino-identity-keys', 'keys'), peers: await idbAll('cc-identity', 'kv') }
-}
-
-function idbAll (dbName, store) {
-  return new Promise((resolve, reject) => {
-    const req = indexedDB.open(dbName)
-    req.onupgradeneeded = () => { if (!req.result.objectStoreNames.contains(store)) req.result.createObjectStore(store) }
-    req.onerror = () => reject(req.error)
-    req.onsuccess = () => {
-      const db = req.result
-      if (!db.objectStoreNames.contains(store)) { db.close(); resolve(new Map()); return }
-      const out = new Map()
-      const cur = db.transaction(store, 'readonly').objectStore(store).openCursor()
-      cur.onsuccess = () => {
-        const c = cur.result
-        if (c) { out.set(String(c.key), c.value); c.continue() } else { db.close(); resolve(out) }
-      }
-      cur.onerror = () => reject(cur.error)
-    }
-  })
-}

package/vault/vault.js

@@ -15,7 +15,7 @@ import {
 import { createIdentityCore } from './core.js'
 import { pubkeyId } from './capabilities.js'
 import { withExternalKeys, appBridge } from './externalKeys.js'
-import { nativeBackends, adoptPageProfiles, readPageStorage } from './nativeStore.js'
+import { nativeBackends } from './nativeStore.js'
 import { useBackend as usePeerBackend } from './peerStore.js'
 
 ;(async () => {
@@ -25,14 +25,7 @@ import { useBackend as usePeerBackend } from './peerStore.js'
   // Y si la app GUARDA la identidad (`storage`, la de iOS): todo vive allí, uno para todas
   // las páginas, porque WebKit parte el almacén de este iframe por página (`./nativeStore.js`).
   const native = bridge && idKeys.storage === true ? await nativeBackends(bridge) : null
-  if (native) {
-    usePeerBackend(native.peers)
-    // Lo que se emparejó cuando la identidad aún vivía en la página, a la app. Si no se puede
-    // leer el almacén de la página se dice (con su error) y se sigue: la identidad de la app
-    // funciona igual, solo que sin ese perfil.
-    try { await adoptPageProfiles(native, bridge, await readPageStorage()) }
-    catch (e) { console.error('[cc-identity] could not bring this page\'s profiles into the app:', e?.message || e) }
-  }
+  if (native) usePeerBackend(native.peers)
 
   // kv estilo localStorage (síncrono) para me, nonces, delegaciones, certs.
   const kv = native ? native.kv : {