create-lexy 0.6.0 → 0.6.1

package/dist/index.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-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=`
+import{readFileSync as Po}from"fs";import tt from"path";import{fileURLToPath as jo}from"url";import{Command as Co}from"commander";import Io from"picocolors";import{spawn as ct}from"child_process";import Q from"fs/promises";import G from"path";import{confirm as dt,isCancel as pt,spinner as Te}from"@clack/prompts";import h 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/'),at=[["components/base/",e=>e.paths.components],["views/",e=>e.paths.views],["hooks/",e=>e.paths.hooks],["lib/",e=>e.paths.lib]],T=(e,t)=>e.files.filter(o=>typeof o.content=="string").map(o=>{let a=at.find(([r])=>o.path.startsWith(r)),n=a?te.posix.join(a[1](t),o.path.slice(a[0].length)):te.posix.join(t.paths.components,te.posix.basename(o.path));return o.encoding==="base64"?{relPath:n,content:o.content,encoding:"base64"}:{relPath:n,content:ot(o.content,t)}});import we from"fs/promises";import nt from"path";var Se=e=>nt.join(e,".lexy"),O=async e=>{let t;try{t=await we.readFile(Se(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},ke=async(e,t)=>{await we.writeFile(Se(e),JSON.stringify(t,null,2)+`
+`)};import q from"fs/promises";import rt from"os";import R from"path";import{fileURLToPath as it}from"url";var Ee="@lexydesign/registry",F=`https://cdn.jsdelivr.net/npm/${Ee}`,st=8e3,J=R.resolve(R.dirname(it(import.meta.url)),"../assets"),lt=R.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()},Pe=async e=>{try{return JSON.parse(await q.readFile(R.join(J,"r",e),"utf-8"))}catch{return null}},oe=async()=>{try{return(await q.readFile(R.join(J,"registry-version"),"utf-8")).trim()}catch{return"bundle"}},$=null,W=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 $},k=async(e,t)=>{let o=e.replace(/^@lexy\//,""),a=t??await W(),n=R.join(lt,a,`${o}.json`);try{return{item:JSON.parse(await q.readFile(n,"utf-8")),version:a,source:"cache"}}catch{}try{let r=await B(`${F}@${a}/r/${o}.json`);return await q.mkdir(R.dirname(n),{recursive:!0}),await q.writeFile(n,JSON.stringify(r)),{item:r,version:a,source:"cdn"}}catch(r){if(r.status===404)throw new Error(`El componente "${o}" no existe en el registry (versi\xF3n ${a}). Mira el cat\xE1logo con \`create-lexy view --list\`.`);let i=await Pe(`${o}.json`);if(i)return{item:i,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.`)}},je=async()=>{try{let e=await W();return{index:await B(`${F}@${e}/r/registry.json`),version:e,source:"cdn"}}catch{let e=await Pe("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.")}},Ce=R.join(J,"theme/lexy-theme.css"),Ie=R.join(J,"fonts");var mt=(e,t)=>new Promise((o,a)=>{ct("pnpm",["add",...e],{cwd:t,stdio:"ignore",shell:!0}).on("close",r=>r===0?o():a(new Error(`pnpm add fall\xF3 con c\xF3digo ${r}`)))}),ut=async(e,t="utf-8")=>{try{return await Q.readFile(e,t)}catch{return null}},Re=async(e,t)=>{let o=process.cwd(),a=await O(o),n=Te();n.start("Resolviendo componentes en el registry...");let r=new Map,i=async p=>{let f=p.toLowerCase().replace(/^@lexy\//,"");if(r.has(f))return;let c=await k(f);r.set(f,c);for(let l of c.item.registryDependencies??[])await i(l)};try{for(let p of e)await i(p)}catch(p){throw n.stop(h.red("No se pudo resolver el pedido.")),p}let d=new Map;for(let[p,{item:f}]of r){let c=[];for(let l of T(f,a)){let g=await ut(G.join(o,l.relPath),l.encoding??"utf-8");c.push({...l,status:g===null?"new":g===l.content?"same":"differs"})}d.set(p,c)}let s=Array.from(d.values()).flat().filter(p=>p.status==="differs");if(n.stop(`Resueltos: ${Array.from(r.keys()).join(", ")}`),s.length>0&&!t.overwrite){let p=s.map(f=>`  ${f.relPath}`).join(`
+`);if(process.stdout.isTTY&&process.stdin.isTTY){let f=await dt({message:`Estos archivos existen con cambios locales y ser\xE1n sobrescritos:
+${p}
+\xBFContinuar?`});if(pt(f)||f!==!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:
+`)+p+h.dim(`
+Usa --overwrite para sobrescribirlos.`)),process.exitCode=1;return}}for(let[p,f]of d){let{item:c,version:l,source:g}=r.get(p);for(let x of f){if(x.status==="same")continue;let A=G.join(o,x.relPath);await Q.mkdir(G.dirname(A),{recursive:!0}),await Q.writeFile(A,x.content,x.encoding??"utf-8")}a.installed[c.name]=l;let P=e.map(x=>x.toLowerCase()).includes(p)?"":h.dim(" (dependencia)"),U=g==="bundle"?h.yellow(" [bundle local \u2014 sin red]"):"";console.log(h.green(`${h.bold(c.title??c.name)} instalado`)+P+h.cyan(` \u2192 ${a.paths.components}/`)+U);for(let x of f){let A=x.status==="same"?h.dim(" (sin cambios)"):"";console.log(h.dim(`   ${x.relPath}${A}`))}}await ke(o,a);let u=new Set;for(let{item:p}of r.values())for(let f of p.dependencies??[])u.add(f);let m=JSON.parse(await Q.readFile(G.join(o,"package.json"),"utf-8")),y={...m.dependencies,...m.devDependencies},z=p=>{let f=p.lastIndexOf("@");return f>0?p.slice(0,f):p},M=Array.from(u).filter(p=>!y[z(p)]);if(M.length>0)if(t.install===!1)console.log(h.yellow(`Dependencias pendientes (inst\xE1lalas t\xFA): ${M.join(", ")}`));else{let p=Te();p.start(`Instalando dependencias: ${M.join(", ")}...`),await mt(M,o),p.stop("Dependencias instaladas.")}};import{spawn as po}from"child_process";import{note as mo,outro as uo,spinner as yo}from"@clack/prompts";import j from"picocolors";import{cancel as yt,intro as ft,isCancel as gt,select as Oe,text as xt}from"@clack/prompts";import _e from"picocolors";var ae=[{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"}],Ne=e=>ae.find(t=>t.value===e).architecture;var vt=`
   ######                  ######
   ##::+####            ####+::##
    #-..:+################+:..:#
@@ -20,8 +20,8 @@ Usa --overwrite para sobrescribirlos.`)),process.exitCode=1;return}}for(let[m,h]
    ...........:====:...........
       ......................
           ..............
-`,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";
+`,ne=e=>{gt(e)&&(yt("Operaci\xF3n cancelada por el usuario."),process.exit(0))},Ae=async e=>{console.clear(),ft(`${_e.cyan(vt)}
+${_e.bold(" Bienvenido al generador de proyectos Lexy")}`);let t=e;if(!t){let n=await xt({message:"\xBFCu\xE1l es el nombre de tu proyecto?",placeholder:"lexy-app",validate:r=>{if(!r||r.trim()==="")return"El nombre es obligatorio.";if(!/^(?:@[a-z0-9-*~][a-z0-9-*._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(r))return"El nombre debe estar en min\xFAsculas, sin espacios ni caracteres especiales."}});ne(n),t=n}let o=await Oe({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"});ne(o);let a=await Oe({message:"\xBFC\xF3mo es lo que vas a construir?",options:ae.map(n=>({label:n.label,value:n.value,hint:n.hint})),initialValue:"app"});return ne(a),{projectName:t,architecture:Ne(a),world:o}};import b from"fs/promises";import w from"path";import{format as qt,resolveConfig as Vt}from"prettier";import Le from"fs/promises";import De from"path";var re="src/prototype/data-contract/prototype-data-contract.ts",ht="src/prototype/data-contract/data-contract-schema.ts",bt="scripts/check-data-contract.ts",wt=String.raw`import { z } from "zod";
 
 const camelCaseIdSchema = z
   .string()
@@ -430,7 +430,7 @@ export function definePrototypeDataContract(
 ): PrototypeDataContract {
   return prototypeDataContractSchema.parse(contract);
 }
-`,It=String.raw`import { ZodError } from "zod";
+`,St=String.raw`import { ZodError } from "zod";
 
 import { prototypeDataContractSchema } from "../src/prototype/data-contract/data-contract-schema";
 
@@ -491,7 +491,7 @@ try {
   }
   process.exitCode = 1;
 }
-`,Et=e=>`import { definePrototypeDataContract } from "./data-contract-schema";
+`,kt=e=>`import { definePrototypeDataContract } from "./data-contract-schema";
 
 /**
  * Fuente de verdad de los datos usados por el prototipo.
@@ -509,1269 +509,1371 @@ export const prototypeDataContract = definePrototypeDataContract({
   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;
+`,ze=async(e,t)=>{let o=async(a,n)=>{let r=De.join(e,a);await Le.mkdir(De.dirname(r),{recursive:!0}),await Le.writeFile(r,n)};await o(ht,wt),await o(re,kt(t)),await o(bt,St)};import Me from"fs/promises";import ie from"path";var se="src/prototype/designer-panel/designer-activity.ts",le="src/prototype/designer-panel/PrototypeDesignerPanel.tsx",Et=String.raw`export type DesignerActivityRecordInput = {
+  kind: "load" | "event";
+  label: string;
+  technicalId?: 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;
+  input?: unknown;
 };
 
-export type PublishedEventResult = {
-  status: "published";
-  label: "Evento publicado";
-  eventId: string;
-  technicalId: string;
+export type DesignerActivityRecord = {
+  id: string;
   occurredAt: string;
-  publicationId: string;
-  receipt?: unknown;
+  kind: "load" | "event";
+  label: string;
+  technicalId?: string;
+  triggerId?: string;
+  inputPreview?: string;
 };
 
-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>;
+export type DesignerActivityRecorder = {
+  record(input: DesignerActivityRecordInput): void;
 };
 
-type PrototypeEventEngineOptions = {
-  contract?: PrototypeEventEngineContract;
-  payloadSchemas?: Record<string, z.ZodType>;
-  executor: PrototypeBackendExecutor;
-  clock?: () => Date;
-  publicationId?: () => string;
+export type DesignerActivityStore = DesignerActivityRecorder & {
+  getSnapshot(): readonly DesignerActivityRecord[];
+  subscribe(listener: () => void): () => void;
+  clear(): void;
 };
 
-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);
+const preview = (value: unknown): string | undefined => {
+  if (value === undefined) return undefined;
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return "[no serializable]";
   }
-  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;
+const tabId = Math.random().toString(36).slice(2, 8);
 
-  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 + '"',
-      );
-    },
+type ChannelMessage =
+  | { type: "record"; record: DesignerActivityRecord }
+  | { type: "clear" }
+  | { type: "syncRequest" }
+  | { type: "sync"; records: DesignerActivityRecord[] };
 
-    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.');
+export const createDesignerActivityStore = (maxItems = 80): DesignerActivityStore => {
+  const listeners = new Set<() => void>();
+  let records: DesignerActivityRecord[] = [];
+  let sequence = 0;
+  let synced = false;
 
-      const payload = parseWithSchema(
-        event.payloadSchema ? payloadSchemas[event.payloadSchema.schemaId] : undefined,
-        input.payload,
-        'Payload del evento "' + input.eventId + '"',
-      );
+  const channel =
+    typeof BroadcastChannel !== "undefined"
+      ? new BroadcastChannel("lexy-designer-activity")
+      : null;
 
-      const envelope: EventPublicationEnvelope = {
-        technicalId: event.technicalId,
-        occurredAt: clock().toISOString(),
-        publicationId: publicationId(),
-        payload,
-      };
+  const notify = () => {
+    for (const listener of listeners) listener();
+  };
 
-      const executorResult = await options.executor.publishEvent({
-        eventId: input.eventId,
-        triggerId: input.triggerId,
-        envelope,
-      });
+  const addRecord = (record: DesignerActivityRecord) => {
+    records = [record, ...records].slice(0, maxItems);
+    notify();
+  };
 
-      const receipt = parseWithSchema(
-        event.receiptSchema ? payloadSchemas[event.receiptSchema.schemaId] : undefined,
-        executorResult?.receipt,
-        'Receipt del evento "' + input.eventId + '"',
-      );
+  if (channel) {
+    channel.onmessage = (event: MessageEvent<ChannelMessage>) => {
+      const message = event.data;
+      if (message.type === "record") addRecord(message.record);
+      else if (message.type === "clear") {
+        records = [];
+        notify();
+      } else if (message.type === "syncRequest") {
+        channel.postMessage({ type: "sync", records });
+      } else if (message.type === "sync" && !synced && records.length === 0) {
+        synced = true;
+        records = message.records.slice(0, maxItems);
+        notify();
+      }
+    };
+    channel.postMessage({ type: "syncRequest" });
+  }
 
-      return {
-        status: "published",
-        label: "Evento publicado",
-        eventId: input.eventId,
-        technicalId: event.technicalId,
-        occurredAt: envelope.occurredAt,
-        publicationId: envelope.publicationId,
-        ...(receipt === undefined ? {} : { receipt }),
+  return {
+    getSnapshot: () => records,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    record: (input) => {
+      sequence += 1;
+      const record: DesignerActivityRecord = {
+        id: tabId + "_" + sequence,
+        occurredAt: new Date().toISOString(),
+        kind: input.kind,
+        label: input.label,
+        ...(input.technicalId ? { technicalId: input.technicalId } : {}),
+        ...(input.triggerId ? { triggerId: input.triggerId } : {}),
+        ...(preview(input.input) ? { inputPreview: preview(input.input) } : {}),
       };
+      addRecord(record);
+      channel?.postMessage({ type: "record", record });
+    },
+    clear: () => {
+      records = [];
+      notify();
+      channel?.postMessage({ type: "clear" });
     },
   };
 };
-`,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);
-  }
-};
+export const designerActivity = createDesignerActivityStore();
+`,Pt=`
+.lexy-dp {
+  --dp-bg: #ffffff;
+  --dp-fg: #242424;
+  --dp-card: #fafafa;
+  --dp-popover: #ffffff;
+  --dp-primary: #4648d4;
+  --dp-primary-fg: #ffffff;
+  --dp-muted: #f5f5f5;
+  --dp-muted-fg: #616161;
+  --dp-accent: #ebf3fc;
+  --dp-accent-fg: #4648d4;
+  --dp-border: #d1d1d1;
+  --dp-ring: #4648d4;
+  --dp-destructive: #d13438;
+  --dp-success: #107c10;
+  --dp-success-fg: #ffffff;
+  --dp-warning: #f7630c;
+  --dp-warning-fg: #ffffff;
+  --dp-info: #0f6cbd;
+  --dp-radius: 0.5rem;
+  --dp-mono: ui-monospace, SFMono-Regular, Menlo, Consolas, "Liberation Mono", monospace;
+  --dp-sans: system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+  color: var(--dp-fg);
+  font-family: var(--dp-sans);
+  font-size: 14px;
+  line-height: 1.4;
+}
+.lexy-dp *, .lexy-dp *::before, .lexy-dp *::after { box-sizing: border-box; }
+.lexy-dp p, .lexy-dp h1, .lexy-dp pre, .lexy-dp ul { margin: 0; }
+.lexy-dp ul { list-style: none; padding: 0; }
+.lexy-dp button { font-family: inherit; color: inherit; }
+.lexy-dp code { font-family: var(--dp-mono); }
+
+/* \u2500\u2500 P\xE1gina completa \u2500\u2500 */
+.lexy-dp-page {
+  display: flex;
+  flex-direction: column;
+  height: 100vh;
+  background: var(--dp-bg);
+}
 
-try {
-  const dataContractModule = await import("../src/prototype/data-contract/prototype-data-contract");
-  const eventEngineModule =
-    await import("../src/prototype/event-engine/prototype-event-engine-contract");
+/* \u2500\u2500 Tabs \u2500\u2500 */
+.lexy-dp-tablist {
+  display: flex;
+  align-items: stretch;
+  border-bottom: 1px solid var(--dp-border);
+  padding: 0 12px;
+  background: var(--dp-bg);
+}
+.lexy-dp-tab {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 8px 12px;
+  font-size: 12px;
+  border: none;
+  border-bottom: 2px solid transparent;
+  margin-bottom: -1px;
+  background: transparent;
+  color: var(--dp-muted-fg);
+  border-radius: 0;
+  cursor: pointer;
+}
+.lexy-dp-tab:hover { color: var(--dp-fg); }
+.lexy-dp-tab.is-active { color: var(--dp-primary); font-weight: 500; border-bottom-color: var(--dp-primary); }
+.lexy-dp-tab svg { width: 14px; height: 14px; }
+.lexy-dp-tabbadge {
+  margin-left: 4px;
+  border-radius: 9999px;
+  background: var(--dp-warning);
+  color: var(--dp-warning-fg);
+  padding: 0 6px;
+  font-size: 10px;
+  font-weight: 500;
+}
+.lexy-dp-body { flex: 1; min-height: 0; }
+.lexy-dp-panel { height: 100%; }
+
+/* \u2500\u2500 Scroll y padding \u2500\u2500 */
+.lexy-dp-scroll { height: 100%; overflow-y: auto; }
+.lexy-dp-pad { padding: 20px 24px; }
+
+/* \u2500\u2500 Columna y toolbar \u2500\u2500 */
+.lexy-dp-col { display: flex; flex-direction: column; height: 100%; }
+.lexy-dp-toolbar {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  border-bottom: 1px solid var(--dp-border);
+  background: var(--dp-bg);
+  padding: 4px 8px;
+}
 
-  const dataContractResult = prototypeDataContractSchema.safeParse(
-    dataContractModule.prototypeDataContract,
-  );
-  const eventEngineResult = prototypeEventEngineContractSchema.safeParse(
-    eventEngineModule.prototypeEventEngineContract,
-  );
+/* \u2500\u2500 Botones \u2500\u2500 */
+.lexy-dp-btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 6px;
+  padding: 6px 12px;
+  font-size: 13px;
+  border-radius: var(--dp-radius);
+  border: 1px solid transparent;
+  background: var(--dp-primary);
+  color: var(--dp-primary-fg);
+  cursor: pointer;
+}
+.lexy-dp-btn:hover { opacity: 0.92; }
+.lexy-dp-btn:disabled { opacity: 0.5; cursor: not-allowed; }
+.lexy-dp-btn--outline { background: transparent; border-color: var(--dp-border); color: var(--dp-fg); }
+.lexy-dp-btn--outline:hover { background: var(--dp-muted); opacity: 1; }
+.lexy-dp-btn--outline:disabled:hover { background: transparent; }
+.lexy-dp-btn--sm { padding: 4px 10px; font-size: 12px; }
+.lexy-dp-btn svg { width: 14px; height: 14px; }
+
+/* \u2500\u2500 Badges \u2500\u2500 */
+.lexy-dp-badge {
+  display: inline-flex;
+  align-items: center;
+  border-radius: 9999px;
+  padding: 1px 8px;
+  font-size: 11px;
+  font-weight: 500;
+  border: 1px solid transparent;
+  background: var(--dp-primary);
+  color: var(--dp-primary-fg);
+  white-space: nowrap;
+}
+.lexy-dp-badge--outline { background: var(--dp-muted); color: var(--dp-muted-fg); border-color: var(--dp-border); }
+.lexy-dp-badge--success { background: var(--dp-success); color: var(--dp-success-fg); }
+.lexy-dp-badge--warning { background: var(--dp-warning); color: var(--dp-warning-fg); }
+
+/* \u2500\u2500 Cards \u2500\u2500 */
+.lexy-dp-card {
+  border: 1px solid var(--dp-border);
+  background: var(--dp-card);
+  border-radius: var(--dp-radius);
+  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
+  padding: 12px 14px;
+}
+.lexy-dp-card__title { font-size: 14px; font-weight: 600; }
+.lexy-dp-card__desc { font-size: 13px; color: var(--dp-muted-fg); margin-top: 2px; }
+.lexy-dp-card__content { margin-top: 10px; }
+.lexy-dp-card__head-row { display: flex; align-items: flex-start; justify-content: space-between; gap: 12px; }
+
+/* \u2500\u2500 Searchbox \u2500\u2500 */
+.lexy-dp-search { position: relative; display: flex; align-items: center; flex: 1; }
+.lexy-dp-search input {
+  width: 100%;
+  padding: 3px 26px 3px 8px;
+  font-size: 12px;
+  font-family: inherit;
+  border: 1px solid var(--dp-border);
+  border-radius: 3px;
+  background: var(--dp-bg);
+  color: var(--dp-fg);
+}
+.lexy-dp-search input:focus { outline: 2px solid var(--dp-ring); outline-offset: -1px; }
+.lexy-dp-search__clear {
+  position: absolute;
+  right: 6px;
+  border: none;
+  background: transparent;
+  color: var(--dp-muted-fg);
+  cursor: pointer;
+  padding: 2px;
+  display: inline-flex;
+}
+.lexy-dp-search__clear svg { width: 14px; height: 14px; }
+
+/* \u2500\u2500 Snippet / separador / etiquetas \u2500\u2500 */
+.lexy-dp-snippet {
+  font-family: var(--dp-mono);
+  font-size: 12px;
+  background: var(--dp-muted);
+  border: 1px solid var(--dp-border);
+  border-radius: var(--dp-radius);
+  padding: 10px 12px;
+  overflow: auto;
+  white-space: pre;
+  color: var(--dp-fg);
+}
+.lexy-dp-sep { border: none; border-top: 1px solid var(--dp-border); height: 1px; }
+.lexy-dp-section-label {
+  font-size: 12px;
+  font-weight: 500;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  color: var(--dp-muted-fg);
+}
+.lexy-dp-muted { color: var(--dp-muted-fg); }
+.lexy-dp-mono { font-family: var(--dp-mono); }
+.lexy-dp-empty { padding: 16px 12px; color: var(--dp-muted-fg); font-size: 13px; }
+
+.lexy-dp-log__event { color: var(--dp-fg); }
+
+/* \u2500\u2500 Stacks y grids \u2500\u2500 */
+.lexy-dp-stack { display: flex; flex-direction: column; gap: 2px; }
+.lexy-dp-stack-sm { display: flex; flex-direction: column; gap: 6px; }
+.lexy-dp-stack-lg { display: flex; flex-direction: column; gap: 12px; }
+.lexy-dp-substack { display: flex; flex-direction: column; gap: 2px; padding-left: 16px; color: var(--dp-muted-fg); }
+.lexy-dp-grid2 { display: grid; grid-template-columns: 1fr 1fr; gap: 8px; }
+
+/* \u2500\u2500 \xC1rbol JSON \u2500\u2500 */
+.lexy-dp-json-str { color: var(--dp-fg); }
+.lexy-dp-json-num { color: var(--dp-info); }
+.lexy-dp-json-row { display: flex; align-items: flex-start; gap: 4px; padding: 1px 0; }
+.lexy-dp-json-spacer { width: 14px; height: 14px; flex-shrink: 0; }
+.lexy-dp-json-leaf { min-width: 0; word-break: break-word; }
+.lexy-dp-json-toggle {
+  display: flex;
+  width: 100%;
+  align-items: flex-start;
+  gap: 4px;
+  padding: 1px 0;
+  text-align: left;
+  background: transparent;
+  border: none;
+  cursor: pointer;
+}
+.lexy-dp-json-toggle:hover { background: var(--dp-muted); }
+.lexy-dp-chevron { width: 14px; height: 14px; flex-shrink: 0; color: var(--dp-muted-fg); margin-top: 1px; }
+.lexy-dp-chevron--sm { width: 12px; height: 12px; margin-top: 0; }
+.lexy-dp-chevron.is-open { transform: rotate(90deg); }
+
+/* \u2500\u2500 Log de actividad \u2500\u2500 */
+.lexy-dp-activitylog {
+  min-height: 100%;
+  background: var(--dp-bg);
+  padding: 4px 0;
+  font-family: var(--dp-mono);
+  font-size: 12px;
+  line-height: 1.5;
+  color: var(--dp-fg);
+}
+.lexy-dp-activitylog--scroll { flex: 1; min-height: 0; overflow-y: auto; }
+.lexy-dp-log { border-bottom: 1px solid var(--dp-border); }
+.lexy-dp-log__head {
+  display: flex;
+  width: 100%;
+  align-items: center;
+  gap: 6px;
+  padding: 4px 8px;
+  text-align: left;
+  background: transparent;
+  border: none;
+  cursor: pointer;
+}
+.lexy-dp-log__head:hover { background: var(--dp-muted); }
+.lexy-dp-log__time { margin-left: auto; flex-shrink: 0; color: var(--dp-muted-fg); }
+.lexy-dp-log__body { padding-bottom: 6px; }
+
+/* \u2500\u2500 Detalle (event/entity detail) \u2500\u2500 */
+.lexy-dp-eventdetail { display: flex; flex-direction: column; font-size: 12px; line-height: 1.5; }
+.lexy-dp-detail-body { padding: 12px 14px; display: flex; flex-direction: column; gap: 6px; }
+.lexy-dp-detail-field { display: flex; gap: 4px; font-family: var(--dp-mono); font-size: 12px; }
+.lexy-dp-detail-label { color: var(--dp-muted-fg); flex-shrink: 0; }
+.lexy-dp-detail-label::after { content: ":"; }
+
+/* \u2500\u2500 Triggers list \u2500\u2500 */
+.lexy-dp-trigger-list { list-style: none; padding: 0; margin: 0; display: flex; flex-direction: column; gap: 4px; }
+.lexy-dp-trigger-item { display: flex; gap: 8px; align-items: baseline; }
+.lexy-dp-bullet { color: var(--dp-primary); font-weight: 700; flex-shrink: 0; }
+
+
+/* \u2500\u2500 Split (lista + detalle) \u2500\u2500 */
+.lexy-dp-split { display: flex; height: 100%; }
+.lexy-dp-split__list {
+  width: 288px;
+  flex-shrink: 0;
+  overflow-y: auto;
+  border-right: 1px solid var(--dp-border);
+  padding: 8px 0;
+  display: flex;
+  flex-direction: column;
+  gap: 1px;
+}
+.lexy-dp-list-section {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  width: 100%;
+  padding: 5px 10px;
+  font-size: 12px;
+  font-weight: 500;
+  color: var(--dp-fg);
+  background: var(--dp-muted);
+  border: none;
+  border-top: 1px solid var(--dp-border);
+  border-bottom: 1px solid var(--dp-border);
+  cursor: pointer;
+  font-family: inherit;
+  text-align: left;
+}
+.lexy-dp-list-section:hover { background: var(--dp-border); }
+.lexy-dp-listitem {
+  width: 100%;
+  text-align: left;
+  border: none;
+  background: transparent;
+  border-radius: 0;
+  padding: 5px 12px;
+  font-family: var(--dp-mono);
+  font-size: 12px;
+  color: var(--dp-fg);
+  cursor: pointer;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.lexy-dp-listitem:hover { background: var(--dp-muted); }
+.lexy-dp-listitem.is-active { background: var(--dp-accent); color: var(--dp-accent-fg); font-weight: 500; }
+.lexy-dp-split__detail { flex: 1; min-width: 0; min-height: 0; overflow-y: auto; padding: 0; }
+
+/* \u2500\u2500 Tabla de campos (devtools) \u2500\u2500 */
+.lexy-dp-field-table { width: 100%; border-collapse: collapse; font-family: var(--dp-mono); font-size: 11px; table-layout: fixed; }
+.lexy-dp-field-table th { text-align: left; font-weight: 500; color: var(--dp-fg); padding: 3px 8px; background: var(--dp-muted); border-bottom: 1px solid var(--dp-border); border-right: 1px solid var(--dp-border); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+.lexy-dp-field-table th:last-child { border-right: none; }
+.lexy-dp-field-table td { padding: 2px 8px; border-bottom: 1px solid var(--dp-border); border-right: 1px solid var(--dp-border); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; vertical-align: top; }
+.lexy-dp-field-table td:last-child { border-right: none; }
+.lexy-dp-field-table tbody tr { cursor: pointer; }
+.lexy-dp-field-table tbody tr:hover { background: var(--dp-muted); }
+.lexy-dp-field-table tbody tr.is-selected { background: var(--dp-accent); color: var(--dp-accent-fg); }
+.lexy-dp-field-table tbody tr.is-selected td { color: var(--dp-accent-fg); }
+.lexy-dp-field-table tbody tr:last-child td { border-bottom: none; }
+
+/* \u2500\u2500 Launcher flotante \u2500\u2500 */
+.lexy-dp-launcher {
+  position: fixed;
+  bottom: 16px;
+  right: 16px;
+  z-index: 40;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  height: 48px;
+  width: 48px;
+  gap: 0;
+  overflow: hidden;
+  border: none;
+  border-radius: 9999px;
+  background: var(--dp-fg);
+  color: var(--dp-primary-fg);
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.18);
+  cursor: pointer;
+  padding: 0 12px;
+}
+.lexy-dp-launcher:hover,
+.lexy-dp-launcher:focus-visible,
+.lexy-dp-launcher.is-open { width: 176px; gap: 8px; }
+.lexy-dp-launcher:focus-visible { outline: 2px solid var(--dp-ring); outline-offset: 2px; }
+.lexy-dp-launcher__icon { width: 20px; height: 20px; flex-shrink: 0; }
+.lexy-dp-launcher__label {
+  overflow: hidden;
+  white-space: nowrap;
+  font-size: 13px;
+  font-weight: 500;
+  max-width: 0;
+  opacity: 0;
+}
+.lexy-dp-launcher:hover .lexy-dp-launcher__label,
+.lexy-dp-launcher:focus-visible .lexy-dp-launcher__label,
+.lexy-dp-launcher.is-open .lexy-dp-launcher__label { max-width: 160px; opacity: 1; }
+
+/* \u2500\u2500 Sheet flotante \u2500\u2500 */
+.lexy-dp-sheet {
+  position: fixed;
+  bottom: 80px;
+  right: 16px;
+  z-index: 40;
+  display: flex;
+  flex-direction: column;
+  height: 70vh;
+  width: min(100vw - 2rem, 400px);
+  overflow: hidden;
+  border: 1px solid var(--dp-border);
+  border-radius: 12px;
+  background: var(--dp-popover);
+  color: var(--dp-fg);
+  box-shadow: 0 20px 40px rgba(0, 0, 0, 0.25);
+}
+.lexy-dp-sheet__header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  border-bottom: 1px solid var(--dp-border);
+  background: var(--dp-fg);
+  padding: 12px 16px;
+  color: var(--dp-primary-fg);
+}
+.lexy-dp-sheet__title { font-size: 14px; font-weight: 500; }
+.lexy-dp-sheet__actions { display: flex; align-items: center; gap: 4px; }
+.lexy-dp-iconbtn {
+  display: flex;
+  height: 28px;
+  width: 28px;
+  align-items: center;
+  justify-content: center;
+  border: none;
+  background: transparent;
+  border-radius: 6px;
+  opacity: 0.7;
+  cursor: pointer;
+}
+.lexy-dp-iconbtn:hover { opacity: 1; }
+.lexy-dp-iconbtn svg { width: 16px; height: 16px; }
+.lexy-dp-sheet__body { flex: 1; min-height: 0; overflow-y: auto; background: var(--dp-bg); }
+`,jt=()=>String.raw`import {
+  Activity,
+  ArrowUpRight,
+  ChevronRight,
+  Maximize2,
+  Settings,
+  Trash2,
+  X,
+  Zap,
+} from "lucide-react";
+import { useState, useSyncExternalStore } from "react";
 
-  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,
-      });
-    }
-  }
+import { prototypeDataContract } from "../data-contract/prototype-data-contract";
+import {
+  catalog,
+  type CatalogEvent,
+  type CatalogLoad,
+} from "../ports/catalog";
+import type { DesignerActivityRecord } from "./designer-activity";
+import { designerActivity } from "./designer-activity";
+
+// Panel autocontenido: trae su propio CSS scopeado (.lexy-dp) y no depende del
+// tema Tailwind del proyecto host ni de componentes del registry. Así se puede
+// previsualizar e iterar el diseño en cualquier entorno.
+const PANEL_STYLES = ${JSON.stringify(Pt)};
+
+function PanelStyles() {
+  return <style>{PANEL_STYLES}</style>;
+}
 
