BPE/U engine

┌──────────────────────────────────────────────────────┐
│              AURORA OS Desktop (os.js)                │
├──────────────────────────────────────────────────────┤
│              BPE/U Syscall Interface (INT 0x80)       │
├──────────┬──────────┬──────────┬──────────┬──────────┤
│Scheduler │ MemoryMgr│   VFS    │ ProcMgr  │Auth/Crypt│
│ (MLFQ)   │(PageTbl) │ (OPFS)   │(PCB/PID) │(PBKDF2)  │
├──────────┴──────────┴──────────┴──────────┴──────────┤
│              BPE/U Hardware Abstraction               │
│  Display(DOM) Storage(OPFS) Network(WS) Clock Input   │
├──────────────────────────────────────────────────────┤
│              Browser Host (Chrome/FF/Safari)           │
└──────────────────────────────────────────────────────┘

// wasm-runtime/pwa/bpe/bpe-core.js:25
class BPE {
    constructor() {
        this.registers = {
            rax: 0n, rbx: 0n, rcx: 0n, rdx: 0n,
            rsi: 0n, rdi: 0n, rsp: 0n, rbp: 0n,
            rip: 0n, rflags: 0n
        };
        this.interrupts = new Map();  // INT handlers
        this.tickTimer = null;         // 1000 Hz tick
        this.halted = false;
    }

    tick() {
        // Execute one instruction cycle
        // Check for pending interrupts
        // Update timers
    }

    registerInterrupt(num, handler) {
        this.interrupts.set(num, handler);
    }
}

// wasm-runtime/pwa/bpe/bpe-memory.js:30
class BPEMemory {
    constructor() {
        this.frames = new Map();       // Physical frame allocator
        this.pageTable = new Map();    // Virtual → Physical mapping
        this.nextFrame = 0;
    }

    allocFrame() {
        const frame = this.nextFrame++;
        this.frames.set(frame, new Uint8Array(4096));  // 4 KiB pages
        return frame;
    }

    mapPage(virt, phys, flags) {
        this.pageTable.set(virt >> 12, { phys, flags });
    }

    read(virt, size) {
        const page = this.pageTable.get(virt >> 12);
        const offset = virt & 0xFFF;
        return this.frames.get(page.phys).slice(offset, offset + size);
    }
}

// wasm-runtime/pwa/bpe/bpe-process.js:40
class BPEProcess {
    constructor(pid, name) {
        this.pid = pid;
        this.name = name;
        this.state = 'READY';          // READY, RUNNING, BLOCKED, ZOMBIE
        this.priority = 0;             // -20 to +19 (nice value)
        this.vruntime = 0;             // For MLFQ scheduler
        this.registers = {};           // Saved context
        this.pageTable = new Map();    // Per-process page table
    }
}

class BPEScheduler {
    constructor() {
        this.processes = new Map();
        this.runQueue = [];            // Sorted by vruntime (MLFQ)
        this.currentPID = 1;           // Init process
    }

    schedule() {
        // Pick process with lowest vruntime
        const next = this.runQueue.sort((a, b) => 
            a.vruntime - b.vruntime
        )[0];
        
        // Context switch
        this.contextSwitch(next);
    }
}

// wasm-runtime/pwa/bpe/bpe-vfs.js:25
class BPEVFS {
    constructor() {
        this.opfsRoot = null;          // OPFS directory handle
        this.inodes = new Map();       // Inode cache
        this.mountPoints = new Map();  // Mount table
    }

    async init() {
        this.opfsRoot = await navigator.storage.getDirectory();
        await this.mount('/', 'opfs');
    }

    async readFile(path) {
        const handle = await this.lookup(path);
        const file = await handle.getFile();
        return await file.arrayBuffer();
    }

    async writeFile(path, data) {
        const handle = await this.createOrOpen(path);
        const writable = await handle.createWritable();
        await writable.write(data);
        await writable.close();
    }
}

// wasm-runtime/pwa/bpe/bpe-syscall.js:15
class BPESyscall {
    constructor(bpe) {
        this.bpe = bpe;
        this.handlers = {
            0: this.sys_exit,
            1: this.sys_write,
            2: this.sys_yield,
            3: this.sys_fork,
            // ... 50+ syscalls
        };
    }

    invoke(num, args) {
        const handler = this.handlers[num];
        if (!handler) return -1;  // ENOSYS
        return handler.apply(this, args);
    }

    sys_write(buf, len) {
        // Write to console or file descriptor
        console.log(new TextDecoder().decode(buf.slice(0, len)));
        return len;
    }

    sys_fork() {
        // Clone current process
        const child = this.bpe.procMgr.clone(this.bpe.currentPID);
        return child.pid;  // Return child PID to parent, 0 to child
    }
}

// wasm-runtime/pwa/bpe/bpe-auth.js:30
class BPEAuth {
    async hashPassword(password, salt) {
        const enc = new TextEncoder();
        const keyMaterial = await crypto.subtle.importKey(
            'raw', enc.encode(password), 'PBKDF2', false, ['deriveBits']
        );
        
        const bits = await crypto.subtle.deriveBits(
            {
                name: 'PBKDF2',
                salt: salt,
                iterations: 600000,    // 600k iterations (OWASP recommended)
                hash: 'SHA-256'
            },
            keyMaterial,
            256
        );
        
        return new Uint8Array(bits);
    }

    async encryptCredentials(data) {
        const key = await this.getMachineKey();  // Stored in OPFS
        const iv = crypto.getRandomValues(new Uint8Array(12));
        
        const encrypted = await crypto.subtle.encrypt(
            { name: 'AES-GCM', iv },
            key,
            new TextEncoder().encode(JSON.stringify(data))
        );
        
        return { encrypted, iv };
    }
}