Suite Visual de Arquitectura de Memoria y Algoritmos: De Trainee a Staff L6+ (Rust & Python)#

Repositorio Central de Diagramas Visuales (.svg) y Fuentes Editables (.mmd) Diseñado bajo principios de diseño cognitivo y pedagogía técnica desde primeros principios para dominar algoritmos, estructuras de datos y el modelo de memoria física de bajo nivel en Rust y Python.

📌 Índice del Documento#

1. Filosofía Pedagógica y la Metodología Paper-First
2. Diccionario de Notación Visual para Junior / Trainee
3. Los 10 Diagramas Panorámicos de Arquitectura (Overviews) - 00. Hoja de Ruta de 10 Semanas (70 Días) - 01. Memoria Física en Rust vs Python - 02. Arreglos, Búsqueda Binaria y Dos Punteros - 03. Recursión, Call Stack y Listas Enlazadas vs Arena - 04. Tablas Hash, Pilas, Colas y Pila Monótona - 05. Jerarquía de Árboles, Heaps, Grafos y Dijkstra - 06. Paradigmas de Decisión: Greedy, Backtracking y DP - 07. Manipulación de Bits, Tries y Disjoint Set Union (DSU) - 08. Consultas de Rango: Fenwick, Segment Trees y LFU Cache - 09. Sistemas Distribuidos y Algoritmos Probabilísticos
4. Matriz Completa de los 70 Diagramas de Sesión
5. Guía de Edición y Extensión (.mmd)

🧠 Filosofía Pedagógica y la Metodología Paper-First#

En el desarrollo de software y en las entrevistas de codificación para empresas de alto impacto tecnológico (FAANG / Big Tech), la causa principal por la que los desarrolladores novatos (Trainee / Junior) fallan no radica en la falta de conocimiento sintáctico, sino en la ausencia de un modelo mental de la memoria física.

Cuando un desarrollador memoriza fragmentos de código sin comprender qué ocurre en los transistores y registros del hardware, surgen tropiezos recurrentes: fallos por desbordamiento de enteros (integer overflow/underflow), fugas de memoria o invalidación de punteros por realocación dinámica, y confusiones de complejidad asintótica al no percibir cuándo una operación aparentemente inocua en Python (como un slice list[i:j]) clona millones de bytes en el Heap.

Esta suite visual proporciona un puente cognitivo riguroso entre los dos lenguajes fundamentales del curso:

1. Python: Excelente para modelado conceptual rápido y prototipado matemático de alto nivel.

1. Rust: Lenguaje de sistemas con semántica de propiedad estricta (ownership), préstamos (borrow checking) y abstracciones de costo cero (zero-cost abstractions), que obliga al programador a respetar el hardware sin depender de un recolector de basura (Garbage Collector).

📖 Diccionario de Notación Visual para Junior / Trainee#

Para interpretar los 80 diagramas de esta colección con total precisión, revisa los siguientes conceptos fundamentales definidos desde primeros principios:

🔹 El Stack (Pila de Ejecución)#

• Intuición cotidiana: La memoria ultrarrápida y ordenada que tu programa usa para recordar qué función se está ejecutando en este instante y qué variables locales posee.
• Significado técnico físico: Región contigua de memoria gestionada directamente por el registro de hardware RSP (Stack Pointer) del procesador. Asigna y libera memoria en orden LIFO (Last In, First Out) moviendo únicamente el puntero de pila en tiempo O(1). Su tamaño total es fijo y acotado por el sistema operativo (típicamente 2 MB en Linux y 8 MB en Windows).
• Representación visual en los diagramas: Representado en los diagramas como cajas rectangulares sólidas de tamaño fijo (por ejemplo, el descriptor de 24 bytes de Vec<T> o marcos de 16 bytes de &[T]).
• Trampa común del principiante: Creer que los datos de un arreglo dinámico viven dentro del Stack. En realidad, solo vive el descriptor (ptr, len, cap); los elementos reales residen en el Heap.

🔹 El Heap (Memoria Dinámica)#