-  if (dataContractResult.success && eventEngineResult.success) {
-    issues.push(
-      ...validateEventEngineReferences({
-        eventEngineContract: eventEngineResult.data,
-        dataContract: dataContractResult.data,
-        payloadSchemas: prototypePayloadSchemas,
-      }),
-    );
+const formatTime = (value: string) =>
+  new Intl.DateTimeFormat("es-CL", {
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+  }).format(new Date(value));
+
+const safeParse = (value: string | undefined): unknown => {
+  if (value === undefined) return undefined;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
   }
+};
 
-  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 })),
+const TREE_INDENT = 14;
+const TREE_BASE = 8;
+
+const renderPrimitive = (value: unknown) => {
+  if (typeof value === "string") return <span className="lexy-dp-json-str">"{value}"</span>;
+  if (typeof value === "number") return <span className="lexy-dp-json-num">{value}</span>;
+  if (typeof value === "boolean") return <span className="lexy-dp-json-num">{String(value)}</span>;
+  if (value === null) return <span className="lexy-dp-muted">null</span>;
+  return <span className="lexy-dp-json-str">{String(value)}</span>;
+};
+
+function JsonNode({
+  label,
+  value,
+  depth = 0,
+  defaultOpen = false,
+}: {
+  label: string;
+  value: unknown;
+  depth?: number;
+  defaultOpen?: boolean;
+}) {
+  const [open, setOpen] = useState(defaultOpen);
+  const isBranch = value !== null && typeof value === "object";
+  const indent = { paddingLeft: (depth * TREE_INDENT + TREE_BASE) + "px" };
+
+  if (!isBranch) {
+    return (
+      <div style={indent} className="lexy-dp-json-row">
+        <span className="lexy-dp-json-spacer" aria-hidden />
+        <span className="lexy-dp-json-leaf">
+          <span className="lexy-dp-muted">{label}:</span> {renderPrimitive(value)}
+        </span>
+      </div>
     );
-  } 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 entries = Object.entries(value as Record<string, unknown>);
 
-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.",
+  return (
+    <div>
+      <button
+        type="button"
+        onClick={() => setOpen((v) => !v)}
+        style={indent}
+        className="lexy-dp-json-toggle"
+      >
+        <ChevronRight className={"lexy-dp-chevron" + (open ? " is-open" : "")} />
+        <span className="lexy-dp-json-leaf">
+          <span className="lexy-dp-muted">{label}:</span>
+          {!open ? (
+            <span className="lexy-dp-muted">
+              {" "}
+              {Array.isArray(value) ? "Array(" + entries.length + ")" : "{…}"}
+            </span>
+          ) : null}
+        </span>
+      </button>
+      {open
+        ? entries.map(([key, child]) => (
+            <JsonNode key={key} label={key} value={child} depth={depth + 1} defaultOpen />
+          ))
+        : null}
+    </div>
   );
+}
 
