manifests: the Adlam and Roman-Balochi script tables leave the .ts

The last two whole transliteration tables still living in code — noted in #746, skipped in #748 because
moving three sets out of a file whose surrounding table stayed would have been incoherent.

balochi gains a "roman" block: Balochi is written in BOTH scripts and the Roman half is a second full
g2p (phonemic, where the Arabic half is defective). Vowel letters, long/short, consonants, and the
retroflex/postalveolar diacritic maps. The DIACRITIC LOGIC stays in balochi.ts, which is the point of
the split.

fula gains an "adlam" block: 34 letters plus the combining marks. Two things worth the reader's time are
now recorded there — that Adlam marks length and gemination with MARKS rather than doubling (so the
transliteration doubles what it just emitted rather than mapping them), and that the marks are written
as SURROGATE PAIRS because they are astral and JSON has no \u{…} form, and invisible besides.

And the move surfaced a triplicate: Adlam digits were folded in THREE places — a lookup table in
fulaAdlam.ts, foldAdlamDigits in numbers.ts, and core/unicode.ts's foldNativeDigits, which has carried
the Adlam base since #745. Both copies now defer to the shared one.

Pure relocation: 998 generated Adlam/Roman words phonemized against main, 0 differ.

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

@@ -41,7 +41,27 @@
     // ⚠ 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.
-    "romanVowels": ["a", "e", "i", "o", "u"],
+    // ⚠ 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.
+        // ⚠ ⟨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ː" },
+        "short": { "a": "a", "e": "eː", "i": "i", "o": "oː", "u": "u" },
+        // Base consonants. ⟨t d⟩ are DENTAL [t̪ d̪] — the retroflex series below is derived from them.
+        "consonants": {
+            "b": "b", "p": "p", "t": "t̪", "d": "d̪", "k": "k", "g": "ɡ", "q": "k", "f": "f", "v": "v",
+            "s": "s", "z": "z", "š": "ʃ", "ž": "ʒ", "c": "t͡ʃ", "j": "d͡ʒ", "x": "x", "ġ": "ɣ", "h": "h",
+            "m": "m", "n": "n", "r": "r", "l": "l", "w": "w", "y": "j"
+        },
+        // A DOT BELOW makes the consonant retroflex; a HÁČEK makes it postalveolar. Keyed by the phone the
+        // base letter already produced (hence "t̪"/"d̪" here, not ⟨t⟩/⟨d⟩) except where the letter is the
+        // only handle — balochi.ts tries the phone first, then the letter.
+        "retroflex": { "t̪": "ʈ", "d̪": "ɖ", "r": "ɽ", "n": "ɳ", "s": "ʂ", "l": "ɭ" },
+        "postalveolar": { "c": "t͡ʃ", "s": "ʃ", "z": "ʒ", "j": "d͡ʒ" }
+    },
 
     // NUMBERS — Balochi Arabic spellings; the canonical IPA is resolved through the cross-script lexicon
     // (balochi-lexicon.tsv now carries these headwords with their full vowels — the defective abjad cannot recover

src/languages/balochi/balochi.ts

@@ -21,7 +21,14 @@ interface BalochiDef {
     consonants: Record<string, string>;
     vowels: Record<string, string>;
     vowelLetters: readonly string[];
-    romanVowels: readonly string[];
+    roman: {
+        vowelLetters: readonly string[];
+        long: Record<string, string>;
+        short: Record<string, string>;
+        consonants: Record<string, string>;
+        retroflex: Record<string, string>;
+        postalveolar: Record<string, string>;
+    };
     numbers: BalNumbersDef;
     clausePunctuation: Record<string, string>;
 }
@@ -70,15 +77,14 @@ export function phonemizeArabic(word: string): string {
 }
 
 // ── Roman-script g2p (phonemic orthography → full IPA) ────────────────────────────────────────────────────────
