README

Kineto es un motor de ejecución (runtime) asíncrono para PHP, diseñado para ofrecer una Developer Experience (DX) moderna e instantánea, similar a Vite o Next.js, pero aplicada al backend.

Olvídate de detener y reiniciar el servidor manualmente o de configuraciones complejas con Docker.
Kineto detecta tus cambios y recarga tu aplicación en milisegundos sin cerrar el puerto TCP.

🚀 Características Principales

• ⚡ Hot Reload Inteligente
  Detecta cambios en tus archivos y reinicia el worker instantáneamente sin tumbar el servidor principal.

• 🔌 Zero Downtime Reload
  Mantiene el socket TCP abierto en el proceso padre, evitando errores de
  Address already in use.

• 💻 Windows & Linux Native
  Arquitectura híbrida basada en proc_open, compatible con Windows, Linux y macOS
  sin WSL ni Docker obligatorios.

• 🎨 Consola estilo Vite
  Feedback visual limpio, con colores, tiempos de carga y estado del servidor.

• 🪶 Ligero y Potente
  Construido sobre ReactPHP, capaz de manejar miles de conexiones concurrentes con un consumo de memoria mínimo.

• 🧩 Framework Agnostic
  Diseñado como librería. Úsalo para tu propio microframework, API o servicio.

📦 Instalación

Instala Kineto como dependencia de tu proyecto:

composer require Erick-arch-bit/kineto-runtime

✨ Novedades (v2.0)

Kineto evoluciona de ser un simple runner a un entorno de desarrollo completo. Estas son las nuevas capacidades integradas:

♻️ Live Browser Reload

Experiencia "Zero-Click". Kineto inyecta automáticamente un script ligero en tus respuestas HTML.

• Al guardar un archivo en tu editor, el servidor se reinicia en el backend.
• El navegador detecta el evento, se reconecta y refresca la página automáticamente.

🚨 Rescue Mode

Si tu código falla (Error de sintaxis o Excepción), el servidor no se detiene.

• Kineto intercepta el error y renderiza una pantalla interactiva en el navegador.
• Visualiza el stack trace, el mensaje de error y resalta la línea exacta de código donde ocurrió el fallo.

🗄️ Database Connection Pool

Gestor de base de datos de alto rendimiento incluido.

• Mantiene un pool de conexiones PDO vivas en memoria.
• Elimina la latencia de conexión (Handshake) en cada petición.
• Recicla las conexiones automáticamente, evitando fugas de memoria.

📂 Static File Server

Servidor de archivos estáticos (.css, .js, imágenes) seguro y no bloqueante.

• Utiliza Streams asíncronos para servir archivos grandes sin consumir RAM excesiva.
• Protegido contra ataques de Path Traversal.

🛠️ Guía de Uso: Base de Datos

Kineto incluye un Facade DB para interactuar con el Pool de conexiones de forma segura y rápida. Ya no necesitas instanciar new PDO().

use Kineto\Runtime\Database\DB;

// 1. SELECT (Retorna array asociativo)
$users = DB::query("SELECT * FROM users WHERE active = 1");

// 2. INSERT / UPDATE
// Usa '?' para prevenir Inyección SQL automáticamente.
DB::query("INSERT INTO logs (message, level) VALUES (?, ?)", ["Error crítico", 1]);

// 3. Obtener una sola fila (Helper)
$user = DB::first("SELECT * FROM users WHERE id = ?", [42]);

⚙️ Configuración del Kernel (app.php)

use Kineto\Runtime\Database\DatabasePool;
use Kineto\Runtime\Support\StaticFileHandler;
use Dotenv\Dotenv;

// 1. Cargar Variables de Entorno
$dotenv = Dotenv::createImmutable(__DIR__);
$dotenv->safeLoad();

// 2. Inicializar Pool de BD (Solo se ejecuta una vez al arranque)
DatabasePool::init([
    'host'     => $_ENV['DB_HOST'] ?? '127.0.0.1',
    'database' => $_ENV['DB_DATABASE'] ?? 'test',
    'username' => $_ENV['DB_USERNAME'] ?? 'root',
    'password' => $_ENV['DB_PASSWORD'] ?? '',
]);

return new class implements \Kineto\Runtime\Contracts\KernelInterface {
    private $staticHandler;

    public function __construct() {
        // Define tu carpeta pública para assets
        $this->staticHandler = new StaticFileHandler(__DIR__ . '/public');
    }

    public function handle($request) {
        // A. Intentar servir archivo estático primero
        $static = $this->staticHandler->serve($request->getUri()->getPath());
        if ($static) return $static;

        // B. Tu lógica del Framework / Router
        // ...
    }
};