-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.',
-      });
-    }
+function LogEntry({ item }: { item: DesignerActivityRecord }) {
+  const [open, setOpen] = useState(false);
+  const trigger = item.triggerId ?? "desconocido";
+  const operationName = item.technicalId ?? item.label;
+  const input = safeParse(item.inputPreview);
+  const inputLabel = item.kind === "load" ? "params" : "payload";
 
-    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 + '".',
-        });
-      }
-    }
-  });
+  return (
+    <div className="lexy-dp-log">
+      <button type="button" onClick={() => setOpen((v) => !v)} className="lexy-dp-log__head">
+        <ChevronRight className={"lexy-dp-chevron lexy-dp-chevron--sm" + (open ? " is-open" : "")} />
+        <span className="lexy-dp-log__event">{operationName}</span>
+        <span className="lexy-dp-log__time">{formatTime(item.occurredAt)}</span>
+      </button>
+      {open ? (
+        <div className="lexy-dp-log__body">
+          <div style={{ paddingLeft: TREE_BASE + "px" }} className="lexy-dp-json-row">
+            <span className="lexy-dp-json-spacer" aria-hidden />
+            <span className="lexy-dp-json-leaf">
+              <span className="lexy-dp-muted">fuente:</span>{" "}
+              <span className="lexy-dp-json-str">{trigger}</span>
+            </span>
+          </div>
+          {input !== undefined ? <JsonNode label={inputLabel} value={input} defaultOpen /> : null}
+        </div>
+      ) : null}
+    </div>
+  );
+}
 
-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;
-};
+const DESIGNER_PANEL_ROUTE = "/designer-panel";
 
-type DataContractFieldLike = {
-  dataType: "string" | "number" | "boolean" | "date" | "datetime" | "enum" | "identifier";
-  required: boolean;
-  enumValues?: string[];
-};
+function ActivityLog() {
+  const activity = useSyncExternalStore(
+    designerActivity.subscribe,
+    designerActivity.getSnapshot,
+    designerActivity.getSnapshot,
+  );
+  return (
+    <div className="lexy-dp-activitylog">
+      {activity.length === 0 ? (
+        <p className="lexy-dp-empty">Sin actividad. Ejecuta una carga o publica un evento.</p>
+      ) : null}
+      {activity.map((item) => (
+        <LogEntry key={item.id} item={item} />
+      ))}
+    </div>
+  );
+}
 
-type DataContractLike = {
-  entities: Record<
-    string,
-    {
-      fields: Record<string, DataContractFieldLike>;
-    }
-  >;
-  relations: Array<{ id: string; fromEntity: string; toEntity: string }>;
-  projections: Record<string, unknown>;
+const matchesQuery = (item: DesignerActivityRecord, query: string): boolean => {
+  const haystack = [
+    item.technicalId,
+    item.label,
+    item.triggerId,
+    item.inputPreview,
+  ]
+    .filter(Boolean)
+    .join(" ")
+    .toLowerCase();
+  return haystack.includes(query);
 };
 
-type EventEngineContractLike = {
-  dataLoads: Record<string, unknown>;
-  events: Record<string, unknown>;
-};
+function ActivityTab() {
+  const [query, setQuery] = useState("");
+  const activity = useSyncExternalStore(
+    designerActivity.subscribe,
+    designerActivity.getSnapshot,
+    designerActivity.getSnapshot,
+  );
+  const normalizedQuery = query.trim().toLowerCase();
+  const filtered = normalizedQuery
+    ? activity.filter((item) => matchesQuery(item, normalizedQuery))
+    : activity;
 
-const splitReference = (reference: string) => {
-  const [entityId, fieldId] = reference.split(".");
-  return { entityId, fieldId };
-};
+  return (
+    <div className="lexy-dp-col">
+      <div className="lexy-dp-toolbar">
+        <button
+          type="button"
+          aria-label="Limpiar actividad"
+          title="Limpiar actividad"
+          className="lexy-dp-iconbtn"
+          onClick={() => designerActivity.clear()}
+        >
+          <Trash2 />
+        </button>
+        <div className="lexy-dp-search">
+          <input
+            value={query}
+            onChange={(event) => setQuery(event.target.value)}
+            placeholder="Buscar en los logs…"
+          />
+          {query ? (
+            <button
+              type="button"
+              aria-label="Limpiar búsqueda"
+              className="lexy-dp-search__clear"
+              onClick={() => setQuery("")}
+            >
+              <X />
+            </button>
+          ) : null}
+        </div>
+      </div>
+      <div className="lexy-dp-activitylog lexy-dp-activitylog--scroll">
+        {filtered.length === 0 ? (
+          <p className="lexy-dp-empty">
+            {activity.length === 0
+              ? "Sin actividad. Ejecuta una carga o publica un evento."
+              : "Sin coincidencias para la búsqueda."}
+          </p>
+        ) : null}
+        {filtered.map((item) => (
+          <LogEntry key={item.id} item={item} />
+        ))}
+      </div>
+    </div>
+  );
+}
 
-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 inferType = (value: unknown): string => {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
 };
 
-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 TYPE_COLORS: Record<string, string> = {
+  string: "var(--dp-success)",
+  number: "var(--dp-info)",
+  boolean: "var(--dp-warning)",
 };
 
-const rutFormat = /^[0-9]{7,8}-[0-9K]$/;
+const TypeLabel = ({ value }: { value: unknown }) => (
+  <span className="lexy-dp-muted" style={{ marginLeft: "8px" }}>{inferType(value)}</span>
+);
 
-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;
-};
+function PayloadKeyNode({
+  label,
+  value,
+  depth = 0,
+}: {
+  label: string;
+  value: unknown;
+  depth?: number;
+}) {
+  const [open, setOpen] = useState(true);
+  const indent = { paddingLeft: depth * TREE_INDENT + TREE_BASE + "px" };
 
-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 (Array.isArray(value)) {
+    const firstObj = value.find(
+      (item) => item !== null && typeof item === "object" && !Array.isArray(item),
+    );
+    const children = firstObj ? Object.entries(firstObj as Record<string, unknown>) : [];
+    if (children.length === 0) {
+      return (
+        <div style={indent} className="lexy-dp-json-row">
+          <span className="lexy-dp-json-spacer" aria-hidden />
+          <span className="lexy-dp-json-leaf" style={{ color: TYPE_COLORS[inferType(value)] ?? "var(--dp-fg)" }}>{label}<TypeLabel value={value} /></span>
+        </div>
+      );
     }
+    return (
+      <div>
+        <button type="button" onClick={() => setOpen((v) => !v)} style={indent} className="lexy-dp-json-toggle">
+          <ChevronRight className={"lexy-dp-chevron" + (open ? " is-open" : "")} />
+          <span className="lexy-dp-json-leaf" style={{ color: TYPE_COLORS[inferType(value)] ?? "var(--dp-fg)" }}>{label}<TypeLabel value={value} /></span>
+        </button>
+        {open
+          ? children.map(([key, child]) => (
+              <PayloadKeyNode key={key} label={key} value={child} depth={depth + 1} />
+            ))
+          : null}
+      </div>
+    );
   }
 
-  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 + '".';
-    }
+  if (value !== null && typeof value === "object") {
+    const entries = Object.entries(value as Record<string, unknown>);
+    return (
+      <div>
+        <button type="button" onClick={() => setOpen((v) => !v)} style={indent} className="lexy-dp-json-toggle">
+          <ChevronRight className={"lexy-dp-chevron" + (open ? " is-open" : "")} />
+          <span className="lexy-dp-json-leaf" style={{ color: TYPE_COLORS[inferType(value)] ?? "var(--dp-fg)" }}>{label}<TypeLabel value={value} /></span>
+        </button>
+        {open
+          ? entries.map(([key, child]) => (
+              <PayloadKeyNode key={key} label={key} value={child} depth={depth + 1} />
+            ))
+          : null}
+      </div>
+    );
   }
 
