@icarusmx/creta 1.3.3 → 1.3.5

package/lib/data/lessons/lesson3-only-way.js

@@ -0,0 +1,349 @@
+export const LESSON_3_ONLY_WAY = {
+  id: 3,
+  title: 'LECCIÓN 3: Las solicitudes son la única forma de conseguir que un objeto lleve a cabo una operación',
+  subtitle: 'Enfoque práctico: Demostrar que NO hay alternativas a las solicitudes para ejecutar operaciones',
+  flow: [
+    {
+      lines: [
+        '\n💡 ¿Por qué ÚNICA forma?',
+        '- No puedes forzar a un objeto a ejecutar algo',
+        '- No puedes manipular directamente su estado interno',
+        '- Toda operación DEBE pasar por una solicitud',
+        '- El objeto decide si acepta o rechaza la solicitud'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver qué significa esto en la práctica...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '🛠️ EJERCICIO PRÁCTICO: Caja Fuerte Digital',
+        '==================================================',
+        '🎯 Vamos a demostrar por qué las solicitudes son la ÚNICA forma',
+        '\nSistema: Una caja fuerte que protege documentos importantes',
+        'Objeto: DigitalSafe'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver todas las formas que NO funcionan...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '❌ FORMAS QUE NO FUNCIONAN',
+        '===================================',
+        'Veamos todas las cosas que NO puedes hacer:',
+        '\n🚫 1. ACCESO DIRECTO A DATOS (Imposible)',
+        '// ❌ Esto NO funciona en objetos bien diseñados\n' +
+          'class DigitalSafe {\n' +
+          '  constructor() {\n' +
+          '    this.#documents = []     // PRIVADO\n' +
+          '    this.#isLocked = true    // PRIVADO\n' +
+          '    this.#password = "1234"  // PRIVADO\n' +
+          '  }\n' +
+          '}\n' +
+          '\n' +
+          'const safe = new DigitalSafe()\n' +
+          '// ❌ ERROR: No puedes acceder a datos privados\n' +
+          'console.log(safe.#documents)  // SyntaxError!\n' +
+          'safe.#isLocked = false        // SyntaxError!'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver más formas que no funcionan...',
+      type: 'pause'
+    },
+    {
+      lines: [
+        '\n🚫 2. MANIPULACIÓN EXTERNA (Imposible)',
+        '// ❌ No puedes forzar cambios desde afuera\n' +
+          'safe.documents = ["documento_falso.pdf"]  // undefined (no existe)\n' +
+          'safe.isLocked = false                     // undefined (no existe)\n' +
+          'safe.forceOpen()                          // TypeError: no es función\n' +
+          '\n' +
+          '// ❌ No puedes inyectar funciones\n' +
+          'safe.hackOpen = function() { this.#isLocked = false }  // No funciona'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver la última forma que no funciona...',
+      type: 'pause'
+    },
+    {
+      lines: [
+        '\n🚫 3. HERENCIA FORZADA (Violación de diseño)',
+        '// ❌ Incluso extendiendo la clase, no puedes saltarte las reglas\n' +
+          'class HackedSafe extends DigitalSafe {\n' +
+          '  forceOpen() {\n' +
+          '    // ❌ ERROR: No puedes acceder a campos privados del padre\n' +
+          '    this.#isLocked = false    // SyntaxError!\n' +
+          '    return this.#documents    // SyntaxError!\n' +
+          '  }\n' +
+          '}',
+        '\n💡 Observación clave:',
+        'El objeto está completamente protegido. No hay forma de',
+        'manipularlo externamente sin su consentimiento.'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver la ÚNICA forma que funciona...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '✅ LA ÚNICA FORMA: SOLICITUDES',
+        '========================================',
+        'Solo hay UNA manera de que el objeto ejecute operaciones:',
+        '\n🔑 IMPLEMENTACIÓN COMPLETA:',
+        'class DigitalSafe {\n' +
+          '  constructor() {\n' +
+          '    this.#documents = []\n' +
+          '    this.#isLocked = true\n' +
+          '    this.#password = "1234"\n' +
+          '    this.#attempts = 0\n' +
+          '    this.#maxAttempts = 3\n' +
+          '  }\n' +
+          '\n' +
+          '  // ✅ SOLICITUD: Intentar desbloquear\n' +
+          '  unlock(password) {\n' +
+          '    if (this.#attempts >= this.#maxAttempts) {\n' +
+          '      return { success: false, message: "Bloqueado por seguridad" }\n' +
+          '    }\n' +
+          '\n' +
+          '    if (password === this.#password) {\n' +
+          '      this.#isLocked = false\n' +
+          '      this.#attempts = 0\n' +
+          '      return { success: true, message: "Caja fuerte desbloqueada" }\n' +
+          '    } else {\n' +
+          '      this.#attempts++\n' +
+          '      return {\n' +
+          '        success: false,\n' +
+          '        message: `Contraseña incorrecta. Intentos restantes: ${this.#maxAttempts - this.#attempts}`\n' +
+          '      }\n' +
+          '    }\n' +
+          '  }\n' +
+          '\n' +
+          '  // ✅ SOLICITUD: Agregar documento\n' +
+          '  addDocument(document) {\n' +
+          '    if (this.#isLocked) {\n' +
+          '      return { success: false, message: "Caja fuerte bloqueada" }\n' +
+          '    }\n' +
+          '\n' +
+          '    this.#documents.push(document)\n' +
+          '    return { success: true, message: "Documento agregado" }\n' +
+          '  }\n' +
+          '\n' +
+          '  // ✅ SOLICITUD: Obtener documentos\n' +
+          '  getDocuments() {\n' +
+          '    if (this.#isLocked) {\n' +
+          '      return { success: false, message: "Caja fuerte bloqueada", documents: [] }\n' +
+          '    }\n' +
+          '\n' +
+          '    return { success: true, documents: [...this.#documents] }\n' +
+          '  }\n' +
+          '\n' +
+          '  // ✅ SOLICITUD: Bloquear\n' +
+          '  lock() {\n' +
+          '    this.#isLocked = true\n' +
+          '    return { success: true, message: "Caja fuerte bloqueada" }\n' +
+          '  }\n' +
+          '\n' +
+          '  // ✅ SOLICITUD: Consultar estado\n' +
+          '  getStatus() {\n' +
+          '    return {\n' +
+          '      isLocked: this.#isLocked,\n' +
+          '      documentsCount: this.#documents.length,\n' +
+          '      attemptsRemaining: this.#maxAttempts - this.#attempts\n' +
+          '    }\n' +
+          '  }\n' +
+          '}'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver por qué esto es la ÚNICA forma...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '🧠 EL OBJETO DECIDE',
+        '=========================',
+        'Observa que cada solicitud permite al objeto DECIDIR:',
+        '\n🔍 EJEMPLO 1: Solicitud aceptada',
+        'const safe = new DigitalSafe()\n' +
+          '\n' +
+          '// SOLICITUD: unlock con contraseña correcta\n' +
+          'const result = safe.unlock("1234")\n' +
+          'console.log(result)  // { success: true, message: "Caja fuerte desbloqueada" }\n' +
+          '\n' +
+          '// El OBJETO decidió aceptar la solicitud porque:\n' +
+          '// - La contraseña era correcta\n' +
+          '// - No se habían agotado los intentos'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver una solicitud rechazada...',
+      type: 'pause'
+    },
+    {
+      lines: [
+        '\n🚫 EJEMPLO 2: Solicitud rechazada',
+        '// SOLICITUD: addDocument sin desbloquear\n' +
+          'const result2 = safe.addDocument("documento_secreto.pdf")\n' +
+          'console.log(result2)  // { success: false, message: "Caja fuerte bloqueada" }\n' +
+          '\n' +
+          '// El OBJETO decidió rechazar la solicitud porque:\n' +
+          '// - La caja fuerte está bloqueada\n' +
+          '// - No cumple las condiciones internas'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver el control total del objeto...',
+      type: 'pause'
+    },
+    {
+      lines: [
+        '\n🛡️ EJEMPLO 3: Protección automática',
+        '// Intentos fallidos múltiples\n' +
+          'safe.unlock("wrong1")  // { success: false, message: "Contraseña incorrecta..." }\n' +
+          'safe.unlock("wrong2")  // { success: false, message: "Contraseña incorrecta..." }\n' +
+          'safe.unlock("wrong3")  // { success: false, message: "Contraseña incorrecta..." }\n' +
+          'safe.unlock("1234")    // { success: false, message: "Bloqueado por seguridad" }\n' +
+          '\n' +
+          '// El OBJETO decidió bloquearse completamente porque:\n' +
+          '// - Se agotaron los intentos permitidos\n' +
+          '// - Sus reglas internas de seguridad se activaron',
+        '\n💡 Punto clave:',
+        'Incluso con la contraseña correcta, el objeto puede rechazar',
+        'la solicitud si sus condiciones internas no se cumplen.'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para la demostración completa...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '🎭 DEMOSTRACIÓN: Flujo Completo',
+        '========================================',
+        'Veamos un flujo completo de solicitudes:',
+        '\n// Crear caja fuerte',
+        'const safe = new DigitalSafe()',
+        '',
+        '// 🔍 SOLICITUD: Consultar estado inicial',
+        'console.log(safe.getStatus())',
+        '// { isLocked: true, documentsCount: 0, attemptsRemaining: 3 }',
+        '',
+        '// 🚫 SOLICITUD: Intentar agregar documento (será rechazada)',
+        "safe.addDocument('mi_testamento.pdf')",
+        "// { success: false, message: 'Caja fuerte bloqueada' }",
+        '',
+        '// 🔑 SOLICITUD: Desbloquear',
+        "safe.unlock('1234')",
+        "// { success: true, message: 'Caja fuerte desbloqueada' }",
+        '',
+        '// ✅ SOLICITUD: Ahora sí agregar documento',
+        "safe.addDocument('mi_testamento.pdf')",
+        "// { success: true, message: 'Documento agregado' }",
+        '',
+        "safe.addDocument('contrato_importante.pdf')",
+        "// { success: true, message: 'Documento agregado' }"
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver la recuperación...',
+      type: 'pause'
+    },
+    {
+      lines: [
+        '\n// 📄 SOLICITUD: Recuperar documentos',
+        'const docs = safe.getDocuments()',
+        'console.log(docs)',
+        "// { success: true, documents: ['mi_testamento.pdf', 'contrato_importante.pdf'] }",
+        '',
+        '// 🔒 SOLICITUD: Bloquear nuevamente',
+        'safe.lock()',
+        "// { success: true, message: 'Caja fuerte bloqueada' }",
+        '',
+        '// 🚫 SOLICITUD: Intentar recuperar (será rechazada)',
+        'safe.getDocuments()',
+        "// { success: false, message: 'Caja fuerte bloqueada', documents: [] }",
+        '\n🎯 Observaciones finales:',
+        '• Cada operación requirió una SOLICITUD específica',
+        '• El objeto controló completamente qué solicitudes aceptar',
+        '• No hubo forma de saltarse este mecanismo',
+        '• Las solicitudes son verdaderamente la ÚNICA forma'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para la conclusión...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '🎓 CONCLUSIÓN: Solicitudes como Única Forma',
+        '==================================================',
+        '🎯 Hemos demostrado que:',
+        '\n1️⃣ NO es posible acceder directamente a datos privados',
+        '2️⃣ NO es posible manipular el objeto externamente',
+        '3️⃣ NO es posible forzar operaciones sin consentimiento',
+        '4️⃣ Las SOLICITUDES son literalmente la única forma',
+        '\n🔑 Características de las solicitudes:',
+        '• El objeto DECIDE si acepta o rechaza',
+        '• Cada solicitud pasa por validaciones internas',
+        '• El objeto mantiene control total de su estado',
+        '• Las reglas internas se respetan siempre',
+        '\n🛡️ Beneficios de este diseño:',
+        '• Seguridad garantizada',
+        '• Integridad de datos preservada',
+        '• Comportamiento predecible',
+        '• Control total del objeto sobre sí mismo',
+        '\n📚 Conexión con otras lecciones:',
+        '• Lección 1: Los objetos que identificamos tienen este comportamiento',
+        '• Lección 2: Esas interacciones son siempre solicitudes',
+        '• Lección 3: ✅ Y son la ÚNICA forma de ejecutar operaciones',
+        '• Lecciones 4-6: Cómo definir formalmente estas solicitudes',
+        '\n💭 Reflexión:',
+        'Imagina que tu casa tuviera esta protección: nadie puede entrar',
+        'a menos que tú decidas abrir la puerta después de verificar',
+        'quién es. Los objetos funcionan exactamente igual.',
+        '\n🏆 Ahora entiendes por qué las solicitudes son la ÚNICA forma:',
+        'porque los objetos están diseñados para protegerse y decidir.'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\n✨ ¡Lección 3 completada! Presiona Enter para salir...',
+      type: 'pause'
+    }
+  ]
+}

package/lib/data/lessons/lesson4-operation-signatures.js

@@ -0,0 +1,332 @@
+export const LESSON_4_OPERATION_SIGNATURES = {
+  id: 4,
+  title: 'LECCIÓN 4: Cada operación declarada por un objeto debe incluir: a) nombre de la operación; b) insumos necesarios para realizar la operación; c) el valor que regresa tras ejecutar la operación. Estos tres elementos constituyen la firma de operación.',
+  subtitle: 'Enfoque práctico: Diseñar firmas de operación precisas y completas',
+  flow: [
+    {
+      lines: [
+        '\n💡 ¿Por qué son importantes las firmas?',
+        '- Define exactamente QUÉ hace la operación (nombre)',
+        '- Define exactamente QUÉ necesita (insumos)',
+        '- Define exactamente QUÉ devuelve (valor de retorno)',
+        '- Permite predecir el comportamiento sin ver la implementación'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para comenzar con ejemplos prácticos...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '🛠️ EJERCICIO PRÁCTICO: Calculadora Financiera',
+        '==================================================',
+        '🎯 Vamos a diseñar firmas de operación precisas y completas',
+        '\nSistema: Calculadora para operaciones financieras',
+        'Objeto: FinancialCalculator'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver firmas mal diseñadas...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '❌ FIRMAS MAL DISEÑADAS',
+        '==============================',
+        'Veamos firmas incompletas o confusas:',
+        '\n🚫 PROBLEMA 1: Nombre poco claro',
+        "// ❌ ¿Qué hace exactamente 'calc'?\n" +
+          'calc(x, y) → ?\n' +
+          '\n' +
+          "// ❌ ¿Es 'do' suma, resta, multiplicación?\n" +
+          'do(amount, rate) → ?',
+        '\n🚫 PROBLEMA 2: Insumos ambiguos',
+        '// ❌ ¿Qué tipo de datos espera?\n' +
+          'calculateInterest(amount, rate) → number\n' +
+          '// ¿amount es string o number?\n' +
+          '// ¿rate es porcentaje (0.05) o entero (5)?',
+        '\n🚫 PROBLEMA 3: Valor de retorno incierto',
+        '// ❌ ¿Qué devuelve exactamente?\n' +
+          'calculatePayment() → ?\n' +
+          '// ¿Un número? ¿Un objeto? ¿null si falla?\n' +
+          '\n' +
+          '// ❌ ¿Y si hay error?\n' +
+          'divideNumbers(a, b) → number\n' +
+          '// ¿Qué pasa si b es 0?'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver más problemas...',
+      type: 'pause'
+    },
+    {
+      lines: [
+        '\n🚫 PROBLEMA 4: Firmas inconsistentes',
+        '// ❌ Métodos similares con firmas diferentes\n' +
+          'addMoney(amount) → boolean\n' +
+          'subtractCash(value, currency) → {success: boolean, balance: number}\n' +
+          'multiply(x, y, precision) → number | null\n' +
+          '\n' +
+          '// ❌ Imposible predecir qué esperar de cada método',
+        '\n💥 Consecuencias:',
+        '• Imposible usar el objeto sin ver el código interno',
+        '• Errores constantes por malentender los parámetros',
+        '• Código frágil y difícil de mantener',
+        '• Colaboración entre objetos impredecible'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver cómo debe ser...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '✅ FIRMAS BIEN DISEÑADAS',
+        '===================================',
+        'Ahora veamos firmas completas y precisas:',
+        '\n🎯 ELEMENTO A: Nombre claro y específico',
+        '// ✅ Nombres que describen exactamente la operación\n' +
+          'calculateSimpleInterest(principal, rate, time) → number\n' +
+          'calculateCompoundInterest(principal, rate, time, frequency) → number\n' +
+          'calculateMonthlyPayment(loanAmount, interestRate, termInMonths) → number',
+        '\n📥 ELEMENTO B: Insumos específicos y tipados',
+        '// ✅ Cada parámetro claramente definido\n' +
+          'calculateSimpleInterest(\n' +
+          '  principal: number,      // Monto principal en pesos\n' +
+          '  rate: number,          // Tasa anual como decimal (0.05 = 5%)\n' +
+          '  time: number           // Tiempo en años\n' +
+          ') → number\n' +
+          '\n' +
+          'calculateMonthlyPayment(\n' +
+          '  loanAmount: number,         // Monto del préstamo en pesos\n' +
+          '  interestRate: number,       // Tasa mensual como decimal\n' +
+          '  termInMonths: number        // Plazo en meses\n' +
+          ') → number',
+        '\n📤 ELEMENTO C: Valor de retorno específico',
+        '// ✅ Especifica exactamente qué devuelve y cuándo\n' +
+          'calculateLoanPayment(amount, rate, term) → {\n' +
+          '  success: boolean,\n' +
+          '  monthlyPayment: number | null,\n' +
+          '  totalInterest: number | null,\n' +
+          '  error: string | null\n' +
+          '}\n' +
+          '\n' +
+          'validateLoanAmount(amount) → {\n' +
+          '  isValid: boolean,\n' +
+          '  minimumRequired: number,\n' +
+          '  maximumAllowed: number\n' +
+          '}'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver la implementación completa...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '🔍 ANÁLISIS DE FIRMAS COMPLETAS',
+        '========================================',
+        'Examinemos cada elemento de las firmas:',
+        '\n💼 EJEMPLO: Calculadora financiera completa',
+        'class FinancialCalculator {\n' +
+          '  // 🎯 FIRMA 1: Interés simple\n' +
+          '  calculateSimpleInterest(\n' +
+          '    principal: number,    // a) Monto principal en pesos\n' +
+          '    rate: number,        // b) Tasa anual (0.05 = 5%)\n' +
+          '    time: number         // c) Tiempo en años\n' +
+          '  ): number {            // RETORNA: Interés total calculado\n' +
+          '    return principal * rate * time\n' +
+          '  }\n' +
+          '\n' +
+          '  // 🎯 FIRMA 2: Validación con resultado estructurado\n' +
+          '  validateLoanApplication(\n' +
+          '    income: number,           // a) Ingreso mensual\n' +
+          '    existingDebt: number,     // b) Deuda actual\n' +
+          '    requestedAmount: number   // c) Monto solicitado\n' +
+          '  ): {                       // RETORNA: Objeto con análisis completo\n' +
+          '    approved: boolean,\n' +
+          '    maxLoanAmount: number,\n' +
+          '    debtToIncomeRatio: number,\n' +
+          '    reasons: string[]\n' +
+          '  }\n' +
+          '\n' +
+          '  // 🎯 FIRMA 3: Cálculo que puede fallar\n' +
+          '  calculateCompoundInterest(\n' +
+          '    principal: number,    // a) Monto principal\n' +
+          '    rate: number,        // b) Tasa anual\n' +
+          '    time: number,        // c) Años\n' +
+          '    frequency: number    // d) Frecuencia de composición\n' +
+          '  ): number | null {     // RETORNA: Resultado o null si hay error\n' +
+          '    if (principal <= 0 || rate < 0 || time <= 0 || frequency <= 0) {\n' +
+          '      return null\n' +
+          '    }\n' +
+          '    return principal * Math.pow(1 + rate/frequency, frequency * time)\n' +
+          '  }\n' +
+          '}'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para analizar cada firma...',
+      type: 'pause'
+    },
+    {
+      lines: [
+        '\n📋 ANÁLISIS FIRMA POR FIRMA:',
+        '\n1️⃣ calculateSimpleInterest:',
+        "   • NOMBRE: 'calculateSimpleInterest' - claro y específico",
+        '   • INSUMOS: (principal, rate, time) - 3 números con propósito definido',
+        '   • RETORNO: number - interés calculado, siempre un número',
+        '\n2️⃣ validateLoanApplication:',
+        "   • NOMBRE: 'validateLoanApplication' - describe validación completa",
+        '   • INSUMOS: (income, existingDebt, requestedAmount) - datos financieros',
+        '   • RETORNO: objeto estructurado - análisis completo con múltiples campos',
+        '\n3️⃣ calculateCompoundInterest:',
+        "   • NOMBRE: 'calculateCompoundInterest' - específico del tipo de interés",
+        '   • INSUMOS: (principal, rate, time, frequency) - 4 parámetros necesarios',
+        '   • RETORNO: number | null - puede fallar si datos inválidos'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver cómo usar estas firmas...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '🎭 DEMOSTRACIÓN: Uso con Firmas Claras',
+        '=============================================',
+        'Veamos cómo las firmas bien diseñadas facilitan el uso:',
+        '\n// Crear calculadora',
+        'const calc = new FinancialCalculator()',
+        '',
+        '// 💡 Con las firmas claras, sabemos exactamente qué esperar:',
+        '',
+        '// FIRMA: calculateSimpleInterest(principal, rate, time) → number',
+        'const interest = calc.calculateSimpleInterest(10000, 0.05, 2)',
+        'console.log(interest)  // 1000 (siempre un número)'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver validación...',
+      type: 'pause'
+    },
+    {
+      lines: [
+        '\n// FIRMA: validateLoanApplication(income, debt, amount) → objeto',
+        'const validation = calc.validateLoanApplication(5000, 1000, 50000)',
+        'console.log(validation)',
+        '// {',
+        '//   approved: false,',
+        '//   maxLoanAmount: 20000,',
+        '//   debtToIncomeRatio: 0.2,',
+        "//   reasons: ['Monto solicitado excede capacidad de pago']",
+        '// }',
+        '',
+        '// 💡 Podemos usar cada campo porque la firma nos dice qué esperar',
+        'if (validation.approved) {',
+        "  console.log('Préstamo aprobado!')",
+        '} else {',
+        "  console.log('Máximo permitido:', validation.maxLoanAmount)",
+        "  validation.reasons.forEach(reason => console.log('❌', reason))",
+        '}'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver manejo de errores...',
+      type: 'pause'
+    },
+    {
+      lines: [
+        '\n// FIRMA: calculateCompoundInterest(...) → number | null',
+        'const compound1 = calc.calculateCompoundInterest(10000, 0.05, 2, 12)',
+        'const compound2 = calc.calculateCompoundInterest(-1000, 0.05, 2, 12)',
+        '',
+        '// 💡 La firma nos dice que puede retornar null, así que verificamos',
+        'if (compound1 !== null) {',
+        "  console.log('Interés compuesto:', compound1)  // 11049.41",
+        '}',
+        '',
+        'if (compound2 === null) {',
+        "  console.log('Error: datos inválidos')  // Se ejecuta",
+        '}',
+        '\n🎯 Beneficios observados:',
+        '• Sabemos exactamente qué pasar a cada método',
+        '• Sabemos exactamente qué esperar de vuelta',
+        '• Podemos manejar errores apropiadamente',
+        '• El código es predecible y confiable'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para la conclusión...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '🎓 CONCLUSIÓN: Firmas de Operación',
+        '========================================',
+        '🎯 Hemos demostrado que cada firma debe incluir:',
+        '\n🎯 A) NOMBRE de la operación:',
+        '   • Claro y específico',
+        '   • Describe exactamente qué hace',
+        "   • Ejemplo: 'calculateSimpleInterest' vs 'calc'",
+        '\n📥 B) INSUMOS necesarios:',
+        '   • Tipo y propósito de cada parámetro',
+        '   • Valores esperados y restricciones',
+        "   • Ejemplo: 'rate: number (decimal, 0.05 = 5%)'",
+        '\n📤 C) VALOR de retorno:',
+        '   • Tipo exacto que retorna',
+        '   • Qué significa el valor',
+        '   • Cómo manejar casos de error',
+        "   • Ejemplo: 'number | null' vs solo 'number'",
+        '\n🌟 Beneficios de firmas completas:',
+        '• Predictibilidad total del comportamiento',
+        '• Colaboración segura entre objetos',
+        '• Código autodocumentado',
+        '• Detección temprana de errores',
+        '\n📚 Conexión con otras lecciones:',
+        '• Lección 1-3: Las operaciones que identificamos necesitan firmas',
+        '• Lección 4: ✅ Cada operación tiene nombre, insumos y retorno',
+        '• Lección 5: El conjunto de firmas forma la interfaz',
+        '• Lección 6: El énfasis está en diseñar estas firmas primero',
+        '\n💭 Reflexión:',
+        '¿Te imaginas usar una función de la que no sabes qué parámetros',
+        'espera ni qué devuelve? ¡Sería imposible! Las firmas son el',
+        'contrato que hace posible la colaboración entre objetos.',
+        '\n🏆 Ahora entiendes por qué cada operación necesita una firma',
+        'completa: es la base de la comunicación predecible.'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\n✨ ¡Lección 4 completada! Presiona Enter para salir...',
+      type: 'pause'
+    }
+  ]
+}