murow 0.0.60 → 0.0.71

package/dist/index.js

@@ -1,24 +0,0 @@
-/**
- * GameDev Utils
- *
- * A collection of utilities for game development, including:
- * - Binary codecs for efficient serialization
- * - Event system for decoupled communication
- * - Fixed-timestep ticker for deterministic simulation
- * - ID generation utilities
- * - Linear interpolation (lerp) utilities
- * - NavMesh pathfinding with obstacle management
- * - Pooled codecs for zero-allocation networking
- * - Prediction system for client-side prediction
- * - Protocol layer for networked multiplayer games
- * - Transport-agnostic networking layer (client/server abstractions)
- * - Entity Component System (ECS) for scalable game architecture
- */
-// Core utilities
-export * from "./core";
-// Protocol layer for networking
-export * from "./protocol";
-// Networking layer (client/server abstractions)
-export * from "./net";
-// Entity Component System
-export * from "./ecs";

package/dist/net/adapters/browser-websocket.js

@@ -1,74 +0,0 @@
-/**
- * Browser WebSocket transport adapter for ClientNetwork
- *
- * @example
- * ```ts
- * const transport = new BrowserWebSocketClientTransport("ws://localhost:3007");
- * const client = new ClientNetwork({ transport, ... });
- * ```
- */
-export class BrowserWebSocketClientTransport {
-    constructor(url) {
-        this.openHandler = null;
-        this.messageHandler = null;
-        this.closeHandler = null;
-        this.errorHandler = null;
-        this.isOpen = false;
-        this.pendingMessages = [];
-        this.ws = new WebSocket(url);
-        this.ws.binaryType = 'arraybuffer';
-        this.ws.onopen = () => {
-            this.isOpen = true;
-            // Flush any pending messages
-            for (const msg of this.pendingMessages) {
-                this.ws.send(msg);
-            }
-            this.pendingMessages = [];
-            if (this.openHandler) {
-                this.openHandler();
-            }
-            ;
-        };
-        this.ws.onmessage = (event) => {
-            if (this.messageHandler && event.data instanceof ArrayBuffer) {
-                this.messageHandler(new Uint8Array(event.data));
-            }
-        };
-        this.ws.onclose = () => {
-            this.isOpen = false;
-            if (this.closeHandler) {
-                this.closeHandler();
-            }
-        };
-        this.ws.onerror = () => {
-            if (this.errorHandler) {
-                this.errorHandler(new Error('WebSocket error'));
-            }
-        };
-    }
-    send(data) {
-        if (this.isOpen && this.ws.readyState === WebSocket.OPEN) {
-            // WebSocket.send() copies the buffer, so this is safe
-            this.ws.send(data);
-        }
-        else if (this.ws.readyState === WebSocket.CONNECTING) {
-            // Queue messages sent before connection is established
-            this.pendingMessages.push(data);
-        }
-    }
-    onMessage(handler) {
-        this.messageHandler = handler;
-    }
-    onOpen(handler) {
-        this.openHandler = handler;
-    }
-    onClose(handler) {
-        this.closeHandler = handler;
-    }
-    onError(handler) {
-        this.errorHandler = handler;
-    }
-    close() {
-        this.ws.close();
-    }
-}

package/dist/net/adapters/bun-websocket.js

