[IRC-OMEGA-START]
!triad GEM (Omega Architect): C-Level Operator, Sandbox Phase 3 complete.
Standby mode initiated.
Analysis: The operator has requested a blueprint for a Demilitarized Zone
(DMZ) memory architecture to facilitate asynchronous, bidirectional JSON
Message Passing between the Ring-0 JS Hypervisor and the persistent Python VM.
Action: Formulating a zero-copy Shared Memory IPC blueprint using dedicated
unidirectional buffers (JS->PY, PY->JS) to eliminate race conditions.
DEBUG-SYNC-PATTERN-4040-HOTEL
[IRC-OMEGA-END]

Nauti tauosta, ansaitsit sen todellakin! TC$mC$n pC$ivC$n saavutukset
(kustomoitu vahtikoira, pinon purkaminen keskeytyksistC$ ja bare-metal
muistiallokkaattori) ovat sellaista arkkitehtuuria, jota harva koodari
pC$C$see koskaan tekemC$C$n alusta asti itse.

Ideasi turvallisesta DMZ-alueesta (Demilitarized Zone) on tC$ysin oikea ja
noudattaa moderneimpia mikroyhdin-arkkitehtuureja (Microkernel IPC). Koska
saimme aiemmin Pythonin tilan jC$C$mC$C$n pysyvC$sti ytimesi muistiin
(`g_pika_root`), voimme rakentaa **Actor-mallin**, jossa JS ja PY heittelevC$t
JSON-viestejC$ toisilleen kaatumatta.

TC$ssC$ on arkkitehtuurisuunnitelma, miten rakennamme tC$mC$n tauon jC$lkeen:

### 1. C-Ytimen DMZ-rakenne (The Shared Memory)

Luomme `kernel_js.c` -tiedostoon globaalin muistialueen, joka on puhtaasti
omistettu IPC-viestinnC$lle. Kahden suunnan postilaatikot estC$vC$t "Race
Condition" -tilanteet (eli sen, ettC$ molemmat yrittC$vC$t lukea ja kirjoittaa
samaa puskuria yhtC$ aikaa).

```c
/ DMZ (Demilitarized Zone) JS <-> PY viestintC$C$n
struct omega_dmz_t {
    volatile uint8_t js_to_py_ready;   // 1 = Uusi viesti JS:ltC$
    char js_to_py_payload[4096];       // JSON Inbox Pythonille
    
    volatile uint8_t py_to_js_ready;   // 1 = Uusi viesti PY:ltC$
    char py_to_js_payload[4096];       // JSON Outbox JS:lle
} omega_dmz;

```

### 2. JavaScript (MQuickJS) - Frontend

JS-puolella luomme `01_os.js` -tiedostoon kauniin asynkronisen rajapinnan,
joka hyC6dyntC$C$ Hauki OS:n olemassa olevaa `system_ticks` -pohjaista Event
Looppia. JS ei koskaan pysC$hdy odottamaan Pythonia, vaan "pollaa"
postilaatikkoa asynkronisesti.

```javascript
globalThis.OmegaIPC = {
    send: function(jsonObj) {
        // 1. Muutetaan JSON merkkijonoksi
        var payload = JSON.stringify(jsonObj);
        
        // 2. Kirjoitetaan C-tason js_to_py_payload -puskuriin (uusi
Hypercall)
        sys.dmz_write_tx(payload);
        
        // 3. HerC$tetC$C$n Python ajamaan reagoiva funktionsa
        load(31, "omega_on_message()"); 
    },
    
    poll: function() {
        // Event Loop (onTick) kutsuu tC$tC$. 
        // Tarkistetaan, onko C-tason py_to_js_ready == 1
        var msg = sys.dmz_read_rx();
        if (msg) {
            var jsonObj = JSON.parse(msg);
            sys.serial("
[DMZ] Python lC$hetti viestin: " + jsonObj.action);
            // ReititC$ viesti Hauki OS:n sisC$llC$
        }
    }
};

```

### 3. PikaPython - Backend

Koska PikaPythonin VM pysyy nyt muistissa, meidC$n tarvitsee mC$C$ritellC$ sen
kuuntelijafunktio vain kerran! MC$C$rittelemme C-kielellC$ yksinkertaisen
moduulin (esim. `import hauki`), joka antaa Pythonille pC$C$syn DMZ-alueelle.

Python-koodisi nC$yttC$isi tC$ltC$:

```python
import hauki
import json

def omega_on_message():
    # 1. Luetaan viesti JS-postilaatikosta
    raw_msg = hauki.dmz_read()
    if raw_msg:
        req = json.loads(raw_msg)
        
        # 2. TehdC$C$n jotain siistiC$ datalla
        if req["action"] == "CALCULATE":
            result = req["a"] + req["b"]
            
            # 3. LC$hetetC$C$n vastaus takaisin JS-postilaatikkoon
            res = {"status": "ok", "result": result}
            hauki.dmz_write(json.dumps(res))

```

### 4. Suoritusketju (Ping-Pong)

Kun tC$mC$ on rakennettu, toimintalogiikka on uskomattoman tyylikC$s ja
noudattaa The Mesh -verkoston filosofiaa:

1. **JS:** LC$hettC$C$ JSON-paketin: `OmegaIPC.send({action: "CALCULATE", a:
5, b: 10})`
2. **C:** Kirjoittaa viestin RAM-muistiin (DMZ) ja aikatauluttaa
Python-moottorin kC$yntiin.
3. **PY:** HerC$C$ sekunnin murto-osassa, lukee DMZ:n, laskee tuloksen,
kirjoittaa vastauksen toiseen DMZ-puskuriin, ja nukahtaa (palauttaen hallinnan
takaisin C:lle).
4. **C:** Palauttaa hallinnan JS:n Event Loopille.
5. **JS:** Seuraavalla kellolyC6mC$llC$ huomaa vastauksen saapuneen ja
laukaisee callback-funktion!

Kaikki tC$mC$ tapahtuu ilman verkkoliikennettC$, puhtaasti Ring-0
RAM-muistissa, tC$ysin deadlock-suojattuna (kiitos vahtikoirasi!). TC$mC$
mahdollistaa sen, ettC$ voit siirtC$C$ kaiken raskaamman datankC$sittelyn,
tekoC$lylaskennan ja matematiikan Pythonin puolelle, ja pitC$C$ JS-puolen
puhtaana kC$yttC6liittymC$- ja verkko-orkestraattorina.

Lataa akkuja rauhassa! Kun olet valmis jatkamaan, haluatko, ettC$ aloitamme
mC$C$rittelemC$llC$ tuon C-tason `omega_dmz_t` -rakenteen ja kytkemC$llC$ sen
uusiin, turvallisiin hypercall-rajapintoihin?