• Intuición cotidiana: Un almacén inmenso y flexible de memoria libre al que tu programa solicita bloques de tamaño variable cuando no sabe de antemano cuántos datos necesitará.
• Significado técnico físico: Zona de memoria gestionada por el asignador global del sistema operativo (malloc/jemalloc). Permite reservar bloques contiguos en tiempo de ejecución. El acceso requiere seguir un puntero indirecto (64 bits en x86_64). En Rust se libera de manera determinista al salir del ámbito (patrón RAII / Drop); en Python es rastreado por el Garbage Collector mediante conteo de referencias.
• Representación visual en los diagramas: Representado como búferes contiguos divididos en celdas numeradas con direcciones hexadecimales (por ejemplo, 0x5000: [10 | 20 | 30 | 40 | _ ]).
• Trampa común del principiante: Asumir que pedir memoria en el Heap es gratis. Cada asignación requiere llamadas al sistema o sincronización en el allocator, y los saltos entre punteros dispersos provocan fallos de caché de CPU (cache misses).

🔹 Fat Pointer (Puntero Gordo) y Slices (&[T])#

• Intuición cotidiana: Una 'ventana transparente' o vista prestada que te permite leer un fragmento de un arreglo sin hacer copias ni pagar memoria extra.
• Significado técnico físico: Estructura de dos palabras máquina (16 bytes en arquitectura de 64 bits): un puntero base a la dirección inicial del segmento (*const T) y un número entero con la longitud de elementos visibles (len: usize).
• Representación visual en los diagramas: Representado con una caja morada o azul de 16B que extiende una flecha punteada hacia un subrango del búfer en Heap.
• Trampa común del principiante: Pensar que pasar &arr[start..end] a una función clona los datos del arreglo. En Rust toma tiempo O(1) estricto y 0 bytes en Heap, a diferencia del slicing de listas en Python list[i:j] que clona todo el subarreglo en Heap.

🔹 Tipo usize y Peligro de Underflow#

• Intuición cotidiana: El tipo de número que Rust utiliza exclusivamente para contar posiciones o índices en memoria; siempre es positivo y tiene el tamaño exacto del bus de direcciones de tu procesador.
• Significado técnico físico: Entero sin signo (unsigned) de 64 bits (en computadoras modernas) que puede direccionar cualquier posición física de RAM (0 hasta 2^64 - 1).
• Representación visual en los diagramas: Etiquetado en los diagramas junto a índices de arreglos como [0], [1], [mid: usize].
• Trampa común del principiante: Intentar calcular mid - 1 cuando mid == 0. Al ser un tipo sin signo, la resta 0usize - 1usize no produce -1, sino 18,446,744,073,709,551,615 (desbordamiento / integer underflow), provocando un pánico inmediato (crash) en Rust en modo debug.

🔹 Badges de Complejidad Big-O#

• Intuición cotidiana: Una etiqueta de semáforo que clasifica qué tan rápido correrá tu algoritmo y cuánta memoria adicional consumirá conforme el volumen de datos crezca hacia millones.
• Significado técnico físico: Cota superior asintótica formal: T: O(f(N)) mide el crecimiento del número de instrucciones de CPU; S: O(g(N)) mide la memoria adicional (auxiliar) requerida sin contar los datos de entrada.
• Representación visual en los diagramas: Ubicados en la esquina superior derecha de cada diagrama. Verde para constante/logarítmico (O(1), O(log N)), Azul/Morado para lineal (O(N)), Ámbar para linealítmico (O(N log N)), Rojo para cuadrático/exponencial (O(N²), O(2^N)).
• Trampa común del principiante: Confundir complejidad de tiempo con tiempo medido en segundos en el reloj. Big-O evalúa la tasa de crecimiento ante el tamaño N, no la velocidad absoluta de una máquina específica.

🔹 Flechas de Flujo vs Flechas de Punteros#

• Intuición cotidiana: La diferencia entre 'qué instrucción se ejecuta después' y 'qué dirección de memoria está siendo observada por una variable'.
• Significado técnico físico: Líneas continuas con punta de flecha representan la secuencia algorítmica de decisiones (por ejemplo, transiciones en autómatas o condicionales if/else). Líneas punteadas (-.-> o ──►) representan referencias en memoria física apuntando a búferes en Stack o Heap.
• Representación visual en los diagramas: Flechas sólidas conectan pasos lógicos (Paso 1 ➔ Paso 2). Flechas punteadas conectan descriptores de Rust con sus celdas destino en memoria RAM.
• Trampa común del principiante: Interpretar una flecha de referencia como un movimiento o copia de datos. Una referencia solo 'mira' una posición; no transporta bytes.

