feat: integra renaser (kernel SASOS bare-metal) al monorepo

renaser —kernel asíncrono de espacio de direcciones único, no-POSIX,
`no_std` x86_64— entra al monorepo como su PROPIO workspace de Cargo,
no fusionado: usa toolchain nightly, target `x86_64-unknown-none` y
`panic = "abort"`, incompatibles con los perfiles globales de brahman.

- `renaser/` — copia del proyecto (sin su `.git`; el repo original
  conserva su historia standalone). Workspace propio con su
  `rust-toolchain.toml` y `.cargo/`.
- `exclude = ["renaser"]` en el workspace de brahman: Cargo lo trata
  como ajeno.
- El kernel de renaser path-depende `mirada-layout` cruzando la
  frontera de workspace — primer núcleo compartido. Semilla de la
  Fase 8 (compositor): geometría de teselado compartida, framebuffer
  nativo de renaser; smithay se queda en el lado Linux.

Verificado: `cargo build -p boot` compila kernel + imagen UEFI con
mirada-layout enlazado para bare-metal.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Cargo.toml

@@ -302,6 +302,13 @@ members = [
     "crates/apps/charka",
 ]
 
+# renaser — el SO bare-metal SASOS. Vive en el mismo repo pero es su
+# PROPIO workspace de Cargo: usa toolchain nightly, target
+# `x86_64-unknown-none` y `panic = "abort"`, incompatibles con los
+# perfiles globales de este workspace. Cargo lo trata como ajeno; los
+# crates compartidos se referencian por `path` cruzando la frontera.
+exclude = ["renaser"]
+
 [workspace.package]
 version = "0.1.0"
 edition = "2021"

renaser/.cargo/config.toml

@@ -0,0 +1,19 @@
+# =============================================================================
+#  renaser :: configuracion de cargo
+# -----------------------------------------------------------------------------
+#  El kernel se compila contra el target NATIVO precompilado `x86_64-unknown-none`
+#  (bare-metal, soft-float, sin SSE). No hay JSON propio ni `build-std`: cero
+#  burocracia del compilador, aislamiento de arquitectura sin friccion.
+# =============================================================================
+
+[unstable]
+# Dependencias de artefacto (RFC 3028): permiten que el miembro `boot` ordene a
+# cargo compilar el kernel para `x86_64-unknown-none` de forma automatica y
+# reciba la ruta de su ELF. Sigue siendo una funcion inestable (nightly).
+bindeps = true
+
+[alias]
+# Compila unicamente el kernel, en aislamiento de arquitectura.
+kernel = "build -p kernel --target x86_64-unknown-none"
+# Construye la imagen UEFI y abre QEMU (equivale a `cargo run -p boot`).
+qemu = "run -p boot"

renaser/.gitignore

