Add Croatian spelling and grammar support (storytold/wordcraft#1114)

Co-authored-by: Brandon Thomas <echelon@gmail.com>

crates/proof/src/hr/grammar.rs

@@ -0,0 +1,169 @@
+//! Conservative Croatian grammar and punctuation checks.
+//! Handles repeated words, whitespace, capitals and duplicated punctuation;
+//! intentionally avoids speculative agreement and comma rules.
+
+use crate::{Issue, IssueKind, ProofLang, words};
+
+/// Words Croatian repeats on purpose: interjections, onomatopoeia and emphatic doubling.
+const ALLOWED_REPEATS: &[&str] =
+    &["da", "ne", "no", "ha", "hej", "joj", "aj", "oh", "uh", "hop", "kuc", "tik", "tak", "bum", "malo", "brzo", "polako", "više", "dobro"];
+const ABBREVIATIONS: &[&str] = &[
+    "npr", "itd", "itp", "tj", "tzv", "odn", "sl", "str", "br", "god", "st", "dr", "mr", "prof", "doc", "ing", "dipl", "mag", "univ", "g", "god",
+    "mj", "min", "sek", "čl", "st", "č", "toč", "tab", "sl", "sv", "ul", "trg", "pr", "izd", "ur", "svez", "vol", "vid", "usp", "prim", "engl",
+    "njem", "hrv", "lat", "tel", "mob", "e", "p", "o", "d", "m", "v", "z", "r", "pon", "uto", "sri", "čet", "pet", "sub", "ned", "sij", "velj",
+    "ožu", "tra", "svi", "lip", "srp", "kol", "ruj", "lis", "stu", "pro",
+];
+
+fn issue(start: usize, end: usize, message: String, suggestions: Vec<String>) -> Issue {
+    Issue { start, end, kind: IssueKind::Grammar, message, suggestions, lang: ProofLang::Hr }
+}
+
+fn capitalize(w: &str) -> String {
+    crate::affix::capitalize(w)
+}
+
+/// Is `prev`, before a period, an abbreviation, an initial, a number or a Roman numeral (after
+/// which a lower-case word doesn't start a sentence)?
+fn abbreviation_or_number(prev: &str) -> bool {
+    prev.chars().count() <= 1
+        || prev.chars().any(|c| c.is_ascii_digit())
+        || (prev.chars().all(|c| matches!(c, 'I' | 'V' | 'X' | 'L' | 'C' | 'D' | 'M')))
+        || ABBREVIATIONS.contains(&prev.to_lowercase().as_str())
+}
+
+const CLOSING: [char; 8] = ['"', '”', '’', '\'', ')', '»', ']', '\u{1}'];
+const OPENING: [char; 8] = ['"', '“', '«', '(', '[', '\'', '‚', '—'];
+
+/// Does the gap between two words end a sentence: a `.`, `!` or `?` (not an ellipsis, not after
+/// an abbreviation), then space, with nothing but quotes and brackets around?
+fn ends_sentence(gap: &str, prev: &str) -> bool {
+    let t = gap.trim_start_matches(CLOSING);
+    let Some(end) = t.chars().next() else { return false };
+    if !matches!(end, '.' | '!' | '?') || t.starts_with("..") {
+        return false;
+    }
+    if end == '.' && abbreviation_or_number(prev) {
+        return false;
+    }
+    let rest = t.trim_start_matches(['.', '!', '?']).trim_start_matches(CLOSING);
+    rest.starts_with(char::is_whitespace) && rest.trim_start().chars().all(|c| OPENING.contains(&c))
+}
+
+/// Grammar issues in a paragraph of Croatian text, in order.
+pub fn check(text: &str) -> Vec<Issue> {
+    let ws: Vec<(usize, usize)> = words(text);
+    let mut v = Vec::new();
+    repeated_words(text, &ws, &mut v);
+    spaces(text, &mut v);
+    sentence_capitals(text, &ws, &mut v);
+    doubled_punctuation(text, &mut v);
+    v.sort_by_key(|i| (i.start, i.end));
+    v
+}
+
+fn repeated_words(text: &str, ws: &[(usize, usize)], v: &mut Vec<Issue>) {
+    for pair in ws.windows(2) {
+        let [(a0, b0), (a1, b1)] = pair else { continue };
+        let (Some(w0), Some(w1), Some(gap)) = (text.get(*a0..*b0), text.get(*a1..*b1), text.get(*b0..*a1)) else { continue };
+        if !gap.is_empty()
+            && gap.chars().all(char::is_whitespace)
+            && w0.chars().all(char::is_alphabetic)
+            && w0.to_lowercase() == w1.to_lowercase()
+            && !ALLOWED_REPEATS.contains(&w0.to_lowercase().as_str())
+        {
+            v.push(issue(*a0, *b1, format!("Ponovljena riječ: \"{w1}\""), vec![w0.to_string()]));
+        }
+    }
+}
+
+fn spaces(text: &str, v: &mut Vec<Issue>) {
+    for (i, c) in text.char_indices() {
+        if c != ' ' {
+            continue;
+        }
+        let rest = text.get(i + 1..).unwrap_or("");
+        let mut it = rest.chars();
+        let Some(p) = it.next() else { continue };
+        let after = it.next();
+        let flag = match p {
+            ',' => true,
+            // `;)` and `;-)` are emoticons.
+            ';' => !matches!(after, Some(')' | '(' | '-' | 'P' | 'D')),
+            // ` ...` is an ellipsis, ` .5` a number.
+            '.' => !matches!(after, Some('.')) && !after.is_some_and(|a| a.is_ascii_digit()),
+            // ` :)`, ` :-)`, ` :D` and similar are emoticons; ` ?!` is still a stray space.
+            ':' | '!' | '?' => after.is_none_or(|a| a.is_whitespace() || matches!(a, '"' | '”' | '’' | '!' | '?')),
+            _ => false,
+        };
+        if flag {
+            v.push(issue(i, i + 1 + p.len_utf8(), "Razmak ispred interpunkcijskog znaka".into(), vec![p.to_string()]));
+        }
+    }
+    for (i, _) in text.match_indices("  ") {
+        if i > 0 && text.get(..i).is_some_and(|t| t.ends_with(' ')) {
+            continue;
+        }
+        v.push(issue(i, i + 2, "Dvostruki razmak".into(), vec![" ".into()]));
+    }
+}
+
+fn sentence_capitals(text: &str, ws: &[(usize, usize)], v: &mut Vec<Issue>) {
+    // List items (`– maçãs,`) may start in lower case.
+    let list_item = text.trim_end().ends_with([',', ';']);
+    for (k, &(a, b)) in ws.iter().enumerate() {
+        let Some(w) = text.get(a..b) else { continue };
+        let starts = if k == 0 {
+            let before = text.get(..a).unwrap_or("");
+            !list_item && before.chars().all(|c| c.is_whitespace() || OPENING.contains(&c))
+        } else {
+            let Some(&(pa, pb)) = ws.get(k - 1) else { continue };
+            ends_sentence(text.get(pb..a).unwrap_or(""), text.get(pa..pb).unwrap_or(""))
+        };
+        if starts && w.chars().next().is_some_and(char::is_lowercase) && w.chars().all(char::is_alphabetic) {
+            v.push(issue(a, b, "Rečenica treba započeti velikim slovom".into(), vec![capitalize(w)]));
+        }
+    }
+}
+
+fn doubled_punctuation(text: &str, v: &mut Vec<Issue>) {
+    let bytes = text.as_bytes();
+    let mut i = 0;
+    while let Some(&b) = bytes.get(i) {
+        if !matches!(b, b',' | b'.' | b';') {
+            i += 1;
+            continue;
+        }
+        let run = bytes.get(i..).map_or(0, |r| r.iter().take_while(|&&x| x == b).count());
+        let flag = match b {
+            b'.' => run == 2,
+            _ => run >= 2,
+        };
+        if flag {
+            let end = i + run;
+            let suggestions: Vec<String> = match b {
+                b'.' => vec![".".into(), "…".into()],
+                _ => vec![char::from(b).to_string()],
+            };
+            v.push(issue(i, end, "Ponovljen interpunkcijski znak".into(), suggestions));
+        }
+        i += run.max(1);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn checks_croatian_punctuation() {
+        let t = "Ovo ovo je primjer , s dva  razmaka..";
+        let issues = check(t);
+        assert!(issues.iter().any(|i| i.message.starts_with("Ponovljena riječ")));
+        assert!(issues.iter().any(|i| i.message == "Dvostruki razmak"));
+        assert!(issues.iter().all(|i| i.lang == ProofLang::Hr));
+    }
+    #[test]
+    fn abbreviations_do_not_trigger_capitals() {
+        let issues = check("To je npr. sasvim dobar primjer.");
+        assert!(!issues.iter().any(|i| i.message == "Rečenica treba započeti velikim slovom"));
+    }
+}

crates/proof/src/hr/mod.rs

@@ -0,0 +1,142 @@
+//! Croatian spelling and conservative grammar support.
+//! Uses an installed hr_HR Hunspell .aff/.dic pair (not bundled).
+//! The engine decodes ISO-8859-2 dictionaries at load time.
+//! Suggestions prioritize č/ć, đ, š, ž and common one-character mistakes.
+//! Hyphenation remains the host engine's fallback until Croatian patterns are supplied.
+
+pub mod grammar;
+mod suggest;
+#[cfg(test)]
+pub(crate) mod test_dict;
+
+use std::sync::{Arc, RwLock};
+
+use crate::affix::AffixDict;
+
+pub use suggest::suggest;
+
+/// The Croatian dictionary: `None` until first use, then the installed one (or an empty one).
+static DICT: RwLock<Option<Arc<AffixDict>>> = RwLock::new(None);
+
+/// File names of a Croatian Hunspell dictionary.
+const NAMES: &[&str] = &["hr_HR", "hr-HR", "hr"];
+
+/// The Croatian dictionary: the installed Hunspell `hr_HR` (read on first use), one given with
+/// [`install_dictionary`], or an empty one when none is available (Croatian spelling is off
+/// then; see [`has_dictionary`]).
+pub fn dictionary() -> Arc<AffixDict> {
+    if let Some(d) = DICT.read().unwrap_or_else(|e| e.into_inner()).as_ref() {
+        return d.clone();
+    }
+    let loaded = Arc::new(load_installed());
+    let mut slot = DICT.write().unwrap_or_else(|e| e.into_inner());
+    // Another thread (or an install) may have filled it meanwhile: that one wins.
+    slot.get_or_insert(loaded).clone()
+}
+
+fn load_installed() -> AffixDict {
+    let Some((aff, dic)) = crate::hunspell::find(NAMES) else {
+        log::info!("Croatian spelling: no Hunspell hr_HR dictionary installed");
+        return AffixDict::default();
+    };
+
+    crate::hunspell::load(&aff, &dic).unwrap_or_else(|e| {
+        log::warn!("Croatian spelling: {e}");
+        AffixDict::default()
+    })
+}
+
+/// Use this Croatian dictionary from now on (Hunspell `.aff` and `.dic` text, decoded to
+/// UTF-8), for example one the user picked. On error the current dictionary stays.
+pub fn install_dictionary(aff: &str, dic: &str) -> Result<(), String> {
+    let d = AffixDict::from_hunspell(aff, dic, &[])?;
+    *DICT.write().unwrap_or_else(|e| e.into_inner()) = Some(Arc::new(d));
+    Ok(())
+}
+
+/// Forget the loaded dictionary, so the next check looks for an installed one again (after
+/// [`crate::hunspell::set_dictionary_dir`] or a dictionary was installed).
+pub fn reload_dictionary() {
+    *DICT.write().unwrap_or_else(|e| e.into_inner()) = None;
+}
+
+/// Is a Croatian dictionary available (spelling is checked)?
+pub fn has_dictionary() -> bool {
+    !dictionary().is_empty()
+}
+
+/// Is `c` a letter of the Latin script (the only one the Croatian dictionary covers)?
+fn is_latin_letter(c: char) -> bool {
+    c.is_alphabetic() && (c < '\u{0250}' || ('\u{1E00}'..='\u{1EFF}').contains(&c))
+}
+
+/// Is `word` spelled correctly in Croatian? Numbers, single letters, short words in capitals
+/// (acronyms: `HRT`, `RH`), words with digits and words in other scripts are accepted, and so
+/// is every word when no Croatian dictionary is installed.
+pub fn is_correct(word: &str) -> bool {
+    is_correct_with(&dictionary(), word)
+}
+
+/// [`is_correct`] against a given dictionary (an empty one accepts everything).
+pub fn is_correct_with(d: &AffixDict, word: &str) -> bool {
+    if d.is_empty() {
+        return true; // no Croatian dictionary installed: no spelling marks
+    }
+    let w = word.trim_matches(|c: char| !c.is_alphanumeric() && c != '\'' && c != '’');
+    let w = w.trim_matches(['\'', '’']);
+    let n = w.chars().count();
+    if n <= 1 || w.chars().any(|c| c.is_ascii_digit()) || !w.chars().any(char::is_alphabetic) {
+        return true;
+    }
+    if w.chars().all(|c| !c.is_lowercase()) && n <= 6 {
+        return true;
+    }
+    if !w.chars().any(is_latin_letter) {
+        return true; // other scripts: no dictionary
+    }
+    if w.contains('-') {
+        return w.split('-').all(|p| p.chars().count() <= 1 || known(d, p));
+    }
+    known(d, w)
+}
+
+/// Is one word (no hyphens) in the dictionary or the user dictionary?
+fn known(d: &AffixDict, w: &str) -> bool {
+    d.check(w) || crate::in_user_dictionary(&w.to_lowercase())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_dictionary_loads() {
+        test_dict::install();
+        let d = dictionary();
+        assert!(has_dictionary());
+        assert!(d.len() > 15);
+        assert!(d.rule_count() > 0);
+        assert!(!d.map().is_empty() && !d.rep().is_empty() && !d.try_chars().is_empty());
+    }
+
+    #[test]
+    fn correct_words_and_affixes() {
+        test_dict::install();
+        for w in ["kuća", "kuće", "računalo", "čovjek", "riječ", "dijete", "Hrvatska", "čokolada", "škola", "škole", "HRT", "2026"] {
+            assert!(is_correct(w), "{w}");
+        }
+    }
+
+    #[test]
+    fn misspellings_are_flagged() {
+        test_dict::install();
+        for w in ["kuca", "racunalo", "covjek", "rijec", "dijeteh", "skolla"] {
+            assert!(!is_correct(w), "{w}");
+        }
+    }
+
+    #[test]
+    fn missing_dictionary_is_silent() {
+        assert!(is_correct_with(&AffixDict::default(), "nepostojećariječ"));
+    }
+}

crates/proof/src/hr/suggest.rs

@@ -0,0 +1,365 @@
+//! Croatian spelling suggestions using dictionary MAP/REP rules, edit distance,
+//! missing spaces and a bounded search. Proper Croatian corrections depend on
+//! the actual installed dictionary entries.
+
+use std::collections::{HashMap, HashSet};
+
+use crate::affix::{AffixDict, Casing, capitalize, casing};
+
+/// Short words often run into the next one (`não é`, `da água`, `para isso`).
+const LEADING_WORDS: &[&str] = &[
+    "a", "ali", "i", "ili", "da", "do", "od", "na", "ne", "ni", "o", "po", "pod", "pri", "sa", "s", "se", "su", "u", "uz", "za", "iz", "je", "će",
+    "bi", "bih", "što", "koji", "koja", "koje", "kao", "kad", "dok", "bez", "pred", "nad",
+];
+const TRAILING_WORDS: &[&str] =
+    &["je", "su", "se", "ga", "mi", "ti", "mu", "joj", "ih", "im", "li", "će", "ću", "bi", "bih", "i", "a", "u", "na", "za", "od", "do"];
+
+const MAX_LETTERS: usize = 40;
+const MAX_MAP_CHANGES: usize = 4;
+const MAX_MAP_VARIANTS: usize = 4096;
+/// Stems the scan of round 6 expands.
+const SCAN_STEMS: usize = 48;
+
+const COST_CASE: u32 = 0;
+const COST_ADD_DIACRITIC: u32 = 4;
+const COST_OTHER_MAP: u32 = 7;
+const COST_DROP_DIACRITIC: u32 = 11;
+const COST_REP: u32 = 10;
+const COST_SPLIT: u32 = 12;
+const COST_SPLIT_RARE: u32 = 18;
+const COST_SWAP: u32 = 14;
+const COST_DROP_OR_ADD: u32 = 15;
+const COST_MISTYPE: u32 = 16;
+const COST_SCAN: u32 = 20;
+
+struct Collector<'a> {
+    d: &'a AffixDict,
+    /// The word, lower case.
+    input: String,
+    tested: HashSet<String>,
+    /// Suggestion → (cost, order found).
+    found: HashMap<String, (u32, usize)>,
+    seq: usize,
+}
+
+impl Collector<'_> {
+    /// Check a lower-case candidate (a word, or two separated by a space) and keep it if every
+    /// word is in the dictionary, as written or capitalized (names).
+    fn offer(&mut self, cand: &str, cost: u32) {
+        if cand.is_empty() || cand == self.input || !self.tested.insert(cand.to_string()) {
+            return;
+        }
+        let mut words = Vec::new();
+        let mut cost = cost;
+        for part in cand.split(' ') {
+            if self.d.contains(part) {
+                words.push(part.to_string());
+            } else {
+                let c = capitalize(part);
+                if !self.d.contains(&c) {
+                    return;
+                }
+                words.push(c);
+                // A name ranks after a common word at the same distance (`moça`, then `Moça`).
+                cost += 1;
+            }
+        }
+        self.keep(words.join(" "), cost);
+    }
+
+    /// Keep a suggestion known to be correct.
+    fn keep(&mut self, text: String, cost: u32) {
+        self.seq += 1;
+        let seq = self.seq;
+        let e = self.found.entry(text).or_insert((cost, seq));
+        if cost < e.0 {
+            *e = (cost, seq);
+        }
+    }
+
+    fn count_within(&self, cost: u32) -> usize {
+        self.found.values().filter(|(c, _)| *c <= cost).count()
+    }
+}
+
+/// The MAP group of each letter (its other members are its likely confusions).
+fn alternatives(c: char, map: &[Vec<char>]) -> Vec<char> {
+    map.iter().filter(|g| g.contains(&c)).flat_map(|g| g.iter().copied()).filter(|&x| x != c).collect()
+}
+
+/// The cost of changing letter `from` to its MAP relative `to`. Adding a missing accent is the
+/// commonest slip (Croatian typed without accents: `coracao`); an accent the writer did type
+/// is likelier right, so taking one away costs more than a known confusion from the REP table
+/// (`seje` → `seja` before `sejé`).
+fn map_cost(from: char, to: char) -> u32 {
+    match (from.is_ascii(), to.is_ascii()) {
+        (true, false) => COST_ADD_DIACRITIC,
+        (false, true) => COST_DROP_DIACRITIC,
+        _ => COST_OTHER_MAP,
+    }
+}
+
+/// Every way of changing up to [`MAX_MAP_CHANGES`] letters to a MAP relative, with its cost.
+fn map_variants(chars: &[char], alts: &[Vec<char>], i: usize, changes: usize, cost: u32, buf: &mut Vec<char>, out: &mut Vec<(String, u32)>) {
+    if out.len() >= MAX_MAP_VARIANTS {
+        return;
+    }
+    let Some(&c) = chars.get(i) else {
+        if changes > 0 {
+            out.push((buf.iter().collect(), cost));
+        }
+        return;
+    };
+    buf.push(c);
+    map_variants(chars, alts, i + 1, changes, cost, buf, out);
+    buf.pop();
+    if changes < MAX_MAP_CHANGES {
+        for &a in alts.get(i).map(Vec::as_slice).unwrap_or_default() {
+            buf.push(a);
+            map_variants(chars, alts, i + 1, changes + 1, cost + map_cost(c, a), buf, out);
+            buf.pop();
+        }
+    }
+}
+
+/// A letter's MAP representative (the first of its group), lower case: `ã` → `a`, `ç` → `c`.
+fn fold(c: char, map: &[Vec<char>]) -> char {
+    let l = c.to_lowercase().next().unwrap_or(c);
+    map.iter().find(|g| g.contains(&l)).and_then(|g| g.first().copied()).unwrap_or(l)
+}
+
+/// Optimal string alignment distance where a MAP slip (`a`/`á`, `c`/`ç`) costs 1 and any other
+/// edit 2; `limit + 1` once it is certainly above `limit`.
+fn weighted_distance(a: &[char], b: &[char], related: &dyn Fn(char, char) -> bool, limit: u32) -> u32 {
+    let m = b.len();
+    let over = limit + 1;
+    let mut prev2 = vec![0u32; m + 1];
+    let mut prev: Vec<u32> = (0..=m as u32).map(|j| j * 2).collect();
+    let mut cur = vec![0u32; m + 1];
+    for (i, &ai) in a.iter().enumerate() {
+        if let Some(c) = cur.get_mut(0) {
+            *c = (i as u32 + 1) * 2;
+        }
+        let mut row_min = u32::MAX;
+        for (j, &bj) in b.iter().enumerate() {
+            let sub = if ai == bj {
+                0
+            } else if related(ai, bj) {
+                1
+            } else {
+                2
+            };
+            let at = |v: &[u32], k: usize| v.get(k).copied().unwrap_or(u32::MAX / 4);
+            let mut v = (at(&prev, j + 1) + 2).min(at(&cur, j) + 2).min(at(&prev, j) + sub);
+            if i > 0 && j > 0 && a.get(i - 1) == Some(&bj) && b.get(j - 1) == Some(&ai) {
+                v = v.min(at(&prev2, j - 1) + 2);
+            }
+            if let Some(c) = cur.get_mut(j + 1) {
+                *c = v;
+            }
+            row_min = row_min.min(v);
+        }
+        if m > 0 && row_min > limit {
+            return over;
+        }
+        std::mem::swap(&mut prev2, &mut prev);
+        std::mem::swap(&mut prev, &mut cur);
+    }
+    prev.get(m).copied().unwrap_or(over).min(over)
+}
+
+/// Spelling suggestions for a Croatian word, best first, at most `max`, in the word's letter case.
+pub fn suggest(word: &str, max: usize) -> Vec<String> {
+    suggest_in(&super::dictionary(), word, max)
+}
+
+/// [`suggest`] against a given dictionary.
+pub fn suggest_in(d: &AffixDict, word: &str, max: usize) -> Vec<String> {
+    let word = word.trim();
+    let n = word.chars().count();
+    if n == 0 || n > MAX_LETTERS || max == 0 || d.is_empty() || word.contains(char::is_whitespace) {
+        return Vec::new();
+    }
+    let case = casing(word);
+    let input = word.to_lowercase();
+    let chars: Vec<char> = input.chars().collect();
+    let mut col = Collector { d, input: input.clone(), tested: HashSet::new(), found: HashMap::new(), seq: 0 };
+    // 1. Letter case.
+    if d.contains(&input) && word != input {
+        col.keep(input.clone(), COST_CASE);
+    } else if d.contains(&capitalize(&input)) && word != capitalize(&input) {
+        col.keep(capitalize(&input), COST_CASE);
+    }
+    // 2. Accents and other MAP slips.
+    let fallback_map = vec![vec!['c', 'č', 'ć'], vec!['d', 'đ'], vec!['s', 'š'], vec!['z', 'ž']];
+    let map = if d.map().is_empty() { &fallback_map } else { d.map() };
+    let alts: Vec<Vec<char>> = chars.iter().map(|&c| alternatives(c, map)).collect();
+    let mut variants = Vec::new();
+    map_variants(&chars, &alts, 0, 0, 0, &mut Vec::with_capacity(n), &mut variants);
+    variants.sort_by_key(|v| v.1);
+    for (v, cost) in &variants {
+        col.offer(v, *cost);
+    }
+    // 3. Common confusions.
+    for (from, to) in d.rep() {
+        if from.is_empty() {
+            continue;
+        }
+        for (i, _) in input.match_indices(from.as_str()) {
+            if let (Some(a), Some(b)) = (input.get(..i), input.get(i + from.len()..)) {
+                col.offer(&format!("{a}{to}{b}"), COST_REP);
+            }
+        }
+    }
+    // 4. A missing space: cheap after a short leading word or before a short trailing one,
+    //    dearer between two longer words, never leaving a stray short half.
+    for (i, _) in input.char_indices().skip(1) {
+        let (Some(a), Some(b)) = (input.get(..i), input.get(i..)) else { continue };
+        let long = |p: &str| p.chars().count() >= 3;
+        let cost = if (LEADING_WORDS.contains(&a) && long(b)) || (long(a) && TRAILING_WORDS.contains(&b)) {
+            COST_SPLIT
+        } else if long(a) && long(b) {
+            COST_SPLIT_RARE
+        } else {
+            continue;
+        };
+        col.offer(&format!("{a} {b}"), cost);
+    }
+    // 5. One typo.
+    let mut letters: Vec<char> = d.try_chars().chars().filter(|c| c.is_lowercase()).collect();
+    if letters.is_empty() {
+        letters = "aeiourntsjkvlmdpbgczčćšžđfh".chars().collect();
+    }
+    let s = |v: &[char]| v.iter().collect::<String>();
+    for i in 0..n.saturating_sub(1) {
+        if chars.get(i) != chars.get(i + 1) {
+            let mut v = chars.clone();
+            v.swap(i, i + 1);
+            col.offer(&s(&v), COST_SWAP);
+        }
+    }
+    for i in 0..n {
+        let mut v = chars.clone();
+        v.remove(i);
+        col.offer(&s(&v), COST_DROP_OR_ADD);
+    }
+    for i in 0..=n {
+        for &c in &letters {
+            let mut v = chars.clone();
+            v.insert(i, c);
+            col.offer(&s(&v), COST_DROP_OR_ADD);
+        }
+    }
+    for i in 0..n {
+        for &c in &letters {
+            if chars.get(i) != Some(&c) {
+                let mut v = chars.clone();
+                if let Some(x) = v.get_mut(i) {
+                    *x = c;
+                }
+                col.offer(&s(&v), COST_MISTYPE);
+            }
+        }
+    }
+    // 6. Further off: scan the stems that start like the word.
+    if col.count_within(COST_MISTYPE) < max {
+        scan(&mut col, &chars);
+    }
+    let mut found: Vec<(String, (u32, usize))> = col.found.into_iter().collect();
+    // Among equal costs, the change nearest the word's start is the likelier intent
+    // (`saúde` before `saudê`: both add an accent, but at the first difference).
+    let diff_at = |text: &str| chars.iter().zip(text.chars()).position(|(a, b)| *a != b).unwrap_or(n);
+    found.sort_by_key(|(text, (cost, seq))| (*cost, diff_at(text), *seq));
+    let mut out: Vec<String> = Vec::new();
+    for (text, _) in found {
+        let t = match case {
+            Casing::Initial => capitalize(&text),
+            Casing::Upper if n > 1 => text.to_uppercase(),
+            _ => text,
+        };
+        if t != word && !out.contains(&t) {
+            out.push(t);
+        }
+        if out.len() >= max {
+            break;
+        }
+    }
+    out
+}
+
+/// Round 6: rank the stems starting with the word's first letter (or a MAP relative of it, either
+/// case) by shared letter pairs, then keep the forms of the best within two typos.
+fn scan(col: &mut Collector, chars: &[char]) {
+    let d = col.d;
+    let map = d.map();
+    let Some(&first) = chars.first() else { return };
+    let folded: Vec<char> = chars.iter().map(|&c| fold(c, map)).collect();
+    let pairs: HashSet<(char, char)> = std::iter::once(' ').chain(folded.iter().copied()).zip(folded.iter().copied()).collect();
+    let mut firsts: Vec<char> = std::iter::once(first).chain(alternatives(first, map)).collect();
+    let upper: Vec<char> = firsts.iter().flat_map(|c| c.to_uppercase()).collect();
+    firsts.extend(upper);
+    firsts.sort_unstable();
+    firsts.dedup();
+    let n = folded.len();
+    let mut best: Vec<(u32, &str)> = Vec::new();
+    for f in firsts {
+        let prefix = f.to_string();
+        for stem in d.stems_with_prefix(&prefix) {
+            let sf: Vec<char> = stem.chars().map(|c| fold(c, map)).collect();
+            let shared = std::iter::once(' ').chain(sf.iter().copied()).zip(sf.iter().copied()).filter(|p| pairs.contains(p)).count();
+            if shared < 2 {
+                continue;
+            }
+            // Shared pairs, less the stem's letters the word doesn't explain, less a length gap
+            // beyond what an ending explains.
+            let extra = sf.len().saturating_sub(shared);
+            let gap = sf.len().abs_diff(n).saturating_sub(4);
+            let score = (shared * 4).saturating_sub(extra * 3 + gap * 2) as u32;
+            if score == 0 {
+                continue;
+            }
+            if best.len() < SCAN_STEMS {
+                best.push((score, stem));
+            } else if let Some(min) = best.iter_mut().min_by_key(|b| b.0)
+                && score > min.0
+            {
+                *min = (score, stem);
+            }
+        }
+    }
+    best.sort_by(|a, b| b.0.cmp(&a.0).then(a.1.cmp(b.1)));
+    let related = |a: char, b: char| fold(a, map) == fold(b, map);
+    let limit = 4;
+    for (_, stem) in best {
+        for form in d.forms(stem) {
+            let lf: Vec<char> = form.to_lowercase().chars().collect();
+            if lf.len().abs_diff(chars.len()) > 2 {
+                continue;
+            }
+            let dist = weighted_distance(&lf, chars, &related, limit);
+            if dist <= limit && lf.as_slice() != chars {
+                col.keep(form, COST_SCAN + dist * 3);
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn croatian_suggestions() {
+        crate::hr::test_dict::install();
+        for (wrong, right) in [("kuca", "kuća"), ("racunalo", "računalo"), ("covjek", "čovjek"), ("rijec", "riječ"), ("skolla", "škola")] {
+            let result = suggest(wrong, 10);
+            assert!(result.iter().any(|s| s == right), "{wrong} -> {result:?}, expected {right}");
+        }
+    }
+    #[test]
+    fn bounded() {
+        crate::hr::test_dict::install();
+        assert!(suggest("", 5).is_empty());
+        assert!(suggest("kuca", 0).is_empty());
+        assert!(suggest(&"a".repeat(41), 5).is_empty());
+    }
+}

crates/proof/src/hr/test_dict.rs

@@ -0,0 +1,42 @@
+//! Small synthetic UTF-8 Croatian Hunspell dictionary for deterministic tests.
+pub const AFF: &str = "SET UTF-8
+TRY abcčćdđefghijklmnoprsštuvzž
+MAP 5
+MAP cčć
+MAP dđ
+MAP sš
+MAP zž
+MAP iije
+REP 3
+REP c č
+REP dj đ
+REP je ije
+SFX A Y 2
+SFX A a e a
+SFX A a i a
+";
+pub const DIC: &str = "18
+kuća/A
+računalo
+čovjek
+riječ
+dijete
+Hrvatska
+čokolada
+škola/A
+more
+sunce
+dobar
+hrvatski
+jezik
+tekst
+pogreška
+pravopis
+provjera
+računala
+";
+pub fn install() {
+    if let Err(e) = super::install_dictionary(AFF, DIC) {
+        panic!("test dictionary: {e}");
+    }
+}

crates/proof/src/lang.rs

@@ -24,6 +24,8 @@ pub enum ProofLang {
     /// Italian (`it`, `it-IT`, `it-CH`): the installed Hunspell dictionary (`it_IT`, when there
     /// is one), the Italian grammar rules and the Italian hyphenation patterns.
     It,
+    /// Croatian (`hr`, `hr-HR`)
+    Hr,
     /// A language without proofing tools here (`fr-FR`, `ja-JP`, `x-none`…). Like Word without
     /// the language's proofing tools: no spelling or grammar marks, so its words are never
     /// flagged as English misspellings. Hyphenation keeps using the English patterns, as before
@@ -33,7 +35,7 @@ pub enum ProofLang {
 
 impl ProofLang {
     /// Every language with a spelling dictionary, in display order.
-    pub const PROOFED: [ProofLang; 4] = [ProofLang::En, ProofLang::Pl, ProofLang::Pt, ProofLang::It];
+    pub const PROOFED: [ProofLang; 5] = [ProofLang::En, ProofLang::Pl, ProofLang::Pt, ProofLang::It, ProofLang::Hr];
 
     /// The proofing language of a BCP 47 tag (`pl-PL`, `en_GB`, `PL`…). Only the primary subtag
     /// counts. No tag (or an empty one) is English, WordCraft's default editing language.
@@ -50,6 +52,8 @@ impl ProofLang {
             ProofLang::Pt
         } else if primary.eq_ignore_ascii_case("it") || primary.eq_ignore_ascii_case("ita") {
             ProofLang::It
+        } else if primary.eq_ignore_ascii_case("hr") || primary.eq_ignore_ascii_case("hrv") {
+            ProofLang::Hr
         } else {
             ProofLang::Other
         }
@@ -63,6 +67,7 @@ impl ProofLang {
             ProofLang::Bg => "bg",
             ProofLang::Pt => "pt",
             ProofLang::It => "it",
+            ProofLang::Hr => "hr",
             ProofLang::Other => "",
         }
     }

crates/proof/src/lib.rs

@@ -34,6 +34,7 @@
 pub mod affix;
 pub mod bg;
 pub mod dict;
+pub mod hr;
 pub mod hunspell;
 pub mod hyphen;
 pub mod it;
@@ -504,6 +505,7 @@ fn spelling_issue(text: &str, a: usize, b: usize, lang: ProofLang, opts: &Option
     }
     let message = match lang {
         ProofLang::Pl => "Możliwy błąd pisowni",
+        ProofLang::Hr => "Moguća pravopisna pogreška",
         ProofLang::Pt => "Possível erro de ortografia",
         ProofLang::It => "Possibile errore di ortografia",
         _ => "Possible spelling mistake",
@@ -521,6 +523,7 @@ pub fn is_correct_in_with(word: &str, lang: ProofLang, opts: &Options) -> bool {
     match lang {
         ProofLang::En => is_correct_with(word, opts),
         ProofLang::Pl => accepted_by_options(word, opts) || pl::is_correct(word),
+        ProofLang::Hr => accepted_by_options(word, opts) || hr::is_correct(word),
         ProofLang::Pt => accepted_by_options(word, opts) || pt::is_correct(word),
         ProofLang::It => accepted_by_options(word, opts) || it::is_correct(word),
         ProofLang::Bg | ProofLang::Other => true,
@@ -532,6 +535,7 @@ pub fn suggest_in(word: &str, max: usize, lang: ProofLang) -> Vec<String> {
     match lang {
         ProofLang::En => suggest(word, max),
         ProofLang::Pl => pl::suggest(word, max),
+        ProofLang::Hr => hr::suggest(word, max),
         ProofLang::Pt => pt::suggest(word, max),
         ProofLang::It => it::suggest(word, max),
         ProofLang::Bg | ProofLang::Other => Vec::new(),
@@ -545,6 +549,7 @@ pub fn check_grammar_in(text: &str, lang: ProofLang) -> Vec<Issue> {
     match lang {
         ProofLang::En => check_grammar(text),
         ProofLang::Pl => pl::grammar::check(text),
+        ProofLang::Hr => hr::grammar::check(text),
         ProofLang::Pt => pt::grammar::check(text),
         ProofLang::It => it::grammar::check(text),
         ProofLang::Bg | ProofLang::Other => Vec::new(),