-  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;
-};
+  return (
+    <div style={indent} className="lexy-dp-json-row">
+      <span className="lexy-dp-json-spacer" aria-hidden />
+      <span className="lexy-dp-json-leaf" style={{ color: TYPE_COLORS[inferType(value)] ?? "var(--dp-fg)" }}>{label}<TypeLabel value={value} /></span>
+    </div>
+  );
+}
 
-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);
-  }
-};
+function EventDetail({ event }: { event: CatalogEvent }) {
+  const [triggersOpen, setTriggersOpen] = useState(true);
+  const [payloadOpen, setPayloadOpen] = useState(true);
 
-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.",
-      });
-    }
-  }
+  const activity = useSyncExternalStore(
+    designerActivity.subscribe,
+    designerActivity.getSnapshot,
+    designerActivity.getSnapshot,
+  );
+  const observedTriggers = Array.from(
+    new Set(
+      activity
+        .filter((record) => record.technicalId === event.technicalId && record.triggerId)
+        .map((record) => record.triggerId as string),
+    ),
+  );
+  const payload = event.lastPayload;
 
-  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.',
-        });
-      }
-    }
-  }
+  return (
+    <div className="lexy-dp-eventdetail">
+      <div className="lexy-dp-detail-body">
+        <div className="lexy-dp-detail-field">
+          <span className="lexy-dp-detail-label">Nombre</span>
+          <span>{event.technicalId}</span>
+        </div>
+        {event.description ? (
+          <div className="lexy-dp-detail-field">
+            <span className="lexy-dp-detail-label">Descripción</span>
+            <span>{event.description}</span>
+          </div>
+        ) : null}
+        {event.lastReceipt ? (
+          <div className="lexy-dp-detail-field">
+            <span className="lexy-dp-detail-label">Último receipt</span>
+            <span className="lexy-dp-mono">
+              {event.lastReceipt.eventId} · {event.lastReceipt.status}
+            </span>
+          </div>
+        ) : null}
+      </div>
 
-  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.',
-          });
-        }
-      }
-    }
-  }
+      <button type="button" className="lexy-dp-list-section" onClick={() => setTriggersOpen((v) => !v)}>
+        Detonantes
+        <ChevronRight className={"lexy-dp-chevron lexy-dp-chevron--sm" + (triggersOpen ? " is-open" : "")} />
+      </button>
+      {triggersOpen ? (
+        <div className="lexy-dp-detail-body">
+          {observedTriggers.length > 0 ? (
+            <ul className="lexy-dp-trigger-list">
+              {observedTriggers.map((trigger) => (
+                <li key={trigger} className="lexy-dp-trigger-item">
+                  <span className="lexy-dp-bullet">·</span>
+                  <span className="lexy-dp-mono">{trigger}</span>
+                </li>
+              ))}
+            </ul>
+          ) : event.trigger ? (
+            <span className="lexy-dp-muted">{event.trigger} · sin publicar aún</span>
+          ) : (
+            <span className="lexy-dp-muted">Sin publicar aún.</span>
+          )}
+        </div>
+      ) : null}
+
+      <button type="button" className="lexy-dp-list-section" onClick={() => setPayloadOpen((v) => !v)}>
+        Payload
+        <ChevronRight className={"lexy-dp-chevron lexy-dp-chevron--sm" + (payloadOpen ? " is-open" : "")} />
+      </button>
+      {payloadOpen ? (
+        <div className="lexy-dp-detail-body">
+          {payload !== undefined && payload !== null ? (
+            typeof payload === "object" ? (
+              <div className="lexy-dp-mono" style={{ fontSize: "12px" }}>
+                {Object.entries(payload as Record<string, unknown>).map(([key, value]) => (
+                  <PayloadKeyNode key={key} label={key} value={value} />
+                ))}
+              </div>
+            ) : (
+              <span className="lexy-dp-mono lexy-dp-muted">{typeof payload}</span>
+            )
+          ) : (
+            <span className="lexy-dp-muted">Sin datos aún — publica el evento para ver el payload.</span>
+          )}
+        </div>
+      ) : null}
+    </div>
+  );
+}
 
-  return issues;
-};
+function LoadDetail({ load }: { load: CatalogLoad }) {
+  const [paramsOpen, setParamsOpen] = useState(true);
+  const params = load.lastParams;
 
-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;
-      }
+  return (
+    <div className="lexy-dp-eventdetail">
+      <div className="lexy-dp-detail-body">
+        <div className="lexy-dp-detail-field">
+          <span className="lexy-dp-detail-label">Nombre</span>
+          <span>{load.technicalId}</span>
+        </div>
+        {load.description ? (
+          <div className="lexy-dp-detail-field">
+            <span className="lexy-dp-detail-label">Descripción</span>
+            <span>{load.description}</span>
+          </div>
+        ) : null}
+        {load.reads.entities.length > 0 ? (
+          <div className="lexy-dp-detail-field">
+            <span className="lexy-dp-detail-label">Lee</span>
+            <span className="lexy-dp-mono">{load.reads.entities.join(", ")}</span>
+          </div>
+        ) : null}
+      </div>
 
-      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 + '".',
-            });
-          }
-        }
+      <button type="button" className="lexy-dp-list-section" onClick={() => setParamsOpen((v) => !v)}>
+        Parámetros
+        <ChevronRight className={"lexy-dp-chevron lexy-dp-chevron--sm" + (paramsOpen ? " is-open" : "")} />
+      </button>
+      {paramsOpen ? (
+        <div className="lexy-dp-detail-body">
+          {params !== undefined && params !== null && typeof params === "object" ? (
+            <div className="lexy-dp-mono" style={{ fontSize: "12px" }}>
+              {Object.entries(params as Record<string, unknown>).map(([key, value]) => (
+                <PayloadKeyNode key={key} label={key} value={value} />
+              ))}
+            </div>
+          ) : (
+            <span className="lexy-dp-muted">Sin parámetros — esta carga no recibe filtros.</span>
+          )}
+        </div>
+      ) : null}
+    </div>
+  );
+}
 
-        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.",
-                });
-              }
-            });
-          }
-        }
+type SelectedContract =
+  | { kind: "event"; id: string }
+  | { kind: "load"; id: string }
+  | { kind: "entity"; id: string };
 
-        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);
-          }
-        }
-      }
-    }
+type EntitySelectedItem =
+  | { kind: "field"; id: string }
+  | { kind: "relation"; id: string; reverse: boolean };
 
-    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 +
-              '".',
-          });
-        }
-      }
-    }
+function EntityDetail({ entityId }: { entityId: string }) {
+  const [fieldsOpen, setFieldsOpen] = useState(true);
+  const [selected, setSelected] = useState<EntitySelectedItem | null>(null);
+  const [itemDetailOpen, setItemDetailOpen] = useState(true);
 
-    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.",
-        });
-      }
-    }
+  const entries = useSyncExternalStore(
+    catalog.subscribe,
+    catalog.getSnapshot,
+    catalog.getSnapshot,
+  );
 
-    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.',
-        });
-      }
-    }
-  }
+  const entity = prototypeDataContract.entities[entityId];
+  if (!entity) return <p className="lexy-dp-empty">Entidad no encontrada.</p>;
+
+  const entityRelations = [
+    ...prototypeDataContract.relations
+      .filter((r) => r.fromEntity === entityId)
+      .map((r) => ({ ...r, targetEntity: r.toEntity, reverse: false })),
+    ...prototypeDataContract.relations
+      .filter((r) => r.toEntity === entityId)
+      .map((r) => ({ ...r, targetEntity: r.fromEntity, reverse: true })),
+  ];
+
+  const hasRows = Object.keys(entity.fields).length > 0 || entityRelations.length > 0;
+
+  const selectedField = selected?.kind === "field" ? entity.fields[selected.id] : null;
+  const selectedRelation =
+    selected?.kind === "relation"
+      ? entityRelations.find((r) => r.id === selected.id && r.reverse === selected.reverse) ?? null
+      : null;
+
+  const fieldEvents =
+    selected?.kind === "field"
+      ? entries.filter(
+          (entry): entry is CatalogEvent =>
+            entry.kind === "event" &&
+            entry.writes.fields.includes(entityId + "." + selected.id),
+        )
+      : [];
+
+  const handleClick = (item: EntitySelectedItem) => {
+    setSelected((prev) =>
+      prev?.kind === item.kind && prev.id === item.id ? null : item,
+    );
+    setItemDetailOpen(true);
+  };
 
-  return issues;
-};
+  const isSelected = (item: EntitySelectedItem) =>
+    selected?.kind === item.kind &&
+    selected.id === item.id &&
+    (item.kind !== "relation" || (selected as { reverse: boolean }).reverse === item.reverse);
 
-export function defineMockGenerationProfile(profile: MockGenerationProfile): MockGenerationProfile {
-  return mockGenerationProfileSchema.parse(profile);
-}
+  return (
+    <div className="lexy-dp-eventdetail">
+      <div className="lexy-dp-detail-body">
+        <div className="lexy-dp-detail-field">
+          <span className="lexy-dp-detail-label">Nombre</span>
+          <span>{entityId}</span>
+        </div>
+        <div className="lexy-dp-detail-field">
+          <span className="lexy-dp-detail-label">Descripción</span>
+          <span>{entity.productDescription}</span>
+        </div>
+      </div>
 
-export function definePrototypeMockScenarios(
-  scenarios: PrototypeMockScenarios,
-): PrototypeMockScenarios {
-  return prototypeMockScenariosSchema.parse(scenarios);
+      <button type="button" className="lexy-dp-list-section" onClick={() => setFieldsOpen((v) => !v)}>
+        Campos
+        <ChevronRight className={"lexy-dp-chevron lexy-dp-chevron--sm" + (fieldsOpen ? " is-open" : "")} />
+      </button>
+      {fieldsOpen ? (
+        !hasRows ? (
+          <div className="lexy-dp-detail-body">
+            <span className="lexy-dp-muted">Sin campos declarados.</span>
+          </div>
+        ) : (
+          <div style={{ overflowX: "auto" }}>
+            <table className="lexy-dp-field-table">
+              <thead>
+                <tr>
+                  <th style={{ color: "var(--dp-fg)" }}>Campo</th>
+                  <th style={{ width: "100px", color: "var(--dp-muted-fg)" }}>Tipo</th>
+                </tr>
+              </thead>
+              <tbody>
+                {Object.entries(entity.fields).map(([fieldId, field]) => {
+                  const sel = isSelected({ kind: "field", id: fieldId });
+                  return (
+                    <tr
+                      key={fieldId}
+                      className={sel ? "is-selected" : ""}
+                      onClick={() => handleClick({ kind: "field", id: fieldId })}
+                    >
+                      <td style={sel ? undefined : { color: TYPE_COLORS[field.dataType] ?? "var(--dp-fg)" }}>
+                        {fieldId}
+                      </td>
+                      <td className={sel ? undefined : "lexy-dp-muted"}>{field.dataType}</td>
+                    </tr>
+                  );
+                })}
+                {entityRelations.map((rel) => {
+                  const sel = isSelected({ kind: "relation", id: rel.id, reverse: rel.reverse });
+                  return (
+                    <tr
+                      key={rel.id + (rel.reverse ? "_r" : "")}
+                      className={sel ? "is-selected" : ""}
+                      onClick={() => handleClick({ kind: "relation", id: rel.id, reverse: rel.reverse })}
+                    >
+                      <td style={sel ? undefined : { color: "var(--dp-primary)" }}>
+                        <span style={{ display: "inline-flex", alignItems: "center", gap: "3px" }}>
+                          <ArrowUpRight style={{ width: "11px", height: "11px", flexShrink: 0 }} />
+                          {rel.id}
+                        </span>
+                      </td>
+                      <td style={sel ? undefined : { color: "var(--dp-primary)", opacity: 0.8 }}>
+                        {rel.targetEntity}
+                      </td>
+                    </tr>
+                  );
+                })}
+              </tbody>
+            </table>
+          </div>
+        )
+      ) : null}
+
+      {selected ? (
+        <>
+          <button type="button" className="lexy-dp-list-section" onClick={() => setItemDetailOpen((v) => !v)}>
+            <span>Detalle · <span className="lexy-dp-mono">{selected.id}</span></span>
+            <ChevronRight className={"lexy-dp-chevron lexy-dp-chevron--sm" + (itemDetailOpen ? " is-open" : "")} />
+          </button>
+          {itemDetailOpen ? (
+            <div className="lexy-dp-detail-body">
+              {selectedField ? (
+                <>
+                  <div className="lexy-dp-detail-field">
+                    <span className="lexy-dp-detail-label">Eventos que modifican</span>
+                  </div>
+                  {fieldEvents.length === 0 ? (
+                    <span className="lexy-dp-muted">Ningún evento modifica este campo.</span>
+                  ) : (
+                    <ul className="lexy-dp-trigger-list">
+                      {fieldEvents.map((event) => (
+                        <li key={event.technicalId} className="lexy-dp-trigger-item">
+                          <span className="lexy-dp-bullet">·</span>
+                          <span className="lexy-dp-mono">{event.technicalId}</span>
+                        </li>
+                      ))}
+                    </ul>
+                  )}
+                </>
+              ) : selectedRelation ? (
+                <>
+                  <div className="lexy-dp-detail-field">
+                    <span className="lexy-dp-detail-label">Descripción</span>
+                    <span>{selectedRelation.productDescription}</span>
+                  </div>
+                  <div className="lexy-dp-detail-field">
+                    <span className="lexy-dp-detail-label">Cardinalidad</span>
+                    <span>{selectedRelation.cardinality}</span>
+                  </div>
+                  <div className="lexy-dp-detail-field">
+                    <span className="lexy-dp-detail-label">Resolución</span>
+                    <span>{selectedRelation.resolution}</span>
+                  </div>
+                </>
+              ) : null}
+            </div>
+          ) : null}
+        </>
+      ) : null}
+    </div>
+  );
 }
