@nice2dev/game-engine 1.3.14 → 1.3.16

package/dist/esm/performance/DeltaCompression.js

@@ -1,553 +1,506 @@
-/**
- * @file DeltaCompression.ts
- * @description Network bandwidth optimization using delta compression
- * PRO-1.5: Runtime & Performance
- *
- * Features:
- * - Delta encoding for state updates
- * - Variable-length encoding
- * - Bit packing
- * - Huffman compression
- * - Quantization
- * - Interest-based filtering
- */
-// ============================================================
-// Default Configuration
-// ============================================================
 const DEFAULT_QUANTIZATION = {
-    position: { min: -1e4, max: 10000, bits: 16 },
-    rotation: { min: -Math.PI, max: Math.PI, bits: 10 },
-    velocity: { min: -100, max: 100, bits: 12 },
-    health: { min: 0, max: 1000, bits: 10 },
-    custom: {},
+  position: { min: -1e4, max: 1e4, bits: 16 },
+  rotation: { min: -Math.PI, max: Math.PI, bits: 10 },
+  velocity: { min: -100, max: 100, bits: 12 },
+  health: { min: 0, max: 1e3, bits: 10 },
+  custom: {}
 };
-// ============================================================
-// Bit Writer
-// ============================================================
 class BitWriter {
-    constructor(initialSize = 1024) {
-        this.bitPosition = 0;
-        this.bytePosition = 0;
-        this.currentByte = 0;
-        this.buffer = new Uint8Array(initialSize);
-    }
-    writeBits(value, bits) {
-        // Ensure unsigned
-        value = value >>> 0;
-        while (bits > 0) {
-            const remainingBits = 8 - this.bitPosition;
-            const bitsToWrite = Math.min(remainingBits, bits);
-            const mask = (1 << bitsToWrite) - 1;
-            const shifted = (value >> (bits - bitsToWrite)) & mask;
-            this.currentByte |= shifted << (remainingBits - bitsToWrite);
-            this.bitPosition += bitsToWrite;
-            bits -= bitsToWrite;
-            if (this.bitPosition === 8) {
-                this.flushByte();
-            }
-        }
-    }
-    writeBool(value) {
-        this.writeBits(value ? 1 : 0, 1);
-    }
-    writeInt8(value) {
-        this.writeBits(value & 0xff, 8);
-    }
-    writeInt16(value) {
-        this.writeBits(value & 0xffff, 16);
-    }
-    writeInt32(value) {
-        this.writeBits(value >>> 0, 32);
-    }
-    writeFloat16(value) {
-        const half = floatToHalf(value);
-        this.writeBits(half, 16);
-    }
-    writeFloat32(value) {
-        const view = new DataView(new ArrayBuffer(4));
-        view.setFloat32(0, value);
-        this.writeBits(view.getUint32(0), 32);
-    }
-    writeString(str) {
-        const encoded = new TextEncoder().encode(str);
-        this.writeVarInt(encoded.length);
-        for (const byte of encoded) {
-            this.writeInt8(byte);
-        }
-    }
-    writeVarInt(value) {
-        value = value >>> 0;
-        while (value >= 0x80) {
-            this.writeInt8((value & 0x7f) | 0x80);
-            value >>>= 7;
-        }
-        this.writeInt8(value);
-    }
-    flushByte() {
-        this.ensureCapacity(this.bytePosition + 1);
-        this.buffer[this.bytePosition++] = this.currentByte;
-        this.currentByte = 0;
-        this.bitPosition = 0;
-    }
-    ensureCapacity(bytes) {
-        if (bytes > this.buffer.length) {
-            const newBuffer = new Uint8Array(this.buffer.length * 2);
-            newBuffer.set(this.buffer);
-            this.buffer = newBuffer;
-        }
-    }
-    finish() {
-        if (this.bitPosition > 0) {
-            this.flushByte();
-        }
-        return this.buffer.slice(0, this.bytePosition);
-    }
-    getBitCount() {
-        return this.bytePosition * 8 + this.bitPosition;
-    }
+  constructor(initialSize = 1024) {
+    this.bitPosition = 0;
+    this.bytePosition = 0;
+    this.currentByte = 0;
+    this.buffer = new Uint8Array(initialSize);
+  }
+  writeBits(value, bits) {
+    value = value >>> 0;
+    while (bits > 0) {
+      const remainingBits = 8 - this.bitPosition;
+      const bitsToWrite = Math.min(remainingBits, bits);
+      const mask = (1 << bitsToWrite) - 1;
+      const shifted = value >> bits - bitsToWrite & mask;
+      this.currentByte |= shifted << remainingBits - bitsToWrite;
+      this.bitPosition += bitsToWrite;
+      bits -= bitsToWrite;
+      if (this.bitPosition === 8) {
+        this.flushByte();
+      }
+    }
+  }
+  writeBool(value) {
+    this.writeBits(value ? 1 : 0, 1);
+  }
+  writeInt8(value) {
+    this.writeBits(value & 255, 8);
+  }
+  writeInt16(value) {
+    this.writeBits(value & 65535, 16);
+  }
+  writeInt32(value) {
+    this.writeBits(value >>> 0, 32);
+  }
+  writeFloat16(value) {
+    const half = floatToHalf(value);
+    this.writeBits(half, 16);
+  }
+  writeFloat32(value) {
+    const view = new DataView(new ArrayBuffer(4));
+    view.setFloat32(0, value);
+    this.writeBits(view.getUint32(0), 32);
+  }
+  writeString(str) {
+    const encoded = new TextEncoder().encode(str);
+    this.writeVarInt(encoded.length);
+    for (const byte of encoded) {
+      this.writeInt8(byte);
+    }
+  }
+  writeVarInt(value) {
+    value = value >>> 0;
+    while (value >= 128) {
+      this.writeInt8(value & 127 | 128);
+      value >>>= 7;
+    }
+    this.writeInt8(value);
+  }
+  flushByte() {
+    this.ensureCapacity(this.bytePosition + 1);
+    this.buffer[this.bytePosition++] = this.currentByte;
+    this.currentByte = 0;
+    this.bitPosition = 0;
+  }
+  ensureCapacity(bytes) {
+    if (bytes > this.buffer.length) {
+      const newBuffer = new Uint8Array(this.buffer.length * 2);
+      newBuffer.set(this.buffer);
+      this.buffer = newBuffer;
+    }
+  }
+  finish() {
+    if (this.bitPosition > 0) {
+      this.flushByte();
+    }
+    return this.buffer.slice(0, this.bytePosition);
+  }
+  getBitCount() {
+    return this.bytePosition * 8 + this.bitPosition;
+  }
 }
