@saulwade/swl-ses 2.6.0 → 2.8.0

package/scripts/lib/integrity-ledger.js

@@ -0,0 +1,1147 @@
+'use strict';
+
+/** Ledger firmado y anclado fuera del workspace para el kernel W2. */
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+const util = require('node:util');
+
+const {
+  canonicalizarIJson,
+  parsearIJson,
+  validarTimestampIso,
+} = require('./signed-envelope');
+
+const policyContextModule = require('./policy-context-provider');
+const createPolicyContextProvider = policyContextModule.createPolicyContextProvider;
+delete policyContextModule.createPolicyContextProvider;
+Object.freeze(policyContextModule);
+const singleUseModule = require('./single-use-store');
+const createSingleUseStore = singleUseModule.createSingleUseStore;
+delete singleUseModule.createSingleUseStore;
+Object.freeze(singleUseModule);
+const gateEngineModule = require('./gate-engine');
+const createGateEngine = gateEngineModule.createGateEngine;
+delete gateEngineModule.createGateEngine;
+Object.freeze(gateEngineModule);
+const policyBrokerPath = require.resolve('./policy-broker');
+let policyBrokerModule = require(policyBrokerPath);
+if (typeof policyBrokerModule.createPolicyBroker !== 'function') {
+  delete require.cache[policyBrokerPath];
+  policyBrokerModule = require(policyBrokerPath);
+}
+const createPolicyBroker = policyBrokerModule.createPolicyBroker;
+delete policyBrokerModule.createPolicyBroker;
+Object.freeze(policyBrokerModule);
+const { compilarPolicyBundle } = require('./policy-bundle');
+const { getContractValidators } = require('./policy-verifier-utils');
+
+const ZERO = '0'.repeat(64);
+const SHA256 = /^[a-f0-9]{64}$/u;
+const IDENTIFIER = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+const EVENT_KEYS = [
+  'schemaVersion', 'streamId', 'sequence', 'previousHash', 'eventType', 'payload',
+  'payloadDigest', 'timestamp', 'trustEpoch', 'trustDigest', 'signerKeyId',
+  'eventHash', 'signature',
+];
+const ANCHOR_KEYS = [
+  'schemaVersion', 'streamId', 'sequence', 'headHash', 'trustEpoch', 'trustDigest',
+  'lastTrustedTime', 'generation',
+];
+const TRUST_KEYS = [
+  'schemaVersion', 'rootKeyDigest', 'trustEpoch', 'trustDigest', 'providers',
+  'signerPath', 'anchorPath', 'integrityKeyId', 'integrityPublicKey',
+];
+const APPEND_KEYS = ['expectedSequence', 'expectedHeadHash', 'eventType', 'payload'];
+const PIN_KEYS = [
+  'schemaVersion', 'rootKeyDigest', 'trustPath', 'signerPath', 'anchorPath', 'streamId',
+];
+const PROCESS_FINGERPRINT = obtenerFingerprintProceso(process.pid);
+const MAX_BYTES = Object.freeze({
+  anchor: 16 * 1024,
+  ledger: 64 * 1024 * 1024,
+  lock: 4 * 1024,
+  payload: 1024 * 1024,
+  provisioning: 16 * 1024,
+  signer: 16 * 1024,
+  trust: 256 * 1024,
+});
+const MAX_EVENTOS = 10000;
+const LOCK_LECTURAS_MAX = 8;
+const LOCK_ESPERA_BASE_MS = 1;
+const LOCK_ESPERA_MAX_MS = 32;
+const LOCK_ESPERA_BUFFER = new Int32Array(new SharedArrayBuffer(4));
+const APPEND_RECEIPTS = new WeakSet();
+const AUTHORITY_RECEIPTS = new WeakSet();
+const RESERVED_EVENT_PREFIXES = Object.freeze([
+  'approval.', 'authorization.', 'gate.', 'grant.', 'legacy.', 'policy.',
+]);
+
+function crearError(codigo, mensaje) {
+  const error = new Error(mensaje);
+  error.codigo = codigo;
+  return error;
+}
+
+function fallar(codigo, mensaje) {
+  throw crearError(codigo, mensaje);
+}
+
+function validarObjeto(valor, codigo, etiqueta) {
+  if (!valor || typeof valor !== 'object' || Array.isArray(valor) || util.types.isProxy(valor)) {
+    fallar(codigo, `${etiqueta} inválido`);
+  }
+  const proto = Object.getPrototypeOf(valor);
+  if (proto !== Object.prototype && proto !== null) fallar(codigo, `${etiqueta} inválido`);
+  if (Object.getOwnPropertySymbols(valor).length > 0) fallar(codigo, `${etiqueta} inválido`);
+  const descriptores = Object.values(Object.getOwnPropertyDescriptors(valor));
+  if (descriptores.some((item) => !item.enumerable || !('value' in item))) {
+    fallar(codigo, `${etiqueta} inválido`);
+  }
+}
+
+function validarClaves(valor, claves, codigo, etiqueta) {
+  if (JSON.stringify(Object.keys(valor).sort()) !== JSON.stringify([...claves].sort())) {
+    fallar(codigo, `${etiqueta} inválido`);
+  }
+}
+
+function congelarProfundo(valor) {
+  if (!valor || typeof valor !== 'object' || Object.isFrozen(valor)) return valor;
+  Object.values(valor).forEach(congelarProfundo);
+  return Object.freeze(valor);
+}
+
+function hashBytes(bytes) {
+  return crypto.createHash('sha256').update(bytes).digest('hex');
+}
+
+function hitFault(punto) {
+  if (process.env.SWL_INTEGRITY_FAULT === punto) {
+    if (!esModoPruebas()) fallar('FAULT_CONFIG_INVALID', 'fault injection fuera de pruebas');
+    fallar('FAULT_INJECTED', `falla inyectada: ${punto}`);
+  }
+}
+
+function esModoPruebas() {
+  return process.env.NODE_ENV === 'test' && process.env.SWL_INTEGRITY_TEST_MODE === '1';
+}
+
+function obtenerFingerprintLinux(pid) {
+  try {
+    const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
+    const cierre = stat.lastIndexOf(')');
+    const campos = stat.slice(cierre + 2).trim().split(/\s+/u);
+    const bootId = fs.readFileSync('/proc/sys/kernel/random/boot_id', 'utf8').trim();
+    return cierre > 0 && campos[19] && bootId ? `${bootId}:${campos[19]}` : null;
+  } catch {
+    return null;
+  }
+}
+
+function obtenerFingerprintProceso(pid) {
+  const nativo = process.platform === 'linux' ? obtenerFingerprintLinux(pid) : null;
+  if (nativo) return nativo;
+  if (pid === process.pid) {
+    return `${process.pid}:${Math.round(Date.now() - process.uptime() * 1000)}`;
+  }
+  return null;
+}
+
+function validarBackendArchivos() {
+  if (process.env.SWL_INTEGRITY_FAULT && !esModoPruebas()) {
+    fallar('FAULT_CONFIG_INVALID', 'fault injection fuera de pruebas');
+  }
+  if (process.platform !== 'linux' && !esModoPruebas()) {
+    fallar('FILE_BACKEND_UNAVAILABLE', 'backend de archivos sin inspector nativo');
+  }
+}
+
+function mismaRuta(a, b) {
+  return path.relative(path.resolve(a), path.resolve(b)) === '';
+}
+
+function validarPermisos(stat, codigo, esDirectorio = false, privado = true) {
+  if (process.platform === 'win32') return;
+  if (typeof process.geteuid === 'function' && stat.uid !== process.geteuid()) {
+    fallar(codigo, 'propietario inseguro');
+  }
+  const permisos = stat.mode & 0o777;
+  const inseguros = esDirectorio && !privado ? (permisos & 0o022) !== 0 : permisos !== (
+    esDirectorio ? 0o700 : 0o600
+  );
+  if (inseguros) fallar(codigo, 'permisos inseguros');
+}
+
+function validarDirectorioSeguro(directorio, privado = false) {
+  const stat = fs.lstatSync(directorio);
+  if (stat.isSymbolicLink() || !stat.isDirectory()) fallar('PATH_INVALID', 'directorio inseguro');
+  if (!mismaRuta(fs.realpathSync(directorio), directorio)) {
+    fallar('PATH_INVALID', 'directorio redirigido');
+  }
+  validarPermisos(stat, 'PATH_INVALID', true, privado);
+}
+
+function esRutaInterna(ruta, workspaceRoot) {
+  const relativa = path.relative(path.resolve(workspaceRoot), path.resolve(ruta));
+  return relativa === '' || (!relativa.startsWith('..') && !path.isAbsolute(relativa));
+}
+
+function validarRutaExternaSegura(ruta, workspaceRoot) {
+  const root = path.parse(ruta).root;
+  const resto = ruta.slice(root.length);
+  const prohibida = typeof ruta !== 'string' || !path.isAbsolute(ruta) || ruta.includes('\0')
+    || /^[\\/]{2}/u.test(ruta) || ruta.normalize('NFKC') !== ruta
+    || /[\u200B-\u200F\u202A-\u202E\u2060-\u206F]/u.test(ruta)
+    || resto.includes(':') || esRutaInterna(ruta, workspaceRoot);
+  if (prohibida) fallar('PATH_INVALID', 'locator externo inseguro');
+  validarDirectorioSeguro(path.dirname(ruta), true);
+}
+
+function asegurarDirectorio(directorio, privado = true) {
+  if (!fs.existsSync(directorio)) fs.mkdirSync(directorio, { mode: 0o700 });
+  validarDirectorioSeguro(directorio, privado);
+}
+
+function validarArchivoRegular(ruta, codigo, maxBytes, privado = true) {
+  validarDirectorioSeguro(path.dirname(ruta), privado);
+  let stat;
+  try {
+    stat = fs.lstatSync(ruta);
+  } catch (error) {
+    if (error.code === 'ENOENT') fallar(codigo, 'archivo no disponible');
+    throw error;
+  }
+  if (stat.isSymbolicLink() || !stat.isFile() || stat.nlink !== 1) {
+    fallar(codigo, 'archivo inseguro');
+  }
+  if (privado) validarPermisos(stat, codigo);
+  if (Number.isInteger(maxBytes) && stat.size > maxBytes) fallar(codigo, 'archivo excede límite');
+  return stat;
+}
+
+function leerBytesEstables(ruta, codigo, maxBytes, privado = true) {
+  const inicial = validarArchivoRegular(ruta, codigo, maxBytes, privado);
+  const descriptor = fs.openSync(ruta, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0));
+  try {
+    const bytes = fs.readFileSync(descriptor);
+    const final = fs.fstatSync(descriptor);
+    if (inicial.dev !== final.dev || inicial.ino !== final.ino || inicial.size !== final.size) {
+      fallar(codigo, 'archivo cambió durante lectura');
+    }
+    if (Number.isInteger(maxBytes) && bytes.length > maxBytes) {
+      fallar(codigo, 'archivo excede límite');
+    }
+    return bytes;
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+
+function leerJson(ruta, codigo, maxBytes) {
+  try {
+    return parsearIJson(leerBytesEstables(ruta, codigo, maxBytes));
+  } catch (error) {
+    if (error.codigo === codigo) throw error;
+    fallar(codigo, 'JSON externo inválido');
+  }
+}
+
+function sincronizarDirectorio(directorio) {
+  const descriptor = fs.openSync(directorio, 'r');
+  try {
+    fs.fsyncSync(descriptor);
+  } catch (error) {
+    const tolerable = process.platform === 'win32'
+      && (error.code === 'EPERM' || error.code === 'EINVAL');
+    if (!tolerable) throw error;
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+
+function escribirTemporal(ruta, bytes, punto) {
+  fs.writeFileSync(ruta, bytes, { flag: 'wx', mode: 0o600 });
+  hitFault(`after-${punto}-temp-write`);
+  const descriptor = fs.openSync(ruta, 'r+');
+  try {
+    fs.fsyncSync(descriptor);
+  } finally {
+    fs.closeSync(descriptor);
+  }
+  hitFault(`after-${punto}-temp-fsync`);
+}
+
+function sincronizarArchivo(ruta) {
+  const descriptor = fs.openSync(ruta, 'r+');
+  try {
+    fs.fsyncSync(descriptor);
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+
+function eliminarSiExiste(ruta) {
+  try {
+    fs.unlinkSync(ruta);
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+  }
+}
+
+function escrituraAtomica(ruta, bytes, puntoRename) {
+  const directorio = path.dirname(ruta);
+  const temporal = `${ruta}.tmp-${process.pid}-${crypto.randomBytes(8).toString('hex')}`;
+  validarDirectorioSeguro(directorio, true);
+  try {
+    escribirTemporal(temporal, bytes, puntoRename);
+    hitFault(`before-${puntoRename}-rename`);
+    validarDirectorioSeguro(directorio, true);
+    fs.renameSync(temporal, ruta);
+    hitFault(`after-${puntoRename}-rename`);
+    validarArchivoRegular(ruta, 'DURABILITY_INVALID', bytes.length);
+    sincronizarArchivo(ruta);
+    sincronizarDirectorio(directorio);
+    hitFault(`after-${puntoRename}-directory-fsync`);
+  } finally {
+    eliminarSiExiste(temporal);
+  }
+}
+
+function esperarLockBreve(intento) {
+  const espera = Math.min(LOCK_ESPERA_BASE_MS << intento, LOCK_ESPERA_MAX_MS);
+  Atomics.wait(LOCK_ESPERA_BUFFER, 0, 0, espera);
+}
+
+// Defensa en profundidad de la publicación atómica del escritor. persistirLockNuevo
+// enlaza el lock con contenido completo, pero deja una ventana residual mínima donde
+// el path final tiene nlink=2 (entre el link y el unlink del temporal): un lector
+// concurrente que cae ahí ve validarArchivoRegular rechazarlo como transitorio. Es
+// contención de creación en curso, no corrupción; se reintenta la lectura hasta que
+// el escritor completa el unlink. Un fallo de VALIDACIÓN (campos malos sobre un lock
+// ya completo) ocurre después, en parsearLock, y nunca se reintenta. Residuales
+// benignos que también se reintentan sin daño (latencia acotada, nunca resultado
+// incorrecto): ENOENT de un lock liberado durante la carrera y PATH_INVALID que
+// leerJson normaliza a LOCK_INVALID.
+function leerLockCrudo(ruta) {
+  let ultimoError;
+  for (let intento = 0; intento < LOCK_LECTURAS_MAX; intento += 1) {
+    try {
+      return leerJson(ruta, 'LOCK_INVALID', MAX_BYTES.lock);
+    } catch (error) {
+      // leerJson normaliza toda falla de lectura/parseo a LOCK_INVALID (ver su
+      // catch): un lock imparseable es contención de creación en curso, se reintenta.
+      ultimoError = error;
+      if (intento + 1 < LOCK_LECTURAS_MAX) esperarLockBreve(intento);
+    }
+  }
+  throw ultimoError;
+}
+
+function parsearLock(ruta) {
+  const lock = leerLockCrudo(ruta);
+  validarObjeto(lock, 'LOCK_INVALID', 'lock');
+  validarClaves(lock, ['ownerToken', 'pid', 'processFingerprint'], 'LOCK_INVALID', 'lock');
+  if (!SHA256.test(lock.ownerToken) || !Number.isInteger(lock.pid) || lock.pid <= 0) {
+    fallar('LOCK_INVALID', 'lock inválido');
+  }
+  if (typeof lock.processFingerprint !== 'string' || lock.processFingerprint.length > 256) {
+    fallar('LOCK_INVALID', 'lock inválido');
+  }
+  return lock;
+}
+
+function inspeccionarProceso(lock) {
+  if (lock.pid === process.pid) {
+    return { alive: true, fingerprint: PROCESS_FINGERPRINT };
+  }
+  try {
+    process.kill(lock.pid, 0);
+  } catch (error) {
+    if (error.code === 'ESRCH') return { alive: false, fingerprint: null };
+  }
+  return { alive: true, fingerprint: obtenerFingerprintProceso(lock.pid) };
+}
+
+function puedeReclamar(lock) {
+  const proceso = inspeccionarProceso(lock);
+  if (!proceso.alive) return true;
+  return proceso.fingerprint !== null && proceso.fingerprint !== lock.processFingerprint;
+}
+
+function locksIguales(a, b) {
+  return a.ownerToken === b.ownerToken
+    && a.pid === b.pid
+    && a.processFingerprint === b.processFingerprint;
+}
+
+function crearLockPropio() {
+  return {
+    ownerToken: crypto.randomBytes(32).toString('hex'),
+    pid: process.pid,
+    processFingerprint: PROCESS_FINGERPRINT,
+  };
+}
+
+function persistirLockNuevo(ruta, valor) {
+  // Publicación atómica-exclusiva: el contenido completo se escribe primero en un
+  // temporal por-proceso y luego se enlaza al path final con linkSync. link() falla
+  // con EEXIST si el lock ya existe —preserva la exclusión mutua que adquirirLock
+  // necesita— y el path final, una vez visible, SIEMPRE trae contenido: nunca la
+  // ventana vacía de un create-then-write. Un crash antes del link deja sólo el
+  // temporal (huérfano limpiable), nunca un lock de 0 bytes irreclamable. La ventana
+  // residual nlink=2 entre link y unlink la absorbe leerLockCrudo (reintento).
+  const temporal = `${ruta}.${crypto.randomBytes(12).toString('hex')}.tmp`;
+  fs.writeFileSync(temporal, `${canonicalizarIJson(valor)}\n`, { flag: 'wx', mode: 0o600 });
+  sincronizarArchivo(temporal);
+  try {
+    fs.linkSync(temporal, ruta);
+  } catch (error) {
+    eliminarSiExiste(temporal);
+    throw error;
+  }
+  eliminarSiExiste(temporal);
+  sincronizarDirectorio(path.dirname(ruta));
+}
+
+function eliminarLockVerificado(ruta, ownerToken) {
+  const actual = parsearLock(ruta);
+  if (actual.ownerToken !== ownerToken) fallar('LOCK_OWNER_MISMATCH', 'owner cambió');
+  fs.unlinkSync(ruta);
+  sincronizarDirectorio(path.dirname(ruta));
+}
+
+function cuarentenarLock(ruta, lock) {
+  const cuarentena = `${ruta}.orphan-${crypto.randomBytes(12).toString('hex')}`;
+  try {
+    fs.renameSync(ruta, cuarentena);
+  } catch (error) {
+    if (error.code === 'ENOENT') fallar('LOCK_CONFLICT', 'otro reclaimer ganó');
+    throw error;
+  }
+  const movido = parsearLock(cuarentena);
+  if (!locksIguales(lock, movido)) fallar('LOCK_CONFLICT', 'lock cambió durante reclaim');
+  fs.unlinkSync(cuarentena);
+  sincronizarDirectorio(path.dirname(ruta));
+}
+
+function recuperarGuardiaReclaim(guardia) {
+  const lock = parsearLock(guardia);
+  if (!puedeReclamar(lock)) fallar('LOCK_CONFLICT', 'reclaim ya está en curso');
+  cuarentenarLock(guardia, lock);
+}
+
+function adquirirGuardiaReclaim(ruta) {
+  const guardia = `${ruta}.reclaim`;
+  const owner = crearLockPropio();
+  try {
+    persistirLockNuevo(guardia, owner);
+    return { guardia, owner };
+  } catch (error) {
+    if (error.code !== 'EEXIST') throw error;
+    recuperarGuardiaReclaim(guardia);
+    return adquirirGuardiaReclaim(ruta);
+  }
+}
+
+function reclamarLock(ruta) {
+  const observado = parsearLock(ruta);
+  if (!puedeReclamar(observado)) fallar('LOCK_HELD', 'lock pertenece a proceso vivo');
+  const { guardia, owner } = adquirirGuardiaReclaim(ruta);
+  try {
+    const actual = parsearLock(ruta);
+    if (!locksIguales(observado, actual)) fallar('LOCK_CONFLICT', 'lock cambió antes de reclaim');
+    if (!puedeReclamar(actual)) fallar('LOCK_HELD', 'lock pertenece a proceso vivo');
+    cuarentenarLock(ruta, actual);
+  } finally {
+    eliminarLockVerificado(guardia, owner.ownerToken);
+  }
+}
+
+function bloquearSiReclaimEnCurso(ruta, ownerToken = null) {
+  const guardia = `${ruta}.reclaim`;
+  if (!fs.existsSync(guardia)) return;
+  try {
+    recuperarGuardiaReclaim(guardia);
+  } catch (error) {
+    if (ownerToken) liberarLock(ruta, ownerToken);
+    throw error;
+  }
+}
+
+function adquirirLock(ruta) {
+  hitFault('before-lock');
+  const valor = crearLockPropio();
+  validarDirectorioSeguro(path.dirname(ruta), true);
+  bloquearSiReclaimEnCurso(ruta);
+  try {
+    persistirLockNuevo(ruta, valor);
+  } catch (error) {
+    if (error.code !== 'EEXIST') throw error;
+    reclamarLock(ruta);
+    return adquirirLock(ruta);
+  }
+  bloquearSiReclaimEnCurso(ruta, valor.ownerToken);
+  hitFault('after-lock');
+  return valor;
+}
+
+function liberarLock(ruta, ownerToken) {
+  eliminarLockVerificado(ruta, ownerToken);
+}
+
+function liberarLockConCodigo(ruta, ownerToken) {
+  try {
+    liberarLock(ruta, ownerToken);
+  } catch (error) {
+    if (error.codigo !== 'LOCK_OWNER_MISMATCH') error.codigo = 'LOCK_RELEASE_FAILED';
+    throw error;
+  }
+}
+
+function conLock(ruta, accion) {
+  const owner = adquirirLock(ruta);
+  let resultado;
+  let falla;
+  try {
+    resultado = accion();
+  } catch (error) {
+    falla = error;
+  }
+  liberarLockConCodigo(ruta, owner.ownerToken);
+  if (falla) throw falla;
+  return resultado;
+}
+
+function validarProviders(actuales, esperados) {
+  validarObjeto(actuales, 'TRUST_INVALID', 'providers');
+  validarObjeto(esperados, 'TRUST_INVALID', 'providers');
+  const a = canonicalizarIJson(actuales);
+  const b = canonicalizarIJson(esperados);
+  if (a !== b) fallar('PROVIDER_BINDING_INVALID', 'providers no coinciden');
+  for (const provider of Object.values(actuales)) {
+    const esperado = hashBytes(Buffer.from(provider.implementation));
+    if (provider.fingerprint !== esperado) {
+      fallar('PROVIDER_BINDING_INVALID', 'fingerprint built-in inválido');
+    }
+  }
+}
+
+function validarPin(pin, config) {
+  validarObjeto(pin, 'PROVISIONING_INVALID', 'pin de provisioning');
+  validarClaves(pin, PIN_KEYS, 'PROVISIONING_INVALID', 'pin de provisioning');
+  if (pin.schemaVersion !== '1.0.0' || !SHA256.test(pin.rootKeyDigest)) {
+    fallar('PROVISIONING_INVALID', 'pin de provisioning inválido');
+  }
+  if (!IDENTIFIER.test(pin.streamId)) fallar('PROVISIONING_INVALID', 'streamId inválido');
+  const receipt = config.receipt;
+  if (pin.rootKeyDigest !== receipt.rootKeyDigest
+      || pin.trustPath !== receipt.trustPath
+      || pin.signerPath !== receipt.signerPath
+      || pin.anchorPath !== receipt.anchorPath) {
+    fallar('ROOT_BINDING_INVALID', 'receipt no coincide con provisioning externo');
+  }
+}
+
+function validarTrust(trust, config) {
+  const receipt = config.receipt;
+  validarObjeto(trust, 'TRUST_INVALID', 'trust externo');
+  validarClaves(trust, TRUST_KEYS, 'TRUST_INVALID', 'trust externo');
+  if (trust.schemaVersion !== '1.0.0' || trust.rootKeyDigest !== receipt.rootKeyDigest) {
+    fallar('ROOT_BINDING_INVALID', 'root externo no coincide');
+  }
+  if (trust.trustEpoch !== receipt.trustEpoch || trust.trustDigest !== receipt.trustDigest) {
+    fallar('TRUST_BINDING_INVALID', 'trust externo no coincide');
+  }
+  validarProviders(trust.providers, receipt.providers);
+  if (trust.signerPath !== receipt.signerPath || trust.anchorPath !== receipt.anchorPath) {
+    fallar('TRUST_BINDING_INVALID', 'locators externos no coinciden');
+  }
+  if (!IDENTIFIER.test(trust.integrityKeyId) || typeof trust.integrityPublicKey !== 'string') {
+    fallar('TRUST_INVALID', 'signer externo inválido');
+  }
+  if (trust.integrityKeyId !== config.signerKeyId) {
+    fallar('TRUST_BINDING_INVALID', 'keyId externo no coincide con receipt');
+  }
+}
+
+function validarAnchor(anchor, config) {
+  validarObjeto(anchor, 'ANCHOR_INVALID', 'anchor');
+  validarClaves(anchor, ANCHOR_KEYS, 'ANCHOR_INVALID', 'anchor');
+  if (anchor.schemaVersion !== '1.0.0' || anchor.streamId !== config.streamId) {
+    fallar('ANCHOR_INVALID', 'anchor de otro stream');
+  }
+  if (!Number.isInteger(anchor.sequence) || anchor.sequence < 0 || !SHA256.test(anchor.headHash)) {
+    fallar('ANCHOR_INVALID', 'head externo inválido');
+  }
+  if (!Number.isInteger(anchor.generation) || anchor.generation !== anchor.sequence) {
+    fallar('ANCHOR_INVALID', 'generación externa inválida');
+  }
+  if (anchor.trustEpoch !== config.receipt.trustEpoch
+      || anchor.trustDigest !== config.receipt.trustDigest) {
+    fallar('ANCHOR_TRUST_INVALID', 'anchor trust inválido');
+  }
+  try {
+    validarTimestampIso(anchor.lastTrustedTime, 'anchor lastTrustedTime');
+  } catch {
+    fallar('ANCHOR_INVALID', 'tiempo externo inválido');
+  }
+  return anchor;
+}
+
+function leerAnchor(config) {
+  return validarAnchor(leerJson(config.anchorPath, 'ANCHOR_UNAVAILABLE', MAX_BYTES.anchor), config);
+}
+
+function eventoSinPruebas(evento) {
+  const unsigned = { ...evento };
+  delete unsigned.eventHash;
+  delete unsigned.signature;
+  return unsigned;
+}
+
+function bytesFirmaEvento(unsigned) {
+  return Buffer.concat([
+    Buffer.from('swl-ses/integrity-ledger/v1\0', 'utf8'),
+    Buffer.from(canonicalizarIJson(unsigned), 'utf8'),
+  ]);
+}
+
+function validarCabeceraEvento(evento, config) {
+  if (evento.schemaVersion !== '1.0.0' || evento.streamId !== config.streamId) {
+    fallar('LEDGER_INVALID', 'evento de otro stream');
+  }
+  if (!Number.isInteger(evento.sequence) || evento.sequence < 1) {
+    fallar('LEDGER_INVALID', 'secuencia inválida');
+  }
+}
+
+function validarDigestsEvento(evento) {
+  const digests = [evento.previousHash, evento.payloadDigest, evento.trustDigest, evento.eventHash];
+  if (digests.some((digest) => !SHA256.test(digest))) {
+    fallar('LEDGER_INVALID', 'digest inválido');
+  }
+}
+
+function validarIdentidadEvento(evento, config) {
+  if (!IDENTIFIER.test(evento.eventType) || !IDENTIFIER.test(evento.signerKeyId)) {
+    fallar('LEDGER_INVALID', 'identificador inválido');
+  }
+  if (evento.signerKeyId !== config.trust.integrityKeyId) {
+    fallar('LEDGER_INVALID', 'signer keyId no coincide');
+  }
+}
+
+function validarTrustEvento(evento, config) {
+  if (evento.trustEpoch !== config.receipt.trustEpoch
+      || evento.trustDigest !== config.receipt.trustDigest) {
+    fallar('LEDGER_INVALID', 'trust de evento inválido');
+  }
+}
+
+function validarPayloadEvento(payload, codigo) {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    fallar(codigo, 'payload inválido');
+  }
+  validarValorIJson(payload, 0);
+  const bytes = Buffer.byteLength(canonicalizarIJson(payload), 'utf8');
+  if (bytes > MAX_BYTES.payload) fallar(codigo, 'payload excede límite');
+}
+
+function validarEventoShape(evento, config) {
+  validarObjeto(evento, 'LEDGER_INVALID', 'evento');
+  validarClaves(evento, EVENT_KEYS, 'LEDGER_INVALID', 'evento');
+  validarCabeceraEvento(evento, config);
+  validarDigestsEvento(evento);
+  validarIdentidadEvento(evento, config);
+  validarPayloadEvento(evento.payload, 'LEDGER_INVALID');
+  validarTimestampIso(evento.timestamp, 'evento timestamp');
+  validarTrustEvento(evento, config);
+}
+
+function verificarEvento(evento, anterior, config) {
+  validarEventoShape(evento, config);
+  if (evento.sequence !== anterior.sequence + 1 || evento.previousHash !== anterior.headHash) {
+    fallar('LEDGER_INVALID', 'cadena no contigua');
+  }
+  if (anterior.lastTrustedTime && evento.timestamp < anterior.lastTrustedTime) {
+    fallar('CLOCK_ROLLBACK', 'tiempo del ledger retrocedió');
+  }
+  const unsigned = eventoSinPruebas(evento);
+  if (hashBytes(Buffer.from(canonicalizarIJson(evento.payload))) !== evento.payloadDigest) {
+    fallar('LEDGER_INVALID', 'payload alterado');
+  }
+  if (hashBytes(Buffer.from(canonicalizarIJson(unsigned))) !== evento.eventHash) {
+    fallar('LEDGER_INVALID', 'evento rehasheado');
+  }
+  let firmaValida = false;
+  try {
+    firmaValida = crypto.verify(
+      null, bytesFirmaEvento(unsigned), config.publicKey, Buffer.from(evento.signature, 'base64url')
+    );
+  } catch { /* firma inválida */ }
+  if (!firmaValida) fallar('SIGNATURE_INVALID', 'firma de evento inválida');
+  return {
+    sequence: evento.sequence,
+    headHash: evento.eventHash,
+    lastTrustedTime: evento.timestamp,
+  };
+}
+
+function parsearLedger(config) {
+  if (!fs.existsSync(config.ledgerPath)) return [];
+  const bytes = leerBytesEstables(config.ledgerPath, 'LEDGER_INVALID', MAX_BYTES.ledger);
+  if (bytes.length === 0) return [];
+  if (bytes[bytes.length - 1] !== 0x0A) fallar('LEDGER_INVALID', 'línea parcial');
+  try {
+    const lineas = dividirJsonl(bytes);
+    if (lineas.length > MAX_EVENTOS) fallar('LEDGER_INVALID', 'ledger excede eventos');
+    return lineas.map((linea) => parsearIJson(linea));
+  } catch {
+    fallar('LEDGER_INVALID', 'ledger JSONL inválido');
+  }
+}
+
+function dividirJsonl(bytes) {
+  const lineas = [];
+  let inicio = 0;
+  for (let indice = 0; indice < bytes.length; indice += 1) {
+    if (bytes[indice] !== 0x0A) continue;
+    if (indice === inicio) fallar('LEDGER_INVALID', 'línea vacía');
+    lineas.push(bytes.subarray(inicio, indice));
+    inicio = indice + 1;
+  }
+  return lineas;
+}
+
+function verificarLedger(config) {
+  const eventos = parsearLedger(config);
+  let tip = { sequence: 0, headHash: ZERO, lastTrustedTime: config.receipt.issuedAt };
+  for (const evento of eventos) tip = verificarEvento(evento, tip, config);
+  return { ...tip, events: eventos };
+}
+
+function anchorsIguales(anchor, tip) {
+  return anchor.sequence === tip.sequence
+    && anchor.headHash === tip.headHash
+    && anchor.lastTrustedTime >= tip.lastTrustedTime
+    && anchor.generation === tip.sequence;
+}
+
+function expectedAnchor(anchor) {
+  return {
+    streamId: anchor.streamId, sequence: anchor.sequence, headHash: anchor.headHash,
+    trustEpoch: anchor.trustEpoch, trustDigest: anchor.trustDigest,
+    lastTrustedTime: anchor.lastTrustedTime, generation: anchor.generation,
+  };
+}
+
+function anchorCoincide(anchor, expected) {
+  return Object.entries(expected).every(([clave, valor]) => anchor[clave] === valor);
+}
+
+function publicarAnchor(config, expected, siguiente) {
+  return conLock(`${config.anchorPath}.lock`, () => {
+    const actual = leerAnchor(config);
+    if (!anchorCoincide(actual, expected)) fallar('ANCHOR_CAS_CONFLICT', 'CAS externo rechazado');
+    escrituraAtomica(
+      config.anchorPath,
+      Buffer.from(`${canonicalizarIJson(siguiente)}\n`),
+      'anchor'
+    );
+    hitFault('anchor-updated-before-response');
+    return siguiente;
+  });
+}
+
+function confirmarAnchor(config, expected, siguiente) {
+  try {
+    return publicarAnchor(config, expected, siguiente);
+  } catch (error) {
+    const noAmbiguo = ['ANCHOR_CAS_CONFLICT', 'LOCK_OWNER_MISMATCH', 'LOCK_RELEASE_FAILED'];
+    if (noAmbiguo.includes(error.codigo)) throw error;
+    try {
+      const observado = leerAnchor(config);
+      if (anchorCoincide(observado, expectedAnchor(siguiente))) return observado;
+    } catch { /* conservar la falla original si el resultado es ambiguo */ }
+    throw error;
+  }
+}
+
+function avanzarTiempoAutoridad(config, anchor, observedAt) {
+  validarVigencia(config.receipt, anchor, observedAt);
+  if (observedAt === anchor.lastTrustedTime) return anchor;
+  return confirmarAnchor(config, expectedAnchor(anchor), {
+    ...anchor, lastTrustedTime: observedAt,
+  });
+}
+
+function avanzarAnchor(config, anchor, state, observedAt) {
+  const primerPendiente = state.events[anchor.sequence];
+  if (!primerPendiente || primerPendiente.previousHash !== anchor.headHash) {
+    fallar('ANCHOR_DIVERGED', 'anchor no es prefijo del ledger');
+  }
+  const ultimo = state.events[state.events.length - 1];
+  if (primerPendiente.timestamp < anchor.lastTrustedTime) {
+    fallar('CLOCK_ROLLBACK', 'sufijo local reduce el tiempo confiable');
+  }
+  if (ultimo.timestamp > observedAt) fallar('CLOCK_FUTURE', 'sufijo local está en el futuro');
+  const siguiente = {
+    schemaVersion: '1.0.0', streamId: config.streamId,
+    sequence: state.sequence, headHash: state.headHash,
+    trustEpoch: config.receipt.trustEpoch, trustDigest: config.receipt.trustDigest,
+    lastTrustedTime: [anchor.lastTrustedTime, ultimo.timestamp].sort().at(-1),
+    generation: anchor.generation + (state.sequence - anchor.sequence),
+  };
+  return confirmarAnchor(config, expectedAnchor(anchor), siguiente);
+}
+
+function reconciliar(config, state, observedAt) {
+  const anchor = leerAnchor(config);
+  validarVigencia(config.receipt, anchor, observedAt);
+  if (anchorsIguales(anchor, state)) return anchor;
+  if (anchor.sequence > state.sequence) fallar('ANCHOR_AHEAD', 'workspace restaurado o stale');
+  if (anchor.sequence === state.sequence) fallar('ANCHOR_DIVERGED', 'anchor divergente');
+  return avanzarAnchor(config, anchor, state, observedAt);
+}
+
+function serializarSnapshot(config, state, anchor) {
+  return `${canonicalizarIJson({
+    schemaVersion: '1.0.0', streamId: config.streamId,
+    sequence: state.sequence, headHash: state.headHash,
+    anchorGeneration: anchor.generation, eventCount: state.events.length,
+  })}\n`;
+}
+
+function publicarSnapshot(config, state, anchor) {
+  escrituraAtomica(
+    config.snapshotPath,
+    Buffer.from(serializarSnapshot(config, state, anchor)),
+    'snapshot'
+  );
+}
+
+function estadoPublico(config, state) {
+  const valor = {
+    streamId: config.streamId, sequence: state.sequence,
+    headHash: state.headHash, events: state.events.map((evento) => structuredClone(evento)),
+  };
+  return congelarProfundo(valor);
+}
+
+function leerVerificado(config) {
+  const observedAt = new Date().toISOString();
+  const state = verificarLedger(config);
+  hitFault('after-reread');
+  const anchor = reconciliar(config, state, observedAt);
+  validarVigencia(config.receipt, anchor, observedAt);
+  publicarSnapshot(config, state, anchor);
+  return estadoPublico(config, state);
+}
+
+function validarEntradaAppend(entrada, esAutoridad = false) {
+  validarObjeto(entrada, 'EVENT_INVALID', 'append');
+  validarClaves(entrada, APPEND_KEYS, 'EVENT_INVALID', 'append');
+  if (!Number.isInteger(entrada.expectedSequence) || entrada.expectedSequence < 0
+      || !SHA256.test(entrada.expectedHeadHash)) {
+    fallar('EVENT_INVALID', 'precondición CAS inválida');
+  }
+  if (!IDENTIFIER.test(entrada.eventType)) fallar('EVENT_INVALID', 'eventType inválido');
+  if (!esAutoridad && RESERVED_EVENT_PREFIXES.some(
+    (prefijo) => entrada.eventType.startsWith(prefijo)
+  )) {
+    fallar('EVENT_TYPE_RESERVED', 'eventType reservado para el kernel');
+  }
+  validarPayloadEvento(entrada.payload, 'EVENT_INVALID');
+}
+
+function crearEvento(config, previo, entrada, timestamp) {
+  const unsigned = {
+    schemaVersion: '1.0.0', streamId: config.streamId, sequence: previo.sequence + 1,
+    previousHash: previo.headHash, eventType: entrada.eventType,
+    payload: structuredClone(entrada.payload),
+    payloadDigest: hashBytes(Buffer.from(canonicalizarIJson(entrada.payload))),
+    timestamp, trustEpoch: config.receipt.trustEpoch, trustDigest: config.receipt.trustDigest,
+    signerKeyId: config.trust.integrityKeyId,
+  };
+  const eventHash = hashBytes(Buffer.from(canonicalizarIJson(unsigned)));
+  const signature = crypto.sign(
+    null, bytesFirmaEvento(unsigned), config.privateKey
+  ).toString('base64url');
+  return { ...unsigned, eventHash, signature };
+}
+
+function persistirLedger(config, events) {
+  const bytes = Buffer.from(events.map((evento) => canonicalizarIJson(evento)).join('\n') + '\n');
+  if (events.length > MAX_EVENTOS || bytes.length > MAX_BYTES.ledger) {
+    fallar('LEDGER_LIMIT_EXCEEDED', 'ledger excede límite');
+  }
+  escrituraAtomica(config.ledgerPath, bytes, 'ledger');
+}
+
+function crearReceiptAppend(config, expected, state, anchor) {
+  const receipt = congelarProfundo({
+    kind: 'integrity-ledger-append-receipt', streamId: config.streamId,
+    expectedSequence: expected.sequence, expectedHeadHash: expected.headHash,
+    expectedAnchorGeneration: expected.generation,
+    sequence: state.sequence, headHash: state.headHash,
+    anchorGeneration: anchor.generation,
+    trustEpoch: anchor.trustEpoch, trustDigest: anchor.trustDigest,
+  });
+  APPEND_RECEIPTS.add(receipt);
+  return receipt;
+}
+
+function append(config, entrada, esAutoridad = false) {
+  validarEntradaAppend(entrada, esAutoridad);
+  return conLock(config.lockPath, () => {
+    const observedAt = new Date().toISOString();
+    const previo = verificarLedger(config);
+    hitFault('after-reread');
+    const anchorPrevio = reconciliar(config, previo, observedAt);
+    if (entrada.expectedSequence !== previo.sequence
+        || entrada.expectedHeadHash !== previo.headHash) {
+      fallar('LEDGER_CAS_CONFLICT', 'precondición local cambió');
+    }
+    const evento = crearEvento(config, previo, entrada, observedAt);
+    const events = [...previo.events, evento];
+    persistirLedger(config, events);
+    hitFault('local-durable-before-anchor-cas');
+    const state = verificarLedger(config);
+    const anchor = avanzarAnchor(config, anchorPrevio, state, observedAt);
+    publicarSnapshot(config, state, anchor);
+    return crearReceiptAppend(config, anchorPrevio, state, anchor);
+  });
+}
+
+function mutarCasEnPruebas(entrada) {
+  if (process.env.SWL_INTEGRITY_FAULT !== 'before-transact-cas-check') return entrada;
+  return { ...entrada, expectedSequence: entrada.expectedSequence + 1 };
+}
+
+function transact(config, action) {
+  return conLock(config.lockPath, () => {
+    const observedAt = new Date().toISOString();
+    const previo = verificarLedger(config);
+    hitFault('after-reread');
+    const reconciliado = reconciliar(config, previo, observedAt);
+    const anchorPrevio = avanzarTiempoAutoridad(config, reconciliado, observedAt);
+    const authority = crearAuthorityReceipt(config, previo, anchorPrevio);
+    const entrada = mutarCasEnPruebas(action(estadoPublico(config, previo), authority));
+    validarEntradaAppend(entrada, true);
+    if (entrada.expectedSequence !== previo.sequence
+        || entrada.expectedHeadHash !== previo.headHash) {
+      fallar('LEDGER_CAS_CONFLICT', 'precondición semántica cambió');
+    }
+    const evento = crearEvento(config, previo, entrada, observedAt);
+    const events = [...previo.events, evento];
+    persistirLedger(config, events);
+    hitFault('local-durable-before-anchor-cas');
+    const state = verificarLedger(config);
+    const anchor = avanzarAnchor(config, anchorPrevio, state, observedAt);
+    publicarSnapshot(config, state, anchor);
+    return crearReceiptAppend(config, anchorPrevio, state, anchor);
+  });
+}
+
+function inspect(config, action) {
+  return conLock(config.lockPath, () => {
+    const observedAt = new Date().toISOString();
+    const state = verificarLedger(config);
+    hitFault('after-reread');
+    const reconciliado = reconciliar(config, state, observedAt);
+    const anchor = avanzarTiempoAutoridad(config, reconciliado, observedAt);
+    const authority = crearAuthorityReceipt(config, state, anchor);
+    const result = action(estadoPublico(config, state), authority);
+    publicarSnapshot(config, state, anchor);
+    return result;
+  });
+}
+
+function crearAuthorityReceipt(config, state, anchor) {
+  const receipt = congelarProfundo({
+    kind: 'kernel-authority-receipt', streamId: config.streamId,
+    rootKeyDigest: config.receipt.rootKeyDigest,
+    sequence: state.sequence, headHash: state.headHash,
+    trustEpoch: anchor.trustEpoch, trustDigest: anchor.trustDigest,
+    lastTrustedTime: anchor.lastTrustedTime, observedAt: anchor.lastTrustedTime,
+  });
+  AUTHORITY_RECEIPTS.add(receipt);
+  return receipt;
+}
+
+function leerAutoridad(config) {
+  const observedAt = new Date().toISOString();
+  const state = verificarLedger(config);
+  hitFault('after-reread');
+  const reconciliado = reconciliar(config, state, observedAt);
+  const anchor = avanzarTiempoAutoridad(config, reconciliado, observedAt);
+  validarVigencia(config.receipt, anchor, observedAt);
+  publicarSnapshot(config, state, anchor);
+  return crearAuthorityReceipt(config, state, anchor);
+}
+
+function validarVigencia(receipt, anchor, now) {
+  if (now < receipt.issuedAt || now > receipt.expiresAt) {
+    fallar('BOOTSTRAP_EXPIRED', 'bootstrap fuera de vigencia');
+  }
+  if (now < anchor.lastTrustedTime) fallar('CLOCK_ROLLBACK', 'reloj detrás del anchor');
+}
+
+function validarValorIJson(valor, profundidad) {
+  if (profundidad > 64) fallar('EVENT_INVALID', 'payload demasiado profundo');
+  if (valor === null || typeof valor === 'string' || typeof valor === 'boolean') return;
+  if (typeof valor === 'number' && Number.isFinite(valor)) return;
+  if (!valor || typeof valor !== 'object' || util.types.isProxy(valor)) {
+    fallar('EVENT_INVALID', 'payload inválido');
+  }
+  const proto = Object.getPrototypeOf(valor);
+  const permitido = Array.isArray(valor)
+    ? proto === Array.prototype
+    : proto === Object.prototype || proto === null;
+  if (!permitido || Object.getOwnPropertySymbols(valor).length > 0) {
+    fallar('EVENT_INVALID', 'payload inválido');
+  }
+  for (const [clave, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(valor))) {
+    if (Array.isArray(valor) && clave === 'length') continue;
+    if (!descriptor.enumerable || !('value' in descriptor)) {
+      fallar('EVENT_INVALID', 'payload inválido');
+    }
+    validarValorIJson(descriptor.value, profundidad + 1);
+  }
+}
+
+function cargarPrivateKey(config) {
+  const privateBytes = leerBytesEstables(
+    config.receipt.signerPath, 'SIGNER_UNAVAILABLE', MAX_BYTES.signer
+  );
+  try {
+    const privateKey = crypto.createPrivateKey(privateBytes);
+    if (privateKey.asymmetricKeyType !== 'ed25519') {
+      fallar('SIGNER_INVALID', 'signer no es Ed25519');
+    }
+    return privateKey;
+  } catch {
+    fallar('SIGNER_INVALID', 'signer no es una llave privada');
+  }
+}
+
+function cargarPublicKey(trust) {
+  try {
+    const publicKey = crypto.createPublicKey(trust.integrityPublicKey);
+    if (publicKey.asymmetricKeyType !== 'ed25519') {
+      fallar('TRUST_INVALID', 'llave externa no Ed25519');
+    }
+    return publicKey;
+  } catch {
+    fallar('TRUST_INVALID', 'llave pública externa inválida');
+  }
+}
+
+function validarParFirmante(config, privateKey, publicKey) {
+  const derivada = crypto.createPublicKey(privateKey).export({ format: 'der', type: 'spki' });
+  const esperada = publicKey.export({ format: 'der', type: 'spki' });
+  if (!Buffer.from(derivada).equals(Buffer.from(esperada))) {
+    fallar('SIGNER_INVALID', 'signer no coincide con trust externo');
+  }
+  if (hashBytes(esperada) !== config.signerPublicKeyDigest) {
+    fallar('TRUST_BINDING_INVALID', 'llave externa no coincide con receipt');
+  }
+}
+
+function cargarMaterial(config) {
+  const provisioningPath = process.env.SWL_KERNEL_PROVISIONING_PATH;
+  if (!provisioningPath || !path.isAbsolute(provisioningPath)) {
+    fallar('PROVISIONING_UNAVAILABLE', 'provisioning externo no configurado');
+  }
+  validarRutaExternaSegura(provisioningPath, config.workspaceRoot);
+  for (const ruta of [config.receipt.trustPath, config.receipt.signerPath, config.anchorPath]) {
+    validarRutaExternaSegura(ruta, config.workspaceRoot);
+  }
+  const pin = leerJson(provisioningPath, 'PROVISIONING_UNAVAILABLE', MAX_BYTES.provisioning);
+  validarPin(pin, config);
+  const trust = leerJson(config.receipt.trustPath, 'TRUST_UNAVAILABLE', MAX_BYTES.trust);
+  validarTrust(trust, config);
+  const privateKey = cargarPrivateKey(config);
+  const publicKey = cargarPublicKey(trust);
+  validarParFirmante(config, privateKey, publicKey);
+  return { pin, privateKey, publicKey, trust };
+}
+
+function crearPaths(workspaceRoot, streamId) {
+  const nombre = hashBytes(Buffer.from(streamId)).slice(0, 24);
+  validarDirectorioSeguro(workspaceRoot);
+  const planning = path.join(workspaceRoot, '.planning');
+  asegurarDirectorio(planning, false);
+  const directorio = path.join(planning, 'integrity');
+  asegurarDirectorio(directorio);
+  return {
+    ledgerPath: path.join(directorio, `${nombre}.jsonl`),
+    lockPath: path.join(directorio, `${nombre}.lock`),
+    snapshotPath: path.join(directorio, `${nombre}.snapshot.json`),
+  };
+}
+
+function crearLedger(config) {
+  const paths = congelarProfundo({
+    ledger: config.ledgerPath, lock: config.lockPath, snapshot: config.snapshotPath,
+  });
+  return Object.freeze({
+    append: (entrada) => append(config, entrada),
+    isAppendReceipt: (receipt) => APPEND_RECEIPTS.has(receipt),
+    isAuthorityReceipt: (receipt) => AUTHORITY_RECEIPTS.has(receipt),
+    paths,
+    read: () => conLock(config.lockPath, () => leerVerificado(config)),
+    readAuthority: () => conLock(config.lockPath, () => leerAutoridad(config)),
+    recover: () => conLock(config.lockPath, () => leerVerificado(config)),
+  });
+}
+
+function crearAuthorityWriter(config) {
+  return Object.freeze({
+    inspect: (action) => inspect(config, action),
+    transact: (action) => transact(config, action),
+  });
+}
+
+function createBuiltInKernelRuntime({
+  receipt, workspaceRoot, signerKeyId, signerPublicKeyDigest,
+}) {
+  const validators = getContractValidators();
+  validarBackendArchivos();
+  const config = {
+    receipt, workspaceRoot, signerKeyId, signerPublicKeyDigest,
+    anchorPath: receipt.anchorPath,
+  };
+  Object.assign(config, cargarMaterial(config));
+  config.streamId = config.pin.streamId;
+  Object.assign(config, crearPaths(workspaceRoot, config.streamId));
+  const anchor = leerAnchor(config);
+  validarVigencia(receipt, anchor, new Date().toISOString());
+  const integrityLedger = crearLedger(config);
+  integrityLedger.read();
+  const authorityWriter = crearAuthorityWriter(config);
+  const contexts = createPolicyContextProvider(authorityWriter);
+  const stores = createSingleUseStore(authorityWriter);
+  const singleUseStore = stores.publicStore;
+  const gates = createGateEngine(authorityWriter, singleUseStore, workspaceRoot);
+  const policyBroker = createPolicyBroker({
+    compileBundle: compilarPolicyBundle,
+    contextReader: contexts.authorizationContextReader,
+    gateReader: gates.authorizationGateReader,
+    grantIssuer: stores.authorizationGrantIssuer,
+    isVerifiedOperation: validators.isVerifiedOperation,
+    workspaceRoot,
+    writer: authorityWriter,
+  });
+  return congelarProfundo({
+    gateEngine: gates.publicGateEngine, integrityLedger,
+    policyContextProvider: contexts.publicProvider,
+    policyBroker,
+    providers: structuredClone(receipt.providers),
+    singleUseStore,
+  });
+}
+
+module.exports = { createBuiltInKernelRuntime };