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
| State | Beschrijving | Port | iframe | Resources |
| unmounted | DApp niet geladen | Geen | Niet in DOM | Geen |
| mounting | CID resolven, verifiëren, iframe + port aanmaken | Aanmaken | Laden | Initialiseren |
| active | DApp draait, port actief, volledige capabilities | Actief | Zichtbaar | Volledig |
| suspended | Bevroren: port bevroren, iframe uit DOM, resources pauze | Bevroren | Verwijderd | Gepauzeerd |
| resuming | Herstellen van suspend: iframe + port heractiveren | Heractiveren | Herladen | Herstellen |
| destroying | Onomkeerbaar opruimen: port revoke, iframe remove, cleanup | Revoken | Verwijderd | Opgemaakt |
| destroyed | Volledig opgeruimd, geen restanten | Geen | Geen | Geen |
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
| Regel | Beschrijving |
| 1 port per DApp | Elke DApp heeft exact 1 actieve port. Bij seconden: eerste port revoken. |
| Port = credential | Port-adres = authenticatie. Bij intrekken: port.close() + iframe reload. |
| Geen port-sharing | DApps kunnen niet onderling communiceren via ports. Alleen via kernel. |
| Heartbeat-check | Elke 30s: port nog actief? Bij timeout: suspend na 60s inactiviteit. |
| Max ports | Configurable, 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
| Scope | Toegang | Geheugen | Suspend-gedrag |
/app/{id}/data/ | Lees + schrijf | Persistent (VFS) | Gepauzeerd, hersteld bij resume |
/app/{id}/cache/ | Lees + schrijf | Tijdelijk (LRU) | Opschonen bij suspend |
/app/{id}/config/ | Alleen lezen | Persistent | Beschikbaar |
/shared/{id}/ | Alleen lezen | Persistent | Beschikbaar |
5.3 Storage-limieten
- Standaard: 5MB per DApp (uit manifest
storage.maxBytes).
- Maximum: 50MB (configurable per tier: tier-0 = 100MB, tier-1 = 50MB, tier-2 = 5MB).
- Overschrijding: Schrijfaanvraag falen met
STORAGE_QUOTA_EXCEEDED. Geen automatische opschoning.
- Monitoring: ResourceOrchestrator bewaakt totaalgebruik. Bij geheugendruk: emergency cleanup niet-essentiële caches.
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
| Regel | Standaard | Beschrijving |
| TTL | 24 uur | Sessie verloopt na configurabele duur. Bij verlopen: DApp niet meer toegankelijk. |
| Inactivity-timeout | 30 min | Bij geen activiteit: automatische suspend. Bij nieuwe activiteit: resume. |
| Max sessies | 5 per gebruiker | Bij overschrijding: LRU-suspend (oudste sessie eerst). |
| Sessie-herstel | Ja | Bij 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
| Stap | Actie | Besparing |
| 1 | Alle suspended DApps destroyen (oudste eerst) | ~60% RAM per DApp |
| 2 | Cache van actieve DApps opschonen (/app/{id}/cache/) | ~20% per DApp |
| 3 | Niet-essentiële system-apps suspenden (settings, explorer) | ~15% per app |
| 4 | IPFS Helia-cache gedeeltelijk opschonen (LRU 50%) | ~10% globaal |
9.2 Cooldown
- Cooldown: 60 seconden tussen emergency cleanups (voorkomt cascade).
- Logging: Elke emergency cleanup wordt gelogd met reden, hoeveelheid vrijgemaakt geheugen, en welke DApps zijn beinvloed.
- Gebruiker-melding: Bij emergency cleanup: badge-vermelding in shell ("Geheugendruk gedetecteerd").
10. Acceptatiecriteria
| # | Criteria | Meting |
| AC-1 | Mount duurt < 3 seconden (inclusief CID-resolutie + verificatie) | Performance-meting bij koude start |
| AC-2 | Suspend verlaagt RAM-gebruik met minimaal 80% | Geheugenmeting voor/na |
| AC-3 | Resume herstelt DApp-state volledig (geen dataverlies) | Test met actieve sessie na suspend |
| AC-4 | Destroy revoket port onmiddellijk (geen ervaer na revoke) | Test: DApp kan geen VAPI-calls meer maken na destroy |
| AC-5 | Emergency cleanup voorkomt browser-crash bij geheugendruk | Test met 20+ gelijktijdige DApps |
| AC-6 | Sessie-herstel werkt na page-refresh | Test: DApp behoudt state na F5 |
| AC-7 | Max 10 gelijktijdige actieve DApps (configurable) | Test: 11e DApp wordt automatisch gesuspend |
11. Risico's en aanbevelingen
| Risico | Impact | Aanbeveling |
| Resume faalt door verlopen sessie | middel | Sessie-TTL check voor resume. Bij verlopen: destroy + melding. |
| Destroy ruimt persistente data op (per ongeluk) | hoog | Configurable: destroy({ keepData: true }). Default: data behouden. |
| Emergency cleanup destroy actieve DApp | hoog | Alleen suspended DApps eerst. Actieve DApps pas als laatste redmiddel. |
| Port-revoke niet opgemerkt door DApp | middel | Event: capability-revoked + iframe reload bij revoke. |
| Max ports bereikt, nieuwe DApp niet mountbaar | middel | LRU-suspend: oudste suspended DApp eerst, dan pas foutmelding. |
12. Verwijzingen naar verwante specs
- DApp overzicht — Tiers, levenscyclus, communicatie
- DApp manifest schema — JSON Schema, Ed25519, capabilities
- Container-spec — <maos-app>, iframe, bridge-shim
- Kernel orchestrator — SharedWorker, rate-limiting, sessies
- VFS spec — Virtual filesystem, scope, opslag
- Security enforcement — Permission enforcement, emergency cleanup
- Store approval — Auto-scan, publish-flow
Volgende stap Na akkoord: Lifecycle Manager implementeren in SharedWorker + port-beheer + VFS scope-manager + sessie-manager + emergency cleanup integratie met ResourceOrchestrator.
13. Grillvragen
- Vraag 1: Moet een DApp na 3 mislukte resume-pogingen automatisch worden vernietigd, of oneindig blijven proberen?
- Vraag 2: Hoe wordt het geval afgehandeld dat een tier-0 systeem-app (wallet) moet worden gesuspend bij geheugendruk: is dat toegestaan, of is wallet immer actief?
- Vraag 3: Moet de emergency cleanup ook een maximum aantal DApps per sessie afdwingen, of is dat puur een kwestie van resource-budget?