Sync develop with main (v0.0.6)

.github/workflows/release.yml

@@ -82,33 +82,66 @@ jobs:
       - name: Build bootable ISO (x86_64)
         run: cargo xtask iso
 
-      - name: Build kernel (aarch64)
+      - name: Build kernel (aarch64, render-capable)
         # aarch64 boots via QEMU `-kernel` (no Limine/ISO on -M virt), so the
-        # release artifact is the raw kernel ELF. This is platform-scope parity
-        # with the x86 ISO above: the automated build embeds whatever is committed
-        # under initramfs/ (the full render-capable Flutter runtime — engine .so,
-        # AOT shell snapshot, ICU, assets — is gitignored and staged separately by
-        # scripts/build-aarch64-shell.sh, exactly like the x86 full-shell ISO).
+        # release artifact is the raw kernel ELF. Unlike the x86 ISO (still
+        # platform-scope), the aarch64 kernel is RENDER-CAPABLE: we fetch the
+        # prebuilt Flutter shell runtime (engine .so + AOT shell snapshot + ICU +
+        # fonts/assets + embedder /init + libc + seed) from the `oscortex-engine-1`
+        # release and stage it into initramfs/ before building, so kernel/build.rs
+        # embeds it. The runtime is gitignored (large, prebuilt), hence the fetch.
+        # NOTE: refresh `oscortex-arm64-shell-runtime.tar.gz` on that release when
+        # the shell Dart/app or engine changes — it is a prebuilt snapshot.
+        env:
+          GH_TOKEN: ${{ github.token }}
         run: |
           set -euo pipefail
+          # Fetch + verify the render runtime bundle.
+          gh release download oscortex-engine-1 --repo "$GITHUB_REPOSITORY" \
+            -p 'oscortex-arm64-shell-runtime.tar.gz' \
+            -p 'oscortex-arm64-shell-runtime.tar.gz.sha256' -O /tmp/rt.tar.gz \
+            --clobber || gh release download oscortex-engine-1 --repo "$GITHUB_REPOSITORY" \
+            -p 'oscortex-arm64-shell-runtime.tar.gz' -O /tmp/rt.tar.gz --clobber
+          if [ -f oscortex-arm64-shell-runtime.tar.gz.sha256 ]; then
+            exp=$(awk '{print $1}' oscortex-arm64-shell-runtime.tar.gz.sha256)
+            got=$(sha256sum /tmp/rt.tar.gz | awk '{print $1}')
+            [ "$exp" = "$got" ] || { echo "runtime sha256 mismatch"; exit 1; }
+          fi
+          # Stage into initramfs/ (kernel/build.rs embeds it).
+          mkdir -p initramfs
+          tar -xzf /tmp/rt.tar.gz -C initramfs
+          ls -lh initramfs/init initramfs/system/lib/libflutter_engine.so \
+                 initramfs/system/flutter/libapp.so
+          # Build the render-capable kernel (embeds the staged runtime).
+          touch kernel/src/fs/initramfs.rs
           cargo build --release --target aarch64-unknown-none -p oscortex-kernel \
             --no-default-features --features arch-aarch64 \
             -Z build-std=core,compiler_builtins,alloc \
             -Z build-std-features=compiler-builtins-mem
+          # Also build the UEFI/Limine bootable ISO (the same render runtime is
+          # already staged in initramfs/). This is what boots in UTM / VMs / bare
+          # metal — a real ISO, not just the raw -kernel ELF. build-iso-aarch64.sh
+          # builds a higher-half limine-boot kernel and packages it with
+          # BOOTAA64.EFI; LIMINE_DIR was exported by the limine install step.
+          LIMINE_DIR="$HOME/limine" bash scripts/build-iso-aarch64.sh
+          ls -lh oscortex-aarch64.iso
 
       - name: Stage release assets
         run: |
           set -euo pipefail
           mkdir -p dist
-          # x86_64 bootable ISO
-          cp oscortex.iso "dist/oscortex-${{ steps.ver.outputs.tag }}.iso"
-          sha256sum "dist/oscortex-${{ steps.ver.outputs.tag }}.iso" \
-            > "dist/oscortex-${{ steps.ver.outputs.tag }}.iso.sha256"
-          # aarch64 kernel ELF
-          cp target/aarch64-unknown-none/release/kernel \
-            "dist/oscortex-aarch64-${{ steps.ver.outputs.tag }}.kernel"
-          sha256sum "dist/oscortex-aarch64-${{ steps.ver.outputs.tag }}.kernel" \
-            > "dist/oscortex-aarch64-${{ steps.ver.outputs.tag }}.kernel.sha256"
+          tag="${{ steps.ver.outputs.tag }}"
+          # Arch-labelled names. Each arch ships a bootable ISO (UEFI) AND, for
+          # aarch64, the raw -kernel ELF for QEMU `-M virt -kernel` users.
+          cp oscortex.iso "dist/oscortex-x86_64-${tag}.iso"
+          cp oscortex-aarch64.iso "dist/oscortex-aarch64-${tag}.iso"
+          cp target/aarch64-unknown-none/release/kernel "dist/oscortex-aarch64-${tag}.kernel"
+          # Checksums computed from inside dist/ so each .sha256 lists a bare
+          # filename and `sha256sum -c` works after downloading just the pair.
+          ( cd dist
+            sha256sum "oscortex-x86_64-${tag}.iso"     > "oscortex-x86_64-${tag}.iso.sha256"
+            sha256sum "oscortex-aarch64-${tag}.iso"    > "oscortex-aarch64-${tag}.iso.sha256"
+            sha256sum "oscortex-aarch64-${tag}.kernel" > "oscortex-aarch64-${tag}.kernel.sha256" )
           ls -lh dist
 
       - name: Publish GitHub Release