@@ -0,0 +1,24 @@
+# =============================================================================
+#  renaser :: archivos que NO se versionan
+# =============================================================================
+
+# Artefactos de compilacion de Rust — kernel, boot y apps WASM.
+/target
+/kernel/target
+/apps/*/target
+
+# Bloqueo de dependencias del kernel: se genera al compilarlo en aislamiento.
+# La verdad de versiones la fija el Cargo.lock raiz — el kernel es dependencia
+# de artefacto de `boot` y se resuelve con el.
+/kernel/Cargo.lock
+
+# Ajustes locales del entorno de desarrollo (personales, no compartidos).
+/.claude/settings.local.json
+
+# Capturas temporales de QEMU.
+*.ppm
+*.png.tmp
+
+# Borrador de trabajo local — puede contener notas y credenciales; nunca se
+# versiona. (Fue subido por error y purgado del historial; ver el README.)
+/renaser.txt

renaser/ARCHITECTURE.md

@@ -0,0 +1,173 @@
+# renaser — Arquitectura
+
+Este documento describe la arquitectura del kernel `renaser` subsistema a
+subsistema. Para el estado por fases, ver `ROADMAP.md`.
+
+## 1. Filosofía
+
+renaser es un **SASOS** — *Single Address Space Operating System*. No hay un
+espacio de direcciones por proceso ni cambios de contexto de hardware: todo el
+sistema —kernel y aplicaciones— comparte una única RAM plana.
+
+El aislamiento NO lo da la MMU ni los anillos de privilegio de la CPU. Lo da el
+**software**: las aplicaciones se distribuyen como bytecode WebAssembly y se
+ejecutan dentro de un intérprete que acota matemáticamente cada acceso a
+memoria. Una aplicación solo puede hacer aquello para lo que el kernel le haya
+inyectado una *capacidad* (una función de host). Lo que no está importado no
+tiene camino físico que recorrer.
+
+La interfaz es **visual desde el primer microsegundo**. No hay TTY; el texto se
+rasteriza como gráfico vectorial. "El texto es un caso particular del dibujo."
+
+## 2. La cadena de arranque
+
+```
+Firmware UEFI  →  crate `bootloader` 0.11  →  kernel::_start  →  kernel_main
+```
+
+El miembro `boot/` (que corre en el **anfitrión**) toma el ELF del kernel,
+lo fusiona con el cargador `bootloader` 0.11 en una imagen de disco UEFI GPT y
+la lanza en QEMU con el firmware OVMF. El cargador deja la CPU en modo largo de
+64 bits, mapea el kernel y le entrega una `BootInfo` con el framebuffer GOP.
+
+## 3. Estructura del espacio de trabajo
+
+El workspace tiene **un solo miembro**, `boot`. El `kernel` y las `apps` están
+**excluidos** a propósito:
+
+- El kernel es `#![no_std] #![no_main]` y define su propio `_start`. Si fuese
+  miembro del workspace, `cargo build` intentaría compilarlo para el anfitrión
+  y fallaría por un símbolo `_start` duplicado con el `crt0` del sistema.
+- Por eso el kernel se construye **solo** como *dependencia de artefacto*
+  (RFC 3028) de `boot`, que le fija el target `x86_64-unknown-none`.
+- Las apps WASM tienen su propio target (`wasm32-unknown-unknown`) y se
+  compilan aparte.
+
+El kernel usa el target **nativo precompilado** `x86_64-unknown-none`: sin
+target JSON propio, sin `build-std`. Soft-float y sin SSE, para que las
+interrupciones no corrompan registros de punto flotante.
+
+## 4. Subsistemas del kernel
+
+### `grafico` — el sustrato visual
+`Color` (RGB de 24 bits, independiente del hardware), `Pantalla` (el
+framebuffer GOP físico, envuelto en seguridad) y `Lienzo` (el búfer intermedio
+en RAM). Toda composición ocurre en el `Lienzo`; `Pantalla::presentar` lo
+vuelca de un solo gesto con escrituras volátiles — **doble búfer**, sin
+desgarros. `codificar` traduce un `Color` al formato nativo del framebuffer.
+
+### `consola` — la superficie de texto e imagen
+Une `Lienzo` + `Pantalla` + una pluma de escritura. Rasteriza glifos con
+`fontdue` y los funde sobre el lienzo mezclando por cobertura (anti-aliasing).
+También vuelca fotogramas crudos del userspace WASM. Es global, tras un `Mutex`.
+
+### `baliza` — la red de seguridad visual
+Publica de forma atómica y sin cerrojos los datos mínimos del framebuffer. Los
+manejadores `#[panic_handler]` y `#[alloc_error_handler]` los usan para pintar
+una franja de advertencia —**roja** si el sistema colapsa, **naranja** si el
+heap se agota— escribiendo directo sobre el silicio, sin confiar en el heap ni
+en estructura dinámica alguna.
+
+### `gdt` — cimientos del manejo de fallos
+GDT propia con segmentos de código y datos del kernel, y un TSS cuyo único
+cometido es alojar un **stack de emergencia** (IST) para el doble fallo: ni un
+desbordamiento de la pila del kernel impide su diagnóstico.
+
+### `interrupts` — la tabla de reflejos
+IDT con manejadores de excepción de CPU (breakpoint recuperable; el resto,
+fatales → `panic!`) e interrupciones de hardware. El doble fallo se atiende
+sobre el stack de emergencia del TSS.
+
+### `pic` — el latido del hardware
+Remapea el par 8259 (PIC) fuera del rango de las excepciones de CPU y programa
+el temporizador de intervalos (PIT). El teclado (IRQ1) deposita scancodes en
+una cola lock-free. `desenmascarar` abre una línea de IRQ concreta —la del
+disco, descubierta en tiempo de ejecución (Fase 6.2)—.
+
+### `drivers` — el hardware que el kernel conquista (Fases 6.1, 6.2)
+A diferencia del framebuffer o el temporizador —que el firmware sirve en
+bandeja—, el disco hay que DESCUBRIRLO y reclamarlo.
+- `pci` — `CamPuertos`: acceso al espacio de configuración del bus PCI por el
+  mecanismo #1 (puertos `0xCF8`/`0xCFC`); `linea_irq` lee la IRQ del dispositivo.
+- `disco` — el disco virtio-blk. Un asignador de marcos por **mapa de bits**
+  —con liberación real— reparte páginas físicas para el DMA; `KernelHal`
+  implementa el `trait Hal` de `virtio-drivers` (traducción de direcciones,
+  memoria rebote para el DMA); el `VirtIOBlk` se monta una vez y persiste tras
+  un `Mutex`. La E/S de bloques es **asíncrona** (Fase 6.2): `EsperaDisco` es un
+  `Future` que envía la petición por la API no bloqueante de `virtio-drivers`,
+  cede la CPU y se reanuda con la IRQ del disco (`atender_irq`). `bloquear_en`
+  conduce ese `Future` desde los contextos síncronos durmiendo la CPU con
+  `hlt`; sobre él, `leer_sectores`/`escribir_sectores` sirven al grafo de
+  objetos. La IRQ del disco se enruta por el PIC 8259, no por el IOAPIC.
+
+### `almacen` — el grafo de objetos direccionado por contenido (Fase 6.1c)
+renaser no tiene un sistema de archivos plano POSIX: tiene un DAG de objetos.
+Un `Objeto` es una carga útil de bytes y una lista de aristas (hashes de
+hijos). La identidad de un objeto es el hash BLAKE3 de su forma serializada
+(`postcard`) — de ahí integridad (un objeto se verifica al leerlo) y
+deduplicación (contenido idéntico, un solo registro). El disco es un **log**:
+el sector 0 es el superbloque (magia, versión, cursor, raíz); tras él se anexan
+los registros de objetos. Un índice hash→sector se reconstruye al arrancar
+recorriendo el log. Las capacidades `sys_object_*` exponen el grafo al
+userspace.
+
+### `memory` — el heap dinámico
+`linked_list_allocator` como `#[global_allocator]` sobre una región estática de
+64 MiB en `.bss`. Desbloquea `alloc::*` — `Box`, `Vec`, `BTreeMap`, `Arc`.
+
+### `async_system` — el reactor cooperativo
+- `task` — `Task`: un `Future` anclado (`Pin<Box<dyn Future>>`) con `TaskId`.
+- `executor` — el `Executor`: censo de tareas, cola de listas, y un `hlt`
+  controlado cuando no hay trabajo.
+- `waker` — un `Waker` que reinyecta el `TaskId` en la cola al despertar.
+- `teclado` — los canales de scancodes. Cada app abre el suyo; la IRQ1 **difunde**
+  cada scancode a todos, de modo que varias apps reciben la entrada en paralelo.
+- `reloj` — convierte la IRQ0 (PIT, 100 Hz) en el `Future` `EsperaFrame`, que se
+  resuelve en el siguiente pulso. Es el **compás de los fotogramas**: una tarea
+  WASM hace su trabajo de un fotograma y `.await`-ea el siguiente.
+
+Las interrupciones de hardware no conmutan el contexto de la CPU: **despiertan
+tareas**. El kernel avanza cooperativamente.
+
+### `texto` — tipografía vectorial
+Empotra un `.ttf` en el binario (`include_bytes!`) y lo rasteriza con `fontdue`
+glifo a glifo, bajo demanda.
+
+### `wasm` — el escudo de aislamiento
+- `mod` — el runtime y la `AplicacionWasm`: una instancia **persistente** entre
+  fotogramas (`Store` + `TypedFunc<(), ()>` + región). El ABI del userspace es
+  `init()` (una vez) y `tick()` (un fotograma, y retorna). Dos guardarraíles
+  acotan a cada app: el **temporal** —un presupuesto de **combustible** (`fuel`)
+  por `tick`; agotarlo la desaloja (baliza púrpura)— y el **espacial** —un techo
+  de memoria lineal vía `Store::limiter`; rebasarlo la desaloja (baliza
+  amarilla)—. En ambos casos `wasmi` lanza una trampa, el kernel recupera el
+  mando y el sistema no sufre. El `Drop` de `AplicacionWasm` reconcilia el ciclo
+  de vida: da de baja su canal de teclado.
+- `env` — la **matriz de capacidades**: las funciones de host que el módulo
+  WASM puede invocar. Hoy son siete:
+  - `sys_render_frame(ptr, len)` — compone un fotograma dentro de la **región**
+    de pantalla asignada a la app. El kernel valida **matemáticamente** que
+    `[ptr, ptr+len)` cae dentro de la memoria lineal del módulo, y que el
+    tamaño es el de la región, antes de leer un byte; si no, aborta la app.
+  - `sys_get_scancode()` — entrega, sin bloquear, el siguiente scancode del
+    canal de teclado **propio** de la app.
+  - `sys_object_put` / `sys_object_datos` / `sys_object_hijo` /
+    `sys_object_raiz` / `sys_object_fijar_raiz` — el acceso al grafo de objetos
+    persistente (ver `almacen`): grabar un objeto, leer su carga útil, recorrer
+    sus aristas, y leer o fijar la raíz del DAG. Cada puntero que la app
+    entrega se valida contra su memoria lineal, igual que en `sys_render_frame`.
+
+Todo puntero inválido aborta la app —es su culpa: el `Error` se traduce en una
+trampa de WASM, la app se desaloja y el resto del sistema sigue—. Un fallo del
+almacenamiento, en cambio, no es culpa de la app: se le devuelve un código de
+error que ella decide cómo afrontar.
+
+## 5. Restricciones de ingeniería
+
+- **Escrituras volátiles** obligatorias para framebuffer y MMIO.
+- **`unsafe`** confinado en células mínimas, cada una con un contrato
+  `SEGURIDAD:` y envuelta en una abstracción segura. `unsafe_op_in_unsafe_fn`
+  está en `deny`.
+- **Alineación**: 16 bytes para estructuras genéricas; 4096 (página) para
+  buffers de asignador y el lienzo de respaldo.
+- **`no_std` estricto**: `core` + `alloc`; nada de `std`.

renaser/CHANGELOG.md

@@ -0,0 +1,457 @@
+# Registro de cambios — renaser
+
+Registro técnico detallado, fase a fase, en orden cronológico. Formato
+inspirado en *Keep a Changelog*. Para la crónica en lenguaje llano, ver
+`DIARIO.md`; para el estado y los planes, `ROADMAP.md`.
+
+---
+
+## Fase 1 — El primer microsegundo — 2026-05-21
+
+### Infraestructura
+- Espacio de trabajo Cargo, `kernel/Cargo.toml`, `.cargo/config.toml`,
+  `rust-toolchain.toml`.
+- Target inicial: especificación JSON propia `x86_64-renaser.json` — PIC,
+  soft-float, sin SSE, enlazador `lld`.
+
+### Añadido
+- `kernel/src/main.rs`: punto de entrada con el macro `entry_point!` de
+  `bootloader_api` 0.11.
+- Adopción y verificación con seguridad de tipos del framebuffer GOP (ancho,
+  alto, formato de píxel, *stride*).
+- Lienzo intermedio estático de 8 MiB en `.bss`, alineado a página: la técnica
+  de doble búfer para evitar parpadeos.
+- `#[panic_handler]` que dibuja una franja roja directamente sobre el
+  framebuffer mediante escrituras volátiles.
+- Dependencias: `bootloader_api` 0.11, `x86_64` 0.15, `embedded-graphics` 0.8.
+
+### Notas
+- Corrección clave: `bootloader` (constructor de imagen, lado anfitrión) no es
+  `bootloader_api` (la API `no_std` que consume el kernel).
+
+---
+
+## Fase 1.5 — Empaquetado y arranque — 2026-05-21
+
+### Cambiado
+- Migración del target del kernel: de la JSON propia `x86_64-renaser.json` al
+  target nativo precompilado `x86_64-unknown-none`. Elimina `build-std` y la
+  burocracia de compilador asociada.
+
+### Añadido
+- Miembro `boot/`: orquestador de anfitrión. Dependencia de artefacto
+  (RFC 3028) sobre el kernel; construcción de la imagen de disco UEFI con
+  `bootloader::UefiBoot`; lanzador de QEMU.
+
+### Toolchain
+- Instalación de la toolchain nightly (la máquina solo tenía la estable).
+
+### Corregido
+- Los nightly recientes exigen `-Zjson-target-spec` para usar specs JSON
+  (resuelto al migrar al target nativo).
+- Sintaxis del acelerador de QEMU: `-machine q35,accel=kvm:tcg`.
+
+### Verificado
+- Arranque en QEMU: superficie índigo limpia a 1280×800.
+- Baliza de pánico (franja roja) confirmada inyectando un pánico de prueba.
+
+---
+
+## Fase 2.0 — Cimientos del manejo de fallos — 2026-05-21
+
+### Añadido
+- `kernel/src/gdt.rs`: GDT propia, TSS y un stack de emergencia (IST)
+  reservado para el manejador de doble fallo.
+- `kernel/src/interrupts.rs`: IDT con manejadores de excepción de CPU. El
+  breakpoint (#BP) es recuperable; #UD, #DE, #GP, #PF y #DF son fatales y
+  encienden la baliza.
+- `#![feature(abi_x86_interrupt)]`.
+
+### Corregido
+- La GDT debe recargar los registros SS/DS/ES con un segmento de datos del
+  kernel: el cargador deja `SS = 0x10`, valor que en la GDT nueva pasa a ser el
+  descriptor del TSS; el primer `iretq` de una rutina de excepción provocaba un
+  #GP. Diagnosticado con la traza `-d int` de QEMU.
+
+### Verificado
+- Excepción `int3` atrapada y superada; línea-latido teal dibujada como prueba.
+
+---
+
+## Fase 2.1 — Interrupciones de hardware — 2026-05-21
+
+### Añadido
+- `kernel/src/pic.rs`: remapeo del par 8259 (PIC) fuera del rango de las
+  excepciones (vectores 0x20+); programación del temporizador PIT a 100 Hz;
+  IRQ1 de teclado.
+- Bucle de render en `kernel_main`, despertado por el temporizador, en
+  sustitución del `hlt` estático.
+
+### Verificado
+- La línea-latido se anima (temporizador en marcha); las pulsaciones de teclado
+  inyectadas cambian el cuadro-eco (teclado en marcha).
+
+---
+
+## Fase 3 — Memoria dinámica y reactor asíncrono — 2026-05-21
+
+### Añadido
+- `kernel/src/memory/`: `linked_list_allocator` como `#[global_allocator]`
+  sobre una región estática en `.bss`.
+- `#[alloc_error_handler]`: franja naranja de agotamiento de memoria.
+  `#![feature(alloc_error_handler)]`.
+- `kernel/src/async_system/`: reactor cooperativo — `Executor`, `Task`/`TaskId`,
+  `Waker` (vía `alloc::task::Wake`) y `ScancodeStream`.
+- `kernel/src/texto.rs`: rasterización de tipografía vectorial con `fontdue`;
+  TTF Adwaita Mono empotrada con `include_bytes!`.
+- Dependencias: `linked_list_allocator` 0.10, `spin` 0.9, `crossbeam-queue`
+  0.3, `futures-util` 0.3, `fontdue` 0.9.
+
+### Cambiado
+- Heap ampliado de 16 MiB a 64 MiB: `fontdue`, al analizar una tipografía real,
+  agotaba los 16 MiB iniciales. El `#[alloc_error_handler]` lo delató pintando
+  la franja naranja — el guardarraíl funcionó en silicio real.
+
+### Corregido
+- El modo `no_std` de `fontdue` está condicionado a su feature `hashbrown`; sin
+  ella recae en `std`. Se fija `default-features = false, features = ["hashbrown"]`.
+
+### Verificado
+- Rótulo de bienvenida rasterizado al arranque; el texto tecleado aparece en vivo.
+
+---
+
+## Fase 4 — El escudo de aislamiento WASM — 2026-05-21
+
+### Añadido
+- `kernel/src/wasm/`: intérprete `wasmi` 1.0.9 en modo `no_std`. `env.rs`
+  define la matriz de capacidades — exactamente dos funciones de host:
+  `sys_render_frame(ptr, len)`, con validación infranqueable de los límites de
+  la memoria lineal, y `sys_get_scancode()`.
+- `apps/hello_wasm/`: primera aplicación del userspace — módulo
+  `wasm32-unknown-unknown` (cdylib), un cuadrado móvil dirigido por teclado. Se
+  empotra en el kernel con `include_bytes!`.
+- Dependencia: `wasmi` 1.0.
+
+### Cambiado
+- El kernel se EXCLUYE del espacio de trabajo (`exclude = ["kernel", "apps"]`):
+  al añadir `wasmi`, `cargo build` intentaba compilar el kernel para el
+  anfitrión y fallaba por un símbolo `_start` duplicado. El kernel pasa a
+  construirse únicamente como dependencia de artefacto de `boot`.
+
+### Corregido
+- `wasmi` `no_std` necesita `default-features = false, features = ["hash-collections"]`.
+- `wasmi` 1.0.9 usa `Linker::instantiate_and_start` (no existe `instantiate`).
+
+### Verificado
+- La aplicación WASM pinta su propia superficie y responde a las pulsaciones de
+  teclado inyectadas, sin más vía hacia el kernel que las dos capacidades.
+
+---
+
+## Mantenimiento — Estructura, documentación e integración — 2026-05-21
+
+### Cambiado
+- Refactorización: `main.rs` dividido de 692 a ~155 líneas. Se extraen los
+  módulos `sync.rs`, `grafico.rs`, `consola.rs` y `baliza.rs`. Sin cambios de
+  comportamiento (verificado en QEMU).
+
+### Añadido
+- Documentación: `CLAUDE.md`, `README.md`, `ARCHITECTURE.md`, `ROADMAP.md`,
+  `CHANGELOG.md` y `DIARIO.md`.
+- Integración con git: repositorio inicializado, remoto `origin` en Gitea,
+  `.gitignore`.
+
+### Seguridad
+- `renaser.txt` —un borrador de trabajo que contenía una credencial— se subió
+  por error en el commit inicial. Se purgó de todo el historial con
+  `git filter-branch` y se reescribió el remoto con `push --force`. La
+  credencial expuesta debe rotarse.
+
+---
+
+## Fase 5 — Multitarea cooperativa, guardarrail de fuel y reloj — 2026-05-22
+
+Unificación de la Fase 3 (reactor) y la Fase 4 (WASM): el userspace deja de ser
+una sola app que monopoliza la CPU y pasa a ser un conjunto de aplicaciones
+cooperativas, aisladas también en el TIEMPO.
+
+### Añadido
+- `kernel/src/async_system/reloj.rs`: convierte la IRQ0 (PIT, 100 Hz) en una
+  primitiva asíncrona. `CONTADOR_PULSOS` (`AtomicU64`) y `EsperaFrame`, un
+  `Future` que se resuelve en el siguiente pulso — la unidad de cesión
+  cooperativa del userspace. Censo de wakers tras `Mutex`, drenado por la IRQ0.
+- `kernel/src/wasm`: ABI de fotograma. `AplicacionWasm` —instancia PERSISTENTE
+  entre fotogramas (`Store` + `TypedFunc<(), ()>` + región)— sustituye al
+  `wasm::ejecutar` de fuego-y-olvido. El módulo del userspace exporta ahora
+  `init()` (una vez) y `tick()` (un fotograma, y retorna).
+- Escudo de combustible: `Engine` con `Config::consume_fuel(true)` y
+  `CompilationMode::Eager` (el `fuel` mide solo ejecución). Presupuesto recargado
+  antes de cada `tick` — `FUEL_ARRANQUE` (20 M) y `FUEL_FOTOGRAMA` (2 M).
+- `kernel/src/wasm/env.rs`: capacidad `sys_render_frame` con **regiones de
+  dibujo** — cada fotograma se compone desplazado por el `(offset_x, offset_y)`
+  de la app; un tamaño ajeno a la región se rechaza. Canal de teclado **por
+  aplicación**: la IRQ1 difunde cada scancode a TODOS los canales, de modo que
+  varias apps reciben la entrada en paralelo sin robársela.
+- `kernel/src/grafico.rs`: `RegionPantalla` y `Color::DESALOJO` (púrpura).
+- `apps/discola/`: aplicación WASM construida para portarse mal — su `tick` es
+  un bucle cerrado. Demuestra el guardarrail de fuel en vivo.
+
+### Cambiado
+- `apps/hello_wasm`: migrada al ABI `init`/`tick`; su lienzo se dimensiona a la
+  región (480×560). El estado del cuadrado persiste en su memoria lineal.
+- `interrupts.rs`: la IRQ0 avanza el `reloj`; la IRQ1 difunde a los canales.
+- `consola.rs`: `volcar_marco` compone en una sub-región; `pintar_desalojo`
+  tatúa la baliza púrpura.
+- Contención de fallos: el subsistema WASM ya no usa `.expect()`. Toda falla
+  —carga, instanciación, desbordamiento, agotamiento de fuel— se devuelve como
+  `Result`; la tarea desaloja la app (baliza púrpura) y el kernel sigue vivo.
+
+### Verificado
+- QEMU: tres apps concurrentes. Dos instancias de `hello_wasm` (mismo bytecode,
+  regiones izquierda y derecha) renderizan y responden a W/A/S/D **en paralelo**,
+  con movimiento idéntico. La app díscola es desalojada en su primer fotograma
+  por agotamiento de combustible: su región queda púrpura y el sistema —kernel y
+  apps vecinas— no sufre un solo sobresalto.
+
+---
+
+## Fase 6.0 — Cuotas de memoria y ciclo de vida del userspace — 2026-05-22
+
+El aislamiento de las aplicaciones, que la Fase 5 hizo temporal (combustible),
+se completa ahora en la dimensión espacial (memoria) y se cierra la fuga de
+recursos del ciclo de vida.
+
+### Añadido
+- Techo de memoria lineal por aplicación: `4 MiB`. `wasm/mod.rs` construye un
+  `StoreLimits` (`StoreLimitsBuilder::memory_size` + `trap_on_grow_failure`) y lo
+  liga al `Store` con `Store::limiter`. Un `memory.grow` que rebase la cuota se
+  convierte en trampa; el kernel la captura y desaloja la app.
+- `FallaApp::SinMemoria` y `Color::DESALOJO_MEMORIA` (amarillo pálido). El
+  desalojo distingue la causa por color: púrpura (tiempo/aborto), amarillo
+  (memoria). La clasificación es robusta — `Error::as_trap_code()` da un código
+  público y unívoco: `TrapCode::GrowthOperationLimited`.
+- `Drop` para `AplicacionWasm`: al morir una app desalojada, su canal de teclado
+  se da de baja del censo de difusión de la IRQ1 — cierra la fuga señalada en la
+  Fase 5. `async_system::teclado` se reorganiza en `crear_canal` /
+  `registrar_canal` / `cerrar_canal`; el canal se inscribe al FINAL de la carga,
+  de modo que una carga fallida no deja canales huérfanos.
+- `apps/glotona/`: aplicación WASM construida para devorar memoria — su `tick`
+  invoca `memory.grow` sin freno. Demuestra el guardarrail espacial en vivo.
+
+### Verificado
+- QEMU: cuatro apps concurrentes. Las dos `hello_wasm` renderizan y responden al
+  teclado en paralelo; la app díscola es desalojada por combustible (franja
+  púrpura) y la app glotona por cuota de memoria (franja amarilla), ambas en su
+  primer fotograma, sin que el kernel ni las apps honradas se inmuten.
+
+---
+
+## Fase 6.1a — Sonda PCI y disco de pruebas — 2026-05-22
+
+Primer paso de la estrategia incremental hacia el almacenamiento: derribar el
+muro del descubrimiento de hardware antes de diseñar nada encima.
+
+### Añadido
+- `kernel/src/drivers/`: nuevo subsistema de drivers. `pci.rs` enumera el bus
+  PCI por fuerza bruta mediante el mecanismo de configuración #1 —puertos de E/S
+  `0xCF8` (dirección) y `0xCFC` (datos)—; recorre buses y dispositivos leyendo
+  el Vendor/Device ID, y localiza el disco virtio-blk (vendor `0x1AF4`, device
+  `0x1001`/`0x1042`), devolviendo su ubicación y sus seis BARs.
+- `kernel_main`: tras fundar la consola, sondea el bus PCI y deja constancia
+  visual del hallazgo.
+
+### Cambiado
+- `boot/src/main.rs`: forja un disco de pruebas `target/disk.img` (fichero
+  disperso de 32 MiB; se respeta si ya existe) y lo adjunta a QEMU como
+  `virtio-blk-pci`. **Corrección de plataforma:** la máquina `q35` es x86_64 y
+  exige la transmisión PCI; `virtio-blk-device` (su gemelo MMIO) es de ARM.
+
+### Verificado
+- QEMU: el kernel enumera el bus y reporta en pantalla
+  `virtio-blk en bus 0 dev 3 :: BAR0 E/S 0x6000` — un dispositivo virtio-blk
+  transicional (device `0x1001`), con su BAR0 en espacio de E/S. El muro del
+  descubrimiento PCI queda derribado; las cuatro apps del userspace siguen
+  operando sin alteración.
+
+---
+
+## Fase 6.1b — HAL, DMA y lectura del sector 0 — 2026-05-22
+
+Segundo paso del sustrato de almacenamiento: el diálogo real con el disco. El
+kernel monta el dispositivo virtio-blk y lee su primer sector por DMA.
+
+### Añadido
+- Dependencia `virtio-drivers` 1.13 (`no_std`, `default-features = false`,
+  feature `alloc`).
+- `kernel/src/drivers/disco.rs`:
+  - **Asignador de marcos** «bump» — reparte páginas físicas de 4 KiB para el
+    DMA, tomadas de la mayor región de RAM libre que el cargador reporta. No
+    libera: suficiente para una sonda (la gestión fina llegará con el grafo).
+  - **`KernelHal`** — implementa el `trait Hal` de `virtio-drivers`. `dma_alloc`
+    entrega marcos físicos a cero; `mmio_phys_to_virt` traduce los BARs (el
+    cargador mapea ≥ 4 GiB de memoria física, que cubre todo MMIO de PCI);
+    `share`/`unshare` usan un buffer rebote para que cualquier región del kernel
+    pueda viajar al dispositivo.
+  - **`montar_y_leer_sector0`** — enumera el bus, habilita E/S + memoria +
+    bus-master, monta el `PciTransport` y el `VirtIOBlk`, y lee el sector 0 por
+    **sondeo** del *used ring* (sin depender aún de interrupciones).
+- `kernel/src/drivers/pci.rs`: reescrito como `CamPuertos`, la implementación de
+  `ConfigurationAccess` de `virtio-drivers` sobre los puertos `0xCF8`/`0xCFC`.
+- `kernel_main` captura `physical_memory_offset` y la región de RAM de
+  `BootInfo`, funda el subsistema de disco y reporta el resultado de la sonda.
+
+### Cambiado
+- `boot/src/main.rs`: al forjar el disco de pruebas graba una firma
+  (`renaser-6.1b`) en su sector 0 — el testigo del viaje de ida y vuelta.
+
+### Verificado
+- QEMU: el kernel reporta `virtio-blk :: bus 0 dev 3 :: 65536 sectores ::
+  s0=renaser-6.1b`. La firma grabada por el anfitrión se lee de vuelta intacta:
+  descubrimiento PCI, transporte, DMA y transferencia funcionan de punta a
+  punta. Las cuatro apps del userspace siguen operando sin alteración.
+
+---
+
+## Fase 6.1c — El grafo de objetos direccionado por contenido — 2026-05-22
+
+Tercer y último paso del sustrato de almacenamiento. El disco deja de ser un
+dispositivo que se sondea y pasa a ser una MEMORIA QUE PERDURA: un grafo
+dirigido acíclico de objetos direccionados por contenido — no un sistema de
+archivos plano POSIX.
+
+### Añadido
+- `kernel/src/almacen.rs` — el grafo de objetos:
+  - **Objeto** — una carga útil de bytes (`datos`) y una lista de aristas
+    (`hijos`: hashes de otros objetos). Las aristas hacen del almacén un DAG.
+  - **Direccionamiento por contenido** — la identidad de un objeto es el hash
+    BLAKE3 de su forma serializada. De ello se siguen dos propiedades que un
+    sistema de archivos jamás regala: INTEGRIDAD (el contenido leído se
+    rehashea y se verifica contra el hash pedido) y DEDUPLICACIÓN (contenido
+    idéntico produce el mismo hash; se almacena una sola vez).
+  - **Disco como log** — el sector 0 es el superbloque (magia `RENASGRF`,
+    versión, cursor del log y hash de la raíz); tras él se anexan los registros
+    de objetos, `[longitud u32 LE][payload postcard][relleno a cero]`. Un
+    índice en memoria (hash -> sector) se reconstruye al arrancar recorriendo
+    el log de cabo a rabo.
+  - API: `init` —monta el disco, lee o forja el superbloque, reconstruye el
+    índice—, `almacenar`, `recuperar`, `raiz` y `fijar_raiz`.
+- Cinco capacidades nuevas del host en `wasm/env.rs` — `sys_object_put`,
+  `sys_object_datos`, `sys_object_hijo`, `sys_object_raiz` y
+  `sys_object_fijar_raiz` —, con la misma validación infranqueable de límites
+  de la memoria lineal que `sys_render_frame`. Distinguen dos clases de fallo:
+  un puntero inválido ABORTA la app —es su culpa, se traduce en trampa—; un
+  fallo del almacenamiento le devuelve un código de error negativo —no lo es—.
+- `apps/cronista/` — la primera aplicación del userspace que escribe en el
+  almacenamiento PERSISTENTE. En cada arranque consulta la raíz del grafo,
+  graba un objeto nuevo —`datos`: el número de arranque; `hijos`: la raíz
+  anterior, el eslabón del DAG— y lo corona como raíz. Pinta una celda por
+  arranque registrado y un testigo de integridad que recorre la cadena entera.
+- Dependencias: `serde` 1 y `postcard` 1 (serialización binaria compacta, el
+  formato que viaja al disco) y `blake3` 1 (la función hash). Las tres `no_std`.
+
+### Cambiado
+- `kernel/src/drivers/disco.rs` reescrito para un sustrato PERMANENTE:
+  - El asignador de marcos «bump» de la Fase 6.1b cede el paso a uno de MAPA DE
+    BITS con liberación real. `dma_dealloc` y `unshare` devuelven los marcos a
+    la arena: un almacén vivo, con su trasiego incesante de DMA, ya no la agota.
+  - El `VirtIOBlk` deja de montarse y destruirse en cada llamada: se monta UNA
+    vez y queda tras un `Mutex` global. `leer_sectores` / `escribir_sectores`
+    exponen la E/S de bloques — el disco deja de ser de solo lectura. Se retira
+    `montar_y_leer_sector0`, la sonda de un solo uso de la Fase 6.1b.
+- `boot/src/main.rs`: el disco de pruebas pasa a ser el disco de objetos. Ya
+  no se le graba una firma — se forja virgen, a cero, y el kernel lo formatea
+  la primera vez que no halle el superbloque.
+- `main.rs`: `informar_disco` (la sonda de la Fase 6.1b) se sustituye por
+  `informar_almacen`, que funda el grafo. El userspace pasa de cuatro a cinco
+  apps; las regiones de discola y glotona se reajustan para alojar a cronista.
+
+### Notas
+- **blake3 forzado a escalar.** El target del kernel corre sin SSE; un camino
+  SIMD de blake3 activado por detección en tiempo de ejecución ejecutaría
+  instrucciones que la CPU, sin `CR4.OSFXSR`, rechazaría con un #UD. Se fija
+  blake3 con `pure` + los cuatro `no_*` (`sse2`, `sse41`, `avx2`, `avx512`):
+  implementación puramente escalar, sin SIMD ni ensamblador.
+
+### Verificado
+- QEMU, TRES arranques consecutivos sobre el mismo disco persistente: la app
+  cronista pinta 1, luego 2, luego 3 celdas — la cuenta de arranques sobrevive
+  a los reinicios porque vive en el grafo, en el disco, no en la RAM. El
+  testigo de integridad queda VERDE en los tres: el DAG entero se recorre, de
+  la raíz al primer eslabón, y su profundidad cuadra con la cuenta. El
+  superbloque en disco confirma la magia `RENASGRF`, versión 1, cursor 4 y la
+  raíz del tercer arranque; el registro del primer arranque guarda `datos = 1`
+  y cero hijos. Las otras cuatro apps siguen su curso sin alteración — las dos
+  `hello_wasm` renderizando, discola desalojada en púrpura, glotona en amarillo.
+
+---
+
+## Fase 6.2 — E/S de disco asíncrona por interrupción — 2026-05-22
+
+La Fase 6.1 hizo hablar al disco, pero por SONDEO: el procesador se quedaba en
+espera activa vigilando el *used ring* de virtio, incapaz de atender nada más.
+La 6.2 libera el planificador cooperativo — la E/S de bloques pasa a ser
+REACTIVA, guiada por la interrupción física del dispositivo.
+
+### Añadido
+- `EsperaDisco` (`drivers/disco.rs`): una transferencia de bloques expresada
+  como `Future` nativo. Posee sus buferes DMA —`BlkReq`, `BlkResp` y los datos,
+  en el heap para una dirección estable—; su `poll` envía la petición por la
+  API NO BLOQUEANTE de `virtio-drivers` (`read_blocks_nb`/`write_blocks_nb`),
+  consulta el *used ring* (`peek_used`) y, si la transferencia sigue en vuelo,
+  inscribe el waker y cede. `leer_bloques`/`escribir_bloques` lo construyen.
+- La IRQ del disco: `montar` descubre la línea de IRQ legada del dispositivo
+  (registro «Interrupt Line», offset 0x3C del espacio de configuración PCI),
+  registra un manejador en la IDT y abre la línea en el PIC.
+  `interrupts::irq_disco` → `disco::atender_irq` reconoce la interrupción en el
+  dispositivo —leer su registro ISR baja la línea INTx— y despierta, vía un
+  waker de ranura única, a la tarea que aguardaba el bloque.
+- `bloquear_en` — el puente para los contextos SÍNCRONOS (el arranque, las
+  capacidades WASM, que no pueden `.await`): lleva un `Future` de disco hasta
+  su final durmiendo la CPU con `hlt` —la despiertan la IRQ del disco o el
+  temporizador, como red de seguridad—; jamás en espera activa con el sistema
+  ya en marcha.
+- `pic::desenmascarar` / `pic::vector_irq`: abrir una línea concreta del par
+  8259 (con su cascada, si vive en el esclavo) y mapear línea → vector de IDT.
+- `pci::linea_irq`: leer el registro «Interrupt Line» de un dispositivo.
+- `tarea_sonda_disco` (`main.rs`): una tarea del reactor que lee el sector 0 de
+  forma asíncrona — la prueba viva de que la IRQ conduce la E/S sin detener a
+  las aplicaciones.
+
+### Cambiado
+- `leer_sectores`/`escribir_sectores` se reescriben sobre la maquinaria
+  asíncrona (`bloquear_en` + `EsperaDisco`). El `almacen` y las capacidades
+  `sys_object_*` NO cambian una línea: heredan la E/S por interrupción de
+  forma transparente — la espera de disco deja de quemar ciclos en sondeo.
+- El `VirtIOBlk` pide al dispositivo que emita interrupciones al completar cada
+  petición (`enable_interrupts`).
+
+### Decisiones de ingeniería
+- **PIC, no IOAPIC.** El kernel corre íntegramente sobre el par 8259 (`pic.rs`)
+  y la crate `x86_64` no ofrece abstracción de APIC. Las IRQ legadas de PCI de
+  la máquina `q35` se enrutan por el 8259: basta leer la línea que el firmware
+  UEFI ya asignó y abrirla. Migrar al IOAPIC habría exigido levantar LAPIC +
+  IOAPIC + parseo de tablas ACPI — un subsistema entero, desproporcionado para
+  el objetivo. El resultado funcional es idéntico: E/S conducida por la
+  interrupción física.
+- **Las capacidades WASM no `.await`-ean.** El intérprete `wasmi` ejecuta las
+  funciones de host de forma SÍNCRONA: no hay manera de suspender un módulo a
+  mitad de una llamada de host. Por eso `sys_object_*` no se vuelven
+  asíncronas; usan `bloquear_en`, que duerme la CPU con `hlt` en lugar de
+  sondear. El verdadero solapamiento E/S ↔ render lo aprovechan las TAREAS del
+  reactor (`tarea_sonda_disco` hoy; la carga dinámica de módulos, mañana).
+- Una IRQ legada de PCI es de NIVEL: el manejador reconoce primero al
+  dispositivo —lo que baja su línea— y sólo después cierra el EOI del PIC; el
+  orden inverso reavivaría la interrupción en bucle.
+- Todo acceso al disco toma su `Mutex` con las interrupciones desactivadas
+  (`without_interrupts`): la IRQ del disco jamás encuentra el cerrojo ocupado,
+  lo que hace imposible el interbloqueo por interrupción.
+
+### Verificado
+- QEMU: el disco virtio-blk se enruta a la IRQ 11. La `tarea_sonda_disco`
+  reporta «sonda asíncrona OK -- 2 IRQ de disco atendidas»: la interrupción del
+  disco dispara de verdad. La app cronista, sobre el disco persistente heredado
+  de la Fase 6.1c, continúa la cuenta de arranques (3 → 4 → 5 celdas) con el
+  testigo de integridad del DAG en verde — la nueva E/S asíncrona lee y escribe
+  el grafo sin un solo fallo. Las cuatro apps WASM siguen su curso, sin un
+  sobresalto ni un micro-congelamiento.

renaser/CLAUDE.md

@@ -0,0 +1,88 @@
+# renaser — guía operativa
+
+**renaser** es un kernel asíncrono de *Espacio de Direccionamiento Único*
+(SASOS) en Rust `#![no_std]`, bare-metal x86_64. Rompe con POSIX: interfaz
+visual nativa desde el arranque, aislamiento **por software** (no por MMU),
+el texto como caso particular del dibujo.
+
+Documentos hermanos: `ARCHITECTURE.md` (arquitectura), `ROADMAP.md` (fases y
+plan), `CHANGELOG.md` (registro técnico de cambios), `DIARIO.md` (crónica en
+lenguaje llano), `README.md` (presentación).
+
+## Construir y ejecutar
+
+Desde la raíz del repositorio:
+
+| Comando | Efecto |
+|---|---|
+| `cargo run` | compila el kernel, forja la imagen UEFI y abre QEMU |
+| `cargo build` | compila el kernel + la imagen, sin lanzar QEMU |
+| `cargo kernel` | alias: compila solo el kernel para `x86_64-unknown-none` |
+
+Verificación headless (sin ventana): añadir
+`-- -display none -monitor unix:/tmp/q.sock,server,nowait` y capturar con
+`screendump` por el socket del monitor.
+
+Reconstruir la app WASM del userspace tras tocar `apps/hello_wasm`:
+
+```sh
+cd apps/hello_wasm
+cargo build --target wasm32-unknown-unknown --release
+cp target/wasm32-unknown-unknown/release/hello_wasm.wasm ../../kernel/assets/app.wasm
+```
+
+## Estructura del espacio de trabajo
+
+- `boot/` — orquestador de **anfitrión**: construye la imagen de disco UEFI con
+  la crate `bootloader` 0.11 y lanza QEMU. Es el **único miembro** del workspace.
+- `kernel/` — el kernel **bare-metal**. Está **excluido** del workspace y se
+  compila solo como dependencia de artefacto de `boot` (target
+  `x86_64-unknown-none`). NUNCA debe ser miembro del workspace ni compilarse
+  para el anfitrión: lo haría fallar por un `_start` duplicado.
+- `apps/` — aplicaciones del userspace, módulos `.wasm`
+  (target `wasm32-unknown-unknown`). Workspaces propios, excluidos.
+
+Módulos del kernel (`kernel/src/`): `main`, `grafico`, `consola`, `baliza`,
+`sync`, `gdt`, `interrupts`, `pic`, `drivers/`, `almacen`, `memory/`,
+`async_system/`, `texto`, `wasm/`. El detalle de cada uno está en
+`ARCHITECTURE.md`.
+
+## Toolchain
+
+Nightly, fijado en `rust-toolchain.toml`. Targets `x86_64-unknown-none` y
+`wasm32-unknown-unknown`. Componentes `rust-src` y `llvm-tools` (los exige el
+build script de la crate `bootloader`). Entorno verificado: Artix Linux,
+QEMU 11, OVMF en `/usr/share/edk2/x64/OVMF.4m.fd` (sin módulo KVM → TCG).
+
+## Convenciones
+
+- **Idioma:** comentarios E identificadores en español.
+- **`unsafe`:** confinado en células mínimas, envuelto de inmediato en una
+  abstracción segura. `#![deny(unsafe_op_in_unsafe_fn)]`. Cada bloque `unsafe`
+  lleva un comentario `SEGURIDAD:` que justifica su corrección.
+- **Framebuffer / MMIO:** siempre `core::ptr::write_volatile`; jamás asignación
+  indexada directa (el optimizador la elidiría).
+- **`no_std` estricto:** solo `core::*` y `alloc::*` (heap vivo desde la Fase 3).
+  Prohibido cualquier ruta de `std::*`.
+- **Alineación:** 16 bytes para estructuras genéricas; 4096 bytes (página) para
+  buffers de memoria y regiones de asignador.
+- Código densamente comentado; se cuida la coherencia de estilo entre módulos.
+
+## Estado
+
+Fases 1 a 5, la 6.0, la 6.1 completa (sustrato de almacenamiento: sonda PCI,
+HAL/DMA y el grafo de objetos) y la 6.2 (E/S de disco asíncrona por
+interrupción) completadas y verificadas en QEMU. Ver `ROADMAP.md`.
+
+## Flujo de trabajo
+
+En **cada iteración** de trabajo, sin excepción:
+
+1. Actualizar `CHANGELOG.md` — la entrada técnica detallada del cambio.
+2. Actualizar `DIARIO.md` — la misma jornada contada en lenguaje llano y
+   elegante, sin carga técnica (es una crónica humana, no un registro técnico).
+3. Verificar en QEMU si el cambio es observable (con captura de pantalla).
+4. `git commit` (mensaje en español, descriptivo) y `git push origin main`.
+
+El remoto `origin` es `gitea.gioser.net/sergio/renaser`. Mensajes de commit en
+español. Verifica una fase en QEMU antes de darla por cerrada.

renaser/Cargo.toml

@@ -0,0 +1,89 @@
+# =============================================================================
+#  renaser :: manifiesto raíz del espacio de trabajo
+# -----------------------------------------------------------------------------
+#  Un único espacio de direccionamiento, una única verdad de versiones.
+#  Las dependencias se declaran aqui una sola vez y persisten, coherentes,
+#  a traves de todos los miembros del sistema.
+# =============================================================================
+
+[workspace]
+resolver = "2"
+# Solo `boot` es miembro del espacio de trabajo: corre en el anfitrion. El
+# kernel queda EXCLUIDO a proposito —es bare-metal puro y jamas debe compilarse
+# para el anfitrion— y se construye unica y exclusivamente como dependencia de
+# artefacto de `boot`, que le fija el target `x86_64-unknown-none`.
+members = ["boot"]
+# El kernel (bare-metal) y las apps WASM (target wasm32) se compilan aparte,
+# cada cual con su propio target; quedan fuera del espacio de trabajo.
+exclude = ["kernel", "apps"]
+
+# -----------------------------------------------------------------------------
+#  Metadatos compartidos: cada miembro hereda esta identidad con `*.workspace`.
+# -----------------------------------------------------------------------------
+[workspace.package]
+version = "0.1.0"
+edition = "2021"
+license = "MPL-2.0"
+authors = ["JL Soltech <gerencia@jlsoltech.com>"]
+description = "renaser :: kernel asincrono SASOS basado en aislamiento por software"
+
+# -----------------------------------------------------------------------------
+#  Dependencias del ecosistema. Reutilizamos infraestructura madura en lugar
+#  de reinventar boilerplate. `default-features = false` se aplica con bisturi,
+#  unicamente alli donde las features por defecto arrastrarian `std`.
+# -----------------------------------------------------------------------------
+[workspace.dependencies]
+# Constructor de la imagen de disco UEFI/BIOS. Es una herramienta de ANFITRION
+# (usa std), la consume el miembro `boot` y NO debe enlazarse jamas en el kernel.
+bootloader = "0.11"
+
+# API `#![no_std]` que el kernel SI consume: expone `entry_point!`, `BootInfo`
+# y la descripcion del framebuffer GOP. Su version debe acompasar a `bootloader`.
+bootloader_api = "0.11"
+
+# Abstraccion de la CPU x86_64: registros de control, GDT, IDT e instrucciones
+# privilegiadas sin ensamblador inline. Es `#![no_std]` de nacimiento; su
+# feature `instructions` (activa por defecto) nos da `hlt` y el control de IRQ.
+x86_64 = "0.15"
+
+# Rasterizacion de primitivas vectoriales sobre el framebuffer. `#![no_std]`,
+# sin heap: en la Fase 1 solo aporta el rasgo `DrawTarget` del lienzo.
+embedded-graphics = "0.8"
+
+# Rasterizador de tipografias. REQUIERE `alloc`, de modo que solo se teje en el
+# kernel una vez exista el asignador (Fase 2). `default-features = false`
+# silencia su feature `std`. Se declara ya para congelar la version.
+# `hashbrown` es lo que ACTIVA el modo `no_std` de fontdue; sin el, la crate
+# recae en `std::collections` y no compila para bare-metal. `simd` queda fuera:
+# nuestro target no tiene SSE.
+fontdue = { version = "0.9", default-features = false, features = ["hashbrown"] }
+
+# --- Fase 3 :: heap dinamico y reactor asincrono ---
+# Asignador del heap del kernel — algoritmo probado, configurado `no_std`.
+linked_list_allocator = "0.10"
+# Exclusion mutua sin sistema operativo: `Mutex` e inicializacion unica `Once`.
+spin = "0.9"
+# Cola lock-free, segura frente a interrupciones, para el canal de scancodes.
+crossbeam-queue = { version = "0.3", default-features = false, features = ["alloc"] }
+# Combinadores `Future`/`Stream` y `AtomicWaker`. Sin ejecutor ni I/O: solo
+# las piezas que renaser teje en su propio reactor.
+futures-util = { version = "0.3", default-features = false, features = ["alloc"] }
+
+# --- Fase 4 :: interprete WebAssembly para el userspace aislado ---
+# `wasmi` en modo bare-metal: sin `std`, sin `wat`, sin `simd` (el target no
+# tiene SSE). `hash-collections` le da mapas basados en hashbrown, `no_std`.
+wasmi = { version = "1.0", default-features = false, features = ["hash-collections"] }
+
+# -----------------------------------------------------------------------------
+#  Perfiles de compilacion. Cargo exige que los perfiles vivan en la RAIZ del
+#  espacio de trabajo. `panic = "abort"` es obligatorio: sin sistema operativo
+#  subyacente no hay desenrollado de pila (`unwinding`) posible.
+# -----------------------------------------------------------------------------
+[profile.dev]
+panic = "abort"
+
+[profile.release]
+panic = "abort"
+opt-level = "s"   # codigo compacto: cada byte cuenta en bare-metal
+lto = true        # el optimizador cruza fronteras de crate
+codegen-units = 1 # una sola unidad => maxima oportunidad de optimizacion

renaser/DIARIO.md

@@ -0,0 +1,226 @@
+# Diario de renaser
+
+*Una crónica, en lenguaje llano, de cómo va naciendo un sistema operativo.
+Cada jornada de trabajo añade aquí su página.*
+
+---
+
+## El primer día — la luz
+
+Todo empezó con un gesto pequeño y luminoso: lograr que la máquina, al
+despertar, no mostrara la fría consola de texto de siempre, sino una superficie
+limpia y serena, de un azul profundo, casi nocturno. Puede parecer poca cosa,
+pero esa superficie es el cimiento de cuanto vendrá: el lienzo en blanco de un
+sistema entero.
+
+Junto a esa primera luz nació también una promesa de honestidad. Si alguna vez
+algo saliera terriblemente mal, renaser no se quedaría callado: pintaría una
+franja roja, ancha y visible, para confesarlo sin rodeos. Una alarma sincera.
+
+## El empaquetado — un cuerpo para viajar
+
+Un sistema no sirve de nada si no puede encenderse en una máquina de verdad.
+Así que el segundo paso fue darle a renaser un cuerpo: envolverlo en un disco
+capaz de arrancar por sí solo, y enseñar al ordenador a lanzarlo. Desde
+entonces, una sola orden basta para verlo cobrar vida ante nuestros ojos.
+
+## Los reflejos — aprender a reaccionar
+
+Hasta aquí, renaser sabía mostrarse, pero no sabía protegerse. La tercera etapa
+consistió en darle reflejos: la capacidad de reaccionar ante lo inesperado en
+lugar de derrumbarse en silencio. Se le tejió una red de seguridad interna para
+que, ante un tropiezo, supiera recogerse con dignidad y avisar de lo ocurrido.
+
+## El latido — sentir el tiempo y escuchar
+
+Un sistema vivo necesita pulso. Se le dio a renaser un latido regular, como un
+metrónomo interno, y oídos para escuchar el teclado. Por primera vez el sistema
+dejó de estar simplemente quieto: empezó a respirar, a redibujarse con cada
+latido y a notar cuándo una mano pulsaba una tecla.
+
+## La memoria y la fluidez — crecer y atender muchas cosas
+
+Para crecer, renaser necesitaba memoria de la que disponer con libertad. Y para
+no atascarse, necesitaba aprender a atender varias cosas a la vez sin que unas
+estorbaran a otras. En esta etapa recibió ambas. Además aprendió a escribir de
+verdad: con una tipografía elegante, dibujando cada letra con esmero. El texto
+dejó de ser un molde rígido para volverse, también él, un dibujo.
+
+## La habitación segura — invitar a otros programas
+
+La etapa más ambiciosa hasta ahora: abrir la puerta a que otros programas
+vivieran dentro de renaser. Pero no de cualquier modo. Cada programa invitado
+entra en una habitación sellada de la que no puede salir; solo puede hacer
+aquello para lo que renaser, expresamente, le tiende un puente. Todo lo demás,
+sencillamente, no existe para él. La primera visita fue modesta y entrañable:
+un cuadrado de color que se desliza por la pantalla obedeciendo al teclado.
+
+## Una jornada de orden — ordenar la casa y guardar la historia
+
+No todo es construir; a veces toca ordenar. Se revisó la estructura del
+proyecto y se repartió mejor el trabajo entre sus piezas, para que cada una
+tuviera un cometido claro y nítido. Se escribió la documentación que cuenta qué
+es renaser y hacia dónde camina. Y se guardó todo el trabajo en un lugar
+seguro, donde queda registro fiel de cada cambio, de modo que ninguna jornada
+se pierda. Hubo, además, un pequeño susto: una contraseña se coló por error
+donde no debía; se retiró de inmediato y se dejó constancia para corregirla.
+
+## El reparto del tiempo — muchos huéspedes, ningún tirano
+
+Hasta esta jornada, el programa invitado de renaser, una vez dentro, se quedaba
+con la casa entera: hablaba sin pausa y no dejaba sitio a nadie más. Era un solo
+huésped, y se comportaba como dueño.
+
+Esta etapa enseñó a renaser a repartir el tiempo. Se acordó un compás —el latido
+del sistema marca, una y otra vez, el turno de cada cual— y se acordó también un
+gesto de cortesía: cada programa hace su pequeña tarea, pinta su fotograma y, al
+terminar, cede el paso. Así, lo que antes era un único inquilino pasaron a ser
+varios, conviviendo en paz, cada uno en su propia ventana de la pantalla.
+
+Pero la cortesía, por sí sola, es frágil: basta un huésped maleducado —uno que
+no quiera ceder nunca el turno— para paralizarlo todo. Por eso se añadió una
+salvaguarda serena pero firme: a cada programa se le entrega, en cada turno, una
+ración medida de tiempo. Si la agota sin terminar —porque se ha enredado en un
+bucle sin fin—, renaser le retira el turno con delicadeza, tiñe su ventana de un
+púrpura inconfundible y prosigue. El sistema no se cuelga; simplemente despide al
+inquilino díscola y sigue atendiendo a los demás, que ni se enteran.
+
+Para comprobarlo se invitó, a propósito, a un huésped díscola: un programa hecho
+para enredarse en un bucle eterno. Al arrancar, las dos ventanas honradas
+cobraron vida y obedecieron al teclado a la vez, en perfecta armonía; la tercera,
+la del díscola, se apagó al instante en un púrpura tranquilo. La promesa quedó
+demostrada: renaser es veloz porque confía, pero nunca ingenuo.
+
+## La otra mitad del muro — el espacio, no solo el tiempo
+
+La jornada anterior enseñó a renaser a repartir el tiempo y a contener al que no
+quería cederlo. Pero un huésped puede portarse mal de dos maneras: acaparando el
+tiempo, sí, o acaparando el espacio. Quedaba media casa por proteger.
+
+En esta etapa se le puso a cada programa un techo a la memoria que puede
+reclamar. Mientras se conforme con su habitación, vive tranquilo; si pretende
+derribar las paredes para anexarse la casa entera, renaser se lo impide con
+serenidad y, como con el díscola, lo despide —esta vez tiñendo su ventana de un
+amarillo pálido, para que de un vistazo se distinga al que abusó del espacio del
+que abusó del tiempo.
+
+Se cerró además una pequeña negligencia de la jornada anterior: cuando un
+huésped era despedido, renaser olvidaba recoger del todo sus cosas. Ahora, al
+marcharse cualquier programa, el sistema reclama hasta el último de sus enseres;
+no queda rastro. Y se invitó a un nuevo huésped de prueba, una aplicación
+glotona hecha para devorar memoria: al arrancar, fue frenada y despedida al
+instante, su ventana amarilla junto a la púrpura del díscola, mientras las dos
+aplicaciones honradas seguían su baile, ajenas a todo.
+
+Con esto, las dos dimensiones físicas —el tiempo y el espacio— quedan bajo el
+gobierno firme y sereno de renaser. El siguiente horizonte es más hondo: dar al
+sistema una memoria que perdure, un lugar donde guardar las cosas más allá del
+apagado. Pero esa es ya otra página.
+
+## El primer golpe a la roca — encontrar el disco
+
+Dar a renaser una memoria que perdure exige, antes que nada, hablar con un
+disco. Y un disco, a diferencia de la pantalla o del teclado, no se le anuncia
+al sistema al nacer: hay que salir a buscarlo. Es una empresa grande, así que se
+decidió acometerla con prudencia, a pasos cortos y firmes.
+
+El primer paso fue, sencillamente, encontrar el disco. renaser aprendió a
+recorrer el bus por el que se enganchan los periféricos de la máquina,
+preguntando puerta por puerta «¿quién hay aquí?», hasta dar con el disco virtual
+que se le había preparado. Y al hallarlo, lo dijo en voz alta sobre su propia
+pantalla: lo había localizado, y supo decir en qué dirección vivía.
+
+Puede parecer un gesto pequeño —una línea de texto—, pero es el primer golpe de
+pico contra una roca dura. La conversación con el disco apenas empieza; pero la
+puerta, al menos, ya está encontrada.
+
+## La primera palabra del disco — leer lo que se escribió
+
+Encontrada la puerta, faltaba lo más difícil: cruzarla. Hablar de verdad con un
+disco no es pedirle las cosas y esperar: es tender con él una memoria
+compartida, un terreno común donde el sistema deja una petición y el disco
+deposita su respuesta. Montar ese terreno —y aprender el protocolo para usarlo—
+fue el trabajo de esta jornada, el más cercano al metal de cuantos renaser ha
+acometido.
+
+Para no equivocar el paso se ideó una prueba sencilla y honesta. Al preparar el
+disco, el sistema anfitrión grabó en su primer renglón una breve firma, una
+palabra clave. Y entonces se le pidió a renaser que, ya por sus propios medios,
+abriera el disco y leyera ese mismo renglón. Si la palabra volvía intacta, no
+habría duda: el camino completo —encontrar el disco, tender la memoria
+compartida, pedir, esperar y recibir— funcionaba de cabo a rabo.
+
+Al arrancar, renaser lo dijo en su pantalla, sereno: había leído el sector
+cero, y la palabra que mostró era, letra por letra, la que se había grabado. El
+disco había hablado, y renaser lo había entendido. La roca, por fin, cedió.
+
+Queda por delante lo más hermoso: sobre esta conversación recién abierta,
+levantar una verdadera memoria duradera —no un archivo de los de antes, sino un
+tejido de objetos—. Pero el cimiento ya está puesto, y es firme.
+
+## Un tejido de objetos — la memoria que perdura
+
+La conversación con el disco estaba abierta; faltaba decidir qué contarle. El
+mundo que renaser hereda de la informática de siempre habría respondido sin
+pensarlo: archivos, carpetas, rutas con barras. renaser eligió otra cosa.
+
+En lugar de un archivero de cajones con etiquetas, se tejió un grafo de
+objetos. Cada objeto es un puñado de datos y unos cuantos hilos que lo enlazan
+con otros. Y —esta es la idea hermosa— ningún objeto lleva un nombre que
+alguien le haya puesto: su nombre es su contenido. De cada uno se calcula una
+huella única, irrepetible, y esa huella es su identidad. Dos cosas idénticas
+tienen la misma huella, de modo que nada se guarda dos veces; y si una se
+corrompe, su huella deja de cuadrar y la mentira se delata sola.
+
+Para que esa memoria mereciera el nombre de duradera hubo que pulir el trato
+con el disco: enseñarle a renaser no solo a leer, sino a escribir. Y poner
+orden en la despensa de la que el sistema toma prestada memoria para hablar con
+el hardware — que ahora, al terminar cada gestión, devuelve lo que tomó en vez
+de acumularlo sin fin.
+
+Y entonces llegó la prueba más bonita. Se escribió una pequeña aplicación, una
+cronista, con un único oficio: llevar la cuenta de las veces que el sistema
+despierta. En cada arranque consulta el grafo, encuentra el último apunte,
+añade el suyo —enlazado al anterior, como el eslabón nuevo de una cadena— y
+pinta una casilla por cada despertar registrado.
+
+Se apagó la máquina y se volvió a encender. Y otra vez. La cronista dibujó
+primero una casilla, luego dos, luego tres. La cuenta no se perdía con el
+apagón: vivía en el disco, en el tejido de objetos, y cada reinicio la
+encontraba intacta y la hacía crecer. Por primera vez, renaser recordaba algo
+de una vida a la siguiente.
+
+La memoria duradera ya no es una promesa. Es un tejido, y tiene sus primeros
+hilos.
+
+## El disco que avisa — la espera que ya no congela
+
+Hablar con el disco, hasta esta jornada, tenía un precio oculto. Cada vez que
+renaser le pedía un bloque, el sistema entero contenía el aliento: el procesador
+se quedaba mirando fijamente al disco, preguntando una y otra vez «¿ya?, ¿ya?»,
+sin hacer nada más, hasta que la respuesta llegaba. Para una lectura suelta
+apenas se notaba. Pero el futuro de renaser —cargar aplicaciones enteras desde
+el disco— habría convertido esos instantes en tirones visibles, en pequeños
+congelamientos de la imagen.
+
+Así que se le enseñó al disco a AVISAR. En lugar de que el sistema vigile, ahora
+es el disco quien, al terminar, da un golpecito en el hombro del kernel —una
+interrupción— para decir «listo». Y mientras tanto, renaser no aguarda de brazos
+cruzados: si hay trabajo, lo hace; si no, se adormece un instante, y el propio
+golpecito del disco lo despierta. Ni un ciclo malgastado.
+
+Para no equivocar el paso se escribió una pequeña sonda: una tarea que pide al
+disco su primer bloque y, en vez de quedarse esperando, cede el turno. Las
+aplicaciones de la pantalla siguieron pintándose, fluidas, mientras el disco
+trabajaba por su cuenta; y cuando el bloque estuvo listo, su aviso reanudó la
+sonda. En la pantalla quedó escrito: la lectura se había atendido por aviso, no
+por vigilancia.
+
+Es un cambio que casi no se ve —la cronista sigue contando arranques, una
+casilla más cada vez— pero que se sentirá en todo lo que venga después. El disco
+y renaser ya no se miran fijamente: se hablan, y entre frase y frase, cada cual
+atiende lo suyo.
+
+---
+
+*El diario continúa. La próxima página la escribirá la próxima jornada.*

renaser/README.md

@@ -0,0 +1,48 @@
+# renaser
+
+**renaser** es un kernel asíncrono de *Espacio de Direccionamiento Único*
+(SASOS), escrito en Rust `#![no_std]` para x86_64 bare-metal.
+
+Es un sistema operativo disruptivo que rompe por completo con el paradigma
+POSIX de los años 70: no emula Linux, no usa archivos planos, no usa TTYs ni
+capas GNU. El aislamiento entre aplicaciones no descansa en la MMU ni en los
+anillos de privilegio de la CPU, sino en **límites matemáticos sobre el
+bytecode** — aislamiento por software (SFI). La interfaz es visual desde el
+primer microsegundo: el texto es, simplemente, un caso particular del dibujo.
+
+## Qué hace, hoy
+
+- Arranca por **UEFI** y adopta el framebuffer GOP con doble búfer sin parpadeo.
+- Se **autoempaqueta** en una imagen de disco UEFI y se lanza en QEMU.
+- Tiene **reflejos de fallo**: GDT/TSS, IDT y manejadores de excepción; si
+  colapsa, lo dibuja (franja roja de pánico, naranja de memoria agotada).
+- **Late con el hardware**: PIC remapeado, temporizador (PIT) y teclado.
+- Gestiona **memoria dinámica** (heap de 64 MiB, asignador global).
+- Ejecuta un **reactor asíncrono cooperativo** sobre los `Future` nativos de
+  Rust: las interrupciones no conmutan contexto, despiertan tareas.
+- Rasteriza **texto vectorial** al vuelo con `fontdue`.
+- Ejecuta un **userspace WebAssembly** aislado por capacidades (`wasmi`): las
+  aplicaciones solo tocan el mundo a través de funciones de host concedidas.
+
+## Construir y ejecutar
+
+Requisitos: `rustup` con toolchain nightly, QEMU y firmware OVMF.
+
+```sh
+cargo run
+```
+
+Compila el kernel para `x86_64-unknown-none`, forja la imagen de disco UEFI y
+abre QEMU. Ver `CLAUDE.md` para el resto de comandos y el flujo de la app WASM.
+
+## Documentación
+
+| Documento | Contenido |
+|---|---|
+| `ARCHITECTURE.md` | la arquitectura del sistema, subsistema a subsistema |
+| `ROADMAP.md` | fases completadas y plan de las siguientes |
+| `CLAUDE.md` | guía operativa: comandos, estructura y convenciones |
+
+## Licencia
+
+MPL-2.0

renaser/ROADMAP.md

@@ -0,0 +1,108 @@
+# renaser — Hoja de ruta
+
+Estado de las fases del proyecto. Para la arquitectura, ver `ARCHITECTURE.md`.
+
+## Fases completadas
+
+Todas verificadas en QEMU (captura de pantalla incluida en su momento).
+
+### Fase 1 — el primer microsegundo
+Arranque UEFI, adopción del framebuffer GOP, lienzo de doble búfer y la baliza
+de pánico (franja roja al colapsar). Punto de entrada con `bootloader_api`.
+
+### Fase 1.5 — empaquetado y arranque
+Miembro `boot/`: constructor de la imagen de disco UEFI (crate `bootloader`
+0.11, vía dependencia de artefacto) y lanzador de QEMU. `cargo run` pasa a
+compilar, forjar la imagen y arrancar, todo de un gesto.
+
+### Fase 2.0 — cimientos del manejo de fallos
+GDT propia + TSS con stack de emergencia (IST) para el doble fallo. IDT con
+manejadores de excepción de CPU. El breakpoint es recuperable; el resto de
+excepciones encienden la baliza.
+
+### Fase 2.1 — interrupciones de hardware
+Remapeo del PIC 8259 fuera del rango de las excepciones. Temporizador (PIT) a
+100 Hz e IRQ1 de teclado. El kernel pasa de "pintar una vez" a un bucle de
+render despertado por el hardware.
+
+### Fase 3 — memoria dinámica y reactor asíncrono
+Heap de 64 MiB con `linked_list_allocator` como asignador global; manejador
+propio de OOM (franja naranja). Reactor cooperativo: `Executor`, `Task`,
+`Waker`. Texto vectorial con `fontdue`: el texto deja de ser mapa de bits.
+
+### Fase 4 — el escudo de aislamiento WASM
+Runtime `wasmi` `no_std`. Matriz de capacidades con dos funciones de host
+(`sys_render_frame`, `sys_get_scancode`) y validación infranqueable de límites
+de la memoria lineal. Primera app del userspace: `apps/hello_wasm`, un módulo
+`wasm32` aislado que pinta y responde al teclado.
+
+### Fase 5 — multitarea cooperativa, fuel y reloj
+Unificación del reactor (Fase 3) y el runtime WASM (Fase 4). El ABI del
+userspace pasa a `init`/`tick`: cada `tick` es un punto de cesión cooperativa.
+`async_system::reloj` convierte la IRQ0 en el `Future` `EsperaFrame`, que marca
+el compás de los fotogramas. Cada app es una `AplicacionWasm` persistente y una
+tarea del reactor. Escudo de combustible (`fuel`): cada `tick` corre con un
+presupuesto estricto; agotarlo desaloja la app sin tocar al kernel. Capacidades
+ampliadas — regiones de dibujo por app y canal de teclado por app. Verificado
+en QEMU con tres apps concurrentes, una de ellas díscola y desalojada en vivo.
+
+### Fase 6.0 — cuotas de memoria y ciclo de vida
+Completa el aislamiento espacial del userspace. Cada `AplicacionWasm` instancia
+su `Store` con un `StoreLimits` (techo de memoria lineal de 4 MiB, vía
+`Store::limiter`); rebasarlo es una trampa que desaloja la app con baliza
+amarilla — gemela de la púrpura del desalojo por combustible. `Drop` para
+`AplicacionWasm` reconcilia el ciclo de vida: da de baja el canal de teclado de
+la difusión de la IRQ1. Verificado en QEMU con cuatro apps — una díscola
+(desalojo temporal) y una glotona (desalojo espacial), ambas en vivo.
+
+## Fase 6.1 — sustrato de almacenamiento (completada)
+
+Estrategia incremental para el almacenamiento, frente al riesgo del hardware:
+
+- **6.1a — Sonda PCI** *(hecha)* — `drivers/pci.rs` enumera el bus PCI por
+  `0xCF8`/`0xCFC` y localiza el disco virtio-blk; `boot` forja el disco de
+  pruebas y lo adjunta como `virtio-blk-pci`. El muro del descubrimiento de
+  hardware queda derribado.
+- **6.1b — HAL y lectura de sector** *(hecha)* — `drivers/disco.rs`: asignador
+  de marcos «bump», `KernelHal` (el `trait Hal` de `virtio-drivers`: DMA y
+  traducción de direcciones) y `montar_y_leer_sector0`, que lee el sector 0 por
+  sondeo. Verificado por una firma que viaja del anfitrión al disco y vuelve.
+- **6.1c — Grafo de objetos** *(hecha)* — `almacen.rs`: el almacenamiento como
+  DAG direccionado por contenido —la identidad de un objeto es el hash BLAKE3
+  de su forma serializada (`postcard`); el disco se organiza como un log con
+  superbloque e índice—, y las cinco capacidades `sys_object_*` que lo exponen
+  al userspace. `drivers/disco.rs` gana un asignador de marcos con liberación
+  real (mapa de bits), escritura de sectores y un `VirtIOBlk` persistente. La
+  app `cronista` lleva la cuenta de los arranques en el grafo: la cuenta
+  perdura entre reinicios.
+
+## Fase 6.2 — E/S de disco asíncrona por interrupción (completada)
+
+La Fase 6.1 hizo hablar al disco, pero por **sondeo**: el procesador se quedaba
+en espera activa vigilando el *used ring* de virtio. La 6.2 libera el
+planificador cooperativo — la E/S de bloques pasa a ser **reactiva**:
+
+- `EsperaDisco` — una transferencia de bloques como `Future` nativo, sobre la
+  API no bloqueante de `virtio-drivers` (`read_blocks_nb` / `peek_used` /
+  `complete_*`). Cede la CPU mientras el disco trabaja.
+- La **IRQ del disco** — `montar` descubre la línea de IRQ legada del
+  dispositivo (registro «Interrupt Line» del espacio de configuración PCI), la
+  enruta por el 8259 y registra su manejador; `atender_irq` reconoce la
+  interrupción y despierta a la tarea que aguardaba el bloque.
+- `bloquear_en` — el puente para los contextos síncronos (el arranque, las
+  capacidades WASM): duerme la CPU con `hlt` en vez de sondear.
+
+Decisión de ingeniería: las IRQ se enrutan por el **PIC 8259** que el kernel ya
+gobierna, no por el IOAPIC — basta leer la línea que el firmware ya asignó.
+Verificado en QEMU: el disco se enruta a la IRQ 11; una tarea-sonda del reactor
+lee un bloque de forma asíncrona mientras las apps siguen pintando.
+
+Líneas abiertas posteriores: carga/descarga dinámica de apps desde el grafo de
+objetos; más capacidades del host (temporización, audio).
+
+## Principios que persisten entre fases
+
+- Reutilizar infraestructura madura de la comunidad antes que reinventar.
+- `unsafe` mínimo, confinado y justificado.
+- Verificar cada fase en QEMU antes de cerrarla.
+- `git commit` + `git push` tras cada iteración.

renaser/apps/cronista/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "cronista"
+version = "0.1.0"

renaser/apps/cronista/Cargo.toml

@@ -0,0 +1,31 @@
+# =============================================================================
+#  renaser :: apps/cronista — Fase 6.1c :: el primer escriba del userspace
+# -----------------------------------------------------------------------------
+#  Un modulo WebAssembly que, a diferencia de sus vecinas, deja HUELLA. En cada
+#  arranque graba un objeto en el grafo persistente del kernel —enlazado al del
+#  arranque anterior, formando una cadena— y lo corona como raiz. Asi lleva la
+#  cronica de cuantas veces ha despertado el sistema: una cuenta que sobrevive
+#  a los reinicios porque vive en el disco, no en la RAM.
+#  Tiene su propio `[workspace]`: queda fuera del espacio de trabajo del kernel.
+# =============================================================================
+
+[package]
+name = "cronista"
+version = "0.1.0"
+edition = "2021"
+description = "renaser :: app WASM cronista — la cronica persistente de los arranques"
+
+[workspace]
+
+# `cdylib` produce un modulo `.wasm` que exporta funciones — el formato que
+# wasmi instancia.
+[lib]
+crate-type = ["cdylib"]
+
+[profile.dev]
+panic = "abort"
+
+[profile.release]
+panic = "abort"
+opt-level = "s"
+lto = true

renaser/apps/cronista/src/lib.rs

@@ -0,0 +1,234 @@
+// =============================================================================
+//  renaser :: apps/cronista — Fase 6.1c :: el primer escriba del userspace
+// -----------------------------------------------------------------------------
+//  Las apps de fases anteriores eran efimeras: su mundo se borraba al apagar la
+//  maquina. `cronista` es la primera que deja HUELLA. En cada arranque:
+//
+//    1. pregunta al kernel por la RAIZ del grafo de objetos —la cabeza de la
+//       cadena de arranques anteriores—;
+//    2. lee de ella el numero del ultimo arranque;
+//    3. graba un objeto nuevo —sus datos: el numero de arranque; su hijo: la
+//       raiz anterior— y lo corona como raiz;
+//    4. recorre la cadena entera para verificar que el DAG persiste integro;
+//    5. pinta una celda por cada arranque registrado.
+//
+//  La cuenta NO vive en la RAM: vive en el disco, en el grafo direccionado por
+//  contenido. Sobrevive a los reinicios. Cada vez que renaser despierta, la
+//  cronista añade un eslabon a la cadena y una celda a su rejilla.
+//
+//  Sus unicas vias hacia el mundo son las capacidades `sys_object_*` que el
+//  kernel le inyecta. No conoce el disco, ni el bus PCI, ni el formato en
+//  sectores: solo objetos, hashes y aristas.
+// =============================================================================
+
+#![no_std]
+
+// --- Las capacidades que el kernel `renaser` inyecta a esta aplicacion. ---
+#[link(wasm_import_module = "renaser")]
+extern "C" {
+    /// Compone un bufer de pixeles (de ESTA memoria lineal) en la region que el
+    /// kernel asigno a esta aplicacion.
+    fn sys_render_frame(ptr: u32, len: u32);
+
+    /// Graba un objeto en el grafo: `datos` es su carga util; `hijos` apunta a
+    /// un arreglo de `hijos_cnt` hashes de 32 bytes —las aristas—. El hash
+    /// resultante se escribe en `salida`. Devuelve 0 si todo fue bien.
+    fn sys_object_put(datos: u32, datos_len: u32, hijos: u32, hijos_cnt: u32, salida: u32) -> i32;
+
+    /// Copia la carga util del objeto `hash` en `salida`. Devuelve el numero de
+    /// bytes copiados, o un valor negativo si fallo.
+    fn sys_object_datos(hash: u32, salida: u32, capacidad: u32) -> i32;
+
+    /// Devuelve el numero de hijos del objeto `hash` y, si `indice` es valido,
+    /// escribe el hash de ese hijo en `salida`. Negativo si el objeto no existe.
+    fn sys_object_hijo(hash: u32, indice: u32, salida: u32) -> i32;
+
+    /// Escribe en `salida` el hash de la raiz del grafo. Devuelve 1 si hay
+    /// raiz, 0 si el grafo aun esta vacio.
+    fn sys_object_raiz(salida: u32) -> i32;
+
+    /// Corona el objeto `hash` como raiz del grafo. Devuelve 0 si lo logro.
+    fn sys_object_fijar_raiz(hash: u32) -> i32;
+}
+
+/// Sin sistema operativo bajo nosotros, un panico solo puede detenerse en seco.
+#[panic_handler]
+fn al_fallar(_: &core::panic::PanicInfo) -> ! {
+    loop {}
+}
+
+// --- Geometria de la escena. El ancho y el alto DEBEN coincidir con la region
+//     que el kernel asigna a esta app. ---
+const ANCHO: usize = 360;
+const ALTO: usize = 80;
+
+/// Lado de paso de la rejilla de celdas, en pixeles.
+const PASO: usize = 20;
+/// Lado de una celda, en pixeles.
+const LADO: usize = 16;
+/// Celdas que caben en una fila.
+const POR_FILA: usize = ANCHO / PASO;
+/// Celdas que caben en la rejilla entera — el techo de lo que se pinta.
+const MAX_CELDAS: usize = POR_FILA * (ALTO / PASO);
+
+/// Indigo casi negro: el fondo del lienzo de la cronista.
+const FONDO: u32 = 0x0E_14_22;
+/// Ambar calido: una celda por arranque registrado.
+const CELDA: u32 = 0xF2_B2_33;
+/// Verde: el DAG se recorrio integro de la raiz al primer eslabon.
+const VERDE: u32 = 0x35_C4_6A;
+/// Rojo: la cadena se rompio — un objeto no resolvio.
+const ROJO: u32 = 0xD4_1E_2C;
+
+/// El lienzo de la aplicacion, en SU propia memoria lineal.
+static mut LIENZO: [u32; ANCHO * ALTO] = [0; ANCHO * ALTO];
+
+// --- Buferes de intercambio con las capacidades `sys_object_*`. El kernel lee
+//     y escribe hashes y datos AQUI, siempre dentro de esta memoria lineal. ---
+/// El hash de la raiz anterior — la cabeza de la cadena al arrancar.
+static mut HASH_RAIZ: [u8; 32] = [0; 32];
+/// El hash del objeto que esta cronista graba en este arranque.
+static mut HASH_NUEVO: [u8; 32] = [0; 32];
+/// Hash de trabajo para recorrer la cadena del DAG.
+static mut HASH_AUX: [u8; 32] = [0; 32];
+/// Los ocho bytes del numero de arranque, de ida y de vuelta del grafo.
+static mut DATOS_IO: [u8; 8] = [0; 8];
+
+/// Preparacion: el kernel la invoca UNA sola vez. Aqui ocurre toda la cronica —
+/// leer el grafo, grabar el eslabon nuevo, verificar el DAG y pintar.
+#[no_mangle]
+pub extern "C" fn init() {
+    // 1. ¿Hay ya una raiz? Es la cabeza de la cadena de arranques anteriores.
+    let tiene_raiz = unsafe { sys_object_raiz(core::ptr::addr_of_mut!(HASH_RAIZ) as u32) } == 1;
+
+    // 2. El numero del ultimo arranque vive en los `datos` de esa raiz.
+    let mut previo: u64 = 0;
+    if tiene_raiz {
+        let leidos = unsafe {
+            sys_object_datos(
+                core::ptr::addr_of!(HASH_RAIZ) as u32,
+                core::ptr::addr_of_mut!(DATOS_IO) as u32,
+                8,
+            )
+        };
+        if leidos == 8 {
+            // SEGURIDAD: lectura de un escalar `Copy` de un estatico propio.
+            previo = u64::from_le_bytes(unsafe { *core::ptr::addr_of!(DATOS_IO) });
+        }
+    }
+    let cuenta = previo + 1;
+
+    // 3. Grabar el objeto de ESTE arranque. Sus `datos` son el numero de
+    //    arranque; su unico hijo, la raiz anterior — el eslabon nuevo del DAG.
+    // SEGURIDAD: escritura de un escalar `Copy` a un estatico propio.
+    unsafe {
+        *core::ptr::addr_of_mut!(DATOS_IO) = cuenta.to_le_bytes();
+    }
+    let (hijos_ptr, hijos_cnt) = if tiene_raiz {
+        (core::ptr::addr_of!(HASH_RAIZ) as u32, 1u32)
+    } else {
+        (0u32, 0u32)
+    };
+    let grabado = unsafe {
+        sys_object_put(
+            core::ptr::addr_of!(DATOS_IO) as u32,
+            8,
+            hijos_ptr,
+            hijos_cnt,
+            core::ptr::addr_of_mut!(HASH_NUEVO) as u32,
+        )
+    };
+
+    // 4. Coronar el objeto nuevo como raiz y verificar la integridad del DAG.
+    let mut integro = false;
+    if grabado == 0
+        && unsafe { sys_object_fijar_raiz(core::ptr::addr_of!(HASH_NUEVO) as u32) } == 0
+    {
+        integro = verificar_cadena(cuenta);
+    }
+
+    // 5. Pintar la cronica: una celda por arranque, un testigo de integridad.
+    pintar(cuenta, integro);
+}
+
+/// Un fotograma de trabajo. El numero de arranque no cambia durante una sesion:
+/// la cronica que `init` pinto persiste en el lienzo del kernel. `tick` solo
+/// cede el control, fiel al ABI cooperativo — no toda app necesita redibujar.
+#[no_mangle]
+pub extern "C" fn tick() {}
+
+/// Recorre la cadena del DAG desde el objeto recien grabado, descendiendo por
+/// el hijo 0, y comprueba que su profundidad coincide con el numero de
+/// arranque. Si coincide, el grafo entero se leyo de vuelta del disco integro.
+fn verificar_cadena(cuenta: u64) -> bool {
+    // Partir del objeto recien grabado.
+    // SEGURIDAD: copia de un arreglo `Copy` entre dos estaticos propios.
+    unsafe {
+        *core::ptr::addr_of_mut!(HASH_AUX) = *core::ptr::addr_of!(HASH_NUEVO);
+    }
+    let mut profundidad: u64 = 0;
+    loop {
+        profundidad += 1;
+        // `sys_object_hijo` lee el hash de HASH_AUX y, si hay hijo, escribe el
+        // del hijo 0 en el MISMO bufer: la cadena desciende un eslabon.
+        let hijos = unsafe {
+            sys_object_hijo(
+                core::ptr::addr_of!(HASH_AUX) as u32,
+                0,
+                core::ptr::addr_of_mut!(HASH_AUX) as u32,
+            )
+        };
+        // Sin hijos: fin de la cadena — el primer arranque de todos. Un valor
+        // negativo seria un objeto que no resolvio: la cadena estaria rota.
+        if hijos <= 0 || profundidad >= 4096 {
+            break;
+        }
+    }
+    profundidad == cuenta
+}
+
+/// Pinta la cronica: el fondo, una celda ambar por arranque y, en la esquina,
+/// el testigo de integridad del grafo.
+fn pintar(cuenta: u64, integro: bool) {
+    // SEGURIDAD: durante `init` esta es la unica via de acceso a LIENZO, y el
+    // kernel jamas reentra el modulo mientras `init` corre.
+    let lienzo: &mut [u32] = unsafe { &mut *core::ptr::addr_of_mut!(LIENZO) };
+    for pixel in lienzo.iter_mut() {
+        *pixel = FONDO;
+    }
+
+    // Una celda ambar por cada arranque registrado, dispuestas en rejilla.
+    let celdas = (cuenta as usize).min(MAX_CELDAS);
+    for i in 0..celdas {
+        let x = (i % POR_FILA) * PASO + 2;
+        let y = (i / POR_FILA) * PASO + 2;
+        rellenar(lienzo, x, y, LADO, LADO, CELDA);
+    }
+
+    // El testigo de integridad: verde si la cadena se recorrio entera de la
+    // raiz al primer eslabon, rojo si algo se rompio.
+    let testigo = if integro { VERDE } else { ROJO };
+    rellenar(lienzo, ANCHO - 14, 4, 10, 10, testigo);
+
+    // SEGURIDAD: `sys_render_frame` es una capacidad del host; el (ptr, len)
+    // describe nuestra propia memoria lineal y el host lo verifica sin piedad.
+    unsafe {
+        sys_render_frame(lienzo.as_ptr() as u32, (ANCHO * ALTO * 4) as u32);
+    }
+}
+
+/// Rellena un rectangulo, recortado con firmeza a los limites del lienzo.
+fn rellenar(lienzo: &mut [u32], x: usize, y: usize, ancho: usize, alto: usize, color: u32) {
+    let x1 = (x + ancho).min(ANCHO);
+    let y1 = (y + alto).min(ALTO);
+    let mut fila = y;
+    while fila < y1 {
+        let base = fila * ANCHO;
+        let mut col = x;
+        while col < x1 {
+            lienzo[base + col] = color;
+            col += 1;
+        }
+        fila += 1;
+    }
+}

renaser/apps/discola/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "discola"
+version = "0.1.0"

renaser/apps/discola/Cargo.toml

@@ -0,0 +1,30 @@
+# =============================================================================
+#  renaser :: apps/discola — el inquilino discolo del userspace
+# -----------------------------------------------------------------------------
+#  Un modulo WebAssembly construido a proposito para portarse mal: su `tick`
+#  cae en un bucle cerrado y jamas retorna. Existe para una sola cosa —
+#  demostrar que el escudo de combustible (fuel) del kernel `renaser` lo
+#  desaloja sin colgar el sistema ni perturbar a sus apps vecinas.
+#  Tiene su propio `[workspace]`: queda fuera del espacio de trabajo del kernel.
+# =============================================================================
+
+[package]
+name = "discola"
+version = "0.1.0"
+edition = "2021"
+description = "renaser :: app WASM discola — un bucle infinito que el fuel fulmina"
+
+[workspace]
+
+# `cdylib` produce un modulo `.wasm` que exporta funciones — el formato que
+# wasmi instancia.
+[lib]
+crate-type = ["cdylib"]
+
+[profile.dev]
+panic = "abort"
+
+[profile.release]
+panic = "abort"
+opt-level = "s"
+lto = true

renaser/apps/discola/src/lib.rs

@@ -0,0 +1,46 @@
+// =============================================================================
+//  renaser :: apps/discola — Fase 5 :: el inquilino discolo del userspace
+// -----------------------------------------------------------------------------
+//  Esta aplicacion esta MAL a proposito. Su `tick` no hace un fotograma de
+//  trabajo y retorna —como manda el ABI cooperativo—: cae en un bucle cerrado
+//  y jamas devuelve el control. En un sistema cooperativo ingenuo, eso colgaria
+//  la maquina entera.
+//
+//  Pero renaser ejecuta cada `tick` con un presupuesto estricto de COMBUSTIBLE.
+//  Cuando este bucle lo agota, el runtime `wasmi` lanza una trampa, el kernel
+//  recupera el mando y desaloja a este modulo — tatuando su region de purpura.
+//  El resto del userspace ni se entera. Eso es lo que esta app demuestra.
+// =============================================================================
+
+#![no_std]
+
+/// Sin sistema operativo bajo nosotros, un panico solo puede detenerse en seco.
+#[panic_handler]
+fn al_fallar(_: &core::panic::PanicInfo) -> ! {
+    loop {}
+}
+
+/// Sumidero de las escrituras del bucle: obliga al compilador a CONSERVAR cada
+/// iteracion —y, con ella, su consumo de combustible— en lugar de elidirla.
+static mut SUMIDERO: u64 = 0;
+
+/// Preparacion. No hay nada honrado que preparar: el kernel la invoca, retorna
+/// sin incidentes, y la app pasa por buena... hasta su primer `tick`.
+#[no_mangle]
+pub extern "C" fn init() {}
+
+/// El fotograma que nunca termina. Un bucle cerrado, deliberado: jamas retorna.
+/// El kernel `renaser` lo cortara por agotamiento de combustible y desalojara
+/// esta aplicacion sin que el sistema sufra un solo sobresalto.
+#[no_mangle]
+pub extern "C" fn tick() {
+    let mut contador: u64 = 0;
+    loop {
+        contador = contador.wrapping_add(1);
+        // SEGURIDAD: escritura volatil a un escalar estatico; su unico fin es
+        // que el optimizador no pueda vaciar el bucle. No se crea referencia.
+        unsafe {
+            core::ptr::write_volatile(core::ptr::addr_of_mut!(SUMIDERO), contador);
+        }
+    }
+}

renaser/apps/glotona/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "glotona"
+version = "0.1.0"

renaser/apps/glotona/Cargo.toml

@@ -0,0 +1,30 @@
+# =============================================================================
+#  renaser :: apps/glotona — el inquilino voraz del userspace
+# -----------------------------------------------------------------------------
+#  Un modulo WebAssembly construido a proposito para devorar memoria: su `tick`
+#  reclama paginas de memoria lineal sin freno. Existe para demostrar que el
+#  techo ESPACIAL del kernel `renaser` lo desaloja —baliza amarilla— sin agotar
+#  el heap del sistema ni perturbar a sus apps vecinas.
+#  Tiene su propio `[workspace]`: queda fuera del espacio de trabajo del kernel.
+# =============================================================================
+
+[package]
+name = "glotona"
+version = "0.1.0"
+edition = "2021"
+description = "renaser :: app WASM glotona — devora memoria; el techo espacial la frena"
+
+[workspace]
+
+# `cdylib` produce un modulo `.wasm` que exporta funciones — el formato que
+# wasmi instancia.
+[lib]
+crate-type = ["cdylib"]
+
+[profile.dev]
+panic = "abort"
+
+[profile.release]
+panic = "abort"
+opt-level = "s"
+lto = true

renaser/apps/glotona/src/lib.rs

@@ -0,0 +1,39 @@
+// =============================================================================
+//  renaser :: apps/glotona — Fase 6.0 :: el inquilino voraz del userspace
+// -----------------------------------------------------------------------------
+//  Esta aplicacion esta MAL a proposito, como su hermana `discola` — pero en la
+//  otra dimension. Donde `discola` devora TIEMPO (un bucle sin fin), `glotona`
+//  devora ESPACIO: su `tick` invoca `memory.grow` reclamando memoria lineal sin
+//  freno alguno.
+//
+//  renaser le impone a cada modulo un techo de memoria. Cuando esta peticion lo
+//  rebasa, el runtime `wasmi` —configurado para ello— lanza una trampa en vez
+//  de devolver un discreto -1; el kernel la captura, desaloja a este modulo y
+//  tiñe su region de amarillo palido. El heap del sistema jamas corre peligro.
+// =============================================================================
+
+#![no_std]
+
+/// Sin sistema operativo bajo nosotros, un panico solo puede detenerse en seco.
+#[panic_handler]
+fn al_fallar(_: &core::panic::PanicInfo) -> ! {
+    loop {}
+}
+
+/// Preparacion. Nada honrado que preparar: la app pasa por buena hasta su
+/// primer `tick`, igual que su hermana `discola`.
+#[no_mangle]
+pub extern "C" fn init() {}
+
+/// El fotograma voraz. Reclama 4096 paginas de memoria lineal de un golpe —
+/// 256 MiB, muy por encima de cualquier techo razonable. El kernel `renaser`
+/// denegara la expansion con una trampa y desalojara esta aplicacion.
+#[no_mangle]
+pub extern "C" fn tick() {
+    // `memory_grow` sobre la memoria 0. Con el techo espacial activo y la
+    // denegacion configurada como trampa, esta instruccion NO retorna: aborta.
+    let _ = core::arch::wasm32::memory_grow(0, 4096);
+    // Red de seguridad: si la denegacion no fuese una trampa, este bucle
+    // cerrado garantiza el desalojo —por combustible— de todos modos.
+    loop {}
+}

renaser/apps/hello_wasm/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "hello_wasm"
+version = "0.1.0"

renaser/apps/hello_wasm/Cargo.toml

@@ -0,0 +1,28 @@
+# =============================================================================
+#  renaser :: apps/hello_wasm — primera aplicacion del userspace aislado
+# -----------------------------------------------------------------------------
+#  No es un ELF: es un modulo WebAssembly puro. Se compila para wasm32 y el
+#  kernel lo ejecuta dentro de wasmi, encerrado en su propia memoria lineal.
+#  Tiene su propio `[workspace]`: queda fuera del espacio de trabajo del kernel.
+# =============================================================================
+
+[package]
+name = "hello_wasm"
+version = "0.1.0"
+edition = "2021"
+description = "renaser :: app WASM de prueba — un cuadrado movil dirigido por teclado"
+
+[workspace]
+
+# `cdylib` produce un modulo `.wasm` que exporta funciones — el formato que
+# wasmi instancia. La aplicacion solo habla con el kernel por funciones del host.
+[lib]
+crate-type = ["cdylib"]
+
+[profile.dev]
+panic = "abort"
+
+[profile.release]
+panic = "abort"
+opt-level = "s"
+lto = true

renaser/apps/hello_wasm/src/lib.rs

@@ -0,0 +1,140 @@
+// =============================================================================
+//  renaser :: apps/hello_wasm — Fase 4/5 :: el primer ciudadano del userspace
+// -----------------------------------------------------------------------------
+//  Esta aplicacion vive DENTRO de su propia memoria lineal de WebAssembly. No
+//  conoce la MMU, no conoce los anillos de privilegio de la CPU: su unica via
+//  hacia el mundo son las dos capacidades que el kernel le inyecta. Lo que no
+//  este importado, sencillamente, no tiene camino fisico que recorrer.
+//
+//  FASE 5 :: el ABI deja de ser un `run()` que se queda dentro para siempre.
+//  Ahora la app exporta `init()` —preparacion, una sola vez— y `tick()` —un
+//  fotograma de trabajo, y RETORNA—. Ese retorno es el punto de cesion
+//  cooperativa: el kernel recupera el control y atiende a las demas apps.
+// =============================================================================
+
+#![no_std]
+
+// --- Las dos UNICAS capacidades que el kernel `renaser` expone al modulo. ---
+#[link(wasm_import_module = "renaser")]
+extern "C" {
+    /// Compone un bufer de pixeles (de ESTA memoria lineal) en la region que el
+    /// kernel asigno a esta aplicacion.
+    fn sys_render_frame(ptr: u32, len: u32);
+    /// Devuelve el ultimo scancode crudo del teclado, o 0 si no hay ninguno.
+    fn sys_get_scancode() -> u32;
+}
+
+/// Sin sistema operativo bajo nosotros, un panico solo puede detenerse en seco.
+#[panic_handler]
+fn al_fallar(_: &core::panic::PanicInfo) -> ! {
+    loop {}
+}
+
+// --- Geometria de la escena. El ancho y el alto DEBEN coincidir con la region
+//     que el kernel asigna a esta app: el host rechaza cualquier fotograma de
+//     un tamaño que no sea, exactamente, el de su ventana. ---
+const ANCHO: usize = 480;
+const ALTO: usize = 560;
+const LADO: usize = 96;
+const PASO: i32 = 24;
+
+/// Azul nocturno: el fondo del lienzo de la aplicacion.
+const FONDO: u32 = 0x0A_18_30;
+/// Ambar: el cuadrado que el usuario gobierna.
+const CUADRO: u32 = 0xFF_B0_00;
+
+/// El lienzo de la aplicacion, en SU propia memoria lineal. El kernel jamas lo
+/// ve directamente: solo recibe el (ptr, len) que cada fotograma le entrega.
+static mut LIENZO: [u32; ANCHO * ALTO] = [0; ANCHO * ALTO];
+
+/// Posicion del cuadrado. Vive entre fotogramas en la memoria lineal del modulo
+/// — el estado persiste porque la instancia, en la Fase 5, ya no es efimera.
+static mut POS_X: i32 = 0;
+static mut POS_Y: i32 = 0;
+
+/// Preparacion: el kernel la invoca UNA sola vez, al cargar el modulo. Pinta el
+/// fondo, centra el cuadrado y vuelca el primer fotograma.
+#[no_mangle]
+pub extern "C" fn init() {
+    // SEGURIDAD: durante `init` y `tick` esta es la unica via de acceso a
+    // LIENZO, y el kernel jamas reentra el modulo mientras una de ellas corre.
+    let lienzo: &mut [u32] = unsafe { &mut *core::ptr::addr_of_mut!(LIENZO) };
+    for pixel in lienzo.iter_mut() {
+        *pixel = FONDO;
+    }
+
+    let x = (ANCHO / 2 - LADO / 2) as i32;
+    let y = (ALTO / 2 - LADO / 2) as i32;
+    rellenar(lienzo, x, y, CUADRO);
+    // SEGURIDAD: escritura de escalares `Copy`; no se crea referencia alguna.
+    unsafe {
+        POS_X = x;
+        POS_Y = y;
+    }
+
+    volcar(lienzo);
+}
+
+/// Un fotograma de trabajo: escucha el teclado, mueve el cuadrado, vuelca la
+/// imagen y RETORNA. El retorno cede la CPU al kernel y a las apps vecinas.
+#[no_mangle]
+pub extern "C" fn tick() {
+    let lienzo: &mut [u32] = unsafe { &mut *core::ptr::addr_of_mut!(LIENZO) };
+    let (mut x, mut y) = unsafe { (POS_X, POS_Y) };
+
+    // 1. Escuchar al teclado a traves de la capacidad del host.
+    let (dx, dy) = match unsafe { sys_get_scancode() } {
+        0x11 => (0, -PASO), // tecla W -> arriba
+        0x1F => (0, PASO),  // tecla S -> abajo
+        0x1E => (-PASO, 0), // tecla A -> izquierda
+        0x20 => (PASO, 0),  // tecla D -> derecha
+        _ => (0, 0),
+    };
+
+    // 2. Borrar el cuadrado anterior repintando su hueco con el fondo.
+    rellenar(lienzo, x, y, FONDO);
+
+    // 3. Moverlo, manteniendolo siempre dentro del lienzo.
+    x = (x + dx).clamp(0, (ANCHO - LADO) as i32);
+    y = (y + dy).clamp(0, (ALTO - LADO) as i32);
+
+    // 4. Dibujar el cuadrado en su nueva posicion y guardar el estado.
+    rellenar(lienzo, x, y, CUADRO);
+    unsafe {
+        POS_X = x;
+        POS_Y = y;
+    }
+
+    // 5. Volcar el fotograma: el host lo compondra dentro de nuestra region.
+    volcar(lienzo);
+}
+
+/// Entrega el lienzo completo al kernel. El (ptr, len) apunta SIEMPRE dentro de
+/// nuestra memoria lineal, y su tamaño es, exactamente, el de la region.
+fn volcar(lienzo: &[u32]) {
+    // SEGURIDAD: `sys_render_frame` es una capacidad del host; el (ptr, len)
+    // describe nuestra propia memoria lineal y el host lo verifica sin piedad.
+    unsafe {
+        sys_render_frame(lienzo.as_ptr() as u32, (ANCHO * ALTO * 4) as u32);
+    }
+}
+
+/// Rellena un cuadrado de lado `LADO`, con su esquina en (x, y), recortado con
+/// firmeza a los limites del lienzo.
+fn rellenar(lienzo: &mut [u32], x: i32, y: i32, color: u32) {
+    let x0 = x.max(0) as usize;
+    let y0 = y.max(0) as usize;
+    let x1 = (x0 + LADO).min(ANCHO);
+    let y1 = (y0 + LADO).min(ALTO);
+
+    let mut fila = y0;
+    while fila < y1 {
+        let base = fila * ANCHO;
+        let mut col = x0;
+        while col < x1 {
+            lienzo[base + col] = color;
+            col += 1;
+        }
+        fila += 1;
+    }
+}

renaser/boot/Cargo.toml

@@ -0,0 +1,27 @@
+# =============================================================================
+#  renaser :: boot (Fase 1.5) — orquestador host-side de empaquetado y arranque
+# -----------------------------------------------------------------------------
+#  Este paquete se ejecuta en el ANFITRION (Artix Linux), nunca en bare-metal.
+#  Toma el ELF nativo del kernel, lo fusiona con el cargador UEFI y lanza QEMU.
+# =============================================================================
+
+[package]
+name = "boot"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+authors.workspace = true
+description = "renaser :: constructor de imagen de disco UEFI y lanzador de QEMU"
+
+[dependencies]
+# Constructor de la imagen de disco UEFI. Corre en el anfitrion, usa `std`.
+bootloader.workspace = true
+
+# Dependencia de ARTEFACTO (RFC 3028). Cargo compila el kernel para
+# `x86_64-unknown-none` —en aislamiento total de arquitectura— y nos inyecta la
+# ruta de su ELF en la variable de entorno `CARGO_BIN_FILE_KERNEL_kernel`,
+# accesible desde `main.rs` mediante el macro `env!`.
+[dependencies.kernel]
+path = "../kernel"
+artifact = "bin"
+target = "x86_64-unknown-none"

renaser/boot/src/main.rs

@@ -0,0 +1,172 @@
+// =============================================================================
+//  renaser :: boot/src/main.rs — Fase 1.5 :: el puente hacia el silicio
+// -----------------------------------------------------------------------------
+//  Un kernel bare-metal no nace solo: alguien debe fusionarlo con un cargador,
+//  sellarlo en una imagen de disco arrancable y entregarlo al hardware. Esa es
+//  la unica mision de este orquestador de ANFITRION.
+//
+//  El flujo es deliberadamente lineal y sin ambiguedad:
+//
+//    1. Localizar el ELF nativo del kernel (lo inyecta la dep. de artefacto).
+//    2. Fusionarlo con el cargador UEFI en una imagen de disco GPT.
+//    3. Lanzar QEMU con esa imagen y el firmware OVMF.
+//
+//  Cada paso que pueda fallar lo hace en voz alta, con un mensaje accionable:
+//  preferimos un error claro a un arranque silencioso hacia la nada.
+// =============================================================================
+
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+/// Ruta del ELF del kernel, ya compilado para `x86_64-unknown-none`.
+///
+/// La dependencia de artefacto define esta variable de entorno en tiempo de
+/// compilacion: cuando este binario de anfitrion existe, el kernel ya existe.
+const KERNEL_ELF: &str = env!("CARGO_BIN_FILE_KERNEL_kernel");
+
+/// Firmware UEFI OVMF tal como lo empaqueta Artix Linux (paquete `edk2-ovmf`).
+/// Es la imagen combinada codigo+variables, apta para `-bios`.
+const OVMF_POR_DEFECTO: &str = "/usr/share/edk2/x64/OVMF.4m.fd";
+
+/// Nombre de la imagen de disco UEFI que renaser genera.
+const NOMBRE_IMAGEN: &str = "renaser-uefi.img";
+
+/// Ruta del disco de objetos del grafo persistente (Fase 6.1c). Relativa al
+/// directorio de trabajo —la raiz del repo—, comun a `boot` y a QEMU.
+const NOMBRE_DISCO: &str = "target/disk.img";
+
+/// Tamaño del disco de objetos: 32 MiB. Se crea como fichero disperso.
+const TAM_DISCO: u64 = 32 * 1024 * 1024;
+
+fn main() {
+    if let Err(fallo) = orquestar() {
+        // Un error de orquestacion se anuncia en rojo y aborta con codigo 1:
+        // ninguna falla del anfitrion debe disfrazarse de exito.
+        eprintln!("\x1b[1;31m[renaser/boot] fallo:\x1b[0m {fallo}");
+        std::process::exit(1);
+    }
+}
+
+/// Ejecuta, en orden, las tres operaciones de la Fase 1.5.
+fn orquestar() -> Result<(), String> {
+    // --- 1. Localizar el artefacto del kernel. ---
+    let kernel = Path::new(KERNEL_ELF);
+    if !kernel.is_file() {
+        return Err(format!(
+            "no se encontro el ELF del kernel en {}\n  \
+             (¿se interrumpio la compilacion de la dependencia de artefacto?)",
+            kernel.display()
+        ));
+    }
+    println!("[renaser/boot] kernel localizado :: {}", kernel.display());
+
+    // --- 2. Fusionar kernel + cargador UEFI en una imagen de disco. ---
+    let imagen = ruta_imagen(kernel);
+    println!("[renaser/boot] forjando imagen UEFI :: {}", imagen.display());
+    bootloader::UefiBoot::new(kernel)
+        .create_disk_image(&imagen)
+        .map_err(|e| format!("la crate `bootloader` no pudo crear la imagen UEFI: {e:?}"))?;
+
+    // --- 3. Garantizar el disco de objetos del grafo persistente. ---
+    preparar_disco_objetos()?;
+
+    // --- 4. Lanzar QEMU sobre esa imagen. ---
+    let ovmf = localizar_ovmf()?;
+    lanzar_qemu(&imagen, &ovmf)
+}
+
+/// Garantiza la existencia del disco de objetos del grafo persistente. Si no
+/// existe, lo forja como un fichero disperso de 32 MiB, ENTERAMENTE A CERO: el
+/// kernel, al no hallar la firma de su superbloque, lo formateara como un grafo
+/// virgen. Si ya existe, lo respeta — el grafo perdura entre arranques.
+fn preparar_disco_objetos() -> Result<(), String> {
+    let disco = Path::new(NOMBRE_DISCO);
+    if disco.is_file() {
+        println!("[renaser/boot] disco de objetos presente :: {}", disco.display());
+        return Ok(());
+    }
+    if let Some(directorio) = disco.parent() {
+        std::fs::create_dir_all(directorio)
+            .map_err(|e| format!("no se pudo crear el directorio del disco de objetos: {e}"))?;
+    }
+    // Forjar el disco: un fichero disperso, a cero, de 32 MiB. El kernel
+    // escribira su superbloque la primera vez que lo monte.
+    let fichero = std::fs::File::create(disco)
+        .map_err(|e| format!("no se pudo crear el disco de objetos «{}»: {e}", disco.display()))?;
+    fichero
+        .set_len(TAM_DISCO)
+        .map_err(|e| format!("no se pudo dimensionar el disco de objetos: {e}"))?;
+    println!(
+        "[renaser/boot] disco de objetos forjado :: {} ({} MiB, virgen)",
+        disco.display(),
+        TAM_DISCO / (1024 * 1024)
+    );
+    Ok(())
+}
+
+/// Calcula la ruta de la imagen: junto al propio ELF del kernel, es decir,
+/// dentro de `target/`. Una ubicacion predecible y siempre escribible.
+fn ruta_imagen(kernel: &Path) -> PathBuf {
+    kernel
+        .parent()
+        .unwrap_or_else(|| Path::new("."))
+        .join(NOMBRE_IMAGEN)
+}
+
+/// Resuelve la ruta del firmware OVMF. Permite sobreescribirla con la variable
+/// de entorno `RENASER_OVMF` para entornos cuyo `edk2-ovmf` viva en otra ruta.
+fn localizar_ovmf() -> Result<String, String> {
+    let ruta = std::env::var("RENASER_OVMF").unwrap_or_else(|_| OVMF_POR_DEFECTO.to_string());
+    if Path::new(&ruta).is_file() {
+        Ok(ruta)
+    } else {
+        Err(format!(
+            "firmware UEFI OVMF no encontrado en «{ruta}»\n  \
+             instala el paquete `edk2-ovmf`, o exporta RENASER_OVMF=<ruta a OVMF.fd>"
+        ))
+    }
+}
+
+/// Invoca QEMU como subproceso. Los argumentos se ciñen a las primitivas
+/// minimas necesarias para que el Framebuffer GOP cobre vida:
+///
+///   * `-bios`            firmware UEFI OVMF.
+///   * `-drive raw`       la imagen de disco UEFI, sin capa de traduccion.
+///   * `-vga std`         VGA estandar => framebuffer lineal que el GOP expone.
+///   * `-serial stdio`    telemetria serial del procesador hacia esta consola.
+///   * `--no-reboot`      un fallo triple detiene la maquina en vez de reiniciar
+///                        en bucle: asi la baliza de panico permanece visible.
+///   * `virtio-blk-pci`   el disco de objetos, sobre el bus PCI (q35 es x86_64;
+///                        `virtio-blk-device`, su gemelo MMIO, es cosa de ARM).
+fn lanzar_qemu(imagen: &Path, ovmf: &str) -> Result<(), String> {
+    println!("[renaser/boot] arrancando QEMU :: la superficie indigo nace ahora\n");
+
+    let mut qemu = Command::new("qemu-system-x86_64");
+    // `accel=kvm:tcg` intenta KVM y, si no esta disponible, recae en TCG puro.
+    qemu.arg("-machine").arg("q35,accel=kvm:tcg")
+        .arg("-m").arg("256M")
+        .arg("-bios").arg(ovmf)
+        .arg("-drive").arg(format!("format=raw,file={}", imagen.display()))
+        .arg("-vga").arg("std")
+        .arg("-serial").arg("stdio")
+        .arg("--no-reboot")
+        // El disco de objetos, como dispositivo virtio-blk sobre el bus PCI.
+        .arg("-drive").arg(format!("format=raw,file={NOMBRE_DISCO},if=none,id=drv0"))
+        .arg("-device").arg("virtio-blk-pci,drive=drv0");
+
+    // Cualquier argumento extra tras `--` se reenvia a QEMU intacto.
+    // Ejemplo: `cargo run -p boot -- -display none -d int`.
+    qemu.args(std::env::args().skip(1));
+
+    match qemu.status() {
+        Ok(estado) if estado.success() => {
+            println!("\n[renaser/boot] QEMU finalizo limpiamente.");
+            Ok(())
+        }
+        Ok(estado) => Err(format!("QEMU termino con estado anomalo: {estado}")),
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Err(
+            "`qemu-system-x86_64` no esta en el PATH; instala el paquete `qemu-full`".to_string(),
+        ),
+        Err(e) => Err(format!("no se pudo ejecutar QEMU: {e}")),
+    }
+}

renaser/kernel/Cargo.toml

@@ -0,0 +1,68 @@
+# =============================================================================
+#  renaser :: kernel — el corazon bare-metal que late en el espacio unico
+# -----------------------------------------------------------------------------
+#  Este paquete esta EXCLUIDO del espacio de trabajo (ver el Cargo.toml raiz):
+#  es codigo puramente bare-metal y solo se compila como dependencia de
+#  artefacto de `boot`, que le impone el target `x86_64-unknown-none`. Por eso
+#  fija sus versiones de forma explicita, sin herencia del workspace.
+# =============================================================================
+
+[package]
+name = "kernel"
+version = "0.1.0"
+edition = "2021"
+license = "MPL-2.0"
+authors = ["JL Soltech <gerencia@jlsoltech.com>"]
+description = "renaser :: kernel asincrono SASOS — entrada, framebuffer y reactor"
+
+# El kernel es un binario freestanding: sin arnes de pruebas ni de benchmarks.
+[[bin]]
+name = "kernel"
+path = "src/main.rs"
+test = false
+bench = false
+doctest = false
+
+[dependencies]
+# --- Fase 1-2 :: arranque, framebuffer e interrupciones ---
+bootloader_api = "0.11"
+x86_64 = "0.15"
+embedded-graphics = "0.8"
+
+# --- Fase 3 :: heap dinamico, reactor asincrono y texto vectorial ---
+linked_list_allocator = "0.10"
+spin = "0.9"
+crossbeam-queue = { version = "0.3", default-features = false, features = ["alloc"] }
+futures-util = { version = "0.3", default-features = false, features = ["alloc"] }
+# `hashbrown` ACTIVA el modo `no_std` de fontdue; sin el recae en `std`.
+fontdue = { version = "0.9", default-features = false, features = ["hashbrown"] }
+
+# --- Fase 4 :: interprete WebAssembly del userspace aislado ---
+# `wasmi` bare-metal: sin `std`, sin `wat`, sin `simd` (el target no tiene SSE).
+wasmi = { version = "1.0", default-features = false, features = ["hash-collections"] }
+
+# --- Fase 6 :: drivers de hardware — el disco virtio-blk sobre el bus PCI ---
+# `virtio-drivers` bare-metal: el kernel implementa su `trait Hal` para el DMA.
+virtio-drivers = { version = "0.13", default-features = false, features = ["alloc"] }
+
+# --- Fase 6.1c :: el grafo de objetos direccionado por contenido ---
+# `serde` da el rasgo de (de)serializacion; `postcard` lo materializa en un
+# formato binario compacto, pensado para sistemas empotrados — el que viaja al
+# disco. Ambos `no_std`, apoyados en `alloc`.
+serde = { version = "1", default-features = false, features = ["alloc", "derive"] }
+postcard = { version = "1", default-features = false, features = ["alloc"] }
+# `blake3`: la funcion hash que da identidad a cada objeto. Se fuerza la
+# implementacion ESCALAR pura (`pure` + los cuatro `no_*`): el target del kernel
+# corre sin SSE, y un camino SIMD activado por deteccion en tiempo de ejecucion
+# ejecutaria instrucciones que la CPU, sin `CR4.OSFXSR`, rechazaria con un #UD.
+blake3 = { version = "1", default-features = false, features = [
+    "pure", "no_sse2", "no_sse41", "no_avx2", "no_avx512",
+] }
+
+# --- Fase 8 (preparación) :: el compositor ---
+# `mirada-layout` es el motor de teselado del compositor de brahman —
+# geometría pura (rectángulos, foco, Z-order), `no_std`, sin smithay ni
+# Wayland. Vive en el monorepo brahman, en su PROPIO workspace; renaser
+# lo enlaza por `path` cruzando la frontera. La feature `serde` queda
+# APAGADA: el kernel computa el layout en memoria, no lo serializa.
+mirada-layout = { path = "../../crates/modules/mirada/mirada-layout" }

renaser/kernel/src/almacen.rs

@@ -0,0 +1,292 @@
+// =============================================================================
+//  renaser :: kernel/src/almacen.rs — Fase 6.1c :: el grafo de objetos
+// -----------------------------------------------------------------------------
+//  renaser rompe con POSIX tambien en el almacenamiento: aqui no hay un sistema
+//  de archivos plano —rutas, directorios, inodos—. Hay un GRAFO DIRIGIDO ACICLICO
+//  de objetos DIRECCIONADOS POR CONTENIDO.
+//
+//  Un objeto es una carga util de bytes y una lista de aristas hacia otros
+//  objetos. Su IDENTIDAD no es un nombre ni un numero: es el hash BLAKE3 de su
+//  forma serializada. De ello se siguen dos propiedades que un FS jamas regala:
+//
+//    * INTEGRIDAD — el hash verifica el contenido; un objeto corrupto se delata.
+//    * DEDUPLICACION — contenido identico produce hash identico; se almacena
+//      una sola vez, aunque mil aristas apunten a el.
+//
+//  El disco se organiza como un LOG: el sector 0 es el superbloque —el ancla
+//  del grafo—, y tras el se anexan los registros de objetos, uno tras otro. Un
+//  indice en memoria (hash -> sector) se reconstruye al arrancar recorriendo el
+//  log. La serializacion la hace `postcard`: binaria, compacta, determinista.
+// =============================================================================
+
+use alloc::collections::BTreeMap;
+use alloc::vec;
+use alloc::vec::Vec;
+
+use serde::{Deserialize, Serialize};
+use spin::{Mutex, Once};
+
+use crate::drivers::disco::{self, TAM_SECTOR};
+
+/// Firma magica del superbloque — «RENASer GRaFo». Distingue un disco de
+/// renaser de uno virgen o ajeno.
+const MAGIA: [u8; 8] = *b"RENASGRF";
+
+/// Version del formato en disco. Un disco con otra version se reformatea.
+const VERSION: u32 = 1;
+
+/// Techo del tamaño de un objeto serializado: 1 MiB. Acota los buferes de E/S
+/// y permite descartar un registro corrupto sin intentar leer un disparate.
+const MAX_OBJETO: usize = 1024 * 1024;
+
+/// El identificador de un objeto: el hash BLAKE3 de su forma serializada. En un
+/// almacen direccionado por contenido, la identidad ES el contenido.
+pub type Hash = [u8; 32];
+
+/// Un objeto del grafo: una carga util opaca y las aristas que lo enlazan con
+/// otros objetos. Los `hijos` hacen del almacen un DAG —no un arbol, no una
+/// lista—: un objeto puede ser hijo de muchos, y el direccionamiento por
+/// contenido garantiza que cada contenido distinto se guarda una sola vez.
+#[derive(Serialize, Deserialize, Clone)]
+pub struct Objeto {
+    /// La carga util del objeto: bytes crudos, que el kernel no interpreta.
+    pub datos: Vec<u8>,
+    /// Los hashes de los objetos hijos: las aristas salientes del DAG.
+    pub hijos: Vec<Hash>,
+}
+
+/// El superbloque: el sector 0 del disco. Ancla el grafo entero — dice por
+/// donde continua el log y cual es el objeto raiz.
+#[derive(Serialize, Deserialize)]
+struct SuperBloque {
+    /// Firma magica: debe ser [`MAGIA`].
+    magia: [u8; 8],
+    /// Version del formato: debe ser [`VERSION`].
+    version: u32,
+    /// Proximo sector libre del log — donde se anexara el siguiente objeto.
+    cursor: u64,
+    /// El objeto raiz del DAG: el punto de entrada que el userspace fija y lee.
+    raiz: Option<Hash>,
+}
+
+/// El estado vivo del almacen: el cursor del log, la raiz y el indice en
+/// memoria que traduce cada hash al sector donde habita su registro.
+struct Almacen {
+    /// Proximo sector libre del log.
+    cursor: u64,
+    /// El objeto raiz del DAG.
+    raiz: Option<Hash>,
+    /// Indice hash -> sector del registro. Se reconstruye al arrancar.
+    indice: BTreeMap<Hash, u64>,
+    /// Capacidad del disco, en sectores.
+    capacidad: u64,
+}
+
+/// El almacen global de renaser. Se funde una sola vez, en `init`.
+static ALMACEN: Once<Mutex<Almacen>> = Once::new();
+
+/// El fruto de fundar el almacen — para que el arranque deje constancia visual.
+pub struct Resumen {
+    /// Capacidad del disco, en sectores.
+    pub capacidad: u64,
+    /// Numero de objetos hallados en el grafo.
+    pub objetos: usize,
+    /// ¿Tiene el grafo un objeto raiz?
+    pub raiz: bool,
+    /// ¿Se reformateo el disco (estaba virgen o era ajeno)?
+    pub formateado: bool,
+}
+
+/// Numero de sectores que ocupa un registro cuyo payload mide `longitud` bytes.
+/// Cada registro en disco es: `[longitud: u32 LE][payload postcard][relleno 0]`.
+fn sectores_registro(longitud: usize) -> u64 {
+    (4 + longitud).div_ceil(TAM_SECTOR) as u64
+}
+
+/// Funda el almacen de objetos: monta el disco, lee el superbloque y, si el
+/// disco ya es de renaser, reconstruye el indice recorriendo el log; si es
+/// virgen o ajeno, lo formatea. Toda falla se devuelve como `Err`.
+pub fn init() -> Result<Resumen, &'static str> {
+    let capacidad = disco::montar()?;
+    if capacidad < 2 {
+        return Err("el disco es demasiado pequeño para un grafo");
+    }
+
+    // Leer el sector 0 e intentar interpretarlo como superbloque de renaser.
+    let mut sector0 = [0u8; TAM_SECTOR];
+    disco::leer_sectores(0, &mut sector0)?;
+
+    let (cursor, raiz, indice, formateado) =
+        match postcard::take_from_bytes::<SuperBloque>(&sector0) {
+            // Disco de renaser, con la version corriente: adoptar su grafo.
+            Ok((sb, _)) if sb.magia == MAGIA && sb.version == VERSION => {
+                let indice = reconstruir_indice(sb.cursor)?;
+                (sb.cursor, sb.raiz, indice, false)
+            }
+            // Disco virgen, ajeno o de otra version: empezar de cero. El log
+            // arranca en el sector 1, justo despues del superbloque.
+            _ => (1, None, BTreeMap::new(), true),
+        };
+
+    let objetos = indice.len();
+    let tiene_raiz = raiz.is_some();
+    let almacen = Almacen {
+        cursor,
+        raiz,
+        indice,
+        capacidad,
+    };
+
+    // Un disco recien formateado necesita su superbloque grabado de inmediato.
+    if formateado {
+        persistir(&almacen)?;
+    }
+    ALMACEN.call_once(|| Mutex::new(almacen));
+
+    Ok(Resumen {
+        capacidad,
+        objetos,
+        raiz: tiene_raiz,
+        formateado,
+    })
+}
+
+/// Recorre el log —del sector 1 al `cursor`— y reconstruye el indice
+/// hash -> sector. Cada registro se rehashea: el indice se reconstruye, no se
+/// confia. Un registro corrupto detiene el escaneo sin incendiar nada.
+fn reconstruir_indice(cursor: u64) -> Result<BTreeMap<Hash, u64>, &'static str> {
+    let mut indice = BTreeMap::new();
+    let mut sector: u64 = 1;
+    while sector < cursor {
+        let payload = leer_registro(sector)?;
+        match payload {
+            // Un payload valido: hashearlo e indexarlo.
+            Some(payload) => {
+                let n = sectores_registro(payload.len());
+                let hash = *blake3::hash(&payload).as_bytes();
+                indice.insert(hash, sector);
+                sector += n;
+            }
+            // Cabecera a cero o longitud imposible: fin (o corrupcion) del log.
+            None => break,
+        }
+    }
+    Ok(indice)
+}
+
+/// Lee el registro que arranca en `sector` y devuelve su payload postcard
+/// (sin la cabecera de longitud ni el relleno). `None` si la cabecera dice
+/// longitud cero —fin del log— o una longitud imposible —corrupcion—.
+fn leer_registro(sector: u64) -> Result<Option<Vec<u8>>, &'static str> {
+    let mut cabecera = [0u8; TAM_SECTOR];
+    disco::leer_sectores(sector, &mut cabecera)?;
+    let longitud =
+        u32::from_le_bytes([cabecera[0], cabecera[1], cabecera[2], cabecera[3]]) as usize;
+    if longitud == 0 || longitud > MAX_OBJETO {
+        return Ok(None);
+    }
+    let n = sectores_registro(longitud) as usize;
+    // Si el registro cabe en el sector ya leido, evitar una segunda lectura.
+    let payload = if n == 1 {
+        cabecera[4..4 + longitud].to_vec()
+    } else {
+        let mut buf = vec![0u8; n * TAM_SECTOR];
+        disco::leer_sectores(sector, &mut buf)?;
+        buf[4..4 + longitud].to_vec()
+    };
+    Ok(Some(payload))
+}
+
+/// Graba el superbloque —el ancla del grafo— en el sector 0.
+fn persistir(almacen: &Almacen) -> Result<(), &'static str> {
+    let sb = SuperBloque {
+        magia: MAGIA,
+        version: VERSION,
+        cursor: almacen.cursor,
+        raiz: almacen.raiz,
+    };
+    let bytes = postcard::to_allocvec(&sb).map_err(|_| "no se pudo serializar el superbloque")?;
+    if bytes.len() > TAM_SECTOR {
+        return Err("el superbloque no cabe en un sector");
+    }
+    let mut sector0 = [0u8; TAM_SECTOR];
+    sector0[..bytes.len()].copy_from_slice(&bytes);
+    disco::escribir_sectores(0, &sector0)
+}
+
+/// Almacena un objeto y devuelve su hash. Direccionamiento por contenido en
+/// estado puro: si un objeto de contenido identico ya existe, NO se reescribe —
+/// se devuelve el hash que ya tenia. El grafo nunca guarda dos veces lo mismo.
+pub fn almacenar(datos: Vec<u8>, hijos: Vec<Hash>) -> Result<Hash, &'static str> {
+    let objeto = Objeto { datos, hijos };
+    let bytes =
+        postcard::to_allocvec(&objeto).map_err(|_| "no se pudo serializar el objeto")?;
+    if bytes.is_empty() || bytes.len() > MAX_OBJETO {
+        return Err("el objeto tiene un tamaño invalido");
+    }
+    // La identidad del objeto: el hash de su forma serializada.
+    let hash = *blake3::hash(&bytes).as_bytes();
+
+    let mutex = ALMACEN.get().ok_or("almacen no inicializado")?;
+    let mut almacen = mutex.lock();
+
+    // ¿Ya esta en el grafo? Entonces no hay nada que grabar.
+    if almacen.indice.contains_key(&hash) {
+        return Ok(hash);
+    }
+
+    // Reservar los sectores del registro al final del log.
+    let n = sectores_registro(bytes.len());
+    if almacen.cursor + n > almacen.capacidad {
+        return Err("el grafo de objetos esta lleno");
+    }
+    let sector = almacen.cursor;
+
+    // Componer el registro: [longitud][payload][relleno a cero] y grabarlo.
+    let mut registro = vec![0u8; n as usize * TAM_SECTOR];
+    registro[0..4].copy_from_slice(&(bytes.len() as u32).to_le_bytes());
+    registro[4..4 + bytes.len()].copy_from_slice(&bytes);
+    disco::escribir_sectores(sector, &registro)?;
+
+    // El objeto ya esta en disco: avanzar el cursor, indexarlo y RE-anclar el
+    // superbloque. El orden importa — el superbloque se graba el ultimo, de
+    // modo que jamas apunte a un registro a medio escribir.
+    almacen.cursor += n;
+    almacen.indice.insert(hash, sector);
+    persistir(&almacen)?;
+
+    Ok(hash)
+}
+
+/// Recupera un objeto por su hash. `Ok(None)` si el hash no esta en el grafo.
+pub fn recuperar(hash: &Hash) -> Result<Option<Objeto>, &'static str> {
+    let mutex = ALMACEN.get().ok_or("almacen no inicializado")?;
+    // Soltar el cerrojo del almacen ANTES de la E/S de disco —lenta, por
+    // sondeo—: el indice ya entrego el sector, y nada mas reclama el cerrojo.
+    let sector = match mutex.lock().indice.get(hash) {
+        Some(&s) => s,
+        None => return Ok(None),
+    };
+    let payload = leer_registro(sector)?.ok_or("registro de objeto corrupto")?;
+    // Verificacion de integridad: el contenido leido DEBE rehashear al hash
+    // pedido. Si no, el disco ha mentido — y se delata.
+    if *blake3::hash(&payload).as_bytes() != *hash {
+        return Err("el objeto no supero la verificacion de integridad");
+    }
+    let (objeto, _) = postcard::take_from_bytes::<Objeto>(&payload)
+        .map_err(|_| "no se pudo deserializar el objeto")?;
+    Ok(Some(objeto))
+}
+
+/// El hash del objeto raiz del grafo, si lo hay.
+pub fn raiz() -> Option<Hash> {
+    ALMACEN.get().and_then(|mutex| mutex.lock().raiz)
+}
+
+/// Corona un objeto como raiz del grafo y ancla el cambio en el superbloque.
+pub fn fijar_raiz(hash: Hash) -> Result<(), &'static str> {
+    let mutex = ALMACEN.get().ok_or("almacen no inicializado")?;
+    let mut almacen = mutex.lock();
+    almacen.raiz = Some(hash);
+    persistir(&almacen)
+}

renaser/kernel/src/async_system/executor.rs

@@ -0,0 +1,103 @@
+// =============================================================================
+//  renaser :: async_system/executor.rs — Fase 3 :: el reactor cooperativo
+// -----------------------------------------------------------------------------
+//  El ejecutor es el corazon reactivo de renaser. Mantiene el censo de tareas
+//  vivas y una cola de las que estan listas para avanzar. Cuando no queda nada
+//  por hacer, no malgasta la CPU en un bucle ocupado: la duerme con `hlt`
+//  hasta que el proximo impulso de hardware la despierte.
+// =============================================================================
+
+use alloc::collections::{BTreeMap, VecDeque};
+use alloc::sync::Arc;
+use core::future::Future;
+use core::task::{Context, Poll, Waker};
+
+use spin::Mutex;
+use x86_64::instructions::interrupts;
+
+use super::task::{Task, TaskId};
+use super::waker::{self, ColaListas};
+
+/// El ejecutor cooperativo de renaser.
+pub struct Executor {
+    /// Censo de todas las tareas vivas, indexadas por su identidad.
+    tareas: BTreeMap<TaskId, Task>,
+    /// Cola de tareas listas para su proximo avance.
+    cola_listas: ColaListas,
+    /// Cache de wakers: uno por tarea, reutilizado entre avances.
+    cache_wakers: BTreeMap<TaskId, Waker>,
+}
+
+impl Executor {
+    /// Crea un ejecutor vacio. Requiere que el heap ya este fundado.
+    pub fn nuevo() -> Executor {
+        Executor {
+            tareas: BTreeMap::new(),
+            cola_listas: Arc::new(Mutex::new(VecDeque::new())),
+            cache_wakers: BTreeMap::new(),
+        }
+    }
+
+    /// Da de alta una tarea nueva y la marca como lista para su primer avance.
+    pub fn spawn(&mut self, futuro: impl Future<Output = ()> + Send + 'static) {
+        let tarea = Task::nueva(futuro);
+        let id = tarea.id;
+        if self.tareas.insert(id, tarea).is_some() {
+            panic!("renaser :: TaskId duplicado — lo imposible ha ocurrido");
+        }
+        interrupts::without_interrupts(|| self.cola_listas.lock().push_back(id));
+    }
+
+    /// Avanza, hasta agotarla, la cola de tareas listas.
+    fn avanzar_listas(&mut self) {
+        loop {
+            // Sacar el siguiente id con las interrupciones acalladas: la cola
+            // es compartida con los wakers que se disparan desde las IRQ.
+            let siguiente = interrupts::without_interrupts(|| self.cola_listas.lock().pop_front());
+            let id = match siguiente {
+                Some(id) => id,
+                None => return,
+            };
+            let tarea = match self.tareas.get_mut(&id) {
+                Some(t) => t,
+                None => continue, // la tarea concluyo en una vuelta previa
+            };
+            // Un waker por tarea, reutilizado: reinyecta esta tarea en la cola.
+            let cola = self.cola_listas.clone();
+            let despertador = self
+                .cache_wakers
+                .entry(id)
+                .or_insert_with(|| waker::crear(id, cola));
+            let mut contexto = Context::from_waker(despertador);
+            if let Poll::Ready(()) = tarea.poll(&mut contexto) {
+                // La tarea termino: se retira del censo y se libera su waker.
+                self.tareas.remove(&id);
+                self.cache_wakers.remove(&id);
+            }
+        }
+    }
+
+    /// Si no queda trabajo, duerme la CPU hasta la proxima interrupcion. El
+    /// chequeo y el `hlt` se hacen con las interrupciones acalladas para que
+    /// ningun despertar se pierda en la rendija entre uno y otro.
+    fn dormir_si_inactivo(&self) {
+        interrupts::disable();
+        let hay_trabajo = !self.cola_listas.lock().is_empty();
+        if hay_trabajo {
+            // Llego trabajo justo ahora: reactivar y seguir sin dormir.
+            interrupts::enable();
+        } else {
+            // `sti; hlt` atomico: habilita y duerme sin condicion de carrera.
+            interrupts::enable_and_hlt();
+        }
+    }
+
+    /// Cede el hilo principal al reactor. No retorna jamas: desde aqui, renaser
+    /// vive del latir de sus interrupciones.
+    pub fn run(&mut self) -> ! {
+        loop {
+            self.avanzar_listas();
+            self.dormir_si_inactivo();
+        }
+    }
+}

renaser/kernel/src/async_system/mod.rs

@@ -0,0 +1,16 @@
+// =============================================================================
+//  renaser :: kernel/src/async_system — el reactor cooperativo (Fase 3 / 5)
+// -----------------------------------------------------------------------------
+//  Aqui renaser rompe con el modelo de hilos pesados de Linux. No hay cambio
+//  de contexto en la CPU: las interrupciones de hardware no conmutan pilas,
+//  DESPIERTAN tareas. El kernel avanza cooperativamente, una tarea cede y la
+//  siguiente toma el relevo. Sobre estos cimientos corre, desde la Fase 5, el
+//  bytecode WASM aislado por software de la Fase 4: cada aplicacion es una
+//  tarea mas, y el `reloj` le marca el compas de sus fotogramas.
+// =============================================================================
+
+pub mod executor;
+pub mod reloj;
+pub mod task;
+pub mod teclado;
+pub mod waker;

renaser/kernel/src/async_system/reloj.rs

@@ -0,0 +1,101 @@
+// =============================================================================
+//  renaser :: async_system/reloj.rs — Fase 5 :: el compas de los fotogramas
+// -----------------------------------------------------------------------------
+//  El temporizador (PIT, IRQ0) ya no solo despierta al ejecutor de su `hlt`:
+//  ahora marca el COMPAS del userspace. Cada pulso a 100 Hz es un fotograma —
+//  una oportunidad de cesion cooperativa. `EsperaFrame` convierte ese pulso de
+//  hardware en un `Future`: una tarea WASM hace su trabajo de un fotograma y
+//  `.await`-ea el siguiente, cediendo la CPU a sus vecinas mientras tanto.
+// =============================================================================
+
+use alloc::vec::Vec;
+use core::future::Future;
+use core::pin::Pin;
+use core::sync::atomic::{AtomicU64, Ordering};
+use core::task::{Context, Poll, Waker};
+
+use spin::{Mutex, Once};
+use x86_64::instructions::interrupts;
+
+/// Pulsos del temporizador acumulados desde el arranque. Lo incrementa la IRQ0;
+/// lo consulta `EsperaFrame`. Atomico: la IRQ y el hilo principal lo comparten.
+static CONTADOR_PULSOS: AtomicU64 = AtomicU64::new(0);
+
+/// Censo de wakers en espera del proximo fotograma. Vive en el heap —de ahi el
+/// `Once`—; tras su `Mutex`, lo disputan el lado tarea y el manejador de IRQ0.
+static EN_ESPERA: Once<Mutex<Vec<Waker>>> = Once::new();
+
+/// Funda el censo de wakers del reloj. Requiere el heap ya activo; debe
+/// invocarse una sola vez, antes de habilitar las interrupciones.
+pub fn init() {
+    EN_ESPERA.call_once(|| Mutex::new(Vec::new()));
+}
+
+/// Punto de entrada DESDE el manejador de IRQ0. Avanza el contador de pulsos y
+/// despierta a cuantas tareas aguardaban el fotograma. Deliberadamente breve y
+/// libre de panicos: corre en contexto de interrupcion.
+pub fn pulso() {
+    // `Release`: el avance del contador se publica ANTES de que los wakers
+    // reinyecten sus tareas; el `poll` que sigue lo leera con `Acquire` y vera,
+    // garantizado, el valor nuevo.
+    CONTADOR_PULSOS.fetch_add(1, Ordering::Release);
+    if let Some(censo) = EN_ESPERA.get() {
+        // En contexto de IRQ las interrupciones ya estan acalladas; tomar aqui
+        // el cerrojo no puede interbloquear, pues el lado tarea siempre lo toma
+        // con las interrupciones desactivadas (ver `inscribir`).
+        for waker in censo.lock().drain(..) {
+            waker.wake();
+        }
+    }
+}
+
+/// Numero de pulsos del temporizador desde el arranque.
+fn pulsos() -> u64 {
+    CONTADOR_PULSOS.load(Ordering::Acquire)
+}
+
+/// Inscribe un waker en el censo de espera del proximo fotograma.
+fn inscribir(waker: Waker) {
+    if let Some(censo) = EN_ESPERA.get() {
+        // El cerrojo lo disputa el manejador de IRQ0: tomarlo con las
+        // interrupciones acalladas hace IMPOSIBLE el interbloqueo.
+        interrupts::without_interrupts(|| censo.lock().push(waker));
+    }
+}
+
+/// Un `Future` que se resuelve en el proximo pulso del temporizador. Es la
+/// unidad de cesion cooperativa del userspace: una tarea WASM hace su trabajo
+/// de un fotograma y `.await`-ea un `EsperaFrame` para ceder hasta el siguiente.
+pub struct EsperaFrame {
+    /// Pulso a partir del cual la espera se da por cumplida.
+    objetivo: u64,
+}
+
+impl EsperaFrame {
+    /// Crea una espera que se resolvera en el siguiente pulso del temporizador.
+    pub fn nueva() -> EsperaFrame {
+        EsperaFrame {
+            objetivo: pulsos() + 1,
+        }
+    }
+}
+
+impl Future for EsperaFrame {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, contexto: &mut Context<'_>) -> Poll<()> {
+        // Lectura optimista: si el fotograma ya llego, no hay nada que esperar.
+        if pulsos() >= self.objetivo {
+            return Poll::Ready(());
+        }
+        // Aun no: inscribir el waker y RE-VERIFICAR. Si un pulso se colo entre
+        // la lectura de arriba y la inscripcion, este segundo chequeo lo atrapa;
+        // sin el, el despertar se perderia hasta el pulso siguiente.
+        inscribir(contexto.waker().clone());
+        if pulsos() >= self.objetivo {
+            Poll::Ready(())
+        } else {
+            Poll::Pending
+        }
+    }
+}

renaser/kernel/src/async_system/task.rs

@@ -0,0 +1,45 @@
+// =============================================================================
+//  renaser :: async_system/task.rs — Fase 3 :: la unidad de trabajo asincrono
+// =============================================================================
+
+use alloc::boxed::Box;
+use core::future::Future;
+use core::pin::Pin;
+use core::sync::atomic::{AtomicU64, Ordering};
+use core::task::{Context, Poll};
+
+/// Identificador unico de una tarea. Autoincremental y atomico: dos tareas
+/// jamas comparten identidad.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct TaskId(u64);
+
+impl TaskId {
+    /// Acuña un identificador nuevo, distinto de todos los anteriores.
+    fn nuevo() -> TaskId {
+        static SIGUIENTE: AtomicU64 = AtomicU64::new(0);
+        TaskId(SIGUIENTE.fetch_add(1, Ordering::Relaxed))
+    }
+}
+
+/// Una tarea asincrona: un `Future` encapsulado, anclado (`Pin`) en el heap
+/// para que su direccion nunca cambie mientras avanza.
+pub struct Task {
+    /// La identidad de la tarea, su nombre ante el ejecutor.
+    pub id: TaskId,
+    futuro: Pin<Box<dyn Future<Output = ()> + Send + 'static>>,
+}
+
+impl Task {
+    /// Envuelve un `Future` en una tarea con identidad propia.
+    pub fn nueva(futuro: impl Future<Output = ()> + Send + 'static) -> Task {
+        Task {
+            id: TaskId::nuevo(),
+            futuro: Box::pin(futuro),
+        }
+    }
+
+    /// Hace avanzar la tarea un paso. `Poll::Ready` significa que concluyo.
+    pub fn poll(&mut self, contexto: &mut Context) -> Poll<()> {
+        self.futuro.as_mut().poll(contexto)
+    }
+}

renaser/kernel/src/async_system/teclado.rs

@@ -0,0 +1,76 @@
+// =============================================================================
+//  renaser :: async_system/teclado.rs — el canal de scancodes del teclado
+// -----------------------------------------------------------------------------
+//  El manejador de IRQ1 es un mero PRODUCTOR: deposita cada scancode en colas
+//  lock-free, seguras frente a interrupciones. Los consumidores —las apps WASM,
+//  via la capacidad `sys_get_scancode`— las drenan sin bloquear.
+//
+//  FASE 5 :: con varias apps concurrentes, una sola cola compartida no sirve:
+//  la primera en sondear le robaria la pulsacion a las demas. Por eso cada
+//  aplicacion abre su PROPIO canal y la IRQ1 DIFUNDE cada scancode a todos —
+//  cada app recibe su copia integra del flujo de entrada.
+// =============================================================================
+
+use alloc::sync::Arc;
+use alloc::vec::Vec;
+
+use crossbeam_queue::ArrayQueue;
+use spin::{Mutex, Once};
+use x86_64::instructions::interrupts;
+
+/// Capacidad de la cola de scancodes de cada app. Holgada: nadie teclea tanto.
+const CAPACIDAD_COLA: usize = 256;
+
+/// Un canal de teclado: la cola lock-free de scancodes de UNA aplicacion.
+pub type CanalTeclado = Arc<ArrayQueue<u8>>;
+
+/// Censo de canales — uno por aplicacion del userspace. El manejador de IRQ1
+/// difunde cada scancode a TODOS: asi cada app recibe su propia copia del
+/// evento, sin que una le arrebate la pulsacion a otra.
+static CANALES: Once<Mutex<Vec<CanalTeclado>>> = Once::new();
+
+/// Funda el censo de canales del teclado. Requiere el heap ya activo; debe
+/// invocarse una sola vez, antes de habilitar las interrupciones.
+pub fn init() {
+    CANALES.call_once(|| Mutex::new(Vec::new()));
+}
+
+/// Crea un canal de teclado nuevo, AUN sin inscribir en la difusion. Cada
+/// aplicacion reclama el suyo al empezar a cargarse.
+pub fn crear_canal() -> CanalTeclado {
+    Arc::new(ArrayQueue::new(CAPACIDAD_COLA))
+}
+
+/// Inscribe un canal en el censo de difusion. Desde este instante, la IRQ1
+/// empuja cada scancode tambien a este canal. Se invoca al final de la carga
+/// de una app: una carga fallida no debe dejar canales huerfanos.
+pub fn registrar_canal(canal: &CanalTeclado) {
+    if let Some(censo) = CANALES.get() {
+        // El cerrojo lo disputa el manejador de IRQ1: tomarlo con las
+        // interrupciones acalladas hace imposible el interbloqueo.
+        interrupts::without_interrupts(|| censo.lock().push(canal.clone()));
+    }
+}
+
+/// Da de baja un canal del censo de difusion. Lo invoca el `Drop` de una
+/// aplicacion desalojada: la IRQ1 deja, de inmediato, de empujarle scancodes.
+pub fn cerrar_canal(canal: &CanalTeclado) {
+    if let Some(censo) = CANALES.get() {
+        interrupts::without_interrupts(|| {
+            censo.lock().retain(|inscrito| !Arc::ptr_eq(inscrito, canal));
+        });
+    }
+}
+
+/// Punto de entrada DESDE el manejador de IRQ1. DIFUNDE el scancode a cuantos
+/// canales haya abiertos. Deliberadamente breve y libre de panicos: corre en
+/// contexto de interrupcion.
+pub fn recibir_scancode(scancode: u8) {
+    if let Some(censo) = CANALES.get() {
+        for canal in censo.lock().iter() {
+            // Si un canal desborda, se descarta el scancode en silencio: mas
+            // vale perder una tecla que colapsar dentro de una interrupcion.
+            let _ = canal.push(scancode);
+        }
+    }
+}

renaser/kernel/src/async_system/waker.rs

@@ -0,0 +1,55 @@
+// =============================================================================
+//  renaser :: async_system/waker.rs — Fase 3 :: el despertador de tareas
+// -----------------------------------------------------------------------------
+//  Un `Waker` es la promesa de que una tarea dormida volvera a ejecutarse. El
+//  nuestro es minimo: al invocarse, reinyecta el `TaskId` de su tarea en la
+//  cola de listas del ejecutor. Quien lo invoque —incluido un manejador de
+//  IRQ— vuelve a poner esa tarea en circulacion.
+// =============================================================================
+
+use alloc::collections::VecDeque;
+use alloc::sync::Arc;
+use alloc::task::Wake;
+use core::task::Waker;
+
+use spin::Mutex;
+
+use super::task::TaskId;
+
+/// La cola de tareas listas para avanzar, compartida entre el ejecutor y todos
+/// los wakers que ha repartido.
+pub type ColaListas = Arc<Mutex<VecDeque<TaskId>>>;
+
+/// El despertador de UNA tarea concreta.
+struct WakerTarea {
+    id: TaskId,
+    cola: ColaListas,
+}
+
+impl WakerTarea {
+    /// Reinyecta la tarea en la cola de ejecucion.
+    fn reinyectar(&self) {
+        // El spinlock de la cola lo tocan tanto el hilo principal como los
+        // manejadores de IRQ. Tomarlo con las interrupciones acalladas hace
+        // IMPOSIBLE el interbloqueo: ninguna IRQ puede interrumpir al hilo
+        // principal justo mientras este sostiene el cerrojo.
+        x86_64::instructions::interrupts::without_interrupts(|| {
+            self.cola.lock().push_back(self.id);
+        });
+    }
+}
+
+impl Wake for WakerTarea {
+    fn wake(self: Arc<Self>) {
+        self.reinyectar();
+    }
+
+    fn wake_by_ref(self: &Arc<Self>) {
+        self.reinyectar();
+    }
+}
+
+/// Crea un `Waker` estandar que, al invocarse, reinyecta `id` en `cola`.
+pub fn crear(id: TaskId, cola: ColaListas) -> Waker {
+    Waker::from(Arc::new(WakerTarea { id, cola }))
+}

renaser/kernel/src/baliza.rs

@@ -0,0 +1,128 @@
+// =============================================================================
+//  renaser :: kernel/src/baliza.rs — la red de seguridad visual del sistema
+// -----------------------------------------------------------------------------
+//  Sin consola de texto que valga cuando el sistema cae: si renaser colapsa, lo
+//  DIBUJA. La baliza publica —de forma atomica y sin cerrojos— los datos
+//  minimos del framebuffer, de modo que los manejadores de fallo puedan pintar
+//  una franja de advertencia incluso cuando el resto del kernel ya no es fiable.
+// =============================================================================
+
+use core::panic::PanicInfo;
+use core::ptr;
+use core::sync::atomic::{AtomicPtr, AtomicU32, AtomicUsize, Ordering};
+
+use crate::grafico::{escribir_pixel_volatil, Pantalla};
+
+/// Datos del framebuffer expuestos a los manejadores de fallo. Todo son
+/// atomicos: la baliza es intrinsecamente `Sync`, sin cerrojos.
+pub(crate) struct BalizaPanico {
+    base: AtomicPtr<u8>,
+    paso_bytes: AtomicUsize,
+    ancho: AtomicUsize,
+    alto: AtomicUsize,
+    bytes_por_pixel: AtomicUsize,
+    /// Rojo de alerta de colapso, ya codificado al formato de la pantalla.
+    pixel_alerta: AtomicU32,
+    /// Naranja de agotamiento de memoria, ya codificado.
+    pixel_oom: AtomicU32,
+}
+
+impl BalizaPanico {
+    /// Baliza apagada: sin pantalla publicada todavia.
+    const fn apagada() -> BalizaPanico {
+        BalizaPanico {
+            base: AtomicPtr::new(ptr::null_mut()),
+            paso_bytes: AtomicUsize::new(0),
+            ancho: AtomicUsize::new(0),
+            alto: AtomicUsize::new(0),
+            bytes_por_pixel: AtomicUsize::new(0),
+            pixel_alerta: AtomicU32::new(0),
+            pixel_oom: AtomicU32::new(0),
+        }
+    }
+
+    /// Enciende la baliza con los datos de una pantalla viva.
+    pub(crate) fn encender(&self, pantalla: &Pantalla, pixel_alerta: u32, pixel_oom: u32) {
+        self.paso_bytes.store(pantalla.paso_bytes, Ordering::Relaxed);
+        self.ancho.store(pantalla.ancho, Ordering::Relaxed);
+        self.alto.store(pantalla.alto, Ordering::Relaxed);
+        self.bytes_por_pixel
+            .store(pantalla.bytes_por_pixel, Ordering::Relaxed);
+        self.pixel_alerta.store(pixel_alerta, Ordering::Relaxed);
+        self.pixel_oom.store(pixel_oom, Ordering::Relaxed);
+        // La base se publica de ultima, con semantica `Release`.
+        self.base.store(pantalla.base, Ordering::Release);
+    }
+
+    /// Pinta, directa y volatilmente, una banda horizontal sobre el framebuffer
+    /// fisico. Es la herramienta de los manejadores de fallo: no confia ni en
+    /// el lienzo, ni en el heap, ni en estructura dinamica alguna.
+    fn pintar_banda(&self, y0: usize, altura: usize, pixel: u32) {
+        let base = self.base.load(Ordering::Acquire);
+        if base.is_null() {
+            return;
+        }
+        let ancho = self.ancho.load(Ordering::Relaxed);
+        let alto = self.alto.load(Ordering::Relaxed);
+        let paso = self.paso_bytes.load(Ordering::Relaxed);
+        let bpp = self.bytes_por_pixel.load(Ordering::Relaxed);
+
+        let y_fin = (y0 + altura).min(alto);
+        let mut y = y0.min(alto);
+        while y < y_fin {
+            let fila = y * paso;
+            let mut x = 0;
+            while x < ancho {
+                // SEGURIDAD: (x, y) esta acotado por las dimensiones que la
+                // baliza publico desde una pantalla real.
+                unsafe {
+                    escribir_pixel_volatil(base.add(fila + x * bpp), pixel, bpp);
+                }
+                x += 1;
+            }
+            y += 1;
+        }
+    }
+
+    /// Altura de la franja de advertencia: ~8 % de la pantalla.
+    fn franja(&self) -> usize {
+        let alto = self.alto.load(Ordering::Relaxed);
+        if alto == 0 {
+            0
+        } else {
+            (alto / 12).max(1)
+        }
+    }
+}
+
+/// Instancia global de la baliza. Comienza apagada y se enciende en el arranque.
+pub(crate) static BALIZA_PANICO: BalizaPanico = BalizaPanico::apagada();
+
+// =============================================================================
+//  MANEJADORES DE FALLO — cuando el sistema colapsa, lo DIBUJA
+// =============================================================================
+
+/// Si renaser colapsa, tatuamos una franja ROJA en lo alto del framebuffer.
+#[panic_handler]
+fn al_colapsar(_info: &PanicInfo) -> ! {
+    x86_64::instructions::interrupts::disable();
+    BALIZA_PANICO.pintar_banda(
+        0,
+        BALIZA_PANICO.franja(),
+        BALIZA_PANICO.pixel_alerta.load(Ordering::Relaxed),
+    );
+    crate::detener()
+}
+
+/// Si el heap se agota, tatuamos una franja NARANJA: un fallo distinto al
+/// colapso, y distinguible de un vistazo.
+#[alloc_error_handler]
+fn al_agotar_memoria(_disposicion: core::alloc::Layout) -> ! {
+    x86_64::instructions::interrupts::disable();
+    BALIZA_PANICO.pintar_banda(
+        0,
+        BALIZA_PANICO.franja(),
+        BALIZA_PANICO.pixel_oom.load(Ordering::Relaxed),
+    );
+    crate::detener()
+}

renaser/kernel/src/consola.rs

@@ -0,0 +1,186 @@
+// =============================================================================
+//  renaser :: kernel/src/consola.rs — la superficie de texto e imagen
+// -----------------------------------------------------------------------------
+//  La consola une el lienzo intermedio, la pantalla fisica y una pluma de
+//  escritura. Rasteriza cada glifo con `fontdue` al vuelo —el texto convertido,
+//  por fin, en dibujo— y tambien sabe volcar fotogramas crudos del userspace
+//  WASM. Es global y serializada tras un `Mutex`: las tareas escriben en ella.
+// =============================================================================
+
+use spin::{Mutex, Once};
+
+use crate::grafico::{codificar, Color, Lienzo, Pantalla, RegionPantalla};
+use crate::texto;
+
+/// Margen del texto respecto al borde del lienzo, en pixeles.
+const MARGEN: usize = 40;
+/// Tamaño de la tipografia, en pixeles.
+const TAM_FUENTE: f32 = 30.0;
+/// Altura de avance de una linea de texto, en pixeles.
+const ALTO_LINEA: usize = 40;
+/// Posicion vertical de la primera linea base.
+const BASE_INICIAL: usize = MARGEN + 30;
+
+/// Interpola dos colores segun una cobertura: `0` => `fondo`, `255` => `tinta`.
+fn mezclar(fondo: Color, tinta: Color, cobertura: u8) -> Color {
+    let canal = |a: u8, b: u8| -> u8 {
+        let c = cobertura as u16;
+        ((a as u16 * (255 - c) + b as u16 * c) / 255) as u8
+    };
+    Color {
+        r: canal(fondo.r, tinta.r),
+        g: canal(fondo.g, tinta.g),
+        b: canal(fondo.b, tinta.b),
+    }
+}
+
+/// La consola grafica de renaser: doble bufer, pantalla fisica y pluma.
+pub(crate) struct Consola {
+    lienzo: Lienzo,
+    pantalla: Pantalla,
+    /// Posicion horizontal de la pluma de escritura.
+    pluma_x: usize,
+    /// Linea base vertical de la pluma de escritura.
+    base_y: usize,
+}
+
+// SEGURIDAD: `Consola` encierra, via `Pantalla`, un puntero crudo al
+// framebuffer. Ese puntero es valido durante toda la vida del kernel y todo
+// acceso a la consola se serializa tras un `Mutex`. En un sistema de un solo
+// nucleo, esto la hace segura de compartir entre el hilo principal y las tareas.
+unsafe impl Send for Consola {}
+
+impl Consola {
+    /// Crea una consola con la pluma en la esquina superior izquierda.
+    pub(crate) fn nueva(lienzo: Lienzo, pantalla: Pantalla) -> Consola {
+        Consola {
+            lienzo,
+            pantalla,
+            pluma_x: MARGEN,
+            base_y: BASE_INICIAL,
+        }
+    }
+
+    /// Lleva la pluma al inicio de la siguiente linea. Al llegar al fondo,
+    /// limpia el lienzo: una pizarra nueva.
+    fn nueva_linea(&mut self) {
+        self.pluma_x = MARGEN;
+        self.base_y += ALTO_LINEA;
+        if self.base_y + ALTO_LINEA >= self.lienzo.alto {
+            self.lienzo.limpiar(Color::LIENZO_EN_REPOSO);
+            self.base_y = BASE_INICIAL;
+        }
+    }
+
+    /// Escribe un caracter: rasteriza su glifo y avanza la pluma.
+    fn escribir_char(&mut self, caracter: char) {
+        if caracter == '\n' {
+            self.nueva_linea();
+            return;
+        }
+        let (metricas, cobertura) = texto::rasterizar(caracter, TAM_FUENTE);
+        // Salto de linea automatico al alcanzar el margen derecho.
+        if self.pluma_x + metricas.advance_width as usize + MARGEN > self.lienzo.ancho {
+            self.nueva_linea();
+        }
+        self.dibujar_glifo(&metricas, &cobertura);
+        self.pluma_x += metricas.advance_width as usize;
+    }
+
+    /// Escribe una cadena completa, caracter a caracter.
+    pub(crate) fn escribir(&mut self, texto: &str) {
+        for caracter in texto.chars() {
+            self.escribir_char(caracter);
+        }
+    }
+
+    /// Funde un mapa de cobertura de `fontdue` sobre el lienzo, en la pluma.
+    fn dibujar_glifo(&mut self, metricas: &fontdue::Metrics, cobertura: &[u8]) {
+        // Origen del glifo: la pluma desplazada por las metricas. El mapa de
+        // `fontdue` se recorre de arriba a abajo desde la cima del glifo.
+        let inicio_x = self.pluma_x as isize + metricas.xmin as isize;
+        let inicio_y = self.base_y as isize - metricas.ymin as isize - metricas.height as isize;
+
+        for fila in 0..metricas.height {
+            for col in 0..metricas.width {
+                let opacidad = cobertura[fila * metricas.width + col];
+                if opacidad == 0 {
+                    continue; // pixel transparente: no toca el fondo
+                }
+                let x = inicio_x + col as isize;
+                let y = inicio_y + fila as isize;
+                if x < 0 || y < 0 {
+                    continue;
+                }
+                let color = mezclar(Color::LIENZO_EN_REPOSO, Color::TEXTO, opacidad);
+                self.lienzo.pintar_pixel(x as usize, y as usize, color);
+            }
+        }
+    }
+
+    /// Compone un fotograma crudo del userspace WASM —pixeles `0x00RRGGBB`, con
+    /// sus limites ya verificados por el host— sobre la SUB-REGION asignada a su
+    /// aplicacion. Cada pixel se recodifica al formato nativo del framebuffer y
+    /// se deposita desplazado por `(region.x, region.y)`: una app jamas escribe
+    /// fuera de su ventana, y varias cohabitan el lienzo sin pisarse.
+    fn volcar_marco(&mut self, region: RegionPantalla, datos: &[u8]) {
+        for (indice, trozo) in datos.chunks_exact(4).enumerate() {
+            let columna = indice % region.ancho;
+            let fila = indice / region.ancho;
+            if fila >= region.alto {
+                break; // el fotograma excede el alto de la region: se ignora el resto
+            }
+            let x = region.x + columna;
+            let y = region.y + fila;
+            if x >= self.lienzo.ancho || y >= self.lienzo.alto {
+                continue; // recorte firme: nada se pinta fuera del lienzo
+            }
+            let p = u32::from_le_bytes([trozo[0], trozo[1], trozo[2], trozo[3]]);
+            let color = Color {
+                r: (p >> 16) as u8,
+                g: (p >> 8) as u8,
+                b: p as u8,
+            };
+            self.lienzo.pixeles[y * self.lienzo.ancho + x] =
+                codificar(self.lienzo.formato, color);
+        }
+        self.presentar();
+    }
+
+    /// Inunda una region entera con un color plano y la presenta. Es la baliza
+    /// de desalojo: cuando una aplicacion falla, su ventana se tatua de purpura.
+    fn pintar_region(&mut self, region: RegionPantalla, color: Color) {
+        self.lienzo
+            .rellenar_rect(region.x, region.y, region.ancho, region.alto, color);
+        self.presentar();
+    }
+
+    /// Vuelca el lienzo sobre la pantalla fisica.
+    pub(crate) fn presentar(&mut self) {
+        self.pantalla.presentar(&self.lienzo);
+    }
+}
+
+/// La consola global de renaser. Se funde en el arranque; despues, las tareas
+/// asincronas y las capacidades del userspace escriben en ella tras su `Mutex`.
+pub(crate) static CONSOLA: Once<Mutex<Consola>> = Once::new();
+
+/// Puerta del kernel para la capacidad `sys_render_frame` del userspace WASM:
+/// compone sobre la consola global un fotograma —cuyos limites el host ya
+/// verifico matematicamente contra la memoria lineal del modulo— dentro de la
+/// region de pantalla que el kernel asigno a esa aplicacion.
+pub(crate) fn volcar_marco_wasm(region: RegionPantalla, datos: &[u8]) {
+    if let Some(consola) = CONSOLA.get() {
+        consola.lock().volcar_marco(region, datos);
+    }
+}
+
+/// Tatua la baliza de desalojo sobre la region de una aplicacion que el kernel
+/// ha dado por terminada. El color delata la causa —purpura para una falla de
+/// ejecucion o de combustible, amarillo palido para un desbordo de memoria—. Es
+/// una advertencia NO fatal: la app muere, el kernel y sus vecinas siguen vivos.
+pub(crate) fn pintar_desalojo(region: RegionPantalla, color: Color) {
+    if let Some(consola) = CONSOLA.get() {
+        consola.lock().pintar_region(region, color);
+    }
+}

renaser/kernel/src/drivers/disco.rs

@@ -0,0 +1,562 @@
+// =============================================================================
+//  renaser :: kernel/src/drivers/disco.rs — Fase 6.2 :: el disco asincrono
+// -----------------------------------------------------------------------------
+//  La Fase 6.1 hizo hablar al disco; pero lo hacia por SONDEO: el procesador se
+//  quedaba en un bucle de espera activa vigilando el «used ring» de virtio,
+//  incapaz de atender nada mas. La Fase 6.2 lo libera. La E/S de bloques pasa a
+//  ser REACTIVA, guiada por la interrupcion fisica del dispositivo:
+//
+//    * `EsperaDisco` — un `Future` nativo: enviada la peticion, cede la CPU; la
+//      IRQ del disco lo despertara cuando el bloque este listo.
+//    * `atender_irq` — el punto al que salta el manejador de la IRQ del disco:
+//      reconoce la interrupcion en el dispositivo y despierta a quien aguardaba.
+//    * `bloquear_en` — el puente para los contextos SINCRONOS (el arranque, las
+//      capacidades WASM): lleva un `Future` de disco hasta su final durmiendo la
+//      CPU con `hlt` —jamas en espera activa una vez el sistema esta en marcha—.
+//
+//  Subsisten de la Fase 6.1 el asignador de marcos por mapa de bits (con
+//  liberacion real) y `KernelHal`, el puente DMA hacia `virtio-drivers`.
+// =============================================================================
+
+use alloc::boxed::Box;
+use alloc::vec;
+use alloc::vec::Vec;
+use core::future::Future;
+use core::pin::Pin;
+use core::ptr::NonNull;
+use core::sync::atomic::{AtomicU64, AtomicU8, Ordering};
+use core::task::{Context, Poll, Waker};
+
+use spin::{Mutex, Once};
+use virtio_drivers::device::blk::{BlkReq, BlkResp, VirtIOBlk, SECTOR_SIZE};
+use virtio_drivers::transport::pci::bus::{Command, DeviceFunction, PciRoot};
+use virtio_drivers::transport::pci::PciTransport;
+use virtio_drivers::{BufferDirection, Hal, PhysAddr};
+use x86_64::instructions::interrupts;
+
+use super::pci::CamPuertos;
+
+/// Tamaño de una pagina / marco fisico, en bytes.
+const PAGINA: u64 = 4096;
+
+/// Techo de marcos que gestiona el asignador de DMA: 4096 marcos => una arena
+/// de 16 MiB. El DMA del disco —colas virtio y buferes rebote— necesita una
+/// fraccion minima de eso; el techo solo acota el tamaño del mapa de bits.
+const MAX_MARCOS: usize = 4096;
+
+/// Vendor ID de VirtIO; Device IDs de un disco de bloques (transicional/moderno).
+const VENDOR_VIRTIO: u16 = 0x1AF4;
+const VIRTIO_BLK_IDS: [u16; 2] = [0x1001, 0x1042];
+
+/// El tamaño de un sector, reexportado para el resto del kernel.
+pub const TAM_SECTOR: usize = SECTOR_SIZE;
+
+// =============================================================================
+//  EL OFFSET DE MEMORIA FISICA Y EL ASIGNADOR DE MARCOS
+// =============================================================================
+
+/// Desplazamiento al que el cargador mapeo toda la memoria fisica: una
+/// direccion fisica `p` es accesible por el kernel en la virtual `p + offset`.
+static OFFSET_FISICO: AtomicU64 = AtomicU64::new(0);
+
+/// Asignador de marcos por MAPA DE BITS: gestiona una arena de RAM fisica
+/// contigua y LIBERA. Cada bit representa un marco de 4 KiB; `1` es ocupado,
+/// `0` libre. Un almacen de objetos vivo asigna y devuelve marcos sin descanso.
+struct AsignadorMarcos {
+    /// Direccion fisica del primer marco gestionado, alineada a pagina.
+    base: u64,
+    /// Numero de marcos que abarca la arena.
+    total: usize,
+    /// Mapa de ocupacion: un bit por marco.
+    mapa: Vec<u64>,
+}
+
+impl AsignadorMarcos {
+    /// ¿Esta libre el marco `i`?
+    fn libre(&self, i: usize) -> bool {
+        (self.mapa[i / 64] >> (i % 64)) & 1 == 0
+    }
+
+    /// Marca el marco `i` como ocupado.
+    fn ocupar(&mut self, i: usize) {
+        self.mapa[i / 64] |= 1 << (i % 64);
+    }
+
+    /// Marca el marco `i` como libre.
+    fn soltar(&mut self, i: usize) {
+        self.mapa[i / 64] &= !(1u64 << (i % 64));
+    }
+
+    /// Reserva `paginas` marcos CONTIGUOS y devuelve la direccion fisica del
+    /// primero. `None` si no hay un hueco contiguo bastante grande.
+    fn asignar(&mut self, paginas: usize) -> Option<u64> {
+        if paginas == 0 || paginas > self.total {
+            return None;
+        }
+        let mut i = 0;
+        while i + paginas <= self.total {
+            // Buscar `paginas` marcos libres consecutivos a partir de `i`.
+            match (i..i + paginas).find(|&k| !self.libre(k)) {
+                // Un marco ocupado rompe la racha: reanudar tras el.
+                Some(ocupado) => i = ocupado + 1,
+                // Racha completa: ocuparla y entregar su direccion fisica.
+                None => {
+                    for k in i..i + paginas {
+                        self.ocupar(k);
+                    }
+                    return Some(self.base + (i as u64) * PAGINA);
+                }
+            }
+        }
+        None
+    }
+
+    /// Devuelve a la arena `paginas` marcos que arrancan en la direccion
+    /// fisica `fisica`. Direcciones ajenas a la arena se ignoran sin daño.
+    fn liberar(&mut self, fisica: u64, paginas: usize) {
+        if fisica < self.base {
+            return;
+        }
+        let inicio = ((fisica - self.base) / PAGINA) as usize;
+        for k in inicio..(inicio + paginas).min(self.total) {
+            self.soltar(k);
+        }
+    }
+}
+
+/// El asignador global de marcos para DMA. Se funde en `init`.
+static ASIGNADOR: Once<Mutex<AsignadorMarcos>> = Once::new();
+
+/// Funda el subsistema de disco: registra el offset de memoria fisica y forja
+/// el asignador de marcos sobre la region de RAM libre que el cargador reporto.
+/// Una sola vez, antes de montar el disco.
+pub fn init(offset_fisico: u64, region_inicio: u64, region_fin: u64) {
+    OFFSET_FISICO.store(offset_fisico, Ordering::Relaxed);
+    let base = alinear_arriba(region_inicio, PAGINA);
+    let disponibles = region_fin.saturating_sub(base) / PAGINA;
+    let total = (disponibles as usize).min(MAX_MARCOS);
+    ASIGNADOR.call_once(|| {
+        Mutex::new(AsignadorMarcos {
+            base,
+            total,
+            mapa: vec![0u64; total.div_ceil(64)],
+        })
+    });
+}
+
+/// Redondea `valor` hacia arriba al multiplo de `alineacion` (potencia de dos).
+fn alinear_arriba(valor: u64, alineacion: u64) -> u64 {
+    (valor + alineacion - 1) & !(alineacion - 1)
+}
+
+/// Reserva `paginas` marcos fisicos contiguos de 4 KiB y devuelve su direccion
+/// fisica. Agotar la arena es un fallo del kernel, no recuperable aqui: el
+/// rasgo `Hal` no admite que `dma_alloc` falle.
+fn asignar_marcos(paginas: usize) -> u64 {
+    ASIGNADOR
+        .get()
+        .expect("DMA :: el asignador de marcos no esta fundado")
+        .lock()
+        .asignar(paginas)
+        .expect("DMA :: la arena de marcos fisicos se agoto")
+}
+
+/// Devuelve `paginas` marcos fisicos a la arena. El reverso de `asignar_marcos`.
+fn liberar_marcos(fisica: u64, paginas: usize) {
+    if let Some(asignador) = ASIGNADOR.get() {
+        asignador.lock().liberar(fisica, paginas);
+    }
+}
+
+/// Traduce una direccion fisica a la virtual que el kernel puede desreferenciar.
+fn a_virtual(fisica: u64) -> *mut u8 {
+    (fisica + OFFSET_FISICO.load(Ordering::Relaxed)) as *mut u8
+}
+
+// =============================================================================
+//  KernelHal — EL PUENTE ENTRE `virtio-drivers` Y LA MEMORIA DE renaser
+// =============================================================================
+
+/// La implementacion del rasgo `Hal` de `virtio-drivers`. Sin estado propio:
+/// se apoya en el asignador de marcos y el offset fisico, ambos globales.
+pub struct KernelHal;
+
+// SEGURIDAD: cada metodo respeta su contrato — `dma_alloc` entrega marcos
+// fisicos exclusivos, contiguos, alineados a pagina y a cero; `dma_dealloc` y
+// `unshare` los devuelven a la arena; las traducciones de direccion son validas
+// porque el cargador mapeo toda la memoria fisica.
+unsafe impl Hal for KernelHal {
+    fn dma_alloc(paginas: usize, _direccion: BufferDirection) -> (PhysAddr, NonNull<u8>) {
+        let fisica = asignar_marcos(paginas);
+        let virtual_ = a_virtual(fisica);
+        // SEGURIDAD: `asignar_marcos` entrego `paginas` marcos exclusivos y
+        // contiguos; `virtual_` es su imagen valida y escribible en el mapeo
+        // de memoria fisica. El rasgo exige que las paginas vayan a cero.
+        unsafe {
+            core::ptr::write_bytes(virtual_, 0, paginas * PAGINA as usize);
+        }
+        (fisica, NonNull::new(virtual_).expect("DMA :: marco fisico nulo"))
+    }
+
+    unsafe fn dma_dealloc(fisica: PhysAddr, _virtual_: NonNull<u8>, paginas: usize) -> i32 {
+        // Con un asignador real, la liberacion ya NO es un gesto vacio: los
+        // marcos vuelven a la arena y quedan disponibles para el proximo DMA.
+        liberar_marcos(fisica, paginas);
+        0
+    }
+
+    unsafe fn mmio_phys_to_virt(fisica: PhysAddr, _tam: usize) -> NonNull<u8> {
+        // El cargador mapeo, como minimo, los primeros 4 GiB de memoria fisica;
+        // todo BAR MMIO de PCI cae dentro y es accesible en `fisica + offset`.
+        NonNull::new(a_virtual(fisica)).expect("MMIO :: direccion fisica nula")
+    }
+
+    unsafe fn share(bufer: NonNull<[u8]>, direccion: BufferDirection) -> PhysAddr {
+        let longitud = bufer.len();
+        let paginas = longitud.div_ceil(PAGINA as usize);
+        let fisica = asignar_marcos(paginas);
+        // Si el bufer viaja HACIA el dispositivo, copiarlo al area DMA rebote.
+        if !matches!(direccion, BufferDirection::DeviceToDriver) {
+            // SEGURIDAD: el rasgo garantiza que `bufer` apunta a `longitud`
+            // bytes validos; el area DMA recien reservada los abarca de sobra.
+            unsafe {
+                core::ptr::copy_nonoverlapping(
+                    bufer.as_ptr() as *const u8,
+                    a_virtual(fisica),
+                    longitud,
+                );
+            }
+        }
+        fisica
+    }
+
+    unsafe fn unshare(fisica: PhysAddr, bufer: NonNull<[u8]>, direccion: BufferDirection) {
+        let longitud = bufer.len();
+        // Si el bufer viene DESDE el dispositivo, copiar el area DMA de vuelta.
+        if !matches!(direccion, BufferDirection::DriverToDevice) {
+            // SEGURIDAD: `fisica` lo entrego `share` para este mismo `bufer`;
+            // ambas regiones abarcan los `longitud` bytes que se copian.
+            unsafe {
+                core::ptr::copy_nonoverlapping(
+                    a_virtual(fisica),
+                    bufer.as_ptr() as *mut u8,
+                    longitud,
+                );
+            }
+        }
+        // Devolver a la arena los marcos del area rebote.
+        liberar_marcos(fisica, longitud.div_ceil(PAGINA as usize));
+    }
+}
+
+// =============================================================================
+//  EL DISCO PERSISTENTE
+// =============================================================================
+
+/// El disco virtio-blk, ya montado. Envuelve al `VirtIOBlk` para poder ligarlo
+/// a un `static`.
+struct Disco(VirtIOBlk<KernelHal, PciTransport>);
+
+// SEGURIDAD: `Disco` encierra punteros crudos a las colas virtio y al MMIO del
+// dispositivo. renaser es un kernel de un solo nucleo y todo acceso al disco se
+// serializa tras el `Mutex` global `DISCO`; jamas se comparte entre hilos
+// reales. Todo acceso normal toma el cerrojo con las interrupciones acalladas,
+// de modo que la IRQ del disco jamas lo encuentra ocupado.
+unsafe impl Send for Disco {}
+
+/// El disco global de renaser. Se monta una sola vez, en `montar`.
+static DISCO: Once<Mutex<Disco>> = Once::new();
+
+/// La linea de IRQ del disco, descubierta al montarlo. Vale 0 si el firmware no
+/// enruto una linea util: en ese caso la E/S recae en el sondeo, con la red de
+/// seguridad del temporizador.
+static IRQ_DISCO: AtomicU8 = AtomicU8::new(0);
+
+/// Cuenta de interrupciones del disco atendidas desde el arranque. Es el
+/// testigo vivo de que la E/S asincrona late de verdad.
+static PULSOS_DISCO: AtomicU64 = AtomicU64::new(0);
+
+/// El waker de la (unica) espera de disco en curso. Las operaciones de disco se
+/// serializan, de modo que una sola ranura basta. La IRQ del disco lo invoca.
+static WAKER_DISCO: Mutex<Option<Waker>> = Mutex::new(None);
+
+/// Enumera el bus PCI, localiza el disco virtio-blk, lo monta y lo deja tras el
+/// `Mutex` global. Descubre ademas su linea de IRQ, registra el manejador y
+/// abre la linea en el PIC: desde aqui el disco puede interrumpir. Devuelve la
+/// capacidad del disco en sectores. Toda falla se devuelve como `Err`.
+pub fn montar() -> Result<u64, &'static str> {
+    let mut raiz = PciRoot::new(CamPuertos);
+
+    // 1. Localizar el primer disco virtio-blk recorriendo el bus.
+    let mut hallado: Option<DeviceFunction> = None;
+    'busqueda: for bus in 0..=255u8 {
+        for (device_function, info) in raiz.enumerate_bus(bus) {
+            if info.vendor_id == VENDOR_VIRTIO && VIRTIO_BLK_IDS.contains(&info.device_id) {
+                hallado = Some(device_function);
+                break 'busqueda;
+            }
+        }
+    }
+    let device_function = hallado.ok_or("virtio-blk no hallado en el bus PCI")?;
+
+    // 2. Habilitar E/S, espacio de memoria y BUS-MASTER. Sin bus-master el
+    //    dispositivo no puede iniciar transferencias DMA por su cuenta.
+    raiz.set_command(
+        device_function,
+        Command::IO_SPACE | Command::MEMORY_SPACE | Command::BUS_MASTER,
+    );
+
+    // 3. Montar el transporte PCI moderno de virtio y el dispositivo de bloques.
+    let transporte = PciTransport::new::<KernelHal, _>(&mut raiz, device_function)
+        .map_err(|_| "no se pudo montar el transporte PCI de virtio")?;
+    let mut disco = VirtIOBlk::<KernelHal, _>::new(transporte)
+        .map_err(|_| "no se pudo inicializar el dispositivo virtio-blk")?;
+    let capacidad = disco.capacity();
+
+    // 4. Pedir al dispositivo que EMITA una interrupcion al completar cada
+    //    peticion — el corazon de la E/S asincrona de esta fase.
+    disco.enable_interrupts();
+    DISCO.call_once(|| Mutex::new(Disco(disco)));
+
+    // 5. Descubrir la linea de IRQ que el firmware asigno al dispositivo y
+    //    enrutarla: registrar el manejador en la IDT y abrir la linea en el
+    //    PIC. Las IRQ 0 y 1 son del temporizador y el teclado; un valor fuera
+    //    de 2..15 (p. ej. 0xFF, «sin conexion») significa que no hay linea
+    //    util — la E/S seguira funcionando, pero por sondeo.
+    let irq = super::pci::linea_irq(device_function);
+    if (2..=15).contains(&irq) {
+        crate::interrupts::registrar_irq_disco(irq);
+        crate::pic::desenmascarar(irq);
+        IRQ_DISCO.store(irq, Ordering::SeqCst);
+    }
+
+    Ok(capacidad)
+}
+
+/// La linea de IRQ del disco, si el firmware enruto una util.
+pub fn irq() -> Option<u8> {
+    match IRQ_DISCO.load(Ordering::SeqCst) {
+        0 => None,
+        n => Some(n),
+    }
+}
+
+/// Numero de interrupciones del disco atendidas desde el arranque.
+pub fn pulsos_disco() -> u64 {
+    PULSOS_DISCO.load(Ordering::Relaxed)
+}
+
+/// Punto de entrada DESDE el manejador de la IRQ del disco. Reconoce la
+/// interrupcion en el dispositivo —leer su registro ISR baja la linea INTx— y
+/// despierta a la tarea que aguardaba el bloque. Breve y libre de panicos:
+/// corre en contexto de interrupcion.
+pub fn atender_irq() {
+    // Estamos en contexto de interrupcion (IF=0). Todo acceso normal a `DISCO`
+    // toma su cerrojo con las interrupciones acalladas, de modo que aqui jamas
+    // esta ocupado: tomarlo no puede interbloquear.
+    if let Some(disco) = DISCO.get() {
+        let _ = disco.lock().0.ack_interrupt();
+    }
+    PULSOS_DISCO.fetch_add(1, Ordering::Relaxed);
+    if let Some(waker) = WAKER_DISCO.lock().take() {
+        waker.wake();
+    }
+}
+
+/// Inscribe el waker de la espera de disco en curso. Una sola ranura: las
+/// operaciones de disco estan serializadas. El cerrojo lo disputa el manejador
+/// de IRQ — tomarlo con las interrupciones acalladas hace imposible el bloqueo.
+fn registrar_waker(waker: Waker) {
+    interrupts::without_interrupts(|| *WAKER_DISCO.lock() = Some(waker));
+}
+
+// =============================================================================
+//  EsperaDisco — UNA OPERACION DE BLOQUE COMO `Future`
+// =============================================================================
+
+/// Una transferencia de bloques en vuelo, expresada como `Future`. Posee sus
+/// propios buferes DMA —el encabezado de peticion, la respuesta y los datos—,
+/// que `virtio-drivers` mantiene prestados hasta que la operacion concluye.
+///
+/// Su `poll` envia la peticion la primera vez y, despues, comprueba el «used
+/// ring»: si el dispositivo aun no ha terminado, inscribe el waker y cede; la
+/// IRQ del disco lo reanudara. Una operacion a la vez — basta para renaser.
+pub struct EsperaDisco {
+    /// Encabezado de la peticion virtio. En el heap: direccion estable mientras
+    /// el dispositivo lo tiene prestado, sin importar si el `Future` se mueve.
+    req: Box<BlkReq>,
+    /// Respuesta de estado del dispositivo. En el heap, por la misma razon.
+    resp: Box<BlkResp>,
+    /// Los datos: destino de una lectura, origen de una escritura.
+    buf: Vec<u8>,
+    /// Primer sector de la transferencia.
+    sector: u64,
+    /// `true` si la operacion escribe; `false` si lee.
+    es_escritura: bool,
+    /// Token que `virtio-drivers` devolvio al enviar la peticion. `None` hasta
+    /// que el primer `poll` la envia.
+    token: Option<u16>,
+}
+
+impl EsperaDisco {
+    /// Hace avanzar la operacion: la envia si aun no lo estaba y comprueba si el
+    /// dispositivo la completo. `None` => sigue en vuelo; `Some` => terminada.
+    fn avanzar(&mut self) -> Option<Result<Vec<u8>, &'static str>> {
+        // Todo el dialogo con el dispositivo, con las interrupciones acalladas:
+        // asi la IRQ del disco jamas encuentra ocupado el cerrojo de `DISCO`.
+        interrupts::without_interrupts(|| {
+            let disco = match DISCO.get() {
+                Some(disco) => disco,
+                None => return Some(Err("disco no montado")),
+            };
+            let mut guardia = disco.lock();
+            let blk = &mut guardia.0;
+
+            // 1. Enviar la peticion la primera vez que se sondea esta espera.
+            if self.token.is_none() {
+                // SEGURIDAD: `req`, `buf` y `resp` viven en esta `EsperaDisco`,
+                // que no se libera ni se accede por otra via hasta que el
+                // `complete_*` de mas abajo cierre la operacion.
+                let envio = unsafe {
+                    if self.es_escritura {
+                        blk.write_blocks_nb(
+                            self.sector as usize,
+                            &mut self.req,
+                            self.buf.as_slice(),
+                            &mut self.resp,
+                        )
+                    } else {
+                        blk.read_blocks_nb(
+                            self.sector as usize,
+                            &mut self.req,
+                            self.buf.as_mut_slice(),
+                            &mut self.resp,
+                        )
+                    }
+                };
+                match envio {
+                    Ok(token) => self.token = Some(token),
+                    Err(_) => return Some(Err("no se pudo enviar la peticion al disco")),
+                }
+            }
+            let token = self.token.unwrap();
+
+            // 2. ¿Ha colocado el dispositivo este token en el «used ring»?
+            if blk.peek_used() != Some(token) {
+                return None; // aun en vuelo
+            }
+
+            // 3. Completado: recoger el resultado y desligar los buferes DMA.
+            // SEGURIDAD: se pasan los MISMOS buferes que recibio el `*_nb`.
+            let fin = unsafe {
+                if self.es_escritura {
+                    blk.complete_write_blocks(token, &self.req, self.buf.as_slice(), &mut self.resp)
+                } else {
+                    blk.complete_read_blocks(
+                        token,
+                        &self.req,
+                        self.buf.as_mut_slice(),
+                        &mut self.resp,
+                    )
+                }
+            };
+            Some(match fin {
+                Ok(()) => Ok(core::mem::take(&mut self.buf)),
+                Err(_) => Err("la operacion de disco no se completo"),
+            })
+        })
+    }
+}
+
+impl Future for EsperaDisco {
+    /// Al terminar, una lectura entrega sus datos; una escritura, un vector
+    /// vacio. El error es siempre un mensaje estable.
+    type Output = Result<Vec<u8>, &'static str>;
+
+    fn poll(self: Pin<&mut Self>, contexto: &mut Context<'_>) -> Poll<Self::Output> {
+        // `EsperaDisco` es `Unpin` —solo `Box`, `Vec` y escalares—: el `Pin`
+        // no impone nada y el acceso mutable es directo.
+        let this = self.get_mut();
+        // Inscribir el waker ANTES de comprobar: si la IRQ se cuela entre la
+        // comprobacion y la inscripcion, el waker ya esta puesto y el despertar
+        // no se pierde — el mismo blindaje que usa `EsperaFrame` (ver `reloj`).
+        registrar_waker(contexto.waker().clone());
+        match this.avanzar() {
+            Some(resultado) => Poll::Ready(resultado),
+            None => Poll::Pending,
+        }
+    }
+}
+
+/// Prepara la LECTURA asincrona de `n_sectores` sectores desde `sector`. El
+/// `Future` que devuelve no toca el disco hasta que se le sondea.
+pub fn leer_bloques(sector: u64, n_sectores: usize) -> EsperaDisco {
+    EsperaDisco {
+        req: Box::new(BlkReq::default()),
+        resp: Box::new(BlkResp::default()),
+        buf: vec![0u8; n_sectores * TAM_SECTOR],
+        sector,
+        es_escritura: false,
+        token: None,
+    }
+}
+
+/// Prepara la ESCRITURA asincrona de `datos` a partir de `sector`. La longitud
+/// de `datos` debe ser multiplo de un sector.
+pub fn escribir_bloques(sector: u64, datos: Vec<u8>) -> EsperaDisco {
+    EsperaDisco {
+        req: Box::new(BlkReq::default()),
+        resp: Box::new(BlkResp::default()),
+        buf: datos,
+        sector,
+        es_escritura: true,
+        token: None,
+    }
+}
+
+// =============================================================================
+//  bloquear_en — EL PUENTE PARA LOS CONTEXTOS SINCRONOS
+// =============================================================================
+
+/// Lleva un `Future` de disco hasta su final desde un contexto SINCRONO — el
+/// arranque, o una capacidad WASM, que no pueden `.await`-ear—. Mientras el
+/// disco trabaja:
+///
+///   * si las interrupciones estan activas, duerme la CPU con `hlt`; la
+///     despertara la IRQ del disco —o el temporizador, como red de seguridad—;
+///   * si no —en el arranque, antes de habilitarlas—, sondea en bucle.
+///
+/// Asi, una vez el sistema esta en marcha, la espera de disco JAMAS malgasta
+/// ciclos en espera activa.
+fn bloquear_en<F: Future>(futuro: F) -> F::Output {
+    let mut futuro = core::pin::pin!(futuro);
+    let waker = Waker::noop();
+    let mut contexto = Context::from_waker(waker);
+    loop {
+        match futuro.as_mut().poll(&mut contexto) {
+            Poll::Ready(salida) => return salida,
+            Poll::Pending => {
+                if interrupts::are_enabled() {
+                    x86_64::instructions::hlt();
+                } else {
+                    core::hint::spin_loop();
+                }
+            }
+        }
+    }
+}
+
+/// Lee `buf.len() / 512` sectores consecutivos a partir de `sector`. Sincrono:
+/// construido sobre la maquinaria asincrona via `bloquear_en`. El bufer debe
+/// medir un multiplo entero de un sector.
+pub fn leer_sectores(sector: u64, buf: &mut [u8]) -> Result<(), &'static str> {
+    let datos = bloquear_en(leer_bloques(sector, buf.len() / TAM_SECTOR))?;
+    buf.copy_from_slice(&datos);
+    Ok(())
+}
+
+/// Escribe `buf.len() / 512` sectores consecutivos a partir de `sector`.
+/// Sincrono, sobre la misma maquinaria asincrona.
+pub fn escribir_sectores(sector: u64, buf: &[u8]) -> Result<(), &'static str> {
+    bloquear_en(escribir_bloques(sector, buf.to_vec())).map(|_| ())
+}

renaser/kernel/src/drivers/mod.rs

@@ -0,0 +1,15 @@
+// =============================================================================
+//  renaser :: kernel/src/drivers — Fase 6.1 :: el puente hacia el hardware real
+// -----------------------------------------------------------------------------
+//  Hasta aqui renaser solo tocaba el silicio que el firmware le servia en
+//  bandeja: el framebuffer GOP, el temporizador, el teclado. Los `drivers`
+//  abren la primera via hacia hardware que el kernel debe DESCUBRIR y reclamar
+//  por si mismo:
+//
+//    * `pci`   — acceso al espacio de configuracion del bus PCI (0xCF8/0xCFC).
+//    * `disco` — el disco virtio-blk: asignador de marcos DMA, `Hal` y la
+//                lectura, por sondeo, de su primer sector.
+// =============================================================================
+
+pub mod disco;
+pub mod pci;

renaser/kernel/src/drivers/pci.rs

@@ -0,0 +1,76 @@
+// =============================================================================
+//  renaser :: kernel/src/drivers/pci.rs — Fase 6.1 :: el acceso al bus PCI
+// -----------------------------------------------------------------------------
+//  El cargador `bootloader` entrega el mapa de memoria y el framebuffer, pero
+//  NO un censo de perifericos: descubrir el disco es tarea del kernel. Aqui
+//  renaser habla con el espacio de configuracion del bus PCI a traves del
+//  mecanismo #1 —los puertos 0xCF8 (direccion) y 0xCFC (datos)—.
+//
+//  Este modulo provee `CamPuertos`, una implementacion del rasgo
+//  `ConfigurationAccess` de `virtio-drivers`: la crate enumera el bus y mapea
+//  los BARs del dispositivo apoyandose en estas dos funciones de acceso.
+// =============================================================================
+
+use virtio_drivers::transport::pci::bus::{ConfigurationAccess, DeviceFunction};
+use x86_64::instructions::port::Port;
+
+/// Puerto de DIRECCION del mecanismo de configuracion PCI #1.
+const CONFIG_ADDRESS: u16 = 0xCF8;
+/// Puerto de DATOS del mecanismo de configuracion PCI #1.
+const CONFIG_DATA: u16 = 0xCFC;
+
+/// Compone la palabra de direccion del mecanismo #1: bit 31 de habilitacion,
+/// bus, dispositivo, funcion y offset de registro alineado a dword.
+fn direccion(device_function: DeviceFunction, offset: u8) -> u32 {
+    0x8000_0000
+        | ((device_function.bus as u32) << 16)
+        | ((device_function.device as u32) << 11)
+        | ((device_function.function as u32) << 8)
+        | ((offset as u32) & 0xFC)
+}
+
+/// Lee un registro de 32 bits del espacio de configuracion PCI.
+fn leer(device_function: DeviceFunction, offset: u8) -> u32 {
+    // SEGURIDAD: 0xCF8/0xCFC son los puertos del mecanismo de configuracion
+    // PCI #1, fijos en la arquitectura PC. La direccion lleva su bit de
+    // habilitacion y el offset alineado a dword, como exige el protocolo.
+    unsafe {
+        Port::<u32>::new(CONFIG_ADDRESS).write(direccion(device_function, offset));
+        Port::<u32>::new(CONFIG_DATA).read()
+    }
+}
+
+/// Escribe un registro de 32 bits en el espacio de configuracion PCI.
+fn escribir(device_function: DeviceFunction, offset: u8, dato: u32) {
+    // SEGURIDAD: vease `leer` — mismos puertos, mismo protocolo del 8259/PCI.
+    unsafe {
+        Port::<u32>::new(CONFIG_ADDRESS).write(direccion(device_function, offset));
+        Port::<u32>::new(CONFIG_DATA).write(dato);
+    }
+}
+
+/// Lee el registro «Interrupt Line» (byte bajo del offset 0x3C): la linea de
+/// IRQ del PIC que el firmware UEFI enruto y asigno a este dispositivo. Es el
+/// puente entre el descubrimiento PCI y el manejo de interrupciones (Fase 6.2).
+pub fn linea_irq(device_function: DeviceFunction) -> u8 {
+    (leer(device_function, 0x3C) & 0xFF) as u8
+}
+
+/// Acceso al espacio de configuracion PCI por puertos de E/S — el mecanismo #1.
+/// Es un tipo sin estado: toda la informacion viaja en cada llamada.
+pub struct CamPuertos;
+
+impl ConfigurationAccess for CamPuertos {
+    fn read_word(&self, device_function: DeviceFunction, register_offset: u8) -> u32 {
+        leer(device_function, register_offset)
+    }
+
+    fn write_word(&mut self, device_function: DeviceFunction, register_offset: u8, data: u32) {
+        escribir(device_function, register_offset, data);
+    }
+
+    unsafe fn unsafe_clone(&self) -> Self {
+        // `CamPuertos` no tiene estado: clonarlo es trivial y sin riesgo.
+        CamPuertos
+    }
+}

renaser/kernel/src/gdt.rs

@@ -0,0 +1,80 @@
+// =============================================================================
+//  renaser :: kernel/src/gdt.rs — Fase 2 :: cimientos del manejo de fallos
+// -----------------------------------------------------------------------------
+//  La GDT y el TSS no se ven jamas, pero sostienen todo lo demas. Su cometido
+//  esencial en renaser es reservar un stack de emergencia inquebrantable: si la
+//  pila del kernel se desborda, el manejador de doble fallo aterrizara sobre
+//  terreno firme en lugar de arrastrar al sistema hacia un fallo triple.
+//
+//  Una sola verdad, instalada una sola vez, que PERSISTE bajo cada interrupcion.
+// =============================================================================
+
+use x86_64::instructions::segmentation::{Segment, CS, DS, ES, SS};
+use x86_64::instructions::tables::load_tss;
+use x86_64::structures::gdt::{Descriptor, GlobalDescriptorTable, SegmentSelector};
+use x86_64::structures::tss::TaskStateSegment;
+use x86_64::VirtAddr;
+
+use crate::CeldaSync;
+
+/// Indice, dentro de la Interrupt Stack Table del TSS, del stack reservado
+/// para el manejador de doble fallo.
+pub const IST_DOBLE_FALLO: u16 = 0;
+
+/// Tamaño del stack de emergencia: 20 KiB. Holgura suficiente para diagnosticar
+/// el fallo y encender la baliza sin volver a tocar la pila comprometida.
+const TAM_STACK_EMERGENCIA: usize = 4096 * 5;
+
+/// Stack de emergencia del doble fallo. Vive en `.bss`; la IST apuntara a su
+/// extremo superior, pues la pila de x86_64 crece hacia direcciones menores.
+static STACK_EMERGENCIA: CeldaSync<[u8; TAM_STACK_EMERGENCIA]> =
+    CeldaSync::nueva([0; TAM_STACK_EMERGENCIA]);
+
+/// El Task State Segment. En 64 bits ya no describe «tareas»: lo conservamos
+/// unicamente por su Interrupt Stack Table.
+static TSS: CeldaSync<TaskStateSegment> = CeldaSync::nueva(TaskStateSegment::new());
+
+/// La Global Descriptor Table propia de renaser.
+static GDT: CeldaSync<GlobalDescriptorTable> = CeldaSync::nueva(GlobalDescriptorTable::new());
+
+/// Instala una GDT propia con su TSS y arma el stack de emergencia.
+///
+/// Debe invocarse una sola vez, durante el arranque, ANTES de cargar la IDT:
+/// la IDT inscribe en cada entrada el selector de codigo vigente en ese momento.
+pub fn init() {
+    // --- 1. Inscribir en el TSS la cima del stack de emergencia. ---
+    // La pila crece hacia abajo: la IST exige la direccion MAS ALTA del bloque.
+    let cima_stack = VirtAddr::from_ptr(STACK_EMERGENCIA.puntero()) + TAM_STACK_EMERGENCIA as u64;
+    // SEGURIDAD: `init` corre una sola vez, en arranque secuencial de un solo
+    // hilo; nada mas referencia el TSS todavia.
+    unsafe {
+        (*TSS.puntero()).interrupt_stack_table[IST_DOBLE_FALLO as usize] = cima_stack;
+    }
+
+    // --- 2. Construir la GDT: codigo de kernel, datos de kernel y el TSS. ---
+    // SEGURIDAD: mismo argumento de unicidad; la GDT aun no esta cargada y
+    // ningun otro flujo posee referencias a estas celdas.
+    let gdt: &'static mut GlobalDescriptorTable = unsafe { &mut *GDT.puntero() };
+    let tss: &'static TaskStateSegment = unsafe { &*TSS.puntero() };
+
+    let sel_codigo: SegmentSelector = gdt.append(Descriptor::kernel_code_segment());
+    let sel_datos: SegmentSelector = gdt.append(Descriptor::kernel_data_segment());
+    let sel_tss: SegmentSelector = gdt.append(Descriptor::tss_segment(tss));
+
+    // --- 3. Activar la GDT y recargar TODOS los registros de segmento. ---
+    let gdt_estatica: &'static GlobalDescriptorTable = gdt;
+    gdt_estatica.load();
+    // SEGURIDAD: los tres selectores apuntan a entradas validas de la GDT
+    // recien cargada. Recargar SS/DS/ES es IMPRESCINDIBLE, no opcional: el
+    // cargador nos deja esos registros con selectores de SU tabla; si SS
+    // conservara el valor heredado, el primer `iretq` de una rutina de
+    // excepcion intentaria recargar un selector que en nuestra GDT ya no
+    // describe un segmento de datos, y degeneraria en un #GP.
+    unsafe {
+        CS::set_reg(sel_codigo);
+        SS::set_reg(sel_datos);
+        DS::set_reg(sel_datos);
+        ES::set_reg(sel_datos);
+        load_tss(sel_tss);
+    }
+}

renaser/kernel/src/grafico.rs

@@ -0,0 +1,325 @@
+// =============================================================================
+//  renaser :: kernel/src/grafico.rs — el sustrato grafico del sistema
+// -----------------------------------------------------------------------------
+//  En renaser el texto es un caso particular del dibujo, y el dibujo descansa
+//  sobre este modulo: el color, el framebuffer fisico (`Pantalla`) y el lienzo
+//  intermedio en RAM (`Lienzo`) que sostiene la tecnica de doble bufer.
+// =============================================================================
+
+use core::cell::UnsafeCell;
+use core::ptr;
+use core::sync::atomic::{AtomicBool, Ordering};
+
+use bootloader_api::info::{FrameBuffer, FrameBufferInfo, PixelFormat};
+use embedded_graphics::draw_target::DrawTarget;
+use embedded_graphics::geometry::{OriginDimensions, Size};
+use embedded_graphics::pixelcolor::{Rgb888, RgbColor};
+use embedded_graphics::Pixel;
+
+/// Ancho maximo de lienzo soportado (Full HD).
+pub(crate) const ANCHO_MAX: usize = 1920;
+/// Alto maximo de lienzo soportado (Full HD).
+pub(crate) const ALTO_MAX: usize = 1080;
+/// Capacidad del lienzo intermedio, en pixeles de 32 bits.
+const PIXELES_MAX: usize = ANCHO_MAX * ALTO_MAX;
+
+// =============================================================================
+//  COLOR — la unidad indivisible del lenguaje visual de renaser
+// =============================================================================
+
+/// Color de 24 bits, independiente del formato fisico del framebuffer.
+#[derive(Clone, Copy)]
+pub(crate) struct Color {
+    pub(crate) r: u8,
+    pub(crate) g: u8,
+    pub(crate) b: u8,
+}
+
+impl Color {
+    /// Reposo del lienzo: un indigo casi negro, sereno y persistente.
+    pub(crate) const LIENZO_EN_REPOSO: Color = Color {
+        r: 0x12,
+        g: 0x16,
+        b: 0x20,
+    };
+
+    /// Alerta de colapso: un rojo saturado, imposible de ignorar.
+    pub(crate) const ALERTA: Color = Color {
+        r: 0xD4,
+        g: 0x1E,
+        b: 0x2C,
+    };
+
+    /// Agotamiento de memoria (OOM): un naranja de advertencia.
+    pub(crate) const OOM: Color = Color {
+        r: 0xFF,
+        g: 0xA5,
+        b: 0x00,
+    };
+
+    /// Tinta del texto: un blanco suave, legible sobre el indigo.
+    pub(crate) const TEXTO: Color = Color {
+        r: 0xE8,
+        g: 0xEC,
+        b: 0xF4,
+    };
+
+    /// Desalojo de una aplicacion: un purpura inequivoco. Distinto del rojo de
+    /// colapso del kernel y del naranja de OOM — porque esto NO es un colapso:
+    /// es el kernel conteniendo a un inquilino discolo y siguiendo vivo.
+    pub(crate) const DESALOJO: Color = Color {
+        r: 0x8B,
+        g: 0x5C,
+        b: 0xF6,
+    };
+
+    /// Desalojo por desbordo de memoria: un amarillo palido. Distingue al
+    /// inquilino que revento su techo ESPACIAL del que agoto su tiempo (purpura).
+    pub(crate) const DESALOJO_MEMORIA: Color = Color {
+        r: 0xFF,
+        g: 0xFF,
+        b: 0xE0,
+    };
+}
+
+// =============================================================================
+//  REGION — la sub-superficie que el kernel asigna a cada aplicacion
+// =============================================================================
+
+/// Una sub-region rectangular de la pantalla, en pixeles. El kernel asigna una
+/// a cada aplicacion del userspace: es, a la vez, su ventana al mundo y su
+/// confinamiento — una app jamas pinta un pixel fuera de la suya.
+#[derive(Clone, Copy)]
+pub(crate) struct RegionPantalla {
+    /// Desplazamiento horizontal de la esquina superior izquierda.
+    pub(crate) x: usize,
+    /// Desplazamiento vertical de la esquina superior izquierda.
+    pub(crate) y: usize,
+    /// Ancho de la region, en pixeles.
+    pub(crate) ancho: usize,
+    /// Alto de la region, en pixeles.
+    pub(crate) alto: usize,
+}
+
+impl RegionPantalla {
+    /// Numero total de pixeles que abarca la region.
+    pub(crate) const fn pixeles(&self) -> usize {
+        self.ancho * self.alto
+    }
+}
+
+/// Traduce un [`Color`] logico al valor nativo de 32 bits que el framebuffer
+/// espera, respetando el orden de canales que reporta el firmware UEFI.
+pub(crate) fn codificar(formato: PixelFormat, color: Color) -> u32 {
+    let (r, g, b) = (color.r as u32, color.g as u32, color.b as u32);
+    match formato {
+        PixelFormat::Rgb => r | (g << 8) | (b << 16),
+        PixelFormat::Bgr => b | (g << 8) | (r << 16),
+        PixelFormat::U8 => (r * 54 + g * 183 + b * 19) >> 8,
+        PixelFormat::Unknown {
+            red_position,
+            green_position,
+            blue_position,
+        } => (r << red_position) | (g << green_position) | (b << blue_position),
+        _ => r | (g << 8) | (b << 16),
+    }
+}
+
+// =============================================================================
+//  ESCRITURA VOLATIL — la unica celula que toca memoria de video real
+// =============================================================================
+
+/// Deposita un pixel ya codificado en una direccion del framebuffer fisico.
+/// Las escrituras son **volatiles**: el optimizador no puede elidirlas.
+///
+/// # Seguridad
+///
+/// `destino` debe apuntar a memoria de video valida y escribible para
+/// `bytes_por_pixel` bytes, correctamente alineada para el ancho de escritura.
+#[inline]
+pub(crate) unsafe fn escribir_pixel_volatil(destino: *mut u8, valor: u32, bytes_por_pixel: usize) {
+    match bytes_por_pixel {
+        4 => unsafe { ptr::write_volatile(destino.cast::<u32>(), valor) },
+        3 => unsafe {
+            ptr::write_volatile(destino, valor as u8);
+            ptr::write_volatile(destino.add(1), (valor >> 8) as u8);
+            ptr::write_volatile(destino.add(2), (valor >> 16) as u8);
+        },
+        2 => unsafe { ptr::write_volatile(destino.cast::<u16>(), valor as u16) },
+        _ => unsafe { ptr::write_volatile(destino, valor as u8) },
+    }
+}
+
+// =============================================================================
+//  LIENZO INTERMEDIO — el corazon del doble bufer
+// =============================================================================
+
+/// Respaldo estatico del lienzo, alineado a pagina. Vive en `.bss`.
+#[repr(align(4096))]
+struct LienzoEstatico(UnsafeCell<[u32; PIXELES_MAX]>);
+
+// SEGURIDAD: el acceso se serializa mediante `LIENZO_ENTREGADO`, que garantiza
+// un unico prestamo mutable durante toda la vida del sistema.
+unsafe impl Sync for LienzoEstatico {}
+
+/// Memoria de respaldo del lienzo intermedio.
+static MEMORIA_LIENZO: LienzoEstatico = LienzoEstatico(UnsafeCell::new([0u32; PIXELES_MAX]));
+
+/// Centinela de entrega unica del lienzo.
+static LIENZO_ENTREGADO: AtomicBool = AtomicBool::new(false);
+
+/// Entrega — exactamente una vez — el prestamo mutable de la memoria del lienzo.
+pub(crate) fn reclamar_memoria_lienzo() -> Option<&'static mut [u32]> {
+    if LIENZO_ENTREGADO.swap(true, Ordering::AcqRel) {
+        return None;
+    }
+    // SEGURIDAD: el `swap` anterior garantiza que este es el unico prestamo
+    // mutable de `MEMORIA_LIENZO` durante toda la ejecucion.
+    let arreglo: &'static mut [u32; PIXELES_MAX] = unsafe { &mut *MEMORIA_LIENZO.0.get() };
+    Some(arreglo.as_mut_slice())
+}
+
+/// Superficie de dibujo en RAM. Cada pixel se almacena ya codificado.
+pub(crate) struct Lienzo {
+    pub(crate) pixeles: &'static mut [u32],
+    pub(crate) ancho: usize,
+    pub(crate) alto: usize,
+    pub(crate) formato: PixelFormat,
+}
+
+impl Lienzo {
+    /// Construye un lienzo sobre la memoria de respaldo reclamada.
+    pub(crate) fn nuevo(
+        memoria: &'static mut [u32],
+        ancho: usize,
+        alto: usize,
+        formato: PixelFormat,
+    ) -> Lienzo {
+        Lienzo {
+            pixeles: memoria,
+            ancho,
+            alto,
+            formato,
+        }
+    }
+
+    /// Pinta un unico pixel. Las coordenadas fuera del lienzo se ignoran.
+    pub(crate) fn pintar_pixel(&mut self, x: usize, y: usize, color: Color) {
+        if x < self.ancho && y < self.alto {
+            self.pixeles[y * self.ancho + x] = codificar(self.formato, color);
+        }
+    }
+
+    /// Rellena un rectangulo, recortado con firmeza a los limites del lienzo.
+    pub(crate) fn rellenar_rect(
+        &mut self,
+        x0: usize,
+        y0: usize,
+        ancho: usize,
+        alto: usize,
+        color: Color,
+    ) {
+        let valor = codificar(self.formato, color);
+        let x_ini = x0.min(self.ancho);
+        let y_ini = y0.min(self.alto);
+        let x_fin = (x0 + ancho).min(self.ancho);
+        let y_fin = (y0 + alto).min(self.alto);
+
+        let mut y = y_ini;
+        while y < y_fin {
+            let base = y * self.ancho;
+            let mut x = x_ini;
+            while x < x_fin {
+                self.pixeles[base + x] = valor;
+                x += 1;
+            }
+            y += 1;
+        }
+    }
+
+    /// Inunda el lienzo entero con un color plano.
+    pub(crate) fn limpiar(&mut self, color: Color) {
+        self.rellenar_rect(0, 0, self.ancho, self.alto, color);
+    }
+}
+
+// `embedded-graphics` ve el lienzo como un `DrawTarget`: sus primitivas
+// vectoriales pueden dibujar directamente sobre el.
+impl DrawTarget for Lienzo {
+    type Color = Rgb888;
+    type Error = core::convert::Infallible;
+
+    fn draw_iter<I>(&mut self, pixeles: I) -> Result<(), Self::Error>
+    where
+        I: IntoIterator<Item = Pixel<Self::Color>>,
+    {
+        for Pixel(punto, color) in pixeles {
+            if let (Ok(x), Ok(y)) = (usize::try_from(punto.x), usize::try_from(punto.y)) {
+                self.pintar_pixel(
+                    x,
+                    y,
+                    Color {
+                        r: color.r(),
+                        g: color.g(),
+                        b: color.b(),
+                    },
+                );
+            }
+        }
+        Ok(())
+    }
+}
+
+impl OriginDimensions for Lienzo {
+    fn size(&self) -> Size {
+        Size::new(self.ancho as u32, self.alto as u32)
+    }
+}
+
+// =============================================================================
+//  PANTALLA — el framebuffer fisico GOP, envuelto en seguridad
+// =============================================================================
+
+/// Vista segura del framebuffer lineal entregado por el firmware UEFI.
+pub(crate) struct Pantalla {
+    pub(crate) base: *mut u8,
+    pub(crate) ancho: usize,
+    pub(crate) alto: usize,
+    pub(crate) paso_bytes: usize,
+    pub(crate) bytes_por_pixel: usize,
+}
+
+impl Pantalla {
+    /// Adopta el framebuffer descrito por `info`. La memoria de video es
+    /// permanente, asi que conservar su puntero crudo es legitimo.
+    pub(crate) fn adoptar(framebuffer: &mut FrameBuffer, info: FrameBufferInfo) -> Pantalla {
+        let base = framebuffer.buffer_mut().as_mut_ptr();
+        Pantalla {
+            base,
+            ancho: info.width,
+            alto: info.height,
+            paso_bytes: info.stride * info.bytes_per_pixel,
+            bytes_por_pixel: info.bytes_per_pixel,
+        }
+    }
+
+    /// Vuelca el lienzo intermedio sobre la pantalla fisica de un solo gesto.
+    pub(crate) fn presentar(&mut self, lienzo: &Lienzo) {
+        let ancho = self.ancho.min(lienzo.ancho);
+        let alto = self.alto.min(lienzo.alto);
+
+        for y in 0..alto {
+            let fila_fisica = y * self.paso_bytes;
+            let fila_lienzo = y * lienzo.ancho;
+            for x in 0..ancho {
+                let pixel = lienzo.pixeles[fila_lienzo + x];
+                // SEGURIDAD: x e y estan acotados por las dimensiones reales
+                // del framebuffer; el desplazamiento cae siempre dentro de el.
+                unsafe {
+                    let destino = self.base.add(fila_fisica + x * self.bytes_por_pixel);
+                    escribir_pixel_volatil(destino, pixel, self.bytes_por_pixel);
+                }
+            }
+        }
+    }
+}

renaser/kernel/src/interrupts.rs

@@ -0,0 +1,148 @@
+// =============================================================================
+//  renaser :: kernel/src/interrupts.rs — Fase 2/3 :: la IDT y los reflejos
+// -----------------------------------------------------------------------------
+//  La Interrupt Descriptor Table es la tabla de reflejos del procesador. ante
+//  cada excepcion o IRQ, la CPU abandona lo que hacia y salta a la entrada que
+//  le corresponde. renaser distingue tres naturalezas de impulso:
+//
+//    * RECUPERABLE — el breakpoint (#BP): se atiende y la ejecucion prosigue.
+//    * FATAL       — el resto de excepciones: se entregan al `panic!`.
+//    * HARDWARE    — temporizador, teclado y disco: ya NO escriben estado
+//                    rustico, sino que alimentan el reactor asincrono.
+// =============================================================================
+
+use core::sync::atomic::{AtomicU8, Ordering};
+
+use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame, PageFaultErrorCode};
+
+use crate::{gdt, pic, CeldaSync};
+
+/// La Interrupt Descriptor Table propia de renaser.
+static IDT: CeldaSync<InterruptDescriptorTable> =
+    CeldaSync::nueva(InterruptDescriptorTable::new());
+
+/// Vector de la IDT asignado a la IRQ del disco. Vale 0 hasta que el montaje
+/// del disco (Fase 6.2) descubra su linea de IRQ y la registre — ninguna IRQ
+/// legitima del disco vive en el vector 0 (reservado a las excepciones).
+static VECTOR_DISCO: AtomicU8 = AtomicU8::new(0);
+
+/// Construye y activa la Interrupt Descriptor Table.
+///
+/// Debe invocarse una sola vez, durante el arranque, DESPUES de [`gdt::init`].
+pub fn init() {
+    // SEGURIDAD: `init` corre una sola vez, en arranque secuencial de un solo
+    // hilo; nada mas referencia la IDT todavia.
+    let idt: &'static mut InterruptDescriptorTable = unsafe { &mut *IDT.puntero() };
+
+    // --- Excepciones de CPU ---
+    idt.breakpoint.set_handler_fn(reflejo_breakpoint);
+    idt.invalid_opcode.set_handler_fn(reflejo_opcode_invalido);
+    idt.divide_error.set_handler_fn(reflejo_division);
+    idt.general_protection_fault
+        .set_handler_fn(reflejo_proteccion_general);
+    idt.page_fault.set_handler_fn(reflejo_fallo_pagina);
+
+    // El doble fallo se atiende SIEMPRE sobre el stack de emergencia del TSS:
+    // ni un desbordamiento de la pila del kernel impedira su diagnostico.
+    // SEGURIDAD: el indice IST referido fue armado previamente por `gdt::init`.
+    unsafe {
+        idt.double_fault
+            .set_handler_fn(reflejo_doble_fallo)
+            .set_stack_index(gdt::IST_DOBLE_FALLO);
+    }
+
+    // --- Interrupciones de hardware, ya remapeadas por el PIC ---
+    idt[pic::VECTOR_TEMPORIZADOR].set_handler_fn(irq_temporizador);
+    idt[pic::VECTOR_TECLADO].set_handler_fn(irq_teclado);
+
+    let idt_estatica: &'static InterruptDescriptorTable = idt;
+    idt_estatica.load();
+}
+
+/// Registra el manejador de la IRQ del disco virtio-blk en la entrada de la IDT
+/// que corresponde a `irq` (Fase 6.2). Lo invoca el montaje del disco, una vez
+/// descubierta la linea de IRQ que el firmware le asigno.
+///
+/// Se llama durante el arranque secuencial, con las interrupciones aun
+/// desactivadas y la linea todavia enmascarada en el PIC: la entrada que se
+/// escribe no puede dispararse mientras se escribe.
+pub fn registrar_irq_disco(irq: u8) {
+    let vector = pic::vector_irq(irq);
+    VECTOR_DISCO.store(vector, Ordering::SeqCst);
+    // SEGURIDAD: el arranque es secuencial y de un solo hilo; las interrupciones
+    // estan desactivadas y la linea del disco, enmascarada. La IDT ya esta
+    // cargada (`init` hizo `lidt`), pero la CPU relee cada entrada en cada
+    // interrupcion: modificar esta entrada en memoria surte efecto de inmediato.
+    let idt: &'static mut InterruptDescriptorTable = unsafe { &mut *IDT.puntero() };
+    idt[vector].set_handler_fn(irq_disco);
+}
+
+// =============================================================================
+//  REFLEJOS DE EXCEPCION — las rutinas a las que la CPU salta ante cada fallo
+// =============================================================================
+
+/// #BP — Breakpoint. Excepcion RECUPERABLE: se atiende sin ruido y, al
+/// retornar, la CPU reanuda la ejecucion justo tras la instruccion `int3`.
+extern "x86-interrupt" fn reflejo_breakpoint(_marco: InterruptStackFrame) {}
+
+/// #UD — Opcode invalido. Fatal: la corriente de instrucciones es incoherente.
+extern "x86-interrupt" fn reflejo_opcode_invalido(marco: InterruptStackFrame) {
+    panic!("EXCEPCION FATAL :: opcode invalido (#UD)\n{marco:#?}");
+}
+
+/// #DE — Error de division. Fatal.
+extern "x86-interrupt" fn reflejo_division(marco: InterruptStackFrame) {
+    panic!("EXCEPCION FATAL :: error de division (#DE)\n{marco:#?}");
+}
+
+/// #GP — Fallo de proteccion general. Fatal.
+extern "x86-interrupt" fn reflejo_proteccion_general(marco: InterruptStackFrame, codigo: u64) {
+    panic!("EXCEPCION FATAL :: proteccion general (#GP) codigo={codigo:#x}\n{marco:#?}");
+}
+
+/// #PF — Fallo de pagina. Fatal en esta fase (sin memoria virtual dinamica).
+extern "x86-interrupt" fn reflejo_fallo_pagina(
+    marco: InterruptStackFrame,
+    codigo: PageFaultErrorCode,
+) {
+    let direccion = x86_64::registers::control::Cr2::read_raw();
+    panic!("EXCEPCION FATAL :: fallo de pagina (#PF) en {direccion:#x} {codigo:?}\n{marco:#?}");
+}
+
+/// #DF — Doble fallo. Fatal e irreversible: por definicion, diverge. Se ejecuta
+/// sobre el stack de emergencia del TSS, nunca sobre la pila comprometida.
+extern "x86-interrupt" fn reflejo_doble_fallo(marco: InterruptStackFrame, _codigo: u64) -> ! {
+    panic!("EXCEPCION FATAL :: doble fallo (#DF)\n{marco:#?}");
+}
+
+// =============================================================================
+//  IMPULSOS DE HARDWARE — productores de eventos para el reactor asincrono
+// =============================================================================
+
+/// IRQ0 — Temporizador. Desde la Fase 5 marca el compas del userspace: cada
+/// pulso avanza el `reloj` y despierta a las tareas que aguardaban su fotograma.
+extern "x86-interrupt" fn irq_temporizador(_marco: InterruptStackFrame) {
+    crate::async_system::reloj::pulso();
+    pic::fin_de_interrupcion(pic::VECTOR_TEMPORIZADOR);
+}
+
+/// IRQ1 — Teclado. Ya no escribe estado rustico: lee el scancode crudo y lo
+/// entrega al reactor asincrono, que despertara a la tarea del teclado.
+extern "x86-interrupt" fn irq_teclado(_marco: InterruptStackFrame) {
+    // SEGURIDAD: 0x60 es el puerto de datos del controlador PS/2, fijo en la
+    // arquitectura PC. Leerlo, ademas, libera al controlador para el siguiente.
+    let scancode: u8 = unsafe { x86_64::instructions::port::Port::new(0x60).read() };
+    crate::async_system::teclado::recibir_scancode(scancode);
+    pic::fin_de_interrupcion(pic::VECTOR_TECLADO);
+}
+
+/// IRQ del disco — virtio-blk (Fase 6.2). El disco ha terminado una
+/// transferencia: `atender_irq` reconoce la interrupcion en el dispositivo
+/// —lo que libera su linea— y despierta a la tarea que aguardaba el bloque.
+/// Asi la E/S de disco deja de bloquear el planificador por sondeo.
+extern "x86-interrupt" fn irq_disco(_marco: InterruptStackFrame) {
+    crate::drivers::disco::atender_irq();
+    // El EOI se cierra DESPUES de reconocer al dispositivo: una IRQ legada de
+    // PCI es de nivel — anunciar el fin sin haber bajado la linea la reavivaria.
+    pic::fin_de_interrupcion(VECTOR_DISCO.load(Ordering::SeqCst));
+}

renaser/kernel/src/main.rs

@@ -0,0 +1,342 @@
+// =============================================================================
+//  renaser :: kernel/src/main.rs — el punto de entrada y la orquestacion
+// -----------------------------------------------------------------------------
+//  Aqui no nace una terminal: nace una superficie. renaser es un kernel
+//  asincrono de Espacio de Direccionamiento Unico (SASOS) que rompe con el
+//  paradigma POSIX — sin TTYs, sin archivos planos, sin capas GNU.
+//
+//  Este archivo es deliberadamente delgado: solo el arranque y el cableado.
+//  Cada subsistema vive en su propio modulo (ver `ARCHITECTURE.md`):
+//
+//    grafico      — color, framebuffer fisico y lienzo de doble bufer.
+//    consola      — superficie de texto/imagen; rasteriza glifos con fontdue.
+//    baliza       — red de seguridad visual; manejadores de panico y de OOM.
+//    sync         — `CeldaSync`, la celda de inicializacion unica.
+//    gdt          — GDT + TSS + stack de emergencia del doble fallo.
+//    interrupts   — IDT, excepciones de CPU e interrupciones de hardware.
+//    pic          — el par 8259 remapeado y el temporizador (PIT).
+//    drivers      — descubrimiento de hardware y E/S de disco asincrona por
+//                   interrupcion: el bus PCI y el virtio-blk (Fases 6.1, 6.2).
+//    almacen      — el grafo de objetos direccionado por contenido (Fase 6.1c).
+//    memory       — el heap dinamico del kernel (`#[global_allocator]`).
+//    async_system — el reactor cooperativo: ejecutor, tareas, wakers, teclado
+//                   y el reloj que marca el compas de los fotogramas (Fase 5).
+//    texto        — rasterizacion de tipografia vectorial (fontdue).
+//    wasm         — el runtime WebAssembly, la matriz de capacidades y el
+//                   escudo de combustible que acota el tiempo de cada app.
+// =============================================================================
+
+#![no_std] // Prohibido `std`: bajo nosotros no hay sistema operativo alguno.
+#![no_main] // El punto de entrada lo define el cargador, no la convencion C.
+#![feature(abi_x86_interrupt)] // ABI de las rutinas de excepcion (Fase 2).
+#![feature(alloc_error_handler)] // Manejador propio de agotamiento de heap (Fase 3).
+#![deny(unsafe_op_in_unsafe_fn)] // Cada operacion `unsafe` se justifica explicitamente.
+
+extern crate alloc; // El heap esta vivo: `alloc::*` queda disponible (Fase 3).
+
+use alloc::format;
+
+use bootloader_api::config::{BootloaderConfig, Mapping};
+use bootloader_api::info::{FrameBufferInfo, MemoryRegionKind, MemoryRegions, PixelFormat};
+use bootloader_api::{entry_point, BootInfo};
+use spin::Mutex;
+
+// --- Subsistemas del kernel ---
+mod almacen;
+mod async_system;
+mod baliza;
+mod consola;
+mod drivers;
+mod gdt;
+mod grafico;
+mod interrupts;
+mod memory;
+mod pic;
+mod sync;
+mod texto;
+mod wasm;
+
+// Reexportaciones para que los submodulos conserven rutas `crate::` estables.
+pub(crate) use consola::volcar_marco_wasm;
+pub(crate) use sync::CeldaSync;
+
+use async_system::executor::Executor;
+use baliza::BALIZA_PANICO;
+use consola::{Consola, CONSOLA};
+use grafico::{
+    codificar, reclamar_memoria_lienzo, Color, Lienzo, Pantalla, RegionPantalla, ALTO_MAX,
+    ANCHO_MAX,
+};
+
+/// El modulo WASM del userspace, empotrado en el binario del kernel para esta
+/// fase de pruebas. Es un `.wasm` puro, compilado aparte para `wasm32`. La
+/// Fase 5 lo instancia DOS veces —el mismo bytecode, dos regiones distintas—
+/// para demostrar la multitarea cooperativa sobre el espacio unico.
+static APP_WASM: &[u8] = include_bytes!("../assets/app.wasm");
+
+/// La aplicacion DISCOLA: un modulo WASM cuyo `tick` cae en un bucle cerrado y
+/// jamas retorna. Existe para una sola cosa — demostrar que el guardarrail de
+/// combustible la fulmina sin despeinar al kernel ni a sus vecinas.
+static DISCOLA_WASM: &[u8] = include_bytes!("../assets/discola.wasm");
+
+/// La aplicacion GLOTONA: un modulo WASM que reclama memoria lineal sin freno.
+/// Demuestra el guardarrail ESPACIAL — el techo de memoria la desaloja con la
+/// baliza amarilla, gemela de la purpura del desalojo por combustible.
+static GLOTONA_WASM: &[u8] = include_bytes!("../assets/glotona.wasm");
+
+/// La aplicacion CRONISTA: la primera ciudadana del userspace que escribe en el
+/// almacenamiento PERSISTENTE. En cada arranque graba un objeto en el grafo
+/// —enlazado al del arranque anterior—, lo corona como raiz y pinta una celda
+/// por cada arranque registrado. El disco recuerda; la cuenta sobrevive a los
+/// reinicios. Demuestra las capacidades `sys_object_*` de la Fase 6.1c.
+static CRONISTA_WASM: &[u8] = include_bytes!("../assets/cronista.wasm");
+
+/// Configuracion que el cargador `bootloader` aplicara antes de cedernos la CPU.
+static CONFIG_ARRANQUE: BootloaderConfig = {
+    let mut config = BootloaderConfig::new_default();
+    // Pedimos la memoria fisica mapeada: cimiento para futuras fases.
+    config.mappings.physical_memory = Some(Mapping::Dynamic);
+    config
+};
+
+// `entry_point!` genera el simbolo `_start`, valida la firma de `kernel_main`
+// y nos transfiere el control con seguridad de tipos.
+entry_point!(kernel_main, config = &CONFIG_ARRANQUE);
+
+/// Detiene la CPU de forma definitiva: `hlt` la duerme hasta una interrupcion.
+pub(crate) fn detener() -> ! {
+    loop {
+        x86_64::instructions::hlt();
+    }
+}
+
+/// Tarea cooperativa de una aplicacion WASM. En cada pulso del reloj le concede
+/// un `tick` —un fotograma de trabajo— y cede la CPU hasta el siguiente; entre
+/// medias corren sus vecinas. Si la app falla o agota su combustible, se la
+/// DESALOJA: se tatua su region con la baliza de purpura y la tarea concluye.
+/// El ejecutor la retira del censo, su memoria se libera, el kernel sigue vivo.
+async fn tarea_aplicacion(mut app: wasm::AplicacionWasm) {
+    loop {
+        async_system::reloj::EsperaFrame::nueva().await;
+        if let Err(falla) = app.tick() {
+            // El color de la baliza delata la causa: purpura si agoto su tiempo
+            // o aborto, amarillo si reviento su techo de memoria.
+            consola::pintar_desalojo(app.region(), falla.color_baliza());
+            return;
+        }
+    }
+}
+
+/// FASE 6.2 — la prueba viva de la E/S asincrona. Esta tarea del reactor lee el
+/// sector 0 del disco SIN bloquear: cede la CPU mientras el disco trabaja —las
+/// apps siguen pintando entre tanto— y la IRQ del disco la reanuda cuando el
+/// bloque esta listo. Deja en la consola el resultado y cuantas interrupciones
+/// de disco se atendieron — el testigo de que la E/S por sondeo quedo atras.
+async fn tarea_sonda_disco() {
+    let resultado = drivers::disco::leer_bloques(0, 1).await;
+    let Some(consola) = CONSOLA.get() else {
+        return;
+    };
+    let mut consola = consola.lock();
+    match resultado {
+        Ok(_) => consola.escribir(&format!(
+            "disco :: sonda asincrona OK -- {} IRQ de disco atendidas\n",
+            drivers::disco::pulsos_disco(),
+        )),
+        Err(motivo) => {
+            consola.escribir(&format!("disco :: sonda asincrona fallida -- {motivo}\n"))
+        }
+    }
+    consola.presentar();
+}
+
+/// Da vida a una aplicacion del userspace: la carga en su region y, si lo
+/// logra, la despacha como tarea cooperativa del reactor. Una carga fallida se
+/// salda pintando su region con la baliza de desalojo — el kernel no se inmuta.
+fn encender_app(ejecutor: &mut Executor, bytecode: &'static [u8], region: RegionPantalla) {
+    match wasm::AplicacionWasm::cargar(bytecode, region) {
+        Ok(app) => ejecutor.spawn(tarea_aplicacion(app)),
+        Err(_) => consola::pintar_desalojo(region, Color::DESALOJO),
+    }
+}
+
+/// Localiza la mayor region de RAM libre que el cargador reporto — la cantera
+/// de la que el DMA del disco tomara sus marcos fisicos.
+fn mayor_region_usable(regiones: &MemoryRegions) -> Option<(u64, u64)> {
+    regiones
+        .iter()
+        .filter(|region| matches!(region.kind, MemoryRegionKind::Usable))
+        .map(|region| (region.start, region.end))
+        .max_by_key(|&(inicio, fin)| fin - inicio)
+}
+
+/// FASE 6.1c — funda el grafo de objetos. Monta el disco virtio-blk, lee o
+/// forja el superbloque, reconstruye el indice recorriendo el log y deja
+/// constancia visual: cuantos sectores tiene el disco, cuantos objetos viven
+/// ya en el grafo y si el arranque encontro —o no— una raiz de la que tirar.
+fn informar_almacen() {
+    // Fundar el almacen ANTES de tomar el cerrojo de la consola: el montaje
+    // del disco hace E/S por sondeo y nada de ello reclama la consola.
+    let resultado = almacen::init();
+    let Some(consola) = CONSOLA.get() else {
+        return;
+    };
+    let mut consola = consola.lock();
+    match resultado {
+        Ok(resumen) => {
+            let estado = if resumen.formateado {
+                "disco formateado"
+            } else {
+                "grafo montado"
+            };
+            consola.escribir(&format!(
+                "almacen :: {} :: {} sectores :: {} objetos :: raiz {}\n",
+                estado,
+                resumen.capacidad,
+                resumen.objetos,
+                if resumen.raiz { "presente" } else { "ausente" },
+            ));
+        }
+        Err(motivo) => {
+            consola.escribir(&format!("almacen :: fallo :: {motivo}\n"));
+        }
+    }
+    // FASE 6.2 — dejar constancia de la linea de IRQ por la que el disco
+    // anunciara, ya sin sondeo, el fin de cada transferencia.
+    match drivers::disco::irq() {
+        Some(irq) => {
+            consola.escribir(&format!("disco :: virtio-blk en IRQ {irq} -- E/S asincrona\n"))
+        }
+        None => consola.escribir("disco :: IRQ no enrutada -- E/S por sondeo\n"),
+    }
+    consola.presentar();
+}
+
+// =============================================================================
+//  PUNTO DE ENTRADA DEL KERNEL
+// =============================================================================
+
+fn kernel_main(boot_info: &'static mut BootInfo) -> ! {
+    // --- 1. Recuperar el framebuffer GOP que el firmware nos confio. ---
+    let framebuffer = match boot_info.framebuffer.as_mut() {
+        Some(fb) => fb,
+        None => detener(),
+    };
+    let info: FrameBufferInfo = framebuffer.info();
+    let formato: PixelFormat = info.pixel_format;
+    let pantalla = Pantalla::adoptar(framebuffer, info);
+
+    // Datos para la sonda de disco (Fase 6.1b): el offset al que el cargador
+    // mapeo la memoria fisica y la mayor region de RAM libre para el DMA.
+    let offset_fisico = boot_info.physical_memory_offset.into_option();
+    let region_dma = mayor_region_usable(&boot_info.memory_regions);
+
+    // --- 2. Encender la baliza: la red de seguridad visual va primero. ---
+    BALIZA_PANICO.encender(
+        &pantalla,
+        codificar(formato, Color::ALERTA),
+        codificar(formato, Color::OOM),
+    );
+
+    // --- 3. Cimientos de fallos e interrupciones (Fases 2.0 y 2.1). ---
+    gdt::init();
+    interrupts::init();
+    pic::init();
+
+    // --- 4. FASE 3 :: fundar el heap. A partir de aqui, `alloc` esta vivo. ---
+    memory::init();
+
+    // --- 5. Con el heap activo, fundar lo que depende de el: el canal de
+    //        scancodes, el reloj de fotogramas y la tipografia vectorial. ---
+    async_system::teclado::init();
+    async_system::reloj::init();
+    texto::init();
+
+    // --- 6. Construir el lienzo y la consola; pintar el rotulo inicial,
+    //        ya rasterizado por fontdue, y publicar la consola globalmente. ---
+    let memoria = match reclamar_memoria_lienzo() {
+        Some(m) => m,
+        None => detener(),
+    };
+    let mut lienzo = Lienzo::nuevo(
+        memoria,
+        info.width.min(ANCHO_MAX),
+        info.height.min(ALTO_MAX),
+        formato,
+    );
+    lienzo.limpiar(Color::LIENZO_EN_REPOSO);
+
+    let mut consola = Consola::nueva(lienzo, pantalla);
+    consola.escribir("renaser :: fase 6.2 -- E/S de disco asincrona por interrupcion\n");
+    consola.presentar();
+    CONSOLA.call_once(|| Mutex::new(consola));
+
+    // --- 6.5. FASE 6.1c :: fundar el subsistema de disco y, sobre el, el grafo
+    //          de objetos: enumerar el bus PCI, montar el transporte virtio-blk,
+    //          y leer o forjar el superbloque del almacen direccionado por
+    //          contenido. El kernel adquiere, por fin, una memoria que perdura. ---
+    match (offset_fisico, region_dma) {
+        (Some(offset), Some((inicio, fin))) => {
+            drivers::disco::init(offset, inicio, fin);
+            informar_almacen();
+        }
+        _ => {
+            if let Some(consola) = CONSOLA.get() {
+                let mut consola = consola.lock();
+                consola.escribir("virtio-blk :: omitido -- memoria fisica sin mapear\n");
+                consola.presentar();
+            }
+        }
+    }
+
+    // --- 7. FASE 5/6 :: levantar el reactor y poblar el userspace con CINCO
+    //        aplicaciones WASM concurrentes, cada una en su propia region:
+    //
+    //          * App 1 — instancia de hello_wasm, a la izquierda, gobernada
+    //            por el teclado.
+    //          * App 2 — segunda instancia del MISMO bytecode, a la derecha:
+    //            un unico modulo en la RAM unificada, dos vidas aisladas.
+    //          * App discola — su `tick` es un bucle cerrado: el escudo de
+    //            COMBUSTIBLE la desaloja (baliza purpura) en su 1er fotograma.
+    //          * App glotona — reclama memoria sin freno: el escudo ESPACIAL
+    //            la desaloja (baliza amarilla) en su 1er fotograma.
+    //          * App cronista — escribe en el GRAFO DE OBJETOS persistente:
+    //            cada arranque deja un objeto enlazado al anterior y pinta una
+    //            celda por arranque. El disco recuerda entre reinicios.
+    //
+    //        Las interrupciones se habilitan AHORA: el temporizador marcara el
+    //        compas de los fotogramas y la IRQ del teclado difundira cada
+    //        scancode a los canales que las apps consultan. ---
+    let mut ejecutor = Executor::nuevo();
+    encender_app(
+        &mut ejecutor,
+        APP_WASM,
+        RegionPantalla { x: 100, y: 120, ancho: 480, alto: 560 },
+    );
+    encender_app(
+        &mut ejecutor,
+        APP_WASM,
+        RegionPantalla { x: 700, y: 120, ancho: 480, alto: 560 },
+    );
+    encender_app(
+        &mut ejecutor,
+        DISCOLA_WASM,
+        RegionPantalla { x: 60, y: 700, ancho: 360, alto: 80 },
+    );
+    encender_app(
+        &mut ejecutor,
+        GLOTONA_WASM,
+        RegionPantalla { x: 460, y: 700, ancho: 360, alto: 80 },
+    );
+    encender_app(
+        &mut ejecutor,
+        CRONISTA_WASM,
+        RegionPantalla { x: 860, y: 700, ancho: 360, alto: 80 },
+    );
+    // FASE 6.2 :: una tarea mas del reactor — no una app WASM— que sondea el
+    // disco de forma ASINCRONA: la demostracion de que la IRQ del disco
+    // conduce la E/S sin detener a las aplicaciones visuales.
+    ejecutor.spawn(tarea_sonda_disco());
+    x86_64::instructions::interrupts::enable();
+    ejecutor.run();
+}

renaser/kernel/src/memory/allocator.rs

@@ -0,0 +1,42 @@
+// =============================================================================
+//  renaser :: kernel/src/memory/allocator.rs — Fase 3 :: el asignador global
+// -----------------------------------------------------------------------------
+//  Reutilizamos un algoritmo probado (`linked_list_allocator`) en lugar de
+//  arriesgar un asignador propio a bugs de fragmentacion. El heap es una region
+//  estatica que PERSISTE durante toda la vida del kernel.
+// =============================================================================
+
+use linked_list_allocator::LockedHeap;
+
+use crate::CeldaSync;
+
+/// 64 MiB de heap para el kernel. La arquitectura estimaba 16, pero `fontdue`,
+/// al analizar una tipografia real, exige mas holgura; el manejador de OOM —la
+/// franja naranja— fue justamente lo que delato esa cota demasiado corta.
+const TAM_HEAP: usize = 64 * 1024 * 1024;
+
+/// Region de respaldo del heap, alineada a pagina, residente en `.bss`. Su
+/// campo solo se alcanza via puntero crudo —asi lo exige `GlobalAlloc`—, de ahi
+/// el `allow(dead_code)`: la memoria se usa, aunque no por una via «normal».
+#[repr(align(4096))]
+#[allow(dead_code)]
+struct RegionHeap([u8; TAM_HEAP]);
+
+/// La memoria fisica del heap. Nace a ceros, no engorda el binario.
+static REGION_HEAP: CeldaSync<RegionHeap> = CeldaSync::nueva(RegionHeap([0u8; TAM_HEAP]));
+
+/// El asignador global. Todo `alloc::*` —`Box`, `Vec`, `BTreeMap`, `Arc`...—
+/// se apoya, en silencio, sobre este.
+#[global_allocator]
+static ASIGNADOR: LockedHeap = LockedHeap::empty();
+
+/// Funda el heap del kernel. Debe invocarse UNA sola vez, en el arranque,
+/// antes del primer uso de cualquier estructura de `alloc`.
+pub fn init() {
+    let inicio: *mut u8 = REGION_HEAP.puntero().cast::<u8>();
+    // SEGURIDAD: la region es estatica, de uso exclusivo del asignador, vive
+    // tanto como el kernel, y `init` se invoca una unica vez en el arranque.
+    unsafe {
+        ASIGNADOR.lock().init(inicio, TAM_HEAP);
+    }
+}

renaser/kernel/src/memory/mod.rs

@@ -0,0 +1,11 @@
+// =============================================================================
+//  renaser :: kernel/src/memory — la memoria dinamica del kernel (Fase 3)
+// -----------------------------------------------------------------------------
+//  El heap no es, en renaser, una utilidad pasiva al estilo C. Existe para
+//  sostener algo vivo: la cola de futuros y los reactores asincronos sobre los
+//  que, fase a fase, se ejecutara el bytecode WASM aislado por software.
+// =============================================================================
+
+pub mod allocator;
+
+pub use allocator::init;

renaser/kernel/src/pic.rs

@@ -0,0 +1,147 @@
+// =============================================================================
+//  renaser :: kernel/src/pic.rs — Fase 2.1 :: el par 8259 y el metronomo
+// -----------------------------------------------------------------------------
+//  El controlador de interrupciones 8259 (PIC) nace, por herencia historica,
+//  con sus vectores solapados sobre los de las excepciones de CPU. Antes de
+//  encender las interrupciones HAY que remapearlo: desplazar sus vectores
+//  fuera del rango 0..31. Aqui tambien programamos el PIT, el temporizador
+//  que dara a renaser su latido regular — el origen de su fluidez.
+// =============================================================================
+
+use x86_64::instructions::port::Port;
+
+// --- Puertos del par de 8259 (maestro + esclavo en cascada). ---
+const CMD_MAESTRO: u16 = 0x20;
+const DATOS_MAESTRO: u16 = 0x21;
+const CMD_ESCLAVO: u16 = 0xA0;
+const DATOS_ESCLAVO: u16 = 0xA1;
+
+// --- Puertos del temporizador de intervalos programable (PIT). ---
+const PIT_COMANDO: u16 = 0x43;
+const PIT_CANAL0: u16 = 0x40;
+/// Frecuencia base del cristal del PIT, en Hz.
+const PIT_BASE_HZ: u32 = 1_193_182;
+
+/// Orden de «fin de interrupcion» que el PIC espera tras cada IRQ atendida.
+const EOI: u8 = 0x20;
+
+/// Vector base del PIC maestro tras el remapeo (justo encima de las 32
+/// excepciones reservadas de la arquitectura).
+const OFFSET_MAESTRO: u8 = 0x20;
+/// Vector base del PIC esclavo tras el remapeo.
+const OFFSET_ESCLAVO: u8 = 0x28;
+
+/// Vector de la IRQ0 — el temporizador (PIT).
+pub const VECTOR_TEMPORIZADOR: u8 = OFFSET_MAESTRO; // 0x20
+/// Vector de la IRQ1 — el teclado.
+pub const VECTOR_TECLADO: u8 = OFFSET_MAESTRO + 1; // 0x21
+
+/// Remapea el par 8259 y programa el PIT a 100 Hz.
+///
+/// Debe invocarse una sola vez, tras cargar la IDT y ANTES de habilitar las
+/// interrupciones con `sti`.
+pub fn init() {
+    remapear();
+    configurar_temporizador(100);
+}
+
+/// Reprograma los vectores del 8259 fuera del rango de las excepciones de CPU.
+fn remapear() {
+    // SEGURIDAD: estos son los puertos de E/S estandar del 8259 en la
+    // arquitectura PC; la secuencia ICW1..ICW4 es su protocolo de inicio.
+    unsafe {
+        let mut cmd_m = Port::<u8>::new(CMD_MAESTRO);
+        let mut dat_m = Port::<u8>::new(DATOS_MAESTRO);
+        let mut cmd_e = Port::<u8>::new(CMD_ESCLAVO);
+        let mut dat_e = Port::<u8>::new(DATOS_ESCLAVO);
+        // Escribir en un puerto inerte da al 8259 el respiro que necesita
+        // entre palabras de control en hardware antiguo.
+        let mut respiro = Port::<u8>::new(0x80);
+
+        // ICW1 — iniciar la secuencia: en cascada, con ICW4 presente.
+        cmd_m.write(0x11u8);
+        respiro.write(0u8);
+        cmd_e.write(0x11u8);
+        respiro.write(0u8);
+        // ICW2 — el remapeo en si: desplazar los vectores lejos de 0..31.
+        dat_m.write(OFFSET_MAESTRO);
+        respiro.write(0u8);
+        dat_e.write(OFFSET_ESCLAVO);
+        respiro.write(0u8);
+        // ICW3 — declarar el cableado de la cascada (el esclavo en la IRQ2).
+        dat_m.write(0b0000_0100u8);
+        respiro.write(0u8);
+        dat_e.write(0b0000_0010u8);
+        respiro.write(0u8);
+        // ICW4 — modo 8086.
+        dat_m.write(0x01u8);
+        respiro.write(0u8);
+        dat_e.write(0x01u8);
+        respiro.write(0u8);
+        // Mascaras: el maestro deja pasar la IRQ0 (temporizador) y la IRQ1
+        // (teclado); todo lo demas, en silencio hasta que renaser lo reclame.
+        dat_m.write(0b1111_1100u8);
+        dat_e.write(0b1111_1111u8);
+    }
+}
+
+/// Programa el canal 0 del PIT para que emita la IRQ0 a `frecuencia_hz`.
+fn configurar_temporizador(frecuencia_hz: u32) {
+    let divisor = (PIT_BASE_HZ / frecuencia_hz) as u16;
+    // SEGURIDAD: 0x43 y 0x40 son los puertos estandar del PIT en el PC.
+    unsafe {
+        let mut comando = Port::<u8>::new(PIT_COMANDO);
+        let mut canal0 = Port::<u8>::new(PIT_CANAL0);
+        // Canal 0, acceso lobyte+hibyte, modo 3 (generador de onda cuadrada).
+        comando.write(0x36u8);
+        canal0.write((divisor & 0xFF) as u8);
+        canal0.write((divisor >> 8) as u8);
+    }
+}
+
+/// Notifica al PIC el «fin de interrupcion» de la IRQ recien atendida. Sin
+/// este aviso, el PIC jamas volveria a emitir esa interrupcion.
+pub fn fin_de_interrupcion(vector: u8) {
+    // SEGURIDAD: enviar EOI al puerto de comandos del PIC tras atender su IRQ
+    // es el cierre obligatorio del protocolo del 8259.
+    unsafe {
+        // Si la IRQ provino del esclavo, ambos PIC deben recibir el EOI.
+        if vector >= OFFSET_ESCLAVO {
+            Port::<u8>::new(CMD_ESCLAVO).write(EOI);
+        }
+        Port::<u8>::new(CMD_MAESTRO).write(EOI);
+    }
+}
+
+/// Vector de la IDT que corresponde a una linea de IRQ (0..15). El remapeo dejo
+/// las 16 lineas del par 8259 en vectores contiguos desde `OFFSET_MAESTRO`: la
+/// IRQ8 cae en `OFFSET_ESCLAVO`, que es justo `OFFSET_MAESTRO + 8`.
+pub fn vector_irq(irq: u8) -> u8 {
+    OFFSET_MAESTRO + irq
+}
+
+/// Levanta la mascara de una linea de IRQ — el PIC empezara a emitirla. Si la
+/// linea vive en el PIC esclavo (8..15), abre tambien la cascada del maestro
+/// (la IRQ2), sin la cual el esclavo jamas alcanzaria a la CPU.
+///
+/// Debe invocarse en el arranque, antes de habilitar las interrupciones.
+pub fn desenmascarar(irq: u8) {
+    // SEGURIDAD: 0x21 y 0xA1 son los puertos de mascara del par 8259 en la
+    // arquitectura PC; leer-modificar-escribir es la via de tocar una linea
+    // sola sin perturbar a las demas.
+    unsafe {
+        if irq < 8 {
+            let mut datos = Port::<u8>::new(DATOS_MAESTRO);
+            let mascara = datos.read();
+            datos.write(mascara & !(1 << irq));
+        } else {
+            let mut datos_e = Port::<u8>::new(DATOS_ESCLAVO);
+            let mascara_e = datos_e.read();
+            datos_e.write(mascara_e & !(1 << (irq - 8)));
+            // La cascada: el esclavo entrega sus IRQ al maestro por la IRQ2.
+            let mut datos_m = Port::<u8>::new(DATOS_MAESTRO);
+            let mascara_m = datos_m.read();
+            datos_m.write(mascara_m & !(1 << 2));
+        }
+    }
+}

renaser/kernel/src/sync.rs

@@ -0,0 +1,29 @@
+// =============================================================================
+//  renaser :: kernel/src/sync.rs — la celda de inicializacion unica
+// -----------------------------------------------------------------------------
+//  Las estructuras globales del kernel (GDT, TSS, IDT, el heap...) nacen una
+//  sola vez, durante el arranque secuencial y de un solo hilo, y despues solo
+//  se leen. `CeldaSync` envuelve ese unico `unsafe` en una abstraccion comun:
+//  un contrato de unicidad que el codigo de arranque garantiza por construccion.
+// =============================================================================
+
+use core::cell::UnsafeCell;
+
+/// Celda `Sync` para estado global de inicializacion unica.
+pub(crate) struct CeldaSync<T>(UnsafeCell<T>);
+
+// SEGURIDAD: cada celda se escribe una sola vez, durante el arranque, antes de
+// que existan interrupciones o concurrencia; despues es de solo lectura.
+unsafe impl<T> Sync for CeldaSync<T> {}
+
+impl<T> CeldaSync<T> {
+    /// Crea una celda con su valor inicial.
+    pub(crate) const fn nueva(valor: T) -> Self {
+        CeldaSync(UnsafeCell::new(valor))
+    }
+
+    /// Puntero crudo al contenido. Quien lo usa asume el contrato de unicidad.
+    pub(crate) fn puntero(&self) -> *mut T {
+        self.0.get()
+    }
+}

renaser/kernel/src/texto.rs

@@ -0,0 +1,36 @@
+// =============================================================================
+//  renaser :: kernel/src/texto.rs — Fase 3 :: el texto como caso del dibujo
+// -----------------------------------------------------------------------------
+//  Con el heap activo, el texto deja de ser un mapa de bits estatico. Una
+//  tipografia vectorial se empotra en el binario y se rasteriza glifo a glifo,
+//  bajo demanda: el texto se vuelve, literalmente, un caso particular del
+//  dibujo — la promesa fundacional de renaser.
+// =============================================================================
+
+use alloc::vec::Vec;
+
+use fontdue::{Font, FontSettings, Metrics};
+use spin::Once;
+
+/// La tipografia vectorial, empotrada en el propio binario del kernel.
+static FUENTE_TTF: &[u8] = include_bytes!("../assets/font.ttf");
+
+/// La fuente ya analizada. Se funde una sola vez, tras activar el heap.
+static FUENTE: Once<Font> = Once::new();
+
+/// Analiza la tipografia empotrada. Requiere el heap ya activo.
+pub fn init() {
+    FUENTE.call_once(|| {
+        Font::from_bytes(FUENTE_TTF, FontSettings::default())
+            .expect("renaser :: la tipografia empotrada es invalida")
+    });
+}
+
+/// Rasteriza un glifo al vuelo: devuelve sus metricas de colocacion y un mapa
+/// de cobertura (un byte de opacidad, 0..=255, por cada pixel del glifo).
+pub fn rasterizar(caracter: char, tam_px: f32) -> (Metrics, Vec<u8>) {
+    FUENTE
+        .get()
+        .expect("renaser :: la tipografia no fue fundida")
+        .rasterize(caracter, tam_px)
+}

renaser/kernel/src/wasm/env.rs

@@ -0,0 +1,349 @@
+// =============================================================================
+//  renaser :: kernel/src/wasm/env.rs — Fase 4/5/6 :: la matriz de capacidades
+// -----------------------------------------------------------------------------
+//  El aislamiento de renaser no descansa en `int 0x80` ni en `sysenter`: no hay
+//  vectores de syscall. Una aplicacion WASM solo puede hacer aquello para lo
+//  que el kernel le haya inyectado una FUNCION DEL HOST. Esta matriz concede:
+//
+//    * sys_render_frame      — componer un fotograma en su region de pantalla;
+//    * sys_get_scancode      — consultar su canal de teclado;
+//    * sys_object_put        — grabar un objeto en el grafo (Fase 6.1c);
+//    * sys_object_datos      — leer la carga util de un objeto;
+//    * sys_object_hijo       — recorrer las aristas del DAG;
+//    * sys_object_raiz       — leer la raiz del grafo;
+//    * sys_object_fijar_raiz — coronar un objeto como raiz.
+//
+//  GUARDARRAIL: el kernel valida MATEMATICAMENTE todo puntero que el modulo le
+//  entrega contra los limites reales de su memoria lineal. No se confia en que
+//  el runtime lo haga; se verifica aqui, antes de leer o escribir un solo byte.
+//
+//  DOS CLASES DE FALLO. Un puntero fuera de limites es CULPA DE LA APP: se
+//  devuelve un `Error` que la ABORTA (el kernel la captura y la desaloja). Un
+//  fallo del almacenamiento —disco, objeto inexistente— NO es culpa de la app:
+//  se le devuelve un codigo de error negativo, y la app decide que hacer.
+// =============================================================================
+
+use wasmi::{Caller, Error, Extern, Linker, Memory, StoreLimits};
+
+use crate::almacen::Hash;
+use crate::async_system::teclado::CanalTeclado;
+use crate::grafico::RegionPantalla;
+
+/// El estado del host adscrito al `Store` de una aplicacion: cuanto necesita
+/// una capacidad para servir a ESA app y a ninguna otra — su region de pantalla,
+/// su canal de teclado y sus cuotas de recursos. Dos apps jamas comparten nada.
+pub(crate) struct ContextoCapacidades {
+    /// La sub-region de pantalla asignada a la aplicacion.
+    pub(crate) region: RegionPantalla,
+    /// El canal de teclado propio de la aplicacion.
+    pub(crate) canal: CanalTeclado,
+    /// El techo de recursos de la aplicacion — hoy, su memoria lineal maxima.
+    /// `wasmi` lo consulta en cada `memory.grow` via `Store::limiter`.
+    pub(crate) limites: StoreLimits,
+}
+
+/// Recupera la memoria lineal exportada por el modulo. Que no la exporte es un
+/// modulo mal formado: se aborta.
+fn obtener_memoria(caller: &Caller<'_, ContextoCapacidades>) -> Result<Memory, Error> {
+    caller
+        .get_export("memory")
+        .and_then(Extern::into_memory)
+        .ok_or_else(|| Error::new("WASM :: el modulo no exporta su memoria lineal"))
+}
+
+/// VALIDACION INFRANQUEABLE DE LIMITES. Comprueba que `[ptr, ptr + len)` cae
+/// entera dentro de la memoria lineal `m` y devuelve ese sub-slice. Un rango
+/// que se desborde aborta la app — el `Error` se traduce en una trampa de WASM.
+fn rango<'a>(m: &'a [u8], ptr: u32, len: usize, fallo: &'static str) -> Result<&'a [u8], Error> {
+    let inicio = ptr as usize;
+    match inicio.checked_add(len) {
+        Some(fin) if fin <= m.len() => Ok(&m[inicio..fin]),
+        _ => Err(Error::new(fallo)),
+    }
+}
+
+/// Lee un hash de 32 bytes de la memoria lineal, con sus limites verificados.
+fn leer_hash(m: &[u8], ptr: u32, fallo: &'static str) -> Result<Hash, Error> {
+    let bytes = rango(m, ptr, 32, fallo)?;
+    let mut hash = [0u8; 32];
+    hash.copy_from_slice(bytes);
+    Ok(hash)
+}
+
+/// Inyecta en el enlazador la matriz de capacidades del modulo WASM. Todo lo
+/// que no se defina aqui le queda, al modulo, fisicamente fuera de alcance.
+///
+/// Devuelve `Err` si una capacidad no se pudo enlazar — un fallo del kernel,
+/// no de la app; aun asi se propaga como `Result` para no incendiar nada.
+pub(crate) fn enlazar_capacidades(
+    enlazador: &mut Linker<ContextoCapacidades>,
+) -> Result<(), Error> {
+    // --- CAPACIDAD 1 :: sys_render_frame(ptr, len) ---
+    // El modulo entrega (ptr, len) hacia su PROPIA memoria lineal; el kernel
+    // valida esos limites y, solo entonces, compone el fotograma DENTRO de la
+    // region asignada a la app.
+    enlazador.func_wrap(
+        "renaser",
+        "sys_render_frame",
+        |caller: Caller<'_, ContextoCapacidades>, ptr: u32, len: u32| -> Result<(), Error> {
+            let region = caller.data().region;
+
+            // El fotograma debe medir EXACTAMENTE los pixeles de la region. Un
+            // tamaño distinto delata a una app que pinta fuera de su ventana:
+            // se aborta antes de tocar un byte.
+            let esperado = region.pixeles() * 4;
+            if len as usize != esperado {
+                return Err(Error::new(
+                    "WASM :: sys_render_frame con un fotograma ajeno a la region asignada",
+                ));
+            }
+
+            let memoria = obtener_memoria(&caller)?;
+            let datos: &[u8] = memoria.data(&caller);
+
+            // VALIDACION INFRANQUEABLE: si (ptr, len) se sale de la memoria
+            // lineal del modulo, se aborta la app —no el kernel—.
+            let marco = rango(
+                datos,
+                ptr,
+                len as usize,
+                "WASM :: sys_render_frame desbordo la memoria lineal del modulo",
+            )?;
+
+            // Limites verificados: la region es segura de leer y componer.
+            crate::volcar_marco_wasm(region, marco);
+            Ok(())
+        },
+    )?;
+
+    // --- CAPACIDAD 2 :: sys_get_scancode() -> u32 ---
+    // Expone, sin bloquear, el siguiente scancode del canal PROPIO de la app.
+    enlazador.func_wrap(
+        "renaser",
+        "sys_get_scancode",
+        |caller: Caller<'_, ContextoCapacidades>| -> u32 {
+            caller.data().canal.pop().unwrap_or(0) as u32
+        },
+    )?;
+
+    // --- CAPACIDAD 3 :: sys_object_put(datos, datos_len, hijos, hijos_cnt, salida) -> i32 ---
+    // Graba un objeto en el grafo. El modulo entrega, en su memoria lineal, la
+    // carga util y un arreglo de `hijos_cnt` hashes de 32 bytes (las aristas).
+    // El kernel escribe el hash resultante —la identidad del objeto— en
+    // `salida`. Devuelve 0 si el objeto se grabo (o ya existia), -1 si el
+    // almacenamiento fallo.
+    enlazador.func_wrap(
+        "renaser",
+        "sys_object_put",
+        |mut caller: Caller<'_, ContextoCapacidades>,
+         datos_ptr: u32,
+         datos_len: u32,
+         hijos_ptr: u32,
+         hijos_cnt: u32,
+         salida: u32|
+         -> Result<i32, Error> {
+            let memoria = obtener_memoria(&caller)?;
+
+            // --- Leer las entradas de la memoria lineal, con limites firmes. ---
+            let (datos, hijos) = {
+                let m = memoria.data(&caller);
+
+                let datos = rango(
+                    m,
+                    datos_ptr,
+                    datos_len as usize,
+                    "WASM :: sys_object_put desbordo la memoria lineal (datos)",
+                )?
+                .to_vec();
+
+                // El arreglo de hijos: `hijos_cnt` hashes contiguos de 32 bytes.
+                let bytes_hijos = (hijos_cnt as usize).checked_mul(32).ok_or_else(|| {
+                    Error::new("WASM :: sys_object_put con un conteo de hijos imposible")
+                })?;
+                let crudo = rango(
+                    m,
+                    hijos_ptr,
+                    bytes_hijos,
+                    "WASM :: sys_object_put desbordo la memoria lineal (hijos)",
+                )?;
+                let mut hijos: alloc::vec::Vec<Hash> =
+                    alloc::vec::Vec::with_capacity(hijos_cnt as usize);
+                for trozo in crudo.chunks_exact(32) {
+                    let mut h = [0u8; 32];
+                    h.copy_from_slice(trozo);
+                    hijos.push(h);
+                }
+
+                // Verificar que el hash de salida cabe ANTES de tocar el disco.
+                rango(
+                    m,
+                    salida,
+                    32,
+                    "WASM :: sys_object_put desbordo la memoria lineal (salida)",
+                )?;
+
+                (datos, hijos)
+            };
+
+            // --- Grabar. Un fallo del almacen NO es culpa de la app: -1. ---
+            match crate::almacen::almacenar(datos, hijos) {
+                Ok(hash) => {
+                    let m = memoria.data_mut(&mut caller);
+                    m[salida as usize..salida as usize + 32].copy_from_slice(&hash);
+                    Ok(0)
+                }
+                Err(_) => Ok(-1),
+            }
+        },
+    )?;
+
+    // --- CAPACIDAD 4 :: sys_object_datos(hash, salida, capacidad) -> i32 ---
+    // Copia la carga util del objeto `hash` en `salida`. Devuelve el numero de
+    // bytes copiados, o -1 si el objeto no existe, -2 si `capacidad` no basta,
+    // -3 si el almacenamiento fallo.
+    enlazador.func_wrap(
+        "renaser",
+        "sys_object_datos",
+        |mut caller: Caller<'_, ContextoCapacidades>,
+         hash_ptr: u32,
+         salida: u32,
+         capacidad: u32|
+         -> Result<i32, Error> {
+            let memoria = obtener_memoria(&caller)?;
+
+            let hash = {
+                let m = memoria.data(&caller);
+                leer_hash(
+                    m,
+                    hash_ptr,
+                    "WASM :: sys_object_datos desbordo la memoria lineal (hash)",
+                )?
+            };
+
+            let objeto = match crate::almacen::recuperar(&hash) {
+                Ok(Some(objeto)) => objeto,
+                Ok(None) => return Ok(-1),
+                Err(_) => return Ok(-3),
+            };
+            if objeto.datos.len() > capacidad as usize {
+                return Ok(-2);
+            }
+
+            // Verificar que el destino cabe, y solo entonces copiar.
+            {
+                let m = memoria.data(&caller);
+                rango(
+                    m,
+                    salida,
+                    objeto.datos.len(),
+                    "WASM :: sys_object_datos desbordo la memoria lineal (salida)",
+                )?;
+            }
+            let n = objeto.datos.len();
+            let m = memoria.data_mut(&mut caller);
+            m[salida as usize..salida as usize + n].copy_from_slice(&objeto.datos);
+            Ok(n as i32)
+        },
+    )?;
+
+    // --- CAPACIDAD 5 :: sys_object_hijo(hash, indice, salida) -> i32 ---
+    // Recorre las aristas del DAG. Devuelve el NUMERO de hijos del objeto
+    // `hash`; si `indice` es valido, ademas escribe el hash de ese hijo en
+    // `salida`. Devuelve -1 si el objeto no existe, -3 si el almacen fallo.
+    enlazador.func_wrap(
+        "renaser",
+        "sys_object_hijo",
+        |mut caller: Caller<'_, ContextoCapacidades>,
+         hash_ptr: u32,
+         indice: u32,
+         salida: u32|
+         -> Result<i32, Error> {
+            let memoria = obtener_memoria(&caller)?;
+
+            let hash = {
+                let m = memoria.data(&caller);
+                leer_hash(
+                    m,
+                    hash_ptr,
+                    "WASM :: sys_object_hijo desbordo la memoria lineal (hash)",
+                )?
+            };
+
+            let objeto = match crate::almacen::recuperar(&hash) {
+                Ok(Some(objeto)) => objeto,
+                Ok(None) => return Ok(-1),
+                Err(_) => return Ok(-3),
+            };
+            let total = objeto.hijos.len();
+
+            // Si el indice apunta a un hijo real, entregar su hash.
+            if let Some(hijo) = objeto.hijos.get(indice as usize) {
+                {
+                    let m = memoria.data(&caller);
+                    rango(
+                        m,
+                        salida,
+                        32,
+                        "WASM :: sys_object_hijo desbordo la memoria lineal (salida)",
+                    )?;
+                }
+                let m = memoria.data_mut(&mut caller);
+                m[salida as usize..salida as usize + 32].copy_from_slice(hijo);
+            }
+            Ok(total as i32)
+        },
+    )?;
+
+    // --- CAPACIDAD 6 :: sys_object_raiz(salida) -> i32 ---
+    // Escribe en `salida` el hash de la raiz del grafo. Devuelve 1 si hay
+    // raiz, 0 si el grafo aun no tiene ninguna.
+    enlazador.func_wrap(
+        "renaser",
+        "sys_object_raiz",
+        |mut caller: Caller<'_, ContextoCapacidades>, salida: u32| -> Result<i32, Error> {
+            let memoria = obtener_memoria(&caller)?;
+            match crate::almacen::raiz() {
+                Some(hash) => {
+                    {
+                        let m = memoria.data(&caller);
+                        rango(
+                            m,
+                            salida,
+                            32,
+                            "WASM :: sys_object_raiz desbordo la memoria lineal (salida)",
+                        )?;
+                    }
+                    let m = memoria.data_mut(&mut caller);
+                    m[salida as usize..salida as usize + 32].copy_from_slice(&hash);
+                    Ok(1)
+                }
+                None => Ok(0),
+            }
+        },
+    )?;
+
+    // --- CAPACIDAD 7 :: sys_object_fijar_raiz(hash) -> i32 ---
+    // Corona el objeto `hash` como raiz del grafo. Devuelve 0 si se logro, -3
+    // si el almacenamiento fallo.
+    enlazador.func_wrap(
+        "renaser",
+        "sys_object_fijar_raiz",
+        |caller: Caller<'_, ContextoCapacidades>, hash_ptr: u32| -> Result<i32, Error> {
+            let memoria = obtener_memoria(&caller)?;
+            let hash = {
+                let m = memoria.data(&caller);
+                leer_hash(
+                    m,
+                    hash_ptr,
+                    "WASM :: sys_object_fijar_raiz desbordo la memoria lineal (hash)",
+                )?
+            };
+            match crate::almacen::fijar_raiz(hash) {
+                Ok(()) => Ok(0),
+                Err(_) => Ok(-3),
+            }
+        },
+    )?;
+
+    Ok(())
+}

renaser/kernel/src/wasm/mod.rs

@@ -0,0 +1,200 @@
+// =============================================================================
+//  renaser :: kernel/src/wasm — Fase 4/5 :: el escudo de aislamiento (WASM)
+// -----------------------------------------------------------------------------
+//  Aqui renaser sustituye las costosas fronteras de hardware (la MMU, los
+//  anillos de la CPU) por limites MATEMATICOS sobre el bytecode. Una aplicacion
+//  WebAssembly se ejecuta en su propia memoria lineal; sus unicas puertas al
+//  exterior son las capacidades que el enlazador del host le concede. Lo que
+//  no este importado no existe: no hay camino fisico para ejecutarlo.
+//
+//  FASE 5 :: el aislamiento deja de ser solo ESPACIAL (memoria) y pasa a ser
+//  tambien TEMPORAL (tiempo de CPU). Cada `tick` se ejecuta con un presupuesto
+//  estricto de COMBUSTIBLE (fuel): si una app lo agota —un bucle infinito, un
+//  trabajo desmedido—, el runtime lanza una trampa, el kernel recupera el mando
+//  y la desaloja. Ningun modulo, por discolo que sea, secuestra el procesador.
+// =============================================================================
+
+pub mod env;
+
+use wasmi::{
+    CompilationMode, Config, Engine, Linker, Module, Store, StoreLimitsBuilder, TrapCode, TypedFunc,
+};
+
+use crate::grafico::{Color, RegionPantalla};
+use env::ContextoCapacidades;
+
+/// Combustible concedido a `init`. Cubre con holgura el pintado inicial del
+/// fondo de una region a pantalla casi completa — un gasto unico, de arranque.
+const FUEL_ARRANQUE: u64 = 20_000_000;
+
+/// Combustible concedido a cada `tick`. Sobra para un fotograma honesto (unos
+/// cientos de miles de operaciones); una app en bucle infinito lo agota en
+/// milisegundos y es desalojada. Este numero ES el techo temporal del userspace.
+const FUEL_FOTOGRAMA: u64 = 2_000_000;
+
+/// Techo de memoria lineal por aplicacion: 4 MiB. Un modulo que intente crecer
+/// su memoria mas alla es desalojado — el aislamiento ESPACIAL del userspace,
+/// gemelo del techo TEMPORAL que impone el combustible.
+const TECHO_MEMORIA: usize = 4 * 1024 * 1024;
+
+/// Por que el kernel da por terminada —desaloja— una aplicacion WASM.
+#[derive(Clone, Copy)]
+pub enum FallaApp {
+    /// El modulo no se pudo cargar, validar, enlazar o instanciar.
+    Carga,
+    /// La aplicacion agoto su combustible dentro de un `tick`: bucle infinito
+    /// o trabajo desmedido. El guardarrail TEMPORAL en accion.
+    SinCombustible,
+    /// La aplicacion intento crecer su memoria lineal mas alla de su cuota.
+    /// El guardarrail ESPACIAL en accion.
+    SinMemoria,
+    /// La aplicacion ejecuto una trampa: acceso fuera de limites, instruccion
+    /// `unreachable`, una capacidad violada... su propio codigo la abortó.
+    Trampa,
+}
+
+impl FallaApp {
+    /// El color de la baliza de desalojo segun la causa de la falla: amarillo
+    /// palido si reviento su techo de memoria, purpura para cualquier otra.
+    pub fn color_baliza(self) -> Color {
+        match self {
+            FallaApp::SinMemoria => Color::DESALOJO_MEMORIA,
+            _ => Color::DESALOJO,
+        }
+    }
+}
+
+/// Una aplicacion WebAssembly viva: su estado PERSISTE entre fotogramas. A
+/// diferencia de la Fase 4 —que instanciaba y cedia el control de un gesto—,
+/// aqui la instancia se conserva y el kernel la hace avanzar `tick` a `tick`.
+pub struct AplicacionWasm {
+    /// El almacen: todo el estado de ESTA instancia — su memoria lineal, sus
+    /// globales y el contexto de capacidades con su region de pantalla.
+    almacen: Store<ContextoCapacidades>,
+    /// El punto de entrada de fotograma, ya resuelto y con seguridad de tipos.
+    /// `TypedFunc` es un asa autosuficiente dentro del `Store`: conservada esta,
+    /// el handle de la `Instance` no aporta nada y no se retiene.
+    func_tick: TypedFunc<(), ()>,
+    /// La region de pantalla de la app — su ventana, y donde se tatua su baliza
+    /// de desalojo si llega a fallar.
+    region: RegionPantalla,
+}
+
+impl AplicacionWasm {
+    /// Carga, valida, instancia y arranca una aplicacion WASM aislada, ligada a
+    /// una region de pantalla. Si algo falla en el camino, se devuelve la falla
+    /// en lugar de incendiar el kernel.
+    ///
+    /// El nuevo ABI del userspace exige dos exportaciones: `init` —invocada una
+    /// sola vez, aqui— y `tick` —un fotograma de trabajo, invocada despues por
+    /// el reactor en cada pulso del reloj.
+    pub fn cargar(bytecode: &[u8], region: RegionPantalla) -> Result<AplicacionWasm, FallaApp> {
+        // 1. El motor, con metricas de combustible y compilacion ANTICIPADA: la
+        //    traduccion del modulo ocurre ahora, de modo que el `fuel` mida
+        //    despues solo EJECUCION, jamas compilacion diferida.
+        let mut config = Config::default();
+        config.consume_fuel(true);
+        config.compilation_mode(CompilationMode::Eager);
+        let motor = Engine::new(&config);
+
+        // 2. Validar y traducir el modulo — ya instrumentado con fuel.
+        let modulo = Module::new(&motor, bytecode).map_err(|_| FallaApp::Carga)?;
+
+        // 3. El almacen, con el contexto de capacidades de ESTA app: su region
+        //    de pantalla, su canal de teclado y su techo de memoria. El canal
+        //    se crea ahora pero se inscribe en la difusion de la IRQ1 al final,
+        //    ya con la app cargada: una carga fallida no deja canales huerfanos.
+        let canal = crate::async_system::teclado::crear_canal();
+        let limites = StoreLimitsBuilder::new()
+            .memory_size(TECHO_MEMORIA)
+            // Una expansion denegada se convierte en TRAMPA, no en un -1 que la
+            // app pudiera ignorar: asi el kernel la captura y la desaloja.
+            .trap_on_grow_failure(true)
+            .build();
+        let mut almacen = Store::new(
+            &motor,
+            ContextoCapacidades {
+                region,
+                canal,
+                limites,
+            },
+        );
+        // Ligar el limitador de recursos: `wasmi` lo consultara en cada
+        // `memory.grow`, tambien durante la instanciacion.
+        almacen.limiter(|contexto| &mut contexto.limites);
+        // Dotar de combustible ANTES de instanciar: la instanciacion no debe
+        // quedarse a cero y abortar.
+        almacen.set_fuel(FUEL_ARRANQUE).map_err(|_| FallaApp::Carga)?;
+
+        // 4. El enlazador y la matriz de capacidades (ver `env`).
+        let mut enlazador: Linker<ContextoCapacidades> = Linker::new(&motor);
+        env::enlazar_capacidades(&mut enlazador).map_err(|_| FallaApp::Carga)?;
+
+        // 5. Instanciar, resolviendo las importaciones contra las capacidades.
+        let instancia = enlazador
+            .instantiate_and_start(&mut almacen, &modulo)
+            .map_err(|_| FallaApp::Carga)?;
+
+        // 6. Resolver los dos puntos del ABI de fotograma: `init` y `tick`.
+        let func_init = instancia
+            .get_typed_func::<(), ()>(&almacen, "init")
+            .map_err(|_| FallaApp::Carga)?;
+        let func_tick = instancia
+            .get_typed_func::<(), ()>(&almacen, "tick")
+            .map_err(|_| FallaApp::Carga)?;
+
+        // 7. Arranque unico: `init` prepara el estado inicial de la aplicacion.
+        almacen.set_fuel(FUEL_ARRANQUE).map_err(|_| FallaApp::Carga)?;
+        func_init
+            .call(&mut almacen, ())
+            .map_err(|_| FallaApp::Carga)?;
+
+        // 8. Con la app ya cargada e instanciada, inscribir su canal de teclado
+        //    en la difusion de la IRQ1: desde aqui recibe cada pulsacion.
+        crate::async_system::teclado::registrar_canal(&almacen.data().canal);
+
+        Ok(AplicacionWasm {
+            almacen,
+            func_tick,
+            region,
+        })
+    }
+
+    /// Hace avanzar la aplicacion un fotograma. Recarga su presupuesto de
+    /// combustible y le cede el control con `tick`. Si la app lo agota o ejecuta
+    /// una trampa, el kernel recupera el mando y la falla se devuelve para que
+    /// la tarea proceda al desalojo. El kernel nunca pierde el control.
+    pub fn tick(&mut self) -> Result<(), FallaApp> {
+        // Recargar el deposito: cada fotograma parte con su techo intacto.
+        self.almacen
+            .set_fuel(FUEL_FOTOGRAMA)
+            .map_err(|_| FallaApp::Trampa)?;
+
+        match self.func_tick.call(&mut self.almacen, ()) {
+            Ok(()) => Ok(()),
+            // `as_trap_code` da un codigo publico y univoco para cada causa:
+            // `OutOfFuel` pliega toda variante de agotamiento de combustible;
+            // `GrowthOperationLimited` es la cuota de memoria denegada.
+            Err(error) => match error.as_trap_code() {
+                Some(TrapCode::OutOfFuel) => Err(FallaApp::SinCombustible),
+                Some(TrapCode::GrowthOperationLimited) => Err(FallaApp::SinMemoria),
+                _ => Err(FallaApp::Trampa),
+            },
+        }
+    }
+
+    /// La region de pantalla asignada a la aplicacion.
+    pub fn region(&self) -> RegionPantalla {
+        self.region
+    }
+}
+
+/// Reconciliacion del ciclo de vida. Cuando una `AplicacionWasm` muere —porque
+/// fue desalojada y su tarea concluyo—, su canal de teclado debe darse de baja
+/// de la difusion de la IRQ1. Sin esto, el manejador de interrupciones seguiria
+/// empujando scancodes a una cola muerta: una fuga lenta pero segura.
+impl Drop for AplicacionWasm {
+    fn drop(&mut self) {
+        crate::async_system::teclado::cerrar_canal(&self.almacen.data().canal);
+    }
+}

renaser/rust-toolchain.toml

@@ -0,0 +1,14 @@
+# =============================================================================
+#  renaser :: fijacion del toolchain
+# -----------------------------------------------------------------------------
+#  Nightly por dos razones que PERSISTEN: las dependencias de artefacto
+#  (`-Zbindeps`) y el script de construccion de la crate `bootloader`, que
+#  compila su propio cargador UEFI/BIOS y necesita `rust-src` + `llvm-tools`.
+#  El kernel en si ya NO necesita `build-std`: usa el target nativo precompilado.
+# =============================================================================
+
+[toolchain]
+channel = "nightly"
+components = ["rust-src", "llvm-tools", "rustfmt", "clippy"]
+targets = ["x86_64-unknown-none", "x86_64-unknown-uefi"]
+profile = "minimal"