create-lexy 0.5.1 → 0.6.1

package/dist/index.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import{readFileSync as At}from"fs";import Me from"path";import{fileURLToPath as Nt}from"url";import{Command as Mt}from"commander";import Dt from"picocolors";import{spawn as Je}from"child_process";import G from"fs/promises";import B from"path";import{confirm as Ke,isCancel as Be,spinner as xe}from"@clack/prompts";import h from"picocolors";import Q from"path";var De=(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/'),_e=[["components/base/",e=>e.paths.components],["views/",e=>e.paths.views],["hooks/",e=>e.paths.hooks],["lib/",e=>e.paths.lib]],P=(e,t)=>e.files.filter(o=>typeof o.content=="string").map(o=>{let r=_e.find(([s])=>o.path.startsWith(s));return{relPath:r?Q.posix.join(r[1](t),o.path.slice(r[0].length)):Q.posix.join(t.paths.components,Q.posix.basename(o.path)),content:De(o.content,t)}});import de from"fs/promises";import qe from"path";var me=e=>qe.join(e,".lexy"),S=async e=>{let t;try{t=await de.readFile(me(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},ue=async(e,t)=>{await de.writeFile(me(e),JSON.stringify(t,null,2)+`
-`)};import q from"fs/promises";import Ve from"os";import E from"path";import{fileURLToPath as ze}from"url";var fe="@lexydesign/registry",M=`https://cdn.jsdelivr.net/npm/${fe}`,He=8e3,J=E.resolve(E.dirname(ze(import.meta.url)),"../assets"),Ue=E.join(Ve.homedir(),".cache","create-lexy","registry"),U=async e=>{let t=await fetch(e,{signal:AbortSignal.timeout(He)});if(!t.ok){let o=new Error(`HTTP ${t.status} al pedir ${e}`);throw o.status=t.status,o}return await t.json()},ge=async e=>{try{return JSON.parse(await q.readFile(E.join(J,"r",e),"utf-8"))}catch{return null}},Z=async()=>{try{return(await q.readFile(E.join(J,"registry-version"),"utf-8")).trim()}catch{return"bundle"}},N=null,K=async()=>{if(N)return N;try{N=(await U(`https://registry.npmjs.org/${fe}/latest`)).version}catch{try{N=(await U(`${M}@latest/package.json`)).version}catch{N=await Z()}}return N},w=async(e,t)=>{let o=e.replace(/^@lexy\//,""),r=t??await K(),n=E.join(Ue,r,`${o}.json`);try{return{item:JSON.parse(await q.readFile(n,"utf-8")),version:r,source:"cache"}}catch{}try{let s=await U(`${M}@${r}/r/${o}.json`);return await q.mkdir(E.dirname(n),{recursive:!0}),await q.writeFile(n,JSON.stringify(s)),{item:s,version:r,source:"cdn"}}catch(s){if(s.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 i=await ge(`${o}.json`);if(i)return{item:i,version:await Z(),source:"bundle"};throw new Error(`No se pudo alcanzar el registry (\xBFsin red?) y "${o}" tampoco est\xE1 en el bundle local del CLI.`)}},ye=async()=>{try{let e=await K();return{index:await U(`${M}@${e}/r/registry.json`),version:e,source:"cdn"}}catch{let e=await ge("registry.json");if(e)return{index:e,version:await Z(),source:"bundle"};throw new Error("No se pudo alcanzar el registry ni leer el bundle local del CLI.")}},he=E.join(J,"theme/lexy-theme.css"),we=E.join(J,"fonts");var Ge=(e,t)=>new Promise((o,r)=>{Je("pnpm",["add",...e],{cwd:t,stdio:"ignore",shell:!0}).on("close",s=>s===0?o():r(new Error(`pnpm add fall\xF3 con c\xF3digo ${s}`)))}),We=async e=>{try{return await G.readFile(e,"utf-8")}catch{return null}},be=async(e,t)=>{let o=process.cwd(),r=await S(o),n=xe();n.start("Resolviendo componentes en el registry...");let s=new Map,i=async a=>{let p=a.toLowerCase().replace(/^@lexy\//,"");if(s.has(p))return;let g=await w(p);s.set(p,g);for(let b of g.item.registryDependencies??[])await i(b)};try{for(let a of e)await i(a)}catch(a){throw n.stop(h.red("No se pudo resolver el pedido.")),a}let l=new Map;for(let[a,{item:p}]of s){let g=[];for(let b of P(p,r)){let T=await We(B.join(o,b.relPath));g.push({...b,status:T===null?"new":T===b.content?"same":"differs"})}l.set(a,g)}let c=Array.from(l.values()).flat().filter(a=>a.status==="differs");if(n.stop(`Resueltos: ${Array.from(s.keys()).join(", ")}`),c.length>0&&!t.overwrite){let a=c.map(p=>`  ${p.relPath}`).join(`
-`);if(process.stdout.isTTY&&process.stdin.isTTY){let p=await Ke({message:`Estos archivos existen con cambios locales y ser\xE1n sobrescritos:
-${a}
-\xBFContinuar?`});if(Be(p)||p!==!0){console.log(h.yellow("Operaci\xF3n cancelada \u2014 nada fue modificado.")),process.exitCode=1;return}}else{console.error(h.red(`Estos archivos existen con cambios locales:
-`)+a+h.dim(`
-Usa --overwrite para sobrescribirlos.`)),process.exitCode=1;return}}for(let[a,p]of l){let{item:g,version:b,source:T}=s.get(a);for(let y of p){if(y.status==="same")continue;let C=B.join(o,y.relPath);await G.mkdir(B.dirname(C),{recursive:!0}),await G.writeFile(C,y.content)}r.installed[g.name]=b;let H=e.map(y=>y.toLowerCase()).includes(a)?"":h.dim(" (dependencia)"),_=T==="bundle"?h.yellow(" [bundle local \u2014 sin red]"):"";console.log(h.green(`${h.bold(g.title??g.name)} instalado`)+H+h.cyan(` \u2192 ${r.paths.components}/`)+_);for(let y of p){let C=y.status==="same"?h.dim(" (sin cambios)"):"";console.log(h.dim(`   ${y.relPath}${C}`))}}await ue(o,r);let m=new Set;for(let{item:a}of s.values())for(let p of a.dependencies??[])m.add(p);let d=JSON.parse(await G.readFile(B.join(o,"package.json"),"utf-8")),u={...d.dependencies,...d.devDependencies},R=a=>{let p=a.lastIndexOf("@");return p>0?a.slice(0,p):a},f=Array.from(m).filter(a=>!u[R(a)]);if(f.length>0)if(t.install===!1)console.log(h.yellow(`Dependencias pendientes (inst\xE1lalas t\xFA): ${f.join(", ")}`));else{let a=xe();a.start(`Instalando dependencias: ${f.join(", ")}...`),await Ge(f,o),a.stop("Dependencias instaladas.")}};import{spawn as vt}from"child_process";import{note as jt,outro as $t,spinner as Ct}from"@clack/prompts";import v from"picocolors";import{cancel as Ye,intro as Xe,isCancel as Qe,select as je,text as Ze}from"@clack/prompts";import $e from"picocolors";var ee=[{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"}],ve=e=>ee.find(t=>t.value===e).architecture;var et=`
+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,9 +20,2292 @@ Usa --overwrite para sobrescribirlos.`)),process.exitCode=1;return}}for(let[a,p]
    ...........:====:...........
       ......................
           ..............
-`,te=e=>{Qe(e)&&(Ye("Operaci\xF3n cancelada por el usuario."),process.exit(0))},Ce=async e=>{console.clear(),Xe(`${$e.cyan(et)}
-${$e.bold(" Bienvenido al generador de proyectos Lexy")}`);let t=e;if(!t){let n=await Ze({message:"\xBFCu\xE1l es el nombre de tu proyecto?",placeholder:"lexy-app",validate:s=>{if(!s||s.trim()==="")return"El nombre es obligatorio.";if(!/^(?:@[a-z0-9-*~][a-z0-9-*._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(s))return"El nombre debe estar en min\xFAsculas, sin espacios ni caracteres especiales."}});te(n),t=n}let o=await je({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"});te(o);let r=await je({message:"\xBFC\xF3mo es lo que vas a construir?",options:ee.map(n=>({label:n.label,value:n.value,hint:n.hint})),initialValue:"app"});return te(r),{projectName:t,architecture:ve(r),world:o}};import k from"fs/promises";import I from"path";var tt={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"]},ot="10.33.3",rt=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@${ot}`,scripts:{dev:"vite",build:"tsc -b && vite build",preview:"vite preview",lint:"eslint .",format:"prettier --write ."},dependencies:{clsx:"^2.1.1",react:"^19.2.6","react-dom":"^19.2.6",...t,"tailwind-merge":"^3.3.1"},devDependencies:{"@babel/core":"^7.29.7","@eslint/js":"^10.0.1","@rolldown/plugin-babel":"^0.2.3","@tailwindcss/vite":"^4.3.0","@types/babel__core":"^7.20.5","@types/node":"^24.12.3","@types/react":"^19.2.14","@types/react-dom":"^19.2.3","@vitejs/plugin-react":"^6.0.1","babel-plugin-react-compiler":"^1.0.0",eslint:"^10.4.1","eslint-plugin-jsx-a11y":"^6.10.2","eslint-plugin-react-hooks":"^7.1.1","eslint-plugin-simple-import-sort":"^13.0.0",globals:"^17.6.0",prettier:"^3.8.4",tailwindcss:"^4.3.0",terser:"^5.48.0",typescript:"~5.9.3","typescript-eslint":"^8.61.0",vite:"^8.0.12"}},null,2)+`
-`},nt=`import path from "node:path";
+`,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()
+  .regex(/^[a-z][a-zA-Z0-9]*$/, "Debe usar camelCase y comenzar con una letra minúscula.");
+
+const nonEmptyTextSchema = z.string().trim().min(1, "No puede quedar vacío.");
+const experienceLabelsSchema = z
+  .array(nonEmptyTextSchema)
+  .min(1, "Debe indicar al menos un uso dentro de la experiencia.");
+
+export const dataOriginSchema = z.enum([
+  "lexyConfirmed",
+  "productAssumption",
+  "generatedByUsability",
+]);
+
+export const technicalValidationStatusSchema = z.enum(["validated", "pendingTi", "rejected"]);
+
+export const dataClassificationSchema = z.enum(["public", "internal", "sensitive", "restricted"]);
+
+export const technicalValidationSchema = z
+  .object({
+    status: technicalValidationStatusSchema,
+    note: nonEmptyTextSchema.optional(),
+    validatedBy: nonEmptyTextSchema.optional(),
+    validatedAt: z.string().datetime({ offset: true }).optional(),
+    evidence: nonEmptyTextSchema.optional(),
+  })
+  .strict()
+  .superRefine((validation, context) => {
+    if (validation.status === "pendingTi" && !validation.note) {
+      context.addIssue({
+        code: "custom",
+        path: ["note"],
+        message: "Un pendiente de TI debe explicar qué necesita validarse.",
+      });
+    }
+
+    if (validation.status === "validated") {
+      if (!validation.validatedBy) {
+        context.addIssue({
+          code: "custom",
+          path: ["validatedBy"],
+          message: "Un dato validado debe indicar quién lo validó.",
+        });
+      }
+      if (!validation.validatedAt) {
+        context.addIssue({
+          code: "custom",
+          path: ["validatedAt"],
+          message: "Un dato validado debe indicar cuándo fue validado.",
+        });
+      }
+    }
+  });
+
+const backendReferenceSchema = z
+  .string()
+  .regex(
+    /^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)*$/,
+    "Las referencias de Lexy deben usar snake_case, por ejemplo cliente.rut_cliente.",
+  );
+
+export const sourceReferenceSchema = z
+  .object({
+    kind: z.enum(["lexyEntity", "lexyProjection", "api", "derived", "unknown"]),
+    reference: nonEmptyTextSchema.optional(),
+  })
+  .strict()
+  .superRefine((source, context) => {
+    if ((source.kind === "lexyEntity" || source.kind === "lexyProjection") && !source.reference) {
+      context.addIssue({
+        code: "custom",
+        path: ["reference"],
+        message: "La fuente Lexy debe indicar su referencia en snake_case.",
+      });
+      return;
+    }
+
+    if (source.reference && (source.kind === "lexyEntity" || source.kind === "lexyProjection")) {
+      const result = backendReferenceSchema.safeParse(source.reference);
+      if (!result.success) {
+        context.addIssue({
+          code: "custom",
+          path: ["reference"],
+          message: result.error.issues[0]?.message ?? "Referencia backend inválida.",
+        });
+      }
+    }
+  });
+
+const usageSchema = z
+  .object({
+    visible: z.boolean(),
+    editable: z.boolean(),
+    calculated: z.boolean(),
+    technical: z.boolean(),
+    filterable: z.boolean().optional(),
+    sortable: z.boolean().optional(),
+  })
+  .strict();
+
+const metadataSchema = z
+  .object({
+    origin: dataOriginSchema,
+    source: sourceReferenceSchema,
+    dataClassification: dataClassificationSchema,
+    technicalValidation: technicalValidationSchema,
+  })
+  .strict();
+
+const validateUsabilityEvidence = (
+  value: {
+    origin: z.infer<typeof dataOriginSchema>;
+    technicalValidation: z.infer<typeof technicalValidationSchema>;
+  },
+  context: z.RefinementCtx,
+) => {
+  if (
+    value.origin === "generatedByUsability" &&
+    value.technicalValidation.status === "validated" &&
+    !value.technicalValidation.evidence
+  ) {
+    context.addIssue({
+      code: "custom",
+      path: ["technicalValidation", "evidence"],
+      message: "Un dato generado por usabilidad solo puede validarse con evidencia explícita.",
+    });
+  }
+};
+
+export const fieldSpecSchema = z
+  .object({
+    id: camelCaseIdSchema,
+    productDescription: nonEmptyTextSchema,
+    dataType: z.enum(["string", "number", "boolean", "date", "datetime", "enum", "identifier"]),
+    required: z.boolean(),
+    usage: usageSchema,
+    usedIn: experienceLabelsSchema,
+    enumValues: z.array(nonEmptyTextSchema).min(1).optional(),
+    derivation: nonEmptyTextSchema.optional(),
+  })
+  .extend(metadataSchema.shape)
+  .strict()
+  .superRefine((field, context) => {
+    validateUsabilityEvidence(field, context);
+
+    if (field.dataType === "enum" && !field.enumValues) {
+      context.addIssue({
+        code: "custom",
+        path: ["enumValues"],
+        message: "Un campo enum debe declarar al menos un valor.",
+      });
+    }
+    if (field.dataType !== "enum" && field.enumValues) {
+      context.addIssue({
+        code: "custom",
+        path: ["enumValues"],
+        message: "Solo los campos enum pueden declarar enumValues.",
+      });
+    }
+    if ((field.usage.calculated || field.source.kind === "derived") && !field.derivation) {
+      context.addIssue({
+        code: "custom",
+        path: ["derivation"],
+        message: "Un dato calculado debe explicar su regla de derivación.",
+      });
+    }
+  });
+
+export const entityStateSpecSchema = z
+  .object({
+    id: camelCaseIdSchema,
+    productDescription: nonEmptyTextSchema,
+    activationCondition: nonEmptyTextSchema,
+    visualImpact: nonEmptyTextSchema,
+    usedIn: experienceLabelsSchema,
+  })
+  .extend(metadataSchema.shape)
+  .strict()
+  .superRefine(validateUsabilityEvidence);
+
+export const entitySpecSchema = z
+  .object({
+    id: camelCaseIdSchema,
+    productDescription: nonEmptyTextSchema,
+    roleInExperience: nonEmptyTextSchema,
+    usedIn: experienceLabelsSchema,
+    fields: z.record(camelCaseIdSchema, fieldSpecSchema),
+    states: z.array(entityStateSpecSchema).optional(),
+  })
+  .extend(metadataSchema.shape)
+  .strict()
+  .superRefine(validateUsabilityEvidence);
+
+export const relationSpecSchema = z
+  .object({
+    id: camelCaseIdSchema,
+    fromEntity: camelCaseIdSchema,
+    toEntity: camelCaseIdSchema,
+    cardinality: z.enum(["oneToOne", "oneToMany", "manyToMany"]),
+    productDescription: nonEmptyTextSchema,
+    requiredBy: experienceLabelsSchema,
+    resolution: z.enum(["embedded", "queried", "derived", "unknown"]),
+    derivation: nonEmptyTextSchema.optional(),
+  })
+  .extend(metadataSchema.shape)
+  .strict()
+  .superRefine((relation, context) => {
+    validateUsabilityEvidence(relation, context);
+    if (
+      (relation.resolution === "derived" || relation.source.kind === "derived") &&
+      !relation.derivation
+    ) {
+      context.addIssue({
+        code: "custom",
+        path: ["derivation"],
+        message: "Una relación derivada debe explicar su regla de derivación.",
+      });
+    }
+  });
+
+export const projectionFieldSpecSchema = z
+  .object({
+    id: camelCaseIdSchema,
+    source: z
+      .string()
+      .regex(
+        /^[a-z][a-zA-Z0-9]*\.[a-z][a-zA-Z0-9]*$/,
+        "Debe referenciar un campo como entidad.campo usando camelCase.",
+      ),
+    required: z.boolean(),
+  })
+  .strict();
+
+export const projectionSpecSchema = z
+  .object({
+    id: camelCaseIdSchema,
+    productDescription: nonEmptyTextSchema,
+    sourceEntities: experienceLabelsSchema,
+    consumedBy: experienceLabelsSchema,
+    fields: z.array(projectionFieldSpecSchema),
+    derivation: nonEmptyTextSchema.optional(),
+  })
+  .extend(metadataSchema.shape)
+  .strict()
+  .superRefine((projection, context) => {
+    validateUsabilityEvidence(projection, context);
+    if (projection.source.kind === "derived" && !projection.derivation) {
+      context.addIssue({
+        code: "custom",
+        path: ["derivation"],
+        message: "Una proyección derivada debe explicar su regla de derivación.",
+      });
+    }
+  });
+
+const projectSchema = z
+  .object({
+    name: nonEmptyTextSchema,
+    description: z.string().trim(),
+  })
+  .strict();
+
+export const prototypeDataContractSchema = z
+  .object({
+    contractVersion: z.literal("1"),
+    project: projectSchema,
+    entities: z.record(camelCaseIdSchema, entitySpecSchema),
+    relations: z.array(relationSpecSchema),
+    projections: z.record(camelCaseIdSchema, projectionSpecSchema),
+  })
+  .strict()
+  .superRefine((contract, context) => {
+    for (const [entityKey, entity] of Object.entries(contract.entities)) {
+      if (entityKey !== entity.id) {
+        context.addIssue({
+          code: "custom",
+          path: ["entities", entityKey, "id"],
+          message: 'El id "' + entity.id + '" debe coincidir con la key "' + entityKey + '".',
+        });
+      }
+
+      for (const [fieldKey, field] of Object.entries(entity.fields)) {
+        if (fieldKey !== field.id) {
+          context.addIssue({
+            code: "custom",
+            path: ["entities", entityKey, "fields", fieldKey, "id"],
+            message: 'El id "' + field.id + '" debe coincidir con la key "' + fieldKey + '".',
+          });
+        }
+      }
+
+      const stateIds = new Set<string>();
+      for (const [stateIndex, state] of (entity.states ?? []).entries()) {
+        if (stateIds.has(state.id)) {
+          context.addIssue({
+            code: "custom",
+            path: ["entities", entityKey, "states", stateIndex, "id"],
+            message: 'El estado "' + state.id + '" está declarado más de una vez.',
+          });
+        }
+        stateIds.add(state.id);
+      }
+    }
+
+    const relationIds = new Set<string>();
+    for (const [relationIndex, relation] of contract.relations.entries()) {
+      if (relationIds.has(relation.id)) {
+        context.addIssue({
+          code: "custom",
+          path: ["relations", relationIndex, "id"],
+          message: 'La relación "' + relation.id + '" está declarada más de una vez.',
+        });
+      }
+      relationIds.add(relation.id);
+
+      if (!contract.entities[relation.fromEntity]) {
+        context.addIssue({
+          code: "custom",
+          path: ["relations", relationIndex, "fromEntity"],
+          message: 'La entidad "' + relation.fromEntity + '" no existe.',
+        });
+      }
+      if (!contract.entities[relation.toEntity]) {
+        context.addIssue({
+          code: "custom",
+          path: ["relations", relationIndex, "toEntity"],
+          message: 'La entidad "' + relation.toEntity + '" no existe.',
+        });
+      }
+    }
+
+    for (const [projectionKey, projection] of Object.entries(contract.projections)) {
+      if (projectionKey !== projection.id) {
+        context.addIssue({
+          code: "custom",
+          path: ["projections", projectionKey, "id"],
+          message:
+            'El id "' + projection.id + '" debe coincidir con la key "' + projectionKey + '".',
+        });
+      }
+
+      for (const [sourceIndex, entityId] of projection.sourceEntities.entries()) {
+        if (!contract.entities[entityId]) {
+          context.addIssue({
+            code: "custom",
+            path: ["projections", projectionKey, "sourceEntities", sourceIndex],
+            message: 'La entidad "' + entityId + '" no existe.',
+          });
+        }
+      }
+
+      const projectionFieldIds = new Set<string>();
+      for (const [fieldIndex, field] of projection.fields.entries()) {
+        if (projectionFieldIds.has(field.id)) {
+          context.addIssue({
+            code: "custom",
+            path: ["projections", projectionKey, "fields", fieldIndex, "id"],
+            message: 'El campo proyectado "' + field.id + '" está declarado más de una vez.',
+          });
+        }
+        projectionFieldIds.add(field.id);
+
+        const [entityId, fieldId] = field.source.split(".");
+        const entity = contract.entities[entityId];
+        if (!entity) {
+          context.addIssue({
+            code: "custom",
+            path: ["projections", projectionKey, "fields", fieldIndex, "source"],
+            message: 'La referencia "' + field.source + '" apunta a una entidad que no existe.',
+          });
+          continue;
+        }
+        if (!entity.fields[fieldId]) {
+          context.addIssue({
+            code: "custom",
+            path: ["projections", projectionKey, "fields", fieldIndex, "source"],
+            message: 'La referencia "' + field.source + '" apunta a un campo que no existe.',
+          });
+        }
+        if (!projection.sourceEntities.includes(entityId)) {
+          context.addIssue({
+            code: "custom",
+            path: ["projections", projectionKey, "fields", fieldIndex, "source"],
+            message: 'La entidad "' + entityId + '" debe declararse también en sourceEntities.',
+          });
+        }
+      }
+    }
+  });
+
+export type DataOrigin = z.infer<typeof dataOriginSchema>;
+export type TechnicalValidationStatus = z.infer<typeof technicalValidationStatusSchema>;
+export type TechnicalValidation = z.infer<typeof technicalValidationSchema>;
+export type SourceReference = z.infer<typeof sourceReferenceSchema>;
+export type FieldSpec = z.infer<typeof fieldSpecSchema>;
+export type EntityStateSpec = z.infer<typeof entityStateSpecSchema>;
+export type EntitySpec = z.infer<typeof entitySpecSchema>;
+export type RelationSpec = z.infer<typeof relationSpecSchema>;
+export type ProjectionSpec = z.infer<typeof projectionSpecSchema>;
+export type PrototypeDataContract = z.infer<typeof prototypeDataContractSchema>;
+
+export function definePrototypeDataContract(
+  contract: PrototypeDataContract,
+): PrototypeDataContract {
+  return prototypeDataContractSchema.parse(contract);
+}
+`,St=String.raw`import { ZodError } from "zod";
+
+import { prototypeDataContractSchema } from "../src/prototype/data-contract/data-contract-schema";
+
+const formatPath = (path: PropertyKey[]) =>
+  path.length === 0 ? "contrato" : path.map(String).join(".");
+
+const printIssues = (error: ZodError) => {
+  console.error("✗ Contrato de datos inválido");
+  for (const issue of error.issues) {
+    console.error("  " + formatPath(issue.path));
+    console.error("  " + issue.message);
+  }
+};
+
+const countPendingValidations = (value: unknown): number => {
+  if (Array.isArray(value)) {
+    return value.reduce((total, item) => total + countPendingValidations(item), 0);
+  }
+  if (!value || typeof value !== "object") return 0;
+
+  const record = value as Record<string, unknown>;
+  const ownPending =
+    record.technicalValidation &&
+    typeof record.technicalValidation === "object" &&
+    (record.technicalValidation as Record<string, unknown>).status === "pendingTi"
+      ? 1
+      : 0;
+
+  return Object.values(record).reduce(
+    (total, item) => total + countPendingValidations(item),
+    ownPending,
+  );
+};
+
+try {
+  const module = await import("../src/prototype/data-contract/prototype-data-contract");
+  const result = prototypeDataContractSchema.safeParse(module.prototypeDataContract);
+
+  if (!result.success) {
+    printIssues(result.error);
+    process.exitCode = 1;
+  } else {
+    const contract = result.data;
+    console.log("✓ Contrato de datos válido");
+    console.log("  " + Object.keys(contract.entities).length + " entidades");
+    console.log("  " + contract.relations.length + " relaciones");
+    console.log("  " + Object.keys(contract.projections).length + " proyecciones");
+    console.log(
+      "  " + countPendingValidations(contract) + " elementos pendientes de validación con TI",
+    );
+  }
+} catch (error) {
+  if (error instanceof ZodError) {
+    printIssues(error);
+  } else {
+    console.error("✗ No se pudo cargar el contrato de datos");
+    console.error("  " + (error instanceof Error ? error.message : String(error)));
+  }
+  process.exitCode = 1;
+}
+`,kt=e=>`import { definePrototypeDataContract } from "./data-contract-schema";
+
+/**
+ * Fuente de verdad de los datos usados por el prototipo.
+ *
+ * El designer describe el producto en lenguaje natural; el agente mantiene este
+ * contrato y ejecuta \`pnpm check:data-contract\` antes de implementar la UI.
+ */
+export const prototypeDataContract = definePrototypeDataContract({
+  contractVersion: "1",
+  project: {
+    name: ${JSON.stringify(e)},
+    description: "",
+  },
+  entities: {},
+  relations: [],
+  projections: {},
+});
+`,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;
+  input?: unknown;
+};
+
+export type DesignerActivityRecord = {
+  id: string;
+  occurredAt: string;
+  kind: "load" | "event";
+  label: string;
+  technicalId?: string;
+  triggerId?: string;
+  inputPreview?: string;
+};
+
+export type DesignerActivityRecorder = {
+  record(input: DesignerActivityRecordInput): void;
+};
+
+export type DesignerActivityStore = DesignerActivityRecorder & {
+  getSnapshot(): readonly DesignerActivityRecord[];
+  subscribe(listener: () => void): () => void;
+  clear(): void;
+};
+
+const preview = (value: unknown): string | undefined => {
+  if (value === undefined) return undefined;
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return "[no serializable]";
+  }
+};
+
+const tabId = Math.random().toString(36).slice(2, 8);
+
+type ChannelMessage =
+  | { type: "record"; record: DesignerActivityRecord }
+  | { type: "clear" }
+  | { type: "syncRequest" }
+  | { type: "sync"; records: DesignerActivityRecord[] };
+
+export const createDesignerActivityStore = (maxItems = 80): DesignerActivityStore => {
+  const listeners = new Set<() => void>();
+  let records: DesignerActivityRecord[] = [];
+  let sequence = 0;
+  let synced = false;
+
+  const channel =
+    typeof BroadcastChannel !== "undefined"
+      ? new BroadcastChannel("lexy-designer-activity")
+      : null;
+
+  const notify = () => {
+    for (const listener of listeners) listener();
+  };
+
+  const addRecord = (record: DesignerActivityRecord) => {
+    records = [record, ...records].slice(0, maxItems);
+    notify();
+  };
+
+  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 {
+    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" });
+    },
+  };
+};
+
+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);
+}
+
+/* \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;
+}
+
+/* \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";
+
+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>;
+}
+
+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;
+  }
+};
+
+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>
+    );
+  }
+
+  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">
+          <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>
+  );
+}
+
+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";
+
+  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>
+  );
+}
+
+const DESIGNER_PANEL_ROUTE = "/designer-panel";
+
+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>
+  );
+}
+
+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);
+};
+
+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;
+
+  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 inferType = (value: unknown): string => {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+};
+
+const TYPE_COLORS: Record<string, string> = {
+  string: "var(--dp-success)",
+  number: "var(--dp-info)",
+  boolean: "var(--dp-warning)",
+};
+
+const TypeLabel = ({ value }: { value: unknown }) => (
+  <span className="lexy-dp-muted" style={{ marginLeft: "8px" }}>{inferType(value)}</span>
+);
+
+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" };
+
+  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 (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 (
+    <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>
+  );
+}
+
+function EventDetail({ event }: { event: CatalogEvent }) {
+  const [triggersOpen, setTriggersOpen] = useState(true);
+  const [payloadOpen, setPayloadOpen] = useState(true);
+
+  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;
+
+  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>
+
+      <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>
+  );
+}
+
+function LoadDetail({ load }: { load: CatalogLoad }) {
+  const [paramsOpen, setParamsOpen] = useState(true);
+  const params = load.lastParams;
+
+  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>
+
+      <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>
+  );
+}
+
+type SelectedContract =
+  | { kind: "event"; id: string }
+  | { kind: "load"; id: string }
+  | { kind: "entity"; id: string };
+
+type EntitySelectedItem =
+  | { kind: "field"; id: string }
+  | { kind: "relation"; id: string; reverse: boolean };
+
+function EntityDetail({ entityId }: { entityId: string }) {
+  const [fieldsOpen, setFieldsOpen] = useState(true);
+  const [selected, setSelected] = useState<EntitySelectedItem | null>(null);
+  const [itemDetailOpen, setItemDetailOpen] = useState(true);
+
+  const entries = useSyncExternalStore(
+    catalog.subscribe,
+    catalog.getSnapshot,
+    catalog.getSnapshot,
+  );
+
+  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);
+  };
+
+  const isSelected = (item: EntitySelectedItem) =>
+    selected?.kind === item.kind &&
+    selected.id === item.id &&
+    (item.kind !== "relation" || (selected as { reverse: boolean }).reverse === item.reverse);
+
+  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>
+
+      <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>
+  );
+}
+
+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>
+    );
+  }
+
+  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;
+
+  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>
+  );
+}
+
+type DesignerTab = "activity" | "events";
+
+export function DesignerPanelPage() {
+  const [tab, setTab] = useState<DesignerTab>("activity");
+
+  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 PrototypeMockState = {
+  datasetVersion: number;
+  entities: Record<string, MockEntityRecord[]>;
+  entitySequences: Record<string, number>;
+};
+
+export type MockStorage = {
+  read(): string | null;
+  write(value: string): void;
+  remove(): void;
+};
+
+export type PrototypeMockStore = {
+  getSnapshot(): PrototypeMockState;
+  subscribe(listener: () => void): () => void;
+  transact(operation: (draft: PrototypeMockState) => void): PrototypeMockState;
+  clearPersistence(): void;
+};
+
+const STORAGE_KEY = "lexy:prototype:mock-store:v1";
+
+const clone = <T>(value: T): T => {
+  if (typeof structuredClone === "function") return structuredClone(value);
+  return JSON.parse(JSON.stringify(value)) as T;
+};
+
+const buildSequences = (entities: Record<string, MockEntityRecord[]>) => {
+  const sequences: Record<string, number> = {};
+  for (const [entityId, records] of Object.entries(entities)) {
+    sequences[entityId] = records.length + 1;
+  }
+  return sequences;
+};
+
+const stateFromFixtures = (): PrototypeMockState => {
+  const entities = clone(fixtures.entities);
+  return {
+    datasetVersion: fixtures.datasetVersion,
+    entities,
+    entitySequences: buildSequences(entities),
+  };
+};
+
+const isCompatible = (value: unknown): value is PrototypeMockState => {
+  if (!value || typeof value !== "object") return false;
+  const state = value as Partial<PrototypeMockState>;
+  return (
+    state.datasetVersion === fixtures.datasetVersion &&
+    Boolean(state.entities && typeof state.entities === "object") &&
+    Boolean(state.entitySequences && typeof state.entitySequences === "object")
+  );
+};
+
+const createMemoryStorage = (): MockStorage => {
+  let current: string | null = null;
+  return {
+    read: () => current,
+    write: (value) => {
+      current = value;
+    },
+    remove: () => {
+      current = null;
+    },
+  };
+};
+
+const createLocalStorageStorage = (key: string): MockStorage => {
+  const memory = createMemoryStorage();
+  const getLocalStorage = () => {
+    try {
+      return globalThis.localStorage;
+    } catch {
+      return undefined;
+    }
+  };
+  return {
+    read: () => {
+      try {
+        return getLocalStorage()?.getItem(key) ?? memory.read();
+      } catch {
+        return memory.read();
+      }
+    },
+    write: (value) => {
+      memory.write(value);
+      try {
+        getLocalStorage()?.setItem(key, value);
+      } catch {
+        // fallback en memoria
+      }
+    },
+    remove: () => {
+      memory.remove();
+      try {
+        getLocalStorage()?.removeItem(key);
+      } catch {
+        // fallback en memoria
+      }
+    },
+  };
+};
+
+export const createPrototypeMockStore = (
+  storage: MockStorage = createLocalStorageStorage(STORAGE_KEY),
+): PrototypeMockStore => {
+  const listeners = new Set<() => void>();
+
+  const hydrate = (): PrototypeMockState => {
+    const persisted = storage.read();
+    if (!persisted) return stateFromFixtures();
+    try {
+      const parsed = JSON.parse(persisted) as unknown;
+      // Al cambiar fixtures se sube datasetVersion: el estado viejo se descarta.
+      if (isCompatible(parsed)) return parsed;
+    } catch {
+      // estado corrupto: reinicia desde fixtures
+    }
+    return stateFromFixtures();
+  };
+
+  let snapshot = hydrate();
+
+  const notify = () => {
+    for (const listener of listeners) listener();
+  };
+
+  return {
+    getSnapshot: () => snapshot,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    transact: (operation) => {
+      const draft = clone(snapshot);
+      operation(draft);
+      snapshot = draft;
+      storage.write(JSON.stringify(snapshot));
+      notify();
+      return snapshot;
+    },
+    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);
+`,_t=String.raw`import type { MockEntityRecord } from "./mock-store";
+
+export type Fixtures = {
+  datasetVersion: number;
+  entities: Record<string, MockEntityRecord[]>;
+};
+
+/**
+ * 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";
+
+/** 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();
+
+export type ReadMeta = z.infer<typeof readMetaSchema>;
+
+/** 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();
+
+export type WriteMeta = z.infer<typeof writeMetaSchema>;
+
+/** 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),
+});
+
+export type EventReceipt = z.infer<typeof eventReceiptSchema>;
+
+/** 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>;
+}
+
+/** 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 CatalogEvent = {
+  kind: "event";
+  technicalId: string;
+  description: string;
+  trigger: string;
+  writes: { entities: string[]; fields: string[] };
+  lastPayload: unknown;
+  lastReceipt: EventReceipt | null;
+};
+
+export type CatalogLoad = {
+  kind: "load";
+  technicalId: string;
+  description: string;
+  trigger: string;
+  reads: { entities: string[]; projections: string[] };
+  lastParams: unknown;
+};
+
+export type CatalogEntry = CatalogEvent | CatalogLoad;
+
+type CatalogMessage =
+  | { type: "entry"; entry: CatalogEntry }
+  | { type: "syncRequest" }
+  | { type: "sync"; entries: CatalogEntry[] };
+
+const createCatalog = () => {
+  const store = new Map<string, CatalogEntry>();
+  const listeners = new Set<() => void>();
+  let snapshot: CatalogEntry[] = [];
+  let synced = false;
+
+  const channel =
+    typeof BroadcastChannel !== "undefined" ? new BroadcastChannel("lexy-ports-catalog") : null;
+
+  const key = (entry: CatalogEntry) => entry.kind + ":" + entry.technicalId;
+
+  const notify = () => {
+    snapshot = Array.from(store.values());
+    for (const l of listeners) l();
+  };
+
+  const apply = (entry: CatalogEntry) => {
+    store.set(key(entry), entry);
+    notify();
+  };
+
+  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" });
+  }
+
+  const publishEntry = (entry: CatalogEntry) => {
+    store.set(key(entry), entry);
+    notify();
+    channel?.postMessage({ type: "entry", entry });
+  };
+
+  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,
+  };
+};
+
+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,
+      );
+    }
+    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,
+      );
+    }
+    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;
+      });
+    }
+
+    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";
+
+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.',
+    );
+  },
+};
+
+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";
@@ -50,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,
+        },
+      },
+    },
   },
 });
-`,st=`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";
@@ -81,14 +2385,14 @@ export default tseslint.config(
     },
   },
 );
-`,it=`{
+`,Wt=`{
   "printWidth": 100
 }
-`,at=`pnpm-lock.yaml
+`,Gt=`pnpm-lock.yaml
 src/lexy-theme.css
 public/fonts/
 dist/
-`,ct=`name: CI
+`,Qt=`name: CI
 
 on:
   push:
@@ -108,9 +2412,10 @@ jobs:
       - run: pnpm install --frozen-lockfile
       - run: pnpm lint
       - run: pnpm exec prettier --check .
-      - run: pnpm build
+      - run: pnpm check:data-contract
+      - run: pnpm build:app
       - run: pnpm audit --audit-level high
-`,lt=`{
+`,Yt=`{
   "files": [],
   "references": [{ "path": "./tsconfig.app.json" }, { "path": "./tsconfig.node.json" }],
   "compilerOptions": {
@@ -118,7 +2423,7 @@ jobs:
     "paths": { "@/*": ["./src/*"] }
   }
 }
-`,pt=`{
+`,Xt=`{
   "compilerOptions": {
     "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
     "target": "ES2022",
@@ -142,7 +2447,7 @@ jobs:
   },
   "include": ["src"]
 }
-`,dt=`{
+`,Zt=`{
   "compilerOptions": {
     "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
     "target": "ES2023",
@@ -159,7 +2464,7 @@ jobs:
   },
   "include": ["vite.config.ts"]
 }
-`,mt=e=>`<!doctype html>
+`,eo=e=>`<!doctype html>
 <html lang="es">
   <head>
     <meta charset="UTF-8" />
@@ -171,9 +2476,9 @@ jobs:
     <script type="module" src="/src/main.tsx"></script>
   </body>
 </html>
-`,ut=`@import "tailwindcss";
+`,to=`@import "tailwindcss";
 @import "./lexy-theme.css";
-`,ft=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";
@@ -200,76 +2505,91 @@ createRoot(document.getElementById("root")!).render(
     <App />
   </StrictMode>,
 );
-`,Pe=`    <main className="flex min-h-screen items-center justify-center bg-background text-foreground">
+`,Ke=`    <main className="flex min-h-screen items-center justify-center bg-background text-foreground">
       <div className="text-center">
         <h1 className="text-2xl font-semibold">Proyecto Lexy listo</h1>
         <p className="mt-2 text-sm text-muted-foreground">
           Trae tu primer componente: <code>npx create-lexy add button</code>
         </p>
       </div>
-    </main>`,gt=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 (
-${Pe}
+${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 (
-${Pe}
+    <>
+${Ke}
+      {showPrototypeDesignerPanel ? <PrototypeDesignerPanel /> : null}
+    </>
   );
 };
-`,yt=`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));
 }
-`,ht=`node_modules/
+`,ro=`node_modules/
 dist/
 *.log
 .env
-`,wt=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 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
 \`\`\`
-`,xt=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":`${M}@latest/r/{name}.json`}},null,2)+`
-`},bt=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:M},componentImportPattern:t?"@/shared/components/base/{Component}":"@/components/base/{Component}",paths:{components:t?"src/shared/components/base":"src/components/base",hooks:t?"src/shared/hooks":"src/hooks",services:t?"src/shared/services":"src/services",lib:t?"src/shared/lib":"src/lib",views:t?"src/features":"src/views"},installed:{}}},Ee=async(e,t)=>{let o=["package.json","src","index.html",".lexy"],r=[];for(let c of o)try{await k.access(I.join(t,c)),r.push(c)}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 c of tt[e.architecture])await k.mkdir(I.join(t,c),{recursive:!0});let n=(c,m)=>k.writeFile(I.join(t,c),m);await n("package.json",rt(e)),await n("vite.config.ts",nt),await n("tsconfig.json",lt),await n("tsconfig.app.json",pt),await n("tsconfig.node.json",dt),await n("eslint.config.js",st),await n(".prettierrc",it),await n(".prettierignore",at),await k.mkdir(I.join(t,".github/workflows"),{recursive:!0}),await n(".github/workflows/ci.yml",ct),await n("index.html",mt(e)),await n(".gitignore",ht),await n("README.md",wt(e)),await n("src/index.css",ut),await n("src/main.tsx",ft(e));let s=e.architecture==="feature"?"src/app":"src/views";await n(`${s}/App.tsx`,gt(e));let i=bt(e);await n(".lexy",JSON.stringify(i,null,2)+`
-`),await n("components.json",xt(e)),await k.copyFile(he,I.join(t,"src/lexy-theme.css")),await k.mkdir(I.join(t,"public/fonts"),{recursive:!0}),await k.cp(we,I.join(t,"public/fonts"),{recursive:!0});let l=I.join(t,i.paths.lib,"utils");await k.mkdir(l,{recursive:!0}),await k.writeFile(I.join(l,"cn.ts"),yt)};var Pt=["feature","layer"],Et=["cliente","crm","mixto"],kt=e=>new Promise((t,o)=>{vt("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}`)))}),ke=async(e,t)=>{let o;!!(e&&t.type)?(Pt.includes(t.type)||(console.error(v.red(`Error: la arquitectura "${t.type}" no es v\xE1lida. Usa "feature" o "layer".`)),process.exit(1)),t.world&&!Et.includes(t.world)&&(console.error(v.red(`Error: el mundo "${t.world}" no es v\xE1lido. Usa "cliente", "crm" o "mixto".`)),process.exit(1)),t.world||console.warn(v.yellow('Aviso: sin --world; se asume "mixto". ')+v.dim("Pasa --world cliente|crm para fijar densidad y voz desde el inicio.")),o={projectName:e,architecture:t.type,world:t.world??"mixto"},console.log(v.blue("Modo automatizado detectado. Saltando interfaz interactiva..."))):o=await Ce(e),jt(`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 n=Ct();n.start("Construyendo tu proyecto...");let s=process.cwd();try{await Ee(o,s)}catch(i){throw n.stop(v.red("No se pudo crear el proyecto.")),i}t.install!==!1&&(n.message("Instalando dependencias base..."),await kt(s)),n.stop("\xA1Proyecto construido con \xE9xito!"),$t(v.green(`Todo listo en el directorio actual
-
-`)+v.dim(`Siguientes pasos:
-`)+v.cyan(`  pnpm dev
-`)+v.cyan("  npx create-lexy add button"))};import It from"fs/promises";import Lt from"path";import F from"picocolors";import oe from"picocolors";var V=(e,t)=>{let o=e.split(`
-`),r=t.split(`
-`),n=o.length,s=r.length,i=Array.from({length:n+1},()=>new Array(s+1).fill(0));for(let d=n-1;d>=0;d--)for(let u=s-1;u>=0;u--)i[d][u]=o[d]===r[u]?i[d+1][u+1]+1:Math.max(i[d+1][u],i[d][u+1]);let l=[],c=0,m=0;for(;c<n&&m<s;)o[c]===r[m]?(l.push({type:"same",text:o[c]}),c++,m++):i[c+1][m]>=i[c][m+1]?l.push({type:"del",text:o[c++]}):l.push({type:"add",text:r[m++]});for(;c<n;)l.push({type:"del",text:o[c++]});for(;m<s;)l.push({type:"add",text:r[m++]});return l},W=e=>e.some(t=>t.type!=="same"),Ie=(e,t=3)=>{if(!W(e))return null;let o=new Array(e.length).fill(!1);e.forEach((s,i)=>{if(s.type!=="same")for(let l=Math.max(0,i-t);l<=Math.min(e.length-1,i+t);l++)o[l]=!0});let r=[],n=!1;for(let s=0;s<e.length;s++){if(!o[s]){n||(r.push(oe.dim("  \u22EF")),n=!0);continue}n=!1;let i=e[s];i.type==="same"?r.push(`  ${i.text}`):i.type==="del"?r.push(oe.red(`- ${i.text}`)):r.push(oe.green(`+ ${i.text}`))}return r.join(`
-`)};var Le=async e=>{let t=process.cwd(),o=await S(t),r=e.toLowerCase(),{item:n,version:s}=await w(r),i=o.installed[r];console.log(F.bold(`
-${n.title??r}`)+F.dim(` \xB7 instalado con registry@${i??"?"} \xB7 vigente registry@${s}
-`));let l=!1;for(let c of P(n,o)){let m=await It.readFile(Lt.join(t,c.relPath),"utf-8").catch(()=>null);if(m===null){console.log(F.red(`\u2717 ${c.relPath} no existe localmente`)+F.dim(` \u2014 cr\xE9alo con \`create-lexy add ${r}\``)),l=!0;continue}let d=Ie(V(m,c.content));d===null?console.log(F.green(`\u2713 ${c.relPath}`)+F.dim(" sin diferencias")):(l=!0,console.log(F.yellow(`\xB1 ${c.relPath}`)+F.dim(" (\u2212 local \xB7 + registry)")),console.log(d))}l&&(process.exitCode=1)};import D from"fs/promises";import O from"path";import j from"picocolors";var Te=async e=>{let t=process.cwd(),o=0,r=f=>console.log(j.green("  \u2713 ")+f),n=f=>console.log(j.yellow("  \u2022 ")+f),s=(f,a)=>{o=1,console.log(j.red("  \u2717 ")+f),a&&console.log(j.dim(`      \u2192 ${a}`))};console.log(j.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 i;try{i=await S(t),r(`.lexy v\xE1lido (arquitectura ${i.architecture}${i.world?`, mundo ${i.world}`:""})`)}catch(f){return s(f.message),1}await D.access(O.join(t,"src/lexy-theme.css")).then(()=>!0,()=>!1)?r("theme presente (src/lexy-theme.css)"):s("falta src/lexy-theme.css","re-cr\xE9alo desde un proyecto nuevo o copia el theme del registry");let c=O.join(i.paths.lib,"utils/cn.ts");await D.access(O.join(t,c)).then(()=>!0,()=>!1)?r(`helper cn presente (${c})`):s(`falta el helper cn (${c})`);let d=O.join(t,"ai/lexy-ai-manifest.json"),u=await D.readFile(d,"utf-8").catch(()=>null);if(u===null)console.log(j.dim("  \xB7 capa de IA no instalada (npx @lexydesign/ai install) \u2014 opcional"));else try{let f=JSON.parse(u),a=f.files??[],p=[];for(let g of a)await D.access(O.join(t,g)).then(()=>!0,()=>!1)||p.push(g);p.length>0?s(`capa de IA ${f.aiVersion??"?"} incompleta \u2014 faltan ${p.length} archivo(s) (${p.slice(0,3).join(", ")}${p.length>3?", \u2026":""})`,"npx @lexydesign/ai install"):r(`capa de IA ${f.aiVersion??"?"} completa (${a.length} archivos)`)}catch{s("ai/lexy-ai-manifest.json no es JSON v\xE1lido","regenera con `npx @lexydesign/ai install`")}let R=Object.entries(i.installed);if(R.length===0)console.log(j.dim(`
-  Sin componentes instalados a\xFAn (create-lexy add <nombre>).`));else{let f=await K();console.log(j.bold(`
-Componentes instalados (registry vigente: ${f})
-`));for(let[a,p]of R){let g;try{g=await w(a)}catch(y){s(`${a}: ${y.message}`);continue}let b=P(g.item,i),T=[],H=!1;for(let y of b){let C=await D.readFile(O.join(t,y.relPath),"utf-8").catch(()=>null);C===null?T.push(y.relPath):W(V(C,y.content))&&(H=!0)}if(T.length>0){s(`${a}: archivos faltantes (${T.join(", ")})`,`create-lexy add ${a}`);continue}if(!H){r(`${a} al d\xEDa (${g.version})`);continue}let _=!0;if(p&&p!==g.version)try{let y=await w(a,p),C=P(y.item,i);_=!1;for(let le of C){let pe=await D.readFile(O.join(t,le.relPath),"utf-8").catch(()=>null);(pe===null||W(V(pe,le.content)))&&(_=!0)}}catch{}_?e.strict?s(`${a}: editado localmente (difiere del registry vigente)`,`create-lexy diff ${a}`):n(`${a}: editado localmente \u2014 divergencia deliberada (m\xEDrala con \`create-lexy diff ${a}\`)`):s(`${a}: desactualizado (instalado con ${p}, vigente ${g.version})`,`create-lexy diff ${a} \xB7 create-lexy add ${a} --overwrite`)}}return console.log(o===0?j.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.
-`):j.red(`
+`):C.red(`
 Hay problemas que atender (exit 1).
-`)),o};import re from"fs/promises";import Se from"path";import{note as Tt,outro as St}from"@clack/prompts";import ne from"picocolors";var Y="LEXY-KICKOFF.md",Ft=`# 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
@@ -291,8 +2611,20 @@ hazlas de a poco, repregunta y resume lo que entendiste. Cubre:
   dashboard, listados, vistas de detalle)?
 - **Pantallas y flujos clave** \u2014 \xBFqu\xE9 vistas importan y qu\xE9 hace la persona en
   cada una? \xBFC\xF3mo se mueve entre ellas?
-- **Datos y referencias** \u2014 \xBFqu\xE9 datos maneja? \xBFHay un Figma, capturas o un
-  producto de referencia que mande sobre composiciones gen\xE9ricas?
+- **Datos de la experiencia** \u2014 \xBFqu\xE9 objetos principales existen? \xBFQu\xE9 necesita
+  ver o modificar la persona? \xBFQu\xE9 relaciones necesita entender? \xBFQu\xE9 estados
+  cambian lo que aparece en pantalla? \xBFQu\xE9 supuestos todav\xEDa debe validar TI?
+- **Cargas de datos** \u2014 \xBFqu\xE9 informaci\xF3n debe llegar desde backend para cada
+  pantalla? \xBFQu\xE9 significa que una carga venga vac\xEDa? \xBFQu\xE9 errores o latencias
+  vale la pena poder probar?
+- **Eventos publicados** \u2014 \xBFqu\xE9 escrituras hace la interfaz? \xBFQu\xE9 hecho ocurri\xF3
+  cuando se publican? \xBFQu\xE9 entidad cambia visualmente despu\xE9s de ver "Evento
+  publicado"? \xBFQu\xE9 debe mantenerse intacto si falla?
+- **Datos mock y escenarios** \u2014 \xBFqu\xE9 situaciones reales debe representar el
+  prototipo? \xBFQu\xE9 casos l\xEDmite importan? \xBFQu\xE9 datos deben verse chilenos? \xBFQu\xE9
+  campos son sensibles aunque sean sint\xE9ticos?
+- **Referencias** \u2014 \xBFhay un Figma, capturas o un producto de referencia que
+  mande sobre composiciones gen\xE9ricas?
 
 ## 2. Traducir las respuestas a flags (no se lo muestres a la persona)
 
@@ -318,26 +2650,45 @@ npx @lexydesign/ai install
 
 ## 4. Volcar la entrevista en el brief vivo
 
-Abre \`ai/PROJECT-CONTEXT.md\` (lo cre\xF3 \`@lexydesign/ai install\`) y compl\xE9talo
-con lo que recopilaste: **qu\xE9 se construye**, **para qui\xE9n**, **pantallas y
-flujos clave**, **referencias** y **decisiones/restricciones** ya tomadas. Ese
-archivo es el plan inicial del proyecto y la memoria de las pr\xF3ximas sesiones.
+1. Abre \`ai/PROJECT-CONTEXT.md\` (lo cre\xF3 \`@lexydesign/ai install\`) y
+   compl\xE9talo con lo que recopilaste: **qu\xE9 se construye**, **para qui\xE9n**,
+   **pantallas y flujos clave**, un resumen de **datos principales**,
+   **referencias** y **decisiones/restricciones** ya tomadas.
+2. Traduce los objetos, datos, relaciones, estados y supuestos conversados a
+   \`src/prototype/data-contract/prototype-data-contract.ts\`. No inventes
+   backend: lo que nazca desde usabilidad queda como
+   \`origin: "generatedByUsability"\` y
+   \`technicalValidation.status: "pendingTi"\`.
+3. 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 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?").
-`,Fe=async e=>{let t=process.cwd();for(let n of["package.json",".lexy"])if(await re.access(Se.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=Se.join(t,Y);if(await re.access(o).then(()=>!0,()=>!1)&&!e.force)throw new Error(`${Y} ya existe. Usa --force para regenerarlo.`);await re.writeFile(o,Ft),Tt(`Se cre\xF3 ${ne.cyan(Y)} en esta carpeta.
-
-Abre la carpeta con Claude Code y di: `+ne.bold("\xABay\xFAdame a arrancar mi proyecto Lexy\xBB")+`.
-El agente te entrevistar\xE1 y montar\xE1 el proyecto por ti.`,"Kickoff listo"),St(ne.green("Sin flags, sin prompts t\xE9cnicos \u2014 solo conversa con el agente."))};import se from"fs/promises";import X from"path";import $ from"picocolors";var ae="@lexydesign/kit",Re=`https://cdn.jsdelivr.net/npm/${ae}`,Oe=8e3,ie=async e=>{let t=await fetch(e,{signal:AbortSignal.timeout(Oe)});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())},Rt=async()=>{try{let t=await fetch(`https://registry.npmjs.org/${ae}/latest`,{signal:AbortSignal.timeout(Oe)});if(t.ok)return(await t.json()).version}catch{}return JSON.parse((await ie(`${Re}@latest/package.json`)).toString("utf-8")).version},Ae=async e=>{let t=process.cwd(),o=X.resolve(t,e.dir??"lexy-kit"),r=X.relative(t,o)||".";if(await se.access(o).then(()=>!0).catch(()=>!1)&&!e.force)throw new Error(`Ya existe ${$.bold(r)}. Usa ${$.cyan("--force")} para sobrescribir o ${$.cyan("--dir <ruta>")} para otra carpeta.`);let s=await Rt();console.log($.dim(`
-Trayendo ${ae}@${s} \u2192 ${r}/
-`));let i=`${Re}@${s}/kit`,l=JSON.parse((await ie(`${i}/manifest.json`)).toString("utf-8")),c=["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",...l.guides?.pautas??[],...l.components.map(d=>d.file),...l.blocks.map(d=>d.file)],m=0;for(let d of c)try{let u=await ie(`${i}/${d}`),R=X.join(o,d);await se.mkdir(X.dirname(R),{recursive:!0}),await se.writeFile(R,u),m+=1}catch(u){console.warn($.yellow(`\u26A0 no se pudo traer ${d}`)+$.dim(` (${u.message})`))}console.log($.green("\u2713 Kit listo")+$.dim(` \u2014 ${m} archivo(s), ${l.components.length} componente(s) + ${l.blocks.length} block(s)
-`)),console.log(`  Abre ${$.bold(`${r}/index.html`)} en el navegador.`),console.log($.dim(`  El cat\xE1logo m\xE1quina-legible est\xE1 en ${r}/manifest.json.
-`))};import Ot from"fs/promises";import ce from"path";import x from"picocolors";var z=e=>console.log(x.bold(x.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
-`))),Ne=async(e,t)=>{if(t.list||!e){let{index:i,version:l,source:c}=await ye();z(`Cat\xE1logo Lexy \xB7 @lexydesign/registry@${l}${c==="bundle"?" (bundle local)":""}`);for(let m of i.items)console.log(`  ${x.bold(m.name.padEnd(20))} ${x.dim(m.description??"")}`);console.log(x.dim(`
-  ${i.items.length} componente(s). Instala con: create-lexy add <nombre>`));return}let o=e.toLowerCase();if(t.installed){let i=process.cwd(),l=await S(i),c=l.installed[o];if(!c){console.error(x.red(`"${o}" no figura como instalado en .lexy. Inst\xE1lalo con \`create-lexy add ${o}\`.`)),process.exitCode=1;return}let{item:m}=await w(o,c).catch(()=>w(o));z(`${m.title??o} \xB7 copia local (instalado con registry@${c})`);for(let d of P(m,l)){let u=await Ot.readFile(ce.join(i,d.relPath),"utf-8").catch(()=>null);z(u===null?`${d.relPath} (FALTANTE)`:d.relPath),u!==null&&console.log(u)}return}let{item:r,version:n,source:s}=await w(o);z(`${r.title??r.name} \xB7 @lexydesign/registry@${n}${s==="bundle"?" (bundle local)":""}`),r.description&&console.log(r.description+`
-`),console.log(x.dim("tipo:           ")+r.type),console.log(x.dim("deps npm:       ")+((r.dependencies??[]).join(", ")||"\u2014")),console.log(x.dim("deps registry:  ")+((r.registryDependencies??[]).join(", ")||"\u2014")),console.log(x.dim("archivos:       ")+r.files.map(i=>ce.posix.basename(i.path)).join(", ")),console.log(x.dim("instalar:       ")+`create-lexy add ${r.name}`);for(let i of r.files)typeof i.content=="string"&&(z(ce.posix.basename(i.path)),console.log(i.content))};var _t=Me.dirname(Nt(import.meta.url)),qt=JSON.parse(At(Me.join(_t,"../package.json"),"utf-8")),L=new Mt,A=e=>async()=>{try{await e()}catch(t){console.error(Dt.red(`
-Error: `)+t.message),process.exit(1)}};L.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(qt.version);L.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)=>A(()=>ke(e,t))());L.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=>A(()=>Fe(e))());L.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)=>A(()=>be(e,t))());L.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)=>A(()=>Ne(e,t))());L.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=>A(()=>Ae(e))());L.command("diff").description("Copia local vs versi\xF3n vigente del registry (exit 1 si hay diferencias)").argument("<component>","Nombre en el registry").action(e=>A(()=>Le(e))());L.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=>A(async()=>{process.exitCode=await Te(e)})());L.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);