-`,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";
+function EventsTab() {
+  const entries = useSyncExternalStore(
+    catalog.subscribe,
+    catalog.getSnapshot,
+    catalog.getSnapshot,
+  );
+  const events = entries.filter((e): e is CatalogEvent => e.kind === "event");
+  const loads = entries.filter((e): e is CatalogLoad => e.kind === "load");
+  const entities = Object.entries(prototypeDataContract.entities);
+
+  const defaultSelected: SelectedContract | null =
+    entities[0] ? { kind: "entity", id: entities[0][0] } : null;
+
+  const [selected, setSelected] = useState<SelectedContract | null>(defaultSelected);
+  const [eventsOpen, setEventsOpen] = useState(true);
+  const [loadsOpen, setLoadsOpen] = useState(true);
+  const [entitiesOpen, setEntitiesOpen] = useState(true);
+
+  if (events.length === 0 && loads.length === 0 && entities.length === 0) {
+    return (
+      <p className="lexy-dp-empty">
+        Publica un evento, ejecuta una carga o declara entidades para ver contenido aquí.
+      </p>
+    );
+  }
 
-/**
- * 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";
+  const selectedEvent =
+    selected?.kind === "event"
+      ? (events.find((e) => e.technicalId === selected.id) ?? null)
+      : null;
+  const selectedLoad =
+    selected?.kind === "load"
+      ? (loads.find((l) => l.technicalId === selected.id) ?? null)
+      : null;
+
+  const renderGroup = (
+    label: string,
+    open: boolean,
+    toggle: () => void,
+    ids: string[],
+    kind: "event" | "load" | "entity",
+  ) =>
+    ids.length > 0 ? (
+      <>
+        <li>
+          <button type="button" className="lexy-dp-list-section" onClick={toggle}>
+            {label}
+            <ChevronRight className={"lexy-dp-chevron lexy-dp-chevron--sm" + (open ? " is-open" : "")} />
+          </button>
+        </li>
+        {open
+          ? ids.map((id) => (
+              <li key={kind + ":" + id}>
+                <button
+                  type="button"
+                  onClick={() => setSelected({ kind, id })}
+                  title={id}
+                  className={
+                    "lexy-dp-listitem" +
+                    (selected?.kind === kind && selected.id === id ? " is-active" : "")
+                  }
+                >
+                  {id}
+                </button>
+              </li>
+            ))
+          : null}
+      </>
+    ) : null;
 
-export const projectionResolvers: ProjectionResolverMap = {};
-`,Kt=String.raw`import type { MockDataLoadHandlerMap } from "./prototype-simulator";
+  return (
+    <div className="lexy-dp-split">
+      <ul className="lexy-dp-split__list">
+        {renderGroup("Eventos", eventsOpen, () => setEventsOpen((v) => !v), events.map((e) => e.technicalId), "event")}
+        {renderGroup("Cargas de datos", loadsOpen, () => setLoadsOpen((v) => !v), loads.map((l) => l.technicalId), "load")}
+        {renderGroup("Entidades", entitiesOpen, () => setEntitiesOpen((v) => !v), entities.map(([id]) => id), "entity")}
+      </ul>
+      <div className="lexy-dp-split__detail">
+        {selected?.kind === "event" && selectedEvent ? (
+          <EventDetail event={selectedEvent} />
+        ) : selected?.kind === "load" && selectedLoad ? (
+          <LoadDetail load={selectedLoad} />
+        ) : selected?.kind === "entity" ? (
+          <EntityDetail entityId={selected.id} />
+        ) : null}
+      </div>
+    </div>
+  );
+}
 
-export const dataLoadHandlers: MockDataLoadHandlerMap = {};
-`,qt=String.raw`import type { MockEventHandlerMap } from "./prototype-simulator";
+type DesignerTab = "activity" | "events";
 
-export const eventHandlers: MockEventHandlerMap = {};
-`,Ut=String.raw`import type {
-  JsonPrimitive,
-  MockEntityRecord,
-  PrototypeMockScenarios,
-} from "./simulator-contract-schema";
+export function DesignerPanelPage() {
+  const [tab, setTab] = useState<DesignerTab>("activity");
 
-export type PublishedEventHistoryItem = {
-  publicationId: string;
-  eventId: string;
-  technicalId: string;
-  occurredAt: string;
-  status: "published";
-};
+  return (
+    <div className="lexy-dp lexy-dp-page">
+      <PanelStyles />
+      <div className="lexy-dp-tablist" role="tablist">
+        <button
+          type="button"
+          role="tab"
+          aria-selected={tab === "activity"}
+          className={"lexy-dp-tab" + (tab === "activity" ? " is-active" : "")}
+          onClick={() => setTab("activity")}
+        >
+          <Activity />
+          Actividad
+        </button>
+        <button
+          type="button"
+          role="tab"
+          aria-selected={tab === "events"}
+          className={"lexy-dp-tab" + (tab === "events" ? " is-active" : "")}
+          onClick={() => setTab("events")}
+        >
+          <Zap />
+          Eventos y Datos
+        </button>
+      </div>
+      <div className="lexy-dp-body">
+        {tab === "activity" ? (
+          <div className="lexy-dp-panel">
+            <ActivityTab />
+          </div>
+        ) : null}
+        {tab === "events" ? (
+          <div className="lexy-dp-panel">
+            <EventsTab />
+          </div>
+        ) : null}
+      </div>
+    </div>
+  );
+}
+
+export function PrototypeDesignerPanel() {
+  const [open, setOpen] = useState(false);
+  return (
+    <div className="lexy-dp">
+      <PanelStyles />
+      {open ? (
+        <div role="dialog" aria-label="Actividad del prototipo" className="lexy-dp-sheet">
+          <div className="lexy-dp-sheet__header">
+            <p className="lexy-dp-sheet__title">Panel de Actividad</p>
+            <div className="lexy-dp-sheet__actions">
+              <button
+                type="button"
+                aria-label="Abrir panel completo"
+                title="Abrir panel completo"
+                className="lexy-dp-iconbtn"
+                onClick={() => window.open(DESIGNER_PANEL_ROUTE, "_blank", "noopener,noreferrer")}
+              >
+                <Maximize2 />
+              </button>
+              <button
+                type="button"
+                aria-label="Cerrar"
+                className="lexy-dp-iconbtn"
+                onClick={() => setOpen(false)}
+              >
+                <X />
+              </button>
+            </div>
+          </div>
+          <div className="lexy-dp-sheet__body">
+            <ActivityLog />
+          </div>
+        </div>
+      ) : null}
+
+      <button
+        type="button"
+        aria-label="Designer Assist"
+        aria-expanded={open}
+        onClick={() => setOpen((value) => !value)}
+        className={"lexy-dp-launcher" + (open ? " is-open" : "")}
+      >
+        <Settings className="lexy-dp-launcher__icon" />
+        <span className="lexy-dp-launcher__label">Designer Assist</span>
+      </button>
+    </div>
+  );
+}
+`,$e=async(e,t)=>{let o=async(a,n)=>{await Me.mkdir(ie.dirname(ie.join(e,a)),{recursive:!0}),await Me.writeFile(ie.join(e,a),n)};await o(se,Et),await o(le,jt())};import Fe from"fs/promises";import qe from"path";var ce="src/prototype/mock-store/mock-store.ts",de="src/prototype/mock-store/fixtures.ts",Ct="src/prototype/ports/types.ts",It="src/prototype/ports/catalog.ts",Tt="src/prototype/ports/mock-read.ts",Rt="src/prototype/ports/mock-write.ts",Nt="src/prototype/ports/production.ts",pe="src/prototype/ports/index.ts",Ot=String.raw`import { fixtures } from "./fixtures";
+
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | { [key: string]: JsonValue };
+export type MockEntityRecord = Record<string, JsonValue>;
 
-export type PrototypeSimulatorState = {
-  simulatorVersion: "1";
+export type PrototypeMockState = {
   datasetVersion: number;
-  activeScenarioId: string;
-  revision: number;
   entities: Record<string, MockEntityRecord[]>;
   entitySequences: Record<string, number>;
-  publicationHistory: PublishedEventHistoryItem[];
 };
 
-export type SimulatorStorage = {
+export type MockStorage = {
   read(): string | null;
   write(value: string): void;
   remove(): void;
 };
 
 export type PrototypeMockStore = {
-  getSnapshot(): PrototypeSimulatorState;
+  getSnapshot(): PrototypeMockState;
   subscribe(listener: () => void): () => void;
-  transact(operation: (draft: PrototypeSimulatorState) => void): PrototypeSimulatorState;
-  switchScenario(scenarioId: string): void;
-  resetScenario(): void;
+  transact(operation: (draft: PrototypeMockState) => void): PrototypeMockState;
   clearPersistence(): void;
 };
 
-type CreatePrototypeMockStoreOptions = {
-  projectName: string;
-  scenarios: PrototypeMockScenarios;
-  storage?: SimulatorStorage;
-  onHydrationWarning?: (message: string) => void;
-};
+const STORAGE_KEY = "lexy:prototype:mock-store:v1";
 
 const clone = <T>(value: T): T => {
   if (typeof structuredClone === "function") return structuredClone(value);
@@ -1786,43 +1888,26 @@ const buildSequences = (entities: Record<string, MockEntityRecord[]>) => {
   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);
+const stateFromFixtures = (): PrototypeMockState => {
+  const entities = clone(fixtures.entities);
   return {
-    simulatorVersion: "1",
-    datasetVersion: scenarios.datasetVersion,
-    activeScenarioId: scenarioId,
-    revision: 0,
+    datasetVersion: fixtures.datasetVersion,
     entities,
     entitySequences: buildSequences(entities),
-    publicationHistory: [],
   };
 };
 
-const isPersistedStateCompatible = (
-  value: unknown,
-  scenarios: PrototypeMockScenarios,
-): value is PrototypeSimulatorState => {
+const isCompatible = (value: unknown): value is PrototypeMockState => {
   if (!value || typeof value !== "object") return false;
-  const state = value as Partial<PrototypeSimulatorState>;
+  const state = value as Partial<PrototypeMockState>;
   return (
-    state.simulatorVersion === "1" &&
-    state.datasetVersion === scenarios.datasetVersion &&
-    typeof state.activeScenarioId === "string" &&
-    Boolean(scenarios.scenarios[state.activeScenarioId]) &&
-    typeof state.revision === "number" &&
+    state.datasetVersion === fixtures.datasetVersion &&
     Boolean(state.entities && typeof state.entities === "object") &&
-    Boolean(state.entitySequences && typeof state.entitySequences === "object") &&
-    Array.isArray(state.publicationHistory)
+    Boolean(state.entitySequences && typeof state.entitySequences === "object")
   );
 };
 
-export const createMemorySimulatorStorage = (): SimulatorStorage => {
+const createMemoryStorage = (): MockStorage => {
   let current: string | null = null;
   return {
     read: () => current,
@@ -1835,8 +1920,8 @@ export const createMemorySimulatorStorage = (): SimulatorStorage => {
   };
 };
 
-export const createLocalStorageSimulatorStorage = (key: string): SimulatorStorage => {
-  const memory = createMemorySimulatorStorage();
+const createLocalStorageStorage = (key: string): MockStorage => {
+  const memory = createMemoryStorage();
   const getLocalStorage = () => {
     try {
       return globalThis.localStorage;
@@ -1844,7 +1929,6 @@ export const createLocalStorageSimulatorStorage = (key: string): SimulatorStorag
       return undefined;
     }
   };
-
   return {
     read: () => {
       try {
@@ -1872,41 +1956,26 @@ export const createLocalStorageSimulatorStorage = (key: string): SimulatorStorag
   };
 };
 
-export const simulatorStorageKey = (projectName: string) =>
-  "lexy:prototype:" + projectName + ":simulator:v1";
-
 export const createPrototypeMockStore = (
-  options: CreatePrototypeMockStoreOptions,
+  storage: MockStorage = createLocalStorageStorage(STORAGE_KEY),
 ): PrototypeMockStore => {
-  const storage =
-    options.storage ?? createLocalStorageSimulatorStorage(simulatorStorageKey(options.projectName));
   const listeners = new Set<() => void>();
 
-  const hydrate = () => {
+  const hydrate = (): PrototypeMockState => {
     const persisted = storage.read();
-    if (!persisted)
-      return createStateFromScenario(options.scenarios, options.scenarios.defaultScenarioId);
-
+    if (!persisted) return stateFromFixtures();
     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.",
-      );
+      // Al cambiar fixtures se sube datasetVersion: el estado viejo se descarta.
+      if (isCompatible(parsed)) return parsed;
     } catch {
-      options.onHydrationWarning?.(
-        "Estado persistido corrupto; se reinicia el simulador al escenario default.",
-      );
+      // estado corrupto: reinicia desde fixtures
     }
-    return createStateFromScenario(options.scenarios, options.scenarios.defaultScenarioId);
+    return stateFromFixtures();
   };
 
   let snapshot = hydrate();
 
-  const persist = () => {
-    storage.write(JSON.stringify(snapshot));
-  };
-
   const notify = () => {
     for (const listener of listeners) listener();
   };
@@ -1922,497 +1991,321 @@ export const createPrototypeMockStore = (
     transact: (operation) => {
       const draft = clone(snapshot);
       operation(draft);
-      draft.revision = snapshot.revision + 1;
       snapshot = draft;
-      persist();
+      storage.write(JSON.stringify(snapshot));
       notify();
       return snapshot;
     },
-    switchScenario: (scenarioId) => {
-      snapshot = createStateFromScenario(options.scenarios, scenarioId);
-      persist();
-      notify();
-    },
-    resetScenario: () => {
-      snapshot = createStateFromScenario(options.scenarios, snapshot.activeScenarioId);
-      persist();
-      notify();
-    },
-    clearPersistence: () => {
-      storage.remove();
-    },
+    clearPersistence: () => storage.remove(),
   };
 };
 
+/** Instancia compartida que ven el adapter de lectura y el de escritura. */
+export const mockStore = createPrototypeMockStore();
+
 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 },
-    );
-  });
+`,_t=String.raw`import type { MockEntityRecord } from "./mock-store";
 
-const splitReference = (reference: string) => {
-  const [entityId, fieldId] = reference.split(".");
-  return { entityId, fieldId };
+export type Fixtures = {
+  datasetVersion: number;
+  entities: Record<string, MockEntityRecord[]>;
 };
 
-const getEntityKeyField = (profile: MockGenerationProfile, entityId: string) => {
-  const field = profile.entityKeys[entityId]?.field;
-  return field ? splitReference(field).fieldId : "id";
+/**
+ * Datos sintéticos, deterministas y revisables en PR. Sin Math.random(),
+ * Date.now() ni new Date(). Usa contexto chileno (es-CL, RUT con K mayúscula,
+ * teléfonos +56, fechas ISO, CLP entero, correos example.com).
+ */
+export const fixtures: Fixtures = {
+  datasetVersion: 1,
+  entities: {},
 };
+`,At=String.raw`import { z } from "zod";
 
-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,
-    );
-  },
-});
+/** Metadata de una carga de datos (GET): describe qué lee y qué la detona. */
+export const readMetaSchema = z
+  .object({
+    description: z.string().optional(),
+    trigger: z.string().optional(),
+    reads: z
+      .object({
+        entities: z.array(z.string()).optional(),
+        projections: z.array(z.string()).optional(),
+      })
+      .strict()
+      .optional(),
+  })
+  .strict();
 
-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 type ReadMeta = z.infer<typeof readMetaSchema>;
 
-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,
-          );
-        },
-      },
-    });
-  },
+/** Metadata de un evento publicado (POST): describe qué escribe y qué lo detona. */
+export const writeMetaSchema = z
+  .object({
+    description: z.string().optional(),
+    trigger: z.string().optional(),
+    writes: z
+      .object({
+        entities: z.array(z.string()).optional(),
+        fields: z.array(z.string()).optional(),
+      })
+      .strict()
+      .optional(),
+  })
+  .strict();
 
-  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",
-      });
-    });
+export type WriteMeta = z.infer<typeof writeMetaSchema>;
 
-    return receipt === undefined ? {} : { receipt };
-  },
+/** Lo que devuelve publish(): el id del hecho creado y el código HTTP. */
+export const eventReceiptSchema = z.object({
+  eventId: z.string(),
+  status: z.number().int().min(100).max(599),
 });
-`,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 EventReceipt = z.infer<typeof eventReceiptSchema>;
 
