Fix two examples

docs/development-rules/sections/front/2-configuracion-del-entorno.md

@@ -138,9 +138,7 @@ Pero en esta área nuestro equipo si tiene opiniones y acuerdos que modifican la
     // Exige `const` si la variable no se reasigna.
     "prefer-const": "error"
   }
-}
 ```
 
 ---
 [Anterior: Introducción](./1-introduccion.md) | [Volver al menú principal](../frontend-structure.md) | [Siguiente: Convenciones Generales](./3-convenciones-generales.md)
-

docs/development-rules/sections/front/4-buenas-practicas-en-typescript.md

@@ -80,7 +80,39 @@ El uso de literales es recomendado para un conjunto de valores fijos y acotados.
 
 ## Helpers y Tipos Utilitarios
 
-**`type guards`**: Hacer uso de estas funciones que validan y reducen el tipo de un valor. Suelen tener esta firma: `(myValue: unknown): myValue is Type`. Son cruciales para trabajar con datos que no tienen un tipo seguro.
+**Type Guards**: Son funciones especializadas que validan y refinan el tipo de un valor en tiempo de ejecución. Estas nos sirven para retener la info del tipo en la ejecución y tienen la firma característica `(myValue: unknown): myValue is Type`, donde el valor de retorno booleano determina si TypeScript debe tratar el valor como el tipo especificado. Son fundamentales para trabajar de forma segura con datos de origen incierto, como respuestas de APIs, entrada del usuario, o cualquier valor de tipo unknown o any
+
+```typescript
+interface DemonData {
+  name: string;
+  powerLevel: number;
+}
+
+// Type guards 
+function isCursedString(value: unknown): value is string {
+  return typeof value === 'string';
+}
+
+function isDemon(value: unknown): value is DemonData {
+  return typeof value === 'object' && 
+         value !== null &&
+         'name' in value && 
+         'powerLevel' in value;
+}
+
+// Implementacion de los type guards
+function summonEntity(entity: unknown) {
+  if (isCursedString(entity)) {
+    console.log(`Invocando: ${entity.toUpperCase()}`); // ✅ TypeScript sabe que es string
+  } else if (isDemon(entity)) {
+    console.log(`${entity.name} aparece con poder ${entity.powerLevel}`); // ✅ TypeScript sabe que es Demon
+  }
+}
+
+// ejecución
+summonEntity("BELZEBÚ"); // → "Invocando: BELZEBÚ"
+summonEntity({ name: "Asmodeo", powerLevel: 666 }); // → "Asmodeo aparece con poder 666"
+```
   
 **`Partial`, `Pick`, `Omit`, and shit...**: Los tipos utilitarios de TypeScript son poderosos. En lugar de crear un tipo nuevo cada vez que necesitas una variante de un tipo ya existente, usar utilitarios.
 

docs/development-rules/sections/front/5-buenas-practicas-en-react.md

@@ -28,7 +28,7 @@ const demonNames: Map<number, string> = new Map([
 ]);
 
 // 2. Declaracion del componente
-export default function MyComponent({ data }: MyComponentProps) {
+export function MyComponent({ data }: MyComponentProps) {
   // a. Hooks, constantes y callbacks memoizados
   const [myState, setMyState] = useState<string>("Some Shit");
   const myContext = useContext(theAppContext);