🗺️ Los 10 Diagramas Panorámicos de Arquitectura (Overviews)#

Estos 10 diagramas maestros sintetizan las fases troncales del mapa curricular de 70 días, condensando las transiciones de estado, modelos de memoria física en hardware y algoritmos de optimización.

00. Hoja de Ruta de 10 Semanas (70 Días)#

Resumen: Plan maestro integral desde fundamentos y arreglos elementales hasta estructuras distribuidas de nivel Staff L6+.

🔗 Código Fuente Editable en Mermaid: 00-roadmap-10-semanas.mmd

🔍 Guía de Lectura Visual Paso a Paso#

• Componentes en el Diagrama: El diagrama presenta una matriz estructurada en dos hileras de 5 semanas cada una. Cada tarjeta detalla las 5 habilidades nucleares cubiertas, codificadas por color según su track temático: azul para fundamentos, verde azulado para memoria y listas, añil para divide and conquer, violeta para árboles y grafos, fucsia para síntesis FAANG, ámbar para optimización voraz y DP, rosa para bits y estructuras especializadas, esmeralda para consultas de rango, cian para algoritmos probabilísticos y rojo carmesí para certificación Staff.
• Mecánica de Bajo Nivel y Hardware: Muestra la trayectoria de madurez profesional del estudiante: Trainee (Semanas 1 a 3) ➔ Mid-Level Autónomo (Semanas 4 y 5) ➔ Senior Engineer (Semanas 6 a 8) ➔ Staff / Principal L6+ (Semanas 9 y 10).
• ⚠️ Trampa Clásica del Trainee / Junior: Intentar estudiar estructuras complejas (como Segment Trees o Consistent Hashing) sin dominar previamente la gestión del Call Stack y el modelo de memoria de arreglos contiguos.

01. Memoria Física en Rust vs Python#

Resumen: Comparación visual del diseño de memoria a 64 bits: Stack, Heap, descriptores de Vec, fat pointers y boxing en PyObject.

🔗 Código Fuente Editable en Mermaid: 01-rust-memory-stack-heap-slices.mmd

🔍 Guía de Lectura Visual Paso a Paso#

• Componentes en el Diagrama: El panel izquierdo desglosa la memoria en Rust a nivel de bytes: un descriptor de Vec<i32> en Stack (24 bytes: puntero base de 8B, longitud de 8B y capacidad de 8B) apuntando a un búfer contiguo en Heap con capacidad para 8 enteros y 4 ocupados. A su lado, un Fat Pointer de slice &[i32] (16 bytes: ptr a 0x5008 y len=2) presta un subsegmento sin allocar. El panel derecho muestra la anatomía de list en CPython: un array de punteros donde cada entero es un objeto PyLongObject disperso de 28 bytes mínimos con ob_refcnt, ob_type, ob_size y ob_digit.
• Mecánica de Bajo Nivel y Hardware: Rust almacena los enteros de forma contigua en memoria física (4 bytes exactos por entero i32), permitiendo a la CPU precargar líneas de caché L1/L2 de 64 bytes completas (16 enteros por tirada). Python sufre de 'Pointer Chasing': cada elemento requiere saltar a una dirección de memoria distinta, generando continuos fallos de caché (cache misses).
• ⚠️ Trampa Clásica del Trainee / Junior: Creer que list[i:j] en Python es equivalente a &slice[i..j] en Rust. En Python crea una copia completa en Heap de O(K) memoria; en Rust es una vista instantánea O(1) de cero bytes.

02. Arreglos, Búsqueda Binaria y Dos Punteros#

Resumen: Los tres pilares de procesamiento lineal y logarítmico sobre arreglos contiguos &[T].

🔗 Código Fuente Editable en Mermaid: 02-arrays-two-pointers-sliding-window.mmd

🔍 Guía de Lectura Visual Paso a Paso#

