Treat verse 0 as an ordinary verse; remove liveScrRef stickiness guard

A chapter's pre-verse-1 superscription is a real, focusable verse-0
segment,
but `liveScrRef` held a stickiness guard that swallowed any same-chapter
`verseNum: 0` reference naming the verse already shown. That guard was
added
(b9dec18, "fix verse-0 echo nav") before verse 0 was a parsed verse, to
absorb
the host's spurious post-verse-nav chapter echo. It could not
distinguish that
echo from a genuine external `<` (previous-verse) from verse 1 — both
are
same-chapter, verse 0, and markerless on the global selector path — so
it also
ate the intentional `<`, leaving the extension stuck on verse 1 instead
of
moving to the superscription.

Verified in a live session (probe logging liveScrRef/rawScrRef) that the
host
no longer emits the spurious echo: exactly one delivery per navigation,
never
an unsolicited trailing verse 0. With the echo gone the guard defended
against
nothing, so remove it. Verse 0 now passes through verbatim; the host's
`<` from
verse 1 lands on the chapter's superscription (the loader resolves verse
0 to
the superscription segment, else to verse 1).

The internal-nav marker machinery is retained — it still classifies
internal/external navigations for the recenter fade. Only its former
role
inside the verse-0 guard is gone.

Tests: collapse the two sticky-behavior tests into one pass-through
regression
test; flip the mid-reveal fade test to expect the curtain to re-engage
for a
verse-0 navigation arriving during fade-in (verse 0 is now an ordinary
mid-reveal move).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: alex-rawlings-yyc

src/__tests__/components/InterlinearNavContext.test.tsx

@@ -84,35 +84,17 @@ describe('InterlinearNavContext', () => {
     expect(result.current.rawScrRef).toEqual(ref);
   });
 