-export type MockDataLoadHandler = (
-  context: MockDataLoadHandlerContext,
-) => unknown | Promise<unknown>;
+/** Lectura (GET): resuelve y devuelve datos; un error se lanza como excepción. */
+export interface LexyReadPort {
+  load<T = unknown>(loadId: string, params?: unknown, meta?: ReadMeta): Promise<T>;
+}
 
-export type MockDataLoadHandlerMap = Record<string, MockDataLoadHandler>;
+/** Escritura (POST): registra un hecho y devuelve su receipt. */
+export interface LexyWritePort {
+  publish(eventId: string, payload: unknown, meta?: WriteMeta): Promise<EventReceipt>;
+}
+`,Lt=String.raw`import type { EventReceipt, ReadMeta, WriteMeta } from "./types";
 
-export type MockEventHandlerContext = {
-  draft: import("./mock-store").PrototypeSimulatorState;
-  envelope: EventPublicationEnvelope;
-  getById(entityId: string, id: JsonPrimitive): MockEntityRecord | undefined;
-  nextEntityId(entityId: string): JsonPrimitive;
+export type CatalogEvent = {
+  kind: "event";
+  technicalId: string;
+  description: string;
+  trigger: string;
+  writes: { entities: string[]; fields: string[] };
+  lastPayload: unknown;
+  lastReceipt: EventReceipt | null;
 };
 
-export type MockEventHandlerResult = {
-  receipt?: unknown;
+export type CatalogLoad = {
+  kind: "load";
+  technicalId: string;
+  description: string;
+  trigger: string;
+  reads: { entities: string[]; projections: string[] };
+  lastParams: unknown;
 };
 
-export type MockEventHandler = (context: MockEventHandlerContext) => MockEventHandlerResult | void;
+export type CatalogEntry = CatalogEvent | CatalogLoad;
 
-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 CatalogMessage =
+  | { type: "entry"; entry: CatalogEntry }
+  | { type: "syncRequest" }
+  | { type: "sync"; entries: CatalogEntry[] };
 
-type CreatePrototypeSimulatorOptions = {
-  profile: MockGenerationProfile;
-  scenarios: PrototypeMockScenarios;
-  projectionResolvers: ProjectionResolverMap;
-  dataLoadHandlers: MockDataLoadHandlerMap;
-  eventHandlers: MockEventHandlerMap;
-};
+const createCatalog = () => {
+  const store = new Map<string, CatalogEntry>();
+  const listeners = new Set<() => void>();
+  let snapshot: CatalogEntry[] = [];
+  let synced = false;
 
-export const createPrototypeSimulator = (
-  options: CreatePrototypeSimulatorOptions,
-): PrototypeSimulator => {
-  const store = createPrototypeMockStore({
-    projectName: prototypeDataContract.project.name,
-    scenarios: options.scenarios,
-    onHydrationWarning: (message) => {
-      console.warn("[Lexy simulator] " + message);
-    },
-  });
+  const channel =
+    typeof BroadcastChannel !== "undefined" ? new BroadcastChannel("lexy-ports-catalog") : null;
 
-  const executor = createMockBackendExecutor({
-    profile: options.profile,
-    scenarios: options.scenarios,
-    store,
-    projectionResolvers: options.projectionResolvers,
-    dataLoadHandlers: options.dataLoadHandlers,
-    eventHandlers: options.eventHandlers,
-  });
+  const key = (entry: CatalogEntry) => entry.kind + ":" + entry.technicalId;
 
-  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(),
+  const notify = () => {
+    snapshot = Array.from(store.values());
+    for (const l of listeners) l();
   };
-};
-
-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 apply = (entry: CatalogEntry) => {
+    store.set(key(entry), entry);
+    notify();
+  };
 
-  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 (channel) {
+    channel.onmessage = (ev: MessageEvent<CatalogMessage>) => {
+      const msg = ev.data;
+      if (msg.type === "entry") apply(msg.entry);
+      else if (msg.type === "syncRequest")
+        channel.postMessage({ type: "sync", entries: Array.from(store.values()) });
+      else if (msg.type === "sync" && !synced && store.size === 0) {
+        synced = true;
+        for (const entry of msg.entries) store.set(key(entry), entry);
+        notify();
       }
-    }
+    };
+    channel.postMessage({ type: "syncRequest" });
   }
 
-  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,
-      }),
-    );
+  const publishEntry = (entry: CatalogEntry) => {
+    store.set(key(entry), entry);
+    notify();
+    channel?.postMessage({ type: "entry", entry });
+  };
 
-    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.',
-        });
-      }
-    }
+  return {
+    recordEvent(technicalId: string, payload: unknown, meta: WriteMeta, receipt: EventReceipt) {
+      const existing = store.get("event:" + technicalId);
+      const prev = existing?.kind === "event" ? existing : undefined;
+      publishEntry({
+        kind: "event",
+        technicalId,
+        description: meta.description ?? prev?.description ?? "",
+        trigger: meta.trigger ?? prev?.trigger ?? "",
+        writes: {
+          entities: meta.writes?.entities ?? prev?.writes.entities ?? [],
+          fields: meta.writes?.fields ?? prev?.writes.fields ?? [],
+        },
+        lastPayload: payload,
+        lastReceipt: receipt,
+      });
+    },
+    recordLoad(technicalId: string, params: unknown, meta: ReadMeta) {
+      const existing = store.get("load:" + technicalId);
+      const prev = existing?.kind === "load" ? existing : undefined;
+      publishEntry({
+        kind: "load",
+        technicalId,
+        description: meta.description ?? prev?.description ?? "",
+        trigger: meta.trigger ?? prev?.trigger ?? "",
+        reads: {
+          entities: meta.reads?.entities ?? prev?.reads.entities ?? [],
+          projections: meta.reads?.projections ?? prev?.reads.projections ?? [],
+        },
+        lastParams: params,
+      });
+    },
+    subscribe: (l: () => void) => {
+      listeners.add(l);
+      return () => listeners.delete(l);
+    },
+    getSnapshot: () => snapshot,
+  };
+};
 
-    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 + '".',
-        });
-      }
+export const catalog = createCatalog();
+`,Dt=String.raw`import { designerActivity } from "../designer-panel/designer-activity";
+import { type MockEntityRecord, mockStore } from "../mock-store/mock-store";
+import { catalog } from "./catalog";
+import { type LexyReadPort, type ReadMeta, readMetaSchema } from "./types";
+
+const isPlainObject = (value: unknown): value is Record<string, unknown> =>
+  Boolean(value) && typeof value === "object" && !Array.isArray(value);
+
+export const mockRead: LexyReadPort = {
+  async load<T = unknown>(loadId: string, params?: unknown, rawMeta: ReadMeta = {}): Promise<T> {
+    const parsed = readMetaSchema.safeParse(rawMeta);
+    if (!parsed.success) {
+      console.warn(
+        '[lexy] Metadata de carga inválida para "' + loadId + '":',
+        parsed.error.flatten().fieldErrors,
+      );
     }
-
-    for (const loadId of Object.keys(eventEngineResult.data.dataLoads)) {
-      if (!dataLoadHandlers[loadId]) {
-        issues.push({
-          path: ["dataLoadHandlers", loadId],
-          message: 'Falta handler para la carga "' + loadId + '".',
-        });
-      }
+    const meta: ReadMeta = parsed.success ? parsed.data : {};
+    catalog.recordLoad(loadId, params, meta);
+
+    const entityId = meta.reads?.entities?.[0];
+    const all = entityId ? (mockStore.getSnapshot().entities[entityId] ?? []) : [];
+    // Filtro genérico: si params es un objeto, exige coincidencia exacta de sus campos.
+    const data: MockEntityRecord[] = isPlainObject(params)
+      ? all.filter((record) =>
+          Object.entries(params).every(([field, value]) => record[field] === value),
+        )
+      : all;
+    designerActivity.record({
+      kind: "load",
+      label: meta.description ?? loadId,
+      technicalId: loadId,
+      triggerId: meta.trigger,
+      input: params,
+    });
+    return data as T;
+  },
+};
+`,zt=String.raw`import { designerActivity } from "../designer-panel/designer-activity";
+import { mockStore } from "../mock-store/mock-store";
+import { catalog } from "./catalog";
+import { type EventReceipt, type LexyWritePort, type WriteMeta, writeMetaSchema } from "./types";
+
+let publicationSequence = 0;
+
+export const mockWrite: LexyWritePort = {
+  async publish(eventId: string, payload: unknown, rawMeta: WriteMeta = {}): Promise<EventReceipt> {
+    const parsed = writeMetaSchema.safeParse(rawMeta);
+    if (!parsed.success) {
+      console.warn(
+        '[lexy] Metadata de evento inválida para "' + eventId + '":',
+        parsed.error.flatten().fieldErrors,
+      );
     }
-    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.',
-        });
-      }
+    const meta: WriteMeta = parsed.success ? parsed.data : {};
+
+    const entityId = meta.writes?.entities?.[0];
+    if (entityId) {
+      mockStore.transact((draft) => {
+        const records = (draft.entities[entityId] ??= []);
+        const nextId = draft.entitySequences[entityId] ?? records.length + 1;
+        records.push({ id: String(nextId), ...(payload as Record<string, unknown>) });
+        draft.entitySequences[entityId] = nextId + 1;
+      });
     }
 
-    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.',
-        });
-      }
-    }
-  }
+    publicationSequence += 1;
+    const receipt: EventReceipt = {
+      eventId: eventId + "_" + publicationSequence,
+      status: 201,
+    };
+    catalog.recordEvent(eventId, payload, meta, receipt);
+    designerActivity.record({
+      kind: "event",
+      label: meta.description ?? eventId,
+      technicalId: eventId,
+      triggerId: meta.trigger,
+      input: payload,
+    });
+    return receipt;
+  },
+};
+`,Mt=String.raw`import type { LexyReadPort, LexyWritePort } from "./types";
 