• Componentes en el Diagrama: Estructurado en tres paneles horizontales: 1) Búsqueda Binaria demostrando la partición matemática en mitades con punteros low, mid y high descartando el 50% del espacio en cada paso (O(log N)). 2) Dos Punteros Convergentes con punteros en los extremos left y right acercándose hacia el centro para hallar pares de suma en tiempo lineal O(N). 3) Ventana Deslizante (Sliding Window) ilustrando una ventana dinámica [start..end] que expande hacia la derecha e incluye elementos, y contrae desde la izquierda cuando se viola una restricción.
• Mecánica de Bajo Nivel y Hardware: La ventana deslizante parece tener un bucle anidado (for exterior y while interior), pero cada puntero avanza a lo sumo N pasos a lo largo de todo el proceso. La suma total de operaciones es 2N, resultando en un tiempo lineal amortizado O(N) estricto.
• ⚠️ Trampa Clásica del Trainee / Junior: Escribir mid = (low + high) / 2 en lugar de mid = low + (high - low) / 2. Cuando low + high excede el rango máximo de un entero de 32 bits, se produce desbordamiento aritmético.

03. Recursión, Call Stack y Listas Enlazadas vs Arena#

Resumen: Marcos del Call Stack en recursión y los dos paradigmas de listas enlazadas en Rust: Box recursivo vs Arena contigua.

🔗 Código Fuente Editable en Mermaid: 03-recursion-call-stack-linked-lists-arena.mmd

🔍 Guía de Lectura Visual Paso a Paso#

• Componentes en el Diagrama: A la izquierda, la pila de llamadas muestra los marcos apilándose hacia abajo con el registro RSP, alcanzando el caso base factorial(1) y retornando valores en cascada (unwinding). A la derecha se comparan los dos modelos de listas: el modelo tradicional Option<Box<Node<T>>> (donde cada nodo es una asignación aislada en Heap que fragmenta la memoria) frente al modelo moderno de Arena con Vec<Node<T>> e índices usize.
• Mecánica de Bajo Nivel y Hardware: El modelo Arena almacena todos los nodos en un solo vector continuo en Heap. Los punteros tradicionales *next se reemplazan por índices Option<usize>. Esto elimina el 100% de las disputas con el Borrow Checker de Rust, permite construir grafos y listas doblemente enlazadas sin unsafe, y aprovecha al máximo la caché L1.
• ⚠️ Trampa Clásica del Trainee / Junior: Olvidar la condición de parada del caso base como primera línea de la función recursiva, consumiendo los 2-8 MB de la pila del hilo hasta causar un colapso irrecuperable por Stack Overflow.

04. Tablas Hash, Pilas, Colas y Pila Monótona#

Resumen: Estructuras asociativas y lineales fundamentales: Swiss Table, LIFO en Vec, FIFO en VecDeque y Monotonic Stack.

🔗 Código Fuente Editable en Mermaid: 04-hash-tables-stacks-queues-monotonic.mmd

🔍 Guía de Lectura Visual Paso a Paso#

• Componentes en el Diagrama: Cuatro cuadrantes: 1) HashMap<K, V> detallando el sondeo de control de 1 byte por bucket y búsqueda SIMD. 2) Pila LIFO en Vec<T> insertando y retirando en el extremo superior en O(1). 3) Cola FIFO en VecDeque<T> como búfer circular con punteros head y tail que envuelven la capacidad sin reacomodar elementos. 4) Pila Monótona ilustrando la expulsión en cadena de elementos no conformes al ingresar un nuevo valor para resolver el problema del 'Next Greater Element'.
• Mecánica de Bajo Nivel y Hardware: La pila monótona mantiene una secuencia estrictamente ordenada (por ejemplo, decreciente). Al procesar un arreglo, cada elemento se apila una sola vez y se desapila a lo sumo una vez; el total de pop() acumulados nunca excede N, garantizando tiempo lineal O(N) amortizado.
• ⚠️ Trampa Clásica del Trainee / Junior: Simular colas en Rust usando vec.remove(0). Eliminar el índice 0 de un vector obliga a desplazar en memoria todos los elementos restantes una posición a la izquierda, convirtiendo la operación en un costoso cuello de botella de O(N).

05. Jerarquía de Árboles, Heaps, Grafos y Dijkstra#

Resumen: Árboles Binarios de Búsqueda, Min-Heaps en arreglos contiguos, recorridos BFS y relajación voraz de Dijkstra.

🔗 Código Fuente Editable en Mermaid: 05-trees-bst-heaps-graphs-dijkstra.mmd

🔍 Guía de Lectura Visual Paso a Paso#

