TC$mC$ on arkkitehtuurillisesti todella syvC$llinen ja loistava suunta! Olet
kC$ytC$nnC6ssC$ keksimC$ssC$ uudelleen Bell Labsin legendaarisen **Plan 9**
-kC$yttC6jC$rjestelmC$n hajautetun konseptin, mutta viet sen moderniin
web-aikaan asynkronisilla striimeillC$ ja lokaaleilla muistitiloilla.

TC$mC$ "FUSE-tyyppinen" (Filesystem in Userspace) lC$hestymistapa on
tC$ydellinen tapa irrottaa kC$yttC6liittymC$ ja komentorivi siitC$ *missC$* ja
*mitC$* data fyysisesti on.

Ideoidaan nC$itC$ konsepteja eteenpC$in, ja hahmotellaan millainen tC$mC$
**Ghost Proxy** (haamuolio) -abstraktio voisi olla.

### 1. FUSE-abstraktio: "Kaikki on resurssia" (Ghost Proxy)

Jotta voimme "mountata" mitC$ tahansa, VFS (Virtual File System) ei voi enC$C$
olettaa, ettC$ kaikki on lokaalissa IndexedDB:ssC$. Sen pitC$C$ muuttua
reitittimeksi.

Kun ajat komennon `cat /mnt/omega/status`, VFS katsoo hakemistopuuta:

1. Aha, `/mnt/omega` on "liitospiste" (mount).
2. Se ohjaa luku- ja kirjoituspyynnC6t tC$hC$n liitospisteeseen sidotulle
**Ghost Proxy** -oliolle.

**Ghost Proxy -rajapinta (Interface)** voisi olla geneerinen luokka, jossa on
vain placeholdereita. Jos haluat uuden laitetyypin, perit tC$mC$n luokan ja
ylimC$C$ritC$t vain haluamasi osat:

* `open(mode)`: Alustaa yhteyden (esim. avaa MeshRPC-yhteyden backendin
API:in).
* `read(cursor, size)`: Hakee halutun chunkin.
* `write(cursor, data)`: Puskee dataa eteenpC$in.
* `stat()`: Palauttaa koon, tyypin (stream/file) ja yksikC6n.

### 2. Asema, Osoittimet ja YksikC6t (aposition, mposition)

TC$mC$ oli mielestC$ni ideasi hienoin osa. Perinteinen UNIX kC$yttC$C$ tavuja
(bytes). Mutta modernissa hajautetussa verkossa, jossa liikkuu JSON-paketteja
ja tapahtumavuota (event streams), tavu on vC$C$rC$ mittayksikkC6.

Ghost Proxylla voisi olla metadata, joka mC$C$rittelee sen **yksikC6n
(unit)**: `byte`, `line`, `json`, tai jopa `crdt_event`.

Silloin ehdottamasi paikalliset tila-muuttujat astuvat kuvaan:

* **`atime` / `mtime**`: Perinteiset aikaleimat (milloin viimeksi
luettiin/kirjoitettiin).
* **`apos` (Access Position)**: MissC$ kohtaa *lukija* on. Esimerkiksi, jos
luemme etC$palvelimen lokeja ja yhteys katkeaa kohdassa `apos: 154`,
paikallinen proxy muistaa tC$mC$n. Kun yhteys palaa, proxy pyytC$C$
automaattisesti "anna data indeksistC$ 155 eteenpC$in".
* **`mpos` (Modified Position)**: MissC$ kohtaa on virtuaalinen "pC$C$ty", eli
mihin seuraava kirjoitus menee (append).
* **`chunk_size`**: Kertoo kuinka isoina paloina dataa kannattaa siirtC$C$
lokaalin muistin (VRAM) ja etC$lC$hteen vC$lillC$.

### 3. EsimerkkejC$ Mount-tyypeistC$ (Ghost Proxy -toteutuksia)

Kun tC$mC$ abstraktio on olemassa, voimme luoda uskomattomia liitospisteitC$
suoraan selaimeen:

* **RAMFS (`/dev/shm`)**: Ghost proxy, joka kirjoittaa datan vain paikalliseen
JS-taulukkoon tai `Uint8Array` -puskuriin. TC$ydellinen vC$liaikaisille
tiedostoille ja huippunopealle putkitukselle. TC$ysin haihtuva.
* **REST/Mesh Proxy (`/mnt/mesh/api`)**: Kun teet `cat /mnt/mesh/users`, proxy
muuttaa `read()`-kutsun saumattomasti JSON-pyynnC6ksi aiemmin rakentamamme
Service Workerin ja OOB-verkon lC$pi. Komennot ruudulla ovat staattisia
tiedosto-operaatioita, mutta taustalla proxy tekee asynkronisia verkkokutsuja
chinkeissC$.
* **Infinite Stream (`/dev/random` tai `/mnt/mesh/events`)**: Proxy, jolla ei
ole fyysistC$ loppua. Sen `stat().size` on C$C$retC6n. Jos ajat `cat
/mnt/mesh/events`, paikallinen pC$C$te jC$C$ kuuntelemaan livenC$ (websocketin
yli) tulevia eventtejC$ ja printtaa niitC$ ruudulle sitC$ mukaa kun proxy
niitC$ vastaanottaa ja pC$ivittC$C$ `apos`-osoitintaan.

### Kuinka tC$mC$ voitaisiin rakentaa olemassa olevaan koodiin?

Olemme onneksi erinomaisessa pisteessC$, koska `vfs.js` -moduulimme on
eristetty. Voimme laajentaa sitC$ seuraavasti:

1. LisC$tC$C$n VFS:C$C$n **Mount Table** (Map, jossa on polkuja, esim.
`/mnt/ram` -> `RamProxyInstance`).
2. Kun ajetaan `vfs.readFile(polku)`, VFS pilkkoo polun. Jos polku alkaa
`/mnt/ram`, se delegoi tyC6n kyseiselle Ghost Proxylle. Muuten se jatkaa
IndexedDB:n kC$yttC6C$.
3. TehdC$C$n VFS:C$C$n perinteisen `readFile`:n rinnalle "matalan tason"
funktioita kuten `vfs.readChunk(polku, offset, size)`, joka hyC6dyntC$C$
nC$itC$ ehdottamiasi uusia `apos` ja `mpos` osoittimia.

Millaisesta "haamu-proxysta" haluaisit aloittaa konseptin todistamisen (Proof
of Concept)?
TehdC$C$nkC6 ensin ultra-kevyt **RAM-levy** (`/ram`), johon voi tallentaa
asioita lennosta ilman IndexedDB-viivettC$, vai rakennetaanko **Mesh Stream
Proxy**, joka yhdistC$isi komentorivisi tiedostonluvun suoraan johonkin
backendin Node-prosessiin verkon yli?