@saulwade/swl-ses 2.6.1 → 2.8.0

package/scripts/lib/runtime-compiler.js

@@ -0,0 +1,327 @@
+'use strict';
+
+const { validarContrato } = require('./harness-ir');
+const { validarPolicyBundle } = require('./policy-bundle');
+const { validarContratoAdapters } = require('./runtime-adapter-contract');
+const {
+  crearLocator,
+  esConjuntoArtefactosVerificado,
+  leerArtefactoVerificado,
+} = require('./runtime-artifact-verifier');
+const { parsearFrontmatter, parsearJSONSeguro } = require('./frontmatter-canonico');
+
+const BUNDLES = new WeakMap();
+const RUNTIMES = Object.freeze({
+  'claude-code': Object.freeze({ target: 'claude', instruction: 'CLAUDE.md', agent: '.md', command: '.md' }),
+  'codex-cli': Object.freeze({ target: 'codex', instruction: 'AGENTS.md', agent: '.toml', command: null }),
+  'gemini-cli': Object.freeze({ target: 'gemini', instruction: 'GEMINI.md', agent: '.md', command: '.toml' }),
+});
+const CORE_PATHS = Object.freeze([
+  'adapter-contract.json',
+  'harness-ir.json',
+  'policy-bundle.json',
+  'schemas/harness-ir.schema.json',
+  'schemas/policy-bundle.schema.json',
+  'schemas/runtime-adapter.schema.json',
+]);
+const OUTPUT_PREFIXES = Object.freeze([
+  'outputs/instructions/',
+  'outputs/agents/',
+  'outputs/skills/',
+  'outputs/rules/',
+  'outputs/commands/',
+  'outputs/hooks/',
+]);
+const SCHEMAS_CANONICOS = Object.freeze({
+  'schemas/harness-ir.schema.json': JSON.stringify(require('../../schemas/harness-ir.schema.json')),
+  'schemas/policy-bundle.schema.json': JSON.stringify(require('../../schemas/policy-bundle.schema.json')),
+  'schemas/runtime-adapter.schema.json': JSON.stringify(require('../../schemas/runtime-adapter.schema.json')),
+});
+const TOML_BASIC = /^([A-Za-z_][A-Za-z0-9_]*) = ("(?:[^"\\\u0000-\u001F]|\\(?:["\\bfnrt]|u[0-9A-Fa-f]{4}))*")$/u;
+const CONTROLES_TOML = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/u;
+const ESCAPE_TOML_VALIDO = /^\\(?:["\\bfnrt]|u[0-9A-Fa-f]{4})/u;
+const EVENTOS_HOOK = Object.freeze({
+  claude: Object.freeze(new Set([
+    'SessionStart', 'PreToolUse', 'PermissionRequest', 'PostToolUse',
+    'UserPromptSubmit', 'Notification', 'Stop', 'SubagentStart', 'SubagentStop', 'PreCompact',
+  ])),
+  codex: Object.freeze(new Set([
+    'SessionStart', 'PreToolUse', 'PermissionRequest', 'PostToolUse', 'UserPromptSubmit', 'Stop',
+  ])),
+  gemini: Object.freeze(new Set(['BeforeTool', 'AfterTool', 'SessionStart'])),
+});
+
+function error(mensaje) {
+  return new TypeError(mensaje);
+}
+
+function parsear(conjunto, ruta, nombre) {
+  const bytes = leerArtefactoVerificado(conjunto, ruta);
+  try {
+    return parsearJSONSeguro(bytes.toString('utf8')).valor;
+  } catch (causa) {
+    throw error(`${nombre} contiene JSON inválido: ${causa.message}`);
+  }
+}
+
+function validarCore(conjunto, rutas, runtimeId, definicion) {
+  for (const ruta of CORE_PATHS) {
+    if (!rutas.has(ruta)) throw error(`artefacto requerido ausente: ${ruta}`);
+  }
+  const contrato = parsear(conjunto, 'adapter-contract.json', 'adapter contract');
+  validarContratoAdapters(contrato);
+  const harness = parsear(conjunto, 'harness-ir.json', 'Harness IR');
+  if (!validarContrato(harness).ok) throw error('Harness IR viola su contrato');
+  const policy = parsear(conjunto, 'policy-bundle.json', 'PolicyBundle');
+  if (!validarPolicyBundle(policy).ok) throw error('PolicyBundle viola su contrato');
+  for (const [ruta, canonico] of Object.entries(SCHEMAS_CANONICOS)) {
+    const schema = parsear(conjunto, ruta, 'schema');
+    if (JSON.stringify(schema) !== canonico) throw error(`schema no canónico: ${ruta}`);
+  }
+}
+
+function exigirExtension(rutas, prefijo, extension, nombre) {
+  const candidatos = rutas.filter((ruta) => ruta.startsWith(prefijo));
+  if (candidatos.length === 0) throw error(`${nombre} requerido`);
+  if (!candidatos.every((ruta) => ruta.endsWith(extension))) {
+    throw error(`${nombre} usa formato incompatible; se requiere ${extension}`);
+  }
+}
+
+function validarInventario(rutas) {
+  for (const ruta of rutas) {
+    const esCore = CORE_PATHS.includes(ruta);
+    const esOutput = OUTPUT_PREFIXES.some((prefijo) => ruta.startsWith(prefijo));
+    if (!esCore && !esOutput) throw error(`artefacto no permitido: ${ruta}`);
+  }
+}
+
+function leerTexto(conjunto, ruta, nombre) {
+  const bytes = leerArtefactoVerificado(conjunto, ruta);
+  const texto = bytes.toString('utf8');
+  if (!Buffer.from(texto, 'utf8').equals(bytes) || texto.trim().length === 0) {
+    throw error(`${nombre} no es texto UTF-8 válido`);
+  }
+  return texto;
+}
+
+function validarFrontmatter(conjunto, ruta, campos) {
+  const texto = leerTexto(conjunto, ruta, ruta);
+  let valor;
+  try {
+    valor = parsearFrontmatter(texto).valor;
+  } catch (causa) {
+    throw error(`${ruta} tiene frontmatter inválido: ${causa.message}`);
+  }
+  if (!valor || Array.isArray(valor)) {
+    throw error(`${ruta} requiere frontmatter`);
+  }
+  for (const campo of campos) {
+    if (typeof valor[campo] !== 'string' || !valor[campo].trim()) {
+      throw error(`${ruta} requiere frontmatter.${campo}`);
+    }
+  }
+}
+
+function separarToml(texto, campoMultilinea, nombre) {
+  if (CONTROLES_TOML.test(texto)) throw error(`${nombre} contiene control TOML inválido`);
+  const marcador = `${campoMultilinea} = `;
+  const coincidencia = new RegExp(`^${marcador}`, 'mu').exec(texto);
+  if (!coincidencia) throw error(`${nombre} TOML requiere ${campoMultilinea}`);
+  const indice = coincidencia.index;
+  const cabecera = texto.slice(0, indice).split(/\r?\n/u)
+    .map((linea) => linea.trim()).filter((linea) => linea && !linea.startsWith('#'));
+  return { cabecera, multilinea: texto.slice(indice + marcador.length).trim() };
+}
+
+function tieneCierreTomlInterno(multilinea, comilla) {
+  const cuerpo = multilinea.slice(comilla.length, -comilla.length);
+  if (comilla === "'''") return cuerpo.includes(comilla);
+  for (let indice = cuerpo.indexOf(comilla); indice >= 0; indice = cuerpo.indexOf(comilla, indice + 1)) {
+    let barras = 0;
+    for (let cursor = indice - 1; cursor >= 0 && cuerpo[cursor] === '\\'; cursor -= 1) barras += 1;
+    if (barras % 2 === 0) return true;
+  }
+  return false;
+}
+
+function tieneEscapeTomlInvalido(cuerpo) {
+  for (let indice = cuerpo.indexOf('\\'); indice >= 0; indice = cuerpo.indexOf('\\', indice + 1)) {
+    const escape = cuerpo.slice(indice).match(ESCAPE_TOML_VALIDO)?.[0];
+    if (!escape) return true;
+    indice += escape.length - 1;
+  }
+  return false;
+}
+
+function validarToml(conjunto, ruta, campoMultilinea, requeridos, opcionales = []) {
+  const texto = leerTexto(conjunto, ruta, ruta);
+  const { cabecera, multilinea } = separarToml(texto, campoMultilinea, ruta);
+  const matches = cabecera.map((linea) => linea.match(TOML_BASIC));
+  const claves = matches.map((match) => match?.[1]);
+  const permitidas = new Set([...requeridos, ...opcionales]);
+  if (claves.some((clave) => !clave || !permitidas.has(clave))) throw error(`${ruta} TOML inválido`);
+  if (new Set(claves).size !== claves.length) throw error(`${ruta} TOML duplica campos`);
+  if (!requeridos.every((campo) => claves.includes(campo))) throw error(`${ruta} TOML incompleto`);
+  for (const match of matches) {
+    if (requeridos.includes(match[1]) && !JSON.parse(match[2]).trim()) {
+      throw error(`${ruta} TOML requerido vacío`);
+    }
+  }
+  const comilla = multilinea.startsWith("'''") ? "'''" : '"""';
+  if (!multilinea.startsWith(comilla) || !multilinea.endsWith(comilla)) {
+    throw error(`${ruta} TOML multilinea inválido`);
+  }
+  if (tieneCierreTomlInterno(multilinea, comilla)) throw error(`${ruta} tiene cierre TOML interno`);
+  const cuerpo = multilinea.slice(comilla.length, -comilla.length);
+  if (!cuerpo.trim()) throw error(`${ruta} TOML multilinea vacío`);
+  if (comilla === '"""' && tieneEscapeTomlInvalido(cuerpo)) {
+    throw error(`${ruta} contiene escape TOML inválido`);
+  }
+}
+
+function validarSkills(conjunto, outputs) {
+  const rutas = outputs.filter((ruta) => ruta.startsWith('outputs/skills/'));
+  if (rutas.length === 0) throw error('skills requerido');
+  const raices = new Set(rutas.map((ruta) => ruta.split('/')[2]));
+  for (const raiz of raices) {
+    const skill = `outputs/skills/${raiz}/SKILL.md`;
+    if (!rutas.includes(skill)) throw error(`skills requiere ${skill}`);
+    validarFrontmatter(conjunto, skill, ['name', 'description']);
+  }
+}
+
+function clavesExactas(valor, permitidas) {
+  return Object.keys(valor).every((clave) => permitidas.includes(clave));
+}
+
+function validarHooks(conjunto, ruta, definicion) {
+  const config = parsear(conjunto, ruta, 'hooks');
+  if (!config || typeof config !== 'object' || Array.isArray(config)) {
+    throw error('hooks debe ser objeto');
+  }
+  if (!config.hooks || typeof config.hooks !== 'object' || Array.isArray(config.hooks)) {
+    throw error('hooks.hooks debe ser objeto');
+  }
+  if (!clavesExactas(config, ['hooks'])) throw error('propiedades hooks raíz no permitidas');
+  for (const [evento, entradas] of Object.entries(config.hooks)) {
+    if (!EVENTOS_HOOK[definicion.target].has(evento)) {
+      throw error(`evento hooks no soportado: ${evento}`);
+    }
+    if (!Array.isArray(entradas)) throw error('hooks event debe ser arreglo');
+    for (const entrada of entradas) validarEntradaHooks(entrada, definicion);
+  }
+}
+
+function validarEntradaHooks(entrada, definicion) {
+  if (!entrada || typeof entrada !== 'object' || Array.isArray(entrada)) {
+    throw error('hooks entrada debe ser objeto');
+  }
+  if (!clavesExactas(entrada, ['matcher', 'hooks'])) {
+    throw error('propiedades hooks entrada no permitidas');
+  }
+  if (entrada.matcher !== undefined && typeof entrada.matcher !== 'string') {
+    throw error('matcher hooks inválido');
+  }
+  if (!Array.isArray(entrada.hooks) || entrada.hooks.length === 0) {
+    throw error('hooks entrada requiere hooks');
+  }
+  for (const hook of entrada.hooks) {
+    validarComandoHook(hook, definicion);
+  }
+}
+
+function validarComandoHook(hook, definicion) {
+  const campos = definicion.target === 'gemini'
+    ? ['name', 'type', 'command', 'timeout']
+    : ['type', 'command', 'timeout'];
+  const esObjeto = hook && typeof hook === 'object' && !Array.isArray(hook);
+  if (!esObjeto || !clavesExactas(hook, campos)) throw error('propiedades hooks command no permitidas');
+  if (hook.type !== 'command' || typeof hook.command !== 'string' || !hook.command.trim()) {
+    throw error('hooks command inválido');
+  }
+  if (definicion.target === 'gemini' && (typeof hook.name !== 'string' || !hook.name.trim())) {
+    throw error('hooks command requiere name');
+  }
+  if (hook.timeout !== undefined && (!Number.isFinite(hook.timeout) || hook.timeout <= 0)) {
+    throw error('timeout hooks inválido');
+  }
+}
+
+function validarAgentes(conjunto, outputs, definicion) {
+  const agentes = outputs.filter((ruta) => ruta.startsWith('outputs/agents/'));
+  exigirExtension(outputs, 'outputs/agents/', definicion.agent, 'agents');
+  for (const ruta of agentes) {
+    if (definicion.target === 'codex') {
+      validarToml(conjunto, ruta, 'developer_instructions', ['name', 'description'], ['sandbox_mode']);
+    } else validarFrontmatter(conjunto, ruta, ['name', 'description']);
+  }
+}
+
+function validarComandos(conjunto, outputs, definicion) {
+  const comandos = outputs.filter((ruta) => ruta.startsWith('outputs/commands/'));
+  if (!definicion.command && comandos.length > 0) throw error('commands no admite archivo nativo');
+  if (!definicion.command) return;
+  exigirExtension(outputs, 'outputs/commands/', definicion.command, 'commands');
+  for (const ruta of comandos) {
+    if (definicion.target === 'gemini') validarToml(conjunto, ruta, 'prompt', ['description']);
+    else validarFrontmatter(conjunto, ruta, ['description']);
+  }
+}
+
+function validarOutputs(conjunto, rutas, definicion) {
+  validarInventario(rutas);
+  const outputs = rutas.filter((ruta) => ruta.startsWith('outputs/'));
+  const instruccion = `outputs/instructions/${definicion.instruction}`;
+  const instrucciones = outputs.filter((ruta) => ruta.startsWith('outputs/instructions/'));
+  if (instrucciones.length !== 1 || instrucciones[0] !== instruccion) {
+    throw error(`instructions requiere exactamente: ${instruccion}`);
+  }
+  leerTexto(conjunto, instruccion, 'instructions');
+  validarAgentes(conjunto, outputs, definicion);
+  validarSkills(conjunto, outputs);
+  exigirExtension(outputs, 'outputs/rules/', '.md', 'rules');
+  outputs.filter((ruta) => ruta.startsWith('outputs/rules/'))
+    .forEach((ruta) => leerTexto(conjunto, ruta, 'rules'));
+  validarComandos(conjunto, outputs, definicion);
+  const hooks = outputs.filter((ruta) => ruta.startsWith('outputs/hooks/'));
+  if (hooks.length !== 1 || hooks[0] !== 'outputs/hooks/hooks.json') throw error('hooks requiere hooks.json');
+  validarHooks(conjunto, hooks[0], definicion);
+}
+
+function compilarRuntimeBundle(runtimeId, conjunto) {
+  const definicion = RUNTIMES[runtimeId];
+  if (!definicion) throw error(`runtime desconocido: ${runtimeId}`);
+  if (!esConjuntoArtefactosVerificado(conjunto)) throw error('se requiere conjunto verificado con brand');
+  const rutas = conjunto.entries.map(({ path }) => path);
+  if (rutas.includes('locator.json')) throw error('locator.json es reservado y no admite inyección');
+  const rutasSet = new Set(rutas);
+  validarCore(conjunto, rutasSet, runtimeId, definicion);
+  validarOutputs(conjunto, rutas, definicion);
+  const bundle = Object.freeze({
+    kind: 'swl-runtime-bundle',
+    schemaVersion: '1.0.0',
+    runtimeId,
+    installerTarget: definicion.target,
+    effectiveMode: 'proposal_only',
+    locator: crearLocator(conjunto),
+  });
+  BUNDLES.set(bundle, conjunto);
+  return bundle;
+}
+
+function esRuntimeBundleCompilado(valor) {
+  return BUNDLES.has(valor);
+}
+
+function leerArtefactoRuntime(bundle, ruta) {
+  const conjunto = BUNDLES.get(bundle);
+  if (!conjunto) throw error('se requiere bundle verificado');
+  return leerArtefactoVerificado(conjunto, ruta);
+}
+
+module.exports = {
+  compilarRuntimeBundle,
+  esRuntimeBundleCompilado,
+  leerArtefactoRuntime,
+};

package/scripts/lib/runtime-conformance.js

@@ -0,0 +1,202 @@
+'use strict';
+
+/**
+ * Store fail-closed de claims runtime C10/W0b.
+ *
+ * El manifiesto empaquetado no depende de `.planning/`. La comparación contra
+ * el censo congelado es un gate separado que sólo se ejecuta en el repositorio.
+ *
+ * @module scripts/lib/runtime-conformance
+ */
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const RAIZ = path.resolve(__dirname, '..', '..');
+const MANIFEST_DEFAULT = path.join(RAIZ, 'manifiestos', 'runtime-conformance.json');
+const SCHEMA_MAJOR = 1;
+const ESTADO_BOOTSTRAP = 'unverified';
+const LABEL_BOOTSTRAP = 'experimental';
+const HASH_PATTERN = /^[a-f0-9]{64}$/;
+const DOMAIN_IDS = Object.freeze([
+  'adopcion',
+  'discovery-producto',
+  'arquitectura-planeacion',
+  'implementacion',
+  'calidad',
+  'seguridad',
+  'entrega-operacion',
+  'mantenimiento',
+  'aprendizaje',
+]);
+const TARGET_MAP = Object.freeze({
+  'claude-code': 'claude',
+  openclaude: 'openclaude',
+  opencode: 'opencode',
+  'gemini-cli': 'gemini',
+  cursor: 'cursor',
+  'codex-cli': 'codex',
+  'github-copilot': 'copilot',
+});
+const CAMPOS_RAIZ = [
+  '$schemaVersion',
+  'kind',
+  'sourceCensus',
+  'migration',
+  'domains',
+  'runtimes',
+];
+
+function esObjetoPlano(valor) {
+  if (valor === null || typeof valor !== 'object' || Array.isArray(valor)) return false;
+  const prototipo = Object.getPrototypeOf(valor);
+  return prototipo === Object.prototype || prototipo === null;
+}
+
+function assertShape(valor, campos, nombre) {
+  if (!esObjetoPlano(valor)) throw new TypeError(`${nombre} debe ser objeto plano`);
+  const faltantes = campos.filter((campo) => !Object.hasOwn(valor, campo));
+  if (faltantes.length > 0) throw new TypeError(`${nombre}: campo requerido ${faltantes[0]}`);
+  const desconocidos = Object.keys(valor).filter((campo) => !campos.includes(campo));
+  if (desconocidos.length > 0) {
+    throw new TypeError(`${nombre}: campo desconocido ${desconocidos[0]}`);
+  }
+}
+
+function assertArrayExacta(valor, longitud, nombre) {
+  if (!Array.isArray(valor) || valor.length !== longitud) {
+    throw new TypeError(`${nombre} debe contener exactamente ${longitud}`);
+  }
+}
+
+function validarVersionYTipo(conformance) {
+  const version = conformance.$schemaVersion;
+  if (typeof version !== 'string' || !/^\d+\.\d+\.\d+$/.test(version)) {
+    throw new TypeError('$schemaVersion inválida');
+  }
+  if (version !== `${SCHEMA_MAJOR}.0.0`) {
+    throw new TypeError('versión de schema bootstrap incompatible; migración explícita requerida');
+  }
+  if (conformance.kind !== 'swl-runtime-claims-bootstrap') {
+    throw new TypeError('kind de conformance inválido');
+  }
+}
+
+function validarFuenteCenso(fuente) {
+  assertShape(fuente, ['repositoryPath', 'sha256', 'denominator'], 'sourceCensus');
+  const pathEsperado = '.planning/audit/certificacion-10/runtime-census.json';
+  if (fuente.repositoryPath !== pathEsperado) throw new TypeError('ruta de censo inválida');
+  if (typeof fuente.sha256 !== 'string' || !HASH_PATTERN.test(fuente.sha256)) {
+    throw new TypeError('sha256 del censo inválido');
+  }
+  if (fuente.denominator !== 7) throw new TypeError('denominador debe conservar siete runtimes');
+}
+
+function validarMigracion(migration) {
+  const campos = ['harnessIrPhase', 'evaluatorPhase', 'requiresSchemaMajor'];
+  assertShape(migration, campos, 'migration');
+  if (migration.harnessIrPhase !== 29 || migration.evaluatorPhase !== 32) {
+    throw new TypeError('fases de migración inválidas');
+  }
+  if (migration.requiresSchemaMajor !== true) {
+    throw new TypeError('la migración debe requerir schema major');
+  }
+}
+
+function validarDominios(dominios) {
+  assertArrayExacta(dominios, DOMAIN_IDS.length, 'domains');
+  dominios.forEach((dominio, indice) => {
+    assertShape(dominio, ['id', 'securityCritical'], `domain ${indice}`);
+    if (dominio.id !== DOMAIN_IDS[indice]) throw new TypeError('orden o ID de dominio inválido');
+    const criticaEsperada = dominio.id === 'seguridad';
+    if (dominio.securityCritical !== criticaEsperada) {
+      throw new TypeError('sólo seguridad puede ser crítica');
+    }
+  });
+}
+
+function validarEstadosDominio(dominios, runtimeId) {
+  assertShape(dominios, DOMAIN_IDS, `dominios de ${runtimeId}`);
+  for (const domainId of DOMAIN_IDS) {
+    if (dominios[domainId] !== ESTADO_BOOTSTRAP) {
+      throw new TypeError(`${runtimeId}.${domainId} debe permanecer unverified`);
+    }
+  }
+}
+
+function validarRuntime(runtime, indice) {
+  const campos = ['id', 'installerTarget', 'certificationStatus', 'domains'];
+  assertShape(runtime, campos, `runtime ${indice}`);
+  const idEsperado = Object.keys(TARGET_MAP)[indice];
+  if (runtime.id !== idEsperado) throw new TypeError('orden, duplicado o ID de runtime inválido');
+  if (runtime.installerTarget !== TARGET_MAP[idEsperado]) {
+    throw new TypeError(`installerTarget inválido para ${runtime.id}`);
+  }
+  if (runtime.certificationStatus !== ESTADO_BOOTSTRAP) {
+    throw new TypeError(`${runtime.id} debe permanecer unverified`);
+  }
+  validarEstadosDominio(runtime.domains, runtime.id);
+}
+
+function validarRuntimes(runtimes) {
+  const idsEsperados = Object.keys(TARGET_MAP);
+  assertArrayExacta(runtimes, idsEsperados.length, 'runtimes');
+  runtimes.forEach(validarRuntime);
+}
+
+function validarConformance(conformance) {
+  assertShape(conformance, CAMPOS_RAIZ, 'runtime conformance');
+  validarVersionYTipo(conformance);
+  validarFuenteCenso(conformance.sourceCensus);
+  validarMigracion(conformance.migration);
+  validarDominios(conformance.domains);
+  validarRuntimes(conformance.runtimes);
+  return conformance;
+}
+
+function cargarConformance(opciones = {}) {
+  const manifestPath = opciones.manifestPath || MANIFEST_DEFAULT;
+  const contenido = fs.readFileSync(manifestPath, 'utf8');
+  return validarConformance(JSON.parse(contenido));
+}
+
+function derivarSupportLabel(runtime) {
+  const indice = Object.keys(TARGET_MAP).indexOf(runtime && runtime.id);
+  if (indice < 0) throw new TypeError('runtime desconocido para derivar supportLabel');
+  validarRuntime(runtime, indice);
+  return LABEL_BOOTSTRAP;
+}
+
+function calcularSha256(contenido) {
+  return crypto.createHash('sha256').update(contenido).digest('hex');
+}
+
+function validarEstructuraCenso(censo, idsEsperados) {
+  if (!esObjetoPlano(censo) || censo.denominador !== idsEsperados.length) {
+    throw new TypeError('denominador del censo no coincide');
+  }
+  const ids = Array.isArray(censo.runtimes) ? censo.runtimes.map(({ id }) => id) : [];
+  if (JSON.stringify(ids) !== JSON.stringify(idsEsperados)) {
+    throw new TypeError('orden o IDs del censo no coinciden');
+  }
+}
+
+function validarContraCenso(conformance, censusPath) {
+  validarConformance(conformance);
+  const contenido = fs.readFileSync(censusPath);
+  if (calcularSha256(contenido) !== conformance.sourceCensus.sha256) {
+    throw new TypeError('digest del censo no coincide');
+  }
+  validarEstructuraCenso(JSON.parse(contenido.toString('utf8')), Object.keys(TARGET_MAP));
+  return { ok: true, denominator: conformance.sourceCensus.denominator };
+}
+
+module.exports = {
+  DOMAIN_IDS,
+  TARGET_MAP,
+  cargarConformance,
+  derivarSupportLabel,
+  validarConformance,
+  validarContraCenso,
+};