-const R_VOWEL = new Set(DEF.romanVowels); // the ROMAN-script vowel letters (balochi.jsonc)
-const R_LONG: Record<string, string> = { a: "aː", e: "eː", i: "iː", o: "oː", u: "uː" };
-const R_SHORT: Record<string, string> = { a: "a", e: "eː", i: "i", o: "oː", u: "u" }; // e,o have no short counterpart
-const R_CONS: Record<string, string> = {
-    b: "b", p: "p", t: "t̪", d: "d̪", k: "k", g: "ɡ", q: "k", f: "f", v: "v", s: "s", z: "z",
-    š: "ʃ", ž: "ʒ", c: "t͡ʃ", j: "d͡ʒ", x: "x", ġ: "ɣ", h: "h", m: "m", n: "n", r: "r", l: "l", w: "w", y: "j",
-};
-const RETRO: Record<string, string> = { "t̪": "ʈ", "d̪": "ɖ", r: "ɽ", n: "ɳ", s: "ʂ", l: "ɭ" };
-const POSTALV: Record<string, string> = { c: "t͡ʃ", s: "ʃ", z: "ʒ", j: "d͡ʒ" };
+// The Roman half's tables (balochi.jsonc `roman`). The diacritic LOGIC — which mark reaches for which
+// table, and that a macron may be combining or precomposed — is the scan below.
+const R_VOWEL = new Set(DEF.roman.vowelLetters);
+const R_LONG = DEF.roman.long;
+const R_SHORT = DEF.roman.short;
+const R_CONS = DEF.roman.consonants;
+const RETRO = DEF.roman.retroflex;
+const POSTALV = DEF.roman.postalveolar;
 const MACRON = "̄", HACEK = "̌", DOTBELOW = "̣";
 
 /** One Balochi word in the Roman orthography → full IPA. Combining/precomposed macron→long vowel, háček→postalveolar,

src/languages/fula/fula.jsonc

@@ -11,6 +11,33 @@
     // vowel LENGTHENER doubles the vowel letter it just wrote. These are those letters.
     "latinVowels": ["a", "e", "i", "o", "u"],
 
+    // ⚠ THE ADLAM FRONT-END (𞤀𞤁𞤂𞤃, U+1E900–1E95F) — the second script Fula is registered for, transliterated
+    // to the Boko/Latin orthography so the ONE g2p serves both. Adlam is the modern (1989, the Barry
+    // brothers) phonemic alphabet for Fulfulde/Pular, in wide diaspora and West-African use.
+    // Keys are the SMALL letters (U+1E922–1E943); the uppercase range folds onto them by a −0x22 offset in
+    // fulaAdlam.ts, since Adlam case is not phonemic. The last four (va x gb z kp sh) are the loan letters,
+    // mapped to the same Boko equivalents the Latin engine already uses so the two scripts stay consistent.
+    "adlam": {
+        "letters": {
+            "𞤢": "a", "𞤣": "d", "𞤤": "l", "𞤥": "m", "𞤦": "b", "𞤧": "s", "𞤨": "p", "𞤩": "ɓ", "𞤪": "r", "𞤫": "e",
+            "𞤬": "f", "𞤭": "i", "𞤮": "o", "𞤯": "ɗ", "𞤰": "ƴ", "𞤱": "w", "𞤲": "n", "𞤳": "k", "𞤴": "y", "𞤵": "u",
+            "𞤶": "j", "𞤷": "c", "𞤸": "h", "𞤹": "q", "𞤺": "g", "𞤻": "ny", "𞤼": "t", "𞤽": "ŋ", "𞤾": "v", "𞤿": "x",
+            "𞥀": "gb", "𞥁": "z", "𞥂": "kp", "𞥃": "sh"
+        },
+        // ⚠ ADLAM MARKS LENGTH AND GEMINATION WITH COMBINING MARKS, NOT BY DOUBLING — which is why the
+        // transliteration has to DOUBLE the letter it just wrote rather than map these to anything:
+        //   lengtheners (ALIF U+1E944 / VOWEL LENGTHENER U+1E945) double the preceding VOWEL (𞤢𞥅 → "aa" → aː)
+        //   gemination  (U+1E946)                                double the preceding CONSONANT (𞤦𞥆 → "bb")
+        // ⚠ WRITTEN AS SURROGATE PAIRS: these are ASTRAL codepoints and JSON has no \u{…} form. They are
+        // also INVISIBLE combining marks, so a literal would be an unreadable blank in this file.
+        // U+1E944 ALIF LENGTHENER, U+1E945 VOWEL LENGTHENER.
+        "lengtheners": ["\uD83A\uDD44", "\uD83A\uDD45"],
+        "gemination": "\uD83A\uDD46", // U+1E946 GEMINATION MARK
+        "hamza": "\uD83A\uDD47", // → the glottal ⟨q⟩, which the Latin g2p already reads as [ʔ]
+        // CONSONANT MODIFIER / GEMINATE CONSONANT MODIFIER / NUKTA — rare foreign-sound marks, dropped.
+        "drop": ["\uD83A\uDD48", "\uD83A\uDD49", "\uD83A\uDD4A"] // U+1E948–1E94A
+    },
+
     "script": ["Latin", "Adlam"],
     "name": "Fula (Fulfulde)",
     "provenance": "Cleanroom, rule-based g2p — Fulfulde Boko/Latin orthography is shallow and near-1:1; validated vs the r12a/Wikipedia references + languagesandnumbers. Sole census provider of the implosives ʄ (ƴ) / ɠ.",

src/languages/fula/fulaAdlam.ts

@@ -12,20 +12,17 @@
  * dropped. The extra loan letters (va x gb z kp sh) transliterate to their Boko equivalents — identical to how the
  * Latin engine already treats them, so the two scripts stay consistent.
  */
