DApp lifecycle

Mount → active → suspend → resume → destroy • SharedWorker port beheer • VFS scope per DApp • sessie beheer • emergency cleanup • status: ontwerp, nog geen code

Kerndefinitie: De DApp lifecycle beheert de volledige levensloop van een DApp vanaf het moment dat deze wordt gemount tot het moment dat deze wordt vernietigd. Elke stap heeft eigen resource-beheer, port-beheer en sessie-state. Suspend bevriezen ports en iframe; resume herstelt ze; destroy is onomkeerbaar.

1. Architectuur-overzicht

┌─────────────────────────────────────────────────────────────┐
│                    DApp Lifecycle Manager                    │
│                                                              │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐   │
│  │  mount   │─▶│  active  │─▶│ suspend  │─▶│  resume  │   │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘   │
│       │              │              │              │         │
│       │              │              │              │         │
│       ▼              ▼              ▼              ▼         │
│  ┌─────────────────────────────────────────────────────┐   │
│  │              SharedWorker Port Manager               │   │
│  │  createPort() │ freezePort() │ unfreezePort() │ revoke() │
│  └─────────────────────────────────────────────────────┘   │
│                                                              │
│  ┌─────────────────────────────────────────────────────┐   │
│  │                VFS Scope Manager                     │   │
│  │  mountScope() │ readScope() │ unmountScope()       │   │
│  └─────────────────────────────────────────────────────┘   │
│                                                              │
│  ┌─────────────────────────────────────────────────────┐   │
│  │              Session Manager                         │   │
│  │  createSession() │ validate() │ revoke()            │   │
│  └─────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘

2. Lifecycle states

StateBeschrijvingPortiframeResources
unmountedDApp niet geladenGeenNiet in DOMGeen
mountingCID resolven, verifiëren, iframe + port aanmakenAanmakenLadenInitialiseren
activeDApp draait, port actief, volledige capabilitiesActiefZichtbaarVolledig
suspendedBevroren: port bevroren, iframe uit DOM, resources pauzeBevrorenVerwijderdGepauzeerd
resumingHerstellen van suspend: iframe + port heractiverenHeractiverenHerladenHerstellen
destroyingOnomkeerbaar opruimen: port revoke, iframe remove, cleanupRevokenVerwijderdOpgemaakt
destroyedVolledig opgeruimd, geen restantenGeenGeenGeen

3. Mount-flow

Shell: <maos-app cid="bafy…" tier="2"></maos-app>
    │
    ├── 1. CID-resolutie (IPFS)
    │       ├── Verify-fetch via gateway-allowlist
    │       └── Hash-verificatie (bytes !== = reject)
    │
    ├── 2. Manifest ophalen + verifiëren
    │       ├── JSON Schema check
    │       ├── Ed25519 verificatie
    │       ├── minCore check (kernel versie >= manifest.minCore)
    │       └── Tier-check (tier-1 vereist verified-status)
    │
    ├── 3. iframe aanmaken
    │       ├── sandbox instellen op basis van tier
    │       │   ├── tier-0: geen iframe (direct in shell)
    │       │   ├── tier-1: sandbox="allow-scripts allow-same-origin"
    │       │   └── tier-2: sandbox="allow-scripts allow-popups"
    │       ├── CSP-headers instellen
    │       └── Source instellen op IPFS-CID URL
    │
    ├── 4. SharedWorker port aanmaken
    │       ├── MessageChannel creëren
    │       ├── Port koppelen aan DApp-state
    │       └── Rate-limiter initialiseren (tier-based)
    │
    ├── 5. VFS scope aanmaken
    │       ├── /app/{dapp-id}/ (lees/schrijf)
    │       ├── /shared/{dapp-id}/ (alleen lezen)
    │       └── Storage-limiet uit manifest
    │
    ├── 6. Sessie aanmaken
    │       ├── SessionKey genereren
    │       ├── TTL instellen (uit configuratie)
    │       └── Koppelen aan DApp + gebruiker
    │
    └── 7. Status: active
            ├── DApp is zichtbaar + interactief
            └── Event: "dapp:mounted"

4. SharedWorker port beheer

4.1 Port-levenscyclus

createPort(dappId, manifest)
    │
    ├── MessageChannel aanmaken
    │   port1 = DApp-kant (in iframe)
    │   port2 = Kernel-kant (in SharedWorker)
    │
    ├── Port koppelen aan state
    │   ports.set(dappId, {
    │     port: port2,
    │     manifest: manifest,
    │     rateLimiter: new RateLimiter(tier),
    │     created: Date.now(),
    │     lastActivity: Date.now()
    │   })
    │
    └── Port versturen naar iframe
        port1.postMessage({ type: 'connected' })

