codexparser 0.3.1 → 0.4.0

package/CHANGELOG.md

@@ -2,6 +2,42 @@
 
 All notable changes to this project are documented here. For full details, see the Release Notes in README and the GitHub Releases page.
 
+## 0.4.0 — 2026-04-28
+
+LXX versification audit + structural fixes. Major data-correctness pass against authoritative sources (Hanhart's Göttingen Esther, Rahlfs-Hanhart 2006, Göttingen Theodotion Daniel/Susanna/Bel) verified via Logos library.
+
+### Added
+
+- `parser.edition("rahlfs" | "auto")` — selects LXX edition. Default `"auto"` uses Göttingen where attested per `src/data/lxx-editions.js` and Rahlfs elsewhere.
+- `passage.convertVersion(target, { edition })` — per-call edition override.
+- `passage.getLXXRahlfs()` helper.
+- `ReferenceParser.expandVersificationValue(value)` — parses `"ch:v"`, `"ch:v1-v2"`, `"ch:v[a-z]"`, returns empty array for malformed/empty input. Handles all shapes used in the data files without producing NaN.
+- `verseSuffix` propagated through `scripture.cv`, `verses[]`, `to.verses[]`, `original`, and `abbr` so converting `Esther 11:2 ENG → LXX` outputs `Esther 1:1a` (was previously losing the letter suffix).
+- `cloned.missingPassages` array on conversions when verses don't exist in the target version (e.g., 1 Kgs 4:21 LXX="").
+- `src/data/lxx-editions.js` — registry of which OT books are in Göttingen vs. Rahlfs-only. Update as new Göttingen volumes ship.
+- New versification files: `2kings.js` (ENG 11:21 = MT/LXX 12:1; ENG 12:1-21 = MT/LXX 12:2-22), `esther.js` (Hanhart-verified Vulgate ↔ Rahlfs letter-suffix mapping for Additions A-F).
+- New `chapter_verses` extensions: Daniel 13 (Susanna, 64 v) + 14 (Bel, 42 v); Esther 10 extended through 16 for Vulgate/RSV-Apocrypha numbering of additions.
+- `Song of Solomon` registered as an alias of `Song of Songs` in `versified.js`.
+
+### Fixed
+
+- **MT-side versification bugs (116 entries):** entries that incorrectly left `mt = eng` when MT actually shifts. Verified by cross-checking against BHS in MongoDB.
+  - `Genesis 31:55-32:32` (33 entries): ENG 31:55 = MT 32:1, ENG 32:N = MT 32:N+1
+  - `1 Samuel 23:29` (1 entry): ENG 23:29 = MT 24:1
+  - `2 Samuel 18:33-19:43` (44 entries): ENG 18:33 = MT 19:1, ENG 19:N = MT 19:N+1
+  - `Psalms 92:0` (1 entry): ENG title = MT 92:1
+  - `Ezekiel 20:45-49` (5 entries): ENG 20:N = MT 21:N-44
+  - `Ezekiel 21:1-32` (32 entries): ENG 21:N = MT 21:N+5
+- `numbers.js`: replaced corrupted final entry (`29:40 → lxx:"26:48"`); added Num 30:1-16 ENG = MT/LXX 30:2-17.
+- `micah.js`: full rewrite. Was off by one on MT and unshifted on LXX. ENG 5:1 = MT/LXX 4:14, ENG 5:2-15 = MT/LXX 5:1-14.
+- `psalms.js`: fixed Ps 147:10-20 boundary. Was at 9/10; correct boundary is at 11/12 (ENG 147:1-11 = LXX 146:1-11; ENG 147:12-20 = LXX 147:1-9).
+- `genesis.js`: removed no-op `35:16` entry; corrected `35:21` to `lxx: ""` (verse missing in LXX).
+- `expandVersificationValue` correctly handles range strings (e.g., Gen 31:48 LXX `"31:47-48"`) by emitting one sub-passage per verse.
+
+### Tests
+
+- 77 assertion-based tests in `tests/lxx-versification-audit.test.js` covering `expandVersificationValue`, all the fixed entries, suffix preservation, edition switching, and the MT-side fixes. All passing.
+
 ## 0.3.0 — 2026-01-10
 
 - Added `convertVersion(targetVersion)` method on passage objects for versification conversion.

package/README.md

@@ -10,10 +10,12 @@ Built with precision and passion, CodexParser handles single verses, ranges, mul
 
 ## Features 🌟
 
--   **Parse Any Reference**: From "Jn 3:16" to "Psalm 115:5,7,10", it’s got you covered.
+-   **Parse Any Reference**: From "Jn 3:16" to "Psalm 115:5,7,10", it's got you covered.
 -   **Structured Output**: Get book, chapter, verses, testament, start/end points, SBL abbreviations, and versification data in a clean object.
 -   **SBL Abbreviations**: Formatted references (e.g., "Ps. 115:5, 7, 10", "Gen. 1:1–3") with periods, en dashes for ranges, and commas with spaces for separated verses.
--   **Versification Support**: Handles differences between English, LXX, and MT texts, with mappings like Psalm 115 (LXX) to Psalm 116 (MT/ENG).
+-   **Versification Support**: Handles differences between English, LXX, and MT texts — including the Greek additions to Esther (A–F) and Daniel (Susanna ch 13, Bel ch 14).
+-   **Göttingen vs. Rahlfs Editions**: Default to Göttingen where attested, fall back to Rahlfs elsewhere; switch with `parser.edition("rahlfs")`.
+-   **Letter-Suffixed Verses**: Hanhart's Esther additions (`1:1a`–`1:1s`, `4:17a`–`4:17z`, etc.) round-trip through `convertVersion` with `verseSuffix` carried through `scripture.cv`.
 -   **Validation**: Checks if verses exist, with detailed error messages for invalid references.
 -   **Combine Passages**: Merge multiple references into a single, cohesive range.
 -   **Chainable API**: Fluent, intuitive method chaining for a smooth workflow.
@@ -157,6 +159,55 @@ Notes:
 - `getVersion("eng"|"lxx"|"mt"|"bhs")` is available; `getBHS()` aliases `MT`.
 - `.scripture.hash` is OSIS textual (e.g., `John.3.16`), `.osisNumeric` uses pythonbible-style integer IDs.
 
+### Editions: Göttingen vs. Rahlfs
+
+CodexParser defaults to **Göttingen** versification where the critical edition exists and falls back to **Rahlfs** where it doesn't (per `src/data/lxx-editions.js`). Switch with `.edition()`:
+
+```javascript
+const parser = new CodexParser()
+
+// Default: "auto" (Göttingen-where-attested, Rahlfs-elsewhere)
+const [a] = parser.parse("Genesis 31:55").getPassages()
+console.log(a.getLXX().scripture.cv)               // "32:1" (Wevers Genesis)
+
+// Force Rahlfs across the whole parser
+parser.edition("rahlfs")
+const [b] = parser.parse("Genesis 31:55").getPassages()
+console.log(b.getLXX().scripture.cv)               // same here; would differ in books with `lxxRahlfs` overrides
+
+// Per-call override (no need to switch the whole parser)
+const [c] = parser.parse("Esther 1:1").getPassages()
+console.log(c.convertVersion("lxx", { edition: "rahlfs" }).scripture.cv)
+console.log(c.getLXXRahlfs().scripture.cv)         // helper equivalent
+```
+
+### Greek additions: Esther A–F and Daniel 13/14
+
+`Esther 11:2`–`16:24` (Vulgate / RSV-Apocrypha numbering) and `Daniel 13`/`14` (Susanna, Bel & the Dragon) parse and convert. Hanhart's letter-suffixed positions (`1:1a`, `4:17a`, `8:12x`, …) are carried through `verseSuffix`.
+
+```javascript
+const parser = new CodexParser()
+
+// Esther Addition A: ENG 11:2 -> LXX 1:1a
+const [e] = parser.parse("Esther 11:2").getPassages()
+const eLxx = e.convertVersion("lxx")
+console.log(eLxx.scripture.cv)                     // "1:1a"
+console.log(eLxx.passages[0].verseSuffix)          // "a"
+console.log(eLxx.passages[0].chapter, eLxx.passages[0].verse) // 1, 1
+
+// Susanna (Daniel 13) parses canonically
+const [s] = parser.parse("Daniel 13:1").getPassages()
+console.log(s.valid)                               // true
+const sMt = s.convertVersion("mt")
+console.log(sMt.missingPassages?.length)           // 1 (LXX-only chapter)
+
+// Range / missing-in-target verses don't NaN-out
+const [g] = parser.parse("Genesis 31:48").getPassages()
+console.log(g.getLXX().scripture.cv)               // "31:47-48" (range)
+const [k] = parser.parse("1 Kings 4:21").getPassages()
+console.log(k.getLXX().missingPassages[0].missingIn) // "lxx"
+```
+
 ---
 
 ## API: Your Codex Arsenal 🛠️
@@ -189,6 +240,24 @@ Here’s the breakdown of CodexParser’s key methods—your tools for mastering
 -   **Returns**: The parser instance for chaining.
 -   **Example**: `parser.bibleVersion("lxx").parse("Psalm 115:5,7,10");`
 
+### `.edition(edition)`
+
+-   **What it does**: Selects the LXX edition. `"auto"` (default) uses Göttingen where attested per `src/data/lxx-editions.js` and Rahlfs elsewhere. `"rahlfs"` forces Rahlfs versification universally and consults `lxxRahlfs` overrides where present.
+-   **Args**: `edition` (string) - `"auto"` or `"rahlfs"`.
+-   **Returns**: The parser instance for chaining.
+-   **Example**: `parser.edition("rahlfs").parse("Esther 11:2");`
+
+### `passage.convertVersion(target, options?)` / `passage.getLXXRahlfs()`
+
+-   **What it does**: Converts a parsed passage to another versification. `target` is `"eng"`, `"lxx"`, `"mt"`, or `"bhs"`. The optional `options.edition` (`"rahlfs"` or `"auto"`) overrides the parser-level edition for this single call. `getLXXRahlfs()` is a shortcut for `convertVersion("lxx", { edition: "rahlfs" })`.
+-   **Returns**: A cloned passage with `chapter` / `verse` / `verseSuffix` remapped, plus `cloned.missingPassages` listing any sub-passages that don't exist in the target version.
+-   **Example**:
+    ```javascript
+    const [p] = parser.parse("Esther 11:2").getPassages()
+    p.convertVersion("lxx").scripture.cv          // "1:1a"
+    p.convertVersion("mt").missingPassages.length // 1 (Add A is LXX-only)
+    ```
+
 ### `.getPassages()`
 
 -   **What it does**: Returns an array of parsed passage objects with handy methods like `.first()`, `.oldTestament()`, `.newTestament()`, and `.combine()`.
@@ -304,6 +373,29 @@ Let’s parse the scriptures together—happy coding! ✝️📚
 
 ## Release Notes
 
+### 0.4.0 (2026-04-28)
+
+LXX versification audit + structural fixes. Major data-correctness pass against authoritative sources (Hanhart's Göttingen Esther, Rahlfs-Hanhart 2006, Göttingen Theodotion Susanna/Daniel/Bel) verified against a Logos library extract.
+
+- New `parser.edition("rahlfs"|"auto")` setter and `passage.convertVersion(target, { edition })` per-call override; `passage.getLXXRahlfs()` helper.
+- `ReferenceParser.expandVersificationValue()` parses `"ch:v"`, `"ch:v1-v2"`, `"ch:v[a-z]"`, and rejects empty/malformed input cleanly. The previously-broken cases (Gen 31:48 LXX `"31:47-48"`, 1 Kgs 4:21 LXX `""`, Isa 64:1 MT `"63:19b"`, Dan 3:24a) all parse correctly.
+- `verseSuffix` is now carried through `scripture.cv`, `verses[]`, `original`, and `abbr` so `Esther 11:2 ENG → LXX` produces `Esther 1:1a` (not `1:1`).
+- `cloned.missingPassages` is populated when a verse doesn't exist in the conversion target (e.g., 1 Kgs 4:21 LXX, Daniel 13 in MT).
+- New `src/data/lxx-editions.js` registry; new `versifications/2kings.js`, `versifications/esther.js` (Hanhart-verified Vulgate ↔ Rahlfs Add A–F mapping); `chapter_verses` extended for Daniel 13/14 (Susanna + Bel) and Esther 10–16 (Vulgate apocrypha layout); `Song of Solomon` aliased to `Song of Songs`.
+- **116 MT-side bugs fixed** across Genesis 31:55–32:32, 1 Samuel 23:29, 2 Samuel 18:33–19:43, Psalms 92:0, Ezekiel 20:45–21:32 — entries that incorrectly left `mt = eng` when MT actually shifts. Verified against BHS data.
+- `numbers.js` corrupted final entry replaced + Num 30 added; `micah.js` rewritten; `psalms.js` Ps 147 boundary corrected from 9/10 to 11/12; `genesis.js` 35:16 no-op removed.
+- 77 assertion-based tests in `tests/lxx-versification-audit.test.js`. All passing.
+- Published to npm as `codexparser@0.4.0`.
+
+### 0.3.0 (2026-01-10)
+
+- Added `convertVersion(targetVersion)` method on passage objects for versification conversion.
+- Accepts version string: `"eng"`, `"lxx"`, `"mt"`, or `"bhs"` (alias for MT).
+- Automatically converts chapter/verse references between versifications when versification data exists.
+- Returns same reference with updated version metadata if no versification exists.
+- Tested with Psalms, Zechariah, and NT passages.
+- Published to npm as `codexparser@0.3.0`.
+
 ### 0.2.0 (2026-01-10)
 
 - Refactored internal architecture into clear folders:

package/RELEASE_NOTES_v0.4.0.md

@@ -0,0 +1,94 @@
+# CodexParser 0.4.0
+
+LXX versification audit + structural fixes. Major data-correctness pass against authoritative sources (Hanhart's Göttingen Esther 1983, Rahlfs-Hanhart 2006, Göttingen Theodotion Susanna/Daniel/Bel 1999) verified against a Logos library extract.
+
+## Highlights
+
+- **Göttingen vs. Rahlfs editions are now selectable.** Default is "auto" (Göttingen where attested, Rahlfs elsewhere); call `parser.edition("rahlfs")` to force Rahlfs everywhere, or pass `{ edition: "rahlfs" }` to `convertVersion`.
+- **Esther's Greek additions A–F now round-trip cleanly.** ENG `Esther 11:2` → LXX `Esther 1:1a` (with `verseSuffix: "a"` carried through `scripture.cv`, `verses[]`, `original`, and `abbr`).
+- **Daniel 13 (Susanna) and 14 (Bel & the Dragon) added** to `chapter_verses` and `versifications/daniel.js` (Theodotion).
+- **Letter-suffixed verses no longer produce NaN** in `convertVersion`. The previously-broken cases (Gen 31:48 LXX `"31:47-48"`, 1 Kgs 4:21 LXX `""`, Isa 64:1 MT `"63:19b"`, Dan 3:24a) all parse correctly via the new `ReferenceParser.expandVersificationValue()` helper.
+- **116 MT-side versification bugs fixed** across Genesis, 1 Samuel, 2 Samuel, Psalms, and Ezekiel — entries that incorrectly left `mt = eng` when MT actually shifts. Cross-verified against BHS data.
+- **Ps 147 boundary fixed** at 11/12 (was 9/10): ENG 147:1-11 = LXX 146:1-11; ENG 147:12-20 = LXX 147:1-9.
+- **Micah versification rewritten** (was off by one on MT and unshifted on LXX): ENG 5:1 = MT/LXX 4:14, ENG 5:2-15 = MT/LXX 5:1-14.
+
+## What's new in the API
+
+```javascript
+const CodexParser = require("codexparser")
+
+// 1. Edition selection
+const parser = new CodexParser().edition("rahlfs")           // force Rahlfs
+const auto   = new CodexParser()                              // auto (default)
+
+// 2. Per-call edition override
+const [p] = parser.parse("Genesis 31:55").getPassages()
+const lxxR = p.convertVersion("lxx", { edition: "rahlfs" })
+const lxxR2 = p.getLXXRahlfs()                                // helper
+
+// 3. Esther additions with letter suffix
+const [e] = parser.parse("Esther 11:2").getPassages()        // Add A
+const lxx = e.convertVersion("lxx")
+console.log(lxx.scripture.cv)                                 // "1:1a"
+console.log(lxx.passages[0].verseSuffix)                      // "a"
+
+// 4. Daniel 13 (Susanna) parses canonically
+const [s] = parser.parse("Daniel 13:1").getPassages()         // valid: true
+const mt  = s.convertVersion("mt")                            // missingPassages: chapter LXX-only
+
+// 5. Range/letter values handled cleanly
+const [g] = parser.parse("Genesis 31:48").getPassages()
+const gLxx = g.convertVersion("lxx")
+console.log(gLxx.scripture.cv)                                // "31:47-48"
+```
+
+## What got fixed in the data
+
+### MT-side bugs (116 entries)
+
+Each of these entries previously had `mt: "<ENG-key>"` (treating MT = ENG) when MT actually has an offset. Verified by checking against BHS texts.
+
+| Book | Range | Pattern |
+|------|-------|---------|
+| Genesis | 31:55-32:32 | ENG 31:55 = MT 32:1; ENG 32:N = MT 32:N+1 |
+| 1 Samuel | 23:29 | ENG 23:29 = MT 24:1 |
+| 2 Samuel | 18:33-19:43 | ENG 18:33 = MT 19:1; ENG 19:N = MT 19:N+1 |
+| Psalms | 92:0 | ENG title = MT 92:1 |
+| Ezekiel | 20:45-49 | ENG 20:N = MT 21:N-44 |
+| Ezekiel | 21:1-32 | ENG 21:N = MT 21:N+5 |
+
+### Other corrections
+
+- `numbers.js`: replaced corrupted final entry; added Num 30:1-16 ENG = MT/LXX 30:2-17.
+- `micah.js`: full rewrite (every entry was wrong).
+- `psalms.js`: fixed Ps 147 boundary 9/10 → 11/12.
+- `genesis.js`: removed no-op `35:16` entry; corrected `35:21` to `lxx: ""` (verse missing in LXX).
+
+## New data files
+
+- `src/data/lxx-editions.js` — registry mapping each OT book to its current Göttingen attestation (`"gottingen"` or `"rahlfs"`). Update as new Göttingen volumes ship.
+- `src/data/versifications/2kings.js` — ENG 11:21 = MT/LXX 12:1; ENG 12:1-21 = MT/LXX 12:2-22.
+- `src/data/versifications/esther.js` — Hanhart-verified Vulgate ↔ Rahlfs letter-suffix mapping for Additions A–F.
+- `src/data/chapter_verses/daniel.js` extended with Susanna (ch 13, 64 v) and Bel & Dragon (ch 14, 42 v).
+- `src/data/chapter_verses/esther.js` extended through chapter 16 (Vulgate / RSV-Apocrypha layout).
+- `Song of Solomon` registered as an alias of `Song of Songs` in `versified.js`.
+
+## New return-shape fields
+
+- **`passage.passages[i].verseSuffix`** — letter suffix when present (`"a"`, `"s"`, `"ee"`, etc.).
+- **`passage.edition`** — `"auto"` or `"rahlfs"`, the resolved edition for this passage.
+- **`cloned.missingPassages`** — array of sub-passages that don't exist in the conversion target (e.g., 1 Kgs 4:21 LXX, Daniel 13 in MT).
+
+## Tests
+
+77 assertion-based tests in `tests/lxx-versification-audit.test.js` covering `expandVersificationValue`, every fixed entry, suffix preservation, edition switching, and the MT-side fixes. All passing. Run with:
+
+```bash
+node tests/lxx-versification-audit.test.js
+```
+
+## Breaking changes
+
+- `convertVersion` now returns `cloned.missingPassages` for verses that don't exist in the target version, where previously those would surface as NaN-valued `chapter`/`verse`. Callers that relied on NaN will need to handle the new `missingPassages` array instead.
+
+See full CHANGELOG: https://github.com/jeremyam/CodexParser/blob/main/CHANGELOG.md

package/package.json

@@ -1,8 +1,18 @@
 {
   "name": "codexparser",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "This is a Javascript Bible parser and text scanner. It will search through texts and collate all scripture references into an array and parse them into objects, and it will parse passages into objects by book, chapter, verse, and testament. ",
   "main": "index.js",
+  "files": [
+    "index.js",
+    "src/index.js",
+    "src/core/",
+    "src/data/",
+    "src/format/",
+    "src/utils/",
+    "CHANGELOG.md",
+    "RELEASE_NOTES_v0.4.0.md"
+  ],
   "scripts": {
     "test": "echo \"Error: no automated test runner configured\" && exit 0"
   },

package/src/core/CodexParser.js

@@ -39,6 +39,7 @@ class CodexParser {
             booksOnly: config.booksOnly ?? false,
             invalid_sequence_strategy: config.invalid_sequence_strategy ?? "include",
             invalid_passage_strategy: config.invalid_passage_strategy ?? "include",
+            edition: CodexParser.#normalizeEdition(config.edition),
         }
 
         this.#scanner = new ScriptureScanner(this.#config)
@@ -134,6 +135,7 @@ class CodexParser {
             booksOnly: config.booksOnly ?? this.#config.booksOnly,
             invalid_sequence_strategy: config.invalid_sequence_strategy ?? this.#config.invalid_sequence_strategy,
             invalid_passage_strategy: config.invalid_passage_strategy ?? this.#config.invalid_passage_strategy,
+            edition: config.edition !== undefined ? CodexParser.#normalizeEdition(config.edition) : this.#config.edition,
         }
 
         // Update scanner and parser configs
@@ -143,6 +145,25 @@ class CodexParser {
         return this
     }
 
+    /**
+     * Sets the LXX edition preference. "auto" (default) uses Göttingen where
+     * attested per src/data/lxx-editions.js and falls back to Rahlfs elsewhere.
+     * "rahlfs" forces Rahlfs versification universally.
+     * @param {string} edition - "auto" | "rahlfs"
+     * @returns {CodexParser}
+     */
+    edition(edition) {
+        this.#config.edition = CodexParser.#normalizeEdition(edition)
+        this.#parser = new ReferenceParser(this.#config)
+        return this
+    }
+
+    static #normalizeEdition(value) {
+        if (value == null) return "auto"
+        const v = String(value).toLowerCase()
+        return v === "rahlfs" ? "rahlfs" : "auto"
+    }
+
     /**
      * Retrieves available verses for a given book and chapter (legacy method)
      * @param {string} book - The book name

package/src/core/ReferenceParser.js

@@ -31,6 +31,39 @@ class ReferenceParser {
         this.#config = config
     }
 
+    /**
+     * Parses a versification value string into one or more {chapter, verse, suffix?} entries.
+     * Accepts:
+     *   - "ch:v"       → [{chapter, verse}]
+     *   - "ch:v1-v2"   → expanded to one entry per verse in range
+     *   - "ch:v[a-z]"  → [{chapter, verse, suffix}]
+     * Returns [] for unparseable input.
+     */
+    static expandVersificationValue(value) {
+        if (typeof value !== "string" || !value.includes(":")) return []
+        const [chPart, vPart] = value.split(":")
+        const chapter = Number(chPart)
+        if (!Number.isFinite(chapter)) return []
+
+        // Range form "v1-v2" (no letter suffixes inside ranges)
+        if (vPart.includes("-")) {
+            const [a, b] = vPart.split("-").map((s) => Number(s.trim()))
+            if (!Number.isFinite(a) || !Number.isFinite(b) || b < a) return []
+            const out = []
+            for (let v = a; v <= b; v++) out.push({ chapter, verse: v })
+            return out
+        }
+
+        // Letter-suffix form "19b"
+        const match = vPart.match(/^(\d+)([a-zA-Z]+)?$/)
+        if (!match) return []
+        const verse = Number(match[1])
+        if (!Number.isFinite(verse)) return []
+        const entry = { chapter, verse }
+        if (match[2]) entry.suffix = match[2]
+        return [entry]
+    }
+
     /**
      * Parses found references into structured passage objects
      * @param {Array} foundReferences - Array of found references from scanner
@@ -53,6 +86,7 @@ class ReferenceParser {
                 endIndex: reference.endIndex,
                 originalText: reference.originalText,
                 version: VersionHandler.getVersion(reference.version || currentVersion, testament),
+                edition: this.#config.edition || "auto",
                 passages: [],
                 scripture: null,
                 valid: true,
@@ -128,19 +162,65 @@ class ReferenceParser {
      */
     #attachVersionHelpers(passage) {
         const self = this
-        const computeConverted = (srcPassage, targetAbbr) => {
+        const computeConverted = (srcPassage, targetAbbr, options = {}) => {
             const versionObj = VersionHandler.getVersionObject(targetAbbr)
             const cloned = JSON.parse(JSON.stringify(srcPassage))
             cloned.version = versionObj
 
-            // Remap chapters/verses according to versification, if present
+            // Resolve which LXX edition to consult. "rahlfs" prefers
+            // versification.lxxRahlfs when present; "auto" (default) uses the
+            // canonical lxx field, which by convention holds Göttingen where
+            // attested and Rahlfs elsewhere (see src/data/lxx-editions.js).
+            const edition =
+                options.edition != null
+                    ? String(options.edition).toLowerCase()
+                    : srcPassage.edition || "auto"
+
+            const resolveTargetKey = (versification) => {
+                if (targetAbbr === "lxx" && edition === "rahlfs" && versification.lxxRahlfs !== undefined) {
+                    return "lxxRahlfs"
+                }
+                return targetAbbr
+            }
+
+            // Remap chapters/verses according to versification, if present.
+            // Versification values may be strict "ch:v", a range "ch:v1-v2",
+            // a letter-suffixed verse "ch:v[a-z]", or "" / null when the verse
+            // does not exist in the target version. We expand ranges and split
+            // missing verses into cloned.missingPassages so summary fields
+            // never contain NaN.
+            const remapped = []
+            const missing = []
             cloned.passages.forEach((sub) => {
-                if (sub.versification && sub.versification[targetAbbr]) {
-                    const [ch, v] = sub.versification[targetAbbr].split(":").map(Number)
-                    sub.chapter = ch
-                    sub.verse = v
+                if (!sub.versification) {
+                    remapped.push(sub)
+                    return
                 }
+                const key = resolveTargetKey(sub.versification)
+                if (!(key in sub.versification)) {
+                    remapped.push(sub)
+                    return
+                }
+                const target = sub.versification[key]
+                if (target == null || target === "") {
+                    missing.push({ ...sub, missingIn: targetAbbr })
+                    return
+                }
+                const expanded = ReferenceParser.expandVersificationValue(target)
+                if (expanded.length === 0) {
+                    remapped.push(sub)
+                    return
+                }
+                expanded.forEach((entry, idx) => {
+                    const next = idx === 0 ? sub : JSON.parse(JSON.stringify(sub))
+                    next.chapter = entry.chapter
+                    next.verse = entry.verse
+                    if (entry.suffix) next.verseSuffix = entry.suffix
+                    remapped.push(next)
+                })
             })
+            cloned.passages = remapped
+            if (missing.length > 0) cloned.missingPassages = missing
 
             // Sort and recompute summary fields
             cloned.passages.sort((a, b) => a.chapter - b.chapter || a.verse - b.verse)
@@ -158,13 +238,13 @@ class ReferenceParser {
                 }
             }
 
-            const chapterVersesMap = {}
+            const chapterEntries = {}
             cloned.passages.forEach((p) => {
-                if (!chapterVersesMap[p.chapter]) chapterVersesMap[p.chapter] = new Set()
-                chapterVersesMap[p.chapter].add(p.verse)
+                if (!chapterEntries[p.chapter]) chapterEntries[p.chapter] = []
+                chapterEntries[p.chapter].push({ verse: p.verse, suffix: p.verseSuffix || "" })
             })
 
-            const sortedChs = Object.keys(chapterVersesMap)
+            const sortedChs = Object.keys(chapterEntries)
                 .map(Number)
                 .sort((a, b) => a - b)
             const chapterStrs = []
@@ -187,13 +267,32 @@ class ReferenceParser {
                 return merged
             }
 
+            const formatChapterVerses = (entries) => {
+                const usable = entries.filter((e) => e.verse > 0)
+                if (usable.length === 0) return []
+                const sorted = [...usable].sort(
+                    (a, b) => a.verse - b.verse || a.suffix.localeCompare(b.suffix)
+                )
+                if (sorted.some((e) => e.suffix)) {
+                    // Letter-suffixed verses (Esther additions, Isa 63:19b, Dan 3:24a):
+                    // do not range-merge - emit each as "<verse><suffix>" individually.
+                    const seen = new Set()
+                    const out = []
+                    for (const e of sorted) {
+                        const tag = `${e.verse}${e.suffix}`
+                        if (seen.has(tag)) continue
+                        seen.add(tag)
+                        out.push(tag)
+                    }
+                    return out
+                }
+                return mergeRanges([...new Set(sorted.map((e) => e.verse))])
+            }
+
             sortedChs.forEach((ch) => {
-                const vs = Array.from(chapterVersesMap[ch])
-                    .filter((v) => v > 0)
-                    .sort((a, b) => a - b)
-                if (vs.length > 0) {
-                    const merged = mergeRanges(vs)
-                    chapterStrs.push(`${ch}:${merged.join(",")}`)
+                const formatted = formatChapterVerses(chapterEntries[ch])
+                if (formatted.length > 0) {
+                    chapterStrs.push(`${ch}:${formatted.join(",")}`)
                 }
             })
 
@@ -205,20 +304,21 @@ class ReferenceParser {
             const lastCh = sortedChs[sortedChs.length - 1]
             cloned.chapter = firstCh
 
-            const mergedFirst = mergeRanges(chapterVersesMap[firstCh] || new Set())
-            cloned.verses = mergedFirst
+            const formattedFirst = formatChapterVerses(chapterEntries[firstCh] || [])
+            cloned.verses = formattedFirst
 
             if (firstCh !== lastCh) {
                 cloned.type = ReferenceParser.REFERENCE_TYPES.MULTI_CHAPTER_RANGE
                 cloned.to = {
                     book: cloned.book,
                     chapter: lastCh,
-                    verses: mergeRanges(chapterVersesMap[lastCh] || new Set()),
+                    verses: formatChapterVerses(chapterEntries[lastCh] || []),
                 }
                 cloned.original = `${cloned.book} ${chapterStrs.join("; ")}`
             } else {
                 const hasRangeOrMultiple =
-                    mergedFirst.length > 1 || (mergedFirst.length === 1 && mergedFirst[0].includes("-"))
+                    formattedFirst.length > 1 ||
+                    (formattedFirst.length === 1 && formattedFirst[0].includes("-"))
                 cloned.type = hasRangeOrMultiple
                     ? ReferenceParser.REFERENCE_TYPES.CHAPTER_VERSE_RANGE
                     : ReferenceParser.REFERENCE_TYPES.CHAPTER_VERSE
@@ -251,12 +351,15 @@ class ReferenceParser {
             return cloned
         }
 
-        passage.getVersion = function (targetVersion) {
+        passage.getVersion = function (targetVersion, options = {}) {
             const targetAbbr = targetVersion.toLowerCase() === "bhs" ? "mt" : targetVersion.toLowerCase()
-            return computeConverted(this, targetAbbr)
+            return computeConverted(this, targetAbbr, options)
+        }
+        passage.getLXX = function (options = {}) {
+            return this.getVersion("lxx", options)
         }
-        passage.getLXX = function () {
-            return this.getVersion("lxx")
+        passage.getLXXRahlfs = function () {
+            return this.getVersion("lxx", { edition: "rahlfs" })
         }
         passage.getMT = function () {
             return this.getVersion("mt")
@@ -267,7 +370,7 @@ class ReferenceParser {
         passage.getEnglish = function () {
             return this.getVersion("eng")
         }
-        passage.convertVersion = function (targetVersion) {
+        passage.convertVersion = function (targetVersion, options = {}) {
             const targetAbbr = targetVersion.toLowerCase() === "bhs" ? "mt" : targetVersion.toLowerCase()
 
             // Check if any passages have versification data
@@ -281,7 +384,7 @@ class ReferenceParser {
             }
 
             // Has versification, use the full conversion
-            return computeConverted(this, targetAbbr)
+            return computeConverted(this, targetAbbr, options)
         }
     }
 

package/src/data/chapter_verses/daniel.js

@@ -11,4 +11,8 @@ module.exports = {
     10: Array.from({ length: 21 }, (_, i) => i + 1), // Daniel 10 has 21 verses
     11: Array.from({ length: 45 }, (_, i) => i + 1), // Daniel 11 has 45 verses
     12: Array.from({ length: 13 }, (_, i) => i + 1), // Daniel 12 has 13 verses
+    // Greek (deuterocanonical) Daniel: Susanna and Bel & the Dragon, present
+    // in LXX (both Theodotion and Old Greek) and absent from MT.
+    13: Array.from({ length: 64 }, (_, i) => i + 1), // Susanna (Theodotion)
+    14: Array.from({ length: 42 }, (_, i) => i + 1), // Bel and the Dragon (Theodotion)
 }

package/src/data/chapter_verses/esther.js

@@ -1,3 +1,8 @@
+// Esther chapter:verse counts using the Vulgate / RSV-with-Apocrypha layout,
+// which appends the six Greek additions (A-F) as chapters 10:4-16:24.
+// Hebrew Esther runs through 10:3; verses 10:4 onward are deuterocanonical
+// (LXX-only). Note: this changes validation - "Esther 11:2" will now resolve
+// even in eng mode. Canonical-only validation is a higher-level concern.
 module.exports = {
     1: Array.from({ length: 22 }, (_, i) => i + 1), // Esther 1 has 22 verses
     2: Array.from({ length: 23 }, (_, i) => i + 1), // Esther 2 has 23 verses
@@ -8,5 +13,11 @@ module.exports = {
     7: Array.from({ length: 10 }, (_, i) => i + 1), // Esther 7 has 10 verses
     8: Array.from({ length: 17 }, (_, i) => i + 1), // Esther 8 has 17 verses
     9: Array.from({ length: 32 }, (_, i) => i + 1), // Esther 9 has 32 verses
-    10: Array.from({ length: 3 }, (_, i) => i + 1), // Esther 10 has 3 verses
+    10: Array.from({ length: 13 }, (_, i) => i + 1), // 10:1-3 Hebrew + 10:4-13 Addition F
+    11: Array.from({ length: 12 }, (_, i) => i + 1), // 11:1 colophon + 11:2-12 Addition A pt 1
+    12: Array.from({ length: 6 }, (_, i) => i + 1), // 12:1-6 Addition A pt 2
+    13: Array.from({ length: 18 }, (_, i) => i + 1), // 13:1-7 Add B + 13:8-18 Add C (Mordecai's prayer)
+    14: Array.from({ length: 19 }, (_, i) => i + 1), // 14:1-19 Add C (Esther's prayer)
+    15: Array.from({ length: 16 }, (_, i) => i + 1), // 15:1-16 Add D (Esther approaches the king)
+    16: Array.from({ length: 24 }, (_, i) => i + 1), // 16:1-24 Add E (king's second decree)
 }

package/src/data/lxx-editions.js

@@ -0,0 +1,58 @@
+// Tracks which OT books have a published Göttingen Septuaginta critical
+// edition. Books listed as "gottingen" are ones the parser treats as
+// Göttingen-attested by default; everything else falls back to Rahlfs.
+//
+// Update this list when new Göttingen volumes ship. The `lxx` field in each
+// versification entry should reflect this default (Göttingen where attested,
+// Rahlfs elsewhere); add an `lxxRahlfs` override only when the two editions
+// disagree on numbering for a specific verse.
+//
+// Sources:
+//   https://adw-goe.de/forschung/forschungsprojekte-akademienprogramm/septuaginta-unternehmen/
+//   Hanhart, R. (1983). Esther. Septuaginta VIII.3.
+//   Ziegler, J. & Munnich, O. (1999). Susanna - Daniel - Bel et Draco. Septuaginta XVI.2.
+//
+// As of 2026-04: published. Pentateuch is partial (Genesis published as
+// Wevers 1974; Exodus, Leviticus, Numbers, Deuteronomy via Wevers).
+module.exports = {
+    Genesis: "gottingen",
+    Exodus: "gottingen",
+    Leviticus: "gottingen",
+    Numbers: "gottingen",
+    Deuteronomy: "gottingen",
+    Joshua: "rahlfs",
+    Judges: "rahlfs",
+    Ruth: "gottingen",
+    "1 Samuel": "rahlfs",
+    "2 Samuel": "rahlfs",
+    "1 Kings": "rahlfs",
+    "2 Kings": "rahlfs",
+    "1 Chronicles": "rahlfs",
+    "2 Chronicles": "rahlfs",
+    Ezra: "gottingen", // 1 Esdras / 2 Esdras (Hanhart)
+    Nehemiah: "gottingen",
+    Esther: "gottingen", // Hanhart 1983
+    Job: "gottingen", // Ziegler 1982
+    Psalms: "gottingen", // Rahlfs 1931
+    Proverbs: "rahlfs",
+    Ecclesiastes: "gottingen", // Gentry 2019
+    "Song of Songs": "rahlfs",
+    "Song of Solomon": "rahlfs",
+    Isaiah: "gottingen", // Ziegler 1939
+    Jeremiah: "gottingen", // Ziegler 1957
+    Lamentations: "gottingen",
+    Ezekiel: "gottingen", // Ziegler 1952
+    Daniel: "gottingen", // Ziegler & Munnich 1999 (incl. Susanna, Bel)
+    Hosea: "gottingen", // Ziegler 1943 (Duodecim Prophetae)
+    Joel: "gottingen",
+    Amos: "gottingen",
+    Obadiah: "gottingen",
+    Jonah: "gottingen",
+    Micah: "gottingen",
+    Nahum: "gottingen",
+    Habakkuk: "gottingen",
+    Zephaniah: "gottingen",
+    Haggai: "gottingen",
+    Zechariah: "gottingen",
+    Malachi: "gottingen",
+}