waha-shared 1.0.307 → 1.0.308

package/dist/functions/scripturePassages.js

@@ -1,33 +1,61 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseVerseRange = void 0;
+exports.parseVerseRange = parseVerseRange;
 exports.getChapterUrl = getChapterUrl;
 exports.getPassagesString = getPassagesString;
 exports.getScripturePassage = getScripturePassage;
 exports.getLessonScripture = getLessonScripture;
+exports.parseBibleSnapshot = parseBibleSnapshot;
 exports.verseToSuperscript = verseToSuperscript;
-exports.getFtbDuration = getFtbDuration;
-exports.enrichSections = enrichSections;
+exports.getLessonPauses = getLessonPauses;
 exports.normalizeVerseTimings = normalizeVerseTimings;
 const bibleStatuses_1 = require("../data/bibleStatuses");
-const firebase_1 = require("../data/firebase");
+const lessonPauses_1 = require("../data/lessonPauses");
 const mediaDurations_1 = require("../data/mediaDurations");
+const specialIds_1 = require("../data/specialIds");
 const languages_1 = require("../functions/languages");
-const sets_1 = require("../types/sets");
-const bibleBooks_1 = require("./bibleBooks");
-const bibles_1 = require("./bibles");
-var bibleBooks_2 = require("./bibleBooks");
-Object.defineProperty(exports, "parseVerseRange", { enumerable: true, get: function () { return bibleBooks_2.parseVerseRange; } });
+const bibleChapters_1 = require("../types/bibleChapters");
+const sets_1 = require("./sets");
+/**
+ * Parses a verse range string like "GEN.1.1-GEN.1.25" or "JHN.3.16" or "REV.22"
+ * Returns the start and end verse IDs
+ */
+function parseVerseRange(passageId) {
+    // Handle single verse: "GEN.1.1" -> "GEN.1.1-GEN.1.1"
+    const parts = passageId.includes('-')
+        ? passageId.split('-')
+        : [passageId, passageId];
+    const startParts = parts[0].split('.');
+    const endParts = parts[1].split('.');
+    const startBook = startParts[0];
+    const startChapter = startParts[1];
+    const startVerse = startParts.length > 2 ? startParts[2] : '1';
+    const endBook = endParts[0];
+    const endChapter = endParts[1];
+    const endVerse = endParts.length > 2 ? endParts[2] : '1';
+    return {
+        startBook,
+        startChapter,
+        startVerse,
+        endBook,
+        endChapter,
+        endVerse,
+        startChapterId: `${startBook}.${startChapter}`,
+        endChapterId: `${endBook}.${endChapter}`,
+    };
+}
 function getChapterUrl(params) {
-    const book = 'book' in params ? params.book : (0, bibleBooks_1.parseVerseRange)(params.passageId).book;
-    const chapter = 'chapter' in params
-        ? params.chapter
-        : (0, bibleBooks_1.parseVerseRange)(params.passageId).chapter;
-    return (firebase_1.firebaseUrl +
+    const startBook = 'startBook' in params
+        ? params.startBook
+        : parseVerseRange(params.passageId).startBook;
+    const startChapter = 'startChapter' in params
+        ? params.startChapter
+        : parseVerseRange(params.passageId).startChapter;
+    return (sets_1.firebaseUrl +
         encodeURIComponent('audio_bibles' +
             `/${params.bibleAudioId}` +
-            `/${book}` +
-            `/${book}_${chapter.padStart(3, '0')}.mp3`) +
+            `/${startBook}` +
+            `/${startBook}_${startChapter.padStart(3, '0')}.mp3`) +
         `?alt=media`);
 }
 /** Extracts verses from a chapter based on verse numbers */
