Class RingBufferWriter

src/ringbuffer.js:58–286

* Ring buffer writer (used by main thread)

 * Ring buffer writer (used by main thread)
 */
class RingBufferWriter {
    constructor(sharedBuffer) {
        this.buffer = sharedBuffer;
        this.int32 = new Int32Array(sharedBuffer);
        this.uint8 = new Uint8Array(sharedBuffer);
        this.dataView = new DataView(sharedBuffer);
    }
    
    /**
     * Get available space in the ring buffer
     */
    availableSpace() {
        const head = Atomics.load(this.int32, NET_HEAD_INDEX);
        const tail = Atomics.load(this.int32, NET_TAIL_INDEX);
        
        if (head >= tail) {
            // Head is ahead of tail: free space is (size - head) + tail - 1
            return (NET_RING_SIZE - head) + tail - 1;
        } else {
            // Tail is ahead: free space is tail - head - 1
            return tail - head - 1;
        }
    }
    
    /**
     * Check if buffer has enough space (non-blocking)
     * @param {number} needed - Bytes needed
     * @returns {boolean}
     */
    hasSpace(needed) {
        return this.availableSpace() >= needed;
    }
    
    /**
     * Signal the worker to wake up and process data
     * Call this when buffer is full to wake the worker to drain it
     */
    signalWorker() {
        Atomics.add(this.int32, IO_READY_INDEX, 1);
        Atomics.notify(this.int32, IO_READY_INDEX);
    }
    
    /**
     * Write a network message to the ring buffer
     * @param {number} type - Message type (NET_MSG_*)
     * @param {Uint8Array|Buffer} payload - Message payload
     * @returns {boolean} - True if written, false if no space
     */
    writeMessage(type, payload) {
        const msgLen = 3 + payload.length; // 2 bytes length + 1 byte type + payload
        
        if (this.availableSpace() < msgLen) {
            return false; // No space
        }
        
        let head = Atomics.load(this.int32, NET_HEAD_INDEX);
        const ringStart = NET_RING_OFFSET;