compact-alignments: batch 1/71 (100 file(s))

README.md

@@ -150,7 +150,7 @@ e.g. `hbo:0430`) `lexeme-alignments` uses, not a bare Strong's number or a raw w
 [**lexeme-alignments' "The anchor: lexeme, not Strong's"**](https://huggingface.co/datasets/bcv-commons/lexeme-alignments#the-anchor-lexeme-not-strongs)
 section for what that means and why (homonym/sense-split handling, the Strong's rollup, etc.) — this
 dataset assumes that anchor as given rather than re-explaining it. (On GitHub, the same section lives at
-[`lexeme-alignments/README.md`](https://github.com/bcv-commons/lexeme-aligner/blob/main/lexeme-alignments/README.md#the-anchor-lexeme-not-strongs).)
+[`lexeme-alignments/README.md`](https://github.com/bcv-commons/lexeme-aligner/blob/main/publish/lexeme-alignments/README.md#the-anchor-lexeme-not-strongs).)
 
 | token | meaning |
 |---|---|
@@ -163,8 +163,56 @@ dataset assumes that anchor as given rather than re-explaining it. (On GitHub, t
 | `""` (empty string) | the verse has no aligned content lexeme, or the edition has no text there (e.g. a non-anchor verse of a pooled translation range) |
 
 Target token positions are addressed by **position in that verse's own tokenized text** — a consumer
-tokenizes the edition's text the same way alignment did (whitespace + punctuation splitting) to resolve
-a position back to a word.
+tokenizes the edition's text the SAME way alignment did to resolve a position back to a word, or target
+positions silently point at the wrong words. This is NOT plain whitespace/punctuation splitting — the
+exact rule (`usj_source.tokenize()`) is: **a token is a maximal run of Unicode letters + combining
+marks** (categories `L`/`M`). Everything else — punctuation, whitespace, AND digits (`Nd`, e.g. `40`,
+`3`) — is a separator, producing NO token at all, not even a placeholder. **Numerals in the source text
+are the sharpest gotcha**: a naive re-tokenizer that treats `"Selama 40 hari"` as 3 tokens (`Selama`,
+`40`, `hari`) will be off-by-one from every position onward, compounding for every subsequent number in
+the verse — this alone can look exactly like a systematic alignment bug when it's actually a
+tokenization mismatch (verified against real client feedback on `ACT 1:3`/`ind_ags`: 8 apparent
+"off-by-one" mismatches collapsed to 2 genuine ones once decoded with the correct tokenizer rule).
+
+**Reference implementation, both languages** (verified byte-for-byte identical to `usj_source.tokenize()`
+on the real `ind_ags` `ACT 1:3` text above):
+
+**Python:**
+```python
+import unicodedata
+
+def tokenize(text: str) -> list[str]:
+    toks, cur = [], []
+    for ch in unicodedata.normalize("NFC", text):
+        if unicodedata.combining(ch):          # drop non-spacing combining marks (Hebrew niqqud,
+            continue                           # Arabic harakat, ...) before the letter/mark test below
+        if unicodedata.category(ch)[0] in ("L", "M"):
+            cur.append(ch)
+        elif cur:
+            toks.append("".join(cur))
+            cur = []
+    if cur:
+        toks.append("".join(cur))
+    return toks
+```
+
+**JavaScript** (covers Latin/Cyrillic/Greek-script targets, which is the large majority — see the
+caveat below for diacritic-heavy scripts):
+```javascript
+function tokenize(text) {
+    const normalized = text.normalize("NFC");
+    return normalized.match(/[\p{L}\p{M}]+/gu) || [];   // \p{L}=letter, \p{M}=mark (Unicode property escapes)
+}
+```
+
+**Honest caveat on the JS version**: JavaScript has no built-in equivalent to Python's
+`unicodedata.combining()` (canonical combining class), so the snippet above doesn't strip non-spacing
+marks (Mn) the way the Python one does — it's exactly right for scripts without those (Latin, Cyrillic,
+Greek — covers most target languages, including the `ind_ags` case here), but for a diacritic-heavy
+script (Hebrew niqqud, Arabic harakat, Devanagari) it may tokenize slightly differently than
+`usj_source.tokenize()`. Rather than ship a JS mark-stripping table that could itself be subtly wrong,
+if you're decoding one of those scripts, treat `usj_source.py`'s Python implementation as the
+authoritative reference.
 
 ### Worked example — the scattered (comma) case