Data Reduction

You type one character: "a"

What changes?
+-------------------------------------------------------------+
|  Line 1:  ################################  (unchanged)     |
|  Line 2:  ################################  (unchanged)     |
|  Line 3:  ################################  (unchanged)     |
|  ...                                                        |
|  Line 39: ################################  (unchanged)     |
|  Line 40: $ command_here|                   (ONE CHAR!)     |
+-------------------------------------------------------------+

Traditional terminal sends: ALL 40 lines = ~50,000 bytes
Actual change: 1 character = ~25 bytes

Wasted: 99.95% of data!

Line Content                    Hash
-----------                     ----
"Hello World"             ->    0xA3F2B71C
"$ ls -la"                ->    0x8C4D91E5
"file.txt  1024"          ->    0x2B7A03F9

// Input: Line content (characters + colors + attributes)
// Output: 64-bit number (the "hash")

"$ ls -la" + [green color] + [bold]
         |
         v
+-------------------------------------------------------+
|   SipHash-1-3 (std::collections::hash_map::DefaultHasher)
|   -------------------------------------------------------
|   - 1 compression round per block
|   - 3 finalization rounds
|   - Optimized for short strings (terminal lines!)
|   - DoS-resistant (random seed per process)
+-------------------------------------------------------+
         |
         v
0x8C4D91E52B7A03F9  (64-bit fingerprint)

// atomic_state.rs:94-130
pub struct CachedLine {
    pub cells: Vec<AtomicCell>,  // Actual character data
    pub hash: u64,               // SipHash-1-3 fingerprint
    pub is_wrapped: bool,        // Line continuation flag
}

impl CachedLine {
    // O(1) comparison using pre-computed hash
    pub fn matches(&self, other: &CachedLine) -> bool {
        self.hash == other.hash    // Just compare two u64s!
    }

    // Hash computed when line content changes
    fn compute_hash(cells: &[AtomicCell]) -> u64 {
        let mut hasher = DefaultHasher::new();
        for cell in cells {
            cell.char.hash(&mut hasher);
            cell.fg.hash(&mut hasher);
            cell.bg.hash(&mut hasher);
            cell.attrs.hash(&mut hasher);
        }
        hasher.finish()
    }
}

Partial = row_indices[] + only_dirty_rows[]
Data size = N * (index + row_data)
          = N * (4 bytes + ~1,250 bytes)
          = N * 1,254 bytes

Full = all_rows[]
Data size = 40 rows * 1,250 bytes = 50,000 bytes

fn compute_diff(
    old_lines: &[CachedLine],
    new_lines: &[CachedLine]
) -> DiffResult {

    let mut dirty_indices: Vec<u32> = vec![];

    for (index, (old, new)) in
        old_lines.iter().zip(new_lines.iter()).enumerate() {
        if !old.matches(new) {        // O(1) hash comparison
            dirty_indices.push(index as u32);
        }
    }

    // 50% THRESHOLD DECISION
    let total_lines = new_lines.len();
    if dirty_indices.len() > total_lines / 2 {
        DiffResult::Full  // More efficient to send everything
    } else if dirty_indices.is_empty() {
        DiffResult::None  // Nothing changed
    } else {
        DiffResult::Partial { dirty_indices }
    }
}

const isPartialMode = typeof diffHint === 'object' && 'Partial' in diffHint;
const isNoneMode = diffHint === 'None';
const bufferSizeMatches = linesObj._length === neededLength;

if ((isPartialMode || isNoneMode) && bufferSizeMatches) {
    // ===============================================
    // PARTIAL/NONE: Reuse existing buffer
    // ===============================================

    if (update.lines.length > 0) {
        this.injectLines(linesObj._array, update.lines, cols);
    }

} else {
    // ===============================================
    // FULL: Recreate entire buffer
    // ===============================================

    const newArray = new Array(neededLength);
    for (let i = 0; i < neededLength; i++) {
        newArray[i] = new BufferLine(cols);
    }
    linesObj._array = newArray;
    this.injectLines(newArray, update.lines, cols);
}

Backend                          Frontend
   |                                |
   | -- GridUpdate (epoch=5) -----> |
   |    [waiting_ack = true]        |
   |                                |
   | <-------- ACK (epoch=5) ------ |
   |    [waiting_ack = false]       |
   |                                |
   | -- GridUpdate (epoch=6) -----> |
   |    ...                         |