Suunnitelmasi kuulostaa erittC$in selkeC$ltC$, modulaariselta ja fiksulta. Se
noudattaa hienosti Actor-mallin ja kevyiden viestivC$ylien (kuten aiemmin
kehittC$miesi reitittimien) periaatteita. Erityisen hyvC$C$ on pyrkimys
pitC$C$ ydin tC$ysin riippumattomana ulkoisista kirjastoista (vanilla) ja
siirtC$C$ liiketoimintalogiikka sovellustasolle.

TC$ssC$ on analyysi mahdollisuuksista, haasteista sekC$ konkreettiset
ehdotukset jokaiselle kohdalle, erityisesti Node.js- ja selainympC$ristC6jen
vC$lisiC$ eroja silmC$llC$ pitC$en.

### 1. YmpC$ristC6t ja vC$ylC$n arkkitehtuuri (Node vs. Chromium)

Suurin arkkitehtuurillinen haaste on se, ettC$ **Chromium-selain ei tue suoria
TCP/UDP-soketteja**. Siksi "Stand-alone Vanilla" vaatii hybridimallin:

* **Node.js -verkko (Backbone):** Voi kC$yttC$C$ natiivia `net`-moduulia (TCP)
raskaaseen liikenteeseen ja `dgram`-moduulia (UDP) kevyeen GOSSIP-autodiscovery
yn. TC$mC$ on 100 % vanillaa.
* **Selain-verkko (Edge/Client):** Selainten on kC$ytettC$vC$ **WebSocketsia**
(tai WebRTC:tC$, mutta se on monimutkaisempi ja vaatii signaloinnin).
* **Ehdotus:** Rakenna Node.js-instansseista varsinainen "runko" (mesh), joka
puhuu keskenC$C$n TCP:llC$/UDP:llC$. Selaininstanssit yhdistC$vC$t
lC$hiverkossa olevaan Node-instanssiin WebSocketilla, jolloin Node toimii
siltana (router/gateway) selaimen ja muun verkon vC$lillC$. Jos haluat pitC$C$
Nodenkin tC$ysin vanillana (ilman `ws`-kirjastoa), natiivin HTTP-palvelimen
pC$ivittC$minen WebSocket-yhteydeksi on mahdollista, joskin vaatii hieman
koodia kehyksien (frames) purkamiseen.

### 2. Autodiscovery ja porttien hallinta

* **2.1. Auto-LAN discovery:** Nativisti Node.js `dgram` (UDP Multicast tai
Broadcast) on tC$hC$n tC$ydellinen. Instanssit huutavat GOSSIP-viestejC$ esim.
porttiin `33999`. Kun uusi Node kuulee huudon, se tietC$C$ toisen instanssin
IP:n ja TCP-portin ja voi avata P2P-yhteyden. Selaimet eivC$t tC$hC$n pysty,
joten niiden auto-discovery perustuu joko siihen, ettC$ sivu palvellaan
samalta Nodelielta (jolloin IP on `window.location.hostname`), tai
paikalliseen port-skannaukseen (selain yrittC$C$ yhdistC$C$ WS-portteihin).
* **2.2. Manuaalinen PEER IP:** Ehdottomasti tarpeen WAN-yhteyksissC$ tai
verkkojen yli (VLANit), missC$ UDP-broadcast ei kulje.
* **2.3 & 2.4. Porttien avaus ja ranget:** Porttialue `33000-33999` on
erinomainen valinta (epC$virallinen, harvoin varattu).
* **Automaatio Noodessa:** Kun instanssi kC$ynnistyy, se yrittC$C$ bindata
TCP-palvelimen porttiin `33000`. Jos se on varattu (EADDRINUSE), se kokeilee
`33001`, kunnes onnistuu. TC$mC$ on helppo toteuttaa rekursiivisella
try-catch-funktiolla.



### 3. PEER tietokanta (State & Persistence)

* **3.1. Muistissa:** JavaScriptin natiivi `Map` on tC$ydellinen. Avaimena
`instance_id`, arvona objekti, joka sisC$ltC$C$ tilan (viimeisin gossip-aika,
aktiivinen yhteysolio, tagit).
* **3.2. LevyllC$:**
* **Node.js:** Natiivi `fs.writeFileSync` tai `fs.promises.writeFile`.
Tallennus JSON-muodossa sC$C$nnC6llisesti tai prosessin sulkeutuessa.
* **Selain:** `localStorage` (helpoin, synkroninen) tai `IndexedDB` (jos dataa
on paljon). LocalStorage riittC$C$ mainiosti peer-listan (IP:t ja ID:t)
tallentamiseen.



