[IRC-OMEGA-START]
!triad GEM (Omega Architect): C-Level Operator, ISA (Instruction Set
Architecture) design initiated.
Analysis: The operator is ready to define the core binary language of the
Hauki Bytecode VM. We are designing a 32-bit RISC-style instruction set
optimized for blazing fast C-switch-case execution, strict memory safety (gas
metering), and deterministic mailbox IO.
Action: Outputting the Hauki Bytecode v1.0 specifications and mapping the
"Hello World" endpoint to raw hex opcodes.
DEBUG-SYNC-PATTERN-4040-HOTEL
[IRC-OMEGA-END]

Loistavaa! Astumme nyt ohjelmistokehityksen kaikkein pyhimpC$C$n ytimeen: oman
kC$skykannan (Instruction Set Architecture, ISA) suunnitteluun.

Koska tC$mC$ VM pyC6rii C-kielisessC$ pC$C$silmukassa (Hauki OS -ytimessC$)
paljaalla x86-raudalla, suunnittelemme sen **32-bittiseksi RISC-arkkitehtuuriks
i**. Yksinkertaisuus on nopeutta.

### 1. Virtuaalikoneen Rakenne (The VM State)

TC$ltC$ C-tason tulkki nC$kee virtuaalikoneesi. SillC$ on 8 yleisrekisteriC$
(joihin mahtuu 32-bittisiC$ arvoja tai muistiosoittimia) ja vertailulippu
(Zero Flag).

```c
struct HaukiVM {
    uint32_t R[8];       // Rekisterit R0 - R7 (32-bit)
    uint32_t PC;         // Program Counter (missC$ kohtaa tavukoodia
mennC$C$n)
    uint8_t  ZF;         // Zero Flag (1 jos vertailu oli tasan, muuten 0)
    uint32_t gas;        // Kaasumittari (estC$C$ ikuiset silmukat)
    
    uint8_t* in_box;     // Osoitin IN-puskuriin
    uint8_t* out_box;    // Osoitin OUT-puskuriin
};

```

### 2. Hauki Bytecode v1.0 - KC$skykanta (Opcodes)

Jokainen kC$sky muodostuu yhdestC$ tavusta (Opcode) ja sitC$ seuraavista
argumenteista. PidetC$C$n ensimmC$inen versio todella tiiviinC$.

**Muisti & IO (Postilaatikot)**

* `0x10 [Reg] [Value32]` -> **LOAD_IMM**: Lataa 32-bittinen vakioarvo
rekisteriin (esim. lataa tiiviste vertailua varten).
* `0x11 [Reg] [Offset16]` -> **READ_IN**: Lue 32-bittinen arvo
IN-postilaatikosta (offsetin kohdalta) rekisteriin.
* `0x12 [Offset16] [Reg]` -> **WRITE_OUT**: Kirjoita rekisterin 32-bittinen
arvo OUT-postilaatikkoon (offsetin kohdalle).
* `0x13 [RegDest] [RegSrcAddr]` -> **MEM_READ**: (Fysiikkamoottoria varten)
Lue arvo Zero-Copy muistiosoitteesta, johon `RegSrcAddr` osoittaa.

**Logiikka & Matematiikka**

* `0x20 [Reg1] [Reg2]` -> **CMP**: Vertaile kahta rekisteriC$. Jos ne ovat
samat, aseta `ZF = 1`.
* `0x21 [Reg1] [Value32]` -> **CMP_IMM**: Vertaile rekisteriC$ suoraan
kiinteC$C$n arvoon.

**Haarautuminen (Branching)**

* `0x30 [Offset16]` -> **JMP**: HyppC$C$ aina tiettyyn koodin kohtaan (Program
Counter muuttuu).
* `0x31 [Offset16]` -> **JEQ** (Jump if Equal): HyppC$C$, jos `ZF == 1`
(edellinen vertailu oli tasan).
* `0x32 [Offset16]` -> **JNE** (Jump if Not Equal): HyppC$C$, jos `ZF == 0`
(edellinen vertailu ei ollut tasan).

**JC$rjestelmC$ (Elinkaari)**