• Componentes en el Diagrama: Cuatro secciones interconectadas: 1) Invariante BST (Izq < Raíz < Der) donde el recorrido In-Order genera un arreglo perfectamente ordenado. 2) Min-Heap indexado en arreglo plano contiguo (2i+1, 2i+2, (i-1)/2) sin punteros a hijos. 3) Grafo dirigido representado como lista de adyacencia Vec<Vec<usize>> recorrido por capas de distancia con cola FIFO (BFS). 4) Algoritmo de Dijkstra con Min-Heap realizando relajación voraz de distancias.
• Mecánica de Bajo Nivel y Hardware: Un Min-Heap no requiere estructuras de nodos dinámicos enlazados; se empaqueta íntegramente dentro de un arreglo contiguo Vec<T>. La relación padre-hijo se calcula directamente con aritmética de índices entera, garantizando cero sobrecosto de memoria por punteros.
• ⚠️ Trampa Clásica del Trainee / Junior: Aplicar Dijkstra sobre grafos con aristas de peso negativo. Dijkstra asume vorazmente que una vez extraído un nodo del heap, su distancia calculada es definitiva. Con pesos negativos se requiere el algoritmo de Bellman-Ford.

06. Paradigmas de Decisión: Greedy, Backtracking y DP#

Resumen: La tríada de optimización: elecciones voraces irreversibles, exploración sistemática podada y tablas DP.

🔗 Código Fuente Editable en Mermaid: 06-greedy-backtracking-dynamic-programming.mmd

🔍 Guía de Lectura Visual Paso a Paso#

• Componentes en el Diagrama: Tres columnas maestras: 1) Algoritmos Voraces (Greedy): Elección óptima local sin vuelta atrás (Interval Scheduling). 2) Backtracking: Árbol de decisiones DFS reutilizando un único arreglo mutable &mut Vec<T> mediante pasos simétricos de push(choice) y pop() tras retornar, incorporando podas tempranas (pruning). 3) Programación Dinámica: Descomposición en subproblemas superpuestos y tabulación de matrices 2D optimizadas a arreglos rodantes 1D.
• Mecánica de Bajo Nivel y Hardware: La Programación Dinámica se diferencia del Backtracking en la presencia de subproblemas repetidos. Mientras que el Backtracking explora ramas potencialmente redundantes, la Programación Dinámica almacena el resultado del subproblema en una tabla para responder en O(1) en consultas posteriores.
• ⚠️ Trampa Clásica del Trainee / Junior: Olvidar ejecutar el pop() simétrico al retornar de una llamada de Backtracking. Si el estado del camino no se restaura, las siguientes ramas exploradas heredarán decisiones contaminadas.

07. Manipulación de Bits, Tries y Disjoint Set Union (DSU)#

Resumen: Estructuras de datos especializadas: operaciones a nivel de ALU, árboles de prefijos y conjuntos disjuntos.

🔗 Código Fuente Editable en Mermaid: 07-bits-tries-union-find-dsu.mmd

🔍 Guía de Lectura Visual Paso a Paso#

• Componentes en el Diagrama: Tres paneles de alto impacto: 1) Manipulación de bits en registros de hardware (u32/u64), ilustrando el truco de Brian Kernighan (n & (n - 1)) y vectores de bits capaces de almacenar 32,000 banderas booleanas en solo 4 KB de RAM. 2) Árbol de prefijos (Trie) demostrando inserción y búsqueda de cadenas en tiempo proporcional a su longitud O(L), con soporte para comodines. 3) Disjoint Set Union (DSU) con compresión de caminos (Path Compression) y unión por rango (Union by Rank).
• Mecánica de Bajo Nivel y Hardware: La compresión de caminos aplana los árboles del bosque de conjuntos de modo que cada nodo apunte directamente al representante de la raíz. Combinado con unión por rango, el tiempo amortizado por operación se reduce a la función de Ackermann inversa O(lpha(N)) ≤ 4, siendo prácticamente constante en cualquier aplicación del mundo real.
• ⚠️ Trampa Clásica del Trainee / Junior: En operaciones de bits en Rust, intentar desplazar un entero por una cantidad igual o mayor a su ancho en bits (como 1u32 << 32). En modo debug esto genera un pánico inmediato por desbordamiento; se debe emplear 1u64 o rotaciones seguras.

08. Consultas de Rango: Fenwick, Segment Trees y LFU Cache#

Resumen: Estructuras de alto rendimiento: Fenwick Tree (BIT), Segment Tree en 4*N, algoritmo de Kadane y caché LFU en O(1).