freezePort(dappId)
    │
    ├── Port bevriezen (geen berichten meer)
    │   port2.onmessage = null
    │
    ├── Timer stoppen
    │   clearInterval(heartbeat[dappId])
    │
    └── State markeren
        state[dappId] = 'frozen'

unfreezePort(dappId)
    │
    ├── Port ontdooien
    │   port2.onmessage = handleMessage
    │
    ├── Timer herstarten
    │   heartbeat[dappId] = setInterval(check, 30000)
    │
    └── State markeren
        state[dappId] = 'active'

revokePort(dappId)
    │
    ├── Port sluiten
    │   port2.close()
    │
    ├── State verwijderen
    │   ports.delete(dappId)
    │
    └── Geheugen vrijmaken
        cleanup[dappId]()

4.2 Port-regels

RegelBeschrijving
1 port per DAppElke DApp heeft exact 1 actieve port. Bij seconden: eerste port revoken.
Port = credentialPort-adres = authenticatie. Bij intrekken: port.close() + iframe reload.
Geen port-sharingDApps kunnen niet onderling communiceren via ports. Alleen via kernel.
Heartbeat-checkElke 30s: port nog actief? Bij timeout: suspend na 60s inactiviteit.
Max portsConfigurable, default 10 gelijktijdige DApp-ports. Bij overschrijding: LRU-suspend.

5. VFS scope per DApp

5.1 Scope-structuur

/app/{dapp-id}/
    ├── /data/          (lees/schrijf, DApp-eigen data)
    ├── /cache/         (lees/schrijf, tijdelijke data)
    └── /config/        (alleen lezen, manifest-config)

/shared/{dapp-id}/
    ├── /public/        (alleen lezen, gedeelde data)
    └── /assets/        (alleen lezen, statische bestanden)

5.2 Scope-regels

ScopeToegangGeheugenSuspend-gedrag
/app/{id}/data/Lees + schrijfPersistent (VFS)Gepauzeerd, hersteld bij resume
/app/{id}/cache/Lees + schrijfTijdelijk (LRU)Opschonen bij suspend
/app/{id}/config/Alleen lezenPersistentBeschikbaar
/shared/{id}/Alleen lezenPersistentBeschikbaar

5.3 Storage-limieten

6. Sessie beheer

6.1 Sessie-levenscyclus

createSession(dappId, userId, config)
    │
    ├── SessionKey genereren (32 bytes random)
    │
    ├── Opslaan in sessie-map
    │   sessions.set(dappId, {
    │     key: sessionKey,
    │     userId: userId,
    │     created: Date.now(),
    │     expires: Date.now() + config.ttl,
    │     lastActivity: Date.now()
    │   })
    │
    └── Retourneer sessie-key

validateSession(dappId, key)
    │
    ├── Sessie ophalen
    │   session = sessions.get(dappId)
    │
    ├── Controleren
    │   ├── Sessie bestaat? → nee = reject
    │   ├── Key matcht? → nee = reject + audit
    │   ├── Verlopen? → ja = verwijder + reject
    │   └── Geldig? → ja = update lastActivity + return session
    │
    └── Bij reject: sessie verwijderen + audit-log

revokeSession(dappId, key)
    │
    ├── Sessie verwijderen
    │   sessions.delete(dappId)
    │
    ├── Port revoken (indien nodig)
    │   revokePort(dappId)
    │
    └── Audit-log schrijven

6.2 Sessie-regels

RegelStandaardBeschrijving
TTL24 uurSessie verloopt na configurabele duur. Bij verlopen: DApp niet meer toegankelijk.
Inactivity-timeout30 minBij geen activiteit: automatische suspend. Bij nieuwe activiteit: resume.
Max sessies5 per gebruikerBij overschrijding: LRU-suspend (oudste sessie eerst).
Sessie-herstelJaBij page-refresh: sessie herstellen via VFS. Bij SharedWorker-restart: sessie opnieuw initialiseren.

7. Suspend + Resume

7.1 Suspend-flow