@@ -1,245 +0,0 @@
-import { generateId } from "../../core/generate-id/generate-id";
-/**
- * Bun WebSocket transport adapter for client-side connections
- */
-export class BunWebSocketClientTransport {
-    constructor(socket) {
-        this.messageHandlers = [];
-        this.closeHandlers = [];
-        this.errorHandlers = [];
-        this.socket = socket;
-        this.setupHandlers();
-    }
-    send(data) {
-        if (this.socket.readyState === WebSocket.OPEN) {
-            this.socket.send(data);
-        }
-    }
-    onMessage(handler) {
-        this.messageHandlers.push(handler);
-    }
-    onClose(handler) {
-        this.closeHandlers.push(handler);
-    }
-    onError(handler) {
-        this.errorHandlers.push(handler);
-    }
-    close() {
-        this.socket.close();
-    }
-    setupHandlers() {
-        this.socket.binaryType = "arraybuffer";
-        this.socket.addEventListener("message", (event) => {
-            if (event.data instanceof ArrayBuffer) {
-                const data = new Uint8Array(event.data);
-                for (const handler of this.messageHandlers) {
-                    handler(data);
-                }
-            }
-            else {
-                // Warn about non-binary messages
-                const error = new Error(`Unexpected message type: ${typeof event.data}`);
-                for (const handler of this.errorHandlers) {
-                    handler(error);
-                }
-            }
-        });
-        this.socket.addEventListener("close", () => {
-            for (const handler of this.closeHandlers) {
-                handler();
-            }
-        });
-        this.socket.addEventListener("error", () => {
-            const error = new Error("WebSocket error");
-            for (const handler of this.errorHandlers) {
-                handler(error);
-            }
-        });
-    }
-    /**
-     * Static factory method to connect to a server
-     */
-    static connect(url) {
-        return new Promise((resolve, reject) => {
-            const socket = new WebSocket(url);
-            const transport = new BunWebSocketClientTransport(socket);
-            socket.addEventListener("open", () => {
-                resolve(transport);
-            });
-            socket.addEventListener("error", (error) => {
-                reject(error);
-            });
-        });
-    }
-}
-/**
- * Bun WebSocket transport adapter for server-side peer connections
- */
-export class BunWebSocketPeerTransport {
-    constructor(socket) {
-        this.messageHandlers = [];
-        this.closeHandlers = [];
-        this.errorHandlers = [];
-        this.socket = socket;
-    }
-    send(data) {
-        this.socket.send(data);
-    }
-    onMessage(handler) {
-        this.messageHandlers.push(handler);
-    }
-    onClose(handler) {
-        this.closeHandlers.push(handler);
-    }
-    onError(handler) {
-        this.errorHandlers.push(handler);
-    }
-    close() {
-        this.socket.close();
-    }
-    _handleOpen() {
-        // No-op for server peer transport
-    }
-    /**
-     * Internal: Call message handlers (used by server adapter)
-     */
-    _handleMessage(data) {
-        for (const handler of this.messageHandlers) {
-            handler(data);
-        }
-    }
-    /**
-     * Internal: Call close handlers (used by server adapter)
-     */
-    _handleClose() {
-        for (const handler of this.closeHandlers) {
-            handler();
-        }
-    }
-    /**
-     * Internal: Call error handlers (used by server adapter)
-     */
-    _handleError(error) {
-        for (const handler of this.errorHandlers) {
-            handler(error);
-        }
-    }
-}
-/**
- * Bun WebSocket server transport adapter
- */
-export class BunWebSocketServerTransport {
-    constructor(server) {
-        this.peers = new Map();
-        this.connectionHandlers = [];
-        this.disconnectionHandlers = [];
-        this.server = server;
-    }
-    onConnection(handler) {
-        this.connectionHandlers.push(handler);
-    }
-    onDisconnection(handler) {
-        this.disconnectionHandlers.push(handler);
-    }
-    getPeer(peerId) {
-        return this.peers.get(peerId);
-    }
-    getPeerIds() {
-        return Array.from(this.peers.keys());
-    }
-    close() {
-        this.server.stop();
-        this.peers.clear();
-    }
-    /**
-     * Internal: Register a new peer (called from Bun server fetch handler)
-     */
-    _registerPeer(socket) {
-        const peerId = generateId({ prefix: "peer_" });
-        const peer = new BunWebSocketPeerTransport(socket);
-        this.peers.set(peerId, peer);
-        // Notify connection handlers
-        for (const handler of this.connectionHandlers) {
-            handler(peer, peerId);
-        }
-        return peerId;
-    }
-    /**
-     * Internal: Handle peer message (called from Bun server message handler)
-     */
-    _handlePeerMessage(peerId, data) {
-        const peer = this.peers.get(peerId);
-        if (peer) {
-            peer._handleMessage(data);
-        }
-    }
-    /**
-     * Internal: Handle peer disconnection (called from Bun server close handler)
-     */
-    _handlePeerDisconnection(peerId) {
-        const peer = this.peers.get(peerId);
-        if (peer) {
-            peer._handleClose();
-            this.peers.delete(peerId);
-            // Notify disconnection handlers
-            for (const handler of this.disconnectionHandlers) {
-                handler(peerId);
-            }
-        }
-    }
-    _handlePeerConnection(peerId) {
-        const peer = this.peers.get(peerId);
-        if (peer) {
-            for (const handler of this.connectionHandlers) {
-                handler(peer, peerId);
-            }
-        }
-    }
-    /**
-     * Static factory method to create a Bun WebSocket server
-     */
-    static create(port) {
-        // Peer ID tracking per socket
-        const socketToPeerId = new WeakMap();
-        let transport;
-        const server = Bun.serve({
-            port,
-            fetch(req, server) {
-                // Upgrade HTTP request to WebSocket
-                if (server.upgrade(req)) {
-                    return; // Connection upgraded
-                }
-                return new Response("Expected WebSocket connection", { status: 400 });
-            },
-            websocket: {
-                open(ws) {
-                    // Register peer on connection
-                    const peerId = transport._registerPeer(ws);
-                    socketToPeerId.set(ws, peerId);
-                    transport._handlePeerConnection(peerId);
-                    transport.connectionHandlers.forEach((handler) => handler(transport.getPeer(peerId), peerId));
-                },
-                message(ws, message) {
-                    // Handle incoming message
-                    const peerId = socketToPeerId.get(ws);
-                    if (peerId && message instanceof Uint8Array) {
-                        transport._handlePeerMessage(peerId, message);
-                    }
-                    else if (peerId && message instanceof ArrayBuffer) {
-                        transport._handlePeerMessage(peerId, new Uint8Array(message));
-                    }
-                },
-                close(ws) {
-                    // Handle disconnection
-                    const peerId = socketToPeerId.get(ws);
-                    if (peerId) {
-                        transport._handlePeerDisconnection(peerId);
-                        socketToPeerId.delete(ws);
-                    }
-                },
-            },
-        });
-        transport = new BunWebSocketServerTransport(server);
-        return transport;
-    }
-}

