$ upload bin/tele_geo.js
[VFS] \U0001f4c4 tele_geo.js saved successfully to /vfs/bin/tele_geo.js
$ upload bin/tele_scrot.js
[VFS] \U0001f4c4 tele_scrot.js saved successfully to /vfs/bin/tele_scrot.js
$ tele_geo
{
B "x": 0,
B "y": 27,
B "raw": "Window 20971523
B Position: 0,27 (screen: 0)
B Geometry: 1400x1023
"
}
Welcome to Mesh OS. System Ready.
$ tele_scrot > /display/vga1:fb0
[DEVICE] Output successfully piped to /display/vga1:fb0

Tuli vC$rikC$stC$ lumisadetta, johtuuko se siitC$ ettC$ tuo vga1 oli PC:n
VGA-moodille "simuloitu" ?

KyllC$, juuri siitC$ se johtuu! Kuva vahvistaa epC$ilyksesi tC$ydellisesti.

Kun putkitat `tele_scrot` -komennolla dataa `/display/vga1:fb0`
-virtuaalinC$yttC6C6n, V2-parserisi purkaa datan `Uint8Array` -muotoon.
VirtuaalinC$yttC6si (`gfx_test`-hengessC$) odottaa todennC$kC6isesti saavansa
raakaa pikselidataa (esim. RGBA-tavuja 4 tavua per pikseli), aivan kuten
vanhan VGA-kortin videomuisti.

Mutta `tele_scrot` palauttaa **tC$yden, pakatun PNG-tiedoston** tavuvirran
(koska `scrot` tallentaa oletuksena PNG:nC$). Kun Canvas yrittC$C$ piirtC$C$
pakatun PNG-tiedoston binC$C$ri-headereita ja zlib-pakattua dataa suoraan
pikseliarvoina (Red, Green, Blue, Alpha), tuloksena on juuri tuollaista
vC$rikC$stC$ "televisiolumisadetta", koska pakattu data nC$yttC$C$
satunnaiselta kohinalta.

TC$mC$n ratkaisemiseen on kaksi eleganttia tapaa:

### Tapa 1: Muutetaan laite-ajuria (Mesh OS -puoli)

Voimme opettaa `/display/`-laiterajapintaa ymmC$rtC$mC$C$n pakattuja
kuvaformaatteja (PNG, JPEG) raa'an pikselidatan lisC$ksi.

Mesh OS:n ytimessC$ (jossain missC$ kC$sittelet `writeToDevice('/display/vga1:f
b0', data)`) voit tarkistaa datan "taikanumeron" (magic number). PNG-tiedostot
alkavat aina tavuilla `[137, 80, 78, 71]` (`\x89PNG`).

```javascript
/ Esimerkki siitC$, miten laiteliitC$ntC$ voi nC$yttC$C$ PNG:n
async function writeToDevice(path, data) {
    if (path.startsWith('/display/')) {
        const device = Registry.devices.get(path);
        
        // Tarkistetaan onko kyseessC$ PNG-tiedoston raakadata
        if (data instanceof Uint8Array && data.length > 4 && 
            data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] ===
71) {
            
            // Luodaan Blob ja siitC$ Data-URL selaimen kuvaelementille
            const blob = new Blob([data], { type: 'image/png' });
            const url = URL.createObjectURL(blob);
            
            // PiirretC$C$n kuva Canvasille
            const img = new Image();
            img.onload = () => {
                device.ctx.drawImage(img, 0, 0, device.canvas.width,
device.canvas.height);
                URL.revokeObjectURL(url); // Vapautetaan muisti
                
                // Ilmoitetaan kC$yttC6liittymC$lle, ettC$ laite on
pC$ivittynyt
                window.Mesh.emit({ action: 'DEVICE_UPDATED', target: path });
            };
            img.src = url;
            return;
        }

        // ... TC$ssC$ vanha koodisi, joka heittC$C$ raa'an pikselidatan
(Uint8ClampedArray) suoraan ruudulle
    }
}

```

TC$mC$ on joustavin tapa: virtuaalinC$yttC6si voi nyt toimia sekC$
"vga-nC$ytC6nohjaimena" retro-peleille ettC$ oikeana kuvien esitysalustana!

### Tapa 2: Puretaan kuva Desktop VM:ssC$ raa'aksi pikselidataksi (RGb/RGBA)

Jos haluat pitC$C$ Mesh OS:n virtuaalinC$ytC6n tiukasti "laitteistotasolla"
(vastaanottamassa vain pikselitaulukoita, kuten `ImageData`), voimme muuttaa
`visual_telemetry_bridge.js`:C$C$.

Voisimme lisC$tC$ Noden palauttamaan raakaa RGB-taulukkoa, esimerkiksi
kC$yttC$mC$llC$ ImageMagick-tyC6kalua (`import` tai `convert`) puskemaan data
raakana RGB-virtana. TC$mC$ on raskaampaa verkolle (pakkaamaton 1080p-kuva vie
paljon kaistaa verrattuna PNG:hen), mutta se pitC$C$ Mesh OS:n
V2-arkkitehtuurin puhtaana.

**Kumpi lC$hestymistapa tuntuu sinusta oikeammalta Mesh OS:n arkkitehtuuriin?**
 EnsimmC$inen (PNG-tuki virtuaalinC$ytC6lle) on huomattavasti kevyempi ja
nopeampi verkon yli.

### Seuraavat askeleet

Haluatko tehdC$ muutoksen virtuaalinC$ytC6n koodiin (Tapa 1), vai haluatko,
ettC$ kirjoitan heti sen luvatun AT-SPI Python-wrapperin, jotta voimme hakea
natiivien nappien koordinaatteja tyC6pC6ydC$ltC$?