@@ -122,22 +155,33 @@ jobs:
           body: |
             Automated production release built from `main`.
 
+            Both architectures ship a **bootable UEFI ISO** — flash it or attach it
+            in UTM / a VM / bare metal. aarch64 additionally ships the raw `-kernel`
+            ELF for `qemu-system-aarch64 -M virt -kernel` users.
+
             **Artifacts:**
-            - `oscortex-<tag>.iso` — x86_64 bootable kernel ISO (Limine BIOS + UEFI),
-              built via `cargo xtask iso`.
-            - `oscortex-aarch64-<tag>.kernel` — aarch64 kernel ELF; boot with
-              `qemu-system-aarch64 -M virt -cpu cortex-a72 -kernel <file> -device ramfb`.
-
-            Both are **platform-scope** builds. The full render-capable Flutter shell
-            (engine `.so` + AOT app snapshot + ICU + assets) is gitignored and staged
-            separately — x86 via `scripts/build-iso.sh`, aarch64 via
-            `scripts/build-aarch64-shell.sh` (which pulls the engine + `gen_snapshot`
-            from the `oscortex-engine-1` release). Wiring that runtime into the
-            automated release is a tracked follow-up.
+            - `oscortex-x86_64-<tag>.iso` — x86_64 bootable kernel ISO (Limine BIOS +
+              UEFI), built via `cargo xtask iso`.
+            - `oscortex-aarch64-<tag>.iso` — **render-capable** aarch64 UEFI ISO
+              (Limine → higher-half kernel), embedding the full Flutter shell runtime
+              (engine + AOT shell snapshot + ICU + fonts/assets). This is the image to
+              boot in **UTM / VMs / bare metal**. In UTM use a single CPU core
+              (OSCortex runs a cooperative single-core scheduler).
+            - `oscortex-aarch64-<tag>.kernel` — the same render-capable kernel as a raw
+              ELF for direct QEMU boot:
+              ```
+              qemu-system-aarch64 -M virt -cpu cortex-a72 -smp 1 -m 2G \
+                -kernel oscortex-aarch64-<tag>.kernel -device ramfb \
+                -device virtio-tablet-device -device virtio-keyboard-device
+              ```
+              Wait ~60–90s (TCG warm-up) for the shell to paint; the virtio-tablet
+              gives mouse hover/click.
 
             Verify with the attached `.sha256` files.
           files: |
-            dist/oscortex-${{ steps.ver.outputs.tag }}.iso
-            dist/oscortex-${{ steps.ver.outputs.tag }}.iso.sha256
+            dist/oscortex-x86_64-${{ steps.ver.outputs.tag }}.iso
+            dist/oscortex-x86_64-${{ steps.ver.outputs.tag }}.iso.sha256
+            dist/oscortex-aarch64-${{ steps.ver.outputs.tag }}.iso
+            dist/oscortex-aarch64-${{ steps.ver.outputs.tag }}.iso.sha256
             dist/oscortex-aarch64-${{ steps.ver.outputs.tag }}.kernel
             dist/oscortex-aarch64-${{ steps.ver.outputs.tag }}.kernel.sha256

iso_root_aarch64/EFI/BOOT/limine.conf

@@ -0,0 +1,9 @@
+# OSCortex aarch64 boot configuration (Limine UEFI)
+timeout: 0
+serial: yes
+verbose: yes
+
+/OSCortex AI-First Kernel
+    protocol: limine
+    path: boot():/boot/kernel
+    kaslr: no

iso_root_aarch64/boot/limine/limine.conf

@@ -0,0 +1,9 @@
+# OSCortex aarch64 boot configuration (Limine UEFI)
+timeout: 0
+serial: yes
+verbose: yes
+
+/OSCortex AI-First Kernel
+    protocol: limine
+    path: boot():/boot/kernel
+    kaslr: no

iso_root_aarch64/limine.conf

@@ -0,0 +1,9 @@
+# OSCortex aarch64 boot configuration (Limine UEFI)
+timeout: 0
+serial: yes
+verbose: yes
+
+/OSCortex AI-First Kernel
+    protocol: limine
+    path: boot():/boot/kernel
+    kaslr: no