package/dist/net/buffer-pool.js

@@ -1,89 +0,0 @@
-import { ObjectPool } from "../core/pooled-codec/pooled-codec";
-/**
- * Message wrapper pool for network messages
- * Pools buffers for wrapping encoded data with message type headers
- *
- * Works alongside PooledCodec:
- * - PooledCodec handles encoding game data (intents/snapshots)
- * - MessageWrapperPool handles wrapping with protocol headers
- *
- * This eliminates the "new Uint8Array(1 + data.length)" allocation in hot paths
- *
- * Uses ObjectPool from core/pooled-codec for consistent pooling strategy
- */
-export class MessageWrapperPool {
-    /**
-     * @param sizeClass Buffers are pooled in multiples of this size (default: 256 bytes)
-     * @param zeroBuffersOnRelease If true, zero buffers before returning to pool (default: false for performance)
-     */
-    constructor(sizeClass = 256, zeroBuffersOnRelease = false) {
-        this.pools = new Map();
-        this.sizeClass = sizeClass;
-        this.zeroBuffersOnRelease = zeroBuffersOnRelease;
-    }
-    /**
-     * Wrap payload data with a message type header
-     * Returns a buffer from the pool (or allocates if needed)
-     *
-     * Format: [messageType: u8][payload: Uint8Array]
-     *
-     * IMPORTANT: Caller must call release() when done to return buffer to pool
-     */
-    wrap(messageType, payload) {
-        const totalSize = 1 + payload.byteLength;
-        const poolSize = Math.ceil(totalSize / this.sizeClass) * this.sizeClass;
-        // Get or create pool for this size class
-        let pool = this.pools.get(poolSize);
-        if (!pool) {
-            pool = new ObjectPool(() => new Uint8Array(poolSize));
-            this.pools.set(poolSize, pool);
-        }
-        // Acquire buffer from pool
-        const buffer = pool.acquire();
-        // Write message type and payload
-        buffer[0] = messageType;
-        buffer.set(payload, 1);
-        // Return view of exact size needed
-        return buffer.subarray(0, totalSize);
-    }
-    /**
-     * Return a buffer to the pool for reuse
-     * Optionally zeros buffer based on constructor config
-     *
-     * WARNING: Caller must not use the buffer after calling release()
-     */
-    release(buffer) {
-        // Get the actual underlying buffer size
-        const poolSize = buffer.buffer.byteLength;
-        // Only pool buffers that match our size classes
-        if (poolSize % this.sizeClass !== 0) {
-            return;
-        }
-        const pool = this.pools.get(poolSize);
-        if (!pool) {
-            return; // No pool for this size, let it be garbage collected
-        }
-        // Create a view of the full buffer
-        const fullBuffer = new Uint8Array(buffer.buffer);
-        // Optionally zero buffer (expensive but safer if caller might hold references)
-        if (this.zeroBuffersOnRelease) {
-            fullBuffer.fill(0);
-        }
-        pool.release(fullBuffer);
-    }
-    /**
-     * Get current pool statistics
-     * Note: ObjectPool doesn't expose size, so we can only list pool classes
-     */
-    getStats() {
-        return {
-            poolSizes: Array.from(this.pools.keys()).sort((a, b) => a - b),
-        };
-    }
-    /**
-     * Clear all pooled buffers (useful for testing or memory cleanup)
-     */
-    clear() {
-        this.pools.clear();
-    }
-}