feat(filebrowser): add delete button to toolbar, fix FAT32 delete/rename with raw sector scanning

- Add SYM_TRASH toolbar button wired to fb_delete_cb (was missing entirely)
- Filter '.' and '..' entries in fb_collect_cb so they never appear
- Rewrite deleteFile/deleteDir/renameFile to use raw sector scanning
  instead of getDirEntries linked-list indices (fixes  gap mismatch)
- Handle root directory correctly (use bootRecord^.rootCluster instead
  of assuming entry 0 is '.')

Dockerfile

@@ -6,7 +6,7 @@ ENV DEBIAN_FRONTEND=noninteractive
 RUN dpkg --add-architecture i386
 RUN apt-get update && apt-get install -y \
 	curl dos2unix wget git make nasm binutils xorriso grub-pc-bin gcc gcc-multilib \
-	python3 python3-pip && \
+	python3 python3-pip python3-pil && \
 	apt-get clean my room
 
 RUN pip3 install --no-cache-dir --break-system-packages "mkdocs>=1.6,<2" mkdocs-material

doc/src/core/core.panic.md

@@ -4,7 +4,9 @@ Architecture-agnostic kernel panic (BSOD) engine.
 
 ## Overview
 
-`core.panic` implements a graphical and serial kernel panic handler for the Asuro kernel. When a fatal condition is detected anywhere in the kernel, `panic` is called with a fault identifier, a human-readable description, and an optional CPU register snapshot. The unit outputs the fault information to the serial syslog for headless debugging and, if LVGL has been initialised, displays a graphical Blue Screen of Death (BSOD).
+`core.panic` implements a graphical and serial kernel panic handler for the Asuro kernel. When a fatal condition is detected anywhere in the kernel, `panic` is called with a fault identifier, a human-readable description, and an optional CPU register snapshot. All diagnostic sections (Fault Info, CPU Registers, Process Info, System Info, Call Stack) are mirrored to the serial syslog for headless debugging. If LVGL has been initialised, a graphical Blue Screen of Death (BSOD) is displayed.
+
+If the panic occurs inside the `gfxd` graphics-rendering process, LVGL state may be corrupt. In this case the unit falls back to rendering the panic screen directly to the VESA framebuffer using `driver.video.DrawString`, `driver.video.DrawHex`, and `driver.video.DrawInt`, bypassing LVGL entirely.
 
 The BSOD screen and all its LVGL widgets are pre-allocated at `init` time so that no dynamic LVGL allocation is needed when a panic fires. At panic time only label text is updated via `lv_label_set_text`, the pre-built screen is loaded, and a single render pass is forced. Text formatting uses static heap buffers and avoids calling any string library routines that might themselves fault.
 
@@ -16,7 +18,7 @@ If `init` has not been called before a panic (early boot panic), the unit gracef
 
 - `io.syslog` — serial fault output
 - `debug.tracer` — call-stack capture and freeze
-- `driver.video` — frame buffer flush
+- `driver.video` — frame buffer flush and text drawing (DrawString, DrawHex, DrawInt) for VESA fallback
 - `memory.heap` — buffer allocation
 - `driver.video.lvgl` — LVGL widget creation and rendering
 - `core.version` — version constants for the system info panel
@@ -24,6 +26,8 @@ If `init` has not been called before a panic (early boot panic), the unit gracef
 - `proc.types` — process state enumeration
 - `core.fmt.targa` — teapot TGA image decoding
 - `core.gfx.texture` — pixel buffer type
+- `core.strings` — string comparison for gfxd process detection
+- `core.gfx.color` — TRGB32 colour type for direct pixel drawing
 
 ## Constants
 
@@ -71,7 +75,7 @@ Creates the hidden BSOD LVGL screen and pre-allocates all widget objects and tex
 ```pascal
 procedure panic(fault : pchar; info : pchar; regs : PRegisterSnapshot);
 ```
-Triggers a kernel panic. Freezes the call-stack tracer, dumps fault information to syslog, and (if the BSOD screen is ready) displays the graphical panic screen. Then calls the registered halt procedure. Re-entrant calls are detected by a guard flag; if `panic` is called while a panic is already in progress, the system halts immediately without further output.
+Triggers a kernel panic. Freezes the call-stack tracer, dumps all diagnostic sections (Fault Info, CPU Registers, Process Info, System Info, Call Stack) to syslog, and displays the graphical panic screen. If the crash occurred in the `gfxd` process, LVGL is bypassed and the screen is rendered directly to the VESA framebuffer. Otherwise, if the LVGL BSOD screen is ready, it is used. Then calls the registered halt procedure. Re-entrant calls are detected by a guard flag; if `panic` is called while a panic is already in progress, the system halts immediately without further output.
 
 Parameters:
 - `fault` — short fault identifier string, e.g. `'arch.x86.fault.gpf'`.
@@ -93,3 +97,17 @@ The teapot image is loaded from a TGA binary linked into the kernel image via an
 All text formatting in the panic path uses a set of internal buffer-writing helpers (`writeHexToBuffer`, `writeStrToBuffer`, `writeIntToBuffer`) that do not call the kernel string library, making the panic path robust against faults in those subsystems.
 
 A compile-time switch `BSOD_ENABLE` gates the display path; if disabled, `panic` only writes to syslog and halts.
