Upeaa tyC6tC$! IRC-lokit ovat kuin oppikirjaesimerkki siitC$, miksi rakensimme
tuon The Mesh -verkoston ja lisC$simme LXC-laajennuksen x-mesh-basic
-moottoriin.

Lokit nC$yttC$vC$t koko totuuden mikropalveluarkkitehtuurin todellisuudesta:
aluksi TASK CLAIM epC$onnistui, sitten LXC-rajapinta valitti "instance is
already running", mutta tyylikC$s virheenkC$sittelysi (ON ERROR GOTO) ja
tilaohjattu suoritus hoitivat homman tyylikkC$C$sti maaliin! Nyt sinulla on
tC$ysin autonominen skripti, joka provisioi uuden sC$hkC6postipalvelimen
pystyyn, siirtC$C$ dev-templatet sisC$C$n ja asettaa oikeudet  tC$ysin "kC$det
irti" -periaatteella.

TC$mC$ antaa meille loistavan pohjan palata Ring-0 -kehitykseen ja rakentaa
tuo pyytC$mC$si DMZ (Demilitarized Zone) JS:n ja Pythonin vC$lille.

DMZ on ratkaisu siihen, ettei kumpikaan kieli blokkaa toista, eivC$tkC$ ne
sotkeudu toistensa muistiin. Luomme kaksi erillistC$ yksisuuntaista
postilaatikkoa (JS -> PY ja PY -> JS) ja hyC6dynnC$mme JSON-muotoa, koska
molemmat kielet (MQuickJS ja PikaPython) ymmC$rtC$vC$t sitC$ natiivisti.

NC$in rakennamme DMZ:n kernel_js.c -tiedostoon:

1. C-Ytimen DMZ-rakenne (The Hardware Mailboxes)
Tarvitsemme kaksi globaalia puskuria ja niille lukot (flags). LisC$C$mme
nC$mC$ kernel_js.c -tiedoston alkuun:

/ ==========================================
/ OMEGA DMZ (JS <-> PY IPC)
/ ==========================================
volatile int dmz_js_to_py_ready = 0;
char dmz_js_to_py_payload[4096]; // JSON Inbox Pythonille

volatile int dmz_py_to_js_ready = 0;
char dmz_py_to_js_payload[4096]; // JSON Outbox JS:lle

2. JS-tason Rajapinnat (MQuickJS Hypercalls)
MQuickJS tarvitsee kaksi uutta Hypercallia (esim. 41 ja 42):

Hypercall 41 (JS -> PY): Kirjoittaa JSON-merkkijonon dmz_js_to_py_payload
-puskuriin ja asettaa dmz_js_to_py_ready = 1.

Hypercall 42 (PY -> JS): Lukee dmz_py_to_js_payload -puskurin, ja jos
dmz_py_to_js_ready == 1, se palauttaa JSON-merkkijonon JS:lle ja asettaa
valmiuslipun nollaan.

/ Hypercall 41: Kirjoita DMZ (JS -> PY)
    if (op == 41 && argc >= 2) {
        JSCStringBuf sbuf; memset(&sbuf, 0, sizeof(sbuf));
        const char *str = JS_ToCString(ctx, argv[1], &sbuf);
        if (str && !dmz_js_to_py_ready) {
            int i = 0;
            while(str[i] && i < 4095) { dmz_js_to_py_payload[i] = str[i]; i++;
}
            dmz_js_to_py_payload[i] = 0;
            dmz_js_to_py_ready = 1;
            return JS_NewInt32(ctx, 1);
        }
        return JS_NewInt32(ctx, 0);
    }

    // Hypercall 42: Lue DMZ (PY -> JS)
    if (op == 42) {
        if (dmz_py_to_js_ready) {
            JSValue ret = JS_NewString(ctx, dmz_py_to_js_payload);
            dmz_py_to_js_ready = 0; // Kuitataan viesti luetuksi
            return ret;
        }
        return JS_UNDEFINED;
    }

3. Python-tason Rajapinnat (PikaPython C-Bindings)
Jotta Python pC$C$see lukemaan ja kirjoittamaan nC$ihin puskureihin, meidC$n
on lisC$ttC$vC$ kaksi uutta C-funktiota pika_hal2.c -tiedostoon, jotka
myC6hemmin rekisterC6imme osaksi Hauki OS -standardikirjastoa
(hauki.dmz_read() ja hauki.dmz_write()).

/ NC$mC$ ovat C-funktiot, joita PikaVM kutsuu
extern volatile int dmz_js_to_py_ready;
extern char dmz_js_to_py_payload[4096];
extern volatile int dmz_py_to_js_ready;
extern char dmz_py_to_js_payload[4096];

char* pika_dmz_read(void) {
    if (dmz_js_to_py_ready) {
        dmz_js_to_py_ready = 0; // Kuitataan luetuksi
        return dmz_js_to_py_payload;
    }
    return "";
}

void pika_dmz_write(char* msg) {
    int i = 0;
    while(msg[i] && i < 4095) { dmz_py_to_js_payload[i] = msg[i]; i++; }
    dmz_py_to_js_payload[i] = 0;
    dmz_py_to_js_ready = 1;
}

4. JC$rjestelmC$n Arkkitehtuuri (The Event Loop Integration)
Kun DMZ on paikallaan, emme enC$C$ kC$ytC$ vanhaa "pysC$ytetC$C$n koko
maailma" -postilaatikkoa (Hypercall 31 & 32). Sen sijaan JS:n Event Loop
(nano_scheduler_tick tai vastaava HSH-ympC$ristC6ssC$) "pollaa" kevyesti
load(42) -kutsua joka kierroksella.

Jos load(42) palauttaa jotain, tarkoittaa se, ettC$ Python herC$si taustalla
(asynkronisesti tai omalla kellolyC6mC$llC$C$n), suoritti laskennan, kirjoitti
tuloksen DMZ:aan ja poistui!

NC$in HSH-kuoressa:

/ Asetetaan asynkroninen kuuntelija
setInterval(function() {
    var msg = load(42);
    if (msg) {
        var data = JSON.parse(msg);
        print("Saatiin viesti Pythonilta: " + data.status);
    }
}, 100);

/ LC$hetetC$C$n viesti Pythonille
load(41, JSON.stringify({ action: "CALCULATE", a: 5, b: 10 }));

Haluatko, ettC$ valmistan sinulle X-Surgeon blokit, joilla nC$mC$ DMZ-puskurit
ja uudet Hypercallit injektoidaan saumattomasti kernel_js.c -tiedostoon, jotta
pC$C$set kokeilemaan datan ping-pongia?