restructure: rsnix kernel + shell crate + rsdos entry point

Architecture:
  rs-dos/  (workspace root, was raisernics/)
  ├── rsnix/     — kernel lib crate (uefi, serial, gop, ps2, interrupts, memory)
  ├── shell/     — shell lib crate (prompt, commands, line input)
  ├── rsdos/     — binary crate (efi_main, init, panic handler)
  └── rsboot/    — future git submodule

No functional changes — boots to shell prompt identically.
Version auto-pulled from Cargo.toml via env!("CARGO_PKG_VERSION").

18 files changed, 229 insertions, 230 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 611d52a..1d697fc 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3,5 +3,20 @@
 version = 4
 
 [[package]]
-name = "raisernics"
+name = "rsdos"
 version = "0.2.0"
+dependencies = [
+ "rsnix",
+ "shell",
+]
+
+[[package]]
+name = "rsnix"
+version = "0.2.0"
+
+[[package]]
+name = "shell"
+version = "0.2.0"
+dependencies = [
+ "rsnix",
+]
diff --git a/Cargo.toml b/Cargo.toml
index d88efe3..14eaeff 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,10 +1,7 @@
-[package]
-name = "raisernics"
+[workspace]
+resolver = "2"
+members = ["rsnix", "shell", "rsdos"]
+
+[workspace.package]
 version = "0.2.0"
 edition = "2021"
-
-[profile.release]
-lto = true
-codegen-units = 1
-strip = "symbols"
-opt-level = "z"
diff --git a/Makefile b/Makefile
index 9f03f93..1fc4194 100644
--- a/Makefile
+++ b/Makefile
@@ -4,10 +4,10 @@ export TARGET=x86_64-unknown-uefi
 export PROFILE=debug
 export OUT_DIR=target/$(TARGET)/$(PROFILE)
 export ESP_DIR=esp
-export KERNEL=$(OUT_DIR)/raisernics.efi
+export KERNEL=$(OUT_DIR)/rsdos.efi
 export BZIMAGE=$(ESP_DIR)/bzImage
 export INITRD=$(ESP_DIR)/initramfs.cpio.gz
-export BOOTLOADER=../rng/rsbl/../build/bootloader/BOOTX64.EFI
+export BOOTLOADER=rsboot/rsboot.efi
 export OVMF=/usr/share/edk2/x64/OVMF.4m.fd
 export BOOT_EFI=$(ESP_DIR)/EFI/BOOT/BOOTX64.EFI
 
@@ -15,7 +15,7 @@ export BOOT_EFI=$(ESP_DIR)/EFI/BOOT/BOOTX64.EFI
 
 # ---- Build ---------------------------------------------------------------
 
-all: $(BZIMAGE) $(INITRD) $(BOOT_EFI)
+all: $(BZIMAGE) $(INITRD)
 
 release: PROFILE=release
 release: export PROFILE=release
@@ -26,16 +26,12 @@ release: all
 # shellcheck disable=SC2034
 CARGO_FLAGS=
 
-$(OUT_DIR)/raisernics.efi: $(shell find src -name '*.rs') Cargo.toml build.rs
-        cargo build --target $(TARGET) $(CARGO_FLAGS)
+$(OUT_DIR)/rsdos.efi: $(shell find rsnix shell rsdos -name '*.rs') Cargo.toml rsnix/Cargo.toml shell/Cargo.toml rsdos/Cargo.toml
+        cargo build --package rsdos --target $(TARGET) $(CARGO_FLAGS)
 
 $(BZIMAGE): $(KERNEL) | $(ESP_DIR)
         cp "$<" "$@"
 
-$(BOOT_EFI): $(BOOTLOADER) | $(ESP_DIR)
-        mkdir -p $(ESP_DIR)/EFI/BOOT
-        cp "$<" "$@"
-
 $(ESP_DIR):
         mkdir -p $(ESP_DIR)
 
@@ -95,7 +91,7 @@ run-image: all
 # ---- Disk image ----------------------------------------------------------
 
 image: all
-        ./tools/boot-image.sh raisernics.img
+        ./tools/boot-image.sh rs-dos.img
 
 # ---- Utilities -----------------------------------------------------------
 
@@ -104,14 +100,14 @@ fmt:
 
 clean:
         cargo clean
