feature: mirror all diagnostics to syslog, add VESA fallback for gfxd crashes

- syslogDump now outputs all five diagnostic sections (Fault Info,
  CPU Registers, Process Info, System Info, Call Stack) to serial,
  matching the on-screen BSOD content
- panic() detects if the crash occurred in the gfxd process and
  falls back to rendering the BSOD directly to the VESA framebuffer
  via driver.video text drawing, bypassing LVGL entirely
- Add DrawChar, DrawString, DrawHex, DrawInt to driver.video for
  8x16 bitmap font rendering directly to the framebuffer
- Export SHOULD_CRASH flag from svc.gfxd interface so test commands
  can trigger a deliberate gfxd crash
- Add app.divzero with DIV0, PF, and CRASHGFXD test commands
- Update doc/src/core/core.panic.md and doc/src/driver/video/driver.video.md

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/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.

src/app/app.divzero.pas

@@ -0,0 +1,57 @@
+{
+    Prog->Ping - ICMP Ping command.
+
+    Sends 10 ICMP echo requests to a host, printing round-trip time
+    for each reply. Sleeps 1 second between pings. Each invocation
+    uses a heap-allocated state record so multiple terminals can app.ping
+    concurrently without corrupting each other.
+
+    @author(Kieron Morris <[email protected]>)
+}
+unit app.divzero;
+
+interface
+
+uses
+    io.stdio, debug.tracer;
+
+procedure init();
+
+implementation
+
+uses
+    arch.x86.bda, driver.net.types, driver.net.proto.icmp, driver.net.util, core.strings,
+    proc.mgr, core.util, arch.x86.util, memory.heap, svc.gfxd;
+
+{ ---- Command entry point (runs as a process) ---- }
+
+procedure run_div0(Params : PParamList; stdin_buf, stdout_buf, stderr_buf : POutBuf);
+begin
+    asm
+        XOR EAX, EAX
+        DIV EAX  { this will trigger a divide by zero exception (interrupt 0) }
+    end;
+end;
+
+procedure run_pf(Params : PParamList; stdin_buf, stdout_buf, stderr_buf : POutBuf);
+begin
+    asm
+        MOV EAX, $DEADBEEF
+        MOV [EAX], EAX  { this will trigger a page fault (interrupt 14) }
+    end;
+end;
+
+procedure run_div0_gfxd(Params : PParamList; stdin_buf, stdout_buf, stderr_buf : POutBuf);
+begin
+    svc.gfxd.SHOULD_CRASH := true;  { set flag to trigger crash in graphics service }
+end;
+
+procedure init();
+begin
+    debug.tracer.push_trace('divzero.init');
+    io.stdio.registerCommand('DIV0', @run_div0, 'Force a divide by zero exception.');
+    io.stdio.registerCommand('PF', @run_pf, 'Force a page fault.');
+    io.stdio.registerCommand('CRASHGFXD', @run_div0_gfxd, 'Force a divide by zero exception in the graphics service.');
+end;
+
+end.

src/app/app.mgr.pas

@@ -33,7 +33,8 @@ uses
     //dispatch
     driver.storage.filedispatch,
     //wasm
-    app.wasm.runner;
+    app.wasm.runner,
+    app.divzero;
 
 { Initialize all baked-in programs }
 procedure init();
@@ -81,6 +82,7 @@ begin
     driver.storage.filedispatch.init();
     app.wasm.runner.init();
     app.setres.init();
+    app.divzero.init();
 end;
 
 end.

src/driver/video/driver.video.pas

@@ -22,7 +22,7 @@ unit driver.video;
 interface
 
 uses
-    memory.heap, debug.tracer, core.gfx.color, driver.video.types, core.ds.hashmap, core.util, arch.x86.util, core.gfx.texture, driver.video.gpu;
+    memory.heap, debug.tracer, core.gfx.color, driver.video.types, core.ds.hashmap, core.util, arch.x86.util, core.gfx.texture, driver.video.gpu, core.gfx.fonts;
 
 procedure init();
 procedure DrawPixel(X : uint32; Y : uint32; Pixel : TRGB32);