+
+### gfxd Crash Detection
+
+When `panic` is triggered, it checks whether the currently executing process is `gfxd` (the graphics daemon). If so, LVGL’s internal state may be corrupt (since `gfxd` drives the LVGL render pipeline), so the unit falls back to `showVESAFallbackScreen`. This procedure fills the screen with the BSOD background colour and renders all diagnostic sections using `driver.video.DrawString`, `driver.video.DrawHex`, and `driver.video.DrawInt` (which draw 8×16 bitmap font glyphs via `DrawPixel`). The layout mirrors the LVGL BSOD but uses a simpler single-column text format.
+
+### Syslog Output
+
+All five diagnostic sections are written to syslog in every panic, regardless of the display path:
+
+1. **Fault Info** — fault identifier and human-readable description
+2. **CPU Registers** — name/value pairs from the register snapshot
+3. **Process Info** — name, PID, parent PID, state, and priority of the current process
+4. **System Info** — kernel version, build date, compiler, revision, heap status, process count, uptime
+5. **Call Stack** — frozen tracer output

doc/src/core/core.strings.md

@@ -106,6 +106,12 @@ function intToString(i : uint32) : pchar;
 ```
 Returns a heap-allocated decimal string representation of `i`.
 
+### int64ToString
+```pascal
+function int64ToString(i : int64) : pchar;
+```
+Returns a heap-allocated decimal string representation of the signed 64-bit integer `i`. Negative values are prefixed with `'-'`.
+
 ### hexStringToInt
 ```pascal
 function hexStringToInt(str : pchar) : uint32;
@@ -118,6 +124,12 @@ function boolToString(b : boolean; ext : boolean) : pchar;
 ```
 Returns a heap-allocated string for the boolean `b`. When `ext` is `true`, returns `'true'` or `'false'`; when `false`, returns `'1'` or `'0'`.
 
+### doubleToStr
+```pascal
+function doubleToStr(d : Double) : pchar;
+```
+Returns a heap-allocated decimal string representation of the 64-bit floating-point value `d`. Integer values are emitted without a decimal point (e.g. `42`). Fractional values include up to 15 significant digits with trailing zeros removed. Very large or very small values use scientific notation (e.g. `1.5e+20`).
+
 ### UnitTest
 ```pascal
 procedure UnitTest;

doc/src/driver/video/driver.video.md

@@ -13,6 +13,7 @@ This unit is the central video interface for the Asuro kernel. It holds a single
 - `driver.video.gpu`
 - `driver.video.vesa32` (and other BPP variants)
 - `core.hashmap`
+- `core.gfx.fonts` — 8×16 bitmap font data for text drawing
 - `syslog`
 
 ## Functions and Procedures
@@ -69,6 +70,34 @@ function backBuffer: PVideoBuffer;
 ```
 Returns a pointer to `VideoInterface.BackBuffer`.
 
+## Text Drawing
+
+These functions render text directly to the framebuffer using the 8×16 bitmap font from `core.gfx.fonts`. They are useful for panic screens or other contexts where LVGL is unavailable. Each function returns the X coordinate immediately after the last drawn pixel, allowing calls to be chained for inline formatting.
+
+### DrawChar
+```pascal
+function DrawChar(X, Y : uint32; C : char; Color : TRGB32) : uint32;
+```
+Draws a single 8×16 bitmap glyph at `(X, Y)` in the given colour. Returns `X + 8`.
+
+### DrawString
+```pascal
+function DrawString(X, Y : uint32; Str : pchar; Color : TRGB32) : uint32;
+```
+Draws a null-terminated string starting at `(X, Y)`. Each character advances X by 8 pixels. Returns the X coordinate after the last character.
+
+### DrawHex
+```pascal
+function DrawHex(X, Y : uint32; Value : uint32; Color : TRGB32) : uint32;
+```
+Draws a `uint32` as a `0xHHHHHHHH` hex string at `(X, Y)`. Returns the X coordinate after the string.
+
+### DrawInt
+```pascal
+function DrawInt(X, Y : uint32; Value : uint32; Color : TRGB32) : uint32;
+```
+Draws an unsigned integer in decimal at `(X, Y)`. Returns the X coordinate after the last digit.
+
 ## Notes
 
 - All drawing operations target the back buffer (`DefaultBuffer`) when double buffering is active. `Flush` transfers the result to the front (visible) buffer.

lvglh/lv_conf.h

@@ -30,8 +30,8 @@
 #define LV_LIMITS_INCLUDE       <limits.h>
 #define LV_STDARG_INCLUDE       <stdarg.h>
 
-/* Built-in memory pool: 256 KB should be plenty for our UI */
-#define LV_MEM_SIZE (256 * 1024U)
+/* Built-in memory pool: 1 MB for complex UI (file browser etc.) */
+#define LV_MEM_SIZE (1024 * 1024U)
 #define LV_MEM_POOL_EXPAND_SIZE 0
 #define LV_MEM_ADR 0