@nyx5/nyx5 0.6.0 → 0.8.0

package/src/nucleo/almacen.js

@@ -15,6 +15,7 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
+import { filaDeIndice, buscarEnMemoria } from '../correo/indice.js';
 
 const readJson = (p, fallback = null) => (fs.existsSync(p) ? JSON.parse(fs.readFileSync(p, 'utf8')) : fallback);
 const writeJson = (p, v) => {
@@ -27,7 +28,7 @@ const writeJson = (p, v) => {
 export class FileStore {
   constructor(dir) {
     this.dir = dir;
-    for (const d of ['agents', 'mailbox', 'queue', 'outbox', 'invitations', 'libro/diario', 'libro/contratos', 'libro/mandatos', 'libro/ops', 'eventos', 'indice/casas', 'indice/agentes']) fs.mkdirSync(path.join(dir, d), { recursive: true });
+    for (const d of ['agents', 'mailbox', 'queue', 'outbox', 'invitations', 'libro/diario', 'libro/contratos', 'libro/mandatos', 'libro/ops', 'libro/notaria', 'eventos', 'indice/casas', 'indice/agentes']) fs.mkdirSync(path.join(dir, d), { recursive: true });
     this.nonces = new Map(); // anti-replay: en FileStore basta memoria (un proceso)
   }
 
@@ -87,6 +88,15 @@ export class FileStore {
     fs.renameSync(p, archived);
     return true;
   }
+  // Historial: lo pendiente y lo ya confirmado (archivado), en orden de llegada, los últimos N.
+  listMailHistory(local, { limit = 200 } = {}) {
+    const leer = (d) => (fs.existsSync(d) ? fs.readdirSync(d).filter((f) => f.endsWith('.json')).map((f) => readJson(path.join(d, f))) : []);
+    const vivos = leer(path.join(this.dir, 'mailbox', local));
+    const archivados = leer(path.join(this.dir, 'archive', local)).map((m) => ({ ...m, acked: m.acked || true }));
+    return [...vivos, ...archivados].sort((a, b) => String(a.received).localeCompare(String(b.received))).slice(-limit);
+  }
+  // Lo pendiente que llegó después de un momento dado (la espera en tiempo real pregunta esto).
+  listMailSince(local, sinceIso) { return this.listMail(local).filter((m) => !sinceIso || String(m.received) > sinceIso); }
 
   // --- cola de salida (store-and-forward) ---
   enqueue(job) { writeJson(path.join(this.dir, 'queue', `${job.id}.json`), job); }
@@ -112,6 +122,64 @@ export class FileStore {
     return fs.readdirSync(dir).filter((f) => f.endsWith('.json')).map((f) => readJson(path.join(dir, f)));
   }
 
+  // --- kv con vencimiento: clientes OAuth, códigos de un uso, tokens (hash) y la bóveda ---
+  _kvPath(ns, key) { return path.join(this.dir, 'kv', ns, `${encodeURIComponent(key)}.json`); }
+  kvGet(ns, key, nowMs = Date.now()) {
+    const r = readJson(this._kvPath(ns, key));
+    if (!r || (r.expires != null && r.expires <= nowMs)) return null;
+    return r.doc;
+  }
+  kvPut(ns, key, doc, expires = null) { writeJson(this._kvPath(ns, key), { doc, expires, created: new Date().toISOString() }); }
+  kvPutIfAbsent(ns, key, doc, expires = null, nowMs = Date.now()) {
+    if (this.kvGet(ns, key, nowMs) !== null) return false;
+    this.kvPut(ns, key, doc, expires);
+    return true;
+  }
+  // Tomar y borrar en un paso: un código de autorización se usa UNA vez.
+  kvTake(ns, key, nowMs = Date.now()) {
+    const p = this._kvPath(ns, key);
+    const r = readJson(p);
+    if (!r) return null;
+    fs.unlinkSync(p);
+    return (r.expires != null && r.expires <= nowMs) ? null : r.doc;
+  }
+  // Contador atómico con vencimiento (límites de tasa durables). Suma `by` (1 por defecto; los
+  // bytes de un cupo diario, por ejemplo). Un contador vencido arranca en `by`.
+  kvIncrement(ns, key, expires = null, nowMs = Date.now(), by = 1) {
+    const n = (Number(this.kvGet(ns, key, nowMs)) || 0) + by;
+    this.kvPut(ns, key, n, expires);
+    return n;
+  }
+  kvDelete(ns, key) { const p = this._kvPath(ns, key); if (fs.existsSync(p)) fs.unlinkSync(p); }
+  // Las claves vivas de un espacio que empiezan por `prefix`, en orden de clave: [{ key, doc }].
+  // Nació para el registro de ideas@ (una fila por idea, clave con el número relleno de ceros).
+  // `after`: sólo claves estrictamente mayores (paginación por clave).
+  kvList(ns, { prefix = '', limit = 1000, after } = {}, nowMs = Date.now()) {
+    const dir = path.join(this.dir, 'kv', ns);
+    if (!fs.existsSync(dir)) return [];
+    const out = [];
+    const claves = fs.readdirSync(dir).filter((f) => f.endsWith('.json')).map((f) => [decodeURIComponent(f.slice(0, -5)), f]).sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
+    for (const [key, f] of claves) {
+      if (!key.startsWith(prefix) || (after != null && !(key > after))) continue;
+      const r = readJson(path.join(dir, f));
+      if (!r || (r.expires != null && r.expires <= nowMs)) continue;
+      out.push({ key, doc: r.doc });
+      if (out.length >= limit) break;
+    }
+    return out;
+  }
+  kvPurge(nowMs = Date.now()) {
+    const raiz = path.join(this.dir, 'kv');
+    if (!fs.existsSync(raiz)) return;
+    for (const ns of fs.readdirSync(raiz)) {
+      for (const f of fs.readdirSync(path.join(raiz, ns))) {
+        const p = path.join(raiz, ns, f);
+        const r = readJson(p);
+        if (r?.expires != null && r.expires <= nowMs) fs.unlinkSync(p);
+      }
+    }
+  }
+
   // --- anti-replay de tokens de auth ---
   useNonce(key, tsMs) {
     if (this.nonces.has(key)) return false;
@@ -144,13 +212,39 @@ export class FileStore {
   }
   libroGetContract(id) { return readJson(path.join(this.dir, 'libro', 'contratos', `${id}.json`)); }
   libroPutContract(c) { writeJson(path.join(this.dir, 'libro', 'contratos', `${c.id}.json`), c); }
-  libroListContracts() { const d = path.join(this.dir, 'libro', 'contratos'); return fs.readdirSync(d).filter((f) => f.endsWith('.json')).map((f) => readJson(path.join(d, f))); }
+  // `state`: un estado o una lista de estados. Sin filtro devuelve todos. Los recorridos del reloj
+  // (verifica@, escrow que vence) piden sólo held/delivered: la tabla entera crecía con cada
+  // contrato cerrado y se leía completa en cada tick (revisión del 14-sep).
+  libroListContracts({ state = null } = {}) {
+    const d = path.join(this.dir, 'libro', 'contratos');
+    const todos = fs.readdirSync(d).filter((f) => f.endsWith('.json')).map((f) => readJson(path.join(d, f)));
+    if (state == null) return todos;
+    const estados = Array.isArray(state) ? state : [state];
+    return todos.filter((c) => estados.includes(c.state));
+  }
   libroFindContractByQuote(quoteId) { return this.libroListContracts().find((c) => c.quote_id === quoteId) || null; }
   libroGetMandate(id) { return readJson(path.join(this.dir, 'libro', 'mandatos', `${id}.json`)); }
   libroPutMandate(m) { writeJson(path.join(this.dir, 'libro', 'mandatos', `${m.id}.json`), m); }
   libroListMandates() { const d = path.join(this.dir, 'libro', 'mandatos'); return fs.readdirSync(d).filter((f) => f.endsWith('.json')).map((f) => readJson(path.join(d, f))); }
   libroGetOp(id) { return readJson(path.join(this.dir, 'libro', 'ops', `${id}.json`)); }
   libroPutOp(id, v) { writeJson(path.join(this.dir, 'libro', 'ops', `${id}.json`), v); }
+
+  // --- notaría (NX-601): sellos de hash. Un archivo por sello; la lectura por hash recorre el
+  // directorio (FileStore es para pruebas y desarrollo; en D1 lo sirve el índice).
+  notariaGet(id) { return readJson(path.join(this.dir, 'libro', 'notaria', `${id}.json`)); }
+  _notariaTodos() { const d = path.join(this.dir, 'libro', 'notaria'); return fs.readdirSync(d).filter((f) => f.endsWith('.json')).map((f) => readJson(path.join(d, f))); }
+  notariaList(sha256) { return this._notariaTodos().filter((s) => s.sha256 === sha256).sort((a, b) => (a.at < b.at ? -1 : a.at > b.at ? 1 : 0)); }
+  notariaFind(sha256, by) { return this._notariaTodos().find((s) => s.sha256 === sha256 && s.by === by) || null; }
+  // Mismo candado que el índice único de D1: un segundo sello del mismo agente para el mismo hash
+  // falla cerrado con 421 (reintentable), así FileStore no es más permisivo que producción.
+  notariaPut(s) {
+    if (this.notariaFind(s.sha256, s.by)) {
+      const e = new Error(`ledger concurrency conflict: seal already exists for ${s.sha256} by ${s.by}`);
+      e.code = 421; e.transient = true;
+      throw e;
+    }
+    writeJson(path.join(this.dir, 'libro', 'notaria', `${s.id}.json`), s);
+  }
   // ---------- instrumentación (nombre, fecha, actor y números; nunca contenido) ----------
   putEvent(e) { writeJson(path.join(this.dir, 'eventos', `${e.id}.json`), e); }
   listEvents({ name = null, since = null, limit = 500 } = {}) {
@@ -160,8 +254,20 @@ export class FileStore {
       .filter((e) => e && (!name || e.name === name) && (!since || e.ts >= since))
       .sort((a, b) => (a.ts < b.ts ? -1 : 1)).slice(-limit);
   }
-  libroStatement(account, limit) {
-    return this.libroJournal().filter((a) => a.lines.some((l) => l.account === account)).slice(-limit);
+  // Extracto por cuenta en el rango [since, until) sobre `at` (ISO ya normalizado por quien
+  // llama, ver estado.js): los `limit` asientos MÁS RECIENTES del rango, y `total` = cuántos hay
+  // en el rango, se muestren o no (el denominador viaja con el resultado).
+  libroStatementRange(account, { since = null, until = null, limit = 20 } = {}) {
+    const todos = this.libroJournal().filter((a) => a.lines.some((l) => l.account === account) && (!since || a.at >= since) && (!until || a.at < until));
+    return { entries: todos.slice(-limit), total: todos.length };
+  }
+  libroStatement(account, limit) { return this.libroStatementRange(account, { limit }).entries; }
+  // Saldo de una cuenta ANTES del asiento `n` y/o de la fecha `at`: la suma de sus deltas hasta
+  // ahí, leída del diario y no de saldos.json, para que un extracto cuadre por sí mismo.
+  libroBalanceBefore(account, { n = null, at = null } = {}) {
+    return this.libroJournal()
+      .filter((a) => (n == null || a.n < n) && (at == null || a.at < at))
+      .reduce((s, a) => s + a.lines.filter((l) => l.account === account).reduce((t, l) => t + l.delta, 0), 0);
   }
 
   // Un movimiento completo del Libro, junto. En D1: un batch atómico donde el PK del asiento (n)
@@ -183,6 +289,7 @@ export class FileStore {
     if (bundle.state) this.libroPutState(bundle.state);
     for (const c of bundle.contracts || []) this.libroPutContract(c);
     for (const m of bundle.mandates || []) this.libroPutMandate(m);
+    for (const s of bundle.sellos || []) this.notariaPut(s);
     if (bundle.op) this.libroPutOp(bundle.op.id, bundle.op.result);
   }
 
@@ -198,15 +305,32 @@ export class FileStore {
   indexGetHouse(domain) { return readJson(path.join(this.dir, 'indice', 'casas', `${domain}.json`)); }
   indexPutHouse(h) { writeJson(path.join(this.dir, 'indice', 'casas', `${h.domain}.json`), h); }
   indexListHouses() { const d = path.join(this.dir, 'indice', 'casas'); return fs.readdirSync(d).filter((f) => f.endsWith('.json')).map((f) => readJson(path.join(d, f))); }
-  indexReplaceAgents(domain, cards) { writeJson(path.join(this.dir, 'indice', 'agentes', `${domain}.json`), { domain, cards, updated: new Date().toISOString() }); }
-  indexSearch({ q, capability, accepts, house, limit = 50, offset = 0 } = {}) {
+  // Cada casa rastreada es un archivo con FILAS: la tarjeta (doc) más las columnas que el índice
+  // extrae de ella (indice.js) y la generación, para que un recorrido por cursor sobrevida a un
+  // rastreo que cambie los puntajes (ver la cabecera de src/correo/indice.js).
+  indexReplaceAgents(domain, cards) {
+    const archivo = path.join(this.dir, 'indice', 'agentes', `${domain}.json`);
+    const previo = new Map(this._indexRows(domain).map((r) => [r.address, r]));
+    const gen = this._indexGen() + 1;
+    const rows = cards.map((c) => filaDeIndice(domain, c, gen, previo.get(c.address) || null));
+    writeJson(archivo, { domain, gen, rows, updated: new Date().toISOString() });
+  }
+  _indexRows(domain) {
+    const f = readJson(path.join(this.dir, 'indice', 'agentes', `${domain}.json`));
+    if (!f) return [];
+    // Archivo del formato anterior (sólo tarjetas): filas sin columnas ni generación.
+    if (!f.rows && Array.isArray(f.cards)) return f.cards.map((c) => filaDeIndice(domain, c, 0, null));
+    return f.rows || [];
+  }
+  _indexGen() {
+    const d = path.join(this.dir, 'indice', 'agentes');
+    return fs.readdirSync(d).filter((f) => f.endsWith('.json')).reduce((m, f) => Math.max(m, readJson(path.join(d, f))?.gen || 0), 0);
+  }
+  indexSearch(f = {}) {
     const d = path.join(this.dir, 'indice', 'agentes');
-    let cards = fs.readdirSync(d).filter((f) => f.endsWith('.json'))
-      .filter((f) => !house || f === `${house}.json`)
-      .flatMap((f) => (readJson(path.join(d, f))?.cards || []));
-    if (capability) cards = cards.filter((c) => c.capabilities?.[capability]);
-    if (accepts) cards = cards.filter((c) => c.capabilities?.accepts?.includes(accepts));
-    if (q) { const needle = String(q).toLowerCase(); cards = cards.filter((c) => c.address.includes(needle) || JSON.stringify(c.capabilities || {}).toLowerCase().includes(needle)); }
-    return { total: cards.length, offset, agents: cards.slice(offset, offset + limit) };
+    const filas = fs.readdirSync(d).filter((x) => x.endsWith('.json'))
+      .filter((x) => !f.house || x === `${f.house}.json`)
+      .flatMap((x) => this._indexRows(x.slice(0, -5)));
+    return buscarEnMemoria(filas, f);
   }
 }

package/src/nucleo/boveda.js

@@ -0,0 +1,37 @@
+// Nyx5/1 — La bóveda: las llaves de los subagentes delegados que la casa guarda para que un
+// conector remoto (el Claude de un teléfono) pueda firmar en nombre de ese subagente.
+//
+// Qué se guarda aquí y qué NO: sólo llaves de subagentes `claude.<dueño>@<casa>`, de alcance
+// limitado a mensajes, con vencimiento y revocables por el dueño. La llave raíz de una persona
+// nunca pasa por la casa: vive en su navegador y es la que firma la delegación.
+//
+// Cifrado en reposo con AES-256-GCM y una llave que vive SÓLO en un secret del Worker
+// (NYX5_VAULT_KEY). Un volcado de la base no entrega ninguna llave. La AAD amarra cada sello a
+// su dueño: una fila copiada bajo otro nombre no abre.
+import { createCipheriv, createDecipheriv, randomBytes } from 'node:crypto';
+import { b64u, unb64u } from './crypto.js';
+
+const AAD = (dueno) => Buffer.from(`nyx5/1 boveda ${dueno}`);
+
+export function abrirBoveda(secreto) {
+  if (!secreto) return null;
+  const llave = Buffer.from(String(secreto).trim(), 'base64');
+  if (llave.length !== 32) throw new Error('NYX5_VAULT_KEY must be exactly 32 bytes, base64-encoded');
+  return {
+    sellar(obj, dueno) {
+      const iv = randomBytes(12);
+      const c = createCipheriv('aes-256-gcm', llave, iv);
+      c.setAAD(AAD(dueno));
+      const ct = Buffer.concat([c.update(Buffer.from(JSON.stringify(obj))), c.final()]);
+      return `v1.${b64u(iv)}.${b64u(ct)}.${b64u(c.getAuthTag())}`;
+    },
+    abrir(sello, dueno) {
+      const [v, iv, ct, tag] = String(sello).split('.');
+      if (v !== 'v1' || !iv || !ct || !tag) throw new Error('unreadable vault seal');
+      const d = createDecipheriv('aes-256-gcm', llave, unb64u(iv));
+      d.setAAD(AAD(dueno));
+      d.setAuthTag(unb64u(tag));
+      return JSON.parse(Buffer.concat([d.update(unb64u(ct)), d.final()]).toString());
+    },
+  };
+}

package/src/nucleo/crypto.js

@@ -8,7 +8,7 @@
 import {
   generateKeyPairSync, createPrivateKey, createPublicKey,
   sign as nodeSign, verify as nodeVerify,
-  randomBytes, randomUUID, createHash, diffieHellman, hkdfSync,
+  randomBytes, randomUUID, createHash, hkdfSync,
   createCipheriv, createDecipheriv,
 } from 'node:crypto';
 
@@ -40,8 +40,18 @@ export function generateKeys() {
 
 const sigPrivateKey = (d, x) => createPrivateKey({ key: { kty: 'OKP', crv: 'Ed25519', d, x }, format: 'jwk' });
 const sigPublicKey = (x) => createPublicKey({ key: { kty: 'OKP', crv: 'Ed25519', x }, format: 'jwk' });
-const encPrivateKey = (d, x) => createPrivateKey({ key: { kty: 'OKP', crv: 'X25519', d, x }, format: 'jwk' });
-const encPublicKey = (x) => createPublicKey({ key: { kty: 'OKP', crv: 'X25519', x }, format: 'jwk' });
+// El acuerdo de claves X25519 va por WebCrypto, NO por node:crypto. Medido el 10-sep-2026 en el
+// runtime real de Cloudflare (workerd, scripts/sonda-workerd.mjs): `diffieHellman` no existe allá,
+// ni con objetos de llave ni desde JWK, mientras que `crypto.subtle` X25519 sí, e importa las
+// mismas JWK que genera Node. En Node y en los tests todo andaba: el defecto sólo se veía cuando
+// el edge mismo cifraba, que es justo lo que hace el conector remoto. El secreto es el mismo
+// (X25519 es estándar), así que el formato de los sobres no cambia y lo cifrado antes se abre igual.
+async function x25519(d, x, publico) {
+  const s = globalThis.crypto.subtle;
+  const priv = await s.importKey('jwk', { kty: 'OKP', crv: 'X25519', x, d }, { name: 'X25519' }, false, ['deriveBits']);
+  const pub = await s.importKey('jwk', { kty: 'OKP', crv: 'X25519', x: publico }, { name: 'X25519' }, true, []);
+  return Buffer.from(await s.deriveBits({ name: 'X25519', public: pub }, priv, 256));
+}
 
 // ---------- Firma de objetos ----------
 // Firma todo el objeto menos el campo indicado (por defecto "signature").
@@ -77,7 +87,7 @@ export function verifyBytes(data, signature, pub) {
 // El AAD amarra el cifrado al sobre (id/from/to) para impedir reenvíos con otro remitente.
 const INFO = Buffer.from('nyx5/1 cek-wrap');
 
-export function encryptContent(content, recipients, aad) {
+export async function encryptContent(content, recipients, aad) {
   const cek = randomBytes(32);
   const iv = randomBytes(12);
   const cipher = createCipheriv('aes-256-gcm', cek, iv);
@@ -85,11 +95,11 @@ export function encryptContent(content, recipients, aad) {
   const ct = Buffer.concat([cipher.update(Buffer.from(JSON.stringify(content))), cipher.final()]);
   const tag = cipher.getAuthTag();
 
-  const eph = generateKeyPairSync('x25519');
-  const epk = eph.publicKey.export({ format: 'jwk' }).x;
+  const eph = generateKeyPairSync('x25519').privateKey.export({ format: 'jwk' });
+  const epk = eph.x;
   const keys = {};
   for (const r of recipients) {
-    const shared = diffieHellman({ privateKey: eph.privateKey, publicKey: encPublicKey(r.enc) });
+    const shared = await x25519(eph.d, eph.x, r.enc);
     const kek = Buffer.from(hkdfSync('sha256', shared, Buffer.from(epk), INFO, 32));
     const wiv = randomBytes(12);
     const c = createCipheriv('aes-256-gcm', kek, wiv);
@@ -99,13 +109,10 @@ export function encryptContent(content, recipients, aad) {
   return { alg: 'X25519+HKDF-SHA256+A256GCM', epk, iv: b64u(iv), ct: b64u(ct), tag: b64u(tag), keys };
 }
 
-export function decryptContent(encrypted, address, keys, aad) {
+export async function decryptContent(encrypted, address, keys, aad) {
   const slot = encrypted?.keys?.[address];
   if (!slot) throw new Error(`no wrapped key for ${address}`);
-  const shared = diffieHellman({
-    privateKey: encPrivateKey(keys.encPriv, keys.enc),
-    publicKey: encPublicKey(encrypted.epk),
-  });
+  const shared = await x25519(keys.encPriv, keys.enc, encrypted.epk);
   const kek = Buffer.from(hkdfSync('sha256', shared, Buffer.from(encrypted.epk), INFO, 32));
   const d = createDecipheriv('aes-256-gcm', kek, unb64u(slot.iv));
   d.setAuthTag(unb64u(slot.tag));
@@ -117,6 +124,42 @@ export function decryptContent(encrypted, address, keys, aad) {
   return JSON.parse(plain.toString());
 }
 
+// ---------- Adjuntos: un archivo cifrado que la casa guarda sin poder leer ----------
+// Un adjunto NO viaja en el sobre: viaja al almacén de objetos de la casa, cifrado, y el sobre
+// lleva su referencia. La llave es ALEATORIA Y POR ADJUNTO y viaja en `attachments[].key` DENTRO
+// del bloque cifrado del sobre: la casa aloja el objeto y no tiene con qué abrirlo (invariante 8).
+//
+// El objeto es autocontenido: iv(12) || ciphertext || tag(16). No hay cabecera, ni nombre, ni
+// tipo: todo eso es contenido y vive dentro del bloque cifrado del sobre.
+//
+// El AAD lo pone quien llama y es `nyx5:blob:<blobId>:<from>` (ver src/correo/adjuntos.js): ata
+// el cifrado a ESTE objeto y a ESTE remitente, así que un adjunto no se reusa desde otra
+// dirección ni se hace pasar por otro objeto.
+export const IV_BLOB = 12;
+export const TAG_BLOB = 16;
+export const generateBlobKey = () => b64u(randomBytes(32));
+
+export function encryptBlob(datos, key, aad) {
+  const k = unb64u(key);
+  if (k.length !== 32) throw new Error('an attachment key is 32 bytes in base64url');
+  const iv = randomBytes(IV_BLOB);
+  const c = createCipheriv('aes-256-gcm', k, iv);
+  c.setAAD(Buffer.from(aad));
+  const ct = Buffer.concat([c.update(Buffer.from(datos)), c.final()]);
+  return Buffer.concat([iv, ct, c.getAuthTag()]);
+}
+
+export function decryptBlob(objeto, key, aad) {
+  const buf = Buffer.from(objeto);
+  if (buf.length < IV_BLOB + TAG_BLOB) throw new Error('object too short to be an encrypted attachment');
+  const k = unb64u(key);
+  if (k.length !== 32) throw new Error('an attachment key is 32 bytes in base64url');
+  const d = createDecipheriv('aes-256-gcm', k, buf.subarray(0, IV_BLOB));
+  d.setAAD(Buffer.from(aad));
+  d.setAuthTag(buf.subarray(buf.length - TAG_BLOB));
+  return Buffer.concat([d.update(buf.subarray(IV_BLOB, buf.length - TAG_BLOB)), d.final()]);
+}
+
 // ---------- Proof-of-work (hashcash) ----------
 function leadingZeroBits(hex) {
   let bits = 0;

package/src/nucleo/keccak.js

@@ -0,0 +1,118 @@
+// Nyx5/1 — Keccak-256 en JavaScript puro, sin dependencias.
+//
+// Por qué existe: Ethereum usa Keccak-256 (el Keccak ORIGINAL de la competencia SHA-3, con relleno
+// pad10*1 puro), y Node sólo trae `sha3-256`, que es FIPS 202: mismo permutador, distinto relleno
+// (FIPS 202 añade el sufijo 0x06 antes del pad10*1). Los dos dan resultados distintos para la
+// misma entrada, y `crypto.createHash('sha3-256')` NO sirve para calcular una dirección, un
+// dominio EIP-712 ni un digest que un contrato vaya a comprobar. Sin esto, un agente de Nyx5
+// puede COBRAR por x402 pero no PAGAR (ver src/puentes/x402-pagador.js).
+//
+// Parámetros de Keccak-256: estado de 1600 bits (25 carriles de 64 bits), tasa r = 1088 bits
+// (136 bytes por bloque), capacidad c = 512, 24 rondas, salida de 32 bytes.
+//
+// Los carriles son BigInt de 64 bits. Es más lento que partir cada carril en dos enteros de 32
+// bits, pero aquí se hashean decenas de bytes por pago, no megabytes, y la claridad vale más que
+// el ciclo. Verificado contra los vectores oficiales del equipo Keccak (ver test/x402-pagador.test.js).
+
+const RONDAS = 24;
+const TASA = 136; // bytes por bloque para Keccak-256
+const MASCARA = (1n << 64n) - 1n;
+
+// Constantes de ronda (iota), RC[0..23] de la especificación de Keccak.
+const RC = [
+  0x0000000000000001n, 0x0000000000008082n, 0x800000000000808an, 0x8000000080008000n,
+  0x000000000000808bn, 0x0000000080000001n, 0x8000000080008081n, 0x8000000000008009n,
+  0x000000000000008an, 0x0000000000000088n, 0x0000000080008009n, 0x000000008000000an,
+  0x000000008000808bn, 0x800000000000008bn, 0x8000000000008089n, 0x8000000000008003n,
+  0x8000000000008002n, 0x8000000000000080n, 0x000000000000800an, 0x800000008000000an,
+  0x8000000080008081n, 0x8000000000008080n, 0x0000000080000001n, 0x8000000080008008n,
+];
+
+// Desplazamientos de rho, indexados por x + 5*y.
+const ROT = [
+  0, 1, 62, 28, 27,
+  36, 44, 6, 55, 20,
+  3, 10, 43, 25, 39,
+  41, 45, 15, 21, 8,
+  18, 2, 61, 56, 14,
+];
+
+const rotl = (v, n) => n === 0 ? v : (((v << BigInt(n)) | (v >> BigInt(64 - n))) & MASCARA);
+
+// Keccak-f[1600] sobre un arreglo de 25 BigInt (se muta en el lugar).
+function keccakF(A) {
+  const C = new Array(5), B = new Array(25);
+  for (let r = 0; r < RONDAS; r++) {
+    // theta
+    for (let x = 0; x < 5; x++) C[x] = A[x] ^ A[x + 5] ^ A[x + 10] ^ A[x + 15] ^ A[x + 20];
+    for (let x = 0; x < 5; x++) {
+      const D = C[(x + 4) % 5] ^ rotl(C[(x + 1) % 5], 1);
+      for (let y = 0; y < 25; y += 5) A[x + y] ^= D;
+    }
+    // rho y pi
+    for (let x = 0; x < 5; x++) {
+      for (let y = 0; y < 5; y++) {
+        B[y + 5 * ((2 * x + 3 * y) % 5)] = rotl(A[x + 5 * y], ROT[x + 5 * y]);
+      }
+    }
+    // chi
+    for (let y = 0; y < 25; y += 5) {
+      for (let x = 0; x < 5; x++) {
+        A[x + y] = B[x + y] ^ ((~B[(x + 1) % 5 + y] & MASCARA) & B[(x + 2) % 5 + y]);
+      }
+    }
+    // iota
+    A[0] ^= RC[r];
+  }
+}
+
+const aBytes = (entrada) => {
+  if (entrada instanceof Uint8Array) return entrada;
+  if (typeof entrada === 'string') return new TextEncoder().encode(entrada);
+  if (ArrayBuffer.isView(entrada)) return new Uint8Array(entrada.buffer, entrada.byteOffset, entrada.byteLength);
+  throw new TypeError('keccak256: se esperaba Uint8Array o string');
+};
+
+// keccak256(bytes | string utf-8) → Uint8Array de 32 bytes.
+export function keccak256(entrada) {
+  const msg = aBytes(entrada);
+  // Relleno pad10*1 del Keccak original: 0x01 en el primer byte libre, 0x80 en el último del
+  // bloque (si el mensaje llena el bloque exacto, se añade un bloque entero de relleno).
+  const bloques = Math.floor(msg.length / TASA) + 1;
+  const buf = new Uint8Array(bloques * TASA);
+  buf.set(msg);
+  buf[msg.length] ^= 0x01;
+  buf[buf.length - 1] ^= 0x80;
+
+  const A = new Array(25).fill(0n);
+  for (let b = 0; b < bloques; b++) {
+    const base = b * TASA;
+    for (let i = 0; i < TASA / 8; i++) {
+      // Carriles little-endian: el byte 0 es el menos significativo.
+      let carril = 0n;
+      for (let j = 7; j >= 0; j--) carril = (carril << 8n) | BigInt(buf[base + i * 8 + j]);
+      A[i] ^= carril;
+    }
+    keccakF(A);
+  }
+  const salida = new Uint8Array(32);
+  for (let i = 0; i < 4; i++) {
+    let carril = A[i];
+    for (let j = 0; j < 8; j++) { salida[i * 8 + j] = Number(carril & 0xffn); carril >>= 8n; }
+  }
+  return salida;
+}
+
+export const aHex = (bytes) => Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+
+// keccak256 en hexadecimal sin prefijo, minúsculas.
+export const keccak256Hex = (entrada) => aHex(keccak256(entrada));
+
+// Hex (con o sin 0x) → Uint8Array. Falla cerrado: un hex de largo impar o con basura no se adivina.
+export function deHex(hex) {
+  const h = String(hex).replace(/^0x/i, '');
+  if (h.length % 2 !== 0 || !/^[0-9a-fA-F]*$/.test(h)) throw new Error(`hex inválido: ${String(hex).slice(0, 20)}`);
+  const out = new Uint8Array(h.length / 2);
+  for (let i = 0; i < out.length; i++) out[i] = parseInt(h.slice(i * 2, i * 2 + 2), 16);
+  return out;
+}

package/src/nucleo/objetos.js

@@ -0,0 +1,78 @@
+// Nyx5/1 — Almacén de OBJETOS de una casa: dónde vive un adjunto cifrado (NX-413).
+//
+// Es deliberadamente tonto: guarda bytes bajo una clave y los devuelve. Todo lo que es «sobre»
+// (quién puede bajarlo, cuántos bytes, hasta cuándo) vive en los metadatos del almacén normal
+// (`kv`, espacio `adjuntos`), y todo lo que es «contenido» (nombre, tipo, llave) viaja dentro
+// del bloque cifrado del sobre y no llega nunca hasta aquí.
+//
+// Tres implementaciones, la misma interfaz async, igual que FileStore / D1Store:
+//   ObjetosR2       Cloudflare R2 (producción; el binding lo pasa src/plataformas/worker.js)
+//   ObjetosDisco    archivos (la casa local de un test, una demo o un desarrollo)
+//   ObjetosMemoria  memoria (un test que no quiere tocar el disco)
+//
+// CONTRATO:
+//   put(clave, bytes) -> void          get(clave) -> Buffer|Uint8Array|null
+//   delete(clave)     -> void          claves()   -> [string]   (sólo lo usa el reloj; opcional)
+//
+// La clave la arma `claveObjeto(blobId)` en src/correo/adjuntos.js y es siempre `blobs/<uuid>`.
+// NUNCA el nombre del archivo: un nombre trae `../` y además le dice a la casa qué hay dentro.
+
+export class ObjetosMemoria {
+  constructor() { this.m = new Map(); }
+  async put(clave, bytes) { this.m.set(clave, Buffer.from(bytes)); }
+  async get(clave) { return this.m.get(clave) ?? null; }
+  async delete(clave) { this.m.delete(clave); }
+  async claves() { return [...this.m.keys()]; }
+}
+
+export class ObjetosDisco {
+  constructor(dir) { this.dir = dir; }
+  // node:fs por import dinámico: este módulo carga limpio en el edge, donde se usa ObjetosR2.
+  async _fs() { this.fs ||= await import('node:fs'); this.path ||= await import('node:path'); return this.fs; }
+  // La clave ya está acotada a `blobs/<uuid>` por quien llama; aquí se vuelve a comprobar, porque
+  // un almacén que escribe donde le digan es un traversal esperando a que alguien se confunda.
+  _ruta(clave) {
+    if (!/^blobs\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(clave)) throw new Error(`clave de objeto inválida: ${JSON.stringify(String(clave).slice(0, 60))}`);
+    return this.path.join(this.dir, clave.slice('blobs/'.length));
+  }
+  async put(clave, bytes) {
+    const fs = await this._fs();
+    const p = this._ruta(clave);
+    fs.mkdirSync(this.path.dirname(p), { recursive: true });
+    const tmp = `${p}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, Buffer.from(bytes), { mode: 0o600 });
+    fs.renameSync(tmp, p);
+  }
+  async get(clave) {
+    const fs = await this._fs();
+    const p = this._ruta(clave);
+    return fs.existsSync(p) ? fs.readFileSync(p) : null;
+  }
+  async delete(clave) {
+    const fs = await this._fs();
+    const p = this._ruta(clave);
+    if (fs.existsSync(p)) fs.unlinkSync(p);
+  }
+  async claves() {
+    const fs = await this._fs();
+    if (!fs.existsSync(this.dir)) return [];
+    return fs.readdirSync(this.dir).filter((f) => !f.endsWith('.tmp')).map((f) => `blobs/${f}`);
+  }
+}
+
+export class ObjetosR2 {
+  constructor(bucket) { this.bucket = bucket; }
+  async put(clave, bytes) { await this.bucket.put(clave, bytes); }
+  async get(clave) {
+    const o = await this.bucket.get(clave);
+    if (!o) return null;
+    return new Uint8Array(await o.arrayBuffer());
+  }
+  async delete(clave) { await this.bucket.delete(clave); }
+  // R2 pagina; el reloj limpia por los METADATOS (kv), no recorriendo el bucket, así que esto
+  // existe sólo para inspección y devuelve la primera página.
+  async claves() {
+    const l = await this.bucket.list({ prefix: 'blobs/', limit: 1000 });
+    return (l.objects || []).map((o) => o.key);
+  }
+}