kernel/Cargo.toml

@@ -39,6 +39,10 @@ default = ["arch-x86_64"]
 arch-x86_64 = []
 arch-aarch64 = []
 arch-riscv64 = []
+# Boot the aarch64 kernel via the Limine UEFI protocol (higher-half, MMU/HHDM/
+# framebuffer set up by the bootloader) instead of the bare `-kernel`/DTB path.
+# Selects the higher-half linker script + the Limine entry trampoline.
+limine-boot = []
 ai-cortex = []
 driver-wasm = []
 self-healing = []

kernel/build.rs

@@ -3,7 +3,15 @@ fn main() {
     let arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap_or_default();
     let out  = std::env::var("OUT_DIR").unwrap();
 
+    // The aarch64 port has TWO mutually-exclusive boot layouts:
+    //   * `-kernel`/DTB boot  → physical link @ 0x40080000, entry `_start`, MMU off
+    //     (aarch64.ld, the default).
+    //   * Limine UEFI boot    → higher-half link @ -2 GiB, entry the Limine
+    //     trampoline, MMU/HHDM/framebuffer already set up by the bootloader
+    //     (aarch64-limine.ld), selected by the `limine-boot` feature.
+    let limine_boot = std::env::var("CARGO_FEATURE_LIMINE_BOOT").is_ok();
     let ld = match arch.as_str() {
+        "aarch64" if limine_boot => "aarch64-limine.ld",
         "aarch64" => "aarch64.ld",
         "riscv64" => "riscv64.ld",
         _         => "x86_64.ld",   // default / x86_64
@@ -15,6 +23,7 @@ fn main() {
     println!("cargo:rerun-if-changed=linker/{ld}");
     println!("cargo:rerun-if-changed=linker/x86_64.ld");
     println!("cargo:rerun-if-changed=linker/aarch64.ld");
+    println!("cargo:rerun-if-changed=linker/aarch64-limine.ld");
     println!("cargo:rerun-if-changed=linker/riscv64.ld");
     println!("cargo:rerun-if-changed=build.rs");
 

kernel/linker/aarch64-limine.ld

@@ -0,0 +1,72 @@
+/* OSCortex aarch64 linker script — Limine higher-half kernel (UEFI boot).
+ *
+ * Unlike the bare `-kernel` path (aarch64.ld, linked to physical 0x40080000 with
+ * the MMU off and entry `_start`), the Limine boot protocol hands the kernel a
+ * machine that already has the MMU on, a higher-half mapping of the kernel, an
+ * HHDM direct-map of physical RAM, and a framebuffer. Limine loads each PT_LOAD
+ * segment at its higher-half virtual link address and jumps to the ELF entry
+ * point at EL1.
+ *
+ * We therefore link this variant to the conventional Limine higher-half base
+ * (-2 GiB) and set the entry to the aarch64 Limine entry trampoline, mirroring
+ * the x86_64 Limine kernel layout. The Limine request statics are discovered by
+ * the bootloader by scanning the loaded image for their magic numbers.
+ */
+OUTPUT_FORMAT("elf64-littleaarch64")
+OUTPUT_ARCH(aarch64)
+ENTRY(_limine_aarch64_entry)
+
+PHDRS {
+    text    PT_LOAD FLAGS(5);  /* R-X */
+    rodata  PT_LOAD FLAGS(4);  /* R-- */
+    data    PT_LOAD FLAGS(6);  /* RW- */
+}
+
+SECTIONS {
+    . = 0xFFFFFFFF80000000;
+
+    .text : ALIGN(4096) {
+        __text_start = .;
+        KEEP(*(.text.limine_entry))   /* entry trampoline first */
+        *(.text .text.*)
+        __text_end = .;
+    } :text
+
+    . = ALIGN(4096);
+
+    .rodata : ALIGN(4096) {
+        __rodata_start = .;
+        *(.rodata .rodata.*)
+        __rodata_end = .;
+    } :rodata
+
+    /* Limine requests (scanned by the bootloader for their magic numbers). */
+    .limine_reqs : {
+        KEEP(*(.limine_requests*))
+        KEEP(*(.limine_requests_start*))
+        KEEP(*(.limine_requests_end*))
+    } :rodata
+
+    . = ALIGN(4096);
+
+    .data : ALIGN(4096) {
+        __data_start = .;
+        *(.data .data.*)
+        *(.got .got.*)
+        __data_end = .;
+    } :data
+
+    . = ALIGN(4096);
+    .bss (NOLOAD) : ALIGN(4096) {
+        __bss_start = .;
+        *(.bss .bss.*)
+        *(COMMON)
+        . = ALIGN(16);
+        __bss_end = .;
+    } :data
+
+    . = ALIGN(4096);
+    __kernel_end = .;
+
+    /DISCARD/ : { *(.eh_frame) *(.eh_frame_hdr) *(.note .note.*) *(.comment) }
+}