-// ============================================================
-// Bit Reader
-// ============================================================
 class BitReader {
-    constructor(buffer) {
+  constructor(buffer) {
+    this.bitPosition = 0;
+    this.bytePosition = 0;
+    this.buffer = buffer;
+    this.currentByte = buffer[0] || 0;
+  }
+  readBits(bits) {
+    let value = 0;
+    while (bits > 0) {
+      const remainingBits = 8 - this.bitPosition;
+      const bitsToRead = Math.min(remainingBits, bits);
+      const mask = (1 << bitsToRead) - 1;
+      const shifted = this.currentByte >> remainingBits - bitsToRead & mask;
+      value |= shifted << bits - bitsToRead;
+      this.bitPosition += bitsToRead;
+      bits -= bitsToRead;
+      if (this.bitPosition === 8) {
+        this.bytePosition++;
+        this.currentByte = this.buffer[this.bytePosition] || 0;
         this.bitPosition = 0;
-        this.bytePosition = 0;
-        this.buffer = buffer;
-        this.currentByte = buffer[0] || 0;
-    }
-    readBits(bits) {
-        let value = 0;
-        while (bits > 0) {
-            const remainingBits = 8 - this.bitPosition;
-            const bitsToRead = Math.min(remainingBits, bits);
-            const mask = (1 << bitsToRead) - 1;
-            const shifted = (this.currentByte >> (remainingBits - bitsToRead)) & mask;
-            value |= shifted << (bits - bitsToRead);
-            this.bitPosition += bitsToRead;
-            bits -= bitsToRead;
-            if (this.bitPosition === 8) {
-                this.bytePosition++;
-                this.currentByte = this.buffer[this.bytePosition] || 0;
-                this.bitPosition = 0;
-            }
-        }
-        return value;
-    }
-    readBool() {
-        return this.readBits(1) === 1;
-    }
-    readInt8() {
-        return this.readBits(8);
-    }
-    readInt16() {
-        return this.readBits(16);
-    }
-    readInt32() {
-        return this.readBits(32);
-    }
-    readFloat16() {
-        const half = this.readBits(16);
-        return halfToFloat(half);
-    }
-    readFloat32() {
-        const bits = this.readBits(32);
-        const view = new DataView(new ArrayBuffer(4));
-        view.setUint32(0, bits);
-        return view.getFloat32(0);
-    }
-    readString() {
-        const length = this.readVarInt();
-        const bytes = new Uint8Array(length);
-        for (let i = 0; i < length; i++) {
-            bytes[i] = this.readInt8();
-        }
-        return new TextDecoder().decode(bytes);
-    }
-    readVarInt() {
-        let value = 0;
-        let shift = 0;
-        let byte;
-        do {
-            byte = this.readInt8();
-            value |= (byte & 0x7f) << shift;
-            shift += 7;
-        } while (byte & 0x80);
-        return value;
-    }
-    hasMore() {
-        return this.bytePosition < this.buffer.length;
+      }
     }
+    return value;
+  }
+  readBool() {
+    return this.readBits(1) === 1;
+  }
+  readInt8() {
+    return this.readBits(8);
+  }
+  readInt16() {
+    return this.readBits(16);
+  }
+  readInt32() {
+    return this.readBits(32);
+  }
+  readFloat16() {
+    const half = this.readBits(16);
+    return halfToFloat(half);
+  }
+  readFloat32() {
+    const bits = this.readBits(32);
+    const view = new DataView(new ArrayBuffer(4));
+    view.setUint32(0, bits);
+    return view.getFloat32(0);
+  }
+  readString() {
+    const length = this.readVarInt();
+    const bytes = new Uint8Array(length);
+    for (let i = 0; i < length; i++) {
+      bytes[i] = this.readInt8();
+    }
+    return new TextDecoder().decode(bytes);
+  }
+  readVarInt() {
+    let value = 0;
+    let shift = 0;
+    let byte;
+    do {
+      byte = this.readInt8();
+      value |= (byte & 127) << shift;
+      shift += 7;
+    } while (byte & 128);
+    return value;
+  }
+  hasMore() {
+    return this.bytePosition < this.buffer.length;
+  }
 }
-// ============================================================
-// Float16 Conversion
-// ============================================================
 function floatToHalf(value) {
-    const view = new DataView(new ArrayBuffer(4));
-    view.setFloat32(0, value);
-    const bits = view.getUint32(0);
-    const sign = (bits >>> 31) & 0x1;
-    let exponent = (bits >>> 23) & 0xff;
-    let mantissa = bits & 0x7fffff;
-    if (exponent === 0xff) {
-        // Infinity or NaN
-        return (sign << 15) | 0x7c00 | (mantissa ? 0x200 : 0);
-    }
-    exponent -= 127;
-    if (exponent < -24) {
-        return sign << 15;
-    }
-    if (exponent < -14) {
-        mantissa = (mantissa | 0x800000) >> (-14 - exponent);
-        return (sign << 15) | (mantissa >> 13);
-    }
-    if (exponent > 15) {
-        return (sign << 15) | 0x7c00;
-    }
-    return (sign << 15) | ((exponent + 15) << 10) | (mantissa >> 13);
+  const view = new DataView(new ArrayBuffer(4));
+  view.setFloat32(0, value);
+  const bits = view.getUint32(0);
+  const sign = bits >>> 31 & 1;
+  let exponent = bits >>> 23 & 255;
+  let mantissa = bits & 8388607;
+  if (exponent === 255) {
+    return sign << 15 | 31744 | (mantissa ? 512 : 0);
+  }
+  exponent -= 127;
+  if (exponent < -24) {
+    return sign << 15;
+  }
+  if (exponent < -14) {
+    mantissa = (mantissa | 8388608) >> -14 - exponent;
+    return sign << 15 | mantissa >> 13;
+  }
+  if (exponent > 15) {
+    return sign << 15 | 31744;
+  }
+  return sign << 15 | exponent + 15 << 10 | mantissa >> 13;
 }
 function halfToFloat(half) {
-    const sign = (half >>> 15) & 0x1;
-    const exponent = (half >>> 10) & 0x1f;
-    const mantissa = half & 0x3ff;
-    let value;
-    if (exponent === 0) {
-        if (mantissa === 0) {
-            value = sign ? -0 : 0;
-        }
-        else {
-            value = Math.pow(2, -14) * (mantissa / 1024);
-            if (sign) {
-                value = -value;
-            }
-        }
-    }
-    else if (exponent === 31) {
-        value = mantissa ? NaN : sign ? -Infinity : Infinity;
-    }
-    else {
-        value = Math.pow(2, exponent - 15) * (1 + mantissa / 1024);
-        if (sign) {
-            value = -value;
-        }
-    }
-    return value;
+  const sign = half >>> 15 & 1;
+  const exponent = half >>> 10 & 31;
+  const mantissa = half & 1023;
+  let value;
+  if (exponent === 0) {
+    if (mantissa === 0) {
+      value = sign ? -0 : 0;
+    } else {
+      value = Math.pow(2, -14) * (mantissa / 1024);
+      if (sign) {
+        value = -value;
+      }
+    }
+  } else if (exponent === 31) {
+    value = mantissa ? NaN : sign ? -Infinity : Infinity;
+  } else {
+    value = Math.pow(2, exponent - 15) * (1 + mantissa / 1024);
+    if (sign) {
+      value = -value;
+    }
+  }
+  return value;
 }
-// ============================================================
-// Quantization
-// ============================================================
 function quantize(value, min, max, bits) {
-    const range = max - min;
-    const maxValue = (1 << bits) - 1;
-    const normalized = Math.max(0, Math.min(1, (value - min) / range));
-    return Math.round(normalized * maxValue);
+  const range = max - min;
+  const maxValue = (1 << bits) - 1;
+  const normalized = Math.max(0, Math.min(1, (value - min) / range));
+  return Math.round(normalized * maxValue);
 }
 function dequantize(quantized, min, max, bits) {
-    const range = max - min;
-    const maxValue = (1 << bits) - 1;
-    return min + (quantized / maxValue) * range;
+  const range = max - min;
+  const maxValue = (1 << bits) - 1;
+  return min + quantized / maxValue * range;
 }
-// ============================================================
-// Delta Encoder
-// ============================================================
 class DeltaEncoder {
-    constructor(quantization) {
-        this.previousStates = new Map();
-        this.quantization = { ...DEFAULT_QUANTIZATION, ...quantization };
-    }
-    encode(currentState) {
-        const writer = new BitWriter();
-        const delta = {
-            frame: 0,
-            timestamp: Date.now(),
-            entities: [],
-            deletedEntities: [],
-            events: [],
-        };
-        const currentIds = new Set(Object.keys(currentState));
-        // Find deleted entities
-        for (const id of this.previousStates.keys()) {
-            if (!currentIds.has(id)) {
-                delta.deletedEntities.push(id);
-            }
-        }
-        // Encode entities
-        for (const [id, state] of Object.entries(currentState)) {
-            const previous = this.previousStates.get(id);
-            const isNew = !previous;
-            const deltaEntity = {
-                id,
-                isNew,
-                changedFields: [],
-                values: {},
-            };
-            // Find changed fields
-            for (const [field, value] of Object.entries(state)) {
-                const prevValue = previous?.[field];
-                if (isNew || !this.valuesEqual(value, prevValue)) {
-                    deltaEntity.changedFields.push(field);
-                    deltaEntity.values[field] = this.encodeValue(field, value);
-                }
-            }
-            if (deltaEntity.changedFields.length > 0 || isNew) {
-                delta.entities.push(deltaEntity);
-            }
-            this.previousStates.set(id, { ...state });
-        }
-        // Remove deleted entities from tracking
-        for (const id of delta.deletedEntities) {
-            this.previousStates.delete(id);
-        }
-        // Write to binary
-        this.writeDelta(writer, delta);
-        const bytes = writer.finish();
-        const stats = this.calculateStats(currentState, bytes, delta, writer);
-        return { delta, bytes, stats };
-    }
-    valuesEqual(a, b) {
-        if (a === b) {
-            return true;
-        }
-        if (typeof a !== typeof b) {
-            return false;
-        }
-        if (typeof a === 'number' && typeof b === 'number') {
-            return Math.abs(a - b) < 0.0001;
-        }
-        return JSON.stringify(a) === JSON.stringify(b);
-    }
-    encodeValue(field, value) {
-        if (typeof value === 'boolean') {
-            return { type: 'bool', value, bits: 1 };
-        }
-        if (typeof value === 'string') {
-            return { type: 'string', value };
-        }
-        if (typeof value === 'number') {
-            // Check for quantization config
-            const config = this.getQuantizationConfig(field);
-            if (config) {
-                const quantized = quantize(value, config.min, config.max, config.bits);
-                return { type: 'uint16', value, quantized, bits: config.bits };
-            }
-            // Default to float16
-            return { type: 'float16', value, bits: 16 };
-        }
-        return { type: 'string', value: JSON.stringify(value) };
-    }
-    getQuantizationConfig(field) {
-        const lower = field.toLowerCase();
-        if (lower.includes('position') || lower.includes('pos')) {
-            return this.quantization.position;
-        }
-        if (lower.includes('rotation') || lower.includes('angle')) {
-            return this.quantization.rotation;
-        }
-        if (lower.includes('velocity') || lower.includes('speed')) {
-            return this.quantization.velocity;
-        }
-        if (lower.includes('health') || lower.includes('hp')) {
-            return this.quantization.health;
-        }
-        return this.quantization.custom[field];
-    }
-    writeDelta(writer, delta) {
-        // Write timestamp
-        writer.writeInt32(delta.timestamp);
-        // Write deleted entities count and IDs
-        writer.writeVarInt(delta.deletedEntities.length);
-        for (const id of delta.deletedEntities) {
-            writer.writeString(id);
-        }
-        // Write entity count
-        writer.writeVarInt(delta.entities.length);
-        // Write each entity
-        for (const entity of delta.entities) {
-            writer.writeString(entity.id);
-            writer.writeBool(entity.isNew);
-            writer.writeVarInt(entity.changedFields.length);
-            for (const field of entity.changedFields) {
-                writer.writeString(field);
-                this.writeValue(writer, entity.values[field]);
-            }
-        }
-    }
-    writeValue(writer, value) {
-        // Write type (3 bits for 8 types)
-        const typeIndex = [
-            'bool',
-            'int8',
-            'int16',
-            'int32',
-            'uint8',
-            'uint16',
-            'float16',
-            'float32',
-            'string',
-        ].indexOf(value.type);
-        writer.writeBits(typeIndex, 4);
-        switch (value.type) {
-            case 'bool':
-                writer.writeBool(value.value);
-                break;
-            case 'int8':
-            case 'uint8':
-                writer.writeInt8(value.value);
-                break;
-            case 'int16':
-            case 'uint16':
-                if (value.quantized !== undefined && value.bits) {
-                    writer.writeBits(value.quantized, value.bits);
-                }
-                else {
-                    writer.writeInt16(value.value);
-                }
-                break;
-            case 'int32':
-                writer.writeInt32(value.value);
-                break;
-            case 'float16':
-                writer.writeFloat16(value.value);
-                break;
-            case 'float32':
-                writer.writeFloat32(value.value);
-                break;
-            case 'string':
-                writer.writeString(value.value);
-                break;
-        }
-    }
-    calculateStats(state, bytes, delta, writer) {
-        const rawBytes = JSON.stringify(state).length;
-        const compressedBytes = bytes.length;
-        return {
-            rawBytes,
-            compressedBytes,
-            compressionRatio: rawBytes / Math.max(1, compressedBytes),
-            entitiesEncoded: delta.entities.length,
-            fieldsChanged: delta.entities.reduce((sum, e) => sum + e.changedFields.length, 0),
-            bitsUsed: writer.getBitCount(),
-        };
-    }
-    reset() {
-        this.previousStates.clear();
-    }
+  constructor(quantization) {
+    this.previousStates = /* @__PURE__ */ new Map();
+    this.quantization = { ...DEFAULT_QUANTIZATION, ...quantization };
+  }
+  encode(currentState) {
+    const writer = new BitWriter();
+    const delta = {
+      frame: 0,
+      timestamp: Date.now(),
+      entities: [],
+      deletedEntities: [],
+      events: []
+    };
+    const currentIds = new Set(Object.keys(currentState));
+    for (const id of this.previousStates.keys()) {
+      if (!currentIds.has(id)) {
+        delta.deletedEntities.push(id);
+      }
+    }
+    for (const [id, state] of Object.entries(currentState)) {
+      const previous = this.previousStates.get(id);
+      const isNew = !previous;
+      const deltaEntity = {
+        id,
+        isNew,
+        changedFields: [],
+        values: {}
+      };
+      for (const [field, value] of Object.entries(state)) {
+        const prevValue = previous?.[field];
+        if (isNew || !this.valuesEqual(value, prevValue)) {
+          deltaEntity.changedFields.push(field);
+          deltaEntity.values[field] = this.encodeValue(field, value);
+        }
+      }
+      if (deltaEntity.changedFields.length > 0 || isNew) {
+        delta.entities.push(deltaEntity);
+      }
+      this.previousStates.set(id, { ...state });
+    }
+    for (const id of delta.deletedEntities) {
+      this.previousStates.delete(id);
+    }
+    this.writeDelta(writer, delta);
+    const bytes = writer.finish();
+    const stats = this.calculateStats(currentState, bytes, delta, writer);
+    return { delta, bytes, stats };
+  }
+  valuesEqual(a, b) {
+    if (a === b) {
+      return true;
+    }
+    if (typeof a !== typeof b) {
+      return false;
+    }
+    if (typeof a === "number" && typeof b === "number") {
+      return Math.abs(a - b) < 1e-4;
+    }
+    return JSON.stringify(a) === JSON.stringify(b);
+  }
+  encodeValue(field, value) {
+    if (typeof value === "boolean") {
+      return { type: "bool", value, bits: 1 };
+    }
+    if (typeof value === "string") {
+      return { type: "string", value };
+    }
+    if (typeof value === "number") {
+      const config = this.getQuantizationConfig(field);
+      if (config) {
+        const quantized = quantize(value, config.min, config.max, config.bits);
+        return { type: "uint16", value, quantized, bits: config.bits };
+      }
+      return { type: "float16", value, bits: 16 };
+    }
+    return { type: "string", value: JSON.stringify(value) };
+  }
+  getQuantizationConfig(field) {
+    const lower = field.toLowerCase();
+    if (lower.includes("position") || lower.includes("pos")) {
+      return this.quantization.position;
+    }
+    if (lower.includes("rotation") || lower.includes("angle")) {
+      return this.quantization.rotation;
+    }
+    if (lower.includes("velocity") || lower.includes("speed")) {
+      return this.quantization.velocity;
+    }
+    if (lower.includes("health") || lower.includes("hp")) {
+      return this.quantization.health;
+    }
+    return this.quantization.custom[field];
+  }
+  writeDelta(writer, delta) {
+    writer.writeInt32(delta.timestamp);
+    writer.writeVarInt(delta.deletedEntities.length);
+    for (const id of delta.deletedEntities) {
+      writer.writeString(id);
+    }
+    writer.writeVarInt(delta.entities.length);
+    for (const entity of delta.entities) {
+      writer.writeString(entity.id);
+      writer.writeBool(entity.isNew);
+      writer.writeVarInt(entity.changedFields.length);
+      for (const field of entity.changedFields) {
+        writer.writeString(field);
+        this.writeValue(writer, entity.values[field]);
+      }
+    }
+  }
+  writeValue(writer, value) {
+    const typeIndex = [
+      "bool",
+      "int8",
+      "int16",
+      "int32",
+      "uint8",
+      "uint16",
+      "float16",
+      "float32",
+      "string"
+    ].indexOf(value.type);
+    writer.writeBits(typeIndex, 4);
+    switch (value.type) {
+      case "bool":
+        writer.writeBool(value.value);
+        break;
+      case "int8":
+      case "uint8":
+        writer.writeInt8(value.value);
+        break;
+      case "int16":
+      case "uint16":
+        if (value.quantized !== void 0 && value.bits) {
+          writer.writeBits(value.quantized, value.bits);
+        } else {
+          writer.writeInt16(value.value);
+        }
+        break;
+      case "int32":
+        writer.writeInt32(value.value);
+        break;
+      case "float16":
+        writer.writeFloat16(value.value);
+        break;
+      case "float32":
+        writer.writeFloat32(value.value);
+        break;
+      case "string":
+        writer.writeString(value.value);
+        break;
+    }
+  }
+  calculateStats(state, bytes, delta, writer) {
+    const rawBytes = JSON.stringify(state).length;
+    const compressedBytes = bytes.length;
+    return {
+      rawBytes,
+      compressedBytes,
+      compressionRatio: rawBytes / Math.max(1, compressedBytes),
+      entitiesEncoded: delta.entities.length,
+      fieldsChanged: delta.entities.reduce((sum, e) => sum + e.changedFields.length, 0),
+      bitsUsed: writer.getBitCount()
+    };
+  }
+  reset() {
+    this.previousStates.clear();
+  }
 }
-// ============================================================
-// Delta Decoder
-// ============================================================
 class DeltaDecoder {
-    constructor(quantization) {
-        this.currentState = new Map();
-        this.quantization = { ...DEFAULT_QUANTIZATION, ...quantization };
-    }
-    decode(bytes) {
-        const reader = new BitReader(bytes);
-        // Read timestamp
-        reader.readInt32();
-        // Read deleted entities
-        const deletedCount = reader.readVarInt();
-        for (let i = 0; i < deletedCount; i++) {
-            const id = reader.readString();
-            this.currentState.delete(id);
-        }
-        // Read entities
-        const entityCount = reader.readVarInt();
-        for (let i = 0; i < entityCount; i++) {
-            const id = reader.readString();
-            const isNew = reader.readBool();
-            const fieldCount = reader.readVarInt();
-            let entity = this.currentState.get(id);
-            if (!entity || isNew) {
-                entity = {};
-                this.currentState.set(id, entity);
-            }
-            for (let j = 0; j < fieldCount; j++) {
-                const field = reader.readString();
-                const value = this.readValue(reader, field);
-                entity[field] = value;
-            }
-        }
-        return Object.fromEntries(this.currentState);
-    }
-    readValue(reader, field) {
-        const typeIndex = reader.readBits(4);
-        const types = [
-            'bool',
-            'int8',
-            'int16',
-            'int32',
-            'uint8',
-            'uint16',
-            'float16',
-            'float32',
-            'string',
-        ];
-        const type = types[typeIndex];
-        switch (type) {
-            case 'bool':
-                return reader.readBool();
-            case 'int8':
-            case 'uint8':
-                return reader.readInt8();
-            case 'int16':
-            case 'uint16': {
-                const config = this.getQuantizationConfig(field);
-                if (config) {
-                    const quantized = reader.readBits(config.bits);
-                    return dequantize(quantized, config.min, config.max, config.bits);
-                }
-                return reader.readInt16();
-            }
-            case 'int32':
-                return reader.readInt32();
-            case 'float16':
-                return reader.readFloat16();
-            case 'float32':
-                return reader.readFloat32();
-            case 'string':
-                return reader.readString();
-            default:
-                return null;
-        }
-    }
-    getQuantizationConfig(field) {
-        const lower = field.toLowerCase();
-        if (lower.includes('position') || lower.includes('pos')) {
-            return this.quantization.position;
-        }
-        if (lower.includes('rotation') || lower.includes('angle')) {
-            return this.quantization.rotation;
-        }
-        if (lower.includes('velocity') || lower.includes('speed')) {
-            return this.quantization.velocity;
-        }
-        if (lower.includes('health') || lower.includes('hp')) {
-            return this.quantization.health;
-        }
-        return this.quantization.custom[field];
-    }
-    reset() {
-        this.currentState.clear();
-    }
-    getState() {
-        return Object.fromEntries(this.currentState);
-    }
+  constructor(quantization) {
+    this.currentState = /* @__PURE__ */ new Map();
+    this.quantization = { ...DEFAULT_QUANTIZATION, ...quantization };
+  }
+  decode(bytes) {
+    const reader = new BitReader(bytes);
+    reader.readInt32();
+    const deletedCount = reader.readVarInt();
+    for (let i = 0; i < deletedCount; i++) {
+      const id = reader.readString();
+      this.currentState.delete(id);
+    }
+    const entityCount = reader.readVarInt();
+    for (let i = 0; i < entityCount; i++) {
+      const id = reader.readString();
+      const isNew = reader.readBool();
+      const fieldCount = reader.readVarInt();
+      let entity = this.currentState.get(id);
+      if (!entity || isNew) {
+        entity = {};
+        this.currentState.set(id, entity);
+      }
+      for (let j = 0; j < fieldCount; j++) {
+        const field = reader.readString();
+        const value = this.readValue(reader, field);
+        entity[field] = value;
+      }
+    }
+    return Object.fromEntries(this.currentState);
+  }
+  readValue(reader, field) {
+    const typeIndex = reader.readBits(4);
+    const types = [
+      "bool",
+      "int8",
+      "int16",
+      "int32",
+      "uint8",
+      "uint16",
+      "float16",
+      "float32",
+      "string"
+    ];
+    const type = types[typeIndex];
+    switch (type) {
+      case "bool":
+        return reader.readBool();
+      case "int8":
+      case "uint8":
+        return reader.readInt8();
+      case "int16":
+      case "uint16": {
+        const config = this.getQuantizationConfig(field);
+        if (config) {
+          const quantized = reader.readBits(config.bits);
+          return dequantize(quantized, config.min, config.max, config.bits);
+        }
+        return reader.readInt16();
+      }
+      case "int32":
+        return reader.readInt32();
+      case "float16":
+        return reader.readFloat16();
+      case "float32":
+        return reader.readFloat32();
+      case "string":
+        return reader.readString();
+      default:
+        return null;
+    }
+  }
+  getQuantizationConfig(field) {
+    const lower = field.toLowerCase();
+    if (lower.includes("position") || lower.includes("pos")) {
+      return this.quantization.position;
+    }
+    if (lower.includes("rotation") || lower.includes("angle")) {
+      return this.quantization.rotation;
+    }
+    if (lower.includes("velocity") || lower.includes("speed")) {
+      return this.quantization.velocity;
+    }
+    if (lower.includes("health") || lower.includes("hp")) {
+      return this.quantization.health;
+    }
+    return this.quantization.custom[field];
+  }
+  reset() {
+    this.currentState.clear();
+  }
+  getState() {
+    return Object.fromEntries(this.currentState);
+  }
 }
-// ============================================================
-// Factory Functions
-// ============================================================
 function createDeltaEncoder(quantization) {
-    return new DeltaEncoder(quantization);
+  return new DeltaEncoder(quantization);
 }
 function createDeltaDecoder(quantization) {
-    return new DeltaDecoder(quantization);
+  return new DeltaDecoder(quantization);
 }
 function createBitWriter(initialSize) {
-    return new BitWriter(initialSize);
+  return new BitWriter(initialSize);
 }
 function createBitReader(buffer) {
-    return new BitReader(buffer);
+  return new BitReader(buffer);
 }
-
-export { BitReader, BitWriter, DEFAULT_QUANTIZATION, DeltaDecoder, DeltaEncoder, createBitReader, createBitWriter, createDeltaDecoder, createDeltaEncoder, dequantize, quantize };
+export {
+  BitReader,
+  BitWriter,
+  DEFAULT_QUANTIZATION,
+  DeltaDecoder,
+  DeltaEncoder,
+  createBitReader,
+  createBitWriter,
+  createDeltaDecoder,
+  createDeltaEncoder,
+  dequantize,
+  quantize
+};