hexstream/
├── config/            # Configuration management
├── core/              # Sequence generation and block processing
│   ├── sequence_generator.py
│   ├── block_processor.py
│   └── superhex.py
├── modules/
│   └── turtle.py      # Turtle module for final compression
├── codec/             # Main compression/decompression
├── server/            # Web interface
├── utils/             # Bit manipulation utilities
└── configs/           # Configuration profiles

// Simplified Turtle module structure
typedef struct {
    uint64_t* keys;        // 16 time-synchronized keys
    uint8_t* keyMask;      // Transformation mask
    float enhancementFactor; // Current enhancement factor
} TurtleModule;

// Initialize Turtle module with timestamp
TurtleModule* initTurtleModule(uint64_t timestamp) {
    TurtleModule* turtle = (TurtleModule*)malloc(sizeof(TurtleModule));
    
    // Generate 16 time-synchronized keys
    turtle->keys = (uint64_t*)malloc(sizeof(uint64_t) * 16);
    turtle->keyMask = (uint8_t*)malloc(16);
    
    // Create keys using Lucas numbers as seed modifiers
    for (int i = 0; i < 16; i++) {
        int lucasModifier = LUCAS[i % 11];
        turtle->keys[i] = generateKey(timestamp, i, lucasModifier);
        
        // Create transformation mask based on phi-resonance
        turtle->keyMask[i] = (uint8_t)(i * PHI) % 8;
    }
    
    // Enhancement factor documented at 28% for phi-resonant data
    turtle->enhancementFactor = 1.28f;
    
    return turtle;
}

// Core mathematical constants
#define PHI 1.618033988749895
#define ROOT6_HALF 1.2247448713915890491
#define PI 3.14159265358979323846
#define EULER 2.71828182845904523536
#define SQRT2 1.41421356237309504880
#define SQRT3 1.73205080756887729352
#define PLASTIC_NUMBER 1.32471795724474602596

// Lucas numbers for phi resonator anchor points
const int LUCAS[] = {2, 1, 3, 4, 7, 11, 18, 29, 47, 76, 123, 199, 322, 521, 843};

// Resonance frequencies
#define PHI_FREQUENCY 76.0f    // Lucas L(9)
#define PI_FREQUENCY 437.0f    // Master broadcast
#define EULER_FREQUENCY 271.0f // Voice generation
#define ROOT2_FREQUENCY 70.0f  // Full duplex
#define ROOT3_FREQUENCY 82.0f  // Hexagonal tiling

# Clone the repository
git clone https://github.com/dragonfire/hexstream.git
cd hexstream

# Build and run the Docker container
docker-compose up -d

# Clone the repository
git clone https://github.com/dragonfire/hexstream.git
cd hexstream

# Create a virtual environment (optional but recommended)
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

# Initialize configuration files
python main.py init

# Compress a file
python main.py compress path/to/file.wav

# Compress without Turtle module
python main.py compress path/to/file.wav --no-turtle

# Decompress a file
python main.py decompress path/to/file.hex

# Start the web server
python main.py server

from hexstream import HexStreamCodec

# Initialize the codec
codec = HexStreamCodec()

# Compress data
with open('input.wav', 'rb') as f:
    data = f.read()
compressed = codec.compress(data)

# Decompress data
original = codec.decompress(compressed)

// JavaScript WebRTC integration
class HexStreamWebRTC {
    constructor(options = {}) {
        this.codec = new HexStreamCodec({
            useWorker: true,
            profile: 'broadcast_optimized'
        });
        this.peerConnection = null;
        this.dataChannel = null;
        this.timestamp = Date.now();
        this.zeroSurface = new ZeroSurface(this.timestamp);
    }
    
    async connect(remoteDescriptionSdp) {
        this.peerConnection = new RTCPeerConnection();
        
        // Create data channel
        this.dataChannel = this.peerConnection.createDataChannel('hexstream', {
            ordered: false,
            maxRetransmits: 0
        });
        
        // Set up event handlers
        this.dataChannel.onopen = () => this.onChannelOpen();
        this.dataChannel.onmessage = (event) => this.onDataReceived(event);
        
        // Set remote description
        if (remoteDescriptionSdp) {
            await this.peerConnection.setRemoteDescription(
                new RTCSessionDescription({
                    type: 'offer',
                    sdp: remoteDescriptionSdp
                })
            );
            
            // Create answer
            const answer = await this.peerConnection.createAnswer();
            await this.peerConnection.setLocalDescription(answer);
            return answer.sdp;
        } else {
            // Create offer
            const offer = await this.peerConnection.createOffer();
            await this.peerConnection.setLocalDescription(offer);
            return offer.sdp;
        }
    }
    
