murow 0.0.70 → 0.0.71

package/src/net/adapters/bun-websocket.ts

@@ -1,292 +0,0 @@
-import type { Server, ServerWebSocket } from "bun";
-import type { TransportAdapter, ServerTransportAdapter } from "../types";
-import { generateId } from "../../core/generate-id/generate-id";
-
-/**
- * Bun WebSocket transport adapter for client-side connections
- */
-export class BunWebSocketClientTransport implements TransportAdapter {
-	private socket: WebSocket;
-	private messageHandlers: Array<(data: Uint8Array) => void> = [];
-	private closeHandlers: Array<() => void> = [];
-	private errorHandlers: Array<(error: Error) => void> = [];
-
-	constructor(socket: WebSocket) {
-		this.socket = socket;
-		this.setupHandlers();
-	}
-
-	send(data: Uint8Array): void {
-		if (this.socket.readyState === WebSocket.OPEN) {
-			this.socket.send(data);
-		}
-	}
-
-	onMessage(handler: (data: Uint8Array) => void): void {
-		this.messageHandlers.push(handler);
-	}
-
-	onClose(handler: () => void): void {
-		this.closeHandlers.push(handler);
-	}
-
-	onError(handler: (error: Error) => void): void {
-		this.errorHandlers.push(handler);
-	}
-
-	close(): void {
-		this.socket.close();
-	}
-
-	private setupHandlers(): void {
-		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: string): Promise<BunWebSocketClientTransport> {
-		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 implements TransportAdapter {
-	private socket: ServerWebSocket<unknown>;
-	private messageHandlers: Array<(data: Uint8Array) => void> = [];
-	private closeHandlers: Array<() => void> = [];
-	private errorHandlers: Array<(error: Error) => void> = [];
-
-	constructor(socket: ServerWebSocket<unknown>) {
-		this.socket = socket;
-	}
-
-	send(data: Uint8Array): void {
-		this.socket.send(data);
-	}
-
-	onMessage(handler: (data: Uint8Array) => void): void {
-		this.messageHandlers.push(handler);
-	}
-
-	onClose(handler: () => void): void {
-		this.closeHandlers.push(handler);
-	}
-
-	onError(handler: (error: Error) => void): void {
-		this.errorHandlers.push(handler);
-	}
-
-	close(): void {
-		this.socket.close();
-	}
-
-	_handleOpen(): void {
-		// No-op for server peer transport
-	}
-
-	/**
-	 * Internal: Call message handlers (used by server adapter)
-	 */
-	_handleMessage(data: Uint8Array): void {
-		for (const handler of this.messageHandlers) {
-			handler(data);
-		}
-	}
-
-	/**
-	 * Internal: Call close handlers (used by server adapter)
-	 */
-	_handleClose(): void {
-		for (const handler of this.closeHandlers) {
-			handler();
-		}
-	}
-
-	/**
-	 * Internal: Call error handlers (used by server adapter)
-	 */
-	_handleError(error: Error): void {
-		for (const handler of this.errorHandlers) {
-			handler(error);
-		}
-	}
-}
-
-/**
- * Bun WebSocket server transport adapter
- */
-export class BunWebSocketServerTransport implements ServerTransportAdapter<BunWebSocketPeerTransport> {
-	private server: Server<unknown>;
-	private peers = new Map<string, BunWebSocketPeerTransport>();
-
-	private connectionHandlers: Array<(peer: BunWebSocketPeerTransport, peerId: string) => void> = [];
-	private disconnectionHandlers: Array<(peerId: string) => void> = [];
-
-	constructor(server: Server<unknown>) {
-		this.server = server;
-	}
-
-	onConnection(handler: (peer: BunWebSocketPeerTransport, peerId: string) => void): void {
-		this.connectionHandlers.push(handler);
-	}
-
-	onDisconnection(handler: (peerId: string) => void): void {
-		this.disconnectionHandlers.push(handler);
-	}
-
-	getPeer(peerId: string): BunWebSocketPeerTransport | undefined {
-		return this.peers.get(peerId);
-	}
-
-	getPeerIds(): string[] {
-		return Array.from(this.peers.keys());
-	}
-
-	close(): void {
-		this.server.stop();
-		this.peers.clear();
-	}
-
-	/**
-	 * Internal: Register a new peer (called from Bun server fetch handler)
-	 */
-	_registerPeer(socket: ServerWebSocket<unknown>): string {
-		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: string, data: Uint8Array): void {
-		const peer = this.peers.get(peerId);
-		if (peer) {
-			peer._handleMessage(data);
-		}
-	}
-
-	/**
-	 * Internal: Handle peer disconnection (called from Bun server close handler)
-	 */
-	_handlePeerDisconnection(peerId: string): void {
-		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: string): void {
-		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: number): BunWebSocketServerTransport {
-		// Peer ID tracking per socket
-		const socketToPeerId = new WeakMap<ServerWebSocket<unknown>, string>();
-
-		let transport: BunWebSocketServerTransport;
-
-		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/src/net/buffer-pool.ts

@@ -1,106 +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 {
-	private pools: Map<number, ObjectPool<Uint8Array>> = new Map();
-	private readonly sizeClass: number;
-	private readonly zeroBuffersOnRelease: boolean;
-
-	/**
-	 * @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: number = 256, zeroBuffersOnRelease: boolean = false) {
-		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: number, payload: Uint8Array): Uint8Array {
-		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: Uint8Array): void {
-		// 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(): { poolSizes: number[] } {
-		return {
-			poolSizes: Array.from(this.pools.keys()).sort((a, b) => a - b),
-		};
-	}
-
-	/**
-	 * Clear all pooled buffers (useful for testing or memory cleanup)
-	 */
-	clear(): void {
-		this.pools.clear();
-	}
-}