create-lexy 0.5.0 → 0.6.0

package/dist/index.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import{readFileSync as Et}from"fs";import ke from"path";import{fileURLToPath as It}from"url";import{Command as Lt}from"commander";import kt from"picocolors";import{spawn as De}from"child_process";import K from"fs/promises";import B from"path";import{confirm as Me,isCancel as qe,spinner as fe}from"@clack/prompts";import h from"picocolors";import Y from"path";var Fe=(e,t)=>t.architecture!=="feature"?e:e.replace(/from ["']@\/lib\/utils\/cn["']/g,'from "@/shared/lib/utils/cn"').replace(/from ["']@\/components\/base\//g,'from "@/shared/components/base/'),Te=[["components/base/",e=>e.paths.components],["views/",e=>e.paths.views],["hooks/",e=>e.paths.hooks],["lib/",e=>e.paths.lib]],P=(e,t)=>e.files.filter(o=>typeof o.content=="string").map(o=>{let n=Te.find(([s])=>o.path.startsWith(s));return{relPath:n?Y.posix.join(n[1](t),o.path.slice(n[0].length)):Y.posix.join(t.paths.components,Y.posix.basename(o.path)),content:Fe(o.content,t)}});import ie from"fs/promises";import Se from"path";var ae=e=>Se.join(e,".lexy"),k=async e=>{let t;try{t=await ie.readFile(ae(e),"utf-8")}catch{throw new Error("No se encontr\xF3 el archivo .lexy. \xBFEst\xE1s en la ra\xEDz de un proyecto Lexy? (cr\xE9alo con `npx create-lexy create`)")}let o=JSON.parse(t);if(!o.paths?.components)throw new Error("El .lexy no tiene paths.components \u2014 archivo corrupto o de una versi\xF3n incompatible.");return o.installed??={},o},ce=async(e,t)=>{await ie.writeFile(ae(e),JSON.stringify(t,null,2)+`
-`)};import M from"fs/promises";import Re from"os";import $ from"path";import{fileURLToPath as Oe}from"url";var le="@lexydesign/registry",O=`https://cdn.jsdelivr.net/npm/${le}`,Ae=8e3,H=$.resolve($.dirname(Oe(import.meta.url)),"../assets"),Ne=$.join(Re.homedir(),".cache","create-lexy","registry"),U=async e=>{let t=await fetch(e,{signal:AbortSignal.timeout(Ae)});if(!t.ok){let o=new Error(`HTTP ${t.status} al pedir ${e}`);throw o.status=t.status,o}return await t.json()},pe=async e=>{try{return JSON.parse(await M.readFile($.join(H,"r",e),"utf-8"))}catch{return null}},X=async()=>{try{return(await M.readFile($.join(H,"registry-version"),"utf-8")).trim()}catch{return"bundle"}},R=null,J=async()=>{if(R)return R;try{R=(await U(`https://registry.npmjs.org/${le}/latest`)).version}catch{try{R=(await U(`${O}@latest/package.json`)).version}catch{R=await X()}}return R},x=async(e,t)=>{let o=e.replace(/^@lexy\//,""),n=t??await J(),r=$.join(Ne,n,`${o}.json`);try{return{item:JSON.parse(await M.readFile(r,"utf-8")),version:n,source:"cache"}}catch{}try{let s=await U(`${O}@${n}/r/${o}.json`);return await M.mkdir($.dirname(r),{recursive:!0}),await M.writeFile(r,JSON.stringify(s)),{item:s,version:n,source:"cdn"}}catch(s){if(s.status===404)throw new Error(`El componente "${o}" no existe en el registry (versi\xF3n ${n}). Mira el cat\xE1logo con \`create-lexy view --list\`.`);let i=await pe(`${o}.json`);if(i)return{item:i,version:await X(),source:"bundle"};throw new Error(`No se pudo alcanzar el registry (\xBFsin red?) y "${o}" tampoco est\xE1 en el bundle local del CLI.`)}},de=async()=>{try{let e=await J();return{index:await U(`${O}@${e}/r/registry.json`),version:e,source:"cdn"}}catch{let e=await pe("registry.json");if(e)return{index:e,version:await X(),source:"bundle"};throw new Error("No se pudo alcanzar el registry ni leer el bundle local del CLI.")}},me=$.join(H,"theme/lexy-theme.css"),ue=$.join(H,"fonts");var _e=(e,t)=>new Promise((o,n)=>{De("pnpm",["add",...e],{cwd:t,stdio:"ignore",shell:!0}).on("close",s=>s===0?o():n(new Error(`pnpm add fall\xF3 con c\xF3digo ${s}`)))}),ze=async e=>{try{return await K.readFile(e,"utf-8")}catch{return null}},ge=async(e,t)=>{let o=process.cwd(),n=await k(o),r=fe();r.start("Resolviendo componentes en el registry...");let s=new Map,i=async a=>{let l=a.toLowerCase().replace(/^@lexy\//,"");if(s.has(l))return;let f=await x(l);s.set(l,f);for(let b of f.item.registryDependencies??[])await i(b)};try{for(let a of e)await i(a)}catch(a){throw r.stop(h.red("No se pudo resolver el pedido.")),a}let p=new Map;for(let[a,{item:l}]of s){let f=[];for(let b of P(l,n)){let L=await ze(B.join(o,b.relPath));f.push({...b,status:L===null?"new":L===b.content?"same":"differs"})}p.set(a,f)}let c=Array.from(p.values()).flat().filter(a=>a.status==="differs");if(r.stop(`Resueltos: ${Array.from(s.keys()).join(", ")}`),c.length>0&&!t.overwrite){let a=c.map(l=>`  ${l.relPath}`).join(`
-`);if(process.stdout.isTTY&&process.stdin.isTTY){let l=await Me({message:`Estos archivos existen con cambios locales y ser\xE1n sobrescritos:
-${a}
-\xBFContinuar?`});if(qe(l)||l!==!0){console.log(h.yellow("Operaci\xF3n cancelada \u2014 nada fue modificado.")),process.exitCode=1;return}}else{console.error(h.red(`Estos archivos existen con cambios locales:
-`)+a+h.dim(`
-Usa --overwrite para sobrescribirlos.`)),process.exitCode=1;return}}for(let[a,l]of p){let{item:f,version:b,source:L}=s.get(a);for(let y of l){if(y.status==="same")continue;let C=B.join(o,y.relPath);await K.mkdir(B.dirname(C),{recursive:!0}),await K.writeFile(C,y.content)}n.installed[f.name]=b;let V=e.map(y=>y.toLowerCase()).includes(a)?"":h.dim(" (dependencia)"),D=L==="bundle"?h.yellow(" [bundle local \u2014 sin red]"):"";console.log(h.green(`${h.bold(f.title??f.name)} instalado`)+V+h.cyan(` \u2192 ${n.paths.components}/`)+D);for(let y of l){let C=y.status==="same"?h.dim(" (sin cambios)"):"";console.log(h.dim(`   ${y.relPath}${C}`))}}await ce(o,n);let d=new Set;for(let{item:a}of s.values())for(let l of a.dependencies??[])d.add(l);let m=JSON.parse(await K.readFile(B.join(o,"package.json"),"utf-8")),g={...m.dependencies,...m.devDependencies},z=a=>{let l=a.lastIndexOf("@");return l>0?a.slice(0,l):a},u=Array.from(d).filter(a=>!g[z(a)]);if(u.length>0)if(t.install===!1)console.log(h.yellow(`Dependencias pendientes (inst\xE1lalas t\xFA): ${u.join(", ")}`));else{let a=fe();a.start(`Instalando dependencias: ${u.join(", ")}...`),await _e(u,o),a.stop("Dependencias instaladas.")}};import{spawn as ut}from"child_process";import{note as ft,outro as gt,spinner as yt}from"@clack/prompts";import v from"picocolors";import{cancel as Ve,intro as Ue,isCancel as He,select as he,text as Je}from"@clack/prompts";import xe from"picocolors";var Q=[{value:"screen",label:"Una pantalla o flujo corto",hint:"landing, formulario, demo \u2014 sin navegaci\xF3n entre secciones",architecture:"layer"},{value:"app",label:"Una app con secciones y navegaci\xF3n",hint:"dashboard, listados, detalle \u2014 varias vistas con router",architecture:"feature"}],ye=e=>Q.find(t=>t.value===e).architecture;var Be=`
+import{readFileSync as To}from"fs";import tt from"path";import{fileURLToPath as Mo}from"url";import{Command as Lo}from"commander";import zo from"picocolors";import{spawn as lt}from"child_process";import W from"fs/promises";import Z from"path";import{confirm as dt,isCancel as pt,spinner as je}from"@clack/prompts";import S from"picocolors";import te from"path";var ot=(e,t)=>t.architecture!=="feature"?e:e.replace(/from ["']@\/lib\/utils\/cn["']/g,'from "@/shared/lib/utils/cn"').replace(/from ["']@\/components\/base\//g,'from "@/shared/components/base/'),nt=[["components/base/",e=>e.paths.components],["views/",e=>e.paths.views],["hooks/",e=>e.paths.hooks],["lib/",e=>e.paths.lib]],C=(e,t)=>e.files.filter(o=>typeof o.content=="string").map(o=>{let r=nt.find(([i])=>o.path.startsWith(i));return{relPath:r?te.posix.join(r[1](t),o.path.slice(r[0].length)):te.posix.join(t.paths.components,te.posix.basename(o.path)),content:ot(o.content,t)}});import xe from"fs/promises";import at from"path";var be=e=>at.join(e,".lexy"),L=async e=>{let t;try{t=await xe.readFile(be(e),"utf-8")}catch{throw new Error("No se encontr\xF3 el archivo .lexy. \xBFEst\xE1s en la ra\xEDz de un proyecto Lexy? (cr\xE9alo con `npx create-lexy create`)")}let o=JSON.parse(t);if(!o.paths?.components)throw new Error("El .lexy no tiene paths.components \u2014 archivo corrupto o de una versi\xF3n incompatible.");return o.installed??={},o},Ie=async(e,t)=>{await xe.writeFile(be(e),JSON.stringify(t,null,2)+`
+`)};import N from"fs/promises";import rt from"os";import j from"path";import{fileURLToPath as it}from"url";var Ee="@lexydesign/registry",F=`https://cdn.jsdelivr.net/npm/${Ee}`,st=8e3,J=j.resolve(j.dirname(it(import.meta.url)),"../assets"),ct=j.join(rt.homedir(),".cache","create-lexy","registry"),B=async e=>{let t=await fetch(e,{signal:AbortSignal.timeout(st)});if(!t.ok){let o=new Error(`HTTP ${t.status} al pedir ${e}`);throw o.status=t.status,o}return await t.json()},ke=async e=>{try{return JSON.parse(await N.readFile(j.join(J,"r",e),"utf-8"))}catch{return null}},oe=async()=>{try{return(await N.readFile(j.join(J,"registry-version"),"utf-8")).trim()}catch{return"bundle"}},_=null,G=async()=>{if(_)return _;try{_=(await B(`https://registry.npmjs.org/${Ee}/latest`)).version}catch{try{_=(await B(`${F}@latest/package.json`)).version}catch{_=await oe()}}return _},x=async(e,t)=>{let o=e.replace(/^@lexy\//,""),r=t??await G(),a=j.join(ct,r,`${o}.json`);try{return{item:JSON.parse(await N.readFile(a,"utf-8")),version:r,source:"cache"}}catch{}try{let i=await B(`${F}@${r}/r/${o}.json`);return await N.mkdir(j.dirname(a),{recursive:!0}),await N.writeFile(a,JSON.stringify(i)),{item:i,version:r,source:"cdn"}}catch(i){if(i.status===404)throw new Error(`El componente "${o}" no existe en el registry (versi\xF3n ${r}). Mira el cat\xE1logo con \`create-lexy view --list\`.`);let n=await ke(`${o}.json`);if(n)return{item:n,version:await oe(),source:"bundle"};throw new Error(`No se pudo alcanzar el registry (\xBFsin red?) y "${o}" tampoco est\xE1 en el bundle local del CLI.`)}},we=async()=>{try{let e=await G();return{index:await B(`${F}@${e}/r/registry.json`),version:e,source:"cdn"}}catch{let e=await ke("registry.json");if(e)return{index:e,version:await oe(),source:"bundle"};throw new Error("No se pudo alcanzar el registry ni leer el bundle local del CLI.")}},Pe=j.join(J,"theme/lexy-theme.css"),Ce=j.join(J,"fonts");var mt=(e,t)=>new Promise((o,r)=>{lt("pnpm",["add",...e],{cwd:t,stdio:"ignore",shell:!0}).on("close",i=>i===0?o():r(new Error(`pnpm add fall\xF3 con c\xF3digo ${i}`)))}),ut=async e=>{try{return await W.readFile(e,"utf-8")}catch{return null}},Re=async(e,t)=>{let o=process.cwd(),r=await L(o),a=je();a.start("Resolviendo componentes en el registry...");let i=new Map,n=async m=>{let h=m.toLowerCase().replace(/^@lexy\//,"");if(i.has(h))return;let s=await x(h);i.set(h,s);for(let c of s.item.registryDependencies??[])await n(c)};try{for(let m of e)await n(m)}catch(m){throw a.stop(S.red("No se pudo resolver el pedido.")),m}let p=new Map;for(let[m,{item:h}]of i){let s=[];for(let c of C(h,r)){let g=await ut(Z.join(o,c.relPath));s.push({...c,status:g===null?"new":g===c.content?"same":"differs"})}p.set(m,s)}let l=Array.from(p.values()).flat().filter(m=>m.status==="differs");if(a.stop(`Resueltos: ${Array.from(i.keys()).join(", ")}`),l.length>0&&!t.overwrite){let m=l.map(h=>`  ${h.relPath}`).join(`
+`);if(process.stdout.isTTY&&process.stdin.isTTY){let h=await dt({message:`Estos archivos existen con cambios locales y ser\xE1n sobrescritos:
+${m}
+\xBFContinuar?`});if(pt(h)||h!==!0){console.log(S.yellow("Operaci\xF3n cancelada \u2014 nada fue modificado.")),process.exitCode=1;return}}else{console.error(S.red(`Estos archivos existen con cambios locales:
+`)+m+S.dim(`
+Usa --overwrite para sobrescribirlos.`)),process.exitCode=1;return}}for(let[m,h]of p){let{item:s,version:c,source:g}=i.get(m);for(let v of h){if(v.status==="same")continue;let O=Z.join(o,v.relPath);await W.mkdir(Z.dirname(O),{recursive:!0}),await W.writeFile(O,v.content)}r.installed[s.name]=c;let I=e.map(v=>v.toLowerCase()).includes(m)?"":S.dim(" (dependencia)"),q=g==="bundle"?S.yellow(" [bundle local \u2014 sin red]"):"";console.log(S.green(`${S.bold(s.title??s.name)} instalado`)+I+S.cyan(` \u2192 ${r.paths.components}/`)+q);for(let v of h){let O=v.status==="same"?S.dim(" (sin cambios)"):"";console.log(S.dim(`   ${v.relPath}${O}`))}}await Ie(o,r);let y=new Set;for(let{item:m}of i.values())for(let h of m.dependencies??[])y.add(h);let u=JSON.parse(await W.readFile(Z.join(o,"package.json"),"utf-8")),d={...u.dependencies,...u.devDependencies},P=m=>{let h=m.lastIndexOf("@");return h>0?m.slice(0,h):m},V=Array.from(y).filter(m=>!d[P(m)]);if(V.length>0)if(t.install===!1)console.log(S.yellow(`Dependencias pendientes (inst\xE1lalas t\xFA): ${V.join(", ")}`));else{let m=je();m.start(`Instalando dependencias: ${V.join(", ")}...`),await mt(V,o),m.stop("Dependencias instaladas.")}};import{spawn as ho}from"child_process";import{note as go,outro as vo,spinner as So}from"@clack/prompts";import E from"picocolors";import{cancel as ft,intro as yt,isCancel as ht,select as Me,text as gt}from"@clack/prompts";import Le from"picocolors";var ne=[{value:"screen",label:"Una pantalla o flujo corto",hint:"landing, formulario, demo \u2014 sin navegaci\xF3n entre secciones",architecture:"layer"},{value:"app",label:"Una app con secciones y navegaci\xF3n",hint:"dashboard, listados, detalle \u2014 varias vistas con router",architecture:"feature"}],Te=e=>ne.find(t=>t.value===e).architecture;var vt=`
   ######                  ######
   ##::+####            ####+::##
    #-..:+################+:..:#
@@ -20,9 +20,2399 @@ Usa --overwrite para sobrescribirlos.`)),process.exitCode=1;return}}for(let[a,l]
    ...........:====:...........
       ......................
           ..............
-`,Z=e=>{He(e)&&(Ve("Operaci\xF3n cancelada por el usuario."),process.exit(0))},we=async e=>{console.clear(),Ue(`${xe.cyan(Be)}
-${xe.bold(" Bienvenido al generador de proyectos Lexy")}`);let t=e;if(!t){let r=await Je({message:"\xBFCu\xE1l es el nombre de tu proyecto?",placeholder:"lexy-app",validate:s=>{if(!s||s.trim()==="")return"El nombre es obligatorio.";if(!/^(?:@[a-z0-9-*~][a-z0-9-*._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(s))return"El nombre debe estar en min\xFAsculas, sin espacios ni caracteres especiales."}});Z(r),t=r}let o=await he({message:"\xBFPara qui\xE9n es este proyecto?",options:[{label:"Clientes de Lexy",value:"cliente",hint:"Producto de cara al cliente final"},{label:"Equipo interno / CRM",value:"crm",hint:"Herramienta densa para el equipo Lexy"},{label:"Ambos o a\xFAn no lo s\xE9",value:"mixto",hint:"Se decide por pantalla m\xE1s adelante"}],initialValue:"mixto"});Z(o);let n=await he({message:"\xBFC\xF3mo es lo que vas a construir?",options:Q.map(r=>({label:r.label,value:r.value,hint:r.hint})),initialValue:"app"});return Z(n),{projectName:t,architecture:ye(n),world:o}};import E from"fs/promises";import I from"path";var Ke={feature:["src/app","src/features","src/shared/assets","src/shared/components/base","src/shared/hooks","src/shared/services","src/shared/lib","src/shared/types"],layer:["src/assets","src/components/base","src/hooks","src/services","src/lib","src/types","src/views","src/stores"]},Ge="10.33.3",We=e=>{let t=e.architecture==="feature"?{"react-router":"^7.9.0"}:{};return JSON.stringify({name:e.projectName,private:!0,version:"0.0.0",type:"module",packageManager:`pnpm@${Ge}`,scripts:{dev:"vite",build:"tsc -b && vite build",preview:"vite preview",lint:"eslint .",format:"prettier --write ."},dependencies:{clsx:"^2.1.1",react:"^19.2.6","react-dom":"^19.2.6",...t,"tailwind-merge":"^3.3.1"},devDependencies:{"@babel/core":"^7.29.7","@eslint/js":"^10.0.1","@rolldown/plugin-babel":"^0.2.3","@tailwindcss/vite":"^4.3.0","@types/babel__core":"^7.20.5","@types/node":"^24.12.3","@types/react":"^19.2.14","@types/react-dom":"^19.2.3","@vitejs/plugin-react":"^6.0.1","babel-plugin-react-compiler":"^1.0.0",eslint:"^10.4.1","eslint-plugin-jsx-a11y":"^6.10.2","eslint-plugin-react-hooks":"^7.1.1","eslint-plugin-simple-import-sort":"^13.0.0",globals:"^17.6.0",prettier:"^3.8.4",tailwindcss:"^4.3.0",terser:"^5.48.0",typescript:"~5.9.3","typescript-eslint":"^8.61.0",vite:"^8.0.12"}},null,2)+`
-`},Ye=`import path from "node:path";
+`,ae=e=>{ht(e)&&(ft("Operaci\xF3n cancelada por el usuario."),process.exit(0))},ze=async e=>{console.clear(),yt(`${Le.cyan(vt)}
+${Le.bold(" Bienvenido al generador de proyectos Lexy")}`);let t=e;if(!t){let a=await gt({message:"\xBFCu\xE1l es el nombre de tu proyecto?",placeholder:"lexy-app",validate:i=>{if(!i||i.trim()==="")return"El nombre es obligatorio.";if(!/^(?:@[a-z0-9-*~][a-z0-9-*._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(i))return"El nombre debe estar en min\xFAsculas, sin espacios ni caracteres especiales."}});ae(a),t=a}let o=await Me({message:"\xBFPara qui\xE9n es este proyecto?",options:[{label:"Clientes de Lexy",value:"cliente",hint:"Producto de cara al cliente final"},{label:"Equipo interno / CRM",value:"crm",hint:"Herramienta densa para el equipo Lexy"},{label:"Ambos o a\xFAn no lo s\xE9",value:"mixto",hint:"Se decide por pantalla m\xE1s adelante"}],initialValue:"mixto"});ae(o);let r=await Me({message:"\xBFC\xF3mo es lo que vas a construir?",options:ne.map(a=>({label:a.label,value:a.value,hint:a.hint})),initialValue:"app"});return ae(r),{projectName:t,architecture:Te(r),world:o}};import R from"fs/promises";import T from"path";import Ae from"fs/promises";import Oe from"path";var re="src/prototype/data-contract/prototype-data-contract.ts",St="src/prototype/data-contract/data-contract-schema.ts",xt="scripts/check-data-contract.ts",bt=String.raw`import { z } from "zod";
+
+const camelCaseIdSchema = z
+  .string()
+  .regex(/^[a-z][a-zA-Z0-9]*$/, "Debe usar camelCase y comenzar con una letra minúscula.");
+
+const nonEmptyTextSchema = z.string().trim().min(1, "No puede quedar vacío.");
+const experienceLabelsSchema = z
+  .array(nonEmptyTextSchema)
+  .min(1, "Debe indicar al menos un uso dentro de la experiencia.");
+
+export const dataOriginSchema = z.enum([
+  "lexyConfirmed",
+  "productAssumption",
+  "generatedByUsability",
+]);
+
+export const technicalValidationStatusSchema = z.enum(["validated", "pendingTi", "rejected"]);
+
+export const dataClassificationSchema = z.enum(["public", "internal", "sensitive", "restricted"]);
+
+export const technicalValidationSchema = z
+  .object({
+    status: technicalValidationStatusSchema,
+    note: nonEmptyTextSchema.optional(),
+    validatedBy: nonEmptyTextSchema.optional(),
+    validatedAt: z.string().datetime({ offset: true }).optional(),
+    evidence: nonEmptyTextSchema.optional(),
+  })
+  .strict()
+  .superRefine((validation, context) => {
+    if (validation.status === "pendingTi" && !validation.note) {
+      context.addIssue({
+        code: "custom",
+        path: ["note"],
+        message: "Un pendiente de TI debe explicar qué necesita validarse.",
+      });
+    }
+
+    if (validation.status === "validated") {
+      if (!validation.validatedBy) {
+        context.addIssue({
+          code: "custom",
+          path: ["validatedBy"],
+          message: "Un dato validado debe indicar quién lo validó.",
+        });
+      }
+      if (!validation.validatedAt) {
+        context.addIssue({
+          code: "custom",
+          path: ["validatedAt"],
+          message: "Un dato validado debe indicar cuándo fue validado.",
+        });
+      }
+    }
+  });
+
+const backendReferenceSchema = z
+  .string()
+  .regex(
+    /^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)*$/,
+    "Las referencias de Lexy deben usar snake_case, por ejemplo cliente.rut_cliente.",
+  );
+
+export const sourceReferenceSchema = z
+  .object({
+    kind: z.enum(["lexyEntity", "lexyProjection", "api", "derived", "unknown"]),
+    reference: nonEmptyTextSchema.optional(),
+  })
+  .strict()
+  .superRefine((source, context) => {
+    if ((source.kind === "lexyEntity" || source.kind === "lexyProjection") && !source.reference) {
+      context.addIssue({
+        code: "custom",
+        path: ["reference"],
+        message: "La fuente Lexy debe indicar su referencia en snake_case.",
+      });
+      return;
+    }
+
+    if (source.reference && (source.kind === "lexyEntity" || source.kind === "lexyProjection")) {
+      const result = backendReferenceSchema.safeParse(source.reference);
+      if (!result.success) {
+        context.addIssue({
+          code: "custom",
+          path: ["reference"],
+          message: result.error.issues[0]?.message ?? "Referencia backend inválida.",
+        });
+      }
+    }
+  });
+
+const usageSchema = z
+  .object({
+    visible: z.boolean(),
+    editable: z.boolean(),
+    calculated: z.boolean(),
+    technical: z.boolean(),
+    filterable: z.boolean().optional(),
+    sortable: z.boolean().optional(),
+  })
+  .strict();
+
+const metadataSchema = z
+  .object({
+    origin: dataOriginSchema,
+    source: sourceReferenceSchema,
+    dataClassification: dataClassificationSchema,
+    technicalValidation: technicalValidationSchema,
+  })
+  .strict();
+
+const validateUsabilityEvidence = (
+  value: {
+    origin: z.infer<typeof dataOriginSchema>;
+    technicalValidation: z.infer<typeof technicalValidationSchema>;
+  },
+  context: z.RefinementCtx,
+) => {
+  if (
+    value.origin === "generatedByUsability" &&
+    value.technicalValidation.status === "validated" &&
+    !value.technicalValidation.evidence
+  ) {
+    context.addIssue({
+      code: "custom",
+      path: ["technicalValidation", "evidence"],
+      message: "Un dato generado por usabilidad solo puede validarse con evidencia explícita.",
+    });
+  }
+};
+
+export const fieldSpecSchema = z
+  .object({
+    id: camelCaseIdSchema,
+    productDescription: nonEmptyTextSchema,
+    dataType: z.enum(["string", "number", "boolean", "date", "datetime", "enum", "identifier"]),
+    required: z.boolean(),
+    usage: usageSchema,
+    usedIn: experienceLabelsSchema,
+    enumValues: z.array(nonEmptyTextSchema).min(1).optional(),
+    derivation: nonEmptyTextSchema.optional(),
+  })
+  .extend(metadataSchema.shape)
+  .strict()
+  .superRefine((field, context) => {
+    validateUsabilityEvidence(field, context);
+
+    if (field.dataType === "enum" && !field.enumValues) {
+      context.addIssue({
+        code: "custom",
+        path: ["enumValues"],
+        message: "Un campo enum debe declarar al menos un valor.",
+      });
+    }
+    if (field.dataType !== "enum" && field.enumValues) {
+      context.addIssue({
+        code: "custom",
+        path: ["enumValues"],
+        message: "Solo los campos enum pueden declarar enumValues.",
+      });
+    }
+    if ((field.usage.calculated || field.source.kind === "derived") && !field.derivation) {
+      context.addIssue({
+        code: "custom",
+        path: ["derivation"],
+        message: "Un dato calculado debe explicar su regla de derivación.",
+      });
+    }
+  });
+
+export const entityStateSpecSchema = z
+  .object({
+    id: camelCaseIdSchema,
+    productDescription: nonEmptyTextSchema,
+    activationCondition: nonEmptyTextSchema,
+    visualImpact: nonEmptyTextSchema,
+    usedIn: experienceLabelsSchema,
+  })
+  .extend(metadataSchema.shape)
+  .strict()
+  .superRefine(validateUsabilityEvidence);
+
+export const entitySpecSchema = z
+  .object({
+    id: camelCaseIdSchema,
+    productDescription: nonEmptyTextSchema,
+    roleInExperience: nonEmptyTextSchema,
+    usedIn: experienceLabelsSchema,
+    fields: z.record(camelCaseIdSchema, fieldSpecSchema),
+    states: z.array(entityStateSpecSchema).optional(),
+  })
+  .extend(metadataSchema.shape)
+  .strict()
+  .superRefine(validateUsabilityEvidence);
+
+export const relationSpecSchema = z
+  .object({
+    id: camelCaseIdSchema,
+    fromEntity: camelCaseIdSchema,
+    toEntity: camelCaseIdSchema,
+    cardinality: z.enum(["oneToOne", "oneToMany", "manyToMany"]),
+    productDescription: nonEmptyTextSchema,
+    requiredBy: experienceLabelsSchema,
+    resolution: z.enum(["embedded", "queried", "derived", "unknown"]),
+    derivation: nonEmptyTextSchema.optional(),
+  })
+  .extend(metadataSchema.shape)
+  .strict()
+  .superRefine((relation, context) => {
+    validateUsabilityEvidence(relation, context);
+    if (
+      (relation.resolution === "derived" || relation.source.kind === "derived") &&
+      !relation.derivation
+    ) {
+      context.addIssue({
+        code: "custom",
+        path: ["derivation"],
+        message: "Una relación derivada debe explicar su regla de derivación.",
+      });
+    }
+  });
+
+export const projectionFieldSpecSchema = z
+  .object({
+    id: camelCaseIdSchema,
+    source: z
+      .string()
+      .regex(
+        /^[a-z][a-zA-Z0-9]*\.[a-z][a-zA-Z0-9]*$/,
+        "Debe referenciar un campo como entidad.campo usando camelCase.",
+      ),
+    required: z.boolean(),
+  })
+  .strict();
+
+export const projectionSpecSchema = z
+  .object({
+    id: camelCaseIdSchema,
+    productDescription: nonEmptyTextSchema,
+    sourceEntities: experienceLabelsSchema,
+    consumedBy: experienceLabelsSchema,
+    fields: z.array(projectionFieldSpecSchema),
+    derivation: nonEmptyTextSchema.optional(),
+  })
+  .extend(metadataSchema.shape)
+  .strict()
+  .superRefine((projection, context) => {
+    validateUsabilityEvidence(projection, context);
+    if (projection.source.kind === "derived" && !projection.derivation) {
+      context.addIssue({
+        code: "custom",
+        path: ["derivation"],
+        message: "Una proyección derivada debe explicar su regla de derivación.",
+      });
+    }
+  });
+
+const projectSchema = z
+  .object({
+    name: nonEmptyTextSchema,
+    description: z.string().trim(),
+  })
+  .strict();
+
+export const prototypeDataContractSchema = z
+  .object({
+    contractVersion: z.literal("1"),
+    project: projectSchema,
+    entities: z.record(camelCaseIdSchema, entitySpecSchema),
+    relations: z.array(relationSpecSchema),
+    projections: z.record(camelCaseIdSchema, projectionSpecSchema),
+  })
+  .strict()
+  .superRefine((contract, context) => {
+    for (const [entityKey, entity] of Object.entries(contract.entities)) {
+      if (entityKey !== entity.id) {
+        context.addIssue({
+          code: "custom",
+          path: ["entities", entityKey, "id"],
+          message: 'El id "' + entity.id + '" debe coincidir con la key "' + entityKey + '".',
+        });
+      }
+
+      for (const [fieldKey, field] of Object.entries(entity.fields)) {
+        if (fieldKey !== field.id) {
+          context.addIssue({
+            code: "custom",
+            path: ["entities", entityKey, "fields", fieldKey, "id"],
+            message: 'El id "' + field.id + '" debe coincidir con la key "' + fieldKey + '".',
+          });
+        }
+      }
+
+      const stateIds = new Set<string>();
+      for (const [stateIndex, state] of (entity.states ?? []).entries()) {
+        if (stateIds.has(state.id)) {
+          context.addIssue({
+            code: "custom",
+            path: ["entities", entityKey, "states", stateIndex, "id"],
+            message: 'El estado "' + state.id + '" está declarado más de una vez.',
+          });
+        }
+        stateIds.add(state.id);
+      }
+    }
+
+    const relationIds = new Set<string>();
+    for (const [relationIndex, relation] of contract.relations.entries()) {
+      if (relationIds.has(relation.id)) {
+        context.addIssue({
+          code: "custom",
+          path: ["relations", relationIndex, "id"],
+          message: 'La relación "' + relation.id + '" está declarada más de una vez.',
+        });
+      }
+      relationIds.add(relation.id);
+
+      if (!contract.entities[relation.fromEntity]) {
+        context.addIssue({
+          code: "custom",
+          path: ["relations", relationIndex, "fromEntity"],
+          message: 'La entidad "' + relation.fromEntity + '" no existe.',
+        });
+      }
+      if (!contract.entities[relation.toEntity]) {
+        context.addIssue({
+          code: "custom",
+          path: ["relations", relationIndex, "toEntity"],
+          message: 'La entidad "' + relation.toEntity + '" no existe.',
+        });
+      }
+    }
+
+    for (const [projectionKey, projection] of Object.entries(contract.projections)) {
+      if (projectionKey !== projection.id) {
+        context.addIssue({
+          code: "custom",
+          path: ["projections", projectionKey, "id"],
+          message:
+            'El id "' + projection.id + '" debe coincidir con la key "' + projectionKey + '".',
+        });
+      }
+
+      for (const [sourceIndex, entityId] of projection.sourceEntities.entries()) {
+        if (!contract.entities[entityId]) {
+          context.addIssue({
+            code: "custom",
+            path: ["projections", projectionKey, "sourceEntities", sourceIndex],
+            message: 'La entidad "' + entityId + '" no existe.',
+          });
+        }
+      }
+
+      const projectionFieldIds = new Set<string>();
+      for (const [fieldIndex, field] of projection.fields.entries()) {
+        if (projectionFieldIds.has(field.id)) {
+          context.addIssue({
+            code: "custom",
+            path: ["projections", projectionKey, "fields", fieldIndex, "id"],
+            message: 'El campo proyectado "' + field.id + '" está declarado más de una vez.',
+          });
+        }
+        projectionFieldIds.add(field.id);
+
+        const [entityId, fieldId] = field.source.split(".");
+        const entity = contract.entities[entityId];
+        if (!entity) {
+          context.addIssue({
+            code: "custom",
+            path: ["projections", projectionKey, "fields", fieldIndex, "source"],
+            message: 'La referencia "' + field.source + '" apunta a una entidad que no existe.',
+          });
+          continue;
+        }
+        if (!entity.fields[fieldId]) {
+          context.addIssue({
+            code: "custom",
+            path: ["projections", projectionKey, "fields", fieldIndex, "source"],
+            message: 'La referencia "' + field.source + '" apunta a un campo que no existe.',
+          });
+        }
+        if (!projection.sourceEntities.includes(entityId)) {
+          context.addIssue({
+            code: "custom",
+            path: ["projections", projectionKey, "fields", fieldIndex, "source"],
+            message: 'La entidad "' + entityId + '" debe declararse también en sourceEntities.',
+          });
+        }
+      }
+    }
+  });
+
+export type DataOrigin = z.infer<typeof dataOriginSchema>;
+export type TechnicalValidationStatus = z.infer<typeof technicalValidationStatusSchema>;
+export type TechnicalValidation = z.infer<typeof technicalValidationSchema>;
+export type SourceReference = z.infer<typeof sourceReferenceSchema>;
+export type FieldSpec = z.infer<typeof fieldSpecSchema>;
+export type EntityStateSpec = z.infer<typeof entityStateSpecSchema>;
+export type EntitySpec = z.infer<typeof entitySpecSchema>;
+export type RelationSpec = z.infer<typeof relationSpecSchema>;
+export type ProjectionSpec = z.infer<typeof projectionSpecSchema>;
+export type PrototypeDataContract = z.infer<typeof prototypeDataContractSchema>;
+
+export function definePrototypeDataContract(
+  contract: PrototypeDataContract,
+): PrototypeDataContract {
+  return prototypeDataContractSchema.parse(contract);
+}
+`,It=String.raw`import { ZodError } from "zod";
+
+import { prototypeDataContractSchema } from "../src/prototype/data-contract/data-contract-schema";
+
+const formatPath = (path: PropertyKey[]) =>
+  path.length === 0 ? "contrato" : path.map(String).join(".");
+
+const printIssues = (error: ZodError) => {
+  console.error("✗ Contrato de datos inválido");
+  for (const issue of error.issues) {
+    console.error("  " + formatPath(issue.path));
+    console.error("  " + issue.message);
+  }
+};
+
+const countPendingValidations = (value: unknown): number => {
+  if (Array.isArray(value)) {
+    return value.reduce((total, item) => total + countPendingValidations(item), 0);
+  }
+  if (!value || typeof value !== "object") return 0;
+
+  const record = value as Record<string, unknown>;
+  const ownPending =
+    record.technicalValidation &&
+    typeof record.technicalValidation === "object" &&
+    (record.technicalValidation as Record<string, unknown>).status === "pendingTi"
+      ? 1
+      : 0;
+
+  return Object.values(record).reduce(
+    (total, item) => total + countPendingValidations(item),
+    ownPending,
+  );
+};
+
+try {
+  const module = await import("../src/prototype/data-contract/prototype-data-contract");
+  const result = prototypeDataContractSchema.safeParse(module.prototypeDataContract);
+
+  if (!result.success) {
+    printIssues(result.error);
+    process.exitCode = 1;
+  } else {
+    const contract = result.data;
+    console.log("✓ Contrato de datos válido");
+    console.log("  " + Object.keys(contract.entities).length + " entidades");
+    console.log("  " + contract.relations.length + " relaciones");
+    console.log("  " + Object.keys(contract.projections).length + " proyecciones");
+    console.log(
+      "  " + countPendingValidations(contract) + " elementos pendientes de validación con TI",
+    );
+  }
+} catch (error) {
+  if (error instanceof ZodError) {
+    printIssues(error);
+  } else {
+    console.error("✗ No se pudo cargar el contrato de datos");
+    console.error("  " + (error instanceof Error ? error.message : String(error)));
+  }
+  process.exitCode = 1;
+}
+`,Et=e=>`import { definePrototypeDataContract } from "./data-contract-schema";
+
+/**
+ * Fuente de verdad de los datos usados por el prototipo.
+ *
+ * El designer describe el producto en lenguaje natural; el agente mantiene este
+ * contrato y ejecuta \`pnpm check:data-contract\` antes de implementar la UI.
+ */
+export const prototypeDataContract = definePrototypeDataContract({
+  contractVersion: "1",
+  project: {
+    name: ${JSON.stringify(e)},
+    description: "",
+  },
+  entities: {},
+  relations: [],
+  projections: {},
+});
+`,De=async(e,t)=>{let o=async(r,a)=>{let i=Oe.join(e,r);await Ae.mkdir(Oe.dirname(i),{recursive:!0}),await Ae.writeFile(i,a)};await o(St,bt),await o(re,Et(t)),await o(xt,It)};import $e from"fs/promises";import Ve from"path";var ie="src/prototype/event-engine/prototype-event-engine-contract.ts",kt="src/prototype/event-engine/event-engine-contract-schema.ts",wt="src/prototype/event-engine/payload-schema.ts",se="src/prototype/event-engine/event-engine.ts",Pt="scripts/check-event-engine.ts",Ct=String.raw`import { z } from "zod";
+
+const camelCaseIdSchema = z
+  .string()
+  .regex(/^[a-z][a-zA-Z0-9]*$/, "Debe usar camelCase y comenzar con una letra minúscula.");
+
+const nonEmptyTextSchema = z.string().trim().min(1, "No puede quedar vacío.");
+
+const technicalEventIdSchema = z
+  .string()
+  .regex(
+    /^[A-Za-z][A-Za-z0-9]*_[A-Za-z0-9]+-[A-Za-z0-9]+_V[0-9]+$/,
+    "Debe usar el formato eventista Dominio_Subdominio-NombreEvento_V1.",
+  );
+
+const dataReferenceSchema = z
+  .string()
+  .regex(
+    /^[a-z][a-zA-Z0-9]*(\.[a-z][a-zA-Z0-9]*)?$/,
+    "Debe referenciar una entidad o campo como entidad o entidad.campo usando camelCase.",
+  );
+
+const triggerSchema = z
+  .object({
+    id: camelCaseIdSchema.optional(),
+    label: nonEmptyTextSchema,
+    source: z.enum(["screen", "userAction", "system", "external", "unknown"]),
+    description: nonEmptyTextSchema.optional(),
+  })
+  .strict();
+
+const schemaReferenceSchema = z
+  .object({
+    schemaId: camelCaseIdSchema,
+  })
+  .strict();
+
+export const dataLoadSpecSchema = z
+  .object({
+    id: camelCaseIdSchema,
+    name: nonEmptyTextSchema,
+    productDescription: nonEmptyTextSchema,
+    trigger: triggerSchema,
+    paramsSchema: schemaReferenceSchema.optional(),
+    responseSchema: schemaReferenceSchema.optional(),
+    reads: z
+      .object({
+        entities: z.array(camelCaseIdSchema).optional(),
+        projections: z.array(camelCaseIdSchema).optional(),
+        fields: z.array(dataReferenceSchema).optional(),
+      })
+      .strict()
+      .optional(),
+    visibleResult: nonEmptyTextSchema,
+    pendingTi: nonEmptyTextSchema.optional(),
+  })
+  .strict();
+
+export const publishedEventSpecSchema = z
+  .object({
+    id: camelCaseIdSchema,
+    name: nonEmptyTextSchema,
+    technicalId: technicalEventIdSchema,
+    productDescription: nonEmptyTextSchema,
+    trigger: triggerSchema,
+    payloadSchema: schemaReferenceSchema.optional(),
+    receiptSchema: schemaReferenceSchema.optional(),
+    writes: z
+      .object({
+        entities: z.array(camelCaseIdSchema).optional(),
+        fields: z.array(dataReferenceSchema).optional(),
+      })
+      .strict()
+      .optional(),
+    visibleResult: nonEmptyTextSchema,
+    pendingTi: nonEmptyTextSchema.optional(),
+  })
+  .strict();
+
+export const prototypeEventEngineContractSchema = z
+  .object({
+    contractVersion: z.literal("1"),
+    dataLoads: z.record(camelCaseIdSchema, dataLoadSpecSchema),
+    events: z.record(camelCaseIdSchema, publishedEventSpecSchema),
+  })
+  .strict()
+  .superRefine((contract, context) => {
+    for (const [loadKey, load] of Object.entries(contract.dataLoads)) {
+      if (loadKey !== load.id) {
+        context.addIssue({
+          code: "custom",
+          path: ["dataLoads", loadKey, "id"],
+          message: 'El id "' + load.id + '" debe coincidir con la key "' + loadKey + '".',
+        });
+      }
+    }
+
+    const technicalIds = new Set<string>();
+    for (const [eventKey, event] of Object.entries(contract.events)) {
+      if (eventKey !== event.id) {
+        context.addIssue({
+          code: "custom",
+          path: ["events", eventKey, "id"],
+          message: 'El id "' + event.id + '" debe coincidir con la key "' + eventKey + '".',
+        });
+      }
+
+      if (technicalIds.has(event.technicalId)) {
+        context.addIssue({
+          code: "custom",
+          path: ["events", eventKey, "technicalId"],
+          message: 'El ID técnico "' + event.technicalId + '" está declarado más de una vez.',
+        });
+      }
+      technicalIds.add(event.technicalId);
+    }
+  });
+
+export type PrototypeEventEngineContract = z.infer<typeof prototypeEventEngineContractSchema>;
+export type DataLoadSpec = z.infer<typeof dataLoadSpecSchema>;
+export type PublishedEventSpec = z.infer<typeof publishedEventSpecSchema>;
+
+export type EventEngineValidationIssue = {
+  path: Array<string | number>;
+  message: string;
+};
+
+type DataContractLike = {
+  entities: Record<string, { fields: Record<string, unknown> }>;
+  projections: Record<string, unknown>;
+};
+
+type PayloadSchemasLike = Record<string, unknown>;
+
+const hasOwn = (record: Record<string, unknown>, key: string) =>
+  Object.prototype.hasOwnProperty.call(record, key);
+
+const validateDataReference = (
+  reference: string,
+  dataContract: DataContractLike,
+): string | null => {
+  const [entityId, fieldId] = reference.split(".");
+  const entity = dataContract.entities[entityId];
+  if (!entity) return 'La entidad "' + entityId + '" no existe en el contrato de datos.';
+  if (fieldId && !hasOwn(entity.fields, fieldId)) {
+    return 'El campo "' + reference + '" no existe en el contrato de datos.';
+  }
+  return null;
+};
+
+export const validateEventEngineReferences = (input: {
+  eventEngineContract: PrototypeEventEngineContract;
+  dataContract: DataContractLike;
+  payloadSchemas: PayloadSchemasLike;
+}): EventEngineValidationIssue[] => {
+  const issues: EventEngineValidationIssue[] = [];
+  const { eventEngineContract, dataContract, payloadSchemas } = input;
+
+  for (const [loadId, load] of Object.entries(eventEngineContract.dataLoads)) {
+    for (const [schemaKey, schemaRef] of [
+      ["paramsSchema", load.paramsSchema],
+      ["responseSchema", load.responseSchema],
+    ] as const) {
+      if (schemaRef && !hasOwn(payloadSchemas, schemaRef.schemaId)) {
+        issues.push({
+          path: ["dataLoads", loadId, schemaKey, "schemaId"],
+          message: 'El schema "' + schemaRef.schemaId + '" no existe en payload-schema.ts.',
+        });
+      }
+    }
+
+    for (const [index, entityId] of (load.reads?.entities ?? []).entries()) {
+      if (!dataContract.entities[entityId]) {
+        issues.push({
+          path: ["dataLoads", loadId, "reads", "entities", index],
+          message: 'La entidad "' + entityId + '" no existe en el contrato de datos.',
+        });
+      }
+    }
+    for (const [index, projectionId] of (load.reads?.projections ?? []).entries()) {
+      if (!dataContract.projections[projectionId]) {
+        issues.push({
+          path: ["dataLoads", loadId, "reads", "projections", index],
+          message: 'La proyección "' + projectionId + '" no existe en el contrato de datos.',
+        });
+      }
+    }
+    for (const [index, reference] of (load.reads?.fields ?? []).entries()) {
+      const message = validateDataReference(reference, dataContract);
+      if (message) {
+        issues.push({
+          path: ["dataLoads", loadId, "reads", "fields", index],
+          message,
+        });
+      }
+    }
+  }
+
+  for (const [eventId, event] of Object.entries(eventEngineContract.events)) {
+    for (const [schemaKey, schemaRef] of [
+      ["payloadSchema", event.payloadSchema],
+      ["receiptSchema", event.receiptSchema],
+    ] as const) {
+      if (schemaRef && !hasOwn(payloadSchemas, schemaRef.schemaId)) {
+        issues.push({
+          path: ["events", eventId, schemaKey, "schemaId"],
+          message: 'El schema "' + schemaRef.schemaId + '" no existe en payload-schema.ts.',
+        });
+      }
+    }
+
+    for (const [index, entityId] of (event.writes?.entities ?? []).entries()) {
+      if (!dataContract.entities[entityId]) {
+        issues.push({
+          path: ["events", eventId, "writes", "entities", index],
+          message: 'La entidad "' + entityId + '" no existe en el contrato de datos.',
+        });
+      }
+    }
+    for (const [index, reference] of (event.writes?.fields ?? []).entries()) {
+      const message = validateDataReference(reference, dataContract);
+      if (message) {
+        issues.push({
+          path: ["events", eventId, "writes", "fields", index],
+          message,
+        });
+      }
+    }
+  }
+
+  return issues;
+};
+
+export function definePrototypeEventEngineContract(
+  contract: PrototypeEventEngineContract,
+): PrototypeEventEngineContract {
+  return prototypeEventEngineContractSchema.parse(contract);
+}
+`,jt=String.raw`import { z } from "zod";
+
+/**
+ * Schemas runtime para params, payloads, responses y receipts del motor.
+ *
+ * Los contratos de Spec 2 referencian estas keys mediante schemaId. El agente
+ * agrega schemas específicos cuando declara cargas o eventos concretos.
+ */
+export const unknownPayloadSchema = z.unknown();
+export const emptyObjectSchema = z.object({}).strict();
+export const unknownResponseSchema = z.unknown();
+export const absentReceiptSchema = z.undefined().optional();
+
+export const prototypePayloadSchemas = {
+  unknown: unknownPayloadSchema,
+  emptyObject: emptyObjectSchema,
+  unknownResponse: unknownResponseSchema,
+  absentReceipt: absentReceiptSchema,
+} satisfies Record<string, z.ZodType>;
+
+export type PrototypePayloadSchemaId = keyof typeof prototypePayloadSchemas;
+`,Rt=String.raw`import { z } from "zod";
+
+import { prototypeEventEngineContract } from "./prototype-event-engine-contract";
+import { prototypePayloadSchemas } from "./payload-schema";
+import type { PrototypeEventEngineContract } from "./event-engine-contract-schema";
+
+export type DataLoadInput = {
+  loadId: string;
+  triggerId?: string;
+  params?: unknown;
+  signal?: AbortSignal;
+};
+
+export type PublishEventInput = {
+  eventId: string;
+  triggerId?: string;
+  payload?: unknown;
+};
+
+export type EventPublicationEnvelope = {
+  technicalId: string;
+  occurredAt: string;
+  publicationId: string;
+  payload: unknown;
+};
+
+export type PublishedEventResult = {
+  status: "published";
+  label: "Evento publicado";
+  eventId: string;
+  technicalId: string;
+  occurredAt: string;
+  publicationId: string;
+  receipt?: unknown;
+};
+
+export type PrototypeBackendExecutor = {
+  loadData(input: {
+    loadId: string;
+    triggerId?: string;
+    params: unknown;
+    signal?: AbortSignal;
+  }): Promise<unknown>;
+  publishEvent(input: {
+    eventId: string;
+    triggerId?: string;
+    envelope: EventPublicationEnvelope;
+  }): Promise<{ receipt?: unknown } | void>;
+};
+
+type PrototypeEventEngineOptions = {
+  contract?: PrototypeEventEngineContract;
+  payloadSchemas?: Record<string, z.ZodType>;
+  executor: PrototypeBackendExecutor;
+  clock?: () => Date;
+  publicationId?: () => string;
+};
+
+const createDefaultPublicationId = () =>
+  "pub_" + Date.now().toString(36) + "_" + Math.random().toString(36).slice(2, 10);
+
+const parseWithSchema = (schema: z.ZodType | undefined, value: unknown, label: string) => {
+  if (!schema) return value;
+  const result = schema.safeParse(value);
+  if (!result.success) {
+    const message = result.error.issues
+      .map((issue) => (issue.path.length > 0 ? issue.path.join(".") + ": " : "") + issue.message)
+      .join("; ");
+    throw new Error(label + " inválido: " + message);
+  }
+  return result.data;
+};
+
+export const createPrototypeEventEngine = (options: PrototypeEventEngineOptions) => {
+  const contract = options.contract ?? prototypeEventEngineContract;
+  const payloadSchemas: Record<string, z.ZodType> =
+    options.payloadSchemas ?? prototypePayloadSchemas;
+  const clock = options.clock ?? (() => new Date());
+  const publicationId = options.publicationId ?? createDefaultPublicationId;
+
+  return {
+    async loadData(input: DataLoadInput): Promise<unknown> {
+      const load = contract.dataLoads[input.loadId];
+      if (!load) throw new Error('La carga de datos "' + input.loadId + '" no está declarada.');
+
+      const params = parseWithSchema(
+        load.paramsSchema ? payloadSchemas[load.paramsSchema.schemaId] : undefined,
+        input.params,
+        'Params de la carga "' + input.loadId + '"',
+      );
+
+      const response = await options.executor.loadData({
+        loadId: input.loadId,
+        triggerId: input.triggerId,
+        params,
+        signal: input.signal,
+      });
+
+      return parseWithSchema(
+        load.responseSchema ? payloadSchemas[load.responseSchema.schemaId] : undefined,
+        response,
+        'Response de la carga "' + input.loadId + '"',
+      );
+    },
+
+    async publishEvent(input: PublishEventInput): Promise<PublishedEventResult> {
+      const event = contract.events[input.eventId];
+      if (!event) throw new Error('El evento publicado "' + input.eventId + '" no está declarado.');
+
+      const payload = parseWithSchema(
+        event.payloadSchema ? payloadSchemas[event.payloadSchema.schemaId] : undefined,
+        input.payload,
+        'Payload del evento "' + input.eventId + '"',
+      );
+
+      const envelope: EventPublicationEnvelope = {
+        technicalId: event.technicalId,
+        occurredAt: clock().toISOString(),
+        publicationId: publicationId(),
+        payload,
+      };
+
+      const executorResult = await options.executor.publishEvent({
+        eventId: input.eventId,
+        triggerId: input.triggerId,
+        envelope,
+      });
+
+      const receipt = parseWithSchema(
+        event.receiptSchema ? payloadSchemas[event.receiptSchema.schemaId] : undefined,
+        executorResult?.receipt,
+        'Receipt del evento "' + input.eventId + '"',
+      );
+
+      return {
+        status: "published",
+        label: "Evento publicado",
+        eventId: input.eventId,
+        technicalId: event.technicalId,
+        occurredAt: envelope.occurredAt,
+        publicationId: envelope.publicationId,
+        ...(receipt === undefined ? {} : { receipt }),
+      };
+    },
+  };
+};
+`,Tt=String.raw`import { ZodError } from "zod";
+
+import { prototypeDataContractSchema } from "../src/prototype/data-contract/data-contract-schema";
+import {
+  prototypeEventEngineContractSchema,
+  validateEventEngineReferences,
+  type EventEngineValidationIssue,
+} from "../src/prototype/event-engine/event-engine-contract-schema";
+import { prototypePayloadSchemas } from "../src/prototype/event-engine/payload-schema";
+
+const formatPath = (path: Array<string | number>) =>
+  path.length === 0 ? "eventEngine" : path.map(String).join(".");
+
+const printIssues = (issues: EventEngineValidationIssue[]) => {
+  console.error("✗ Motor de eventos inválido");
+  for (const issue of issues) {
+    console.error("  " + formatPath(issue.path));
+    console.error("  " + issue.message);
+  }
+};
+
+try {
+  const dataContractModule = await import("../src/prototype/data-contract/prototype-data-contract");
+  const eventEngineModule =
+    await import("../src/prototype/event-engine/prototype-event-engine-contract");
+
+  const dataContractResult = prototypeDataContractSchema.safeParse(
+    dataContractModule.prototypeDataContract,
+  );
+  const eventEngineResult = prototypeEventEngineContractSchema.safeParse(
+    eventEngineModule.prototypeEventEngineContract,
+  );
+
+  const issues: EventEngineValidationIssue[] = [];
+  if (!dataContractResult.success) {
+    for (const issue of dataContractResult.error.issues) {
+      issues.push({
+        path: ["dataContract", ...issue.path.map(String)],
+        message: issue.message,
+      });
+    }
+  }
+  if (!eventEngineResult.success) {
+    for (const issue of eventEngineResult.error.issues) {
+      issues.push({
+        path: issue.path.map(String),
+        message: issue.message,
+      });
+    }
+  }
+
+  if (dataContractResult.success && eventEngineResult.success) {
+    issues.push(
+      ...validateEventEngineReferences({
+        eventEngineContract: eventEngineResult.data,
+        dataContract: dataContractResult.data,
+        payloadSchemas: prototypePayloadSchemas,
+      }),
+    );
+  }
+
+  if (issues.length > 0) {
+    printIssues(issues);
+    process.exitCode = 1;
+  } else {
+    const contract = eventEngineResult.data!;
+    console.log("✓ Motor de eventos válido");
+    console.log("  " + Object.keys(contract.dataLoads).length + " cargas de datos");
+    console.log("  " + Object.keys(contract.events).length + " eventos publicados");
+  }
+} catch (error) {
+  if (error instanceof ZodError) {
+    printIssues(
+      error.issues.map((issue) => ({ path: issue.path.map(String), message: issue.message })),
+    );
+  } else {
+    console.error("✗ No se pudo cargar el motor de eventos");
+    console.error("  " + (error instanceof Error ? error.message : String(error)));
+  }
+  process.exitCode = 1;
+}
+`,Mt=()=>`import { definePrototypeEventEngineContract } from "./event-engine-contract-schema";
+
+/**
+ * Cat\xE1logo de comunicaciones externas del frontend.
+ *
+ * - dataLoads: lecturas remotas para alimentar la UI.
+ * - events: escrituras publicadas como hechos Lexy.
+ *
+ * Las interacciones locales no se declaran ac\xE1.
+ */
+export const prototypeEventEngineContract = definePrototypeEventEngineContract({
+  contractVersion: "1",
+  dataLoads: {},
+  events: {},
+});
+`,_e=async e=>{let t=async(o,r)=>{let a=Ve.join(e,o);await $e.mkdir(Ve.dirname(a),{recursive:!0}),await $e.writeFile(a,r)};await t(kt,Ct),await t(ie,Mt()),await t(wt,jt),await t(se,Rt),await t(Pt,Tt)};import Fe from"fs/promises";import Ne from"path";var Lt="src/prototype/simulator/simulator-contract-schema.ts",ce="src/prototype/simulator/mock-generation-profile.ts",le="src/prototype/simulator/mock-scenarios.ts",zt="src/prototype/simulator/projection-resolvers.ts",At="src/prototype/simulator/data-load-handlers.ts",Ot="src/prototype/simulator/event-handlers.ts",Dt="src/prototype/simulator/mock-store.ts",$t="src/prototype/simulator/mock-backend-executor.ts",de="src/prototype/simulator/prototype-simulator.ts",Vt="scripts/check-simulator.ts",_t=String.raw`import { z } from "zod";
+
+const camelCaseIdSchema = z
+  .string()
+  .regex(/^[a-z][a-zA-Z0-9]*$/, "Debe usar camelCase y comenzar con una letra minúscula.");
+
+const dataReferenceSchema = z
+  .string()
+  .regex(
+    /^[a-z][a-zA-Z0-9]*\.[a-z][a-zA-Z0-9]*$/,
+    "Debe referenciar un campo como entidad.campo usando camelCase.",
+  );
+
+const nonEmptyTextSchema = z.string().trim().min(1, "No puede quedar vacío.");
+
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | { [key: string]: JsonValue };
+export type MockEntityRecord = Record<string, JsonValue>;
+
+export const jsonValueSchema: z.ZodType<JsonValue> = z.lazy(() =>
+  z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(jsonValueSchema),
+    z.record(z.string(), jsonValueSchema),
+  ]),
+);
+
+export const mockEntityRecordSchema = z.record(z.string(), jsonValueSchema);
+
+export const mockSemanticSchema = z.enum([
+  "personName",
+  "rutCl",
+  "mobilePhoneCl",
+  "landlinePhoneCl",
+  "email",
+  "clpAmount",
+  "dateCl",
+  "datetimeCl",
+  "regionCl",
+  "communeCl",
+  "addressCl",
+  "companyNameCl",
+  "legalCaseReferenceCl",
+  "freeText",
+  "custom",
+]);
+
+export const fieldMockHintSchema = z
+  .object({
+    semantic: mockSemanticSchema,
+    description: nonEmptyTextSchema.optional(),
+    examples: z.array(nonEmptyTextSchema).optional(),
+    constraints: z
+      .object({
+        min: z.number().optional(),
+        max: z.number().optional(),
+        pattern: nonEmptyTextSchema.optional(),
+        allowedValues: z.array(nonEmptyTextSchema).optional(),
+      })
+      .strict()
+      .optional(),
+    rutValidation: z.enum(["formatOnly", "validChecksum"]).optional(),
+  })
+  .strict();
+
+export const mockGenerationProfileSchema = z
+  .object({
+    profileVersion: z.literal("1"),
+    locale: z
+      .object({
+        language: z.literal("es"),
+        locale: z.literal("es-CL"),
+        country: z.literal("CL"),
+        timezone: z.literal("America/Santiago"),
+        currency: z.literal("CLP"),
+        dateStorage: z.literal("iso8601"),
+        dateDisplay: z.literal("dd-MM-yyyy"),
+        timeDisplay: z.literal("24h"),
+      })
+      .strict(),
+    safety: z
+      .object({
+        syntheticOnly: z.literal(true),
+        allowProductionImports: z.literal(false),
+        externalUse: z.literal(false),
+        emailDomain: z.literal("example.com"),
+      })
+      .strict(),
+    entityKeys: z.record(
+      camelCaseIdSchema,
+      z
+        .object({
+          field: dataReferenceSchema,
+        })
+        .strict(),
+    ),
+    relationBindings: z.record(
+      camelCaseIdSchema,
+      z
+        .object({
+          relation: camelCaseIdSchema,
+          fromField: dataReferenceSchema,
+          toField: dataReferenceSchema,
+        })
+        .strict(),
+    ),
+    fieldHints: z.record(dataReferenceSchema, fieldMockHintSchema),
+  })
+  .strict();
+
+export const mockOperationErrorSchema = z
+  .object({
+    code: camelCaseIdSchema,
+    message: nonEmptyTextSchema,
+    recoverable: z.boolean(),
+  })
+  .strict();
+
+export const mockDataLoadBehaviorSchema = z
+  .object({
+    latencyMs: z.number().int().min(0).optional(),
+    outcome: z.enum(["normal", "empty", "error"]).optional(),
+    error: mockOperationErrorSchema.optional(),
+  })
+  .strict()
+  .superRefine((behavior, context) => {
+    const outcome = behavior.outcome ?? "normal";
+    if (outcome === "error" && !behavior.error) {
+      context.addIssue({
+        code: "custom",
+        path: ["error"],
+        message: "Un behavior error debe declarar el error controlado.",
+      });
+    }
+    if (outcome !== "error" && behavior.error) {
+      context.addIssue({
+        code: "custom",
+        path: ["error"],
+        message: "Solo un behavior error puede declarar error.",
+      });
+    }
+  });
+
+export const mockEventBehaviorSchema = z
+  .object({
+    latencyMs: z.number().int().min(0).optional(),
+    outcome: z.enum(["normal", "error"]).optional(),
+    error: mockOperationErrorSchema.optional(),
+  })
+  .strict()
+  .superRefine((behavior, context) => {
+    const outcome = behavior.outcome ?? "normal";
+    if (outcome === "error" && !behavior.error) {
+      context.addIssue({
+        code: "custom",
+        path: ["error"],
+        message: "Un behavior error debe declarar el error controlado.",
+      });
+    }
+    if (outcome !== "error" && behavior.error) {
+      context.addIssue({
+        code: "custom",
+        path: ["error"],
+        message: "Solo un behavior error puede declarar error.",
+      });
+    }
+  });
+
+export const mockScenarioSchema = z
+  .object({
+    id: camelCaseIdSchema,
+    name: nonEmptyTextSchema,
+    description: nonEmptyTextSchema,
+    entities: z.record(camelCaseIdSchema, z.array(mockEntityRecordSchema)),
+    behaviors: z
+      .object({
+        dataLoads: z.record(camelCaseIdSchema, mockDataLoadBehaviorSchema).optional(),
+        events: z.record(camelCaseIdSchema, mockEventBehaviorSchema).optional(),
+      })
+      .strict()
+      .optional(),
+  })
+  .strict();
+
+export const prototypeMockScenariosSchema = z
+  .object({
+    scenariosVersion: z.literal("1"),
+    datasetVersion: z.number().int().positive(),
+    defaultScenarioId: camelCaseIdSchema,
+    scenarios: z.record(camelCaseIdSchema, mockScenarioSchema),
+  })
+  .strict()
+  .superRefine((catalog, context) => {
+    if (!catalog.scenarios[catalog.defaultScenarioId]) {
+      context.addIssue({
+        code: "custom",
+        path: ["defaultScenarioId"],
+        message: 'El escenario default "' + catalog.defaultScenarioId + '" no existe.',
+      });
+    }
+
+    for (const [scenarioKey, scenario] of Object.entries(catalog.scenarios)) {
+      if (scenarioKey !== scenario.id) {
+        context.addIssue({
+          code: "custom",
+          path: ["scenarios", scenarioKey, "id"],
+          message: 'El id "' + scenario.id + '" debe coincidir con la key "' + scenarioKey + '".',
+        });
+      }
+    }
+  });
+
+export type MockSemantic = z.infer<typeof mockSemanticSchema>;
+export type FieldMockHint = z.infer<typeof fieldMockHintSchema>;
+export type MockGenerationProfile = z.infer<typeof mockGenerationProfileSchema>;
+export type MockOperationError = z.infer<typeof mockOperationErrorSchema>;
+export type MockDataLoadBehavior = z.infer<typeof mockDataLoadBehaviorSchema>;
+export type MockEventBehavior = z.infer<typeof mockEventBehaviorSchema>;
+export type MockScenario = z.infer<typeof mockScenarioSchema>;
+export type PrototypeMockScenarios = z.infer<typeof prototypeMockScenariosSchema>;
+
+export type SimulatorValidationIssue = {
+  path: Array<string | number>;
+  message: string;
+};
+
+type DataContractFieldLike = {
+  dataType: "string" | "number" | "boolean" | "date" | "datetime" | "enum" | "identifier";
+  required: boolean;
+  enumValues?: string[];
+};
+
+type DataContractLike = {
+  entities: Record<
+    string,
+    {
+      fields: Record<string, DataContractFieldLike>;
+    }
+  >;
+  relations: Array<{ id: string; fromEntity: string; toEntity: string }>;
+  projections: Record<string, unknown>;
+};
+
+type EventEngineContractLike = {
+  dataLoads: Record<string, unknown>;
+  events: Record<string, unknown>;
+};
+
+const splitReference = (reference: string) => {
+  const [entityId, fieldId] = reference.split(".");
+  return { entityId, fieldId };
+};
+
+const getField = (dataContract: DataContractLike, reference: string) => {
+  const { entityId, fieldId } = splitReference(reference);
+  return {
+    entityId,
+    fieldId,
+    entity: dataContract.entities[entityId],
+    field: dataContract.entities[entityId]?.fields[fieldId],
+  };
+};
+
+const isSemanticCompatible = (semantic: MockSemantic, field: DataContractFieldLike): boolean => {
+  if (semantic === "custom") return true;
+  if (semantic === "clpAmount") return field.dataType === "number";
+  if (semantic === "dateCl") return field.dataType === "date";
+  if (semantic === "datetimeCl") return field.dataType === "datetime";
+  if (field.dataType === "enum") return ["regionCl", "communeCl", "custom"].includes(semantic);
+  return ["string", "identifier"].includes(field.dataType);
+};
+
+const rutFormat = /^[0-9]{7,8}-[0-9K]$/;
+
+const isValidRutChecksum = (rut: string) => {
+  if (!rutFormat.test(rut)) return false;
+  const [body, verifier] = rut.split("-");
+  let sum = 0;
+  let multiplier = 2;
+  for (let index = body.length - 1; index >= 0; index -= 1) {
+    sum += Number(body[index]) * multiplier;
+    multiplier = multiplier === 7 ? 2 : multiplier + 1;
+  }
+  const result = 11 - (sum % 11);
+  const expected = result === 11 ? "0" : result === 10 ? "K" : String(result);
+  return verifier === expected;
+};
+
+const mobilePhoneFormat = /^\+56 9 [0-9]{4} [0-9]{4}$/;
+const landlinePhoneFormat = /^\+56 [2-9] [0-9]{4} [0-9]{4}$/;
+const isoDateFormat = /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/;
+const datetimeWithOffsetFormat =
+  /^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]{3})?(?:Z|[+-][0-9]{2}:[0-9]{2})$/;
+const emailFormat = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const secretLikeFormat =
+  /(sk-[a-z0-9_-]{12,}|ghp_[a-z0-9_]{12,}|api[_-]?key|secret|token|password|BEGIN PRIVATE KEY)/i;
+
+const validateChileanValue = (input: {
+  value: JsonValue;
+  hint: FieldMockHint;
+  emailDomain: string;
+}): string | null => {
+  const { value, hint, emailDomain } = input;
+  if (value === null) return null;
+
+  if (hint.semantic === "rutCl") {
+    if (typeof value !== "string" || !rutFormat.test(value)) {
+      return "El RUT debe usar formato 12345678-9 y K mayúscula.";
+    }
+    if (hint.rutValidation === "validChecksum" && !isValidRutChecksum(value)) {
+      return "El RUT no cumple el dígito verificador módulo 11.";
+    }
+  }
+
+  if (
+    hint.semantic === "mobilePhoneCl" &&
+    (typeof value !== "string" || !mobilePhoneFormat.test(value))
+  ) {
+    return "El móvil chileno debe usar formato +56 9 XXXX XXXX.";
+  }
+
+  if (
+    hint.semantic === "landlinePhoneCl" &&
+    (typeof value !== "string" || !landlinePhoneFormat.test(value))
+  ) {
+    return "El teléfono fijo chileno debe usar formato +56 X XXXX XXXX.";
+  }
+
+  if (hint.semantic === "dateCl" && (typeof value !== "string" || !isoDateFormat.test(value))) {
+    return "La fecha de storage debe usar ISO YYYY-MM-DD.";
+  }
+
+  if (
+    hint.semantic === "datetimeCl" &&
+    (typeof value !== "string" || !datetimeWithOffsetFormat.test(value))
+  ) {
+    return "El datetime debe usar ISO 8601 con offset o Z.";
+  }
+
+  if (hint.semantic === "clpAmount" && (!Number.isInteger(value) || typeof value !== "number")) {
+    return "Los montos CLP deben almacenarse como enteros sin decimales.";
+  }
+
+  if (hint.semantic === "email") {
+    if (typeof value !== "string" || !emailFormat.test(value)) {
+      return "El correo debe tener formato válido.";
+    }
+    if (!value.endsWith("@" + emailDomain)) {
+      return 'Los correos mock deben usar el dominio "' + emailDomain + '".';
+    }
+  }
+
+  return null;
+};
+
+const validateValueType = (field: DataContractFieldLike, value: JsonValue): string | null => {
+  if (value === null) return null;
+  if (field.dataType === "number" && typeof value !== "number") return "Debe ser number.";
+  if (field.dataType === "boolean" && typeof value !== "boolean") return "Debe ser boolean.";
+  if (
+    ["string", "identifier", "date", "datetime", "enum"].includes(field.dataType) &&
+    typeof value !== "string"
+  ) {
+    return "Debe ser string.";
+  }
+  if (field.dataType === "date" && typeof value === "string" && !isoDateFormat.test(value)) {
+    return "Debe usar fecha ISO YYYY-MM-DD.";
+  }
+  if (
+    field.dataType === "datetime" &&
+    typeof value === "string" &&
+    !datetimeWithOffsetFormat.test(value)
+  ) {
+    return "Debe usar datetime ISO 8601 con offset o Z.";
+  }
+  if (
+    field.dataType === "enum" &&
+    typeof value === "string" &&
+    !field.enumValues?.includes(value)
+  ) {
+    return 'El valor "' + value + '" no existe en enumValues.';
+  }
+  return null;
+};
+
+const visitStringValues = (value: JsonValue, visitor: (text: string) => void): void => {
+  if (typeof value === "string") {
+    visitor(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) visitStringValues(item, visitor);
+    return;
+  }
+  if (value && typeof value === "object") {
+    for (const item of Object.values(value)) visitStringValues(item, visitor);
+  }
+};
+
+export const validateMockProfileReferences = (input: {
+  profile: MockGenerationProfile;
+  dataContract: DataContractLike;
+}): SimulatorValidationIssue[] => {
+  const issues: SimulatorValidationIssue[] = [];
+  const { profile, dataContract } = input;
+
+  for (const [entityId, binding] of Object.entries(profile.entityKeys)) {
+    const { entityId: fieldEntityId, fieldId, field } = getField(dataContract, binding.field);
+    if (!dataContract.entities[entityId]) {
+      issues.push({
+        path: ["entityKeys", entityId],
+        message: 'La entidad "' + entityId + '" no existe en la Spec 1.',
+      });
+    }
+    if (fieldEntityId !== entityId) {
+      issues.push({
+        path: ["entityKeys", entityId, "field"],
+        message: "La key de entidad debe apuntar a un campo de la misma entidad.",
+      });
+    }
+    if (!field) {
+      issues.push({
+        path: ["entityKeys", entityId, "field"],
+        message: 'El campo "' + fieldEntityId + "." + fieldId + '" no existe.',
+      });
+    } else if (!["identifier", "string", "number"].includes(field.dataType)) {
+      issues.push({
+        path: ["entityKeys", entityId, "field"],
+        message: "La key debe ser identifier, string o number.",
+      });
+    }
+  }
+
+  for (const [bindingId, binding] of Object.entries(profile.relationBindings)) {
+    const relation = dataContract.relations.find((candidate) => candidate.id === binding.relation);
+    if (!relation) {
+      issues.push({
+        path: ["relationBindings", bindingId, "relation"],
+        message: 'La relación "' + binding.relation + '" no existe en la Spec 1.',
+      });
+    }
+    for (const key of ["fromField", "toField"] as const) {
+      const { entityId, fieldId, field } = getField(dataContract, binding[key]);
+      if (!field) {
+        issues.push({
+          path: ["relationBindings", bindingId, key],
+          message: 'El campo "' + entityId + "." + fieldId + '" no existe.',
+        });
+      }
+    }
+  }
+
+  for (const [reference, hint] of Object.entries(profile.fieldHints)) {
+    const { entityId, fieldId, field } = getField(dataContract, reference);
+    if (!field) {
+      issues.push({
+        path: ["fieldHints", reference],
+        message: 'El campo "' + entityId + "." + fieldId + '" no existe.',
+      });
+      continue;
+    }
+    if (!isSemanticCompatible(hint.semantic, field)) {
+      issues.push({
+        path: ["fieldHints", reference, "semantic"],
+        message:
+          'La semántica "' + hint.semantic + '" no es compatible con ' + field.dataType + ".",
+      });
+    }
+    if (field.dataType === "enum" && hint.constraints?.allowedValues) {
+      for (const value of hint.constraints.allowedValues) {
+        if (!field.enumValues?.includes(value)) {
+          issues.push({
+            path: ["fieldHints", reference, "constraints", "allowedValues"],
+            message: 'El valor "' + value + '" no existe en enumValues.',
+          });
+        }
+      }
+    }
+  }
+
+  return issues;
+};
+
+export const validateMockScenarios = (input: {
+  profile: MockGenerationProfile;
+  scenarios: PrototypeMockScenarios;
+  dataContract: DataContractLike;
+  eventEngineContract: EventEngineContractLike;
+}): SimulatorValidationIssue[] => {
+  const issues: SimulatorValidationIssue[] = [];
+  const { profile, scenarios, dataContract, eventEngineContract } = input;
+
+  for (const [scenarioId, scenario] of Object.entries(scenarios.scenarios)) {
+    for (const [entityId, records] of Object.entries(scenario.entities)) {
+      const entity = dataContract.entities[entityId];
+      if (!entity) {
+        issues.push({
+          path: ["scenarios", scenarioId, "entities", entityId],
+          message: 'La entidad "' + entityId + '" no existe en la Spec 1.',
+        });
+        continue;
+      }
+
+      const keyBinding = profile.entityKeys[entityId];
+      const seenKeys = new Set<JsonValue>();
+      for (const [recordIndex, record] of records.entries()) {
+        for (const fieldKey of Object.keys(record)) {
+          if (!entity.fields[fieldKey]) {
+            issues.push({
+              path: ["scenarios", scenarioId, "entities", entityId, recordIndex, fieldKey],
+              message: 'El campo "' + fieldKey + '" no existe en la entidad "' + entityId + '".',
+            });
+          }
+        }
+
+        for (const [fieldKey, field] of Object.entries(entity.fields)) {
+          const value = record[fieldKey];
+          if (field.required && value === undefined) {
+            issues.push({
+              path: ["scenarios", scenarioId, "entities", entityId, recordIndex, fieldKey],
+              message: "El campo requerido está ausente.",
+            });
+            continue;
+          }
+          if (value !== undefined) {
+            const typeMessage = validateValueType(field, value);
+            if (typeMessage) {
+              issues.push({
+                path: ["scenarios", scenarioId, "entities", entityId, recordIndex, fieldKey],
+                message: typeMessage,
+              });
+            }
+
+            const hint = profile.fieldHints[entityId + "." + fieldKey];
+            if (hint) {
+              const chileMessage = validateChileanValue({
+                value,
+                hint,
+                emailDomain: profile.safety.emailDomain,
+              });
+              if (chileMessage) {
+                issues.push({
+                  path: ["scenarios", scenarioId, "entities", entityId, recordIndex, fieldKey],
+                  message: chileMessage,
+                });
+              }
+            }
+
+            visitStringValues(value, (text) => {
+              if (emailFormat.test(text) && !text.endsWith("@" + profile.safety.emailDomain)) {
+                issues.push({
+                  path: ["scenarios", scenarioId, "entities", entityId, recordIndex, fieldKey],
+                  message:
+                    'Los correos mock deben usar el dominio "' + profile.safety.emailDomain + '".',
+                });
+              }
+              if (secretLikeFormat.test(text)) {
+                issues.push({
+                  path: ["scenarios", scenarioId, "entities", entityId, recordIndex, fieldKey],
+                  message: "El valor parece contener un secreto, token o credencial.",
+                });
+              }
+            });
+          }
+        }
+
+        if (keyBinding) {
+          const { fieldId } = splitReference(keyBinding.field);
+          const keyValue = record[fieldId];
+          if (keyValue !== undefined) {
+            if (seenKeys.has(keyValue)) {
+              issues.push({
+                path: ["scenarios", scenarioId, "entities", entityId, recordIndex, fieldId],
+                message: 'La key "' + String(keyValue) + '" está duplicada.',
+              });
+            }
+            seenKeys.add(keyValue);
+          }
+        }
+      }
+    }
+
+    for (const [bindingId, binding] of Object.entries(profile.relationBindings)) {
+      const from = splitReference(binding.fromField);
+      const to = splitReference(binding.toField);
+      const fromRecords = scenario.entities[from.entityId] ?? [];
+      const toRecords = scenario.entities[to.entityId] ?? [];
+      const targetValues = new Set(toRecords.map((record) => record[to.fieldId]));
+
+      for (const [recordIndex, record] of fromRecords.entries()) {
+        const value = record[from.fieldId];
+        if (value !== undefined && value !== null && !targetValues.has(value)) {
+          issues.push({
+            path: ["scenarios", scenarioId, "entities", from.entityId, recordIndex, from.fieldId],
+            message:
+              'Referencia "' +
+              String(value) +
+              '" inexistente para relationBinding "' +
+              bindingId +
+              '".',
+          });
+        }
+      }
+    }
+
+    for (const [loadId, behavior] of Object.entries(scenario.behaviors?.dataLoads ?? {})) {
+      if (!eventEngineContract.dataLoads[loadId]) {
+        issues.push({
+          path: ["scenarios", scenarioId, "behaviors", "dataLoads", loadId],
+          message: 'La carga "' + loadId + '" no existe en la Spec 2.',
+        });
+      }
+      if ((behavior.outcome ?? "normal") === "empty" && behavior.error) {
+        issues.push({
+          path: ["scenarios", scenarioId, "behaviors", "dataLoads", loadId, "error"],
+          message: "El outcome empty no puede incluir error.",
+        });
+      }
+    }
+
+    for (const eventId of Object.keys(scenario.behaviors?.events ?? {})) {
+      if (!eventEngineContract.events[eventId]) {
+        issues.push({
+          path: ["scenarios", scenarioId, "behaviors", "events", eventId],
+          message: 'El evento "' + eventId + '" no existe en la Spec 2.',
+        });
+      }
+    }
+  }
+
+  return issues;
+};
+
+export function defineMockGenerationProfile(profile: MockGenerationProfile): MockGenerationProfile {
+  return mockGenerationProfileSchema.parse(profile);
+}
+
+export function definePrototypeMockScenarios(
+  scenarios: PrototypeMockScenarios,
+): PrototypeMockScenarios {
+  return prototypeMockScenariosSchema.parse(scenarios);
+}
+`,Ft=String.raw`import { defineMockGenerationProfile } from "./simulator-contract-schema";
+
+/**
+ * Perfil para que el agente genere data mock coherente con Chile.
+ *
+ * La IA lo completa en autoría. El runtime solo consume objetos TypeScript
+ * explícitos y deterministas.
+ */
+export const mockGenerationProfile = defineMockGenerationProfile({
+  profileVersion: "1",
+  locale: {
+    language: "es",
+    locale: "es-CL",
+    country: "CL",
+    timezone: "America/Santiago",
+    currency: "CLP",
+    dateStorage: "iso8601",
+    dateDisplay: "dd-MM-yyyy",
+    timeDisplay: "24h",
+  },
+  safety: {
+    syntheticOnly: true,
+    allowProductionImports: false,
+    externalUse: false,
+    emailDomain: "example.com",
+  },
+  entityKeys: {},
+  relationBindings: {},
+  fieldHints: {},
+});
+`,Nt=String.raw`import { definePrototypeMockScenarios } from "./simulator-contract-schema";
+
+/**
+ * Escenarios mock persistibles.
+ *
+ * Un proyecto fresco nace vacío y válido. El agente agrega fixtures explícitos
+ * después del kickoff y sube datasetVersion cuando cambia el dataset.
+ */
+export const prototypeMockScenarios = definePrototypeMockScenarios({
+  scenariosVersion: "1",
+  datasetVersion: 1,
+  defaultScenarioId: "base",
+  scenarios: {
+    base: {
+      id: "base",
+      name: "Recorrido principal",
+      description: "Escenario inicial pendiente de completar durante el kickoff.",
+      entities: {},
+    },
+    empty: {
+      id: "empty",
+      name: "Estado vacío",
+      description: "Escenario sin resultados.",
+      entities: {},
+    },
+    edgeCases: {
+      id: "edgeCases",
+      name: "Casos límite",
+      description: "Escenario pendiente de completar según la experiencia.",
+      entities: {},
+    },
+  },
+});
+`,Ht=String.raw`import type { ProjectionResolverMap } from "./prototype-simulator";
+
+export const projectionResolvers: ProjectionResolverMap = {};
+`,Kt=String.raw`import type { MockDataLoadHandlerMap } from "./prototype-simulator";
+
+export const dataLoadHandlers: MockDataLoadHandlerMap = {};
+`,qt=String.raw`import type { MockEventHandlerMap } from "./prototype-simulator";
+
+export const eventHandlers: MockEventHandlerMap = {};
+`,Ut=String.raw`import type {
+  JsonPrimitive,
+  MockEntityRecord,
+  PrototypeMockScenarios,
+} from "./simulator-contract-schema";
+
+export type PublishedEventHistoryItem = {
+  publicationId: string;
+  eventId: string;
+  technicalId: string;
+  occurredAt: string;
+  status: "published";
+};
+
+export type PrototypeSimulatorState = {
+  simulatorVersion: "1";
+  datasetVersion: number;
+  activeScenarioId: string;
+  revision: number;
+  entities: Record<string, MockEntityRecord[]>;
+  entitySequences: Record<string, number>;
+  publicationHistory: PublishedEventHistoryItem[];
+};
+
+export type SimulatorStorage = {
+  read(): string | null;
+  write(value: string): void;
+  remove(): void;
+};
+
+export type PrototypeMockStore = {
+  getSnapshot(): PrototypeSimulatorState;
+  subscribe(listener: () => void): () => void;
+  transact(operation: (draft: PrototypeSimulatorState) => void): PrototypeSimulatorState;
+  switchScenario(scenarioId: string): void;
+  resetScenario(): void;
+  clearPersistence(): void;
+};
+
+type CreatePrototypeMockStoreOptions = {
+  projectName: string;
+  scenarios: PrototypeMockScenarios;
+  storage?: SimulatorStorage;
+  onHydrationWarning?: (message: string) => void;
+};
+
+const clone = <T>(value: T): T => {
+  if (typeof structuredClone === "function") return structuredClone(value);
+  return JSON.parse(JSON.stringify(value)) as T;
+};
+
+const buildSequences = (entities: Record<string, MockEntityRecord[]>) => {
+  const sequences: Record<string, number> = {};
+  for (const [entityId, records] of Object.entries(entities)) {
+    sequences[entityId] = records.length + 1;
+  }
+  return sequences;
+};
+
+const createStateFromScenario = (
+  scenarios: PrototypeMockScenarios,
+  scenarioId: string,
+): PrototypeSimulatorState => {
+  const scenario = scenarios.scenarios[scenarioId];
+  if (!scenario) throw new Error('El escenario "' + scenarioId + '" no existe.');
+  const entities = clone(scenario.entities);
+  return {
+    simulatorVersion: "1",
+    datasetVersion: scenarios.datasetVersion,
+    activeScenarioId: scenarioId,
+    revision: 0,
+    entities,
+    entitySequences: buildSequences(entities),
+    publicationHistory: [],
+  };
+};
+
+const isPersistedStateCompatible = (
+  value: unknown,
+  scenarios: PrototypeMockScenarios,
+): value is PrototypeSimulatorState => {
+  if (!value || typeof value !== "object") return false;
+  const state = value as Partial<PrototypeSimulatorState>;
+  return (
+    state.simulatorVersion === "1" &&
+    state.datasetVersion === scenarios.datasetVersion &&
+    typeof state.activeScenarioId === "string" &&
+    Boolean(scenarios.scenarios[state.activeScenarioId]) &&
+    typeof state.revision === "number" &&
+    Boolean(state.entities && typeof state.entities === "object") &&
+    Boolean(state.entitySequences && typeof state.entitySequences === "object") &&
+    Array.isArray(state.publicationHistory)
+  );
+};
+
+export const createMemorySimulatorStorage = (): SimulatorStorage => {
+  let current: string | null = null;
+  return {
+    read: () => current,
+    write: (value) => {
+      current = value;
+    },
+    remove: () => {
+      current = null;
+    },
+  };
+};
+
+export const createLocalStorageSimulatorStorage = (key: string): SimulatorStorage => {
+  const memory = createMemorySimulatorStorage();
+  const getLocalStorage = () => {
+    try {
+      return globalThis.localStorage;
+    } catch {
+      return undefined;
+    }
+  };
+
+  return {
+    read: () => {
+      try {
+        return getLocalStorage()?.getItem(key) ?? memory.read();
+      } catch {
+        return memory.read();
+      }
+    },
+    write: (value) => {
+      memory.write(value);
+      try {
+        getLocalStorage()?.setItem(key, value);
+      } catch {
+        // fallback en memoria
+      }
+    },
+    remove: () => {
+      memory.remove();
+      try {
+        getLocalStorage()?.removeItem(key);
+      } catch {
+        // fallback en memoria
+      }
+    },
+  };
+};
+
+export const simulatorStorageKey = (projectName: string) =>
+  "lexy:prototype:" + projectName + ":simulator:v1";
+
+export const createPrototypeMockStore = (
+  options: CreatePrototypeMockStoreOptions,
+): PrototypeMockStore => {
+  const storage =
+    options.storage ?? createLocalStorageSimulatorStorage(simulatorStorageKey(options.projectName));
+  const listeners = new Set<() => void>();
+
+  const hydrate = () => {
+    const persisted = storage.read();
+    if (!persisted)
+      return createStateFromScenario(options.scenarios, options.scenarios.defaultScenarioId);
+
+    try {
+      const parsed = JSON.parse(persisted) as unknown;
+      if (isPersistedStateCompatible(parsed, options.scenarios)) return parsed;
+      options.onHydrationWarning?.(
+        "Estado persistido incompatible; se reinicia el simulador al escenario default.",
+      );
+    } catch {
+      options.onHydrationWarning?.(
+        "Estado persistido corrupto; se reinicia el simulador al escenario default.",
+      );
+    }
+    return createStateFromScenario(options.scenarios, options.scenarios.defaultScenarioId);
+  };
+
+  let snapshot = hydrate();
+
+  const persist = () => {
+    storage.write(JSON.stringify(snapshot));
+  };
+
+  const notify = () => {
+    for (const listener of listeners) listener();
+  };
+
+  return {
+    getSnapshot: () => snapshot,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    transact: (operation) => {
+      const draft = clone(snapshot);
+      operation(draft);
+      draft.revision = snapshot.revision + 1;
+      snapshot = draft;
+      persist();
+      notify();
+      return snapshot;
+    },
+    switchScenario: (scenarioId) => {
+      snapshot = createStateFromScenario(options.scenarios, scenarioId);
+      persist();
+      notify();
+    },
+    resetScenario: () => {
+      snapshot = createStateFromScenario(options.scenarios, snapshot.activeScenarioId);
+      persist();
+      notify();
+    },
+    clearPersistence: () => {
+      storage.remove();
+    },
+  };
+};
+
+export const findRecordById = (
+  records: readonly MockEntityRecord[],
+  fieldId: string,
+  id: JsonPrimitive,
+) => records.find((record) => record[fieldId] === id);
+`,Bt=String.raw`import type {
+  EventPublicationEnvelope,
+  PrototypeBackendExecutor,
+} from "../event-engine/event-engine";
+import type {
+  JsonPrimitive,
+  MockEntityRecord,
+  MockGenerationProfile,
+  MockOperationError,
+  PrototypeMockScenarios,
+} from "./simulator-contract-schema";
+import {
+  findRecordById,
+  type PrototypeMockStore,
+  type PrototypeSimulatorState,
+} from "./mock-store";
+import type {
+  MockDataLoadHandlerMap,
+  MockEventHandlerMap,
+  ProjectionResolverContext,
+  ProjectionResolverMap,
+} from "./prototype-simulator";
+
+export class MockBackendError extends Error {
+  code: string;
+  recoverable: boolean;
+
+  constructor(error: MockOperationError) {
+    super(error.message);
+    this.name = "MockBackendError";
+    this.code = error.code;
+    this.recoverable = error.recoverable;
+  }
+}
+
+type CreateMockBackendExecutorOptions = {
+  profile: MockGenerationProfile;
+  scenarios: PrototypeMockScenarios;
+  store: PrototypeMockStore;
+  projectionResolvers: ProjectionResolverMap;
+  dataLoadHandlers: MockDataLoadHandlerMap;
+  eventHandlers: MockEventHandlerMap;
+};
+
+const delay = (latencyMs: number | undefined, signal?: AbortSignal) =>
+  new Promise<void>((resolve, reject) => {
+    if (!latencyMs) {
+      resolve();
+      return;
+    }
+    if (signal?.aborted) {
+      reject(new DOMException("Operación abortada.", "AbortError"));
+      return;
+    }
+    const timeout = globalThis.setTimeout(resolve, latencyMs);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        globalThis.clearTimeout(timeout);
+        reject(new DOMException("Operación abortada.", "AbortError"));
+      },
+      { once: true },
+    );
+  });
+
+const splitReference = (reference: string) => {
+  const [entityId, fieldId] = reference.split(".");
+  return { entityId, fieldId };
+};
+
+const getEntityKeyField = (profile: MockGenerationProfile, entityId: string) => {
+  const field = profile.entityKeys[entityId]?.field;
+  return field ? splitReference(field).fieldId : "id";
+};
+
+const createProjectionContext = (
+  profile: MockGenerationProfile,
+  state: PrototypeSimulatorState,
+): ProjectionResolverContext => ({
+  entities: state.entities,
+  getEntity: (entityId) => state.entities[entityId] ?? [],
+  getById: (entityId, id) =>
+    findRecordById(state.entities[entityId] ?? [], getEntityKeyField(profile, entityId), id),
+  getRelated: (relationId, sourceId) => {
+    const binding = Object.values(profile.relationBindings).find(
+      (candidate) => candidate.relation === relationId,
+    );
+    if (!binding) return [];
+    const target = splitReference(binding.toField);
+    return (state.entities[target.entityId] ?? []).filter(
+      (record) => record[target.fieldId] === sourceId,
+    );
+  },
+});
+
+const nextEntityId = (
+  profile: MockGenerationProfile,
+  draft: PrototypeSimulatorState,
+  entityId: string,
+): JsonPrimitive => {
+  const keyField = getEntityKeyField(profile, entityId);
+  const records = draft.entities[entityId] ?? [];
+  const numericIds = records
+    .map((record) => record[keyField])
+    .filter((value): value is number => typeof value === "number");
+  if (numericIds.length > 0) return Math.max(...numericIds) + 1;
+
+  const sequence = draft.entitySequences[entityId] ?? records.length + 1;
+  draft.entitySequences[entityId] = sequence + 1;
+  return entityId + "-" + sequence;
+};
+
+export const createMockBackendExecutor = (
+  options: CreateMockBackendExecutorOptions,
+): PrototypeBackendExecutor => ({
+  async loadData(input) {
+    const state = options.store.getSnapshot();
+    const scenario = options.scenarios.scenarios[state.activeScenarioId];
+    const behavior = scenario.behaviors?.dataLoads?.[input.loadId];
+    await delay(behavior?.latencyMs, input.signal);
+
+    if (behavior?.outcome === "error" && behavior.error) throw new MockBackendError(behavior.error);
+    if (behavior?.outcome === "empty") return [];
+
+    const handler = options.dataLoadHandlers[input.loadId];
+    if (!handler) throw new Error('Falta handler para la carga "' + input.loadId + '".');
+
+    return handler({
+      params: input.params,
+      signal: input.signal,
+      store: options.store,
+      projections: {
+        resolve: (projectionId, params) => {
+          const resolver = options.projectionResolvers[projectionId];
+          if (!resolver)
+            throw new Error('Falta resolver para la proyección "' + projectionId + '".');
+          return resolver(
+            createProjectionContext(options.profile, options.store.getSnapshot()),
+            params,
+          );
+        },
+      },
+    });
+  },
+
+  async publishEvent(input) {
+    const state = options.store.getSnapshot();
+    const scenario = options.scenarios.scenarios[state.activeScenarioId];
+    const behavior = scenario.behaviors?.events?.[input.eventId];
+    await delay(behavior?.latencyMs);
+
+    if (behavior?.outcome === "error" && behavior.error) throw new MockBackendError(behavior.error);
+
+    const handler = options.eventHandlers[input.eventId];
+    if (!handler) throw new Error('Falta handler para el evento "' + input.eventId + '".');
+
+    let receipt: unknown;
+    options.store.transact((draft) => {
+      const getById = (entityId: string, id: JsonPrimitive): MockEntityRecord | undefined =>
+        findRecordById(
+          draft.entities[entityId] ?? [],
+          getEntityKeyField(options.profile, entityId),
+          id,
+        );
+
+      const result = handler({
+        draft,
+        envelope: input.envelope as EventPublicationEnvelope,
+        getById,
+        nextEntityId: (entityId) => nextEntityId(options.profile, draft, entityId),
+      });
+      receipt = result?.receipt;
+      draft.publicationHistory.push({
+        publicationId: input.envelope.publicationId,
+        eventId: input.eventId,
+        technicalId: input.envelope.technicalId,
+        occurredAt: input.envelope.occurredAt,
+        status: "published",
+      });
+    });
+
+    return receipt === undefined ? {} : { receipt };
+  },
+});
+`,Jt=String.raw`import type { EventPublicationEnvelope } from "../event-engine/event-engine";
+import { createPrototypeEventEngine } from "../event-engine/event-engine";
+import { prototypeDataContract } from "../data-contract/prototype-data-contract";
+import { dataLoadHandlers } from "./data-load-handlers";
+import { eventHandlers } from "./event-handlers";
+import { mockGenerationProfile } from "./mock-generation-profile";
+import { createMockBackendExecutor } from "./mock-backend-executor";
+import { createPrototypeMockStore, type PrototypeMockStore } from "./mock-store";
+import { prototypeMockScenarios } from "./mock-scenarios";
+import { projectionResolvers } from "./projection-resolvers";
+import type {
+  JsonPrimitive,
+  MockEntityRecord,
+  MockGenerationProfile,
+  PrototypeMockScenarios,
+} from "./simulator-contract-schema";
+
+export type ProjectionResolverContext = {
+  entities: Readonly<Record<string, readonly MockEntityRecord[]>>;
+  getEntity(entityId: string): readonly MockEntityRecord[];
+  getById(entityId: string, id: JsonPrimitive): MockEntityRecord | undefined;
+  getRelated(relationId: string, sourceId: JsonPrimitive): readonly MockEntityRecord[];
+};
+
+export type ProjectionResolver = (context: ProjectionResolverContext, params?: unknown) => unknown;
+
+export type ProjectionResolverMap = Record<string, ProjectionResolver>;
+
+export type MockDataLoadHandlerContext = {
+  params: unknown;
+  signal?: AbortSignal;
+  store: PrototypeMockStore;
+  projections: {
+    resolve(projectionId: string, params?: unknown): unknown;
+  };
+};
+
+export type MockDataLoadHandler = (
+  context: MockDataLoadHandlerContext,
+) => unknown | Promise<unknown>;
+
+export type MockDataLoadHandlerMap = Record<string, MockDataLoadHandler>;
+
+export type MockEventHandlerContext = {
+  draft: import("./mock-store").PrototypeSimulatorState;
+  envelope: EventPublicationEnvelope;
+  getById(entityId: string, id: JsonPrimitive): MockEntityRecord | undefined;
+  nextEntityId(entityId: string): JsonPrimitive;
+};
+
+export type MockEventHandlerResult = {
+  receipt?: unknown;
+};
+
+export type MockEventHandler = (context: MockEventHandlerContext) => MockEventHandlerResult | void;
+
+export type MockEventHandlerMap = Record<string, MockEventHandler>;
+
+export type PrototypeSimulator = {
+  executor: ReturnType<typeof createMockBackendExecutor>;
+  store: PrototypeMockStore;
+  getActiveScenario(): PrototypeMockScenarios["scenarios"][string];
+  listScenarios(): Array<{ id: string; name: string; description: string }>;
+  switchScenario(scenarioId: string): void;
+  reset(): void;
+  clearPersistence(): void;
+};
+
+type CreatePrototypeSimulatorOptions = {
+  profile: MockGenerationProfile;
+  scenarios: PrototypeMockScenarios;
+  projectionResolvers: ProjectionResolverMap;
+  dataLoadHandlers: MockDataLoadHandlerMap;
+  eventHandlers: MockEventHandlerMap;
+};
+
+export const createPrototypeSimulator = (
+  options: CreatePrototypeSimulatorOptions,
+): PrototypeSimulator => {
+  const store = createPrototypeMockStore({
+    projectName: prototypeDataContract.project.name,
+    scenarios: options.scenarios,
+    onHydrationWarning: (message) => {
+      console.warn("[Lexy simulator] " + message);
+    },
+  });
+
+  const executor = createMockBackendExecutor({
+    profile: options.profile,
+    scenarios: options.scenarios,
+    store,
+    projectionResolvers: options.projectionResolvers,
+    dataLoadHandlers: options.dataLoadHandlers,
+    eventHandlers: options.eventHandlers,
+  });
+
+  return {
+    executor,
+    store,
+    getActiveScenario: () => options.scenarios.scenarios[store.getSnapshot().activeScenarioId],
+    listScenarios: () =>
+      Object.values(options.scenarios.scenarios).map((scenario) => ({
+        id: scenario.id,
+        name: scenario.name,
+        description: scenario.description,
+      })),
+    switchScenario: (scenarioId) => store.switchScenario(scenarioId),
+    reset: () => store.resetScenario(),
+    clearPersistence: () => store.clearPersistence(),
+  };
+};
+
+export const prototypeSimulator = createPrototypeSimulator({
+  profile: mockGenerationProfile,
+  scenarios: prototypeMockScenarios,
+  projectionResolvers,
+  dataLoadHandlers,
+  eventHandlers,
+});
+
+export const prototypeEventEngine = createPrototypeEventEngine({
+  executor: prototypeSimulator.executor,
+});
+`,Gt=String.raw`import { ZodError } from "zod";
+
+import { prototypeDataContractSchema } from "../src/prototype/data-contract/data-contract-schema";
+import { prototypeEventEngineContractSchema } from "../src/prototype/event-engine/event-engine-contract-schema";
+import { dataLoadHandlers } from "../src/prototype/simulator/data-load-handlers";
+import { eventHandlers } from "../src/prototype/simulator/event-handlers";
+import { mockGenerationProfile } from "../src/prototype/simulator/mock-generation-profile";
+import { prototypeMockScenarios } from "../src/prototype/simulator/mock-scenarios";
+import { projectionResolvers } from "../src/prototype/simulator/projection-resolvers";
+import {
+  mockGenerationProfileSchema,
+  prototypeMockScenariosSchema,
+  validateMockProfileReferences,
+  validateMockScenarios,
+  type SimulatorValidationIssue,
+} from "../src/prototype/simulator/simulator-contract-schema";
+
+const formatPath = (path: Array<string | number>) =>
+  path.length === 0 ? "simulator" : path.map(String).join(".");
+
+const printIssues = (issues: SimulatorValidationIssue[]) => {
+  console.error("✗ Simulador inválido");
+  for (const issue of issues) {
+    console.error("  " + formatPath(issue.path));
+    console.error("  " + issue.message);
+  }
+};
+
+try {
+  const dataContractModule = await import("../src/prototype/data-contract/prototype-data-contract");
+  const eventEngineModule =
+    await import("../src/prototype/event-engine/prototype-event-engine-contract");
+
+  const dataContractResult = prototypeDataContractSchema.safeParse(
+    dataContractModule.prototypeDataContract,
+  );
+  const eventEngineResult = prototypeEventEngineContractSchema.safeParse(
+    eventEngineModule.prototypeEventEngineContract,
+  );
+  const profileResult = mockGenerationProfileSchema.safeParse(mockGenerationProfile);
+  const scenariosResult = prototypeMockScenariosSchema.safeParse(prototypeMockScenarios);
+
+  const issues: SimulatorValidationIssue[] = [];
+  for (const [prefix, result] of [
+    ["dataContract", dataContractResult],
+    ["eventEngine", eventEngineResult],
+    ["profile", profileResult],
+    ["scenarios", scenariosResult],
+  ] as const) {
+    if (!result.success) {
+      for (const issue of result.error.issues) {
+        issues.push({
+          path: [prefix, ...issue.path.map(String)],
+          message: issue.message,
+        });
+      }
+    }
+  }
+
+  if (
+    dataContractResult.success &&
+    eventEngineResult.success &&
+    profileResult.success &&
+    scenariosResult.success
+  ) {
+    issues.push(
+      ...validateMockProfileReferences({
+        profile: profileResult.data,
+        dataContract: dataContractResult.data,
+      }),
+      ...validateMockScenarios({
+        profile: profileResult.data,
+        scenarios: scenariosResult.data,
+        dataContract: dataContractResult.data,
+        eventEngineContract: eventEngineResult.data,
+      }),
+    );
+
+    for (const projectionId of Object.keys(projectionResolvers)) {
+      if (!dataContractResult.data.projections[projectionId]) {
+        issues.push({
+          path: ["projectionResolvers", projectionId],
+          message: 'La proyección "' + projectionId + '" no existe en la Spec 1.',
+        });
+      }
+    }
+
+    const requiredProjections = new Set<string>();
+    for (const load of Object.values(eventEngineResult.data.dataLoads)) {
+      for (const projectionId of load.reads?.projections ?? [])
+        requiredProjections.add(projectionId);
+    }
+    for (const projectionId of requiredProjections) {
+      if (!projectionResolvers[projectionId]) {
+        issues.push({
+          path: ["projectionResolvers", projectionId],
+          message: 'Falta resolver para la proyección consumida "' + projectionId + '".',
+        });
+      }
+    }
+
+    for (const loadId of Object.keys(eventEngineResult.data.dataLoads)) {
+      if (!dataLoadHandlers[loadId]) {
+        issues.push({
+          path: ["dataLoadHandlers", loadId],
+          message: 'Falta handler para la carga "' + loadId + '".',
+        });
+      }
+    }
+    for (const handlerId of Object.keys(dataLoadHandlers)) {
+      if (!eventEngineResult.data.dataLoads[handlerId]) {
+        issues.push({
+          path: ["dataLoadHandlers", handlerId],
+          message: 'El handler "' + handlerId + '" no corresponde a ninguna carga.',
+        });
+      }
+    }
+
+    for (const eventId of Object.keys(eventEngineResult.data.events)) {
+      if (!eventHandlers[eventId]) {
+        issues.push({
+          path: ["eventHandlers", eventId],
+          message: 'Falta handler para el evento "' + eventId + '".',
+        });
+      }
+    }
+    for (const handlerId of Object.keys(eventHandlers)) {
+      if (!eventEngineResult.data.events[handlerId]) {
+        issues.push({
+          path: ["eventHandlers", handlerId],
+          message: 'El handler "' + handlerId + '" no corresponde a ningún evento.',
+        });
+      }
+    }
+  }
+
+  if (issues.length > 0) {
+    printIssues(issues);
+    process.exitCode = 1;
+  } else {
+    console.log("✓ Simulador válido");
+    console.log("  " + Object.keys(prototypeMockScenarios.scenarios).length + " escenarios");
+    console.log("  datasetVersion " + prototypeMockScenarios.datasetVersion);
+  }
+} catch (error) {
+  if (error instanceof ZodError) {
+    printIssues(
+      error.issues.map((issue) => ({ path: issue.path.map(String), message: issue.message })),
+    );
+  } else {
+    console.error("✗ No se pudo cargar el simulador");
+    console.error("  " + (error instanceof Error ? error.message : String(error)));
+  }
+  process.exitCode = 1;
+}
+`,He=async e=>{let t=async(o,r)=>{let a=Ne.join(e,o);await Fe.mkdir(Ne.dirname(a),{recursive:!0}),await Fe.writeFile(a,r)};await t(Lt,_t),await t(ce,Ft),await t(le,Nt),await t(zt,Ht),await t(At,Kt),await t(Ot,qt),await t(Dt,Ut),await t($t,Bt),await t(de,Jt),await t(Vt,Gt)};var Zt={feature:["src/app","src/features","src/shared/assets","src/shared/components/base","src/shared/hooks","src/shared/services","src/shared/lib","src/shared/types"],layer:["src/assets","src/components/base","src/hooks","src/services","src/lib","src/types","src/views","src/stores"]},Wt="10.33.3",Xt=e=>{let t=e.architecture==="feature"?{"react-router":"^7.9.0"}:{};return JSON.stringify({name:e.projectName,private:!0,version:"0.0.0",type:"module",packageManager:`pnpm@${Wt}`,scripts:{dev:"vite","check:data-contract":"tsx scripts/check-data-contract.ts","check:event-engine":"tsx scripts/check-event-engine.ts","check:simulator":"tsx scripts/check-simulator.ts","check:prototype":"pnpm check:data-contract && pnpm check:event-engine && pnpm check:simulator","build:app":"tsc -b && vite build",build:"pnpm check:prototype && pnpm build:app",preview:"vite preview",lint:"eslint .",format:"prettier --write ."},dependencies:{clsx:"^2.1.1",react:"^19.2.6","react-dom":"^19.2.6",...t,"tailwind-merge":"^3.3.1",zod:"^4.1.0"},devDependencies:{"@babel/core":"^7.29.7","@eslint/js":"^10.0.1","@rolldown/plugin-babel":"^0.2.3","@tailwindcss/vite":"^4.3.0","@types/babel__core":"^7.20.5","@types/node":"^24.12.3","@types/react":"^19.2.14","@types/react-dom":"^19.2.3","@vitejs/plugin-react":"^6.0.1","babel-plugin-react-compiler":"^1.0.0",eslint:"^10.4.1","eslint-plugin-jsx-a11y":"^6.10.2","eslint-plugin-react-hooks":"^7.1.1","eslint-plugin-simple-import-sort":"^13.0.0",globals:"^17.6.0",prettier:"^3.8.4",tailwindcss:"^4.3.0",terser:"^5.48.0",tsx:"^4.19.0",typescript:"~5.9.3","typescript-eslint":"^8.61.0",vite:"^8.0.12"}},null,2)+`
+`},Yt=`import path from "node:path";
 
 import babel from "@rolldown/plugin-babel";
 import tailwindcss from "@tailwindcss/vite";
@@ -52,7 +2442,7 @@ export default defineConfig({
     },
   },
 });
-`,Xe=`import js from "@eslint/js";
+`,Qt=`import js from "@eslint/js";
 import jsxA11y from "eslint-plugin-jsx-a11y";
 import reactHooks from "eslint-plugin-react-hooks";
 import simpleImportSort from "eslint-plugin-simple-import-sort";
@@ -81,14 +2471,14 @@ export default tseslint.config(
     },
   },
 );
-`,Qe=`{
+`,eo=`{
   "printWidth": 100
 }
-`,Ze=`pnpm-lock.yaml
+`,to=`pnpm-lock.yaml
 src/lexy-theme.css
 public/fonts/
 dist/
-`,et=`name: CI
+`,oo=`name: CI
 
 on:
   push:
@@ -108,9 +2498,12 @@ jobs:
       - run: pnpm install --frozen-lockfile
       - run: pnpm lint
       - run: pnpm exec prettier --check .
-      - run: pnpm build
+      - run: pnpm check:data-contract
+      - run: pnpm check:event-engine
+      - run: pnpm check:simulator
+      - run: pnpm build:app
       - run: pnpm audit --audit-level high
-`,tt=`{
+`,no=`{
   "files": [],
   "references": [{ "path": "./tsconfig.app.json" }, { "path": "./tsconfig.node.json" }],
   "compilerOptions": {
@@ -118,7 +2511,7 @@ jobs:
     "paths": { "@/*": ["./src/*"] }
   }
 }
-`,ot=`{
+`,ao=`{
   "compilerOptions": {
     "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
     "target": "ES2022",
@@ -142,7 +2535,7 @@ jobs:
   },
   "include": ["src"]
 }
-`,rt=`{
+`,ro=`{
   "compilerOptions": {
     "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
     "target": "ES2023",
@@ -159,7 +2552,7 @@ jobs:
   },
   "include": ["vite.config.ts"]
 }
-`,nt=e=>`<!doctype html>
+`,io=e=>`<!doctype html>
 <html lang="es">
   <head>
     <meta charset="UTF-8" />
@@ -171,9 +2564,9 @@ jobs:
     <script type="module" src="/src/main.tsx"></script>
   </body>
 </html>
-`,st=`@import "tailwindcss";
+`,so=`@import "tailwindcss";
 @import "./lexy-theme.css";
-`,it=e=>e.architecture==="feature"?`import "./index.css";
+`,co=e=>e.architecture==="feature"?`import "./index.css";
 
 import { StrictMode } from "react";
 import { createRoot } from "react-dom/client";
@@ -200,18 +2593,18 @@ createRoot(document.getElementById("root")!).render(
     <App />
   </StrictMode>,
 );
-`,be=`    <main className="flex min-h-screen items-center justify-center bg-background text-foreground">
+`,Ke=`    <main className="flex min-h-screen items-center justify-center bg-background text-foreground">
       <div className="text-center">
         <h1 className="text-2xl font-semibold">Proyecto Lexy listo</h1>
         <p className="mt-2 text-sm text-muted-foreground">
           Trae tu primer componente: <code>npx create-lexy add button</code>
         </p>
       </div>
-    </main>`,at=e=>e.architecture==="feature"?`import { Route, Routes } from "react-router";
+    </main>`,lo=e=>e.architecture==="feature"?`import { Route, Routes } from "react-router";
 
 const Home = () => {
   return (
-${be}
+${Ke}
   );
 };
 
@@ -224,52 +2617,53 @@ export const App = () => {
 };
 `:`export const App = () => {
   return (
-${be}
+${Ke}
   );
 };
-`,ct=`import { type ClassValue, clsx } from "clsx";
+`,po=`import { type ClassValue, clsx } from "clsx";
 import { twMerge } from "tailwind-merge";
 
 export function cn(...inputs: ClassValue[]) {
   return twMerge(clsx(inputs));
 }
-`,lt=`node_modules/
+`,mo=`node_modules/
 dist/
 *.log
 .env
-`,pt=e=>`# ${e.projectName}
+`,uo=e=>`# ${e.projectName}
 
 Proyecto Lexy (React + Vite + TS + theme Lexy). Los componentes viven en tu proyecto: m\xEDralos con \`view\`, inst\xE1lalos con \`add\`, ed\xEDtalos con libertad.
 
 \`\`\`bash
 pnpm dev                          # desarrollo
+pnpm check:prototype              # validar datos, cargas/eventos y simulador
 npx create-lexy view button       # ver un componente antes de instalarlo
 npx create-lexy add button        # instalarlo (local y editable)
 npx create-lexy doctor            # divergencia con el registry
 \`\`\`
-`,dt=e=>{let o=e.architecture==="feature"?"@/shared":"@";return JSON.stringify({$schema:"https://ui.shadcn.com/schema.json",style:"new-york",rsc:!1,tsx:!0,tailwind:{config:"",css:"src/index.css",baseColor:"neutral",cssVariables:!0},aliases:{components:`${o}/components`,ui:`${o}/components/base`,utils:`${o}/lib/utils/cn`,lib:`${o}/lib`,hooks:`${o}/hooks`},registries:{"@lexy":`${O}@latest/r/{name}.json`}},null,2)+`
-`},mt=e=>{let t=e.architecture==="feature";return{version:"2.0.0",generatedAt:new Date().toISOString(),architecture:e.architecture,world:e.world,registry:{package:"@lexydesign/registry",cdn:O},componentImportPattern:t?"@/shared/components/base/{Component}":"@/components/base/{Component}",paths:{components:t?"src/shared/components/base":"src/components/base",hooks:t?"src/shared/hooks":"src/hooks",services:t?"src/shared/services":"src/services",lib:t?"src/shared/lib":"src/lib",views:t?"src/features":"src/views"},installed:{}}},ve=async(e,t)=>{let o=["package.json","src","index.html",".lexy"],n=[];for(let c of o)try{await E.access(I.join(t,c)),n.push(c)}catch{}if(n.length>0)throw new Error(`El directorio actual ya contiene archivos de un proyecto (${n.join(", ")}). Ejecuta el comando dentro de una carpeta vac\xEDa.`);for(let c of Ke[e.architecture])await E.mkdir(I.join(t,c),{recursive:!0});let r=(c,d)=>E.writeFile(I.join(t,c),d);await r("package.json",We(e)),await r("vite.config.ts",Ye),await r("tsconfig.json",tt),await r("tsconfig.app.json",ot),await r("tsconfig.node.json",rt),await r("eslint.config.js",Xe),await r(".prettierrc",Qe),await r(".prettierignore",Ze),await E.mkdir(I.join(t,".github/workflows"),{recursive:!0}),await r(".github/workflows/ci.yml",et),await r("index.html",nt(e)),await r(".gitignore",lt),await r("README.md",pt(e)),await r("src/index.css",st),await r("src/main.tsx",it(e));let s=e.architecture==="feature"?"src/app":"src/views";await r(`${s}/App.tsx`,at(e));let i=mt(e);await r(".lexy",JSON.stringify(i,null,2)+`
-`),await r("components.json",dt(e)),await E.copyFile(me,I.join(t,"src/lexy-theme.css")),await E.mkdir(I.join(t,"public/fonts"),{recursive:!0}),await E.cp(ue,I.join(t,"public/fonts"),{recursive:!0});let p=I.join(t,i.paths.lib,"utils");await E.mkdir(p,{recursive:!0}),await E.writeFile(I.join(p,"cn.ts"),ct)};var ht=["feature","layer"],xt=["cliente","crm","mixto"],wt=e=>new Promise((t,o)=>{ut("pnpm",["install"],{cwd:e,stdio:"ignore",shell:!0}).on("close",r=>r===0?t():o(new Error(`pnpm install fall\xF3 con c\xF3digo ${r}`)))}),je=async(e,t)=>{let o;!!(e&&t.type)?(ht.includes(t.type)||(console.error(v.red(`Error: la arquitectura "${t.type}" no es v\xE1lida. Usa "feature" o "layer".`)),process.exit(1)),t.world&&!xt.includes(t.world)&&(console.error(v.red(`Error: el mundo "${t.world}" no es v\xE1lido. Usa "cliente", "crm" o "mixto".`)),process.exit(1)),t.world||console.warn(v.yellow('Aviso: sin --world; se asume "mixto". ')+v.dim("Pasa --world cliente|crm para fijar densidad y voz desde el inicio.")),o={projectName:e,architecture:t.type,world:t.world??"mixto"},console.log(v.blue("Modo automatizado detectado. Saltando interfaz interactiva..."))):o=await we(e),ft(`Nombre: ${o.projectName}
+`,fo=e=>{let o=e.architecture==="feature"?"@/shared":"@";return JSON.stringify({$schema:"https://ui.shadcn.com/schema.json",style:"new-york",rsc:!1,tsx:!0,tailwind:{config:"",css:"src/index.css",baseColor:"neutral",cssVariables:!0},aliases:{components:`${o}/components`,ui:`${o}/components/base`,utils:`${o}/lib/utils/cn`,lib:`${o}/lib`,hooks:`${o}/hooks`},registries:{"@lexy":`${F}@latest/r/{name}.json`}},null,2)+`
+`},yo=e=>{let t=e.architecture==="feature";return{version:"2.0.0",generatedAt:new Date().toISOString(),architecture:e.architecture,world:e.world,registry:{package:"@lexydesign/registry",cdn:F},componentImportPattern:t?"@/shared/components/base/{Component}":"@/components/base/{Component}",paths:{components:t?"src/shared/components/base":"src/components/base",hooks:t?"src/shared/hooks":"src/hooks",services:t?"src/shared/services":"src/services",lib:t?"src/shared/lib":"src/lib",views:t?"src/features":"src/views"},prototype:{dataContractVersion:"1",dataContractPath:re,eventEngineVersion:"1",eventEngineContractPath:ie,eventEnginePath:se,simulatorVersion:"1",simulatorProfilePath:ce,simulatorScenariosPath:le,simulatorPath:de,defaultScenarioId:"base"},installed:{}}},qe=async(e,t)=>{let o=["package.json","src","index.html",".lexy"],r=[];for(let l of o)try{await R.access(T.join(t,l)),r.push(l)}catch{}if(r.length>0)throw new Error(`El directorio actual ya contiene archivos de un proyecto (${r.join(", ")}). Ejecuta el comando dentro de una carpeta vac\xEDa.`);for(let l of Zt[e.architecture])await R.mkdir(T.join(t,l),{recursive:!0});let a=(l,y)=>R.writeFile(T.join(t,l),y);await a("package.json",Xt(e)),await a("vite.config.ts",Yt),await a("tsconfig.json",no),await a("tsconfig.app.json",ao),await a("tsconfig.node.json",ro),await a("eslint.config.js",Qt),await a(".prettierrc",eo),await a(".prettierignore",to),await R.mkdir(T.join(t,".github/workflows"),{recursive:!0}),await a(".github/workflows/ci.yml",oo),await a("index.html",io(e)),await a(".gitignore",mo),await a("README.md",uo(e)),await a("src/index.css",so),await a("src/main.tsx",co(e)),await De(t,e.projectName),await _e(t),await He(t);let i=e.architecture==="feature"?"src/app":"src/views";await a(`${i}/App.tsx`,lo(e));let n=yo(e);await a(".lexy",JSON.stringify(n,null,2)+`
+`),await a("components.json",fo(e)),await R.copyFile(Pe,T.join(t,"src/lexy-theme.css")),await R.mkdir(T.join(t,"public/fonts"),{recursive:!0}),await R.cp(Ce,T.join(t,"public/fonts"),{recursive:!0});let p=T.join(t,n.paths.lib,"utils");await R.mkdir(p,{recursive:!0}),await R.writeFile(T.join(p,"cn.ts"),po)};var xo=["feature","layer"],bo=["cliente","crm","mixto"],Io=e=>new Promise((t,o)=>{ho("pnpm",["install"],{cwd:e,stdio:"ignore",shell:!0}).on("close",a=>a===0?t():o(new Error(`pnpm install fall\xF3 con c\xF3digo ${a}`)))}),Ue=async(e,t)=>{let o;!!(e&&t.type)?(xo.includes(t.type)||(console.error(E.red(`Error: la arquitectura "${t.type}" no es v\xE1lida. Usa "feature" o "layer".`)),process.exit(1)),t.world&&!bo.includes(t.world)&&(console.error(E.red(`Error: el mundo "${t.world}" no es v\xE1lido. Usa "cliente", "crm" o "mixto".`)),process.exit(1)),t.world||console.warn(E.yellow('Aviso: sin --world; se asume "mixto". ')+E.dim("Pasa --world cliente|crm para fijar densidad y voz desde el inicio.")),o={projectName:e,architecture:t.type,world:t.world??"mixto"},console.log(E.blue("Modo automatizado detectado. Saltando interfaz interactiva..."))):o=await ze(e),go(`Nombre: ${o.projectName}
 Arquitectura: ${o.architecture}
-Mundo: ${o.world}`,"Configuraci\xF3n de Proyecto");let r=yt();r.start("Construyendo tu proyecto...");let s=process.cwd();try{await ve(o,s)}catch(i){throw r.stop(v.red("No se pudo crear el proyecto.")),i}t.install!==!1&&(r.message("Instalando dependencias base..."),await wt(s)),r.stop("\xA1Proyecto construido con \xE9xito!"),gt(v.green(`Todo listo en el directorio actual
-
-`)+v.dim(`Siguientes pasos:
-`)+v.cyan(`  pnpm dev
-`)+v.cyan("  npx create-lexy add button"))};import bt from"fs/promises";import vt from"path";import F from"picocolors";import ee from"picocolors";var q=(e,t)=>{let o=e.split(`
-`),n=t.split(`
-`),r=o.length,s=n.length,i=Array.from({length:r+1},()=>new Array(s+1).fill(0));for(let m=r-1;m>=0;m--)for(let g=s-1;g>=0;g--)i[m][g]=o[m]===n[g]?i[m+1][g+1]+1:Math.max(i[m+1][g],i[m][g+1]);let p=[],c=0,d=0;for(;c<r&&d<s;)o[c]===n[d]?(p.push({type:"same",text:o[c]}),c++,d++):i[c+1][d]>=i[c][d+1]?p.push({type:"del",text:o[c++]}):p.push({type:"add",text:n[d++]});for(;c<r;)p.push({type:"del",text:o[c++]});for(;d<s;)p.push({type:"add",text:n[d++]});return p},G=e=>e.some(t=>t.type!=="same"),Ce=(e,t=3)=>{if(!G(e))return null;let o=new Array(e.length).fill(!1);e.forEach((s,i)=>{if(s.type!=="same")for(let p=Math.max(0,i-t);p<=Math.min(e.length-1,i+t);p++)o[p]=!0});let n=[],r=!1;for(let s=0;s<e.length;s++){if(!o[s]){r||(n.push(ee.dim("  \u22EF")),r=!0);continue}r=!1;let i=e[s];i.type==="same"?n.push(`  ${i.text}`):i.type==="del"?n.push(ee.red(`- ${i.text}`)):n.push(ee.green(`+ ${i.text}`))}return n.join(`
-`)};var Pe=async e=>{let t=process.cwd(),o=await k(t),n=e.toLowerCase(),{item:r,version:s}=await x(n),i=o.installed[n];console.log(F.bold(`
-${r.title??n}`)+F.dim(` \xB7 instalado con registry@${i??"?"} \xB7 vigente registry@${s}
-`));let p=!1;for(let c of P(r,o)){let d=await bt.readFile(vt.join(t,c.relPath),"utf-8").catch(()=>null);if(d===null){console.log(F.red(`\u2717 ${c.relPath} no existe localmente`)+F.dim(` \u2014 cr\xE9alo con \`create-lexy add ${n}\``)),p=!0;continue}let m=Ce(q(d,c.content));m===null?console.log(F.green(`\u2713 ${c.relPath}`)+F.dim(" sin diferencias")):(p=!0,console.log(F.yellow(`\xB1 ${c.relPath}`)+F.dim(" (\u2212 local \xB7 + registry)")),console.log(m))}p&&(process.exitCode=1)};import A from"fs/promises";import S from"path";import j from"picocolors";var $e=async e=>{let t=process.cwd(),o=0,n=u=>console.log(j.green("  \u2713 ")+u),r=u=>console.log(j.yellow("  \u2022 ")+u),s=(u,a)=>{o=1,console.log(j.red("  \u2717 ")+u),a&&console.log(j.dim(`      \u2192 ${a}`))};console.log(j.bold(`
+Mundo: ${o.world}`,"Configuraci\xF3n de Proyecto");let a=So();a.start("Construyendo tu proyecto...");let i=process.cwd();try{await qe(o,i)}catch(n){throw a.stop(E.red("No se pudo crear el proyecto.")),n}t.install!==!1&&(a.message("Instalando dependencias base..."),await Io(i)),a.stop("\xA1Proyecto construido con \xE9xito!"),vo(E.green(`Todo listo en el directorio actual
+
+`)+E.dim(`Siguientes pasos:
+`)+E.cyan(`  pnpm dev
+`)+E.cyan("  npx create-lexy add button"))};import Eo from"fs/promises";import ko from"path";import z from"picocolors";import pe from"picocolors";var H=(e,t)=>{let o=e.split(`
+`),r=t.split(`
+`),a=o.length,i=r.length,n=Array.from({length:a+1},()=>new Array(i+1).fill(0));for(let u=a-1;u>=0;u--)for(let d=i-1;d>=0;d--)n[u][d]=o[u]===r[d]?n[u+1][d+1]+1:Math.max(n[u+1][d],n[u][d+1]);let p=[],l=0,y=0;for(;l<a&&y<i;)o[l]===r[y]?(p.push({type:"same",text:o[l]}),l++,y++):n[l+1][y]>=n[l][y+1]?p.push({type:"del",text:o[l++]}):p.push({type:"add",text:r[y++]});for(;l<a;)p.push({type:"del",text:o[l++]});for(;y<i;)p.push({type:"add",text:r[y++]});return p},X=e=>e.some(t=>t.type!=="same"),Be=(e,t=3)=>{if(!X(e))return null;let o=new Array(e.length).fill(!1);e.forEach((i,n)=>{if(i.type!=="same")for(let p=Math.max(0,n-t);p<=Math.min(e.length-1,n+t);p++)o[p]=!0});let r=[],a=!1;for(let i=0;i<e.length;i++){if(!o[i]){a||(r.push(pe.dim("  \u22EF")),a=!0);continue}a=!1;let n=e[i];n.type==="same"?r.push(`  ${n.text}`):n.type==="del"?r.push(pe.red(`- ${n.text}`)):r.push(pe.green(`+ ${n.text}`))}return r.join(`
+`)};var Je=async e=>{let t=process.cwd(),o=await L(t),r=e.toLowerCase(),{item:a,version:i}=await x(r),n=o.installed[r];console.log(z.bold(`
+${a.title??r}`)+z.dim(` \xB7 instalado con registry@${n??"?"} \xB7 vigente registry@${i}
+`));let p=!1;for(let l of C(a,o)){let y=await Eo.readFile(ko.join(t,l.relPath),"utf-8").catch(()=>null);if(y===null){console.log(z.red(`\u2717 ${l.relPath} no existe localmente`)+z.dim(` \u2014 cr\xE9alo con \`create-lexy add ${r}\``)),p=!0;continue}let u=Be(H(y,l.content));u===null?console.log(z.green(`\u2713 ${l.relPath}`)+z.dim(" sin diferencias")):(p=!0,console.log(z.yellow(`\xB1 ${l.relPath}`)+z.dim(" (\u2212 local \xB7 + registry)")),console.log(u))}p&&(process.exitCode=1)};import A from"fs/promises";import f from"path";import k from"picocolors";var Ge=async e=>{let t=process.cwd(),o=0,r=s=>console.log(k.green("  \u2713 ")+s),a=s=>console.log(k.yellow("  \u2022 ")+s),i=(s,c)=>{o=1,console.log(k.red("  \u2717 ")+s),c&&console.log(k.dim(`      \u2192 ${c}`))};console.log(k.bold(`
 Diagn\xF3stico del proyecto Lexy
-`));let i;try{i=await k(t),n(`.lexy v\xE1lido (arquitectura ${i.architecture}${i.world?`, mundo ${i.world}`:""})`)}catch(u){return s(u.message),1}await A.access(S.join(t,"src/lexy-theme.css")).then(()=>!0,()=>!1)?n("theme presente (src/lexy-theme.css)"):s("falta src/lexy-theme.css","re-cr\xE9alo desde un proyecto nuevo o copia el theme del registry");let c=S.join(i.paths.lib,"utils/cn.ts");await A.access(S.join(t,c)).then(()=>!0,()=>!1)?n(`helper cn presente (${c})`):s(`falta el helper cn (${c})`);let m=S.join(t,"ai/lexy-ai-manifest.json"),g=await A.readFile(m,"utf-8").catch(()=>null);if(g===null)console.log(j.dim("  \xB7 capa de IA no instalada (npx @lexydesign/ai install) \u2014 opcional"));else try{let u=JSON.parse(g),a=u.files??[],l=[];for(let f of a)await A.access(S.join(t,f)).then(()=>!0,()=>!1)||l.push(f);l.length>0?s(`capa de IA ${u.aiVersion??"?"} incompleta \u2014 faltan ${l.length} archivo(s) (${l.slice(0,3).join(", ")}${l.length>3?", \u2026":""})`,"npx @lexydesign/ai install"):n(`capa de IA ${u.aiVersion??"?"} completa (${a.length} archivos)`)}catch{s("ai/lexy-ai-manifest.json no es JSON v\xE1lido","regenera con `npx @lexydesign/ai install`")}let z=Object.entries(i.installed);if(z.length===0)console.log(j.dim(`
-  Sin componentes instalados a\xFAn (create-lexy add <nombre>).`));else{let u=await J();console.log(j.bold(`
-Componentes instalados (registry vigente: ${u})
-`));for(let[a,l]of z){let f;try{f=await x(a)}catch(y){s(`${a}: ${y.message}`);continue}let b=P(f.item,i),L=[],V=!1;for(let y of b){let C=await A.readFile(S.join(t,y.relPath),"utf-8").catch(()=>null);C===null?L.push(y.relPath):G(q(C,y.content))&&(V=!0)}if(L.length>0){s(`${a}: archivos faltantes (${L.join(", ")})`,`create-lexy add ${a}`);continue}if(!V){n(`${a} al d\xEDa (${f.version})`);continue}let D=!0;if(l&&l!==f.version)try{let y=await x(a,l),C=P(y.item,i);D=!1;for(let ne of C){let se=await A.readFile(S.join(t,ne.relPath),"utf-8").catch(()=>null);(se===null||G(q(se,ne.content)))&&(D=!0)}}catch{}D?e.strict?s(`${a}: editado localmente (difiere del registry vigente)`,`create-lexy diff ${a}`):r(`${a}: editado localmente \u2014 divergencia deliberada (m\xEDrala con \`create-lexy diff ${a}\`)`):s(`${a}: desactualizado (instalado con ${l}, vigente ${f.version})`,`create-lexy diff ${a} \xB7 create-lexy add ${a} --overwrite`)}}return console.log(o===0?j.green(`
+`));let n;try{n=await L(t),r(`.lexy v\xE1lido (arquitectura ${n.architecture}${n.world?`, mundo ${n.world}`:""})`)}catch(s){return i(s.message),1}await A.access(f.join(t,"src/lexy-theme.css")).then(()=>!0,()=>!1)?r("theme presente (src/lexy-theme.css)"):i("falta src/lexy-theme.css","re-cr\xE9alo desde un proyecto nuevo o copia el theme del registry");let l=f.join(n.paths.lib,"utils/cn.ts");await A.access(f.join(t,l)).then(()=>!0,()=>!1)?r(`helper cn presente (${l})`):i(`falta el helper cn (${l})`);let u=await A.readFile(f.join(t,"package.json"),"utf-8").then(s=>JSON.parse(s)).catch(()=>null),d=async(s,c)=>{await A.access(f.join(t,s)).then(()=>!0,()=>!1)?r(`${c} presente (${s})`):i(`falta ${c} (${s})`)},P=(s,c)=>{if(!u){i("package.json no se pudo leer para validar scripts del prototipo");return}let g=u.scripts?.[s];if(!g){i(`falta el script ${s} en package.json`,c?`agrega \`${c}\``:void 0);return}if(c&&!g.includes(c)){i(`el script ${s} no ejecuta ${c}`);return}r(`script ${s} configurado`)};if(!n.prototype)a("prototipo funcional no habilitado \u2014 proyecto anterior a las specs de datos/eventos/simulador");else{let s=n.prototype.dataContractPath;if(!s)a("contrato de datos no configurado \u2014 proyecto anterior a la Spec 1");else{await d(s,"contrato de datos");let c=f.join(f.dirname(s),"data-contract-schema.ts");await d(c,"schema del contrato"),await d("scripts/check-data-contract.ts","validador del contrato"),P("check:data-contract","tsx scripts/check-data-contract.ts")}n.prototype.eventEngineVersion?(n.prototype.eventEngineContractPath?(await d(n.prototype.eventEngineContractPath,"contrato del motor de eventos"),await d(f.join(f.dirname(n.prototype.eventEngineContractPath),"event-engine-contract-schema.ts"),"schema del motor de eventos"),await d(f.join(f.dirname(n.prototype.eventEngineContractPath),"payload-schema.ts"),"schemas runtime del motor de eventos")):i("eventEngineContractPath no est\xE1 configurado en .lexy"),n.prototype.eventEnginePath?await d(n.prototype.eventEnginePath,"engine de eventos"):i("eventEnginePath no est\xE1 configurado en .lexy"),await d("scripts/check-event-engine.ts","validador del motor de eventos"),P("check:event-engine","tsx scripts/check-event-engine.ts")):a("motor de eventos no habilitado \u2014 proyecto anterior a la Spec 2"),n.prototype.simulatorVersion?(n.prototype.simulatorProfilePath?(await d(n.prototype.simulatorProfilePath,"perfil del simulador"),await d(f.join(f.dirname(n.prototype.simulatorProfilePath),"simulator-contract-schema.ts"),"schema del simulador"),await d(f.join(f.dirname(n.prototype.simulatorProfilePath),"projection-resolvers.ts"),"resolvers de proyecci\xF3n del simulador"),await d(f.join(f.dirname(n.prototype.simulatorProfilePath),"data-load-handlers.ts"),"handlers de carga del simulador"),await d(f.join(f.dirname(n.prototype.simulatorProfilePath),"event-handlers.ts"),"handlers de evento del simulador"),await d(f.join(f.dirname(n.prototype.simulatorProfilePath),"mock-store.ts"),"store persistente del simulador"),await d(f.join(f.dirname(n.prototype.simulatorProfilePath),"mock-backend-executor.ts"),"executor mock del simulador")):i("simulatorProfilePath no est\xE1 configurado en .lexy"),n.prototype.simulatorScenariosPath?await d(n.prototype.simulatorScenariosPath,"escenarios del simulador"):i("simulatorScenariosPath no est\xE1 configurado en .lexy"),n.prototype.simulatorPath?await d(n.prototype.simulatorPath,"ensamblaje del simulador"):i("simulatorPath no est\xE1 configurado en .lexy"),await d("scripts/check-simulator.ts","validador del simulador"),P("check:simulator","tsx scripts/check-simulator.ts"),P("check:prototype","check:simulator")):a("simulador persistente no habilitado \u2014 proyecto anterior a la Spec 3")}let V=f.join(t,"ai/lexy-ai-manifest.json"),m=await A.readFile(V,"utf-8").catch(()=>null);if(m===null)console.log(k.dim("  \xB7 capa de IA no instalada (npx @lexydesign/ai install) \u2014 opcional"));else try{let s=JSON.parse(m),c=s.files??[],g=[];for(let I of c)await A.access(f.join(t,I)).then(()=>!0,()=>!1)||g.push(I);g.length>0?i(`capa de IA ${s.aiVersion??"?"} incompleta \u2014 faltan ${g.length} archivo(s) (${g.slice(0,3).join(", ")}${g.length>3?", \u2026":""})`,"npx @lexydesign/ai install"):r(`capa de IA ${s.aiVersion??"?"} completa (${c.length} archivos)`)}catch{i("ai/lexy-ai-manifest.json no es JSON v\xE1lido","regenera con `npx @lexydesign/ai install`")}let h=Object.entries(n.installed);if(h.length===0)console.log(k.dim(`
+  Sin componentes instalados a\xFAn (create-lexy add <nombre>).`));else{let s=await G();console.log(k.bold(`
+Componentes instalados (registry vigente: ${s})
+`));for(let[c,g]of h){let I;try{I=await x(c)}catch(D){i(`${c}: ${D.message}`);continue}let q=C(I.item,n),v=[],O=!1;for(let D of q){let U=await A.readFile(f.join(t,D.relPath),"utf-8").catch(()=>null);U===null?v.push(D.relPath):X(H(U,D.content))&&(O=!0)}if(v.length>0){i(`${c}: archivos faltantes (${v.join(", ")})`,`create-lexy add ${c}`);continue}if(!O){r(`${c} al d\xEDa (${I.version})`);continue}let ee=!0;if(g&&g!==I.version)try{let D=await x(c,g),U=C(D.item,n);ee=!1;for(let ve of U){let Se=await A.readFile(f.join(t,ve.relPath),"utf-8").catch(()=>null);(Se===null||X(H(Se,ve.content)))&&(ee=!0)}}catch{}ee?e.strict?i(`${c}: editado localmente (difiere del registry vigente)`,`create-lexy diff ${c}`):a(`${c}: editado localmente \u2014 divergencia deliberada (m\xEDrala con \`create-lexy diff ${c}\`)`):i(`${c}: desactualizado (instalado con ${g}, vigente ${I.version})`,`create-lexy diff ${c} \xB7 create-lexy add ${c} --overwrite`)}}return console.log(o===0?k.green(`
 Todo en orden.
-`):j.red(`
+`):k.red(`
 Hay problemas que atender (exit 1).
-`)),o};import te from"fs/promises";import Ee from"path";import{note as jt,outro as Ct}from"@clack/prompts";import oe from"picocolors";var W="LEXY-KICKOFF.md",Pt=`# Kickoff de proyecto Lexy \u2014 protocolo de entrevista
+`)),o};import me from"fs/promises";import Ze from"path";import{note as wo,outro as Po}from"@clack/prompts";import ue from"picocolors";var Y="LEXY-KICKOFF.md",Co=`# Kickoff de proyecto Lexy \u2014 protocolo de entrevista
 
 > **Para el agente (Claude Code):** este archivo es tu guion. La persona que
 > tienes enfrente es **dise\xF1adora, no programadora**: no le preguntes por
@@ -291,8 +2685,20 @@ hazlas de a poco, repregunta y resume lo que entendiste. Cubre:
   dashboard, listados, vistas de detalle)?
 - **Pantallas y flujos clave** \u2014 \xBFqu\xE9 vistas importan y qu\xE9 hace la persona en
   cada una? \xBFC\xF3mo se mueve entre ellas?
-- **Datos y referencias** \u2014 \xBFqu\xE9 datos maneja? \xBFHay un Figma, capturas o un
-  producto de referencia que mande sobre composiciones gen\xE9ricas?
+- **Datos de la experiencia** \u2014 \xBFqu\xE9 objetos principales existen? \xBFQu\xE9 necesita
+  ver o modificar la persona? \xBFQu\xE9 relaciones necesita entender? \xBFQu\xE9 estados
+  cambian lo que aparece en pantalla? \xBFQu\xE9 supuestos todav\xEDa debe validar TI?
+- **Cargas de datos** \u2014 \xBFqu\xE9 informaci\xF3n debe llegar desde backend para cada
+  pantalla? \xBFQu\xE9 significa que una carga venga vac\xEDa? \xBFQu\xE9 errores o latencias
+  vale la pena poder probar?
+- **Eventos publicados** \u2014 \xBFqu\xE9 escrituras hace la interfaz? \xBFQu\xE9 hecho ocurri\xF3
+  cuando se publican? \xBFQu\xE9 entidad cambia visualmente despu\xE9s de ver "Evento
+  publicado"? \xBFQu\xE9 debe mantenerse intacto si falla?
+- **Datos mock y escenarios** \u2014 \xBFqu\xE9 situaciones reales debe representar el
+  prototipo? \xBFQu\xE9 casos l\xEDmite importan? \xBFQu\xE9 datos deben verse chilenos? \xBFQu\xE9
+  campos son sensibles aunque sean sint\xE9ticos?
+- **Referencias** \u2014 \xBFhay un Figma, capturas o un producto de referencia que
+  mande sobre composiciones gen\xE9ricas?
 
 ## 2. Traducir las respuestas a flags (no se lo muestres a la persona)
 
@@ -318,22 +2724,43 @@ npx @lexydesign/ai install
 
 ## 4. Volcar la entrevista en el brief vivo
 
-Abre \`ai/PROJECT-CONTEXT.md\` (lo cre\xF3 \`@lexydesign/ai install\`) y compl\xE9talo
-con lo que recopilaste: **qu\xE9 se construye**, **para qui\xE9n**, **pantallas y
-flujos clave**, **referencias** y **decisiones/restricciones** ya tomadas. Ese
-archivo es el plan inicial del proyecto y la memoria de las pr\xF3ximas sesiones.
+1. Abre \`ai/PROJECT-CONTEXT.md\` (lo cre\xF3 \`@lexydesign/ai install\`) y
+   compl\xE9talo con lo que recopilaste: **qu\xE9 se construye**, **para qui\xE9n**,
+   **pantallas y flujos clave**, un resumen de **datos principales**,
+   **referencias** y **decisiones/restricciones** ya tomadas.
+2. Traduce los objetos, datos, relaciones, estados y supuestos conversados a
+   \`src/prototype/data-contract/prototype-data-contract.ts\`. No inventes
+   backend: lo que nazca desde usabilidad queda como
+   \`origin: "generatedByUsability"\` y
+   \`technicalValidation.status: "pendingTi"\`.
+3. Declara las comunicaciones externas en
+   \`src/prototype/event-engine/prototype-event-engine-contract.ts\`: lecturas
+   remotas como **cargas de datos** y escrituras como **eventos publicados**.
+   No declares interacciones locales.
+4. Completa \`src/prototype/simulator/\` con perfil, escenarios, resolvers y
+   handlers m\xEDnimos. Usa datos sint\xE9ticos, deterministas y formato chileno.
+5. Ejecuta \`pnpm check:prototype\` y corrige cualquier inconsistencia antes de
+   empezar a implementar pantallas.
+
+\`PROJECT-CONTEXT.md\` es el resumen humano. El contrato TypeScript es la fuente
+estructurada de datos para las pr\xF3ximas sesiones. El motor explica qu\xE9 se carga
+o publica y el simulador entrega datos mock persistentes sin backend real.
 
 ## 5. Cerrar
 
-Borra este archivo (\`${W}\`): su trabajo termin\xF3. Conf\xEDrmale a la
+Borra este archivo (\`${Y}\`): su trabajo termin\xF3. Conf\xEDrmale a la
 persona que su proyecto est\xE1 listo y prop\xF3n el primer paso concreto
 (p. ej. "\xBFDise\xF1amos la pantalla de inicio?").
-`,Ie=async e=>{let t=process.cwd();for(let r of["package.json",".lexy"])if(await te.access(Ee.join(t,r)).then(()=>!0,()=>!1))throw new Error(`El directorio actual ya contiene un proyecto (${r}). \`kickoff\` es para empezar de cero en una carpeta vac\xEDa.`);let o=Ee.join(t,W);if(await te.access(o).then(()=>!0,()=>!1)&&!e.force)throw new Error(`${W} ya existe. Usa --force para regenerarlo.`);await te.writeFile(o,Pt),jt(`Se cre\xF3 ${oe.cyan(W)} en esta carpeta.
+`,We=async e=>{let t=process.cwd();for(let a of["package.json",".lexy"])if(await me.access(Ze.join(t,a)).then(()=>!0,()=>!1))throw new Error(`El directorio actual ya contiene un proyecto (${a}). \`kickoff\` es para empezar de cero en una carpeta vac\xEDa.`);let o=Ze.join(t,Y);if(await me.access(o).then(()=>!0,()=>!1)&&!e.force)throw new Error(`${Y} ya existe. Usa --force para regenerarlo.`);await me.writeFile(o,Co),wo(`Se cre\xF3 ${ue.cyan(Y)} en esta carpeta.
 
-Abre la carpeta con Claude Code y di: `+oe.bold("\xABay\xFAdame a arrancar mi proyecto Lexy\xBB")+`.
-El agente te entrevistar\xE1 y montar\xE1 el proyecto por ti.`,"Kickoff listo"),Ct(oe.green("Sin flags, sin prompts t\xE9cnicos \u2014 solo conversa con el agente."))};import $t from"fs/promises";import re from"path";import w from"picocolors";var _=e=>console.log(w.bold(w.cyan(`
+Abre la carpeta con Claude Code y di: `+ue.bold("\xABay\xFAdame a arrancar mi proyecto Lexy\xBB")+`.
+El agente te entrevistar\xE1 y montar\xE1 el proyecto por ti.`,"Kickoff listo"),Po(ue.green("Sin flags, sin prompts t\xE9cnicos \u2014 solo conversa con el agente."))};import fe from"fs/promises";import Q from"path";import w from"picocolors";var he="@lexydesign/kit",Xe=`https://cdn.jsdelivr.net/npm/${he}`,Ye=8e3,ye=async e=>{let t=await fetch(e,{signal:AbortSignal.timeout(Ye)});if(!t.ok){let o=new Error(`HTTP ${t.status} al pedir ${e}`);throw o.status=t.status,o}return Buffer.from(await t.arrayBuffer())},jo=async()=>{try{let t=await fetch(`https://registry.npmjs.org/${he}/latest`,{signal:AbortSignal.timeout(Ye)});if(t.ok)return(await t.json()).version}catch{}return JSON.parse((await ye(`${Xe}@latest/package.json`)).toString("utf-8")).version},Qe=async e=>{let t=process.cwd(),o=Q.resolve(t,e.dir??"lexy-kit"),r=Q.relative(t,o)||".";if(await fe.access(o).then(()=>!0).catch(()=>!1)&&!e.force)throw new Error(`Ya existe ${w.bold(r)}. Usa ${w.cyan("--force")} para sobrescribir o ${w.cyan("--dir <ruta>")} para otra carpeta.`);let i=await jo();console.log(w.dim(`
+Trayendo ${he}@${i} \u2192 ${r}/
+`));let n=`${Xe}@${i}/kit`,p=JSON.parse((await ye(`${n}/manifest.json`)).toString("utf-8")),l=["index.html","kit.css","kit.js","manifest.json","README.md","AGENTS.md","llms.txt","llms-full.txt","fonts/noto-sans-latin.woff2","fonts/OFL-NotoSans.txt",...p.guides?.pautas??[],...p.components.map(u=>u.file),...p.blocks.map(u=>u.file)],y=0;for(let u of l)try{let d=await ye(`${n}/${u}`),P=Q.join(o,u);await fe.mkdir(Q.dirname(P),{recursive:!0}),await fe.writeFile(P,d),y+=1}catch(d){console.warn(w.yellow(`\u26A0 no se pudo traer ${u}`)+w.dim(` (${d.message})`))}console.log(w.green("\u2713 Kit listo")+w.dim(` \u2014 ${y} archivo(s), ${p.components.length} componente(s) + ${p.blocks.length} block(s)
+`)),console.log(`  Abre ${w.bold(`${r}/index.html`)} en el navegador.`),console.log(w.dim(`  El cat\xE1logo m\xE1quina-legible est\xE1 en ${r}/manifest.json.
+`))};import Ro from"fs/promises";import ge from"path";import b from"picocolors";var K=e=>console.log(b.bold(b.cyan(`
 \u2500\u2500 ${e} \u2500\u2500
-`))),Le=async(e,t)=>{if(t.list||!e){let{index:i,version:p,source:c}=await de();_(`Cat\xE1logo Lexy \xB7 @lexydesign/registry@${p}${c==="bundle"?" (bundle local)":""}`);for(let d of i.items)console.log(`  ${w.bold(d.name.padEnd(20))} ${w.dim(d.description??"")}`);console.log(w.dim(`
-  ${i.items.length} componente(s). Instala con: create-lexy add <nombre>`));return}let o=e.toLowerCase();if(t.installed){let i=process.cwd(),p=await k(i),c=p.installed[o];if(!c){console.error(w.red(`"${o}" no figura como instalado en .lexy. Inst\xE1lalo con \`create-lexy add ${o}\`.`)),process.exitCode=1;return}let{item:d}=await x(o,c).catch(()=>x(o));_(`${d.title??o} \xB7 copia local (instalado con registry@${c})`);for(let m of P(d,p)){let g=await $t.readFile(re.join(i,m.relPath),"utf-8").catch(()=>null);_(g===null?`${m.relPath} (FALTANTE)`:m.relPath),g!==null&&console.log(g)}return}let{item:n,version:r,source:s}=await x(o);_(`${n.title??n.name} \xB7 @lexydesign/registry@${r}${s==="bundle"?" (bundle local)":""}`),n.description&&console.log(n.description+`
-`),console.log(w.dim("tipo:           ")+n.type),console.log(w.dim("deps npm:       ")+((n.dependencies??[]).join(", ")||"\u2014")),console.log(w.dim("deps registry:  ")+((n.registryDependencies??[]).join(", ")||"\u2014")),console.log(w.dim("archivos:       ")+n.files.map(i=>re.posix.basename(i.path)).join(", ")),console.log(w.dim("instalar:       ")+`create-lexy add ${n.name}`);for(let i of n.files)typeof i.content=="string"&&(_(re.posix.basename(i.path)),console.log(i.content))};var Ft=ke.dirname(It(import.meta.url)),Tt=JSON.parse(Et(ke.join(Ft,"../package.json"),"utf-8")),T=new Lt,N=e=>async()=>{try{await e()}catch(t){console.error(kt.red(`
-Error: `)+t.message),process.exit(1)}};T.name("create-lexy").description("CLI del Lexy Design System: crea proyectos y trae componentes a demanda.\nLos componentes viven en tu proyecto \u2014 m\xEDralos con `view`, inst\xE1lalos con `add`, ed\xEDtalos con libertad.").version(Tt.version);T.command("create",{isDefault:!0}).alias("init").description("Crea un proyecto Lexy vac\xEDo (React + Vite + TS + theme); los componentes llegan con `add`").argument("[project-name]","Nombre del proyecto").option("-t, --type <architecture>","Arquitectura (feature o layer) \u2014 activa el modo no interactivo").option("-w, --world <world>","Mundo de dise\xF1o (cliente, crm o mixto)").option("--no-install","No correr pnpm install al final").action((e,t)=>N(()=>je(e,t))());T.command("kickoff").description("Deja un .md de entrevista para que el agente conduzca el arranque de un dise\xF1ador (carpeta vac\xEDa)").option("--force","Regenerar el .md de kickoff si ya existe").action(e=>N(()=>Ie(e))());T.command("add").description("Instala componentes del registry en tu proyecto (local y editable), con sus dependencias").argument("<components...>","Nombres en el registry (ej: button card)").option("--overwrite","Sobrescribir copias locales con cambios sin preguntar").option("--no-install","No instalar dependencias npm").action((e,t)=>N(()=>ge(e,t))());T.command("view").description("Muestra c\xF3digo + doc + metadata de un componente antes de instalarlo").argument("[component]","Nombre en el registry (sin nombre: lista el cat\xE1logo)").option("--installed","Mostrar la copia local instalada en vez de la del registry").option("--list","Listar el cat\xE1logo completo").action((e,t)=>N(()=>Le(e,t))());T.command("diff").description("Copia local vs versi\xF3n vigente del registry (exit 1 si hay diferencias)").argument("<component>","Nombre en el registry").action(e=>N(()=>Pe(e))());T.command("doctor").description("Drift de todo lo instalado contra el registry (solo lectura; exit 1 con problemas)").option("--strict","Las ediciones locales tambi\xE9n hacen fallar").action(e=>N(async()=>{process.exitCode=await $e(e)})());T.parse(process.argv);
+`))),et=async(e,t)=>{if(t.list||!e){let{index:n,version:p,source:l}=await we();K(`Cat\xE1logo Lexy \xB7 @lexydesign/registry@${p}${l==="bundle"?" (bundle local)":""}`);for(let y of n.items)console.log(`  ${b.bold(y.name.padEnd(20))} ${b.dim(y.description??"")}`);console.log(b.dim(`
+  ${n.items.length} componente(s). Instala con: create-lexy add <nombre>`));return}let o=e.toLowerCase();if(t.installed){let n=process.cwd(),p=await L(n),l=p.installed[o];if(!l){console.error(b.red(`"${o}" no figura como instalado en .lexy. Inst\xE1lalo con \`create-lexy add ${o}\`.`)),process.exitCode=1;return}let{item:y}=await x(o,l).catch(()=>x(o));K(`${y.title??o} \xB7 copia local (instalado con registry@${l})`);for(let u of C(y,p)){let d=await Ro.readFile(ge.join(n,u.relPath),"utf-8").catch(()=>null);K(d===null?`${u.relPath} (FALTANTE)`:u.relPath),d!==null&&console.log(d)}return}let{item:r,version:a,source:i}=await x(o);K(`${r.title??r.name} \xB7 @lexydesign/registry@${a}${i==="bundle"?" (bundle local)":""}`),r.description&&console.log(r.description+`
+`),console.log(b.dim("tipo:           ")+r.type),console.log(b.dim("deps npm:       ")+((r.dependencies??[]).join(", ")||"\u2014")),console.log(b.dim("deps registry:  ")+((r.registryDependencies??[]).join(", ")||"\u2014")),console.log(b.dim("archivos:       ")+r.files.map(n=>ge.posix.basename(n.path)).join(", ")),console.log(b.dim("instalar:       ")+`create-lexy add ${r.name}`);for(let n of r.files)typeof n.content=="string"&&(K(ge.posix.basename(n.path)),console.log(n.content))};var Ao=tt.dirname(Mo(import.meta.url)),Oo=JSON.parse(To(tt.join(Ao,"../package.json"),"utf-8")),M=new Lo,$=e=>async()=>{try{await e()}catch(t){console.error(zo.red(`
+Error: `)+t.message),process.exit(1)}};M.name("create-lexy").description("CLI del Lexy Design System: crea proyectos y trae componentes a demanda.\nLos componentes viven en tu proyecto \u2014 m\xEDralos con `view`, inst\xE1lalos con `add`, ed\xEDtalos con libertad.").version(Oo.version);M.command("create",{isDefault:!0}).alias("init").description("Crea un proyecto Lexy vac\xEDo (React + Vite + TS + theme); los componentes llegan con `add`").argument("[project-name]","Nombre del proyecto").option("-t, --type <architecture>","Arquitectura (feature o layer) \u2014 activa el modo no interactivo").option("-w, --world <world>","Mundo de dise\xF1o (cliente, crm o mixto)").option("--no-install","No correr pnpm install al final").action((e,t)=>$(()=>Ue(e,t))());M.command("kickoff").description("Deja un .md de entrevista para que el agente conduzca el arranque de un dise\xF1ador (carpeta vac\xEDa)").option("--force","Regenerar el .md de kickoff si ya existe").action(e=>$(()=>We(e))());M.command("add").description("Instala componentes del registry en tu proyecto (local y editable), con sus dependencias").argument("<components...>","Nombres en el registry (ej: button card)").option("--overwrite","Sobrescribir copias locales con cambios sin preguntar").option("--no-install","No instalar dependencias npm").action((e,t)=>$(()=>Re(e,t))());M.command("view").description("Muestra c\xF3digo + doc + metadata de un componente antes de instalarlo").argument("[component]","Nombre en el registry (sin nombre: lista el cat\xE1logo)").option("--installed","Mostrar la copia local instalada en vez de la del registry").option("--list","Listar el cat\xE1logo completo").action((e,t)=>$(()=>et(e,t))());M.command("kit").description("Trae el kit HTML/low-fi (mismos componentes y blocks en HTML plano) a una carpeta").option("--dir <path>","Carpeta destino (por defecto: lexy-kit)").option("--force","Sobrescribir la carpeta si ya existe").action(e=>$(()=>Qe(e))());M.command("diff").description("Copia local vs versi\xF3n vigente del registry (exit 1 si hay diferencias)").argument("<component>","Nombre en el registry").action(e=>$(()=>Je(e))());M.command("doctor").description("Drift de todo lo instalado contra el registry (solo lectura; exit 1 con problemas)").option("--strict","Las ediciones locales tambi\xE9n hacen fallar").action(e=>$(async()=>{process.exitCode=await Ge(e)})());M.parse(process.argv);