    sendData(data) {
        // Compress data with HexStream
        const compressed = this.codec.compress(data);
        
        // Generate delta based on shared reference
        const delta = this.zeroSurface.generateDelta(compressed);
        
        // Send only the delta
        this.dataChannel.send(delta);
    }
    
    onDataReceived(event) {
        // Receive delta
        const delta = event.data;
        
        // Reconstruct compressed data using shared reference
        const compressed = this.zeroSurface.reconstructFromDelta(delta);
        
        // Decompress
        const original = this.codec.decompress(compressed);
        
        // Process original data
        this.onData(original);
    }
    
    onChannelOpen() {
        console.log('HexStream data channel open');
    }
    
    onData(data) {
        // Override this method to handle received data
    }
}

// audio-stream.js
import { HexStreamWebRTC } from '@dragonfire/hexstream';
import { AudioContext } from 'web-audio-api';

class AudioStreamer {
    constructor() {
        this.audioContext = new AudioContext();
        this.hexstream = new HexStreamWebRTC({
            profile: 'broadcast_optimized'
        });
        
        // Override onData method
        this.hexstream.onData = (data) => this.processAudioData(data);
    }
    
    async start(remoteSdp) {
        // Connect to remote peer
        const localSdp = await this.hexstream.connect(remoteSdp);
        
        // Start audio capture if this is the sender
        if (!remoteSdp) {
            this.startAudioCapture();
        }
        
        return localSdp;
    }
    
    startAudioCapture() {
        navigator.mediaDevices.getUserMedia({ audio: true })
            .then(stream => {
                // Create source from microphone
                const source = this.audioContext.createMediaStreamSource(stream);
                
                // Create processor to get raw audio data
                const processor = this.audioContext.createScriptProcessor(4096, 1, 1);
                
                processor.onaudioprocess = (e) => {
                    // Get audio data
                    const audioData = e.inputBuffer.getChannelData(0);
                    
                    // Send via HexStream
                    this.hexstream.sendData(audioData.buffer);
                };
                
                // Connect
                source.connect(processor);
                processor.connect(this.audioContext.destination);
            });
    }
    
    processAudioData(audioBuffer) {
        // Create audio buffer
        const buffer = this.audioContext.createBuffer(1, audioBuffer.byteLength / 4, this.audioContext.sampleRate);
        
        // Fill buffer with received data
        const channelData = buffer.getChannelData(0);
        const floatArray = new Float32Array(audioBuffer);
        channelData.set(floatArray);
        
        // Play audio
        const source = this.audioContext.createBufferSource();
        source.buffer = buffer;
        source.connect(this.audioContext.destination);
        source.start();
    }
}

// video-stream.js
import { HexStreamWebRTC } from '@dragonfire/hexstream';

class VideoStreamer {
    constructor(videoElement) {
        this.videoElement = videoElement;
        this.hexstream = new HexStreamWebRTC({
            profile: 'maximum_performance'
        });
        
        // Override onData method
        this.hexstream.onData = (data) => this.processVideoFrame(data);
        
        // Setup canvas for video frames
        this.canvas = document.createElement('canvas');
        this.context = this.canvas.getContext('2d');
    }
    
    async start(remoteSdp) {
        // Connect to remote peer
        const localSdp = await this.hexstream.connect(remoteSdp);
        
        // Start video capture if this is the sender
        if (!remoteSdp) {
            this.startVideoCapture();
        }
        
        return localSdp;
    }
    
    startVideoCapture() {
        navigator.mediaDevices.getUserMedia({ video: true })
            .then(stream => {
                // Show local video
                this.videoElement.srcObject = stream;
                
                // Setup canvas size
                this.canvas.width = 640;
                this.canvas.height = 480;
                
                // Capture frames at 30fps
                setInterval(() => {
                    // Draw video frame to canvas
                    this.context.drawImage(this.videoElement, 0, 0, this.canvas.width, this.canvas.height);
                    
                    // Get frame data
                    const imageData = this.context.getImageData(0, 0, this.canvas.width, this.canvas.height);
                    
                    // Send frame via HexStream
                    this.hexstream.sendData(imageData.data.buffer);
                }, 33);  // ~30fps
            });
    }
    
    processVideoFrame(frameBuffer) {
        // Create ImageData from received buffer
        const imageData = new ImageData(
            new Uint8ClampedArray(frameBuffer),
            this.canvas.width,
            this.canvas.height
        );
        
        // Draw frame to canvas
        this.context.putImageData(imageData, 0, 0);
        
        // Convert canvas to video frame
        const stream = this.canvas.captureStream();
        this.videoElement.srcObject = stream;
    }
}