Jiti simplifica la ejecución de TypeScript y ESM en Node.js, pero corregir errores en tiempo de ejecución requiere una configuración adecuada. El primer paso consiste en habilitar el generador de registros internos (logging) mediante la opción debug al instanciar el cargador.

import { createJiti } from 'jiti';

// Instanciar Jiti con salida de depuración activada
const runtime = createJiti(import.meta.url, { 
  debug: true,
  esm: true 
});

Al activar esta bandera, la consola volcará información crítica sobre el estado inicial, incluyendo la versión del runtime, el estado de la caché del sistema de archivos y las configuraciones de interoperabilidad de módulos. Estos datos son fundamentales para verificar que el entorno de carga coincide con las expectativas del proyecto.

Interpretación de la salida de consola

El subsistema de registro de Jiti, ubicado internamente en las utilidades principales, proporciona visibilidad sobre el flujo de trabajo del cargador. Es fundamental prestar atención a los siguientes eventos:

• Resolución de módulos: Cómo y dónde se localizan los archivos.
• Transformación de código: El proceso de transpilación de TypeScript a JavaScript.
• Estado de caché: Confirmación de si se está utilizando una versión cacheada o recompilando.

Un ejemplo de salida tras la inicialización correcta podría ser:

[jiti:init] v1.20.0 | fs-cache: activado | interop-defaults: verdadero

Verificar estas líneas ayuda a asegurar que Jiti no esté ejecutándose con una configuración heredada o incorrecta.

Configuración de Source Maps para trazabilidad precisa

Para que los errores de ejecución apunten a las líneas correctas en los archivos .ts originales en lugar del JavaScript compilado, es imperativo configurar los mapas de origen en tsconfig.json.

{
  "compilerOptions": {
    "sourceMap": true,
    "inlineSourceMap": false,
    "declarationMap": true
  }
}

Con esta configuración, cuando se produzca una excepción no manejada, el stack trace en la consola referenciará directamente los archivos fuente de TypeScript, facilitando la localización inmediata del fallo.

Integración con el inspector de Node.js

Para problemas lógicos complejos, la combinación de los logs de Jiti con el inspector nativo de Node.js permite una depuración interactiva. Se puede iniciar una sesión de inspección utilizando los flagos estándar de Node junto con el registro de Jiti:

node --inspect-brk -r jiti/register src/index.ts

El comando anterior detendrá la ejecución en la primera línea y permitirá conectar herramientas como Chrome DevTools o VS Code para establecer puntos de interrupción e inspeccionar variables en tiempo real.

Diagnóstico de fallos comunes mediante logs

El análisis de los registros permite categorizar y resolver incidencias frecuentes:

• Errores de resolución ("Cannot find module"): Indican discrepancias en las rutas o alias. Revisar la lógica de resolución es crucial.
• Fallos de transpilación: Errores lanzados durante la transformación sugieren sintaxis incompatible.
• Estancamiento de caché: Si los cambios en el código no se reflejan, la caché del sistema de archivos puede estar obsoleta. Forzar su reconstrucción resolviendo este problema suele ser necesario.
• Conflictos con módulos nativos: Jiti posee lógica especial para módulos como typescript; los logs mostrarán si estas exclusiones se están aplicando correctamente.

Supervisión de rendimiento y consumo de memoria

Más allá de la corrección de errores, monitorear el rendimiento del cargador es vital. Es posible instrumentar el código para medir el uso de memoria durante la carga de módulos:

const medirMemoria = (etiqueta) => {
  const uso = process.memoryUsage();
  const heapEnMB = (uso.heapUsed / 1024 / 1024).toFixed(2);
  console.log(`[${etiqueta}] Heap usado: ${heapEnMB} MB`);
};

Integrando estas mediciones en puntos estratégicos de la aplicación, se pueden detectar fugas de memoria o cuellos de botella en el proceso de importación y compilación realizados por Jiti.