@icarusmx/creta 0.11.0 → 1.0.1

package/ascii-logo.txt

@@ -0,0 +1,11 @@
+█████████████████████████████
+█   █     █     █     █     █
+█ █ █ ███ █ ███ █ ███ █ ███ █
+█   █     █     █     █     █
+█ ███ █ ███ █ ███ █ ███ █ █ █
+█  C     R     E     T     A █
+█ ███ █ ███ █ ███ █ ███ █ █ █
+█   █     █     █     █     █
+█████████████████████████████
+
+🏛️  Salgamos de este laberinto  🏛️

package/bin/creta.js

@@ -8,6 +8,9 @@ import { fileURLToPath } from 'url'
 import { CretaCodeSession } from '../lib/session.js'
 import { Lesson1SystemDecomposition } from '../lessons/lesson1-system-decomposition.js'
 import { Lesson2ObjectRequests } from '../lessons/lesson2-object-requests.js'
+import { Lesson3OnlyWay } from '../lessons/lesson3-only-way.js'
+import { Lesson4OperationSignatures } from '../lessons/lesson4-operation-signatures.js'
+import { Lesson5InterfaceSet } from '../lessons/lesson5-interface-set.js'
 import { Lesson6InterfaceDesign } from '../lessons/lesson6-interface-design.js'
 
 const ENUNCIADOS = [
@@ -52,9 +55,21 @@ const ENUNCIADOS = [
 const args = process.argv.slice(2)
 const command = args[0]
 
-// Welcome message
-console.log("🏛️ Bienvenido a Creta")
-console.log("La escuela de software de icarus.mx\n")
+// ASCII Logo
+console.log(`
+█████████████████████████████
+█   █     █     █     █     █
+█ █ █ ███ █ ███ █ ███ █ ███ █
+█   █     █     █     █     █
+█ ███ █ ███ █ ███ █ ███ █ █ █
+█  C     R     E     T     A █
+█ ███ █ ███ █ ███ █ ███ █ █ █
+█   █     █     █     █     █
+█████████████████████████████
+
+🏛️  Salgamos de este laberinto  🏛️
+La escuela de software de icarus.mx
+`)
 
 if (!command) {
   // Default behavior: show main menu
@@ -623,8 +638,20 @@ async function startMainMenuInteractive() {
     process.stdout.write('\x1b[2J')
     process.stdout.write('\x1b[H')
 
-    console.log("🏛️ Bienvenido a Creta")
-    console.log("La escuela de software de icarus.mx\n")
+    console.log(`
+█████████████████████████████
+█   █     █     █     █     █
+█ █ █ ███ █ ███ █ ███ █ ███ █
+█   █     █     █     █     █
+█ ███ █ ███ █ ███ █ ███ █ █ █
+█  C     R     E     T     A █
+█ ███ █ ███ █ ███ █ ███ █ █ █
+█   █     █     █     █     █
+█████████████████████████████
+
+🏛️  Salgamos de este laberinto  🏛️
+La escuela de software de icarus.mx
+`)
     console.log("Te ofrecemos las siguientes opciones")
     console.log("Usa ↑/↓ para navegar, Enter para seleccionar, 'q' para salir\n")
 
@@ -856,6 +883,48 @@ async function startEnunciadosSelectorInteractive() {
             console.log("- Ejercicios prácticos que ilustren el concepto")
             console.log("- Proyectos específicos para internalizar la idea")
           }
+        } else if (enunciadoSeleccionado.id === 3) {
+          console.log("\n🚀 ¡Lección disponible! Iniciando sesión de estudio dirigida...")
+          await new Promise(resolve => setTimeout(resolve, 1500)) // Brief pause
+
+          try {
+            const lesson3 = new Lesson3OnlyWay()
+            await lesson3.start()
+          } catch (error) {
+            console.error("\n❌ Error al ejecutar la lección:", error.message)
+            console.log("\n🚀 Próximamente:")
+            console.log("- Sesiones de estudio dirigidas basadas en este enunciado")
+            console.log("- Ejercicios prácticos que ilustren el concepto")
+            console.log("- Proyectos específicos para internalizar la idea")
+          }
+        } else if (enunciadoSeleccionado.id === 4) {
+          console.log("\n🚀 ¡Lección disponible! Iniciando sesión de estudio dirigida...")
+          await new Promise(resolve => setTimeout(resolve, 1500)) // Brief pause
+
+          try {
+            const lesson4 = new Lesson4OperationSignatures()
+            await lesson4.start()
+          } catch (error) {
+            console.error("\n❌ Error al ejecutar la lección:", error.message)
+            console.log("\n🚀 Próximamente:")
+            console.log("- Sesiones de estudio dirigidas basadas en este enunciado")
+            console.log("- Ejercicios prácticos que ilustren el concepto")
+            console.log("- Proyectos específicos para internalizar la idea")
+          }
+        } else if (enunciadoSeleccionado.id === 5) {
+          console.log("\n🚀 ¡Lección disponible! Iniciando sesión de estudio dirigida...")
+          await new Promise(resolve => setTimeout(resolve, 1500)) // Brief pause
+
+          try {
+            const lesson5 = new Lesson5InterfaceSet()
+            await lesson5.start()
+          } catch (error) {
+            console.error("\n❌ Error al ejecutar la lección:", error.message)
+            console.log("\n🚀 Próximamente:")
+            console.log("- Sesiones de estudio dirigidas basadas en este enunciado")
+            console.log("- Ejercicios prácticos que ilustren el concepto")
+            console.log("- Proyectos específicos para internalizar la idea")
+          }
         } else if (enunciadoSeleccionado.id === 6) {
           console.log("\n🚀 ¡Lección disponible! Iniciando sesión de estudio dirigida...")
           await new Promise(resolve => setTimeout(resolve, 1500)) // Brief pause
@@ -987,6 +1056,54 @@ async function startEnunciadosSelectorFallback() {
           console.log("- Proyectos específicos para internalizar la idea")
         }
         return
+      } else if (enunciadoSeleccionado.id === 3) {
+        console.log("\n🚀 ¡Lección disponible! Iniciando sesión de estudio dirigida...")
+        rl.close()
+        await new Promise(resolve => setTimeout(resolve, 1500)) // Brief pause
+
+        try {
+          const lesson3 = new Lesson3OnlyWay()
+          await lesson3.start()
+        } catch (error) {
+          console.error("\n❌ Error al ejecutar la lección:", error.message)
+          console.log("\n🚀 Próximamente:")
+          console.log("- Sesiones de estudio dirigidas basadas en este enunciado")
+          console.log("- Ejercicios prácticos que ilustren el concepto")
+          console.log("- Proyectos específicos para internalizar la idea")
+        }
+        return
+      } else if (enunciadoSeleccionado.id === 4) {
+        console.log("\n🚀 ¡Lección disponible! Iniciando sesión de estudio dirigida...")
+        rl.close()
+        await new Promise(resolve => setTimeout(resolve, 1500)) // Brief pause
+
+        try {
+          const lesson4 = new Lesson4OperationSignatures()
+          await lesson4.start()
+        } catch (error) {
+          console.error("\n❌ Error al ejecutar la lección:", error.message)
+          console.log("\n🚀 Próximamente:")
+          console.log("- Sesiones de estudio dirigidas basadas en este enunciado")
+          console.log("- Ejercicios prácticos que ilustren el concepto")
+          console.log("- Proyectos específicos para internalizar la idea")
+        }
+        return
+      } else if (enunciadoSeleccionado.id === 5) {
+        console.log("\n🚀 ¡Lección disponible! Iniciando sesión de estudio dirigida...")
+        rl.close()
+        await new Promise(resolve => setTimeout(resolve, 1500)) // Brief pause
+
+        try {
+          const lesson5 = new Lesson5InterfaceSet()
+          await lesson5.start()
+        } catch (error) {
+          console.error("\n❌ Error al ejecutar la lección:", error.message)
+          console.log("\n🚀 Próximamente:")
+          console.log("- Sesiones de estudio dirigidas basadas en este enunciado")
+          console.log("- Ejercicios prácticos que ilustren el concepto")
+          console.log("- Proyectos específicos para internalizar la idea")
+        }
+        return
       } else if (enunciadoSeleccionado.id === 6) {
         console.log("\n🚀 ¡Lección disponible! Iniciando sesión de estudio dirigida...")
         rl.close()

package/lessons/lesson3-only-way.js

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

package/lessons/lesson4-operation-signatures.js

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

package/lessons/lesson5-interface-set.js

@@ -0,0 +1,330 @@
+#!/usr/bin/env node
+
+// LECCIÓN 5: La interfaz de un objeto es el conjunto de todas sus firmas de operación
+// Enfoque práctico: Demostrar cómo las firmas individuales forman una interfaz coherente
+
+import { createInterface } from 'readline'
+
+export class Lesson5InterfaceSet {
+  constructor() {
+    this.rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    })
+  }
+
+  async start() {
+    console.log("🎯 LECCIÓN 5: Interfaz como Conjunto de Firmas")
+    console.log("=" .repeat(50))
+    console.log("📚 Enunciado: La interfaz de un objeto es el conjunto de todas sus firmas de operación.")
+
+    console.log("\n💡 ¿Qué significa esto?")
+    console.log("- Una interfaz NO es una sola operación")
+    console.log("- Es el CONJUNTO COMPLETO de todas las firmas")
+    console.log("- Define TODO lo que el objeto puede hacer")
+    console.log("- Es el 'contrato público' del objeto")
+
+    await this.waitForEnter("\nPresiona Enter para comenzar con ejemplos prácticos...")
+
+    await this.practicalExercise()
+    await this.conclusion()
+
+    this.rl.close()
+  }
+
+  async practicalExercise() {
+    console.clear()
+    console.log("🛠️ EJERCICIO PRÁCTICO: Reproductor de Música")
+    console.log("=" .repeat(50))
+    console.log("🎯 Vamos a construir una interfaz completa paso a paso")
+    console.log("\nSistema: Reproductor de música digital")
+    console.log("Objeto: MusicPlayer")
+
+    await this.waitForEnter("\nPresiona Enter para ver cómo NO diseñar una interfaz...")
+
+    await this.step1_IncompleteInterface()
+    await this.step2_CompleteInterface()
+    await this.step3_InterfaceCoherence()
+    await this.step4_InterfaceUsage()
+  }
+
+  async step1_IncompleteInterface() {
+    console.clear()
+    console.log("❌ INTERFAZ INCOMPLETA")
+    console.log("=" .repeat(30))
+    console.log("Veamos un objeto con interfaz parcial:")
+
+    console.log("\n🚫 PROBLEMA: Solo algunas operaciones definidas")
+    console.log(`class MusicPlayer {
+  // ✅ Operación bien definida
+  play(songId: string): boolean {
+    // implementación...
+  }
+
+  // ❌ Otras operaciones sin firma clara
+  stop() {
+    // ¿Qué devuelve? ¿Puede fallar?
+  }
+
+  volume(level) {
+    // ¿Qué tipo es level? ¿Qué rango?
+  }
+
+  // ❌ Operaciones faltantes
+  // ¿Cómo pauso? ¿Cómo cambio de canción?
+  // ¿Cómo consulto qué está sonando?
+}`)
+
+    console.log("\n💥 Problemas de interfaz incompleta:")
+    console.log("• Imposible predecir qué operaciones están disponibles")
+    console.log("• Firmas inconsistentes entre operaciones")
+    console.log("• Funcionalidad básica faltante")
+    console.log("• Colaboración con otros objetos impredecible")
+
+    await this.waitForEnter("\nPresiona Enter para ver otro problema...")
+
+    console.log("\n🚫 PROBLEMA: Firmas sin relación")
+    console.log(`class BadMusicPlayer {
+  // ❌ Firmas que no forman un conjunto coherente
+  startMusic(file: string): void          // Usa archivos
+  playTrack(id: number): boolean          // Usa IDs numéricos
+  beginSong(song: object): string         // Usa objetos
+
+  setVol(x: number): void                 // Volumen sin validación
+  adjustAudio(level: string): boolean     // Volumen como string??
+
+  getCurrentStatus(): any                 // Retorna 'any' (inútil)
+  getInfo(): string                       // Retorna string (ambiguo)
+}`)
+
+    console.log("\n📉 Resultado:")
+    console.log("No es una interfaz, es una colección caótica de operaciones")
+    console.log("sin relación ni coherencia entre sí.")
+
+    await this.waitForEnter("\nPresiona Enter para ver cómo debe ser...")
+  }
+
+  async step2_CompleteInterface() {
+    console.clear()
+    console.log("✅ INTERFAZ COMPLETA Y COHERENTE")
+    console.log("=" .repeat(40))
+    console.log("Veamos una interfaz bien diseñada:")
+
+    console.log("\n🎵 CONJUNTO COMPLETO de firmas de operación:")
+    console.log(`interface MusicPlayerInterface {
+  // 🎮 GRUPO: Control de reproducción
+  play(songId: string): Promise<{success: boolean, message: string}>
+  pause(): Promise<{success: boolean, currentPosition: number}>
+  stop(): Promise<{success: boolean}>
+  resume(): Promise<{success: boolean, message: string}>
+
+  // 🔊 GRUPO: Control de audio
+  setVolume(level: number): {success: boolean, currentVolume: number}  // 0-100
+  getVolume(): number
+  mute(): {success: boolean, previousVolume: number}
+  unmute(): {success: boolean, restoredVolume: number}
+
+  // 📋 GRUPO: Gestión de playlist
+  addSong(song: Song): {success: boolean, playlistLength: number}
+  removeSong(songId: string): {success: boolean, wasPlaying: boolean}
+  getPlaylist(): Song[]
+  shufflePlaylist(): {success: boolean, newOrder: string[]}
+
+  // 📊 GRUPO: Información de estado
+  getCurrentSong(): Song | null
+  getPlaybackStatus(): {
+    isPlaying: boolean,
+    isPaused: boolean,
+    currentTime: number,
+    totalTime: number,
+    volume: number
+  }
+  getDuration(songId: string): number | null
+
+  // ⚙️ GRUPO: Configuración
+  setRepeatMode(mode: 'none' | 'one' | 'all'): boolean
+  getRepeatMode(): 'none' | 'one' | 'all'
+  setShuffleMode(enabled: boolean): boolean
+  isShuffleEnabled(): boolean
+}`)
+
+    await this.waitForEnter("\nPresiona Enter para analizar esta interfaz...")
+
+    console.log("\n🔍 ANÁLISIS del conjunto:")
+    console.log("\n1️⃣ COMPLETITUD:")
+    console.log("   • Todas las operaciones necesarias están presentes")
+    console.log("   • No hay funcionalidad faltante básica")
+    console.log("   • Cubre todo el comportamiento esperado")
+
+    console.log("\n2️⃣ COHERENCIA:")
+    console.log("   • Todas las firmas usan tipos consistentes")
+    console.log("   • Patrones de retorno consistentes")
+    console.log("   • Nomenclatura uniforme")
+
+    console.log("\n3️⃣ ORGANIZACIÓN:")
+    console.log("   • Operaciones agrupadas por funcionalidad")
+    console.log("   • Cada grupo tiene propósito claro")
+    console.log("   • Fácil de entender y recordar")
+
+    await this.waitForEnter("\nPresiona Enter para ver la implementación...")
+  }
+
+  async step3_InterfaceCoherence() {
+    console.clear()
+    console.log("🧩 COHERENCIA DE LA INTERFAZ")
+    console.log("=" .repeat(35))
+    console.log("Veamos cómo las firmas forman un conjunto coherente:")
+
+    console.log("\n📏 CONSISTENCIA EN TIPOS:")
+    console.log(`// ✅ Todas las operaciones de canciones usan string
+play(songId: string)
+removeSong(songId: string)
+getDuration(songId: string)
+
+// ✅ Todas las operaciones de volumen usan number (0-100)
+setVolume(level: number)        // 0-100
+getVolume(): number            // 0-100
+mute(): {previousVolume: number}  // 0-100`)
+
+    console.log("\n🔄 CONSISTENCIA EN PATRONES:")
+    console.log(`// ✅ Operaciones de configuración siguen patrón set/get
+setRepeatMode(mode) / getRepeatMode()
+setShuffleMode(enabled) / isShuffleEnabled()
+setVolume(level) / getVolume()
+
+// ✅ Operaciones de estado siguen patrón de objeto estructurado
+getPlaybackStatus(): {isPlaying, isPaused, currentTime, ...}
+pause(): {success, currentPosition}
+mute(): {success, previousVolume}`)
+
+    console.log("\n🎯 COMPLETITUD FUNCIONAL:")
+    console.log(`// ✅ Para cada acción, hay su contraparte
+play() ↔ pause() ↔ stop() ↔ resume()
+mute() ↔ unmute()
+addSong() ↔ removeSong()
+
+// ✅ Para cada operación de cambio, hay consulta
+setVolume() → getVolume()
+setRepeatMode() → getRepeatMode()`)
+
+    await this.waitForEnter("\nPresiona Enter para ver cómo se usa...")
+  }
+
+  async step4_InterfaceUsage() {
+    console.clear()
+    console.log("🎭 DEMOSTRACIÓN: Uso de Interfaz Completa")
+    console.log("=" .repeat(45))
+    console.log("Veamos cómo se usa una interfaz bien diseñada:")
+
+    console.log("\n// Crear reproductor")
+    console.log("const player = new MusicPlayer()")
+    console.log("")
+    console.log("// 🎵 Usar GRUPO de reproducción")
+    console.log("const song = new Song('123', 'Bohemian Rhapsody', 'Queen')")
+    console.log("await player.addSong(song)")
+    console.log("")
+    console.log("const playResult = await player.play('123')")
+    console.log("if (playResult.success) {")
+    console.log("  console.log('Reproduciendo:', playResult.message)")
+    console.log("}")
+
+    await this.waitForEnter("\nPresiona Enter para ver más uso...")
+
+    console.log("\n// 🔊 Usar GRUPO de audio")
+    console.log("const volumeResult = player.setVolume(75)")
+    console.log("console.log('Volumen actual:', volumeResult.currentVolume)")
+    console.log("")
+    console.log("// 📊 Usar GRUPO de información")
+    console.log("const status = player.getPlaybackStatus()")
+    console.log("console.log(`Reproduciendo: ${status.isPlaying}`)")
+    console.log("console.log(`Tiempo: ${status.currentTime}/${status.totalTime}`)")
+    console.log("console.log(`Volumen: ${status.volume}`)")
+
+    await this.waitForEnter("\nPresiona Enter para ver uso avanzado...")
+
+    console.log("\n// 🎮 Combinando múltiples grupos")
+    console.log("async function createMusicSession() {")
+    console.log("  // Configurar reproductor")
+    console.log("  player.setRepeatMode('all')")
+    console.log("  player.setShuffleMode(true)")
+    console.log("  player.setVolume(60)")
+    console.log("  ")
+    console.log("  // Agregar canciones")
+    console.log("  const songs = ['123', '456', '789']")
+    console.log("  for (const songId of songs) {")
+    console.log("    await player.addSong(getSong(songId))")
+    console.log("  }")
+    console.log("  ")
+    console.log("  // Iniciar reproducción")
+    console.log("  await player.play(songs[0])")
+    console.log("  ")
+    console.log("  // Monitorear estado cada segundo")
+    console.log("  setInterval(() => {")
+    console.log("    const status = player.getPlaybackStatus()")
+    console.log("    updateUI(status)")
+    console.log("  }, 1000)")
+    console.log("}")
+
+    console.log("\n🌟 Beneficios observados:")
+    console.log("• Cada operación se complementa con las demás")
+    console.log("• Podemos crear flujos complejos combinando firmas")
+    console.log("• La interfaz completa permite cualquier funcionalidad")
+    console.log("• El conjunto es mayor que la suma de sus partes")
+
+    await this.waitForEnter("\nPresiona Enter para la conclusión...")
+  }
+
+  async conclusion() {
+    console.clear()
+    console.log("🎓 CONCLUSIÓN: Interfaz como Conjunto de Firmas")
+    console.log("=" .repeat(50))
+    console.log("🎯 Hemos demostrado que:")
+
+    console.log("\n1️⃣ Una interfaz es el CONJUNTO COMPLETO de firmas")
+    console.log("2️⃣ No es una operación individual, sino TODAS juntas")
+    console.log("3️⃣ Las firmas deben ser coherentes entre sí")
+    console.log("4️⃣ El conjunto debe cubrir toda la funcionalidad necesaria")
+
+    console.log("\n🧩 Características de una buena interfaz:")
+    console.log("• COMPLETITUD - todas las operaciones necesarias")
+    console.log("• COHERENCIA - tipos y patrones consistentes")
+    console.log("• ORGANIZACIÓN - agrupación lógica de funcionalidades")
+    console.log("• PREDICTIBILIDAD - comportamiento uniforme")
+
+    console.log("\n🎯 La interfaz como contrato:")
+    console.log("• Define TODO lo que el objeto puede hacer")
+    console.log("• Especifica exactamente cómo interactuar")
+    console.log("• Garantiza comportamiento predecible")
+    console.log("• Permite colaboración confiable")
+
+    console.log("\n📚 Conexión con otras lecciones:")
+    console.log("• Lección 1-3: Los objetos necesitan interfaces para interactuar")
+    console.log("• Lección 4: Cada operación de la interfaz tiene firma completa")
+    console.log("• Lección 5: ✅ La interfaz es el conjunto de TODAS las firmas")
+    console.log("• Lección 6: El énfasis debe estar en diseñar este conjunto")
+
+    console.log("\n💭 Reflexión:")
+    console.log("Imagina un control remoto que solo tuviera algunos botones:")
+    console.log("play pero no pause, volumen+ pero no volumen-. ¡Sería inútil!")
+    console.log("Las interfaces necesitan ser conjuntos completos y coherentes.")
+
+    console.log("\n🏆 Ahora entiendes qué es realmente una interfaz:")
+    console.log("el conjunto completo de todas las firmas de operación.")
+
+    await this.waitForEnter("\n✨ ¡Lección 5 completada! Presiona Enter para salir...")
+  }
+
+  async waitForEnter(message) {
+    return new Promise((resolve) => {
+      this.rl.question(message, () => {
+        resolve()
+      })
+    })
+  }
+}
+
+// Para usar la lección independientemente
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const lesson = new Lesson5InterfaceSet()
+  await lesson.start()
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@icarusmx/creta",
-  "version": "0.11.0",
+  "version": "1.0.1",
   "description": "Salgamos de este laberinto.",
   "type": "module",
   "bin": {