-  it('keeps the current verse when the host echoes a verse-0 reference for the chapter already shown', () => {
-    // After a verse navigation the host re-broadcasts the chapter as a separate verse-0 reference.
-    // Normalizing that to verse 1 would read as a fresh move off the verse the user is on, so a
-    // verse-0 echo for the same book+chapter must stay sticky on the current verse.
+  it('passes a same-chapter verse-0 reference through to liveScrRef (host < from verse 1)', () => {
+    // Verse 0 is a real, focusable verse (a chapter superscription), so a verse-0 reference for the
+    // chapter already shown passes through verbatim rather than being held on the current verse. This
+    // is the host's `<` (previous-verse) from verse 1: it must land on the superscription, which the
+    // loader resolves from verse 0 (or back to verse 1 when the chapter has no verse-0 segment).
     const { result, setRef, rerender } = renderNavMutable({
       book: 'GEN',
       chapterNum: 3,
-      verseNum: 7,
+      verseNum: 1,
     });
-    expect(result.current.liveScrRef).toEqual({ book: 'GEN', chapterNum: 3, verseNum: 7 });
-
-    act(() => setRef({ book: 'GEN', chapterNum: 3, verseNum: 0 }));
-    rerender();
-
-    expect(result.current.liveScrRef).toEqual({ book: 'GEN', chapterNum: 3, verseNum: 7 });
-  });
-
-  it('passes a same-chapter verse-0 echo through when it matches a fresh internal-nav marker', () => {
-    // Selecting a verse-0 superscription navigates the host to verse 0 of the chapter already shown,
-    // so the host's echo is shaped exactly like the spurious post-nav chapter echo. A fresh
-    // internal-nav marker for that verse-0 key marks it as our own deliberate move, so the stickiness
-    // exception lets it through to the superscription rather than holding the prior verse.
-    const { result, setRef, rerender } = renderNavMutable({
-      book: 'GEN',
-      chapterNum: 3,
-      verseNum: 7,
-    });
-
-    act(() => result.current.navigate({ book: 'GEN', chapterNum: 3, verseNum: 0 }, 'internal'));
+    expect(result.current.liveScrRef).toEqual({ book: 'GEN', chapterNum: 3, verseNum: 1 });
 
     act(() => setRef({ book: 'GEN', chapterNum: 3, verseNum: 0 }));
     rerender();
@@ -542,9 +524,11 @@ describe('InterlinearNavContext', () => {
       expect(result.current.fadePhase).toBe('out');
     });
 
-    it('does not re-engage the curtain for a verse-0 echo during the fade-in', () => {
-      // The host's chapter re-broadcast (verse 0 for the chapter already shown) is sticky — it
-      // names the verse currently displayed, so it must not read as a fresh navigation mid-reveal.
+    it('re-engages the curtain for a verse-0 navigation arriving during the fade-in', () => {
+      // Verse 0 is an ordinary verse (a chapter superscription), so a verse-0 reference naming a
+      // different verse than the one shown is a real mid-reveal navigation — e.g. the host's `<` from
+      // verse 1 landing on the superscription. It re-engages the curtain like any other external move
+      // arriving while the new book is still fading in, rather than fading the fresh content twice.
       const { result, rerender, setRef } = renderNavMutable({
         book: 'GEN',
         chapterNum: 1,
@@ -559,7 +543,7 @@ describe('InterlinearNavContext', () => {
       act(() => setRef({ book: 'ZEP', chapterNum: 3, verseNum: 0 }));
       rerender();
 
-      expect(result.current.fadePhase).toBe('in');
+      expect(result.current.fadePhase).toBe('out');
     });
 
     it('clears the pending fade-in timer on unmount', () => {

src/__tests__/components/Interlinearizer.test.tsx

@@ -535,8 +535,8 @@ describe('Interlinearizer', () => {
 
   it('writes a verse-0 reference to the host when a verse-0 token is selected', () => {
     // Selecting a superscription token navigates the host to verse 0 like any other verse; the
-    // internal-nav marker keeps the host's chapter echo from bouncing the view (the stickiness
-    // exception in InterlinearNavContext). Default scrRef is GEN 1:1, so this is a real verse change.
+    // 'internal' origin records a nav marker so the segment window skips the recenter fade for our
+    // own move. Default scrRef is GEN 1:1, so this is a real verse change.
     const mockNavigate = jest.fn();
     renderInterlinearizer({ book: GEN_SUPERSCRIPTION_BOOK, navigate: mockNavigate });
 

src/components/InterlinearNavContext.tsx

@@ -113,20 +113,14 @@ export interface InterlinearNav {
    */
   rawScrRef: SerializedVerseRef;
   /**
-   * The active reference, equal to `rawScrRef` except that a verse-0 reference naming the chapter
-   * already shown is held sticky on the current verse — unless it matches a fresh internal-nav
-   * marker (the extension's own move to that chapter's superscription), which passes through. A
-   * verse-0 reference is otherwise passed through verbatim: when it names a chapter with a verse-0
-   * superscription segment, that segment becomes the active verse. Whether a given chapter actually
-   * has verse-0 content is unknown here (the book is not loaded at this layer), so the loader
-   * resolves a verse-0 reference with no matching segment back to the chapter's first numbered
-   * verse before rendering.
-   *
-   * The sticky exception exists because, after a verse navigation, the host re-broadcasts the
-   * chapter as a separate `verseNum: 0` reference (an echo of the current location, not a real
-   * move); treating that as a jump to verse 0 would yank the view off the verse the user is on. The
-   * marker carve-out distinguishes that spurious echo from a deliberate verse-0 navigation the
-   * extension itself just made (which is shaped identically).
+   * The active reference. Equal to `rawScrRef`, with object identity reused across the host's
+   * value-equal duplicate deliveries so a re-send reads as no change. Verse 0 is treated as an
+   * ordinary verse: a `verseNum: 0` reference passes through verbatim, so the host's `<`
+   * (previous-verse) from verse 1 lands on the chapter's superscription. When it names a chapter
+   * with a verse-0 superscription segment, that segment becomes the active verse. Whether a given
+   * chapter actually has verse-0 content is unknown here (the book is not loaded at this layer), so
+   * the loader resolves a verse-0 reference with no matching segment back to the chapter's first
+   * numbered verse before rendering.
    */
   liveScrRef: SerializedVerseRef;
   /**
@@ -226,8 +220,10 @@ export function InterlinearNavProvider({
   stableRawScrRefRef.current = rawScrRef;
 
   /**
-   * The last committed {@link liveScrRef}, mirrored so the verse-0 stickiness below can compare the
-   * incoming `rawScrRef` against the verse currently shown.
+   * The last committed {@link liveScrRef}, mirrored so the duplicate-delivery guard below can reuse
+   * the previously committed object identity when the host re-sends a value-equal reference, and so
+   * the render-phase mid-reveal guard can compare the incoming reference against the verse last
+   * shown.
    */
   const liveScrRefRef = useRef<SerializedVerseRef>(rawScrRef);
 
@@ -236,40 +232,21 @@ export function InterlinearNavProvider({
    * `Date.now()` stamp. `navigate(ref, 'internal')` records `verseKey(ref)`; `consumeInternalNav`
    * removes it on match. Keyed (not a single value) so that rapid successive clicks both stay
    * pending and neither host delivery is misread as external. The stamp gives each marker a TTL
-   * ({@link INTERNAL_NAV_TTL_MS} — see its doc for why stranded markers must expire), honored by ALL
-   * readers: `consumeInternalNav` (which also evicts expired markers), the verse-0 stickiness
-   * exception below, and the render-phase mid-reveal guard (both pure reads — no eviction during
-   * render).
+   * ({@link INTERNAL_NAV_TTL_MS} — see its doc for why stranded markers must expire), honored by
+   * both readers: `consumeInternalNav` (which also evicts expired markers) and the render-phase
+   * mid-reveal guard (a pure read — no eviction during render).
    */
   const pendingInternalNavRef = useRef<Map<string, number>>(new Map());
 
-  // After a verse navigation the host re-broadcasts the *chapter* to the scroll group as a separate
-  // `verseNum: 0` reference (an echo of the current location, not a real move). Treating that as a
-  // jump to verse 0 would yank the views off the verse the user is actually on, so a verse-0
-  // reference that names the book+chapter already shown is held sticky: keep the current `liveScrRef`
-  // (its real verse).
-  //
-  // The exception is a verse-0 reference the extension itself just navigated to — selecting a
-  // chapter's verse-0 superscription segment writes `verseNum: 0` for the chapter already shown,
-  // which is shaped exactly like the spurious echo. A fresh internal-nav marker for that verse-0 key
-  // distinguishes the two: when one exists, this is our own deliberate move to the superscription, so
-  // it passes through (and `consumeInternalNav` clears the marker downstream). A pure read here — no
-  // eviction during render, matching the render-phase mid-reveal guard.
-  //
-  // Every other reference — including a verse-0 reference for a *different* chapter (a genuine chapter
-  // jump, which the loader resolves to the verse-0 superscription when one exists, else to verse 1) —
-  // passes through verbatim. The duplicate-delivery guard reuses the previously committed object when
-  // a re-send is value-equal, so a duplicate never reads as a fresh navigation.
+  // Verse 0 is a real, focusable verse (a chapter's pre-verse-1 superscription content; see
+  // `usjBookExtractor`), so a `verseNum: 0` reference is passed through verbatim like any other verse
+  // — including the host's `<` (previous-verse) from verse 1, which lands on the chapter's
+  // superscription. When the chapter has no verse-0 segment, the loader resolves verse 0 to the
+  // chapter's first numbered verse before rendering. The duplicate-delivery guard reuses the
+  // previously committed object when a re-send is value-equal, so a duplicate never reads as a fresh
+  // navigation.
   const liveScrRef = useMemo(() => {
     const prev = liveScrRefRef.current;
-    if (
-      rawScrRef.verseNum === 0 &&
-      rawScrRef.book === prev.book &&
-      rawScrRef.chapterNum === prev.chapterNum &&
-      !isInternalNavMarkerFresh(pendingInternalNavRef.current.get(verseKey(rawScrRef)))
-    ) {
-      return prev;
-    }
     return areScrRefsEqual(rawScrRef, prev) ? prev : rawScrRef;
   }, [rawScrRef]);
   /**

src/components/Interlinearizer.tsx

@@ -212,9 +212,9 @@ function InterlinearizerInner({
    * reference. (The loader's `viewScrRef` freeze normally keeps the two in sync, so this guards a
    * transient.)
    *
-   * A verse-0 segment (a chapter superscription) navigates like any other: the write records an
-   * internal-nav marker so the host's chapter echo is recognized as our own move rather than
-   * bouncing the view back. (See the verse-0 stickiness exception in `InterlinearNavContext`.)
+   * A verse-0 segment (a chapter superscription) navigates like any other verse: the `'internal'`
+   * origin records a nav marker so the segment window recognizes the host's echo as our own move
+   * and skips the recenter fade (the target is already on screen).
    *
    * @param tokenRef - The word-token ref to focus.
    */
@@ -237,8 +237,8 @@ function InterlinearizerInner({
    * Updates the active scripture reference (when the verse actually changed) and, when a specific
    * token was clicked, focuses that token. Skips the write to PAPI when the clicked verse matches
    * the current one, avoiding a gratuitous echo round-trip. A verse-0 segment (a chapter
-   * superscription) writes like any other verse — the internal-nav marker keeps the host's chapter
-   * echo from bouncing the view (see the verse-0 stickiness exception in `InterlinearNavContext`).
+   * superscription) writes like any other verse — the `'internal'` origin records a nav marker so
+   * the segment window skips the recenter fade for our own move.
    *
    * @param ref - The verse coordinate that was selected.
    * @param tokenRef - The token that was clicked; omitted when the whole segment was selected.