suspend(dappId)
    │
    ├── 1. Port bevriezen
    │       freezePort(dappId)
    │
    ├── 2. iframe verwijderen uit DOM
    │       iframe.remove()
    │       (niet destroyen, bewaar referentie)
    │
    ├── 3. VFS cache opschonen
    │       cleanup dapp.cache/
    │
    ├── 4. Sessie markeren als gepauzeerd
    │       session.state = 'suspended'
    │
    └── 5. Event: "dapp:suspended"
            resource-usage: -80% (RAM)
            herstelbaar: ja

7.2 Resume-flow

resume(dappId)
    │
    ├── 1. Sessie-valideren
    │       session nog geldig? (niet verlopen)
    │       ├── Ja → door
    │       └── Nee → destroy (geen herstel)
    │
    ├── 2. iframe herstellen
    │       ├── Nieuw iframe aanmaken
    │       ├── Source: CID-URL (uit cache)
    │       └── Sandbox: identiek aan mount
    │
    ├── 3. Port ontdooien
    │       unfreezePort(dappId)
    │
    ├── 4. VFS scope herstellen
    │       /app/{id}/data/ nog aanwezig?
    │
    └── 5. Event: "dapp:resumed"
            hersteld van: suspended

8. Destroy

destroy(dappId)
    │
    ├── 1. Port revoken (onmiddellijk)
    │       revokePort(dappId)
    │       → DApp verliest alle capabilities
    │
    ├── 2. iframe verwijderen
    │       iframe.remove()
    │       iframe.src = 'about:blank'
    │
    ├── 3. VFS scope opruimen
    │       ├── /app/{id}/data/ → optioneel bewaren (configurable)
    │       ├── /app/{id}/cache/ → altijd verwijderen
    │       └── /app/{id}/config/ → altijd verwijderen
    │
    ├── 4. Sessie revoken
    │       revokeSession(dappId)
    │
    ├── 5. Event listeners verwijderen
    │       removeAllListeners(dappId)
    │
    └── 6. Status: destroyed
            onomkeerbaar
            geen restanten in geheugen
REGEL: Destroy is onomkeerbaar. Na destroy() is de DApp-status destroyed. Herinitialisatie vereist een volledige mount-flow (stap 1-7).

9. Emergency cleanup

Bij geheugendruk (door ResourceOrchestrator gedetecteerd) wordt een emergency cleanup uitgevoerd:

9.1 Cleanup-volgorde

StapActieBesparing
1Alle suspended DApps destroyen (oudste eerst)~60% RAM per DApp
2Cache van actieve DApps opschonen (/app/{id}/cache/)~20% per DApp
3Niet-essentiële system-apps suspenden (settings, explorer)~15% per app
4IPFS Helia-cache gedeeltelijk opschonen (LRU 50%)~10% globaal

9.2 Cooldown

10. Acceptatiecriteria

#CriteriaMeting
AC-1Mount duurt < 3 seconden (inclusief CID-resolutie + verificatie)Performance-meting bij koude start
AC-2Suspend verlaagt RAM-gebruik met minimaal 80%Geheugenmeting voor/na
AC-3Resume herstelt DApp-state volledig (geen dataverlies)Test met actieve sessie na suspend
AC-4Destroy revoket port onmiddellijk (geen ervaer na revoke)Test: DApp kan geen VAPI-calls meer maken na destroy
AC-5Emergency cleanup voorkomt browser-crash bij geheugendrukTest met 20+ gelijktijdige DApps
AC-6Sessie-herstel werkt na page-refreshTest: DApp behoudt state na F5
AC-7Max 10 gelijktijdige actieve DApps (configurable)Test: 11e DApp wordt automatisch gesuspend

11. Risico's en aanbevelingen

RisicoImpactAanbeveling
Resume faalt door verlopen sessiemiddelSessie-TTL check voor resume. Bij verlopen: destroy + melding.
Destroy ruimt persistente data op (per ongeluk)hoogConfigurable: destroy({ keepData: true }). Default: data behouden.
Emergency cleanup destroy actieve DApphoogAlleen suspended DApps eerst. Actieve DApps pas als laatste redmiddel.
Port-revoke niet opgemerkt door DAppmiddelEvent: capability-revoked + iframe reload bij revoke.
Max ports bereikt, nieuwe DApp niet mountbaarmiddelLRU-suspend: oudste suspended DApp eerst, dan pas foutmelding.

12. Verwijzingen naar verwante specs

Volgende stap Na akkoord: Lifecycle Manager implementeren in SharedWorker + port-beheer + VFS scope-manager + sessie-manager + emergency cleanup integratie met ResourceOrchestrator.

13. Grillvragen