review: the digit fold must not swallow the pass-through

foldNativeDigits returns a NON-digit unchanged, so ADLAM[ch] ?? foldNativeDigits(ch) was never
undefined — which killed the pass-through branch below it and, worse, set lastBase (the gemination
target) from characters that are not Adlam letters. A stray ’ or an Arabic-Indic digit before U+1E946
doubled itself instead of the last real letter. It also folded every other script's digits inside an
Adlam token. Guarded on the Adlam digit range, which is what the DIGITS lookup it replaced covered.

Verified against main on 1292 generated words that now include stray and foreign characters precisely
so this path is exercised — the earlier 998-word run used only well-formed Adlam and missed it.

Also split balochi's stacked header: the first paragraph still described the flat romanVowels key from
#751 rather than the six-table roman object that landed, so it now sits on roman.vowelLetters where it
is true.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012Lc3WnUgogC7okV7n53vjr

Author: christopherthompson81

src/languages/balochi/balochi.jsonc

@@ -38,14 +38,13 @@
     // abjad intends.
     "vowelLetters": ["ا", "آ", "و", "ى", "ی", "ے"],
 
-    // ⚠ ORTHOGRAPHIC, NOT IPA, AND NOT THE ARABIC-SCRIPT LIST ABOVE. Balochi is written in both scripts;
-    // phonemizeRoman scans the ROMAN spelling, and these are its vowel letters. "vowelLetters" above is
-    // the Arabic-script set, for a different scan in the same engine.
     // ⚠ THE ROMAN ORTHOGRAPHY, a SECOND full g2p in the same engine — Balochi is written in both scripts and
     // this half is PHONEMIC where the Arabic half is defective, so it resolves to full IPA on its own rather
     // than leaning on the lexicon. The two halves share nothing but the language.
     "roman": {
-        // The vowel letters (the scan's own class), then long vs short by diacritic. A MACRON writes length.
+        // ⚠ ORTHOGRAPHIC, NOT IPA, AND NOT THE ARABIC-SCRIPT "vowelLetters" ABOVE — that one is the abjad's
+        // set, for the other scan in this same engine. These are the Roman letters, then long vs short by
+        // diacritic; a MACRON writes length.
         // ⚠ ⟨e o⟩ ARE LONG IN BOTH COLUMNS: Balochi has no short /e o/, so an unmarked ⟨e⟩ is still [eː].
         "vowelLetters": ["a", "e", "i", "o", "u"],
         "long": { "a": "aː", "e": "eː", "i": "iː", "o": "oː", "u": "uː" },

src/languages/fula/fulaAdlam.ts

@@ -23,6 +23,7 @@ const LENGTHENER = new Set(MANIFEST.adlam.lengtheners);
 const GEMINATION = MANIFEST.adlam.gemination;
 const HAMZA = MANIFEST.adlam.hamza;
 const DROP = new Set(MANIFEST.adlam.drop);
+const ADLAM_DIGIT = /[\u{1E950}-\u{1E959}]/u; // 𞥐–𞥙, the only digits this scan may fold
 const VOWELS = new Set(MANIFEST.latinVowels); // the LATIN spelling vowels (fula.jsonc)
 
 /** Is any character of `s` in the Adlam block (U+1E900–1E95F)? */
@@ -47,7 +48,11 @@ export function adlamToLatin(word: string): string {
         if (ch === GEMINATION) { out += lastBase; continue; }
         if (ch === HAMZA) { out += "q"; lastBase = "q"; continue; }
         if (DROP.has(ch)) continue;
-        const lat = ADLAM[ch] ?? foldNativeDigits(ch);
+        // ⚠ THE DIGIT TEST MUST STAY NARROW. foldNativeDigits folds EVERY script's digits and returns a
+        // non-digit unchanged, so calling it unguarded would (a) make `lat` never undefined, killing the
+        // pass-through below, and (b) set lastBase — the gemination target — from a character that is not
+        // an Adlam letter at all. Guarding on the Adlam digit range keeps the undefined signal intact.
+        const lat = ADLAM[ch] ?? (ADLAM_DIGIT.test(ch) ? foldNativeDigits(ch) : undefined);
         if (lat !== undefined) { out += lat; lastBase = lat; } else out += raw; // pass unknown through
     }
     return out;