@@ -57,90 +85,170 @@ function extractVersesFromChapter(chapter, startVerse, endVerse) {
  *   ["GEN.1.1-GEN.1.25", "GEN.2.4-GEN.2.7", "EXO.3.3-EXO.3.25"] -> "Genesis 1: 1-25, 2: 4-7, Exodus 3: 3-25"
  *   ["JHN.1.1"] -> "John 1: 1"
  */
-function getPassagesString(passages) {
+function getPassagesString(passageIds, language) {
+    if (!passageIds || passageIds.length === 0)
+        return '';
     const parts = [];
     let currentBook = null;
-    for (const passage of passages) {
-        const bibleInfo = (0, bibles_1.getBibleInfo)(passage.bibleId);
-        if (!bibleInfo)
-            continue;
-        const { book, chapter, startVerse, endVerse } = (0, bibleBooks_1.parseVerseRange)(passage.passageId);
-        const bookName = bibleInfo.bookNames[book];
-        if (!bookName)
-            continue;
-        const verseRange = startVerse === endVerse ? startVerse : `${startVerse}-${endVerse}`;
-        if (currentBook !== book) {
-            currentBook = book;
-            parts.push((0, languages_1.numerals)(`${bookName} ${chapter}: ${verseRange}`, bibleInfo.language.script));
+    for (const passageId of passageIds) {
+        const { startBook, startChapter, startVerse, endChapter, endVerse } = parseVerseRange(passageId);
+        let bookName = 
+        // American sign language should use English book names.
+        language.languageId === 'ase'
+            ? bibleStatuses_1.bibleStatuses.NLT.bookNames[startBook]
+            : language.bible.bookNames[startBook];
+        if (!bookName) {
+            bookName = language.bibleFallback?.bookNames[startBook];
+            if (!bookName)
+                continue;
+        }
+        // New book - include book name
+        if (currentBook !== startBook) {
+            currentBook = startBook;
+            // Same chapter
+            if (startChapter === endChapter) {
+                if (startVerse === endVerse) {
+                    parts.push(`${bookName} ${startChapter}: ${startVerse}`);
+                }
+                else {
+                    parts.push(`${bookName} ${startChapter}: ${startVerse}-${endVerse}`);
+                }
+            }
+            else {
+                // Different chapters
+                parts.push(`${bookName} ${startChapter}: ${startVerse}-${endChapter}: ${endVerse}`);
+            }
         }
         else {
-            parts.push((0, languages_1.numerals)(`${chapter}: ${verseRange}`, bibleInfo.language.script));
+            // Same book - omit book name
+            if (startChapter === endChapter) {
+                if (startVerse === endVerse) {
+                    parts.push(`${startChapter}: ${startVerse}`);
+                }
+                else {
+                    parts.push(`${startChapter}: ${startVerse}-${endVerse}`);
+                }
+            }
+            else {
+                // Different chapters
+                parts.push(`${startChapter}: ${startVerse}-${endChapter}: ${endVerse}`);
+            }
         }
     }
-    return parts.join(', ');
+    return (0, languages_1.numerals)(parts.join(', '), language.script.name);
 }
 /** Gets a scripture passage by extracting verses from chapters documents. */
-async function getScripturePassage({ bibleId, passageId, getChapter, noTextAvailableString, }) {
-    const bibleInfo = (0, bibles_1.getBibleInfo)(bibleId);
-    const { startVerse, endVerse, chapterId } = (0, bibleBooks_1.parseVerseRange)(passageId);
-    const noTextAvailableReturn = {
-        bibleId,
-        header: getPassagesString([{ passageId, bibleId }]),
-        passageId,
-        verses: [],
-    };
-    if (!bibleInfo)
-        return noTextAvailableReturn;
-    const returnExpected = bibleInfo.availableTextChapters.includes(chapterId) ||
-        bibleInfo.availableTimingsChapters.includes(chapterId);
-    /**
-     * In this case, we know the bible does not have text for this chapter, so the
-     * user will see a placeholder verse.
-     */
-    if (!returnExpected) {
-        noTextAvailableReturn.verses = [
-            { text: noTextAvailableString, verseId: '' },
-        ];
-        return noTextAvailableReturn;
-    }
+async function getScripturePassage({ bibleId, bibleFallbackId, passageId, getChapter, languageInfo, }) {
     try {
+        const { startBook, startChapter, startVerse, endBook, endChapter, endVerse, } = parseVerseRange(passageId);
         const startVerseNum = parseInt(startVerse);
         const endVerseNum = parseInt(endVerse);
-        const chapter = await getChapter({ chapterId, bibleId });
-        if (!chapter)
-            return noTextAvailableReturn;
-        const verses = extractVersesFromChapter(chapter, startVerseNum, endVerseNum);
-        if (verses.length === 0) {
-            console.warn(`No verses found for passage ${bibleId};${passageId}`);
-            return noTextAvailableReturn;
+        // Same chapter - simple case
+        if (startBook === endBook && startChapter === endChapter) {
+            const chapterId = `${startBook}.${startChapter}`;
+            let chapter = await getChapter({ chapterId, bibleId });
+            if (!chapter && bibleFallbackId)
+                chapter = await getChapter({ chapterId, bibleId: bibleFallbackId });
+            if (!chapter) {
+                console.warn(`Chapter not found: ${bibleId}.${chapterId} for passage ${passageId}`);
+                return;
+            }
+            const verses = extractVersesFromChapter(chapter, startVerseNum, endVerseNum);
+            if (verses.length === 0) {
+                console.warn(`No verses found for passage ${passageId}`);
+                return;
+            }
+            return {
+                passageId,
+                bibleId,
+                header: getPassagesString([passageId], languageInfo),
+                verses,
+            };
         }
-        if (!verses.some((v) => v.text))
-            verses[0].text = noTextAvailableString;
+        // Multi-chapter passage (rare but possible)
+        // Example: GEN.1.26-GEN.2.3
+        const chapters = [];
+        // Get all chapters in the range
+        const startChapterNum = parseInt(startChapter);
+        const endChapterNum = parseInt(endChapter);
+        for (let i = startChapterNum; i <= endChapterNum; i++) {
+            const chapterId = `${startBook}.${i}`;
+            let chapter = await getChapter({ chapterId, bibleId });
+            if (!chapter && bibleFallbackId)
+                chapter = await getChapter({ chapterId, bibleId: bibleFallbackId });
+            if (chapter) {
+                chapters.push(chapter);
+            }
+            else {
+                console.warn(`Missing chapter in range: ${bibleId}.${chapterId}`);
+            }
+        }
+        if (chapters.length === 0) {
+            return;
+        }
+        // Extract verses from each chapter
+        const allVerses = [];
+        chapters.forEach((chapter, index) => {
+            if (index === 0) {
+                // First chapter - from startVerse to end
+                const lastVerse = Math.max(...chapter.verses.map((v) => parseInt(v.verseId.split('.')[2])));
+                allVerses.push(...extractVersesFromChapter(chapter, startVerseNum, lastVerse));
+            }
+            else if (index === chapters.length - 1) {
+                // Last chapter - from beginning to endVerse
+                allVerses.push(...extractVersesFromChapter(chapter, 1, endVerseNum));
+            }
+            else {
+                // Middle chapters - all verses
+                allVerses.push(...chapter.verses);
+            }
+        });
         return {
             passageId,
-            bibleId: chapter.translationId,
-            header: getPassagesString([{ passageId, bibleId }]),
-            verses,
+            bibleId,
+            header: getPassagesString([passageId], languageInfo),
+            verses: allVerses,
         };
     }
     catch (error) {
         console.error(`Error getting scripture passage ${passageId} in ${bibleId}`, error);
-        throw error;
+        return;
     }
 }
-/** Gets all scripture passages for a lesson. */
-async function getLessonScripture({ getChapter, lessonInfo, noTextAvailableString, }) {
-    return Promise.all(lessonInfo.sections
-        .filter((s) => s.chapter === sets_1.Chapter.STORY)
-        .map((s) => {
-        const [bibleId, passageId] = s.id.split(';');
-        return getScripturePassage({
-            bibleId,
-            passageId,
-            getChapter,
-            noTextAvailableString,
-        });
-    }));
+/**
+ * Gets multiple scripture passages efficiently (Future optimization: could
+ * batch the chapter fetches)
+ */
+async function getLessonScripture(params) {
+    const passages = await Promise.all(params.passageIds.map((passageId) => getScripturePassage({ ...params, passageId })));
+    return passages;
+}
+function parseBibleSnapshot(snapshot, bible) {
+    const validChapters = [];
+    if (!snapshot) {
+        console.warn('No snapshot for', bible);
+        return [];
+    }
+    else if (snapshot.empty) {
+        console.warn('Empty snapshot for', bible);
+        return [];
+    }
+    for (const doc of snapshot.docs) {
+        const chapterParse = bibleChapters_1.BibleChapter.safeParse(doc.data());
+        if (!chapterParse.success) {
+            console.warn('Skipping invalid bible chapter document', doc.id, chapterParse.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`));
+        }
+        else {
+            validChapters.push(chapterParse.data);
+        }
+    }
+    if (validChapters.length === 0) {
+        console.warn('No valid chapters for', bible);
+        return [];
+    }
+    else {
+        return validChapters;
+    }
 }
 /**
  * Converts a verse number to a superscript string. This is useful for
@@ -177,102 +285,131 @@ function verseToSuperscript(num) {
         .join('');
 }
 /**
- * Returns the FTB audio duration + afterFtb pause for a section, or 0 if the
- * section has no FTB.
+ * Splits a passage's verses into per-chapter chunks. Single-chapter passages
+ * produce one chunk. Multi-chapter passages (rare, e.g. GEN.1.26-GEN.2.3)
+ * produce one chunk per chapter, with isPartOfPrevious=true on the 2nd+ chunks.
+ * This mirrors leviathan's passage_ids_by_chapter splitting logic.
  */
-function getFtbDuration(section, lessonInfo) {
-    if (!section.ftbFileName)
-        return 0;
-    const ftbDuration = mediaDurations_1.mediaDurations[lessonInfo.contentLanguages.ftbs]?.[section.ftbFileName];
-    if (ftbDuration == null) {
-        console.warn(`FTB duration not found for ${section.ftbFileName}`);
-    }
-    return (ftbDuration ?? 0) + lessonInfo.lessonPauses.afterFtb;
-}
-/**
- * Fills in `length` (for verse-timed story sections) and `startTime` (for all
- * sections) by accumulating forward through the lesson. After this, every
- * section has both fields set.
- */
-function enrichSections(lessonInfo, scripture) {
-    const storySections = lessonInfo.sections.filter((s) => s.chapter === sets_1.Chapter.STORY);
-    // Forward pass: compute lengths and start times for all non-application
-    // sections.
-    let currentTime = 0;
-    const enriched = lessonInfo.sections.map((section) => {
-        if (!section.chapter)
-            return { ...section, startTime: 0, length: 0 };
-        currentTime += section.pauseBefore ?? 0;
-        let length;
-        const startTime = currentTime;
-        if (section.chapter !== sets_1.Chapter.STORY) {
-            length = mediaDurations_1.mediaDurations[section.languageId]?.[section.fileName];
+function splitPassageIntoChunks(verses) {
+    if (verses.length === 0)
+        return [];
+    const chunks = [];
+    let currentChapterId = null;
+    for (const verse of verses) {
+        const parts = verse.verseId.split('.');
+        const chapterId = `${parts[0]}.${parts[1]}`;
+        if (chapterId !== currentChapterId) {
+            chunks.push({
+                verses: [verse],
+                bookId: parts[0],
+                isPartOfPrevious: currentChapterId !== null,
+            });
+            currentChapterId = chapterId;
         }
         else {
-            currentTime += getFtbDuration(section, lessonInfo);
-            const [bibleId, passageId] = section.id.split(';');
-            length = bibleStatuses_1.bibleStatuses[bibleId]?.customPassages?.[passageId];
-            if (!length) {
-                const passage = scripture[storySections.indexOf(section)];
-                if (passage) {
-                    const firstTimed = passage.verses.find((v) => v.timings);
-                    const lastTimed = [...passage.verses].reverse().find((v) => v.timings);
-                    if (firstTimed?.timings && lastTimed?.timings) {
-                        length = lastTimed.timings[1] - firstTimed.timings[0];
-                    }
-                }
-            }
-        }
-        if (length == null) {
-            console.warn(`Missing duration for section ${section.id} (${section.chapter}, ${section.fileName})`);
-        }
-        currentTime += length ?? 0;
-        return { ...section, length: length ?? 0, startTime };
-    });
-    // Backward pass: compute application section start times from the end of the
-    // lesson file, so they are always correct even if story durations are
-    // slightly off.
-    const fullFileName = lessonInfo.type === 'dbs'
-        ? lessonInfo.full.localFileName
-        : lessonInfo.video.localFileName;
-    const totalDuration = mediaDurations_1.mediaDurations[lessonInfo.languageId]?.[fullFileName] ?? 0;
-    if (totalDuration > 0) {
-        let timeFromEnd = totalDuration;
-        const applicationSections = enriched.filter((s) => s.chapter === sets_1.Chapter.APPLICATION);
-        for (const section of [...applicationSections].reverse()) {
-            timeFromEnd -= section.length;
-            section.startTime = timeFromEnd;
-            timeFromEnd -= section.pauseBefore ?? 0;
+            chunks[chunks.length - 1].verses.push(verse);
         }
     }
-    return enriched;
+    return chunks;
 }
 /**
- * Converts verse timings from chapter-relative to lesson-relative using each
- * section's `startTime` (set by {@link enrichSections}).
+ * Some lessons were built using a system that used slightly different pause
+ * values.
  */
-function normalizeVerseTimings({ enrichedSections, scripture, lessonInfo, }) {
-    const storySections = enrichedSections.filter((s) => s.chapter === sets_1.Chapter.STORY);
-    return scripture.map((passage, passageIndex) => {
-        const section = storySections[passageIndex];
-        if (!section)
-            return passage;
-        const firstTimedVerse = passage.verses.find((v) => v.timings);
-        if (!firstTimedVerse?.timings)
+const alternativeLessonPauses = {
+    beforeStory: 1,
+    afterStory: 1,
+    betweenPassages: 0.5,
+    beforeFtb: 1,
+    afterFtb: 0.5,
+};
+/**
+ * List of languages whose lessons were built using slightly different pause
+ * values.
+ */
+const usesAlternativeLessonPauses = ['tel', 'som', 'kmr', 'swz', 'vie'];
+/** Returns the correct lesson pauses for a given language. */
+function getLessonPauses(languageId) {
+    return usesAlternativeLessonPauses.includes(languageId)
+        ? alternativeLessonPauses
+        : lessonPauses_1.lessonPauses;
+}
+/**
+ * Converts verse timings within each scripture passage from chapter-relative to
+ * full-lesson relative. This includes accounting for question durations,
+ * pauses, and from-the-book durations.
+ *
+ * Multi-chapter passages are split into per-chapter chunks internally, since
+ * the audio is clipped from individual chapter files.
+ */
+function normalizeVerseTimings({ lessonInfo, scripture, }) {
+    const languageInfo = (0, languages_1.getLanguageInfo)(lessonInfo.meetLanguageId);
+    const pauses = getLessonPauses(lessonInfo.meetLanguageId);
+    let cumulativeTime = lessonInfo.fellowshipDuration + pauses.beforeStory;
+    if (specialIds_1.specialIds.introductionLessonIds.includes(lessonInfo.lessonId) &&
+        lessonInfo.type === 'dbs' &&
+        lessonInfo.introLength)
+        cumulativeTime += lessonInfo.introLength;
+    let lastBook = null;
+    /** Tracks the overall passage index (not chunk index) for FTB/pause logic. */
+    let globalChunkIndex = 0;
+    return scripture?.map((passage) => {
+        if (!passage)
+            return undefined;
+        const chunks = splitPassageIntoChunks(passage.verses);
+        if (chunks.length === 0)
             return passage;
-        const offset = section.startTime +
-            getFtbDuration(section, lessonInfo) -
-            firstTimedVerse.timings[0];
-        return {
-            ...passage,
-            verses: passage.verses.map((verse) => {
+        const adjustedVerses = [];
+        for (const chunk of chunks) {
+            const firstTimedVerse = chunk.verses.find((v) => v.timings);
+            if (!firstTimedVerse?.timings) {
+                // No timing data — pass through unadjusted
+                adjustedVerses.push(...chunk.verses);
+                if (!chunk.isPartOfPrevious)
+                    globalChunkIndex++;
+                continue;
+            }
+            const chunkAudioStart = firstTimedVerse.timings[0];
+            // Add FTB + pauses. Chunks that are continuations of a multi-chapter
+            // passage (isPartOfPrevious) get no pause — they are concatenated directly.
+            if (!chunk.isPartOfPrevious) {
+                if (lastBook !== chunk.bookId) {
+                    if (globalChunkIndex !== 0) {
+                        cumulativeTime += pauses.beforeFtb;
+                    }
+                    const ftbLanguage = languageInfo.titles ?? languageInfo.languageId;
+                    const ftbKey = `${ftbLanguage}.${chunk.bookId}.mp3`;
+                    const ftbDuration = mediaDurations_1.mediaDurations[ftbLanguage]?.[ftbKey];
+                    if (ftbDuration != null)
+                        cumulativeTime += ftbDuration;
+                    else {
+                        console.error(`FTB duration not found for ${ftbKey}`);
+                        return passage;
+                    }
+                    cumulativeTime += pauses.afterFtb;
+                    lastBook = chunk.bookId;
+                }
+                else if (globalChunkIndex !== 0) {
+                    cumulativeTime += pauses.betweenPassages;
+                }
+                globalChunkIndex++;
+            }
+            const offset = cumulativeTime - chunkAudioStart;
+            for (const verse of chunk.verses) {
                 if (!verse.timings)
-                    return verse;
-                return {
-                    ...verse,
-                    timings: [verse.timings[0] + offset, verse.timings[1] + offset],
-                };
-            }),
-        };
+                    adjustedVerses.push(verse);
+                else
+                    adjustedVerses.push({
+                        ...verse,
+                        timings: [verse.timings[0] + offset, verse.timings[1] + offset],
+                    });
+            }
+            // Advance cumulative time by this chunk's audio duration
+            const lastTimedVerse = [...chunk.verses].reverse().find((v) => v.timings);
+            if (lastTimedVerse?.timings) {
+                cumulativeTime += lastTimedVerse.timings[1] - chunkAudioStart;
+            }
+        }
+        return { ...passage, verses: adjustedVerses };
     });
 }

package/dist/functions/sets.d.ts

@@ -1,15 +1,17 @@
 import { TranslationsApp } from '../data/translationsApp/translationsApp.zod';
 import type { LanguageInfo, MeetTranslations } from '../types/languages';
-import { DbsInfo, EnrichedSection, Lesson, LessonInfo, SetInfo, VideoInfo } from '../types/sets';
-export declare function getSetInfo({ setId, languageId, setIds, t, }: {
+import { ScripturePassage } from '../types/scripturePassages';
+import { DbsInfo, Lesson, LessonInfo, SetInfo, VideoInfo } from '../types/sets';
+export declare const firebaseUrl = "https://firebasestorage.googleapis.com/v0/b/waha-app-db.appspot.com/o/";
+export declare function getSetInfo({ setId, meetLanguageId, setIds, t, }: {
     setId: string;
-    languageId: string;
+    meetLanguageId: string;
     t: MeetTranslations & TranslationsApp[string];
     setIds: string[];
 }): SetInfo | undefined;
-export declare function getLessonInfo({ lessonId, languageInfo, setInfo, t, useSpokenQuestions, }: {
+export declare function getLessonInfo({ lessonId, meetLanguageInfo, setInfo, t, useSpokenQuestions, }: {
     lessonId: Lesson['lessonId'] | undefined;
-    languageInfo: LanguageInfo;
+    meetLanguageInfo: LanguageInfo;
     setInfo?: SetInfo;
     t: MeetTranslations & TranslationsApp[string];
     useSpokenQuestions?: boolean;
@@ -18,13 +20,50 @@ export declare function convertSToString(time: number): string;
 /** Determines whether a lesson should be visible in Waha. */
 export declare function shouldShowLesson(lessonInfo: LessonInfo | undefined, languageInfo: LanguageInfo): boolean;
 /**
- * Validates that the computed lesson duration (from section lengths) matches
- * the actual audio file duration. Sections must be enriched (all have `length`)
- * via {@link enrichSections} before calling this.
- *
- * @returns The difference between the computed length and the total duration.
+ * Calculate start times for each section based on question durations and total
+ * audio duration. Must be called after audio is loaded to get accurate total
+ * duration.
+ */
+export declare function calculateSectionTimings({ languageInfo, thisLesson, totalDuration, normalizedScripture, supportsVerseHighlight, }: {
+    thisLesson: DbsInfo | VideoInfo;
+    totalDuration: number;
+    languageInfo: LanguageInfo;
+    normalizedScripture: Array<ScripturePassage | undefined>;
+    /**
+     * Determine if the timings are valid to be used for section timings.
+     *
+     * Supports verse highlight example:
+     *
+     * - GEN.1.1-GEN.1.10 -> 83
+     * - GEN.2.1-GEN.2.4 -> 100
+     * - GEN.2.7-GEN.2.10 -> 120
+     *
+     * Doesn't support verse highlight example:
+     *
+     * - GEN.1.1-GEN.1.10 -> 83
+     * - GEN.2.1-GEN.2.4 -> undefined
+     * - GEN.2.7-GEN.2.10 -> undefined
+     *
+     * First passage is always valid because its start time is simply the length
+     * of the previous audio. Subsequent passages require good verse timing data.
+     */
+    supportsVerseHighlight: boolean;
+}): Map<string, number>;
+/**
+ * Checks if pre-normalized verse timings for given scripture are valid. Does
+ * this by comparing the real duration of the full lesson mp3 file with the
+ * calculated duration based on individual question durations and verse timing
+ * data from bible chapter documents. For lessons generated programmatically
+ * with recent systems, they should be nearly identical. For older lessons that
+ * were made by hand, they may be off. If they're too off, they will be flagged
+ * as invalid and the lesson will default to not using verse timings.
  */
-export declare function getExpectedLessonDuration({ enrichedSections, lessonInfo, }: {
-    enrichedSections: EnrichedSection[];
+export declare function getSupportsVerseHighlight({ lessonInfo, scripture, totalDuration, }: {
     lessonInfo: DbsInfo | VideoInfo;
-}): number;
+    scripture: Array<ScripturePassage | undefined>;
+    totalDuration: number | undefined;
+}): {
+    computedLength: number;
+    diff: number;
+    passed: boolean;
+};