-  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 })),
+export const productionRead: LexyReadPort = {
+  async load<T = unknown>(loadId: string): Promise<T> {
+    throw new Error(
+      '[lexy] productionRead.load("' + loadId + '") sin implementar: conéctalo al GET de tu API.',
     );
-  } 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";
+  },
+};
+
+export const productionWrite: LexyWritePort = {
+  async publish(eventId: string) {
+    throw new Error(
+      '[lexy] productionWrite.publish("' + eventId + '") sin implementar: encólalo en el worker.',
+    );
+  },
+};
+`,$t=String.raw`import { mockRead } from "./mock-read";
+import { mockWrite } from "./mock-write";
+import { productionRead, productionWrite } from "./production";
+import type { LexyReadPort, LexyWritePort } from "./types";
+
+const USE_MOCK = import.meta.env.DEV;
+
+export const read: LexyReadPort = USE_MOCK ? mockRead : productionRead;
+export const write: LexyWritePort = USE_MOCK ? mockWrite : productionWrite;
+
+export type {
+  EventReceipt,
+  LexyReadPort,
+  LexyWritePort,
+  ReadMeta,
+  WriteMeta,
+} from "./types";
+`,Ft=[[ce,Ot],[de,_t],[Ct,At],[It,Lt],[Tt,Dt],[Rt,zt],[Nt,Mt],[pe,$t]],Ve=async e=>{for(let[t,o]of Ft){let a=qe.join(e,t);await Fe.mkdir(qe.dirname(a),{recursive:!0}),await Fe.writeFile(a,o)}};var Kt={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"]},Ut="10.33.3",Ht=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@${Ut}`,scripts:{dev:"vite","check:data-contract":"tsx scripts/check-data-contract.ts","check:prototype":"pnpm check:data-contract","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","lucide-react":"^0.460.0",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)+`
+`},Bt=`import path from "node:path";
 
 import babel from "@rolldown/plugin-babel";
 import tailwindcss from "@tailwindcss/vite";
@@ -2440,9 +2333,30 @@ export default defineConfig({
     terserOptions: {
       compress: { drop_console: true, drop_debugger: true },
     },
+    // Code splitting por grupos de vendor (auditor\xEDa de desarrollo, jun 2026):
+    // node_modules se separa en bundles tem\xE1ticos para carga diferida y mejor
+    // cach\xE9 entre deploys. Los grupos sin match simplemente no emiten chunk.
+    rolldownOptions: {
+      output: {
+        codeSplitting: {
+          groups: [
+            { name: "react-core", test: /node_modules[\\\\/](react|react-dom|scheduler)[\\\\/]/ },
+            { name: "router", test: /node_modules[\\\\/]react-router[\\\\/]/ },
+            { name: "query", test: /node_modules[\\\\/]@tanstack[\\\\/]/ },
+            { name: "state", test: /node_modules[\\\\/]jotai[\\\\/]/ },
+            { name: "utils", test: /node_modules[\\\\/](clsx|tailwind-merge|class-variance-authority|zod)[\\\\/]/ },
+            { name: "ui", test: /node_modules[\\\\/](tailwind-animations|@tailwindcss)[\\\\/]/ },
+            { name: "radix", test: /node_modules[\\\\/]@radix-ui[\\\\/]/ },
+            { name: "icons", test: /node_modules[\\\\/]lucide-react[\\\\/]/ },
+            { name: "vendor", test: /node_modules[\\\\/]/ },
+          ],
+          minSize: 20000,
+        },
+      },
+    },
   },
 });
-`,Qt=`import js from "@eslint/js";
+`,Jt=`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";
@@ -2471,14 +2385,14 @@ export default tseslint.config(
     },
   },
 );
-`,eo=`{
+`,Wt=`{
   "printWidth": 100
 }
-`,to=`pnpm-lock.yaml
+`,Gt=`pnpm-lock.yaml
 src/lexy-theme.css
 public/fonts/
 dist/
-`,oo=`name: CI
+`,Qt=`name: CI
 
 on:
   push:
@@ -2499,11 +2413,9 @@ jobs:
       - run: pnpm lint
       - run: pnpm exec prettier --check .
       - run: pnpm check:data-contract
-      - run: pnpm check:event-engine
-      - run: pnpm check:simulator
       - run: pnpm build:app
       - run: pnpm audit --audit-level high
-`,no=`{
+`,Yt=`{
   "files": [],
   "references": [{ "path": "./tsconfig.app.json" }, { "path": "./tsconfig.node.json" }],
   "compilerOptions": {
@@ -2511,7 +2423,7 @@ jobs:
     "paths": { "@/*": ["./src/*"] }
   }
 }
-`,ao=`{
+`,Xt=`{
   "compilerOptions": {
     "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
     "target": "ES2022",
@@ -2535,7 +2447,7 @@ jobs:
   },
   "include": ["src"]
 }
-`,ro=`{
+`,Zt=`{
   "compilerOptions": {
     "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
     "target": "ES2023",
@@ -2552,7 +2464,7 @@ jobs:
   },
   "include": ["vite.config.ts"]
 }
-`,io=e=>`<!doctype html>
+`,eo=e=>`<!doctype html>
 <html lang="es">
   <head>
     <meta charset="UTF-8" />
@@ -2564,9 +2476,9 @@ jobs:
     <script type="module" src="/src/main.tsx"></script>
   </body>
 </html>
-`,so=`@import "tailwindcss";
+`,to=`@import "tailwindcss";
 @import "./lexy-theme.css";
-`,co=e=>e.architecture==="feature"?`import "./index.css";
+`,oo=e=>e.architecture==="feature"?`import "./index.css";
 
 import { StrictMode } from "react";
 import { createRoot } from "react-dom/client";
@@ -2600,7 +2512,9 @@ createRoot(document.getElementById("root")!).render(
           Trae tu primer componente: <code>npx create-lexy add button</code>
         </p>
       </div>
-    </main>`,lo=e=>e.architecture==="feature"?`import { Route, Routes } from "react-router";
+    </main>`,ao=e=>e.architecture==="feature"?`import { Route, Routes } from "react-router";
+
+import { PrototypeDesignerPanel } from "../prototype/designer-panel/PrototypeDesignerPanel";
 
 const Home = () => {
   return (
@@ -2608,62 +2522,74 @@ ${Ke}
   );
 };
 
+const showPrototypeDesignerPanel = import.meta.env.DEV;
+
 export const App = () => {
   return (
-    <Routes>
-      <Route path="/" element={<Home />} />
-    </Routes>
+    <>
+      <Routes>
+        <Route path="/" element={<Home />} />
+      </Routes>
+      {showPrototypeDesignerPanel ? <PrototypeDesignerPanel /> : null}
+    </>
   );
 };
-`:`export const App = () => {
+`:`import { PrototypeDesignerPanel } from "../prototype/designer-panel/PrototypeDesignerPanel";
+
+const showPrototypeDesignerPanel = import.meta.env.DEV;
+
+export const App = () => {
   return (
+    <>
 ${Ke}
+      {showPrototypeDesignerPanel ? <PrototypeDesignerPanel /> : null}
+    </>
   );
 };
-`,po=`import { type ClassValue, clsx } from "clsx";
+`,no=`import { type ClassValue, clsx } from "clsx";
 import { twMerge } from "tailwind-merge";
 
 export function cn(...inputs: ClassValue[]) {
   return twMerge(clsx(inputs));
 }
-`,mo=`node_modules/
+`,ro=`node_modules/
 dist/
 *.log
 .env
-`,uo=e=>`# ${e.projectName}
+`,io=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
+pnpm check:prototype              # validar el contrato de datos del prototipo
 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
 \`\`\`
-`,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}
+`,so=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)+`
+`},lo=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,runtimeVersion:"1",mockStorePath:ce,fixturesPath:de,portsPath:pe,designerPanelVersion:"1",designerPanelPath:le,designerActivityStorePath:se},installed:{}}},Ue=async(e,t)=>{let o=["package.json","src","index.html",".lexy"],a=[];for(let s of o)try{await b.access(w.join(t,s)),a.push(s)}catch{}if(a.length>0)throw new Error(`El directorio actual ya contiene archivos de un proyecto (${a.join(", ")}). Ejecuta el comando dentro de una carpeta vac\xEDa.`);for(let s of Kt[e.architecture])await b.mkdir(w.join(t,s),{recursive:!0});let n=(s,u)=>b.writeFile(w.join(t,s),u);await n("package.json",Ht(e)),await n("vite.config.ts",Bt),await n("tsconfig.json",Yt),await n("tsconfig.app.json",Xt),await n("tsconfig.node.json",Zt),await n("eslint.config.js",Jt),await n(".prettierrc",Wt),await n(".prettierignore",Gt),await b.mkdir(w.join(t,".github/workflows"),{recursive:!0}),await n(".github/workflows/ci.yml",Qt),await n("index.html",eo(e)),await n(".gitignore",ro),await n("README.md",io(e)),await n("src/index.css",to),await n("src/main.tsx",oo(e)),await ze(t,e.projectName),await Ve(t);let r=lo(e);await $e(t,r);let i=e.architecture==="feature"?"src/app":"src/views";await n(`${i}/App.tsx`,ao(e)),await n(".lexy",JSON.stringify(r,null,2)+`
+`),await n("components.json",so(e)),await b.copyFile(Ce,w.join(t,"src/lexy-theme.css")),await b.mkdir(w.join(t,"public/fonts"),{recursive:!0}),await b.cp(Ie,w.join(t,"public/fonts"),{recursive:!0});let d=w.join(t,r.paths.lib,"utils");await b.mkdir(d,{recursive:!0}),await b.writeFile(w.join(d,"cn.ts"),no),await co(t)},co=async e=>{let t=[],o=async a=>{let n;try{n=await b.readdir(a,{withFileTypes:!0})}catch{return}for(let r of n){let i=w.join(a,r.name);r.isDirectory()?await o(i):/\.(ts|tsx)$/.test(r.name)&&t.push(i)}};await o(w.join(e,"src")),await o(w.join(e,"scripts"));for(let a of t){let n=await b.readFile(a,"utf-8"),r=await Vt(a)??{},i=await qt(n,{...r,filepath:a});i!==n&&await b.writeFile(a,i)}};var fo=["feature","layer"],go=["cliente","crm","mixto"],xo=e=>new Promise((t,o)=>{po("pnpm",["install"],{cwd:e,stdio:"ignore",shell:!0}).on("close",n=>n===0?t():o(new Error(`pnpm install fall\xF3 con c\xF3digo ${n}`)))}),He=async(e,t)=>{let o;!!(e&&t.type)?(fo.includes(t.type)||(console.error(j.red(`Error: la arquitectura "${t.type}" no es v\xE1lida. Usa "feature" o "layer".`)),process.exit(1)),t.world&&!go.includes(t.world)&&(console.error(j.red(`Error: el mundo "${t.world}" no es v\xE1lido. Usa "cliente", "crm" o "mixto".`)),process.exit(1)),t.world||console.warn(j.yellow('Aviso: sin --world; se asume "mixto". ')+j.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(j.blue("Modo automatizado detectado. Saltando interfaz interactiva..."))):o=await Ae(e),mo(`Nombre: ${o.projectName}
 Arquitectura: ${o.architecture}