@@ -46,6 +46,14 @@ function frontBufferLocation : uint32;
 
 Procedure basicFDrawTexture(Buffer : PVideoBuffer; X : uint32; Y : uint32; Texture : PTexture);
 
+{ Text drawing — renders 8x16 bitmap font glyphs directly to the
+  framebuffer via DrawPixel.  Useful for panic screens and other
+  contexts where LVGL is unavailable. }
+function DrawChar(X, Y : uint32; C : char; Color : TRGB32) : uint32;
+function DrawString(X, Y : uint32; Str : pchar; Color : TRGB32) : uint32;
+function DrawHex(X, Y : uint32; Value : uint32; Color : TRGB32) : uint32;
+function DrawInt(X, Y : uint32; Value : uint32; Color : TRGB32) : uint32;
+
 implementation
 
 uses
@@ -342,6 +350,81 @@ begin
     frontBufferLocation:= VideoInterface.FrontBuffer.Location;
 end;
 
+{ ============================================================
+  Text drawing — 8x16 bitmap font via Std_Font
+  ============================================================ }
+
+const
+    HexChars : array[0..15] of char = '0123456789ABCDEF';
+
+function DrawChar(X, Y : uint32; C : char; Color : TRGB32) : uint32;
+var
+    row, col : uint32;
+    glyphRow : uint8;
+begin
+    for row := 0 to 15 do begin
+        glyphRow := Std_Font[ord(C) * 16 + row];
+        for col := 0 to 7 do begin
+            if (glyphRow AND ($80 SHR col)) <> 0 then
+                DrawPixel(X + col, Y + row, Color);
+        end;
+    end;
+    DrawChar := X + 8;
+end;
+
+function DrawString(X, Y : uint32; Str : pchar; Color : TRGB32) : uint32;
+var
+    i : uint32;
+begin
+    i := 0;
+    while Str[i] <> #0 do begin
+        DrawChar(X, Y, Str[i], Color);
+        X := X + 8;
+        Inc(i);
+    end;
+    DrawString := X;
+end;
+
+function DrawHex(X, Y : uint32; Value : uint32; Color : TRGB32) : uint32;
+var
+    buf : array[0..10] of char;
+    i   : uint32;
+begin
+    buf[0] := '0';
+    buf[1] := 'x';
+    for i := 0 to 7 do
+        buf[2 + i] := HexChars[(Value SHR (28 - i * 4)) AND $F];
+    buf[10] := #0;
+    DrawHex := DrawString(X, Y, @buf[0], Color);
+end;
+
+function DrawInt(X, Y : uint32; Value : uint32; Color : TRGB32) : uint32;
+var
+    buf    : array[0..11] of char;
+    digits : array[0..9] of char;
+    count  : uint32;
+    i      : uint32;
+    tmp    : uint32;
+begin
+    if Value = 0 then begin
+        buf[0] := '0';
+        buf[1] := #0;
+        DrawInt := DrawString(X, Y, @buf[0], Color);
+        exit;
+    end;
+    count := 0;
+    tmp := Value;
+    while tmp > 0 do begin
+        digits[count] := char((tmp mod 10) + ord('0'));
+        tmp := tmp div 10;
+        Inc(count);
+    end;
+    for i := 0 to count - 1 do
+        buf[i] := digits[count - 1 - i];
+    buf[count] := #0;
+    DrawInt := DrawString(X, Y, @buf[0], Color);
+end;
+
 procedure reinit(fb_addr, width, height, pitch : uint32; bpp : uint8);
 begin
     debug.tracer.push_trace('driver.video.reinit.enter');

src/svc/svc.gfxd.pas

@@ -13,6 +13,10 @@ unit svc.gfxd;
 
 interface
 
+var
+    SHOULD_CRASH : boolean;  { set to true to intentionally trigger a crash for testing purposes }
+    
+
 procedure init;
 
 implementation
@@ -56,6 +60,12 @@ begin
             lvgl_handler;
             driver.video.Flush;
         end;
+        if SHOULD_CRASH then begin
+            asm
+                XOR EAX, EAX
+                DIV EAX  { this will trigger a divide by zero exception (interrupt 0) }
+            end;
+        end;
     end;
 end;