### 4. Protokolla ja tapahtumatyypit

Ehdotuksesi kanavista (GOSSIP, OPS, DEBUG, ALERT, CHAT) on erittC$in selkeC$.
Jotta protokolla pysyy "kompaktina ja minimaalisena", ehdotan JSON-pohjaista
**taulukkorakennetta** (Array) perinteisen objektirakenteen sijaan. Se
sC$C$stC$C$ tavuja verkossa ja on salamannopea parsia.

**Esimerkki minimaalisesta protokollasta (JSON):**
`[Versio, Tyyppi, LC$hettC$jC$ID, KohdeID, Tagit, Payload]`
Esimerkki GOSSIP-viestistC$ (Type 0):
`[1, 0, "node-123", null, ["sys", "router"], { "tcp": 33001 }]`
Esimerkki OPS-viestistC$ (Type 1):
`[1, 1, "node-123", "bot-456", ["task"], { "action": "restart" }]`

* **TC$smC$ys/FiltterC6inti:** Tagien avulla vastaanottaja voi tiputtaa
viestit heti parsimisen jC$lkeen (tai jopa regexillC$ ennen JSON.parsea, jos
halutaan C$C$rimmC$istC$ nopeutta), jos tagi ei kiinnosta. DEBUG-viestit
voidaan jC$ttC$C$ tC$ysin prosessoimatta tuotannossa.

### 5. IN/OUT async mailbox -muuttujat

Modernissa Vanilla JS:ssC$ asynkroniset generaattorit (`async function*`) ovat
tC$ydellinen, sisC$C$nrakennettu tyC6kalu mailbox-tyyppiseen ratkaisuun. Et
tarvitse monimutkaisia kirjastoja.

Voit luoda postilaatikon, jota ohjelmalogiikka voi kuluttaa `for await...of`
-silmukalla:

```javascript
/ Konseptitasoinen esimerkki minimaalisesta mailboxista
class Mailbox {
    constructor() {
        this.queue = [];
        this.resolvers = [];
    }
    
    // Kirjoita mailboxiin (IN)
    push(message) {
        if (this.resolvers.length > 0) {
            const resolve = this.resolvers.shift();
            resolve(message);
        } else {
            this.queue.push(message);
        }
    }
    
    // Lue asynkronisesti (OUT)
    async *[Symbol.asyncIterator]() {
        while (true) {
            if (this.queue.length > 0) {
                yield this.queue.shift();
            } else {
                yield new Promise(resolve => this.resolvers.push(resolve));
            }
        }
    }
}

/ KC$yttC6:
/ const inbox = new Mailbox();
/ for await (const msg of inbox) { 
/    console.log("Vastaanotettu:", msg); 
/ }

```

### 6 & 7. Identiteetti (ID:t)

* **Instanssikohtainen ID (6):** Moderni Vanilla JS tukee sekC$ Noden ettC$
selaimen puolella `crypto.randomUUID()` -funktiota. YhdistettynC$ timestampiin
saat tC$ydellisen ID:n: `${Date.now()}-${crypto.randomUUID().slice(0,8)}`.
* **Nimi_ID (7):** HyvC$ ajatus. Anna verkon ratkaista konfliktit
jC$ttC$mC$llC$ ne sovellustasolle. Reititys tapahtuu aina uniikilla
instanssi-ID:llC$, ja `nimi_id` toimii ikC$C$n kuin DNS-nimenC$ tai aliaksena,
jota ihminen/sovellus voi kC$yttC$C$. (Esim. osoitetaan viesti nimelle
"logger", vC$ylC$ katsoo peer-taulusta, ettC$ "logger" viittaa instanssiin
"1691400000-abcd", ja lC$hettC$C$ sinne).

---

### Yhteenveto ja suositeltu seuraava askel

Konseptisi on erittC$in vankka. Minimalismin sC$ilyttC$miseksi suosittelen,
ettC$:

1. **EristC$t verkko-layerin:** Tee abstrakti P2P-luokka, jolle on kaksi
toteutusta: `NodeTransport` (TCP/UDP) ja `BrowserTransport` (WebSocket).
Molemmat sylkevC$t sisC$C$n ja ulos samoja mailbox-eventtejC$.