WASM runtime

// wasm-runtime/pwa/bpe/bpe-vfs.js:30
class BPEVFS {
    async init() {
        // Get OPFS root directory
        this.opfsRoot = await navigator.storage.getDirectory();
        
        // Request persistent storage
        if (navigator.storage.persist) {
            const granted = await navigator.storage.persist();
            if (granted) console.log('OPFS persistence granted');
        }
    }

    async readFile(path) {
        const parts = path.split('/').filter(p => p);
        let dir = this.opfsRoot;
        
        // Navigate to parent directory
        for (let i = 0; i < parts.length - 1; i++) {
            dir = await dir.getDirectoryHandle(parts[i]);
        }
        
        // Get file handle
        const fileHandle = await dir.getFileHandle(parts[parts.length - 1]);
        const file = await fileHandle.getFile();
        return await file.arrayBuffer();
    }

    async writeFile(path, data) {
        const parts = path.split('/').filter(p => p);
        let dir = this.opfsRoot;
        
        // Create parent directories
        for (let i = 0; i < parts.length - 1; i++) {
            dir = await dir.getDirectoryHandle(parts[i], { create: true });
        }
        
        // Create or open file
        const fileHandle = await dir.getFileHandle(
            parts[parts.length - 1], 
            { create: true }
        );
        
        const writable = await fileHandle.createWritable();
        await writable.write(data);
        await writable.close();
    }
}

// wasm-runtime/pwa/bpe/bpe-auth.js:40
async hashPassword(password, salt) {
    const enc = new TextEncoder();
    
    // Import password as key material
    const keyMaterial = await crypto.subtle.importKey(
        'raw',
        enc.encode(password),
        'PBKDF2',
        false,
        ['deriveBits']
    );
    
    // Derive key with PBKDF2
    const bits = await crypto.subtle.deriveBits(
        {
            name: 'PBKDF2',
            salt: salt,
            iterations: 600000,  // OWASP 2023 recommendation
            hash: 'SHA-256'
        },
        keyMaterial,
        256  // 256-bit output
    );
    
    return new Uint8Array(bits);
}

async encryptData(data, key) {
    const iv = crypto.getRandomValues(new Uint8Array(12));
    
    const encrypted = await crypto.subtle.encrypt(
        { name: 'AES-GCM', iv },
        key,
        new TextEncoder().encode(data)
    );
    
    return { encrypted, iv };
}

// wasm-runtime/pwa/bpe/bpe-network.js:20
class BPENetwork {
    async connect(host, port) {
        return new Promise((resolve, reject) => {
            this.ws = new WebSocket(`wss://${host}:${port}`);
            
            this.ws.onopen = () => {
                this.connected = true;
                resolve(0);  // Success
            };
            
            this.ws.onerror = (err) => {
                reject(-1);  // Connection failed
            };
            
            this.ws.onmessage = (event) => {
                this.receiveQueue.push(event.data);
            };
        });
    }

    async send(data) {
        if (!this.connected) return -1;
        this.ws.send(data);
        return data.byteLength;
    }

    async recv(maxLen) {
        while (this.receiveQueue.length === 0) {
            await new Promise(r => setTimeout(r, 10));  // Poll
        }
        return this.receiveQueue.shift();
    }
}

// wasm-runtime/pwa/persistent-fs.js:80
class IndexedDBStorage {
    async init() {
        return new Promise((resolve, reject) => {
            const req = indexedDB.open('AuroraOS', 1);
            
            req.onupgradeneeded = (e) => {
                const db = e.target.result;
                if (!db.objectStoreNames.contains('files')) {
                    db.createObjectStore('files', { keyPath: 'path' });
                }
            };
            
            req.onsuccess = (e) => {
                this.db = e.target.result;
                resolve();
            };
            
            req.onerror = reject;
        });
    }

    async writeFile(path, data) {
        const tx = this.db.transaction(['files'], 'readwrite');
        const store = tx.objectStore('files');
        await store.put({ path, data, timestamp: Date.now() });
    }

    async readFile(path) {
        const tx = this.db.transaction(['files'], 'readonly');
        const store = tx.objectStore('files');
        const result = await store.get(path);
        return result ? result.data : null;
    }
}