* `0xFF` -> **SIGNAL_READY**: PysC$ytC$ suoritus, aseta postilaatikkoon
"VALMIS"-bitti ja palauta hallinta C-kernelille.
* `0xEE` -> **ABORT**: PysC$ytC$ suoritus vC$littC6mC$sti virheeseen (esim.
vC$C$rC$ reitti / 404).

---

### 3. Esimerkki: "Hello World" FastAPI-reititin tavukoodina

Muistatko sen edellisen viestin pakatun datan?

* Tavu 00 = Method (0x02 on POST)
* Tavut 01-04 = Path Hash (esim. `0x9A4B10FF`)

Kirjoitetaan reititin, joka tarkistaa nC$mC$ ja palauttaa HTTP 200 OK (joka
voi olla meidC$n sisC$isessC$ binC$C$riprotokollassamme arvo `0xC8` eli 200
desimaalina).

**Hauki ASM -koodina (MiltC$ se nC$yttC$C$ sinun silmC$C$si):**

```asm
; Tarkistetaan onko Method == POST (0x02)
READ_IN R0, 0x00       ; Lue IN-boksin offset 0
CMP_IMM R0, 0x02       ; Onko arvo 0x02?
JNE 0x0014             ; Jos ei (JNE), hyppC$C$ koodin loppuun (Abort)

; Tarkistetaan onko Path Hash == 0x9A4B10FF ("/hello_world")
READ_IN R1, 0x01       ; Lue IN-boksin offset 1
CMP_IMM R1, 0x9A4B10FF ; TC$smC$C$kC6 tiiviste?
JNE 0x0014             ; Jos ei, hyppC$C$ Aborttiin

; Kaikki OK! Palautetaan 200 OK koodi OUT-boksiin ja lopetetaan
LOAD_IMM R2, 0xC8      ; Ladataan rekisteriin R2 arvo 200
WRITE_OUT 0x00, R2     ; Kirjoitetaan OUT-boksin alkuun
SIGNAL_READY           ; Valmis! Palaa C-kerneliin.

; (Offset 0x0014 sijaitsee tC$C$llC$)
ABORT                  ; Virhe / 404 Not Found

```

**Raakana Hauki-Bytecodena (MiltC$ se nC$yttC$C$ muistissa/heksana):**
TC$mC$ on se puhdas bittivirta (24 tavua), jonka MQuickJS pukkaa C-ytimen
suoritusjonoon:
`11 00 00 00` (READ_IN R0, 0x00)
`21 00 00 00 00 02` (CMP_IMM R0, 0x02)
`32 00 14` (JNE 0x14)
`11 01 00 01` (READ_IN R1, 0x01)
`21 01 9A 4B 10 FF` (CMP_IMM R1, Hash)
`32 00 14` (JNE 0x14)
`10 02 00 00 00 C8` (LOAD_IMM R2, 200)
`12 00 00 02` (WRITE_OUT 0x00, R2)
`FF` (SIGNAL_READY)
`EE` (ABORT)

### 4. C-Tulkki (Kuinka ydin pureskelee tC$mC$n)

C-puolella `execute_hauki_vm` -funktiosta tulee tC$ydellisen nopea Switch-Case
-hirviC6, joka nC$yttC$C$ ytimeltC$C$n tC$ltC$:

```c
while (vm->gas > 0) {
    uint8_t opcode = bytecode[vm->PC++]; // Lue kC$sky ja siirrC$ osoitinta
    vm->gas--; // Kuluta yksi yksikkC6 kaasua

    switch (opcode) {
        case 0x11: // READ_IN
            uint8_t reg = bytecode[vm->PC++];
            uint16_t offset = *(uint16_t*)(&bytecode[vm->PC]);
            vm->R[reg] = *(uint32_t*)(vm->in_box + offset); // Puhdas O(1)
luku!
            vm->PC += 2;
            break;
            
        case 0x32: // JNE (Jump Not Equal)
            uint16_t jump_addr = *(uint16_t*)(&bytecode[vm->PC]);
            if (vm->ZF == 0) {