+import { foldNativeDigits } from "../../core/unicode.ts";
 import { MANIFEST } from "./manifest.ts";
 
-// Adlam SMALL LETTER (U+1E922–1E943) → Fula Boko/Latin. Uppercase (U+1E900–1E921) folds here by the −0x22 offset.
-const ADLAM: Record<string, string> = {
-    "𞤢": "a", "𞤣": "d", "𞤤": "l", "𞤥": "m", "𞤦": "b", "𞤧": "s", "𞤨": "p", "𞤩": "ɓ", "𞤪": "r", "𞤫": "e",
-    "𞤬": "f", "𞤭": "i", "𞤮": "o", "𞤯": "ɗ", "𞤰": "ƴ", "𞤱": "w", "𞤲": "n", "𞤳": "k", "𞤴": "y", "𞤵": "u",
-    "𞤶": "j", "𞤷": "c", "𞤸": "h", "𞤹": "q", "𞤺": "g", "𞤻": "ny", "𞤼": "t", "𞤽": "ŋ", "𞤾": "v", "𞤿": "x",
-    "𞥀": "gb", "𞥁": "z", "𞥂": "kp", "𞥃": "sh",
-};
-const DIGITS: Record<string, string> = { "𞥐": "0", "𞥑": "1", "𞥒": "2", "𞥓": "3", "𞥔": "4", "𞥕": "5", "𞥖": "6", "𞥗": "7", "𞥘": "8", "𞥙": "9" };
-const LENGTHENER = new Set(["\u{1E944}", "\u{1E945}"]); // ALIF / VOWEL LENGTHENER → double the preceding vowel
-const GEMINATION = "\u{1E946}"; // GEMINATION MARK → double the preceding consonant
-const HAMZA = "\u{1E947}"; // → the glottal ⟨q⟩ ([ʔ] in the g2p)
-const DROP = new Set(["\u{1E948}", "\u{1E949}", "\u{1E94A}"]); // CONSONANT MODIFIER / GEMINATE MOD / NUKTA (foreign)
+// The Adlam tables (fula.jsonc `adlam`): letter → Boko/Latin, and the combining marks. The TRANSLITERATION
+// LOGIC — case folding, and that a lengthener/gemination mark doubles what was just emitted rather than
+// mapping to anything — is the scan below.
+const ADLAM = MANIFEST.adlam.letters;
+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 VOWELS = new Set(MANIFEST.latinVowels); // the LATIN spelling vowels (fula.jsonc)
 
 /** Is any character of `s` in the Adlam block (U+1E900–1E95F)? */
@@ -50,7 +47,7 @@ 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] ?? DIGITS[ch];
+        const lat = ADLAM[ch] ?? foldNativeDigits(ch);
         if (lat !== undefined) { out += lat; lastBase = lat; } else out += raw; // pass unknown through
     }
     return out;

src/languages/fula/manifest.ts

@@ -10,6 +10,14 @@ export interface FulaManifest {
     rules: [string, string, boolean][];
     /** The LATIN spelling vowels the Adlam lengthener doubles; not IPA. */
     latinVowels: readonly string[];
+    /** The Adlam front-end: letter → Boko/Latin, plus the combining marks. */
+    adlam: {
+        letters: Record<string, string>;
+        lengtheners: readonly string[];
+        gemination: string;
+        hamza: string;
+        drop: readonly string[];
+    };
     clausePunctuation: Record<string, string>;
 }
 

src/languages/fula/numbers.ts

@@ -102,10 +102,10 @@ export function numberToWords(n: number): string {
     return r === 0 ? head : `${head} ${E} ${numberToWords(r)}`;
 }
 
-/** Adlam digits 𞥐–𞥙 (U+1E950–1E959) → ASCII, so the number branch serves both registered scripts. */
-export function foldAdlamDigits(s: string): string {
-    return [...s].map((ch) => {
-        const c = ch.codePointAt(0)!;
-        return c >= 0x1e950 && c <= 0x1e959 ? String(c - 0x1e950) : ch;
-    }).join("");
-}
+/**
+ * Adlam digits 𞥐–𞥙 (U+1E950–1E959) → ASCII, so the number branch serves both registered scripts.
+ * Re-exported from the shared fold rather than re-implemented: core/unicode.ts carries the Adlam base in
+ * NATIVE_DIGIT_BASES, and this file had a third copy of the same arithmetic (fulaAdlam.ts had a fourth,
+ * as a lookup table).
+ */
+export { foldNativeDigits as foldAdlamDigits } from "../../core/unicode.ts";