-        rm -rf $(ESP_DIR) raisernics.img
+        rm -rf $(ESP_DIR) rs-dos.img
 
 help:
-        @echo "raisernics — Make targets"
+        @echo "rs-dos — Make targets"
         @echo ""
         @echo "  make              build kernel + ESP (default)"
         @echo "  make release      build with --release (smaller binary)"
-        @echo "  make image        create bootable USB image (raisernics.img)"
+        @echo "  make image        create bootable USB image (rs-dos.img)"
         @echo "  make run          QEMU serial console (no graphics)"
         @echo "  make run-gui      QEMU with graphical window (GOP/PS2)"
         @echo "  make debug        QEMU + GDB stub on :1234"
diff --git a/rsdos/Cargo.toml b/rsdos/Cargo.toml
new file mode 100644
index 0000000..5bf83fe
--- /dev/null
+++ b/rsdos/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "rsdos"
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
+rsnix = { path = "../rsnix" }
+shell = { path = "../shell" }
diff --git a/rsdos/src/main.rs b/rsdos/src/main.rs
new file mode 100644
index 0000000..543556b
--- /dev/null
+++ b/rsdos/src/main.rs
@@ -0,0 +1,138 @@
+#![no_std]
+#![no_main]
+#![allow(static_mut_refs, unsafe_code)]
+
+use core::panic::PanicInfo;
+use rsnix::uefi::*;
+
+// ---------------------------------------------------------------------------
+// Panic handler
+// ---------------------------------------------------------------------------
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    use core::fmt::Write;
+    rsnix::serial::write_str("\r\n*** PANIC ***\r\n");
+    let _ = write!(&mut rsnix::serial::SerialWriter, "{}\r\n", info.message());
+    if let Some(loc) = info.location() {
+        let _ = write!(
+            &mut rsnix::serial::SerialWriter,
+            "  at {}:{}\r\n",
+            loc.file(),
+            loc.line()
+        );
+    }
+    loop {
+        unsafe {
+            core::arch::asm!("cli; hlt");
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// EFI entry point
+// ---------------------------------------------------------------------------
+#[no_mangle]
+pub extern "efiapi" fn efi_main(image_handle: Handle, system_table: *mut SystemTable) -> ! {
+    let st = unsafe { &mut *system_table };
+    let bs = unsafe { &mut *st.boot_services };
+    let con_out = unsafe { &mut *st.con_out };
+
+    // ---- Phase 1: UEFI boot services alive ----
+
+    // Print banner via UEFI console
+    unsafe {
+        let s = concat!("rsnix v", env!("CARGO_PKG_VERSION"), " booting..\n");
+        let bytes = s.as_bytes();
+        let mut buf: [u16; 48] = [0; 48];
+        for (i, &b) in bytes.iter().enumerate().take(47) {
+            buf[i] = b as u16;
+        }
+        (con_out.output_string)(con_out, buf.as_ptr());
+    }
+
+    rsnix::serial::init();
+    rsnix::serial_println!("=== rsnix boot ===");
+
+    // Stash the memory map
+    let map_key = match rsnix::memory::capture_memory_map(bs) {
+        Ok(k) => k,
+        Err(e) => {
+            rsnix::serial_println!("mem: capture_memory_map failed 0x{:x}", e);
+            0
+        }
+    };
+
+    // Locate GOP (Graphics Output Protocol)
+    let mut gop_interface: *mut core::ffi::c_void = core::ptr::null_mut();
+    let gop_guid = EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID;
+    let gop_result = unsafe {
+        (bs.locate_protocol)(
+            &gop_guid as *const Guid,
+            core::ptr::null_mut(),
+            &mut gop_interface,
+        )
+    };
+    if gop_result == EFI_SUCCESS {
+        let gop = unsafe { &mut *(gop_interface as *mut GraphicsOutputProtocol) };
+        rsnix::serial_println!("gop: framebuffer found");
+        rsnix::gop::init(gop);
+    } else {
+        rsnix::serial_println!("gop: not found (0x{:x})", gop_result);
+    }
+
+    // ExitBootServices — we now own the machine
+    if unsafe { (bs.exit_boot_services)(image_handle, map_key) } != EFI_SUCCESS {
+        rsnix::serial_println!("WARN: ExitBootServices failed, retrying...");
+        match rsnix::memory::refresh_and_exit(bs, image_handle) {
+            Ok(_) => {}
+            Err(e) => {
+                rsnix::serial_println!("FATAL: cannot ExitBootServices (0x{:x})", e);
+                loop {
+                    unsafe {
+                        core::arch::asm!("cli; hlt");
+                    }
+                }
+            }
+        }
+    }
+
+    // ---- Phase 2: Native mode ----
+    rsnix::serial::init();
+    rsnix::serial_println!("serial: COM1 115200 8N1");
+    rsnix::ps2::init();
+    rsnix::serial_println!("ps2: keyboard initialized");
+    rsnix::interrupts::init();
+    rsnix::serial_println!("intr: IDT loaded, PIC remapped, timer ~100 Hz");
+
+    dump_memory_summary();
+
+    rsnix::serial_println!("boot: entering shell");
+    shell::run();
+}
+
+// ---------------------------------------------------------------------------
+// Print a memory summary from the stashed memory map
+// ---------------------------------------------------------------------------
+fn dump_memory_summary() {
+    let (map, key) = rsnix::memory::get_map();
+    let mut conventional_4k = 0u64;
+    let mut addr_space_4k = 0u64;
+    for desc in map.iter() {
+        let pages = desc.number_of_pages;
+        addr_space_4k += pages;
+        if desc.kind == 7 {
+            conventional_4k += pages;
+        }
+    }
+    rsnix::serial_println!(
+        "mem: {} entries, key=0x{:x}, usable: {} KB ({} MB)",
+        map.len(),
+        key,
+        conventional_4k * 4,
+        (conventional_4k * 4) / 1024,
+    );
+    rsnix::serial_println!(
+        "mem: address space: {} MB (incl. PCIe MMIO)",
+        (addr_space_4k * 4) / 1024,
+    );
+}
diff --git a/rsnix/Cargo.toml b/rsnix/Cargo.toml
new file mode 100644
index 0000000..d8cd26b
--- /dev/null
+++ b/rsnix/Cargo.toml
@@ -0,0 +1,4 @@
+[package]
+name = "rsnix"
+version.workspace = true
+edition.workspace = true
diff --git a/build.rs b/rsnix/build.rs
index 35447e9..35447e9 100644
--- a/build.rs
+++ b/rsnix/build.rs
diff --git a/src/font.rs b/rsnix/src/font.rs
index e188513..e188513 100644
--- a/src/font.rs
+++ b/rsnix/src/font.rs
diff --git a/src/gop.rs b/rsnix/src/gop.rs
index 9645bb0..9645bb0 100644
--- a/src/gop.rs
+++ b/rsnix/src/gop.rs
diff --git a/src/interrupts.rs b/rsnix/src/interrupts.rs
index 90d5bbb..8f2acd7 100644
--- a/src/interrupts.rs
+++ b/rsnix/src/interrupts.rs
@@ -174,7 +174,7 @@ impl KeyBuf {
         let h = self.head.load(Ordering::Acquire);
         let next = t.wrapping_add(1);
         // Full if the distance between head and tail == capacity (256).
-        if next.wrapping_sub(h) as u16 > 255 {
+        if next.wrapping_sub(h) > 255 {
             return; // drop — ring is full
         }
         unsafe {
@@ -362,7 +362,7 @@ pub fn init() {
 
         // Build the IDTR pseudo-descriptor.
         IDTR = [
-            (256u16 * 16 - 1) as u16,      // limit = 256*16 - 1
+            ((256u16 * 16 - 1)),      // limit = 256*16 - 1
             idt_ptr as u16,                // base lo
             (idt_ptr as u64 >> 16) as u16, // base mid
             (idt_ptr as u64 >> 32) as u16, // base hi
diff --git a/rsnix/src/lib.rs b/rsnix/src/lib.rs
new file mode 100644
index 0000000..6c7fb3c
--- /dev/null
+++ b/rsnix/src/lib.rs
@@ -0,0 +1,11 @@
+#![no_std]
+
+extern crate alloc;
+
+pub mod uefi;
+pub mod serial;
+pub mod gop;
+pub mod font;
+pub mod ps2;
+pub mod interrupts;
+pub mod memory;
diff --git a/src/memory.rs b/rsnix/src/memory.rs
index d223f69..39fd88d 100644
--- a/src/memory.rs
+++ b/rsnix/src/memory.rs
@@ -85,7 +85,7 @@ pub fn capture_memory_map(bs: &BootServices) -> Result<usize, Status> {
     }
 
     // Round up to desc_size alignment
-    let buf_size = (buf_size + desc_size - 1) / desc_size * desc_size;
+    let buf_size = buf_size.div_ceil(desc_size) * desc_size;
 
     // If our static buffer is too small, fall back to pool (rare)
     if buf_size > unsafe { MAP_WORK_BUF.len() } {
diff --git a/src/ps2.rs b/rsnix/src/ps2.rs
index 4ea8b7a..b83a4e0 100644
--- a/src/ps2.rs
+++ b/rsnix/src/ps2.rs
@@ -346,11 +346,10 @@ fn update_modifiers(scancode: u8, pressed: bool, e0: bool) {
         (0x1D, true) => set_mod(state, MOD_RCTRL, pressed),
         (0x38, false) => set_mod(state, MOD_LALT, pressed),
         (0x38, true) => set_mod(state, MOD_RALT, pressed),
-        (0x3A, false) => {
-            if pressed {
+        (0x3A, false)
+            if pressed => {
                 state.modifiers ^= MOD_CAPS;
             }
-        }
         _ => {}
     }
 }
diff --git a/src/serial.rs b/rsnix/src/serial.rs
index 03fa570..03fa570 100644
--- a/src/serial.rs
+++ b/rsnix/src/serial.rs
diff --git a/src/uefi.rs b/rsnix/src/uefi.rs
index 2e3ed6b..2e3ed6b 100644
--- a/src/uefi.rs
+++ b/rsnix/src/uefi.rs
diff --git a/shell/Cargo.toml b/shell/Cargo.toml
new file mode 100644
index 0000000..9fd10bc
--- /dev/null
+++ b/shell/Cargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "shell"
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
+rsnix = { path = "../rsnix" }
diff --git a/src/shell.rs b/shell/src/lib.rs
index 8e4cb62..bdd79c6 100644
--- a/src/shell.rs
+++ b/shell/src/lib.rs
@@ -1,14 +1,24 @@
+#![no_std]
+
+extern crate alloc;
+
 /// Minimal command shell — reads from PS/2 keyboard, writes to GOP + serial.
-use crate::ps2::{self, KeyEvent};
-use crate::{gop_print, gop_println, serial_print, serial_println};
+use rsnix::ps2::{self, KeyEvent};
+use rsnix::{gop_print, gop_println, serial_print, serial_println};
 
 /// Maximum input line length.
 const LINE_BUF_SIZE: usize = 256;
 
 /// Run the shell forever.
 pub fn run() -> ! {
-    gop_println!("raisernics v{} — type 'help' for commands", env!("CARGO_PKG_VERSION"));
-    serial_println!("========== raisernics v{} ==========", env!("CARGO_PKG_VERSION"));
+    gop_println!(
+        "rs-dos v{} — type 'help' for commands",
+        env!("CARGO_PKG_VERSION")
+    );
+    serial_println!(
+        "========== rs-dos v{} ==========",
+        env!("CARGO_PKG_VERSION")
+    );
 
     loop {
         // Print prompt
@@ -53,32 +63,32 @@ fn read_line() -> heapless_str::String<LINE_BUF_SIZE> {
     loop {
         match ps2::poll_key() {
             KeyEvent::Enter => {
-                crate::gop::put_char('\n');
-                crate::serial::write_str("\r\n");
+                rsnix::gop::put_char('\n');
+                rsnix::serial::write_str("\r\n");
                 return buf;
             }
             KeyEvent::Char(c) if c.is_ascii_graphic() || c == ' ' => {
                 if buf.push(c).is_ok() {
-                    crate::gop::put_char(c);
+                    rsnix::gop::put_char(c);
                     // Echo to serial too
                     let mut s = [0u8; 4];
                     let s = c.encode_utf8(&mut s);
-                    crate::serial::write_str(s);
+                    rsnix::serial::write_str(s);
                 }
             }
             KeyEvent::Backspace => {
                 if buf.pop().is_some() {
                     // GOP backspace: move cursor back and erase
-                    crate::gop::put_char('\x08');
+                    rsnix::gop::put_char('\x08');
                     // Serial backspace: send BS SP BS (standard terminal protocol)
-                    crate::serial::write_str("\x08 \x08");
+                    rsnix::serial::write_str("\x08 \x08");
                 }
             }
             KeyEvent::Tab => {
                 for _ in 0..4 {
                     if buf.push(' ').is_ok() {
-                        crate::gop::put_char(' ');
-                        crate::serial::write_str(" ");
+                        rsnix::gop::put_char(' ');
+                        rsnix::serial::write_str(" ");
                     }
                 }
             }
@@ -120,14 +130,14 @@ fn cmd_echo(args: &str) {
 }
 
 fn cmd_clear() {
-    crate::gop::clear_screen();
+    rsnix::gop::clear_screen();
 }
 
 fn cmd_info() {
     // Test that the global allocator works: build a String on the heap
-    let mut s = alloc::string::String::from("raisernics v");
+    let mut s = alloc::string::String::from("rs-dos v");
     s.push_str(env!("CARGO_PKG_VERSION"));
-    s.push_str(" — RNG custom kernel");
+    s.push_str(" — rsnix kernel");
     gop_println!("{}", s);
     gop_println!("arch: x86_64, freestanding, no userspace");
     serial_println!("{}", s);
@@ -136,7 +146,7 @@ fn cmd_info() {
 }
 
 fn cmd_mem() {
-    let (map, key) = crate::memory::get_map();
+    let (map, key) = rsnix::memory::get_map();
 
     let mut total_kb = 0u64;
     let mut conventional_kb = 0u64;
diff --git a/src/main.rs b/src/main.rs
deleted file mode 100644
index 9a901f5..0000000
--- a/src/main.rs
+++ /dev/null
@@ -1,186 +0,0 @@
-#![no_std]
-#![no_main]
-#![allow(static_mut_refs, unsafe_code, dead_code, unused_doc_comments)]
-
-// SAFETY: single-core kernel, no preemption — static mut access is sound
-// Toy kernel: dead code and unused items during active development
-
-extern crate alloc;
-
-mod font;
-mod gop;
-mod interrupts;
-mod memory;
-mod ps2;
-mod serial;
-mod shell;
-mod uefi;
-
-use core::panic::PanicInfo;
-use uefi::*;
-
-// ---------------------------------------------------------------------------
-// Panic handler
-// ---------------------------------------------------------------------------
-#[panic_handler]
-fn panic(info: &PanicInfo) -> ! {
-    use core::fmt::Write;
-    serial::write_str("\r\n*** PANIC ***\r\n");
-    let _ = write!(&mut serial::SerialWriter, "{}\r\n", info.message());
-    if let Some(loc) = info.location() {
-        let _ = write!(
-            &mut serial::SerialWriter,
-            "  at {}:{}\r\n",
-            loc.file(),
-            loc.line()
-        );
-    }
-    loop {
-        unsafe {
-            core::arch::asm!("cli; hlt");
-        }
-    }
-}
-
-// ---------------------------------------------------------------------------
-// EFI entry point
-// ---------------------------------------------------------------------------
-#[no_mangle]
-pub extern "efiapi" fn efi_main(image_handle: Handle, system_table: *mut SystemTable) -> ! {
-    let st = unsafe { &mut *system_table };
-    let bs = unsafe { &mut *st.boot_services };
-    let con_out = unsafe { &mut *st.con_out };
-
-    // ---- Phase 1: UEFI boot services alive ----
-
-    // Print banner via UEFI console
-    unsafe {
-        let banner: [u16; 28] = [
-            'r' as u16, 'a' as u16, 'i' as u16, 's' as u16, 'e' as u16, 'r' as u16, 'n' as u16,
-            'i' as u16, 'c' as u16, 's' as u16, ' ' as u16, 'v' as u16, '0' as u16, '.' as u16,
-            '1' as u16, ' ' as u16, '-' as u16, ' ' as u16, 'b' as u16, 'o' as u16, 'o' as u16,
-            't' as u16, 'i' as u16, 'n' as u16, 'g' as u16, '.' as u16, '.' as u16, 0x0A,
-        ];
-        (con_out.output_string)(con_out, banner.as_ptr());
-    }
-
-    // Init serial early so we can debug-print before EBS
-    serial::init();
-
-    serial_println!("=== raisernics boot ===");
-
-    // Stash the memory map
-    let map_key = memory::capture_memory_map(bs);
-    let map_key = match map_key {
-        Ok(k) => k,
-        Err(e) => {
-            serial_println!("mem: capture_memory_map failed 0x{:x}", e);
-            0
-        }
-    };
-
-    // Locate GOP (Graphics Output Protocol)
-    let mut gop_interface: *mut core::ffi::c_void = core::ptr::null_mut();
-    let gop_guid = EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID;
-    let gop_result = unsafe {
-        (bs.locate_protocol)(
-            &gop_guid as *const Guid,
-            core::ptr::null_mut(),
-            &mut gop_interface,
-        )
-    };
-    if gop_result == EFI_SUCCESS {
-        let gop = unsafe { &mut *(gop_interface as *mut GraphicsOutputProtocol) };
-        serial_println!("gop: framebuffer found");
-        gop::init(gop);
-    } else {
-        serial_println!("gop: not found (0x{:x})", gop_result);
-    }
-
-    // ExitBootServices — we now own the machine
-    let ebs_result = unsafe { (bs.exit_boot_services)(image_handle, map_key) };
-    if ebs_result != EFI_SUCCESS {
-        // Memory map may have changed; try again with fresh map
-        // (This is the standard UEFI EBS retry dance.)
-        serial_println!(
-            "WARN: ExitBootServices failed (0x{:x}), retrying...",
-            ebs_result
-        );
-        let _map_key = match memory::refresh_and_exit(bs, image_handle) {
-            Ok(k) => k,
-            Err(e) => {
-                serial_println!("FATAL: cannot ExitBootServices (0x{:x})", e);
-                loop {
-                    unsafe {
-                        core::arch::asm!("cli; hlt");
-                    }
-                }
-            }
-        };
-    }
-
-    // ---- Phase 2: Native mode ----
-
-    serial::init();
-    serial_println!("serial: COM1 115200 8N1");
-
-    // PS/2 keyboard
-    ps2::init();
-    serial_println!("ps2: keyboard initialized");
-
-    // Interrupts — IDT, PIC, PIT timer, keyboard IRQ handler
-    interrupts::init();
-    serial_println!("intr: IDT loaded, PIC remapped, timer ~100 Hz");
-
-    // Memory: the bump allocator was set up during capture_memory_map.
-    // `alloc::Vec`, `alloc::String`, `format!` etc. are now usable.
-
-    // Print memory summary
-    dump_memory_summary();
-
-    serial_println!("boot: entering shell");
-    shell::run();
-}
-
-// ---------------------------------------------------------------------------
-// Print a memory summary from the stashed memory map
-// ---------------------------------------------------------------------------
-fn dump_memory_summary() {
-    let (map, key) = memory::get_map();
-    let mut conventional_4k = 0u64;
-    let mut addr_space_4k = 0u64;
-    for desc in map.iter() {
-        let pages = desc.number_of_pages;
-        addr_space_4k += pages;
-        if desc.kind == 7 {
-            conventional_4k += pages;
-        }
-    }
-    serial_println!(
-        "mem: {} entries, key=0x{:x}, usable: {} KB ({} MB)",
-        map.len(),
-        key,
-        conventional_4k * 4,
-        (conventional_4k * 4) / 1024,
-    );
-    serial_println!(
-        "mem: address space: {} MB (incl. PCIe MMIO)",
-        (addr_space_4k * 4) / 1024,
-    );
-}
-
-// ---------------------------------------------------------------------------
-// Helper: write a panic-proof string via UEFI console (used before serial)
-// ---------------------------------------------------------------------------
-#[allow(dead_code)]
-unsafe fn uefi_puts(con_out: *mut SimpleTextOutput, s: &str) {
-    // Simple ASCII → UEFI-CHAR16 conversion (stack buffer, panic-safe)
-    let mut buf: [u16; 128] = [0; 128];
-    let len = s.len().min(127);
-    for (i, &b) in s.as_bytes()[..len].iter().enumerate() {
-        buf[i] = b as u16;
-    }
-    buf[len] = 0x0A; // LF
-    let out = unsafe { &mut *con_out };
-    (out.output_string)(out, buf.as_ptr());
-}