TC$mC$ on arkkitehtuurisesti puhdasta kultaa. Ehdotuksesi on tC$smC$lleen sama
mekanismi, jolla oikeat fyysiset prosessorit kC$sittelevC$t laitteistoa
(Memory-Mapped I/O eli MMIO).

Sijaan, ettC$ prosessori tietC$isi lukevansa verkkokorttia tai
nC$ytC6nohjainta, laitteistotason Memory Management Unit (MMU) huijaa
prosessoria luulemaan, ettC$ se lukee normaalia RAM-muistia. X-MESH-BASIC on
The Dark Meshin virtuaaliprosessori, joten sen pitC$isi ehdottomasti tukea
AST-puun (Abstract Syntax Tree) virtualisointia!

Koska Node.js ja selainten JavaScript-moottorit tukevat natiivisti
`Proxy`-objekteja, voimme kC$C$riC$ koko `state.program` -objektin (joka
pitC$C$ sisC$llC$C$n BASIC-ohjelman rivit) "virtuaaliseen MMU-yksikkC6C6n"
erittC$in tehokkaasti ilman raskaita ehtolauseita perussilmukassa.

TehdC$C$n uusi ydinlaajennus `ext/mmu.js`, joka mahdollistaa minkC$ tahansa
muistialueen "mappaamisen" dynaamiseen JS-rutiiniin.

### 1. Luodaan MMU-Laajennus (ext/mmu.js)

Aja tC$mC$ pC$C$tteeseen. Se luo uuden MMU-komennon, joka kaappaa AST-puun
luvut lennosta erittC$in nopealla Proxylla. Samalla se tC$yttC$C$
`state.lineNumbers` -taulun, jotta BASICin klassiset `RESTORE` ja `KV READ`
lC6ytC$vC$t virtuaalisen muistiavaruuden aivan kuten oikean koodin.

```bash
cat << 'EOF' > /mnt/mesh_root/src/x-mesh-basic/ext/mmu.js
/ ext/mmu.js - Memory Management Unit for AST Virtualization
registerHandler('MMU', function(stmt, state, evalExpr, next, handleError) {
    let parts = stmt.split(' ');
    let action = parts[1].toUpperCase();

    if (action === 'MAP') {
        // Syntaksi: MMU MAP 50000 TO 59999 VIA "zfs_handler"
        let toIdx = stmt.indexOf(' TO ');
        let viaIdx = stmt.indexOf(' VIA ');
        
        let startLine = Number(evalExpr(parts[2], state.memory));
        let endLine = Number(evalExpr(stmt.substring(toIdx + 4,
viaIdx).trim(), state.memory));
        let handlerName = evalExpr(stmt.substring(viaIdx + 5).trim(),
state.memory);

        if (!state.mmu_active) {
            let origProgram = state.program;
            // TCSSC ON TAIKA: Proxy sieppaa kaikki luvut state.program[rivi]
            state.program = new Proxy(origProgram, {
                get: function(target, prop) {
                    let num = Number(prop);
                    if (!isNaN(num) && state.mmu_regions) {
                        for (let r of state.mmu_regions) {
                            if (num >= r.start && num <= r.end) {
                                // M-BUS tai Puskuri palauttaa koodin TCSSC
nanosekunnissa!
                                let vData = state.jsRoutines[r.handler](num -
r.start);
                                return vData ? "DATA " + vData : "REM [MMU
EMPTY]";
                            }
                        }
                    }
                    return target[prop];
                }
            });
            state.mmu_active = true;
            state.mmu_regions = [];
        }
        
        state.mmu_regions.push({ start: startLine, end: endLine, handler:
handlerName });
        
        // RekisterC6idC$C$n osoitteet lineNumbers-tauluun, jotta RESTORE
lC6ytC$C$ ne!
        for (let i = startLine; i <= endLine; i++) {
            if (state.lineNumbers.indexOf(i) === -1) state.lineNumbers.push(i);
        }
        state.lineNumbers.sort((a, b) => a - b);
        
        console.log(`[MMU] Muistialue ${startLine}-${endLine} virtualisoitu
rutiinille: ${handlerName}`);
    }
    
    state.currentLineIndex++;
    setImmediate(next);
});
EOF


```

### 2. Miten MMU toimii kC$ytC$nnC6ssC$?

Kun tC$mC$ on kC$C$nnetty sisC$C$n, `crm_sync.bas` tai mikC$ tahansa muu
mesh-ohjelma voidaan kirjoittaa C$C$rimmC$isen lyhyesti.

Dataa ei tarvitse enC$C$ parsia puskureista. Ohjelmoija vain mappaa alueen ja
kC$sittelee sitC$ ikC$C$n kuin rivillC$ 50000 lukisi aina tuorein
verkkopaketti.

```basic
10 REM === OMEGA ZFS STREAMING VIA VIRTUAL MMU ===
20 PRINT "[*] Alustetaan verkkopuskuri ja MMU..."
30 LET HANDLER_JS$ = "function(offset) { let pkt = global.MBUS_STATE.rx_queue[o
ffset]; return pkt ? pkt.payload : null; }"
40 JS DEFINE "zfs_stream" HANDLER_JS$

50 REM Mapataan 1000 rivin ikkuna verkkopuskuriin!
60 MMU MAP 50000 TO 50999 VIA "zfs_stream"

70 PRINT "[*] Odotetaan dataa rivilta 50000..."
80 RESTORE 50000
90 KV READ INTO REQ_OBJ

100 IF REQ_OBJ == "" THEN SUSPEND : GOTO 90
110 PRINT "Virtualisoitu data luettu suoraan AST-puusta: " + REQ_OBJ["sukunimi"
]
120 HALT

```

TC$llC$ rakenteella eristC$mme kielen muistinhallinnan ja siirrC$mme
kompleksisuuden suoraan C-tason nopeudella toimivan Javascript Proxyn
harteille. The Dark Mesh pudottaa datan vC$ylC$lle, MMU mappaa sen koodiksi,
ja BASIC-ohjelmoija ainoastaan lausuu `RESTORE` ja `READ`.

Miten haluaisit kC$sitellC$ tilanteen, jossa virtuaalinen `READ` saavuttaa
puskurin lopun? PitC$isikC6 MMU:n laukaista automaattisesti laitteistokeskeytys
 (trap), joka pyytC$C$ OMEGA-verkolta seuraavan ZFS-sivun ilman, ettC$
BASIC-koodin tarvitsee tietC$C$ asiasta mitC$C$n?