-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(`
+Mundo: ${o.world}`,"Configuraci\xF3n de Proyecto");let n=yo();n.start("Construyendo tu proyecto...");let r=process.cwd();try{await Ue(o,r)}catch(i){throw n.stop(j.red("No se pudo crear el proyecto.")),i}t.install!==!1&&(n.message("Instalando dependencias base..."),await xo(r)),n.stop("\xA1Proyecto construido con \xE9xito!"),uo(j.green(`Todo listo en el directorio actual
+
+`)+j.dim(`Siguientes pasos:
+`)+j.cyan(`  pnpm dev
+`)+j.cyan("  npx create-lexy add button"))};import vo from"fs/promises";import ho from"path";import S from"picocolors";import me from"picocolors";var V=(e,t)=>{let o=e.split(`
+`),a=t.split(`
+`),n=o.length,r=a.length,i=Array.from({length:n+1},()=>new Array(r+1).fill(0));for(let m=n-1;m>=0;m--)for(let y=r-1;y>=0;y--)i[m][y]=o[m]===a[y]?i[m+1][y+1]+1:Math.max(i[m+1][y],i[m][y+1]);let d=[],s=0,u=0;for(;s<n&&u<r;)o[s]===a[u]?(d.push({type:"same",text:o[s]}),s++,u++):i[s+1][u]>=i[s][u+1]?d.push({type:"del",text:o[s++]}):d.push({type:"add",text:a[u++]});for(;s<n;)d.push({type:"del",text:o[s++]});for(;u<r;)d.push({type:"add",text:a[u++]});return d},Y=e=>e.some(t=>t.type!=="same"),Be=(e,t=3)=>{if(!Y(e))return null;let o=new Array(e.length).fill(!1);e.forEach((r,i)=>{if(r.type!=="same")for(let d=Math.max(0,i-t);d<=Math.min(e.length-1,i+t);d++)o[d]=!0});let a=[],n=!1;for(let r=0;r<e.length;r++){if(!o[r]){n||(a.push(me.dim("  \u22EF")),n=!0);continue}n=!1;let i=e[r];i.type==="same"?a.push(`  ${i.text}`):i.type==="del"?a.push(me.red(`- ${i.text}`)):a.push(me.green(`+ ${i.text}`))}return a.join(`
+`)};var Je=async e=>{let t=process.cwd(),o=await O(t),a=e.toLowerCase(),{item:n,version:r}=await k(a),i=o.installed[a];console.log(S.bold(`
+${n.title??a}`)+S.dim(` \xB7 instalado con registry@${i??"?"} \xB7 vigente registry@${r}
+`));let d=!1;for(let s of T(n,o)){let u=await vo.readFile(ho.join(t,s.relPath),s.encoding??"utf-8").catch(()=>null);if(u===null){console.log(S.red(`\u2717 ${s.relPath} no existe localmente`)+S.dim(` \u2014 cr\xE9alo con \`create-lexy add ${a}\``)),d=!0;continue}if(s.encoding==="base64"){u===s.content?console.log(S.green(`\u2713 ${s.relPath}`)+S.dim(" sin diferencias")):(d=!0,console.log(S.yellow(`\xB1 ${s.relPath}`)+S.dim(" (binario difiere del registry)")));continue}let m=Be(V(u,s.content));m===null?console.log(S.green(`\u2713 ${s.relPath}`)+S.dim(" sin diferencias")):(d=!0,console.log(S.yellow(`\xB1 ${s.relPath}`)+S.dim(" (\u2212 local \xB7 + registry)")),console.log(m))}d&&(process.exitCode=1)};import _ from"fs/promises";import v from"path";import C from"picocolors";var We=async e=>{let t=process.cwd(),o=0,a=c=>console.log(C.green("  \u2713 ")+c),n=c=>console.log(C.yellow("  \u2022 ")+c),r=(c,l)=>{o=1,console.log(C.red("  \u2717 ")+c),l&&console.log(C.dim(`      \u2192 ${l}`))};console.log(C.bold(`
 Diagn\xF3stico del proyecto Lexy
-`));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(`
+`));let i;try{i=await O(t),a(`.lexy v\xE1lido (arquitectura ${i.architecture}${i.world?`, mundo ${i.world}`:""})`)}catch(c){return r(c.message),1}await _.access(v.join(t,"src/lexy-theme.css")).then(()=>!0,()=>!1)?a("theme presente (src/lexy-theme.css)"):r("falta src/lexy-theme.css","re-cr\xE9alo desde un proyecto nuevo o copia el theme del registry");let s=v.join(i.paths.lib,"utils/cn.ts");await _.access(v.join(t,s)).then(()=>!0,()=>!1)?a(`helper cn presente (${s})`):r(`falta el helper cn (${s})`);let m=await _.readFile(v.join(t,"package.json"),"utf-8").then(c=>JSON.parse(c)).catch(()=>null),y=async(c,l)=>{await _.access(v.join(t,c)).then(()=>!0,()=>!1)?a(`${l} presente (${c})`):r(`falta ${l} (${c})`)},z=(c,l)=>{if(!m){r("package.json no se pudo leer para validar scripts del prototipo");return}let g=m.scripts?.[c];if(!g){r(`falta el script ${c} en package.json`,l?`agrega \`${l}\``:void 0);return}if(l&&!g.includes(l)){r(`el script ${c} no ejecuta ${l}`);return}a(`script ${c} configurado`)};if(!i.prototype)n("prototipo funcional no habilitado \u2014 proyecto anterior al runtime de datos y ports");else{let c=i.prototype.dataContractPath;if(!c)n("contrato de datos no configurado \u2014 proyecto anterior a la Spec 1");else{await y(c,"contrato de datos");let l=v.join(v.dirname(c),"data-contract-schema.ts");await y(l,"schema del contrato"),await y("scripts/check-data-contract.ts","validador del contrato"),z("check:data-contract","tsx scripts/check-data-contract.ts")}i.prototype.runtimeVersion?(i.prototype.mockStorePath?(await y(i.prototype.mockStorePath,"mock-store del prototipo"),await y(v.join(v.dirname(i.prototype.mockStorePath),"fixtures.ts"),"fixtures del prototipo")):r("mockStorePath no est\xE1 configurado en .lexy"),i.prototype.portsPath?await y(i.prototype.portsPath,"ports del prototipo"):r("portsPath no est\xE1 configurado en .lexy")):n("runtime del prototipo no habilitado \u2014 proyecto anterior a la Spec 2"),i.prototype.designerPanelVersion?(i.prototype.designerPanelPath?await y(i.prototype.designerPanelPath,"panel de asistencia al Designer"):r("designerPanelPath no est\xE1 configurado en .lexy"),i.prototype.designerActivityStorePath?await y(i.prototype.designerActivityStorePath,"store de actividad del Designer"):r("designerActivityStorePath no est\xE1 configurado en .lexy")):n("panel de asistencia al Designer no habilitado \u2014 proyecto anterior a la Spec 4")}let M=v.join(t,"ai/lexy-ai-manifest.json"),p=await _.readFile(M,"utf-8").catch(()=>null);if(p===null)console.log(C.dim("  \xB7 capa de IA no instalada (npx @lexydesign/ai install) \u2014 opcional"));else try{let c=JSON.parse(p),l=c.files??[],g=[];for(let P of l)await _.access(v.join(t,P)).then(()=>!0,()=>!1)||g.push(P);g.length>0?r(`capa de IA ${c.aiVersion??"?"} incompleta \u2014 faltan ${g.length} archivo(s) (${g.slice(0,3).join(", ")}${g.length>3?", \u2026":""})`,"npx @lexydesign/ai install"):a(`capa de IA ${c.aiVersion??"?"} completa (${l.length} archivos)`)}catch{r("ai/lexy-ai-manifest.json no es JSON v\xE1lido","regenera con `npx @lexydesign/ai install`")}let f=Object.entries(i.installed);if(f.length===0)console.log(C.dim(`
+  Sin componentes instalados a\xFAn (create-lexy add <nombre>).`));else{let c=await W();console.log(C.bold(`
+Componentes instalados (registry vigente: ${c})
+`));for(let[l,g]of f){let P;try{P=await k(l)}catch(L){r(`${l}: ${L.message}`);continue}let U=T(P.item,i),x=[],A=!1;for(let L of U){let H=await _.readFile(v.join(t,L.relPath),"utf-8").catch(()=>null);H===null?x.push(L.relPath):Y(V(H,L.content))&&(A=!0)}if(x.length>0){r(`${l}: archivos faltantes (${x.join(", ")})`,`create-lexy add ${l}`);continue}if(!A){a(`${l} al d\xEDa (${P.version})`);continue}let ee=!0;if(g&&g!==P.version)try{let L=await k(l,g),H=T(L.item,i);ee=!1;for(let he of H){let be=await _.readFile(v.join(t,he.relPath),"utf-8").catch(()=>null);(be===null||Y(V(be,he.content)))&&(ee=!0)}}catch{}ee?e.strict?r(`${l}: editado localmente (difiere del registry vigente)`,`create-lexy diff ${l}`):n(`${l}: editado localmente \u2014 divergencia deliberada (m\xEDrala con \`create-lexy diff ${l}\`)`):r(`${l}: desactualizado (instalado con ${g}, vigente ${P.version})`,`create-lexy diff ${l} \xB7 create-lexy add ${l} --overwrite`)}}return console.log(o===0?C.green(`
 Todo en orden.
-`):k.red(`
+`):C.red(`
 Hay problemas que atender (exit 1).
-`)),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
+`)),o};import ue from"fs/promises";import Ge from"path";import{note as bo,outro as wo}from"@clack/prompts";import ye from"picocolors";var X="LEXY-KICKOFF.md",So=`# 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
@@ -2733,34 +2659,36 @@ npx @lexydesign/ai install
    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
+3. Mant\xE9n los datos mock en
+   \`src/prototype/mock-store/fixtures.ts\`, nunca dentro de componentes. Las
+   pantallas leen con \`read.load(loadId, params, meta)\` y publican hechos con
+   \`write.publish(eventId, payload, meta)\`, importados desde
+   \`src/prototype/ports\`. La metadata inline (\`reads\`/\`writes\`,
+   \`description\`, \`trigger\`) alimenta el panel del Designer. No registres
+   interacciones puramente locales.
+4. 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.
+\`PROJECT-CONTEXT.md\` es el resumen humano. El contrato de datos TypeScript es la
+fuente estructurada para las pr\xF3ximas sesiones. El mock-store mantiene datos
+coherentes y persistentes; los ports separan el adapter mock del adapter de
+producci\xF3n; el panel registra cargas y publicaciones para inspecci\xF3n.
 
 ## 5. Cerrar
 
-Borra este archivo (\`${Y}\`): su trabajo termin\xF3. Conf\xEDrmale a la
+Borra este archivo (\`${X}\`): 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?").
-`,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: `+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(`
+`,Qe=async e=>{let t=process.cwd();for(let n of["package.json",".lexy"])if(await ue.access(Ge.join(t,n)).then(()=>!0,()=>!1))throw new Error(`El directorio actual ya contiene un proyecto (${n}). \`kickoff\` es para empezar de cero en una carpeta vac\xEDa.`);let o=Ge.join(t,X);if(await ue.access(o).then(()=>!0,()=>!1)&&!e.force)throw new Error(`${X} ya existe. Usa --force para regenerarlo.`);await ue.writeFile(o,So),bo(`Se cre\xF3 ${ye.cyan(X)} en esta carpeta.
+
+Abre la carpeta con Claude Code y di: `+ye.bold("\xABay\xFAdame a arrancar mi proyecto Lexy\xBB")+`.
+El agente te entrevistar\xE1 y montar\xE1 el proyecto por ti.`,"Kickoff listo"),wo(ye.green("Sin flags, sin prompts t\xE9cnicos \u2014 solo conversa con el agente."))};import fe from"fs/promises";import Z from"path";import I from"picocolors";var xe="@lexydesign/kit",Ye=`https://cdn.jsdelivr.net/npm/${xe}`,Xe=8e3,ge=async e=>{let t=await fetch(e,{signal:AbortSignal.timeout(Xe)});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())},ko=async()=>{try{let t=await fetch(`https://registry.npmjs.org/${xe}/latest`,{signal:AbortSignal.timeout(Xe)});if(t.ok)return(await t.json()).version}catch{}return JSON.parse((await ge(`${Ye}@latest/package.json`)).toString("utf-8")).version},Ze=async e=>{let t=process.cwd(),o=Z.resolve(t,e.dir??"lexy-kit"),a=Z.relative(t,o)||".";if(await fe.access(o).then(()=>!0).catch(()=>!1)&&!e.force)throw new Error(`Ya existe ${I.bold(a)}. Usa ${I.cyan("--force")} para sobrescribir o ${I.cyan("--dir <ruta>")} para otra carpeta.`);let r=await ko();console.log(I.dim(`
+Trayendo ${xe}@${r} \u2192 ${a}/
+`));let i=`${Ye}@${r}/kit`,d=JSON.parse((await ge(`${i}/manifest.json`)).toString("utf-8")),s=["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",...d.guides?.pautas??[],...d.components.map(m=>m.file),...d.blocks.map(m=>m.file)],u=0;for(let m of s)try{let y=await ge(`${i}/${m}`),z=Z.join(o,m);await fe.mkdir(Z.dirname(z),{recursive:!0}),await fe.writeFile(z,y),u+=1}catch(y){console.warn(I.yellow(`\u26A0 no se pudo traer ${m}`)+I.dim(` (${y.message})`))}console.log(I.green("\u2713 Kit listo")+I.dim(` \u2014 ${u} archivo(s), ${d.components.length} componente(s) + ${d.blocks.length} block(s)
+`)),console.log(`  Abre ${I.bold(`${a}/index.html`)} en el navegador.`),console.log(I.dim(`  El cat\xE1logo m\xE1quina-legible est\xE1 en ${a}/manifest.json.
+`))};import Eo from"fs/promises";import ve from"path";import E from"picocolors";var K=e=>console.log(E.bold(E.cyan(`
 \u2500\u2500 ${e} \u2500\u2500
-`))),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);
+`))),et=async(e,t)=>{if(t.list||!e){let{index:i,version:d,source:s}=await je();K(`Cat\xE1logo Lexy \xB7 @lexydesign/registry@${d}${s==="bundle"?" (bundle local)":""}`);for(let u of i.items)console.log(`  ${E.bold(u.name.padEnd(20))} ${E.dim(u.description??"")}`);console.log(E.dim(`
+  ${i.items.length} componente(s). Instala con: create-lexy add <nombre>`));return}let o=e.toLowerCase();if(t.installed){let i=process.cwd(),d=await O(i),s=d.installed[o];if(!s){console.error(E.red(`"${o}" no figura como instalado en .lexy. Inst\xE1lalo con \`create-lexy add ${o}\`.`)),process.exitCode=1;return}let{item:u}=await k(o,s).catch(()=>k(o));K(`${u.title??o} \xB7 copia local (instalado con registry@${s})`);for(let m of T(u,d)){let y=await Eo.readFile(ve.join(i,m.relPath),"utf-8").catch(()=>null);K(y===null?`${m.relPath} (FALTANTE)`:m.relPath),y!==null&&console.log(y)}return}let{item:a,version:n,source:r}=await k(o);K(`${a.title??a.name} \xB7 @lexydesign/registry@${n}${r==="bundle"?" (bundle local)":""}`),a.description&&console.log(a.description+`
+`),console.log(E.dim("tipo:           ")+a.type),console.log(E.dim("deps npm:       ")+((a.dependencies??[]).join(", ")||"\u2014")),console.log(E.dim("deps registry:  ")+((a.registryDependencies??[]).join(", ")||"\u2014")),console.log(E.dim("archivos:       ")+a.files.map(i=>ve.posix.basename(i.path)).join(", ")),console.log(E.dim("instalar:       ")+`create-lexy add ${a.name}`);for(let i of a.files)typeof i.content=="string"&&(K(ve.posix.basename(i.path)),console.log(i.content))};var To=tt.dirname(jo(import.meta.url)),Ro=JSON.parse(Po(tt.join(To,"../package.json"),"utf-8")),N=new Co,D=e=>async()=>{try{await e()}catch(t){console.error(Io.red(`
+Error: `)+t.message),process.exit(1)}};N.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(Ro.version);N.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)=>D(()=>He(e,t))());N.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=>D(()=>Qe(e))());N.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)=>D(()=>Re(e,t))());N.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)=>D(()=>et(e,t))());N.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=>D(()=>Ze(e))());N.command("diff").description("Copia local vs versi\xF3n vigente del registry (exit 1 si hay diferencias)").argument("<component>","Nombre en el registry").action(e=>D(()=>Je(e))());N.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=>D(async()=>{process.exitCode=await We(e)})());N.parse(process.argv);