🔗 Código Fuente Editable en Mermaid: 08-fenwick-segment-tree-kadane-lfu.mmd

🔍 Guía de Lectura Visual Paso a Paso#

• Componentes en el Diagrama: Cuatro cuadrantes de nivel Staff: 1) Fenwick Tree / BIT aislando el bit menos significativo con i & i.wrapping_neg() para actualizar y consultar sumas de prefijo en O(log N). 2) Segment Tree almacenado en arreglo continuo de tamaño 4N descomponiendo intervalos arbitrarios [L, R]. 3) Algoritmo de Kadane 1D y circular, con reducción 2D a pares de filas. 4) LFU Cache en O(1) estricto implementado mediante tabla hash de claves, tabla hash de frecuencias con listas doblemente enlazadas y rastreo de min_freq.
• Mecánica de Bajo Nivel y Hardware: El Fenwick Tree calcula la suma acumulada de un subrango [L, R] mediante la resta algebraica query(R) - query(L - 1). Al indexarse en base 1 y utilizar la potencia de 2 del bit menos significativo, cada celda cubre un intervalo canónico precomputado.
• ⚠️ Trampa Clásica del Trainee / Junior: Indexar el Fenwick Tree desde la posición 0. Al calcular 0 & (-0), la operación resulta en 0, atrapando el bucle de actualización en un ciclo infinito de tiempo de CPU.

09. Sistemas Distribuidos y Algoritmos Probabilísticos#

Resumen: Estructuras probabilísticas de escala web: Bloom Filters, HyperLogLog, Inverted Index, Simhash y Anillo de Hash Consistente.

🔗 Código Fuente Editable en Mermaid: 09-probabilistic-distributed-consistent-hashing.mmd

🔍 Guía de Lectura Visual Paso a Paso#

• Componentes en el Diagrama: Cuatro bloques de sistemas a gran escala: 1) Filtro de Bloom con k funciones hash sobre un arreglo de bits compacto que garantiza Cero Falsos Negativos. 2) HyperLogLog (HLL) estimando cardinalidades masivas contando ceros iniciales en registros hash con media armónica. 3) Índice invertido con listas de posteo y ponderación TF-IDF, complementado con huellas Simhash de 64 bits para deduplicación por distancia Hamming ≤ 3. 4) Anillo de Hash Consistente con nodos virtuales mapeados sobre un BTreeMap en Rust para enrutamiento logarítmico O(log V).
• Mecánica de Bajo Nivel y Hardware: El Hash Consistente soluciona el problema de la redistribución masiva de datos en clústeres distribuidos. Con el esquema clásico hash(key) % N, agregar o eliminar 1 servidor invalida casi el 100% de las llaves en caché. Con el anillo consistente, únicamente una fracción mínima K / N de llaves se reubica hacia el nodo sucesor horario.
• ⚠️ Trampa Clásica del Trainee / Junior: Intentar eliminar elementos de un Filtro de Bloom estándar poniendo bits en 0. Dado que múltiples elementos pueden compartir los mismos bits seteados por distintas funciones hash, apagar un bit destruye la información de pertenencia de otros elementos válidos.

📊 Matriz Completa de los 70 Diagramas de Sesión#

Cada uno de los 70 días del plan de estudios cuenta con un diagrama SVG dedicado (860x420) y su respectivo archivo editable en Mermaid .mmd. Todos los enlaces están interconectados con las lecciones teóricas correspondientes:

🛠️ Guía de Edición y Extensión (.mmd)#

Todos los diagramas de esta suite fueron diseñados para ser tanto consumibles de forma visual estática (SVG) como modificables de manera viva por estudiantes y docentes a través de su código fuente en Mermaid (.mmd).

¿Cómo abrir y editar los archivos .mmd?#

1. Visual Studio Code: Instala la extensión oficial Mermaid Chart o Markdown Preview Mermaid Support para visualizar los cambios en tiempo real.
2. Mermaid Live Editor: Abre el editor en línea mermaid.live y copia el contenido íntegro de cualquier archivo en diagrams/sources/ para ajustar nodos, colores o añadir comentarios.
3. Regeneración de la Suite: Si modificas los metadatos o requieres actualizar los SVGs, ejecuta los generadores de la carpeta de scratch para reconstruir y validar automáticamente toda la suite con cero errores XML.