Core Engine Processing Pipeline

on_key_ext(key, caps, ctrl, shift) → Result
│
├─► [!enabled || ctrl?] ──► clear buffer ──► return NONE
│
├─► [is_break(key)?] ──► check shortcuts ──► clear buffer ──► return
│
├─► [key == DELETE?] ──► pop buffer ──► return NONE
│
└─► process(key, caps, shift)
    │
    ├── STAGE 1: Stroke (d → đ)
    │   └── try_stroke() - scan buffer for un-stroked 'd'
    │
    ├── STAGE 2: Tone (circumflex/horn/breve)
    │   └── try_tone() - apply aa→â, ow→ơ, aw→ă patterns
    │
    ├── STAGE 3: Mark (sắc/huyền/hỏi/ngã/nặng)
    │   └── try_mark() - find vowel position, apply mark
    │
    ├── STAGE 4: Remove (z/0)
    │   └── handle_remove() - clear mark or tone
    │
    ├── STAGE 5: W-Vowel (Telex only)
    │   └── try_w_as_vowel() - "w" → "ư" with validation
    │
    ├── STAGE 6: Normal Letter
    │   └── handle_normal_letter() - push to buffer
    │
    └── STAGE 7: Word Boundary Shortcut
        └── try_word_boundary_shortcut() - expand abbreviations

pub fn apply_stroke(buf: &mut Buffer) -> TransformResult {
    // Find first 'd' that hasn't been stroked
    for i in 0..buf.len() {
        if let Some(c) = buf.get_mut(i) {
            if c.key == keys::D && !c.stroke {
                c.stroke = true;
                return TransformResult::success(vec![i]);
            }
        }
    }
    TransformResult::none()
}

// When applying horn modifier to buffer with "uo" or "ou" adjacent
let buffer_keys: Vec<u16> = buf.iter().map(|c| c.key).collect();
targets = Phonology::find_horn_positions(&buffer_keys, &vowel_positions);

// Example: "duoc" + 'w' → "dươc"
// Both 'u' and 'o' receive horn modifier

pub fn apply_mark(buf: &mut Buffer, mark_value: u8, modern: bool) -> TransformResult {
    let vowels = utils::collect_vowels(buf);
    if vowels.is_empty() {
        return TransformResult::none();
    }

    // Find position using phonology rules
    let last_vowel_pos = vowels.last().map(|v| v.pos).unwrap_or(0);
    let has_final = utils::has_final_consonant(buf, last_vowel_pos);
    let has_qu = utils::has_qu_initial(buf);
    let has_gi = utils::has_gi_initial(buf);
    let pos = Phonology::find_tone_position(&vowels, has_final, modern, has_qu, has_gi);

    // Clear any existing mark first
    for v in &vowels {
        if let Some(c) = buf.get_mut(v.pos) {
            c.mark = mark::NONE;
        }
    }

    // Apply new mark
    if let Some(c) = buf.get_mut(pos) {
        c.mark = mark_value;
        return TransformResult::success(vec![pos]);
    }

    TransformResult::none()
}

fn try_w_as_vowel(&mut self, caps: bool) -> Option<Result> {
    // Only in Telex mode
    if self.method != 0 {
        return None;
    }

    // Skip if last_transform == WShortcutSkipped
    if matches!(self.last_transform, Some(Transform::WShortcutSkipped)) {
        return None;
    }

    // Revert check
    if matches!(self.last_transform, Some(Transform::WAsVowel)) {
        // Revert: ư → w
        self.buf.pop();
        self.buf.push(Char::new(keys::W, caps));
        // ...
        return Some(Result::send(1, &[if caps { 'W' } else { 'w' }]));
    }

    // Try transformation
    let mut test_buf = self.buf.clone();
    test_buf.push(Char::new(keys::U, caps));
    if let Some(c) = test_buf.get_mut(test_buf.len() - 1) {
        c.tone = tone::HORN; // U + horn = ư
    }

    // Validate
    let test_keys: Vec<u16> = test_buf.iter().map(|c| c.key).collect();
    if !is_valid(&test_keys) {
        return None; // Invalid, don't transform
    }

    // Apply
    self.buf = test_buf;
    self.last_transform = Some(Transform::WAsVowel);
    Some(Result::send(0, &[chars::get_uw(caps)]))
}

pub fn try_match(
    &self,
    buffer: &str,
    key_char: Option<char>,
    is_word_boundary: bool,
    method: InputMethod,
) -> Option<ShortcutMatch> {
    // Lookup (longest-match-first)
    for (trigger, shortcut) in self.sorted_triggers() {
        if !buffer.ends_with(trigger) {
            continue;
        }
        
        // Check condition
        match shortcut.condition {
            TriggerCondition::Immediate => { /* match now */ },
            TriggerCondition::OnWordBoundary => {
                if !is_word_boundary {
                    continue;
                }
            }
        }
        
        // Apply case transformation
        let output = match shortcut.case_mode {
            CaseMode::Exact => shortcut.replacement.clone(),
            CaseMode::MatchCase => {
                if buffer.chars().all(|c| c.is_uppercase()) {
                    shortcut.replacement.to_uppercase()
                } else if buffer.chars().next().unwrap().is_uppercase() {
                    capitalize(&shortcut.replacement)
                } else {
                    shortcut.replacement.clone()
                }
            }
        };
        
        return Some(ShortcutMatch {
            backspace_count: trigger.len(),
            output,
            include_trigger_key: true,
        });
    }
    
    None
}

/// Circular buffer - fixed 256 chars
pub struct Buffer {
    data: [Char; MAX],  // MAX = 256
    len: usize,
}

/// Single character with modifiers
pub struct Char {
    pub key: u16,     // Virtual keycode
    pub caps: bool,   // Uppercase?
    pub tone: u8,     // 0=none, 1=circumflex, 2=horn
    pub mark: u8,     // 0=none, 1-5=sắc/huyền/hỏi/ngã/nặng
    pub stroke: bool, // d → đ
}

#[repr(C)]
pub struct Result {
    pub chars: [u32; MAX],  // UTF-32 output
    pub action: u8,         // 0=None, 1=Send, 2=Restore
    pub backspace: u8,      // Chars to delete
    pub count: u8,          // Valid char count
    pub flags: u8,          // Additional flags
}

impl Result {
    pub fn none() -> Self { /* ... */ }
    pub fn send(backspace: u8, chars: &[char]) -> Self { /* ... */ }
}