@a0n/aeon 5.0.1

package/dist/compression/index.cjs

@@ -0,0 +1,1445 @@
+'use strict';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/utils/logger.ts
+var consoleLogger = {
+  debug: (...args) => {
+    console.debug("[AEON:DEBUG]", ...args);
+  },
+  info: (...args) => {
+    console.info("[AEON:INFO]", ...args);
+  },
+  warn: (...args) => {
+    console.warn("[AEON:WARN]", ...args);
+  },
+  error: (...args) => {
+    console.error("[AEON:ERROR]", ...args);
+  }
+};
+var currentLogger = consoleLogger;
+function getLogger() {
+  return currentLogger;
+}
+
+// src/compression/CompressionEngine.ts
+var logger = getLogger();
+var CompressionEngine = class {
+  stats = {
+    totalCompressed: 0,
+    totalDecompressed: 0,
+    totalOriginalBytes: 0,
+    totalCompressedBytes: 0,
+    averageCompressionRatio: 0,
+    compressionTimeMs: 0,
+    decompressionTimeMs: 0
+  };
+  preferredAlgorithm = "gzip";
+  constructor(preferredAlgorithm = "gzip") {
+    this.preferredAlgorithm = preferredAlgorithm;
+    logger.debug("[CompressionEngine] Initialized", {
+      algorithm: preferredAlgorithm,
+      supportsNative: this.supportsNativeCompression()
+    });
+  }
+  /**
+   * Check if native compression is available
+   */
+  supportsNativeCompression() {
+    return typeof CompressionStream !== "undefined" && typeof DecompressionStream !== "undefined";
+  }
+  /**
+   * Compress data
+   */
+  async compress(data) {
+    const startTime = performance.now();
+    const inputData = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    const originalSize = inputData.byteLength;
+    let compressed;
+    let algorithm = this.preferredAlgorithm;
+    if (this.supportsNativeCompression()) {
+      try {
+        compressed = await this.compressNative(
+          inputData,
+          this.preferredAlgorithm
+        );
+      } catch (error) {
+        logger.warn(
+          "[CompressionEngine] Native compression failed, using fallback",
+          error
+        );
+        compressed = inputData;
+        algorithm = "none";
+      }
+    } else {
+      compressed = inputData;
+      algorithm = "none";
+    }
+    const compressionRatio = originalSize > 0 ? 1 - compressed.byteLength / originalSize : 0;
+    const batch = {
+      id: `batch-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      compressed,
+      originalSize,
+      compressedSize: compressed.byteLength,
+      compressionRatio,
+      algorithm,
+      timestamp: Date.now()
+    };
+    const elapsed = performance.now() - startTime;
+    this.stats.totalCompressed++;
+    this.stats.totalOriginalBytes += originalSize;
+    this.stats.totalCompressedBytes += compressed.byteLength;
+    this.stats.compressionTimeMs += elapsed;
+    this.updateAverageRatio();
+    logger.debug("[CompressionEngine] Compressed", {
+      original: originalSize,
+      compressed: compressed.byteLength,
+      ratio: (compressionRatio * 100).toFixed(1) + "%",
+      algorithm,
+      timeMs: elapsed.toFixed(2)
+    });
+    return batch;
+  }
+  /**
+   * Decompress data
+   */
+  async decompress(batch) {
+    const startTime = performance.now();
+    let decompressed;
+    if (batch.algorithm === "none") {
+      decompressed = batch.compressed;
+    } else if (this.supportsNativeCompression()) {
+      try {
+        decompressed = await this.decompressNative(
+          batch.compressed,
+          batch.algorithm
+        );
+      } catch (error) {
+        logger.warn("[CompressionEngine] Native decompression failed", error);
+        throw error;
+      }
+    } else {
+      throw new Error("Native decompression not available");
+    }
+    const elapsed = performance.now() - startTime;
+    this.stats.totalDecompressed++;
+    this.stats.decompressionTimeMs += elapsed;
+    logger.debug("[CompressionEngine] Decompressed", {
+      compressed: batch.compressedSize,
+      decompressed: decompressed.byteLength,
+      algorithm: batch.algorithm,
+      timeMs: elapsed.toFixed(2)
+    });
+    return decompressed;
+  }
+  /**
+   * Compress using native CompressionStream
+   */
+  async compressNative(data, algorithm) {
+    const stream = new CompressionStream(algorithm);
+    const writer = stream.writable.getWriter();
+    const reader = stream.readable.getReader();
+    writer.write(
+      new Uint8Array(
+        data.buffer,
+        data.byteOffset,
+        data.byteLength
+      )
+    );
+    writer.close();
+    const chunks = [];
+    let done = false;
+    while (!done) {
+      const result = await reader.read();
+      done = result.done;
+      if (result.value) {
+        chunks.push(result.value);
+      }
+    }
+    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const combined = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      combined.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return combined;
+  }
+  /**
+   * Decompress using native DecompressionStream
+   */
+  async decompressNative(data, algorithm) {
+    const stream = new DecompressionStream(algorithm);
+    const writer = stream.writable.getWriter();
+    const reader = stream.readable.getReader();
+    writer.write(
+      new Uint8Array(
+        data.buffer,
+        data.byteOffset,
+        data.byteLength
+      )
+    );
+    writer.close();
+    const chunks = [];
+    let done = false;
+    while (!done) {
+      const result = await reader.read();
+      done = result.done;
+      if (result.value) {
+        chunks.push(result.value);
+      }
+    }
+    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const combined = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      combined.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return combined;
+  }
+  /**
+   * Split compressed batch into chunks for transmission
+   */
+  splitIntoChunks(batch, chunkSize = 64 * 1024) {
+    const chunks = [];
+    const data = batch.compressed;
+    const total = Math.ceil(data.byteLength / chunkSize);
+    for (let i = 0; i < total; i++) {
+      const start = i * chunkSize;
+      const end = Math.min(start + chunkSize, data.byteLength);
+      const chunkData = data.slice(start, end);
+      chunks.push({
+        chunkId: `${batch.id}-chunk-${i}`,
+        batchId: batch.id,
+        data: chunkData,
+        index: i,
+        total,
+        checksum: this.simpleChecksum(chunkData)
+      });
+    }
+    return chunks;
+  }
+  /**
+   * Reassemble chunks into compressed batch
+   */
+  reassembleChunks(chunks) {
+    const sorted = [...chunks].sort((a, b) => a.index - b.index);
+    if (sorted.length === 0) {
+      throw new Error("Cannot reassemble: no chunks provided");
+    }
+    const total = sorted[0].total;
+    if (sorted.length !== total) {
+      throw new Error(
+        `Missing chunks: got ${sorted.length}, expected ${total}`
+      );
+    }
+    const totalLength = sorted.reduce(
+      (sum, chunk) => sum + chunk.data.length,
+      0
+    );
+    const combined = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of sorted) {
+      combined.set(chunk.data, offset);
+      offset += chunk.data.length;
+    }
+    return combined;
+  }
+  /**
+   * Simple checksum for chunk verification
+   */
+  simpleChecksum(data) {
+    let hash = 0;
+    for (let i = 0; i < data.length; i++) {
+      hash = (hash << 5) - hash + data[i] | 0;
+    }
+    return (hash >>> 0).toString(16);
+  }
+  /**
+   * Update average compression ratio
+   */
+  updateAverageRatio() {
+    if (this.stats.totalOriginalBytes > 0) {
+      this.stats.averageCompressionRatio = 1 - this.stats.totalCompressedBytes / this.stats.totalOriginalBytes;
+    }
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return { ...this.stats };
+  }
+  /**
+   * Reset statistics
+   */
+  resetStats() {
+    this.stats = {
+      totalCompressed: 0,
+      totalDecompressed: 0,
+      totalOriginalBytes: 0,
+      totalCompressedBytes: 0,
+      averageCompressionRatio: 0,
+      compressionTimeMs: 0,
+      decompressionTimeMs: 0
+    };
+  }
+};
+var compressionEngineInstance = null;
+function getCompressionEngine() {
+  if (!compressionEngineInstance) {
+    compressionEngineInstance = new CompressionEngine();
+  }
+  return compressionEngineInstance;
+}
+function resetCompressionEngine() {
+  compressionEngineInstance = null;
+}
+
+// src/compression/DeltaSyncOptimizer.ts
+var logger2 = getLogger();
+var DeltaSyncOptimizer = class _DeltaSyncOptimizer {
+  static MAX_HISTORY_SIZE = 1e4;
+  operationHistory = /* @__PURE__ */ new Map();
+  stats = {
+    totalOperations: 0,
+    totalFull: 0,
+    totalDelta: 0,
+    totalOriginalSize: 0,
+    totalDeltaSize: 0,
+    averageReductionPercent: 0,
+    lastSyncTime: 0,
+    fullOperationThreshold: 1e3
+    // Force full if delta > 1KB
+  };
+  constructor(fullOperationThreshold = 1e3) {
+    this.stats.fullOperationThreshold = fullOperationThreshold;
+    logger2.debug("[DeltaSyncOptimizer] Initialized", {
+      threshold: fullOperationThreshold
+    });
+  }
+  /**
+   * Compute delta for single operation
+   */
+  computeDelta(operation) {
+    const operationJson = JSON.stringify(operation);
+    const originalSize = new TextEncoder().encode(operationJson).byteLength;
+    const previous = this.operationHistory.get(operation.id);
+    if (!previous) {
+      const delta = {
+        id: `delta-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+        type: "full",
+        operationId: operation.id,
+        operationType: operation.type,
+        sessionId: operation.sessionId,
+        timestamp: Date.now(),
+        fullData: operation.data,
+        priority: operation.priority
+      };
+      this.stats.totalOperations++;
+      this.stats.totalFull++;
+      this.stats.totalOriginalSize += originalSize;
+      const deltaSize2 = new TextEncoder().encode(
+        JSON.stringify(delta)
+      ).byteLength;
+      this.stats.totalDeltaSize += deltaSize2;
+      this.operationHistory.set(operation.id, operation);
+      if (this.operationHistory.size > _DeltaSyncOptimizer.MAX_HISTORY_SIZE) {
+        const firstKey = this.operationHistory.keys().next().value;
+        if (firstKey !== void 0) this.operationHistory.delete(firstKey);
+      }
+      return delta;
+    }
+    const changes = {};
+    const changeMask = [];
+    let hasMeaningfulChanges = false;
+    for (const [key, value] of Object.entries(operation.data)) {
+      const oldValue = previous.data[key];
+      if (!this.deepEqual(value, oldValue)) {
+        changes[key] = value;
+        changeMask.push(key);
+        hasMeaningfulChanges = true;
+      }
+    }
+    for (const key of Object.keys(previous.data)) {
+      if (!(key in operation.data)) {
+        changes[key] = null;
+        changeMask.push(`${key}:deleted`);
+        hasMeaningfulChanges = true;
+      }
+    }
+    const deltaData = {
+      id: `delta-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      type: "delta",
+      operationId: operation.id,
+      operationType: operation.type,
+      sessionId: operation.sessionId,
+      timestamp: Date.now(),
+      changes: hasMeaningfulChanges ? changes : void 0,
+      changeMask: hasMeaningfulChanges ? changeMask : void 0,
+      priority: operation.priority
+    };
+    const deltaSize = new TextEncoder().encode(
+      JSON.stringify(deltaData)
+    ).byteLength;
+    const finalDelta = deltaSize > this.stats.fullOperationThreshold ? {
+      ...deltaData,
+      type: "full",
+      fullData: operation.data,
+      changes: void 0,
+      changeMask: void 0
+    } : deltaData;
+    this.stats.totalOperations++;
+    if (finalDelta.type === "full") {
+      this.stats.totalFull++;
+    } else {
+      this.stats.totalDelta++;
+    }
+    this.stats.totalOriginalSize += originalSize;
+    this.stats.totalDeltaSize += deltaSize;
+    this.operationHistory.set(operation.id, operation);
+    if (this.operationHistory.size > _DeltaSyncOptimizer.MAX_HISTORY_SIZE) {
+      const firstKey = this.operationHistory.keys().next().value;
+      if (firstKey !== void 0) this.operationHistory.delete(firstKey);
+    }
+    return finalDelta;
+  }
+  /**
+   * Compute deltas for batch of operations
+   */
+  computeBatchDeltas(operations) {
+    const deltas = operations.map((op) => this.computeDelta(op));
+    const totalOriginalSize = operations.reduce(
+      (sum, op) => sum + new TextEncoder().encode(JSON.stringify(op)).byteLength,
+      0
+    );
+    const totalDeltaSize = deltas.reduce(
+      (sum, delta) => sum + new TextEncoder().encode(JSON.stringify(delta)).byteLength,
+      0
+    );
+    const reductionPercent = totalOriginalSize > 0 ? Math.round(
+      (totalOriginalSize - totalDeltaSize) / totalOriginalSize * 100
+    ) : 0;
+    const batch = {
+      batchId: `batch-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      operations: deltas,
+      timestamp: Date.now(),
+      totalOriginalSize,
+      totalDeltaSize,
+      reductionPercent
+    };
+    logger2.debug("[DeltaSyncOptimizer] Batch computed", {
+      operations: operations.length,
+      reduction: reductionPercent,
+      size: totalDeltaSize
+    });
+    return batch;
+  }
+  /**
+   * Decompress delta operation back to full operation
+   */
+  decompressDelta(delta) {
+    if (delta.type === "full") {
+      return {
+        id: delta.operationId,
+        type: delta.operationType,
+        sessionId: delta.sessionId,
+        data: delta.fullData || {},
+        status: "pending",
+        createdAt: delta.timestamp
+      };
+    }
+    const previous = this.operationHistory.get(delta.operationId);
+    if (!previous) {
+      logger2.warn("[DeltaSyncOptimizer] Cannot decompress - no history", {
+        operationId: delta.operationId
+      });
+      return {
+        id: delta.operationId,
+        type: delta.operationType,
+        sessionId: delta.sessionId,
+        data: delta.changes || {},
+        status: "pending",
+        createdAt: delta.timestamp
+      };
+    }
+    const reconstructed = {
+      ...previous,
+      data: {
+        ...previous.data,
+        ...delta.changes || {}
+      }
+    };
+    if (delta.changes) {
+      for (const [key, value] of Object.entries(delta.changes)) {
+        if (value === null) {
+          delete reconstructed.data[key];
+        }
+      }
+    }
+    return reconstructed;
+  }
+  /**
+   * Update history after successful sync
+   */
+  updateHistory(operations) {
+    for (const op of operations) {
+      this.operationHistory.set(op.id, op);
+    }
+    while (this.operationHistory.size > _DeltaSyncOptimizer.MAX_HISTORY_SIZE) {
+      const firstKey = this.operationHistory.keys().next().value;
+      if (firstKey !== void 0) this.operationHistory.delete(firstKey);
+      else break;
+    }
+    logger2.debug("[DeltaSyncOptimizer] History updated", {
+      count: operations.length,
+      totalHistorySize: this.operationHistory.size
+    });
+  }
+  /**
+   * Clear history for specific operations
+   */
+  clearHistory(operationIds) {
+    for (const id of operationIds) {
+      this.operationHistory.delete(id);
+    }
+    logger2.debug("[DeltaSyncOptimizer] History cleared", {
+      cleared: operationIds.length,
+      remaining: this.operationHistory.size
+    });
+  }
+  /**
+   * Get current performance statistics
+   */
+  getStats() {
+    if (this.stats.totalOperations > 0) {
+      this.stats.averageReductionPercent = Math.round(
+        (this.stats.totalOriginalSize - this.stats.totalDeltaSize) / this.stats.totalOriginalSize * 100
+      );
+    }
+    return { ...this.stats };
+  }
+  /**
+   * Reset statistics
+   */
+  resetStats() {
+    this.stats = {
+      totalOperations: 0,
+      totalFull: 0,
+      totalDelta: 0,
+      totalOriginalSize: 0,
+      totalDeltaSize: 0,
+      averageReductionPercent: 0,
+      lastSyncTime: 0,
+      fullOperationThreshold: this.stats.fullOperationThreshold
+    };
+    logger2.debug("[DeltaSyncOptimizer] Stats reset");
+  }
+  /**
+   * Set the full operation threshold
+   */
+  setFullOperationThreshold(bytes) {
+    this.stats.fullOperationThreshold = bytes;
+    logger2.debug("[DeltaSyncOptimizer] Threshold updated", { bytes });
+  }
+  /**
+   * Get history size for memory monitoring
+   */
+  getHistorySize() {
+    return this.operationHistory.size;
+  }
+  /**
+   * Get memory footprint estimate
+   */
+  getMemoryEstimate() {
+    let totalBytes = 0;
+    for (const op of this.operationHistory.values()) {
+      totalBytes += new TextEncoder().encode(JSON.stringify(op)).byteLength;
+    }
+    return totalBytes;
+  }
+  /**
+   * Deep equality check for nested objects
+   */
+  deepEqual(a, b) {
+    if (a === b) return true;
+    if (a == null || b == null) return false;
+    if (typeof a !== "object" || typeof b !== "object") return false;
+    const aObj = a;
+    const bObj = b;
+    const aKeys = Object.keys(aObj);
+    const bKeys = Object.keys(bObj);
+    if (aKeys.length !== bKeys.length) return false;
+    for (const key of aKeys) {
+      if (!this.deepEqual(aObj[key], bObj[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+var deltaSyncInstance = null;
+function getDeltaSyncOptimizer(threshold) {
+  if (!deltaSyncInstance) {
+    deltaSyncInstance = new DeltaSyncOptimizer(threshold);
+  }
+  return deltaSyncInstance;
+}
+function resetDeltaSyncOptimizer() {
+  deltaSyncInstance = null;
+}
+
+// src/compression/codecs.ts
+var RawCodec = class {
+  id = 0;
+  name = "raw";
+  encode(data) {
+    return data;
+  }
+  decode(data) {
+    return data;
+  }
+};
+var RLECodec = class {
+  id = 1;
+  name = "rle";
+  encode(data) {
+    if (data.length === 0) return new Uint8Array(0);
+    const output = new Uint8Array(data.length * 3);
+    let writePos = 0;
+    let i = 0;
+    while (i < data.length) {
+      const byte = data[i];
+      let runLength = 1;
+      while (i + runLength < data.length && data[i + runLength] === byte && runLength < 65535) {
+        runLength++;
+      }
+      output[writePos++] = byte;
+      output[writePos++] = runLength >>> 8 & 255;
+      output[writePos++] = runLength & 255;
+      i += runLength;
+    }
+    return output.subarray(0, writePos);
+  }
+  decode(data, originalSize) {
+    const output = new Uint8Array(originalSize);
+    let readPos = 0;
+    let writePos = 0;
+    while (readPos < data.length && writePos < originalSize) {
+      const byte = data[readPos++];
+      const count = data[readPos++] << 8 | data[readPos++];
+      const end = Math.min(writePos + count, originalSize);
+      output.fill(byte, writePos, end);
+      writePos = end;
+    }
+    return output;
+  }
+};
+var DeltaCodec = class {
+  id = 2;
+  name = "delta";
+  encode(data) {
+    if (data.length === 0) return new Uint8Array(0);
+    const output = new Uint8Array(data.length);
+    output[0] = data[0];
+    for (let i = 1; i < data.length; i++) {
+      output[i] = data[i] - data[i - 1] & 255;
+    }
+    return output;
+  }
+  decode(data, originalSize) {
+    const output = new Uint8Array(originalSize);
+    if (data.length === 0) return output;
+    output[0] = data[0];
+    for (let i = 1; i < data.length && i < originalSize; i++) {
+      output[i] = output[i - 1] + data[i] & 255;
+    }
+    return output;
+  }
+};
+var LZ77Codec = class _LZ77Codec {
+  id = 3;
+  name = "lz77";
+  static WINDOW_SIZE = 4096;
+  static MIN_MATCH = 3;
+  static MAX_MATCH = 18;
+  encode(data) {
+    if (data.length === 0) return new Uint8Array(0);
+    const output = new Uint8Array(data.length + Math.ceil(data.length / 8) + 16);
+    let writePos = 0;
+    let readPos = 0;
+    while (readPos < data.length) {
+      const controlPos = writePos++;
+      let controlByte = 0;
+      for (let bit = 0; bit < 8 && readPos < data.length; bit++) {
+        const windowStart = Math.max(0, readPos - _LZ77Codec.WINDOW_SIZE);
+        let bestOffset = 0;
+        let bestLength = 0;
+        for (let j = windowStart; j < readPos; j++) {
+          let matchLen = 0;
+          while (matchLen < _LZ77Codec.MAX_MATCH && readPos + matchLen < data.length && data[j + matchLen] === data[readPos + matchLen]) {
+            matchLen++;
+          }
+          if (matchLen >= _LZ77Codec.MIN_MATCH && matchLen > bestLength) {
+            bestOffset = readPos - j;
+            bestLength = matchLen;
+          }
+        }
+        if (bestLength >= _LZ77Codec.MIN_MATCH) {
+          controlByte |= 1 << bit;
+          const lengthCode = bestLength - _LZ77Codec.MIN_MATCH;
+          output[writePos++] = bestOffset >>> 8 & 15 | lengthCode << 4;
+          output[writePos++] = bestOffset & 255;
+          readPos += bestLength;
+        } else {
+          output[writePos++] = data[readPos++];
+        }
+      }
+      output[controlPos] = controlByte;
+    }
+    return output.subarray(0, writePos);
+  }
+  decode(data, originalSize) {
+    const output = new Uint8Array(originalSize);
+    let readPos = 0;
+    let writePos = 0;
+    while (readPos < data.length && writePos < originalSize) {
+      const controlByte = data[readPos++];
+      for (let bit = 0; bit < 8 && readPos < data.length && writePos < originalSize; bit++) {
+        if (controlByte & 1 << bit) {
+          const byte1 = data[readPos++];
+          const byte2 = data[readPos++];
+          const offset = (byte1 & 15) << 8 | byte2;
+          const length = (byte1 >>> 4) + _LZ77Codec.MIN_MATCH;
+          const srcStart = writePos - offset;
+          for (let k = 0; k < length && writePos < originalSize; k++) {
+            output[writePos++] = output[srcStart + k];
+          }
+        } else {
+          output[writePos++] = data[readPos++];
+        }
+      }
+    }
+    return output;
+  }
+};
+var BrotliCodec = class {
+  id = 4;
+  name = "brotli";
+  quality;
+  constructor(quality = 4) {
+    this.quality = quality;
+  }
+  encode(data) {
+    try {
+      const zlib = __require("zlib");
+      return new Uint8Array(zlib.brotliCompressSync(Buffer.from(data), {
+        params: {
+          [zlib.constants.BROTLI_PARAM_QUALITY]: this.quality
+        }
+      }));
+    } catch {
+      return data;
+    }
+  }
+  decode(data) {
+    const zlib = __require("zlib");
+    return new Uint8Array(zlib.brotliDecompressSync(Buffer.from(data)));
+  }
+};
+var GzipCodec = class {
+  id = 5;
+  name = "gzip";
+  level;
+  constructor(level = 6) {
+    this.level = level;
+  }
+  encode(data) {
+    try {
+      const zlib = __require("zlib");
+      return new Uint8Array(zlib.gzipSync(Buffer.from(data), {
+        level: this.level
+      }));
+    } catch {
+      return data;
+    }
+  }
+  decode(data) {
+    const zlib = __require("zlib");
+    return new Uint8Array(zlib.gunzipSync(Buffer.from(data)));
+  }
+};
+var HuffmanCodec = class {
+  id = 6;
+  name = "huffman";
+  encode(data) {
+    if (data.length < 32) return data;
+    const freq = new Uint32Array(256);
+    for (let i = 0; i < data.length; i++) freq[data[i]]++;
+    const symbols = [];
+    for (let i = 0; i < 256; i++) {
+      if (freq[i] > 0) symbols.push({ sym: i, freq: freq[i] });
+    }
+    if (symbols.length <= 1) return data;
+    const nodes = symbols.map((s) => ({
+      freq: s.freq,
+      sym: s.sym,
+      left: -1,
+      right: -1
+    }));
+    const heap = [...nodes];
+    heap.sort((a, b) => a.freq - b.freq);
+    while (heap.length > 1) {
+      const left = heap.shift();
+      const right = heap.shift();
+      const leftIdx = nodes.indexOf(left);
+      const rightIdx = nodes.indexOf(right);
+      const parent = {
+        freq: left.freq + right.freq,
+        sym: -1,
+        left: leftIdx,
+        right: rightIdx
+      };
+      nodes.push(parent);
+      let idx = 0;
+      while (idx < heap.length && heap[idx].freq <= parent.freq) idx++;
+      heap.splice(idx, 0, parent);
+    }
+    const codeLengths = new Uint8Array(256);
+    const root = nodes.length - 1;
+    const dfs = (nodeIdx, depth) => {
+      const node = nodes[nodeIdx];
+      if (node.left === -1 && node.right === -1) {
+        codeLengths[node.sym] = depth || 1;
+        return;
+      }
+      if (node.left >= 0) dfs(node.left, depth + 1);
+      if (node.right >= 0) dfs(node.right, depth + 1);
+    };
+    dfs(root, 0);
+    for (let i = 0; i < 256; i++) {
+      if (codeLengths[i] > 15) return data;
+    }
+    const sorted = [];
+    for (let i = 0; i < 256; i++) {
+      if (codeLengths[i] > 0) sorted.push({ sym: i, len: codeLengths[i] });
+    }
+    sorted.sort((a, b) => a.len - b.len || a.sym - b.sym);
+    const codes = new Uint32Array(256);
+    let code = 0;
+    let prevLen = sorted[0].len;
+    codes[sorted[0].sym] = 0;
+    for (let i = 1; i < sorted.length; i++) {
+      code = code + 1 << sorted[i].len - prevLen;
+      codes[sorted[i].sym] = code;
+      prevLen = sorted[i].len;
+    }
+    let totalBits = 0;
+    for (let i = 0; i < data.length; i++) totalBits += codeLengths[data[i]];
+    const totalBytes = Math.ceil(totalBits / 8);
+    const headerSize = 260;
+    const output = new Uint8Array(headerSize + totalBytes);
+    output.set(codeLengths, 0);
+    new DataView(output.buffer).setUint32(256, totalBits);
+    let bitPos = 0;
+    for (let i = 0; i < data.length; i++) {
+      const sym = data[i];
+      const codeVal = codes[sym];
+      const codeLen = codeLengths[sym];
+      for (let b = codeLen - 1; b >= 0; b--) {
+        if (codeVal >>> b & 1) {
+          const byteIdx = headerSize + (bitPos >>> 3);
+          output[byteIdx] |= 1 << 7 - (bitPos & 7);
+        }
+        bitPos++;
+      }
+    }
+    return output;
+  }
+  decode(data, originalSize) {
+    if (data.length < 260) return data.subarray(0, originalSize);
+    const codeLengths = data.subarray(0, 256);
+    const totalBits = new DataView(
+      data.buffer,
+      data.byteOffset + 256,
+      4
+    ).getUint32(0);
+    const sorted = [];
+    for (let i = 0; i < 256; i++) {
+      if (codeLengths[i] > 0) sorted.push({ sym: i, len: codeLengths[i] });
+    }
+    sorted.sort((a, b) => a.len - b.len || a.sym - b.sym);
+    const tree = [[-1, -1, -1]];
+    const insertCode = (codeVal, len, sym) => {
+      let node = 0;
+      for (let b = len - 1; b >= 0; b--) {
+        const bit = codeVal >>> b & 1;
+        if (tree[node][bit] === -1) {
+          tree[node][bit] = tree.length;
+          tree.push([-1, -1, -1]);
+        }
+        node = tree[node][bit];
+      }
+      tree[node][2] = sym;
+    };
+    let code = 0;
+    let prevLen = sorted[0].len;
+    insertCode(0, sorted[0].len, sorted[0].sym);
+    for (let i = 1; i < sorted.length; i++) {
+      code = code + 1 << sorted[i].len - prevLen;
+      insertCode(code, sorted[i].len, sorted[i].sym);
+      prevLen = sorted[i].len;
+    }
+    const output = new Uint8Array(originalSize);
+    let bitPos = 0;
+    let outPos = 0;
+    const bitsStart = 260;
+    while (outPos < originalSize && bitPos < totalBits) {
+      let node = 0;
+      while (tree[node][2] === -1 && bitPos < totalBits) {
+        const byteIdx = bitsStart + (bitPos >>> 3);
+        const bit = data[byteIdx] >>> 7 - (bitPos & 7) & 1;
+        node = tree[node][bit];
+        bitPos++;
+      }
+      if (tree[node][2] !== -1) {
+        output[outPos++] = tree[node][2];
+      }
+    }
+    return output;
+  }
+};
+var DICTIONARY_STRINGS = [
+  // Long patterns first (most savings per match)
+  "addEventListener",
+  // 16 bytes → 2 = saves 14
+  "querySelector",
+  // 13 → 2 = saves 11
+  "createElement",
+  // 13 → 2 = saves 11
+  "justify-content",
+  // 15 → 2 = saves 13
+  "align-items:center",
+  // 19 → 2 = saves 17
+  "textContent",
+  // 11 → 2 = saves 9
+  "display:flex",
+  // 12 → 2 = saves 10
+  "display:grid",
+  // 12 → 2 = saves 10
+  "display:none",
+  // 12 → 2 = saves 10
+  "background:",
+  // 11 → 2 = saves 9
+  "font-weight:",
+  // 12 → 2 = saves 10
+  "font-size:",
+  // 10 → 2 = saves 8
+  "className",
+  // 9 → 2 = saves 7
+  "undefined",
+  // 9 → 2 = saves 7
+  "container",
+  // 9 → 2 = saves 7
+  "transform:",
+  // 10 → 2 = saves 8
+  "overflow:",
+  // 9 → 2 = saves 7
+  "position:",
+  // 9 → 2 = saves 7
+  "function ",
+  // 9 → 2 = saves 7
+  "children",
+  // 8 → 2 = saves 6
+  "document",
+  // 8 → 2 = saves 6
+  "display:",
+  // 8 → 2 = saves 6
+  "padding:",
+  // 8 → 2 = saves 6
+  "onClick",
+  // 7 → 2 = saves 5
+  "useState",
+  // 8 → 2 = saves 6
+  "https://",
+  // 8 → 2 = saves 6
+  "default",
+  // 7 → 2 = saves 5
+  "extends",
+  // 7 → 2 = saves 5
+  "return ",
+  // 7 → 2 = saves 5
+  "export ",
+  // 7 → 2 = saves 5
+  "import ",
+  // 7 → 2 = saves 5
+  "margin:",
+  // 7 → 2 = saves 5
+  "border:",
+  // 7 → 2 = saves 5
+  "cursor:",
+  // 7 → 2 = saves 5
+  "height:",
+  // 7 → 2 = saves 5
+  "</span>",
+  // 7 → 2 = saves 5
+  "color:",
+  // 6 → 2 = saves 4
+  "width:",
+  // 6 → 2 = saves 4
+  "const ",
+  // 6 → 2 = saves 4
+  "class ",
+  // 6 → 2 = saves 4
+  "</div>",
+  // 6 → 2 = saves 4
+  "<span ",
+  // 6 → 2 = saves 4
+  "<div ",
+  // 5 → 2 = saves 3
+  "async",
+  // 5 → 2 = saves 3
+  "await",
+  // 5 → 2 = saves 3
+  "false",
+  // 5 → 2 = saves 3
+  "this.",
+  // 5 → 2 = saves 3
+  "props",
+  // 5 → 2 = saves 3
+  "state",
+  // 5 → 2 = saves 3
+  "</p>",
+  // 4 → 2 = saves 2
+  "null",
+  // 4 → 2 = saves 2
+  "true",
+  // 4 → 2 = saves 2
+  "flex",
+  // 4 → 2 = saves 2
+  "grid",
+  // 4 → 2 = saves 2
+  "none",
+  // 4 → 2 = saves 2
+  "auto",
+  // 4 → 2 = saves 2
+  "self",
+  // 4 → 2 = saves 2
+  ".css",
+  // 4 → 2 = saves 2
+  ".com",
+  // 4 → 2 = saves 2
+  "var(",
+  // 4 → 2 = saves 2
+  "<p>",
+  // 3 → 2 = saves 1
+  ".js",
+  // 3 → 2 = saves 1
+  "px;",
+  // 3 → 2 = saves 1
+  "rem"
+  // 3 → 2 = saves 1
+];
+var DICTIONARY = DICTIONARY_STRINGS.map(
+  (s) => new TextEncoder().encode(s)
+);
+var DictionaryCodec = class {
+  id = 7;
+  name = "dictionary";
+  encode(data) {
+    if (data.length < 4) return data;
+    const output = [];
+    let pos = 0;
+    while (pos < data.length) {
+      let matched = false;
+      for (let idx = 0; idx < DICTIONARY.length; idx++) {
+        const entry = DICTIONARY[idx];
+        if (pos + entry.length > data.length) continue;
+        let match = true;
+        for (let j = 0; j < entry.length; j++) {
+          if (data[pos + j] !== entry[j]) {
+            match = false;
+            break;
+          }
+        }
+        if (match) {
+          output.push(0, idx + 1);
+          pos += entry.length;
+          matched = true;
+          break;
+        }
+      }
+      if (!matched) {
+        if (data[pos] === 0) {
+          output.push(0, 0);
+        } else {
+          output.push(data[pos]);
+        }
+        pos++;
+      }
+    }
+    return new Uint8Array(output);
+  }
+  decode(data, originalSize) {
+    const output = [];
+    let pos = 0;
+    while (pos < data.length && output.length < originalSize) {
+      if (data[pos] === 0) {
+        pos++;
+        if (data[pos] === 0) {
+          output.push(0);
+        } else {
+          const entry = DICTIONARY[data[pos] - 1];
+          for (let j = 0; j < entry.length; j++) output.push(entry[j]);
+        }
+        pos++;
+      } else {
+        output.push(data[pos]);
+        pos++;
+      }
+    }
+    return new Uint8Array(output);
+  }
+};
+var PURE_JS_CODECS = [
+  new RawCodec(),
+  new RLECodec(),
+  new DeltaCodec(),
+  new LZ77Codec(),
+  new HuffmanCodec(),
+  new DictionaryCodec()
+];
+var BUILTIN_CODECS = [
+  ...PURE_JS_CODECS,
+  new BrotliCodec(),
+  new GzipCodec()
+];
+var CODEC_MAP = new Map(
+  BUILTIN_CODECS.map((c) => [c.id, c])
+);
+function getCodecById(id) {
+  const codec = CODEC_MAP.get(id);
+  if (!codec) {
+    throw new Error(`Unknown codec ID: ${id}`);
+  }
+  return codec;
+}
+
+// src/compression/TopologicalCompressor.ts
+var CHUNK_HEADER_SIZE = 9;
+function encodeChunkHeader(codecId, originalSize, compressedSize) {
+  const header = new Uint8Array(CHUNK_HEADER_SIZE);
+  const view = new DataView(header.buffer);
+  header[0] = codecId;
+  view.setUint32(1, originalSize);
+  view.setUint32(5, compressedSize);
+  return header;
+}
+function decodeChunkHeader(data, offset) {
+  const codecId = data[offset];
+  const view = new DataView(data.buffer, data.byteOffset + offset + 1, 8);
+  const originalSize = view.getUint32(0);
+  const compressedSize = view.getUint32(4);
+  return { codecId, originalSize, compressedSize };
+}
+var STREAM_HEADER_SIZE = 5;
+function encodeStreamHeader(strategy, originalSize) {
+  const header = new Uint8Array(STREAM_HEADER_SIZE);
+  header[0] = strategy;
+  new DataView(header.buffer).setUint32(1, originalSize);
+  return header;
+}
+function decodeStreamHeader(data) {
+  const strategy = data[0];
+  const originalSize = new DataView(
+    data.buffer,
+    data.byteOffset + 1,
+    4
+  ).getUint32(0);
+  return { strategy, originalSize };
+}
+var TopologicalCompressor = class {
+  config;
+  constructor(config) {
+    this.config = {
+      chunkSize: config?.chunkSize ?? 4096,
+      codecs: config?.codecs ?? BUILTIN_CODECS,
+      streamRace: config?.streamRace ?? false
+    };
+  }
+  /**
+   * Compress data using fork/race/fold.
+   *
+   * When streamRace=false (default): per-chunk race only.
+   * When streamRace=true: two-level race — global codecs vs per-chunk topo.
+   */
+  compress(data) {
+    if (data.length === 0) {
+      return {
+        data: new Uint8Array(0),
+        chunks: [],
+        originalSize: 0,
+        compressedSize: 0,
+        ratio: 0,
+        codecsUsed: 0,
+        bettiNumber: 0,
+        timeMs: 0
+      };
+    }
+    if (!this.config.streamRace) {
+      return this.compressChunked(data);
+    }
+    return this.compressTwoLevel(data);
+  }
+  /**
+   * Decompress data produced by compress().
+   */
+  decompress(compressed) {
+    if (compressed.length === 0) return new Uint8Array(0);
+    if (!this.config.streamRace) {
+      return this.decompressChunked(compressed);
+    }
+    return this.decompressTwoLevel(compressed);
+  }
+  // ════════════════════════════════════════════════════════════════════════
+  // Level 2: Per-Chunk Topological Compression
+  // ════════════════════════════════════════════════════════════════════════
+  compressChunked(data) {
+    const startTime = performance.now();
+    const { chunkSize, codecs } = this.config;
+    const numChunks = Math.ceil(data.length / chunkSize);
+    const compressedChunks = [];
+    const chunkResults = [];
+    const codecWins = /* @__PURE__ */ new Set();
+    const bettiNumber = Math.max(0, codecs.length - 1);
+    for (let i = 0; i < numChunks; i++) {
+      const chunkStart = i * chunkSize;
+      const chunkEnd = Math.min(chunkStart + chunkSize, data.length);
+      const chunk = data.subarray(chunkStart, chunkEnd);
+      let bestCodecId = 0;
+      let bestCompressed = chunk;
+      let ventCount = 0;
+      for (const codec of codecs) {
+        const compressed = codec.encode(chunk);
+        if (compressed.length >= chunk.length && codec.id !== 0) {
+          ventCount++;
+          continue;
+        }
+        if (compressed.length < bestCompressed.length) {
+          bestCodecId = codec.id;
+          bestCompressed = compressed;
+        }
+      }
+      const header = encodeChunkHeader(
+        bestCodecId,
+        chunk.length,
+        bestCompressed.length
+      );
+      const frame = new Uint8Array(CHUNK_HEADER_SIZE + bestCompressed.length);
+      frame.set(header, 0);
+      frame.set(bestCompressed, CHUNK_HEADER_SIZE);
+      compressedChunks.push(frame);
+      codecWins.add(bestCodecId);
+      const codecName = codecs.find((c) => c.id === bestCodecId)?.name ?? "unknown";
+      chunkResults.push({
+        chunkIndex: i,
+        codecId: bestCodecId,
+        codecName,
+        originalSize: chunk.length,
+        compressedSize: frame.length,
+        ratio: chunk.length > 0 ? 1 - frame.length / chunk.length : 0,
+        vented: ventCount
+      });
+    }
+    const totalCompressedSize = compressedChunks.reduce(
+      (sum, c) => sum + c.length,
+      0
+    );
+    const output = new Uint8Array(totalCompressedSize);
+    let offset = 0;
+    for (const c of compressedChunks) {
+      output.set(c, offset);
+      offset += c.length;
+    }
+    return {
+      data: output,
+      chunks: chunkResults,
+      originalSize: data.length,
+      compressedSize: totalCompressedSize,
+      ratio: data.length > 0 ? 1 - totalCompressedSize / data.length : 0,
+      codecsUsed: codecWins.size,
+      bettiNumber,
+      timeMs: performance.now() - startTime
+    };
+  }
+  decompressChunked(compressed) {
+    const chunks = [];
+    let totalOriginalSize = 0;
+    let readPos = 0;
+    while (readPos < compressed.length) {
+      if (readPos + CHUNK_HEADER_SIZE > compressed.length) {
+        throw new Error(`Truncated chunk header at offset ${readPos}`);
+      }
+      const { codecId, originalSize, compressedSize } = decodeChunkHeader(
+        compressed,
+        readPos
+      );
+      readPos += CHUNK_HEADER_SIZE;
+      if (readPos + compressedSize > compressed.length) {
+        throw new Error(
+          `Truncated chunk data at offset ${readPos}: need ${compressedSize}, have ${compressed.length - readPos}`
+        );
+      }
+      chunks.push({
+        codecId,
+        originalSize,
+        compressedData: compressed.subarray(readPos, readPos + compressedSize)
+      });
+      readPos += compressedSize;
+      totalOriginalSize += originalSize;
+    }
+    const output = new Uint8Array(totalOriginalSize);
+    let writePos = 0;
+    for (const chunk of chunks) {
+      const codec = getCodecById(chunk.codecId);
+      const decompressed = codec.decode(
+        chunk.compressedData,
+        chunk.originalSize
+      );
+      output.set(decompressed, writePos);
+      writePos += chunk.originalSize;
+    }
+    return output;
+  }
+  // ════════════════════════════════════════════════════════════════════════
+  // Level 1: Stream-Level Two-Level Race
+  // ════════════════════════════════════════════════════════════════════════
+  /**
+   * Two-level fork/race/fold:
+   *
+   *   FORK (stream level):
+   *     ├─ Path 0: Per-chunk topological (Level 2)
+   *     ├─ Path 1: Global codec A on entire stream
+   *     ├─ Path 2: Global codec B on entire stream
+   *     └─ ...
+   *   RACE: Smallest total output wins
+   *   FOLD: 5-byte strategy header + compressed data
+   *
+   * On homogeneous text, global brotli wins (cross-chunk dictionary).
+   * On mixed content, per-chunk topo wins (adapts per region).
+   * The topology decides — not the programmer.
+   */
+  compressTwoLevel(data) {
+    const startTime = performance.now();
+    const { codecs } = this.config;
+    const chunkedResult = this.compressChunked(data);
+    const chunkedTotal = STREAM_HEADER_SIZE + chunkedResult.compressedSize;
+    const globalCandidates = [];
+    for (const codec of codecs) {
+      if (codec.id === 0) continue;
+      try {
+        const compressed = codec.encode(data);
+        const totalSize = STREAM_HEADER_SIZE + compressed.length;
+        if (compressed.length < data.length) {
+          globalCandidates.push({
+            codecId: codec.id,
+            codecName: codec.name,
+            compressed,
+            totalSize
+          });
+        }
+      } catch {
+      }
+    }
+    let bestStrategy = 0;
+    let bestSize = chunkedTotal;
+    let bestGlobal = null;
+    for (const candidate of globalCandidates) {
+      if (candidate.totalSize < bestSize) {
+        bestStrategy = candidate.codecId;
+        bestSize = candidate.totalSize;
+        bestGlobal = candidate;
+      }
+    }
+    const streamHeader = encodeStreamHeader(bestStrategy, data.length);
+    const outerPaths = globalCandidates.length + 1;
+    const innerBeta = Math.max(0, codecs.length - 1);
+    const totalBeta = outerPaths - 1 + innerBeta;
+    if (bestStrategy === 0) {
+      const output = new Uint8Array(STREAM_HEADER_SIZE + chunkedResult.data.length);
+      output.set(streamHeader, 0);
+      output.set(chunkedResult.data, STREAM_HEADER_SIZE);
+      return {
+        ...chunkedResult,
+        data: output,
+        compressedSize: output.length,
+        ratio: data.length > 0 ? 1 - output.length / data.length : 0,
+        bettiNumber: totalBeta,
+        strategy: "chunked",
+        timeMs: performance.now() - startTime
+      };
+    } else {
+      const output = new Uint8Array(STREAM_HEADER_SIZE + bestGlobal.compressed.length);
+      output.set(streamHeader, 0);
+      output.set(bestGlobal.compressed, STREAM_HEADER_SIZE);
+      return {
+        data: output,
+        chunks: [],
+        originalSize: data.length,
+        compressedSize: output.length,
+        ratio: data.length > 0 ? 1 - output.length / data.length : 0,
+        codecsUsed: 1,
+        bettiNumber: totalBeta,
+        strategy: `global:${bestGlobal.codecName}`,
+        timeMs: performance.now() - startTime
+      };
+    }
+  }
+  decompressTwoLevel(compressed) {
+    if (compressed.length < STREAM_HEADER_SIZE) {
+      throw new Error("Truncated stream header");
+    }
+    const { strategy, originalSize } = decodeStreamHeader(compressed);
+    const payload = compressed.subarray(STREAM_HEADER_SIZE);
+    if (strategy === 0) {
+      return this.decompressChunked(payload);
+    } else {
+      const codec = getCodecById(strategy);
+      return codec.decode(payload, originalSize);
+    }
+  }
+  /** Get the codecs available for racing. */
+  getCodecs() {
+    return this.config.codecs;
+  }
+  /** Get the chunk size. */
+  getChunkSize() {
+    return this.config.chunkSize;
+  }
+};
+
+exports.BUILTIN_CODECS = BUILTIN_CODECS;
+exports.BrotliCodec = BrotliCodec;
+exports.CompressionEngine = CompressionEngine;
+exports.DeltaCodec = DeltaCodec;
+exports.DeltaSyncOptimizer = DeltaSyncOptimizer;
+exports.DictionaryCodec = DictionaryCodec;
+exports.GzipCodec = GzipCodec;
+exports.HuffmanCodec = HuffmanCodec;
+exports.LZ77Codec = LZ77Codec;
+exports.PURE_JS_CODECS = PURE_JS_CODECS;
+exports.RLECodec = RLECodec;
+exports.RawCodec = RawCodec;
+exports.TopologicalCompressor = TopologicalCompressor;
+exports.getCodecById = getCodecById;
+exports.getCompressionEngine = getCompressionEngine;
+exports.getDeltaSyncOptimizer = getDeltaSyncOptimizer;
+exports.resetCompressionEngine = resetCompressionEngine;
+exports.resetDeltaSyncOptimizer = resetDeltaSyncOptimizer;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map