teams-transcripts 0.5.0__py3-none-any.whl

teams_transcripts/services/extraction.py

@@ -0,0 +1,1603 @@
+"""Transcript extraction services.
+
+Functions that extract transcript data, roster members, and chat messages
+from the Teams browser UI via the :class:`~teams_transcripts.ports.browser.BrowserPort`.
+
+Each function takes a connected browser and manages its own connect/disconnect
+lifecycle.  Return values are strings or domain objects -- no file I/O is
+performed here.
+
+Extracted from ``transcript_download.py`` lines 2001--3240.
+
+Schema version: 1.0.0
+Created: 2026-04-25
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import typing
+from collections import Counter
+from datetime import datetime, timedelta
+
+from teams_transcripts.domain.html import strip_html_to_text
+from teams_transcripts.domain.models import ChatMessage, Reaction, RosterMember
+from teams_transcripts.domain.speakers import resolve_chat_author
+from teams_transcripts.domain.timestamps import (
+    parse_meeting_times,
+    sec_to_vtt_float,
+    sec_to_vtt_int,
+    ts_to_sec,
+    utc_to_local_iso,
+)
+from teams_transcripts.domain.vtt import generate_vtt_from_segments
+
+if typing.TYPE_CHECKING:
+    from teams_transcripts.infrastructure.logging import Logger
+    from teams_transcripts.infrastructure.signals import ShutdownCoordinator
+    from teams_transcripts.ports.browser import BrowserPort
+
+
+# ---------------------------------------------------------------------------
+# Step 7: Permission check
+# ---------------------------------------------------------------------------
+
+
+async def check_permission(
+    browser: BrowserPort,
+    target_id: str,
+    logger: Logger,
+    shutdown: ShutdownCoordinator,
+) -> str:
+    """Check the Download button state in the transcript iframe.
+
+    Args:
+        browser: Browser port (manages its own connection).
+        target_id: CDP target ID for the transcript iframe.
+        logger: Logger instance.
+        shutdown: Shutdown coordinator.
+
+    Returns:
+        ``"has_permission"``, ``"no_permission"``, or ``"no_button"``.
+    """
+    await browser.connect(target_id)
+    try:
+        max_attempts = 10
+        for attempt in range(max_attempts):
+            shutdown.check_shutdown()
+            result_json = await browser.evaluate("""
+                (function() {
+                    var btn = document.querySelector('button[aria-haspopup="true"]');
+                    if (!btn) return JSON.stringify({state: "no_button"});
+                    var text = btn.textContent || "";
+                    if (text.indexOf("permission") !== -1)
+                        return JSON.stringify({
+                            state: "no_permission",
+                            message: text.trim().substring(0, 100)
+                        });
+                    return JSON.stringify({state: "has_permission"});
+                })()
+            """)
+            if result_json:
+                result = json.loads(str(result_json))
+                logger.log("step7", f"Permission state: {result['state']}")
+                if result.get("message"):
+                    logger.log("step7", f"Message: {result['message']}")
+                if result["state"] == "no_button":
+                    if attempt < max_attempts - 1:
+                        logger.log(
+                            "step7",
+                            f"Attempt {attempt + 1}/{max_attempts} -- waiting for button...",
+                        )
+                        await shutdown.interruptible_sleep(2)
+                        continue
+                    return "no_button"
+                return result["state"]
+            logger.log("step7", f"Attempt {attempt + 1}/{max_attempts} -- waiting for button...")
+            await shutdown.interruptible_sleep(2)
+    finally:
+        await browser.disconnect()
+
+    return "no_button"
+
+
+# ---------------------------------------------------------------------------
+# Step 7A: Native VTT download (blob interception)
+# ---------------------------------------------------------------------------
+
+
+async def download_native_vtt(
+    browser: BrowserPort,
+    target_id: str,
+    logger: Logger,
+    shutdown: ShutdownCoordinator,
+) -> str | None:
+    """Download the transcript via blob interception (Approach A).
+
+    Monkey-patches ``URL.createObjectURL`` to capture VTT blob content,
+    then triggers the download via the UI menu.
+
+    Args:
+        browser: Browser port.
+        target_id: CDP target ID for the transcript iframe.
+        logger: Logger instance.
+        shutdown: Shutdown coordinator.
+
+    Returns:
+        VTT content as a string, or ``None`` if capture failed.
+    """
+    await browser.connect(target_id)
+    try:
+        # 1. Install blob interceptor
+        patch_result = await browser.evaluate("""
+            (function() {
+                window.__capturedVTT = null;
+                if (!window.__teamsTranscriptOrigCreateObjectURL) {
+                    window.__teamsTranscriptOrigCreateObjectURL = URL.createObjectURL;
+                }
+                URL.createObjectURL = function(blob) {
+                    if (blob instanceof Blob) {
+                        blob.text().then(function(text) {
+                            if (text.indexOf('WEBVTT') !== -1) {
+                                window.__capturedVTT = text;
+                            }
+                        });
+                    }
+                    return window.__teamsTranscriptOrigCreateObjectURL.call(URL, blob);
+                };
+                return 'interceptor installed';
+            })()
+        """)
+        logger.log("step7a", f"Blob interceptor: {patch_result}")
+
+        # 2. Open the Download dropdown menu
+        menu_result_json = await browser.evaluate("""
+            (function() {
+                var btn = document.querySelector('button[aria-haspopup="true"]');
+                if (!btn) return JSON.stringify({error: 'Download button not found'});
+                if (btn.getAttribute('aria-expanded') !== 'true') btn.click();
+                return JSON.stringify({ok: true});
+            })()
+        """)
+        menu_result = json.loads(str(menu_result_json))
+        if menu_result.get("error"):
+            logger.log("step7a", f"Error: {menu_result['error']}")
+            return None
+        logger.log("step7a", "Download menu opened")
+
+        # 3. Wait for menu to render
+        await shutdown.interruptible_sleep(1)
+
+        # 4. Click "Download as .vtt"
+        click_result_json = await browser.evaluate("""
+            (function() {
+                var vttBtn = document.querySelector(
+                    'button[aria-label="Download as .vtt"]'
+                );
+                if (!vttBtn) {
+                    var allBtns = Array.from(
+                        document.querySelectorAll('button[role="menuitem"]')
+                    );
+                    vttBtn = allBtns.find(function(b) {
+                        return b.textContent && b.textContent.indexOf('.vtt') !== -1;
+                    });
+                }
+                if (!vttBtn) return JSON.stringify({error: 'VTT menu item not found'});
+                vttBtn.click();
+                return JSON.stringify({ok: true});
+            })()
+        """)
+        click_result = json.loads(str(click_result_json))
+        if click_result.get("error"):
+            logger.log("step7a", f"Error: {click_result['error']}")
+            return None
+        logger.log("step7a", "Clicked 'Download as .vtt'")
+
+        # 5. Wait for the blob to be captured
+        logger.log("step7a", "Waiting for VTT blob capture...")
+        await shutdown.interruptible_sleep(3)
+
+        # 6. Check if the VTT was captured
+        status_json = await browser.evaluate("""
+            (function() {
+                if (window.__capturedVTT) {
+                    return JSON.stringify({
+                        captured: true,
+                        length: window.__capturedVTT.length
+                    });
+                }
+                return JSON.stringify({captured: false});
+            })()
+        """)
+        status = json.loads(str(status_json))
+
+        if not status.get("captured"):
+            logger.log("step7a", "VTT blob was not captured.")
+            return None
+
+        length = status["length"]
+        logger.log("step7a", f"Captured {length} chars of VTT content")
+
+        # 7. Retrieve content in chunks (large transcripts may exceed
+        #    the single-expression return limit)
+        chunks = []
+        chunk_size = 50000
+        for offset in range(0, length, chunk_size):
+            chunk = await browser.evaluate(
+                f"window.__capturedVTT.substring({offset}, {offset + chunk_size})"
+            )
+            chunks.append(chunk)
+
+        return "".join(chunks)
+    finally:
+        await browser.evaluate("""
+            (function() {
+                if (window.__teamsTranscriptOrigCreateObjectURL) {
+                    URL.createObjectURL = window.__teamsTranscriptOrigCreateObjectURL;
+                    delete window.__teamsTranscriptOrigCreateObjectURL;
+                }
+                return 'interceptor restored';
+            })()
+        """)
+        await browser.disconnect()
+
+
+# ---------------------------------------------------------------------------
+# Step 7B (React props): Approach A fallback
+# ---------------------------------------------------------------------------
+
+
+async def extract_via_react_props(
+    browser: BrowserPort,
+    target_id: str,
+    logger: Logger,
+    speaker_map: dict[str, str] | None = None,
+) -> str | None:
+    """Extract transcript data from the React fibre tree (Approach A variant).
+
+    The TranscriptList component holds all entries in its ``entries``
+    prop, bypassing the virtualised list renderer entirely.
+
+    Args:
+        browser: Browser port.
+        target_id: CDP target ID for the transcript iframe.
+        logger: Logger instance.
+        speaker_map: Optional GUID-to-display-name mapping for speaker
+            name resolution.
+
+    Returns:
+        VTT content as a string, ``None`` if the React props are not
+        accessible (caller should fall back to DOM scrolling).
+    """
+    await browser.connect(target_id)
+    try:
+        entries_json = await browser.evaluate(r"""
+            (function() {
+                var el = document.querySelector('[role="list"]');
+                if (!el) return JSON.stringify({error: 'no list element'});
+                var fiberKey = Object.keys(el).find(function(k) {
+                    return k.startsWith('__reactFiber$');
+                });
+                if (!fiberKey) return JSON.stringify({error: 'no fiber key'});
+
+                var current = el[fiberKey];
+                var depth = 0;
+                var entries = null;
+                while (current && depth < 25) {
+                    var props = current.memoizedProps || {};
+                    if (props.entries && Array.isArray(props.entries)
+                        && props.entries.length > 0) {
+                        entries = props.entries;
+                        break;
+                    }
+                    current = current.return;
+                    depth++;
+                }
+                if (!entries)
+                    return JSON.stringify({error: 'entries not found'});
+
+                function parseDur(d) {
+                    if (!d) return null;
+                    var m = d.match(/PT(?:(\d+)H)?(?:(\d+)M)?(?:([\d.]+)S)?/);
+                    if (!m) return null;
+                    return (parseInt(m[1]||0)*3600)
+                         + (parseInt(m[2]||0)*60)
+                         + parseFloat(m[3]||0);
+                }
+
+                var result = [];
+                for (var i = 0; i < entries.length; i++) {
+                    var e = entries[i];
+                    if (e.type !== 'Text') continue;
+                    var ts = parseDur(e.timestamp);
+                    result.push({
+                        speaker: e.speakerDisplayName || 'Unknown',
+                        speakerId: e.speakerId || '',
+                        ts: ts,
+                        text: e.text || ''
+                    });
+                }
+                return JSON.stringify({ok: true, items: result});
+            })()
+        """)
+    finally:
+        await browser.disconnect()
+
+    data = json.loads(str(entries_json))
+
+    if data.get("error"):
+        logger.log("step7b", f"React props extraction failed: {data['error']}")
+        return None
+
+    items = data["items"]
+    if not items:
+        logger.log("step7b", "React props returned 0 text entries.")
+        return None
+
+    logger.log("step7b", f"React props: extracted {len(items)} text entries")
+
+    # Resolve speaker names using the Recap Speakers mapping.
+    if speaker_map:
+        resolved_pairs: dict[str, str] = {}
+        for item in items:
+            sid = item.get("speakerId", "")
+            guid = sid.split("@")[0] if "@" in sid else sid
+            if guid not in speaker_map:
+                continue
+            recap_name = speaker_map[guid]
+            transcript_name = item["speaker"]
+            if recap_name == transcript_name:
+                continue
+            item["speaker"] = recap_name
+            resolved_pairs[transcript_name] = recap_name
+        if resolved_pairs:
+            for old, new in resolved_pairs.items():
+                logger.log("step7b", f"  Resolved speaker: {old!r} -> {new!r}")
+            total = sum(1 for it in items if it["speaker"] in resolved_pairs.values())
+            logger.log(
+                "step7b",
+                f"Resolved {len(resolved_pairs)} speaker name(s) ({total} entries affected)",
+            )
+
+    # Filter out meta entries
+    segments = []
+    for item in items:
+        text = item["text"]
+        if "started transcription" in text or "stopped transcription" in text:
+            continue
+        segments.append(item)
+
+    # Generate VTT using float timestamps (Approach A)
+    vtt = ["WEBVTT", ""]
+    for i, seg in enumerate(segments):
+        ss = seg["ts"] if seg["ts"] is not None else 0
+        es = segments[i + 1]["ts"] if i + 1 < len(segments) else ss + 10
+        if es is None or es <= ss:
+            es = ss + 10
+        vtt.extend(
+            [
+                str(i + 1),
+                f"{sec_to_vtt_float(ss)} --> {sec_to_vtt_float(es)}",
+                f"<v {seg['speaker']}>{seg['text']}</v>",
+                "",
+            ]
+        )
+
+    content = "\n".join(vtt)
+
+    logger.log("step7b", f"Generated {len(content)} bytes, {len(segments)} segments")
+    logger.log("step7b", "Speakers:")
+    for sp, cnt in Counter(s["speaker"] for s in segments).most_common():
+        logger.log("step7b", f"  {sp}: {cnt}")
+
+    return content
+
+
+# ---------------------------------------------------------------------------
+# Step 7B (DOM scrolling): Approach B
+# ---------------------------------------------------------------------------
+
+
+async def extract_dom_vtt(
+    browser: BrowserPort,
+    target_id: str,
+    logger: Logger,
+) -> str | None:
+    """Extract transcript from the DOM via scrolling (Approach B).
+
+    Scrolls through the virtualised transcript list, collecting all header
+    and sub-entry elements.  Applies forward-fill, backfill, and
+    discontinuity detection before generating VTT.
+
+    Args:
+        browser: Browser port.
+        target_id: CDP target ID for the transcript iframe.
+        logger: Logger instance.
+
+    Returns:
+        VTT content as a string, or ``None`` on failure.
+    """
+    headers: dict[int, dict] = {}
+    texts: dict[int, dict] = {}
+    header_to_texts: dict[int, set[int]] = {}
+    orphaned_texts: list[int] = []
+
+    await browser.connect(target_id)
+    try:
+        # Scroll to top
+        await browser.evaluate("""
+            (function() {
+                var el = document.querySelector('[role="list"]');
+                var p = el;
+                while (p && p.scrollHeight <= p.clientHeight) p = p.parentElement;
+                if (p) p.scrollTop = 0;
+            })()
+        """)
+        await _async_sleep(0.5)
+
+        # Scroll through virtualised list, extracting entries
+        consecutive_empty = 0
+        for scroll_pass in range(200):
+            items_json = await browser.evaluate("""
+                (function() {
+                    var items = Array.from(
+                        document.querySelectorAll('[role="listitem"]')
+                    );
+                    var result = [];
+                    var currentHeaderNum = null;
+                    for (var i = 0; i < items.length; i++) {
+                        var id = items[i].id || '';
+                        var num = parseInt(id.replace(/[^0-9]/g, ''));
+                        if (id.startsWith('itemHeader')) {
+                            currentHeaderNum = num;
+                            result.push({
+                                type: 'h', n: num,
+                                s: items[i].querySelector(
+                                    '[class*="itemDisplayName"]'
+                                )?.textContent?.trim(),
+                                t: items[i].querySelector(
+                                    '[class*="baseTimestamp"] span[aria-hidden]'
+                                )?.textContent?.trim()
+                            });
+                        } else if (id.startsWith('sub-entry')) {
+                            result.push({
+                                type: 'e', n: num, hn: currentHeaderNum,
+                                x: items[i].textContent?.trim()
+                            });
+                        }
+                    }
+                    if (items.length > 0) {
+                        items[items.length - 1].scrollIntoView(
+                            {behavior: 'instant', block: 'center'}
+                        );
+                    }
+                    return JSON.stringify(result);
+                })()
+            """)
+            items = json.loads(str(items_json))
+
+            new_count = 0
+            for item in items:
+                if item["type"] == "h" and item["n"] not in headers:
+                    headers[item["n"]] = {
+                        "speaker": item["s"],
+                        "timestamp": item["t"],
+                    }
+                    new_count += 1
+                elif item["type"] == "e" and item["n"] not in texts:
+                    texts[item["n"]] = {
+                        "text": item["x"],
+                        "headerNum": item.get("hn"),
+                    }
+                    new_count += 1
+                    hn = item.get("hn")
+                    if hn is None:
+                        orphaned_texts.append(item["n"])
+                    else:
+                        if hn not in header_to_texts:
+                            header_to_texts[hn] = set()
+                        header_to_texts[hn].add(item["n"])
+
+            if scroll_pass % 10 == 0:
+                logger.log(
+                    "step7b",
+                    f"Pass {scroll_pass}: +{new_count} | headers={len(headers)} texts={len(texts)}",
+                )
+
+            if new_count == 0:
+                consecutive_empty += 1
+            else:
+                consecutive_empty = 0
+
+            if consecutive_empty >= 3 and scroll_pass >= 3:
+                logger.log("step7b", f"Extraction complete at pass {scroll_pass}")
+                break
+
+            await _async_sleep(0.25)
+    finally:
+        await browser.disconnect()
+
+    # Sort text lists per header
+    sorted_header_texts: dict[int, list[int]] = {hn: sorted(s) for hn, s in header_to_texts.items()}
+
+    if orphaned_texts:
+        logger.log(
+            "step7b",
+            f"WARNING: {len(orphaned_texts)} sub-entries had no header "
+            f"in view: {orphaned_texts[:5]}...",
+        )
+
+    # Build ordered segments
+    segments: list[dict] = []
+    null_ts_count = 0
+    for hn in sorted(sorted_header_texts.keys()):
+        h = headers.get(hn, {})
+        ts_raw = h.get("timestamp")
+        ts_sec = ts_to_sec(ts_raw) if ts_raw else None
+        if ts_sec is None:
+            null_ts_count += 1
+        for tn in sorted_header_texts[hn]:
+            t = texts.get(tn, {})
+            text = t.get("text", "")
+            if "started transcription" in text or "stopped transcription" in text:
+                continue
+            segments.append(
+                {
+                    "speaker": h.get("speaker", "Unknown"),
+                    "ts_sec": ts_sec,
+                    "text": text,
+                }
+            )
+
+    if null_ts_count > 0:
+        logger.log(
+            "step7b",
+            f"WARNING: {null_ts_count} headers had null/empty timestamps.",
+        )
+
+    # Forward-fill null timestamps
+    last_good = None
+    for seg in segments:
+        if seg["ts_sec"] is not None:
+            last_good = seg["ts_sec"]
+        elif last_good is not None:
+            seg["ts_sec"] = last_good + 10
+            last_good = seg["ts_sec"]
+
+    # Backfill remaining nulls
+    next_good = None
+    for seg in reversed(segments):
+        if seg["ts_sec"] is not None:
+            next_good = seg["ts_sec"]
+        elif next_good is not None:
+            seg["ts_sec"] = max(0, next_good - 10)
+            next_good = seg["ts_sec"]
+
+    # Final fallback
+    for seg in segments:
+        if seg["ts_sec"] is None:
+            seg["ts_sec"] = 0
+
+    # Detect timestamp discontinuities
+    if len(segments) > 2:
+        running_max = 0
+        cut_at = None
+        for i, seg in enumerate(segments):
+            ts = seg["ts_sec"]
+            if i > 0 and ts is not None and running_max > 0:
+                gap = ts - running_max
+                if gap > 600 and ts > running_max * 2:
+                    logger.log(
+                        "step7b",
+                        f"WARNING: Timestamp discontinuity at segment {i}: "
+                        f"{sec_to_vtt_int(running_max)} -> {sec_to_vtt_int(ts)} "
+                        f"(gap {gap:.0f}s). Truncating "
+                        f"{len(segments) - i} segment(s).",
+                    )
+                    cut_at = i
+                    break
+            if ts is not None and ts > running_max:
+                running_max = ts
+        if cut_at is not None:
+            segments = segments[:cut_at]
+
+    # Generate VTT using integer timestamps (Approach B)
+    content = generate_vtt_from_segments(segments)
+
+    logger.log("step7b", f"Generated {len(content)} bytes, {len(segments)} segments")
+    logger.log("step7b", "Speakers:")
+    for sp, cnt in Counter(s["speaker"] for s in segments).most_common():
+        logger.log("step7b", f"  {sp}: {cnt}")
+
+    return content
+
+
+# ---------------------------------------------------------------------------
+# Multi-part support
+# ---------------------------------------------------------------------------
+
+
+async def detect_part_tabs(
+    browser: BrowserPort,
+    target_id: str,
+) -> int:
+    """Detect Part N tabs in the Recap view.
+
+    Args:
+        browser: Browser port.
+        target_id: CDP target ID for the main Teams target.
+
+    Returns:
+        Number of parts (1 if no Part tabs are present).
+    """
+    await browser.connect(target_id)
+    try:
+        count_json = await browser.evaluate(r"""
+            (function() {
+                var tabs = Array.from(document.querySelectorAll('[role="tab"]'));
+                var parts = tabs.filter(function(t) {
+                    return /^Part\s*\d/i.test(t.textContent.trim());
+                });
+                return JSON.stringify({count: parts.length});
+            })()
+        """)
+    finally:
+        await browser.disconnect()
+    data = json.loads(str(count_json))
+    return max(1, data.get("count", 0))
+
+
+async def click_part_and_transcript(
+    browser: BrowserPort,
+    target_id: str,
+    part_number: int,
+    logger: Logger,
+    shutdown: ShutdownCoordinator,
+) -> bool:
+    """Navigate to Part N's Transcript via a full Recap re-entry.
+
+    Teams only creates the xplatplugins iframe when the Transcript tab
+    is first activated within a Recap session.  Switching parts via tab
+    clicks (Part 2 → Transcript) does NOT create a new iframe -- the
+    old one is destroyed but no replacement appears.
+
+    To force iframe creation for Part 2+, this function:
+
+    1. Exits Recap by clicking the "Chat" tab.
+    2. Re-enters Recap by clicking the "Recap" tab.
+    3. Waits for Recap content to load.
+    4. Clicks the Part N tab.
+    5. Clicks the Transcript sub-tab.
+
+    This triggers a fresh Recap session and reliable iframe creation.
+
+    Args:
+        browser: Browser port.
+        target_id: CDP target ID for the main Teams target.
+        part_number: 1-based part number.
+        logger: Logger instance.
+        shutdown: Shutdown coordinator.
+
+    Returns:
+        ``True`` if navigation succeeded.
+    """
+    await browser.connect(target_id)
+    try:
+        # Step 1: Exit Recap by clicking the Chat tab.
+        chat_result = await browser.evaluate("""
+            (function() {
+                var tabs = Array.from(document.querySelectorAll('[role="tab"]'));
+                var chatTab = tabs.find(function(t) {
+                    return t.textContent.trim() === 'Chat';
+                });
+                if (!chatTab) return 'no_chat_tab';
+                chatTab.click();
+                return 'clicked_chat';
+            })()
+        """)
+        logger.log("multi-part", f"Exit Recap (Chat tab): {chat_result}")
+
+        await shutdown.interruptible_sleep(2)
+
+        # Step 2: Re-enter Recap.
+        recap_result = await browser.evaluate("""
+            (function() {
+                var tabs = Array.from(document.querySelectorAll('[role="tab"]'));
+                var recapTab = tabs.find(function(t) {
+                    return t.textContent.indexOf('Recap') !== -1;
+                });
+                if (!recapTab) return 'no_recap_tab';
+                recapTab.click();
+                return 'clicked_recap';
+            })()
+        """)
+        logger.log("multi-part", f"Re-enter Recap: {recap_result}")
+
+        if recap_result == "no_recap_tab":
+            return False
+
+        await shutdown.interruptible_sleep(3)
+
+        # Step 3: Click Part N tab.
+        part_result = await browser.evaluate(rf"""
+            (function() {{
+                var tabs = Array.from(document.querySelectorAll('[role="tab"]'));
+                var partTab = tabs.find(function(t) {{
+                    return /^Part\s*{part_number}($|Part)/i.test(
+                        t.textContent.trim()
+                    );
+                }});
+                if (!partTab) return 'no_part_tab';
+                partTab.click();
+                return 'clicked_part';
+            }})()
+        """)
+        logger.log("multi-part", f"Part {part_number} tab: {part_result}")
+
+        if part_result == "no_part_tab":
+            return False
+
+        await shutdown.interruptible_sleep(2)
+
+        # Step 4: Click Transcript sub-tab.
+        transcript_result = await browser.evaluate("""
+            (function() {
+                var tabs = Array.from(document.querySelectorAll('[role="tab"]'));
+                var transcriptTab = tabs.find(function(t) {
+                    return t.textContent.indexOf('Transcript') !== -1;
+                });
+                if (!transcriptTab) return 'no_transcript_tab';
+                transcriptTab.click();
+                return 'clicked_transcript';
+            })()
+        """)
+        logger.log(
+            "multi-part",
+            f"Transcript tab for Part {part_number}: {transcript_result}",
+        )
+
+        if transcript_result == "no_transcript_tab":
+            return False
+
+        await shutdown.interruptible_sleep(3)
+    finally:
+        await browser.disconnect()
+
+    return True
+
+
+# ---------------------------------------------------------------------------
+# Roster extraction
+# ---------------------------------------------------------------------------
+
+
+async def retry_click_transcript(
+    browser: BrowserPort,
+    target_id: str,
+    logger: Logger,
+    shutdown: ShutdownCoordinator,
+) -> bool:
+    """Click Speakers then Transcript to force-reload the iframe.
+
+    Used as a retry mechanism when :func:`find_iframe_target` fails to
+    find an xplatplugins iframe for a subsequent part.  Cycling through
+    the Speakers tab ensures the Transcript click is a genuine state
+    transition even if Transcript was already selected.
+
+    Args:
+        browser: Browser port.
+        target_id: CDP target ID for the main Teams target.
+        logger: Logger instance.
+        shutdown: Shutdown coordinator.
+
+    Returns:
+        ``True`` if the Transcript tab was found and clicked.
+    """
+    await browser.connect(target_id)
+    try:
+        await browser.evaluate("""
+            (function() {
+                var tabs = Array.from(document.querySelectorAll('[role="tab"]'));
+                var speakersTab = tabs.find(function(t) {
+                    return /speaker/i.test(t.textContent);
+                });
+                if (speakersTab) speakersTab.click();
+            })()
+        """)
+        await shutdown.interruptible_sleep(2)
+
+        result = await browser.evaluate("""
+            (function() {
+                var tabs = Array.from(document.querySelectorAll('[role="tab"]'));
+                var transcriptTab = tabs.find(function(t) {
+                    return t.textContent.indexOf('Transcript') !== -1;
+                });
+                if (!transcriptTab) return 'no_transcript_tab';
+                transcriptTab.click();
+                return 'clicked_transcript';
+            })()
+        """)
+        logger.log("multi-part", f"Transcript tab retry: {result}")
+        if result == "no_transcript_tab":
+            return False
+
+        await shutdown.interruptible_sleep(3)
+    finally:
+        await browser.disconnect()
+
+    return True
+
+
+async def extract_roster_members(
+    browser: BrowserPort,
+    target_id: str,
+    logger: Logger,
+    shutdown: ShutdownCoordinator,
+    speaker_map: dict[str, str] | None = None,
+) -> tuple[list[RosterMember], str]:
+    """Extract the full meeting chat member list via the participant popover.
+
+    Primary approach:
+        1. Click ``[data-tid="chat-header-participant-count"]`` to open
+           the participant popover.
+        2. Read ``props.members`` from the ``chat-header-participant-list``
+           element's React fibre tree (level 7).  This contains ALL
+           members with ``displayName``, ``email``, ``objectId``, etc.
+        3. Close the popover with Escape.
+
+    Fallback (when the popover button is missing or the fibre read fails):
+        Read ``chat.membersLimited`` + ``chat.me`` from the
+        ``chat-topic-menu`` fibre tree.  This returns only ~3-4 members
+        for large meetings.
+
+    In both cases, the ``organizerId`` is read from
+    ``chat.meetingInformation`` on the ``chat-topic-menu`` fibre tree.
+
+    Args:
+        browser: Browser port.
+        target_id: CDP target ID for the main Teams target.
+        logger: Logger instance.
+        shutdown: Shutdown coordinator.
+        speaker_map: Optional GUID-to-name mapping for name resolution.
+
+    Returns:
+        Tuple of ``(members, organizer_id)``:
+            - ``members``: list of :class:`RosterMember` instances.
+            - ``organizer_id``: bare GUID of the meeting organiser,
+              or empty string when unavailable.
+    """
+    await browser.connect(target_id)
+    try:
+        # --- Step 1: Read organizerId from chat-topic-menu fibre tree ---
+        organizer_id = await _read_organizer_id(browser, logger)
+
+        # --- Step 2: Try participant popover approach ---
+        raw_members = await _try_popover_extraction(browser, logger, shutdown)
+
+        # --- Step 3: Fallback to membersLimited if popover failed ---
+        if raw_members is None:
+            logger.log("roster", "Popover unavailable; falling back to membersLimited")
+            raw_members = await _read_members_limited(browser, logger)
+    finally:
+        await browser.disconnect()
+
+    if not raw_members:
+        logger.log("roster", "No members found in roster.")
+        return [], organizer_id
+
+    # Build RosterMember list with name cleaning
+    members = _build_roster_members(raw_members, organizer_id, speaker_map)
+    logger.log("roster", f"Extracted {len(members)} member(s)")
+    return members, organizer_id
+
+
+async def _read_organizer_id(browser: BrowserPort, logger: Logger) -> str:
+    """Read ``meetingInformation.organizerId`` from the chat-topic-menu fibre."""
+    raw = await browser.evaluate("""
+        (function() {
+            var menu = document.querySelector('[data-tid="chat-topic-menu"]');
+            if (!menu) return JSON.stringify({error: 'no_menu'});
+
+            var fiberKey = Object.keys(menu).find(function(k) {
+                return k.startsWith('__reactFiber$');
+            });
+            if (!fiberKey) return JSON.stringify({error: 'no_fiber'});
+
+            var current = menu[fiberKey];
+            for (var i = 0; i < 25 && current; i++) {
+                var props = current.memoizedProps;
+                if (props && props.chat && props.chat.meetingInformation) {
+                    var mi = props.chat.meetingInformation;
+                    return JSON.stringify({
+                        organizerId: mi.organizerId || ''
+                    });
+                }
+                current = current.return;
+            }
+            return JSON.stringify({error: 'no_meeting_info'});
+        })()
+    """)
+    if not raw:
+        return ""
+    data = json.loads(str(raw))
+    if data.get("error"):
+        logger.log("roster", f"Could not read organizer: {data['error']}")
+        return ""
+    return data.get("organizerId", "")
+
+
+async def _try_popover_extraction(
+    browser: BrowserPort,
+    logger: Logger,
+    shutdown: ShutdownCoordinator,
+) -> list[dict] | None:
+    """Try to extract all members via the participant popover.
+
+    Returns a list of member dicts on success, or ``None`` if the popover
+    could not be opened or the fibre tree could not be read.
+    """
+    # Click the participant count button to open the popover
+    click_result = await browser.evaluate("""
+        (function() {
+            var btn = document.querySelector(
+                '[data-tid="chat-header-participant-count"]'
+            );
+            if (!btn) return JSON.stringify({error: 'no_button'});
+            btn.click();
+            return JSON.stringify({clicked: true});
+        })()
+    """)
+    if not click_result:
+        return None
+    click_data = json.loads(str(click_result))
+    if click_data.get("error"):
+        logger.log("roster", f"Popover button: {click_data['error']}")
+        return None
+
+    logger.log("roster", "Opened participant popover")
+    await shutdown.interruptible_sleep(1)
+
+    # Read props.members from chat-header-participant-list fibre tree
+    raw = await browser.evaluate(r"""
+        (function() {
+            var el = document.querySelector(
+                '[data-tid="chat-header-participant-list"]'
+            );
+            if (!el) return JSON.stringify({error: 'no_list_element'});
+
+            var fiberKey = Object.keys(el).find(function(k) {
+                return k.startsWith('__reactFiber$');
+            });
+            if (!fiberKey) return JSON.stringify({error: 'no_fiber'});
+
+            var current = el[fiberKey];
+            for (var depth = 0; depth < 15 && current; depth++) {
+                var props = current.memoizedProps || {};
+                if (props.members && Array.isArray(props.members)
+                        && props.members.length > 0
+                        && props.members[0].objectId) {
+                    var result = [];
+                    for (var i = 0; i < props.members.length; i++) {
+                        var m = props.members[i];
+                        result.push({
+                            displayName: m.displayName || '',
+                            mri: m.mri || '',
+                            objectId: m.objectId || '',
+                            email: m.email || ''
+                        });
+                    }
+                    return JSON.stringify({
+                        members: result,
+                        count: result.length,
+                        level: depth
+                    });
+                }
+                current = current.return;
+            }
+            return JSON.stringify({error: 'no_members_in_fiber'});
+        })()
+    """)
+
+    # Close the popover (Escape key)
+    await browser.send_command(
+        "Input.dispatchKeyEvent",
+        {"type": "keyDown", "key": "Escape", "code": "Escape", "windowsVirtualKeyCode": 27},
+    )
+    await browser.send_command(
+        "Input.dispatchKeyEvent",
+        {"type": "keyUp", "key": "Escape", "code": "Escape", "windowsVirtualKeyCode": 27},
+    )
+
+    if not raw:
+        logger.log("roster", "Popover fibre read returned nothing")
+        return None
+
+    data = json.loads(str(raw))
+    if data.get("error"):
+        logger.log("roster", f"Popover fibre: {data['error']}")
+        return None
+
+    members = data.get("members", [])
+    logger.log(
+        "roster",
+        f"Popover extraction: {len(members)} members (fibre level {data.get('level', '?')})",
+    )
+    return members
+
+
+async def _read_members_limited(
+    browser: BrowserPort,
+    logger: Logger,
+) -> list[dict]:
+    """Fallback: read membersLimited + me from chat-topic-menu fibre tree."""
+    raw = await browser.evaluate("""
+        (function() {
+            var menu = document.querySelector('[data-tid="chat-topic-menu"]');
+            if (!menu) return JSON.stringify({error: 'no_menu'});
+
+            var fiberKey = Object.keys(menu).find(function(k) {
+                return k.startsWith('__reactFiber$');
+            });
+            if (!fiberKey) return JSON.stringify({error: 'no_fiber'});
+
+            var current = menu[fiberKey];
+            for (var i = 0; i < 25 && current; i++) {
+                var props = current.memoizedProps;
+                if (props && props.chat && props.chat.membersLimited) {
+                    var chat = props.chat;
+                    var members = [];
+
+                    var limited = chat.membersLimited || [];
+                    for (var j = 0; j < limited.length; j++) {
+                        var m = limited[j];
+                        members.push({
+                            displayName: m.displayName || '',
+                            mri: m.mri || '',
+                            objectId: m.objectId || '',
+                            email: m.email || ''
+                        });
+                    }
+
+                    if (chat.me) {
+                        members.push({
+                            displayName: chat.me.displayName || '',
+                            mri: chat.me.mri || '',
+                            objectId: chat.me.objectId || '',
+                            email: chat.me.email || ''
+                        });
+                    }
+
+                    return JSON.stringify({members: members});
+                }
+                current = current.return;
+            }
+            return JSON.stringify({error: 'no_chat_props'});
+        })()
+    """)
+    if not raw:
+        return []
+    data = json.loads(str(raw))
+    if data.get("error"):
+        logger.log("roster", f"membersLimited fallback: {data['error']}")
+        return []
+    return data.get("members", [])
+
+
+def _build_roster_members(
+    raw_members: list[dict],
+    organizer_id: str,
+    speaker_map: dict[str, str] | None,
+) -> list[RosterMember]:
+    """Build :class:`RosterMember` list from raw member dicts.
+
+    Applies name cleaning (``v-`` prefix, ``(...)`` suffix removal)
+    and speaker map resolution.
+    """
+    members: list[RosterMember] = []
+    for m in raw_members:
+        name = m.get("displayName") or "Unknown"
+        guid = _normalise_object_id(m.get("objectId", ""))
+        organiser_guid = _normalise_object_id(organizer_id)
+
+        if speaker_map and guid and guid in speaker_map:
+            name = speaker_map[guid]
+        else:
+            cleaned = re.sub(r"^v-", "", name)
+            cleaned = re.sub(r"\s*\([^)]+\)\s*$", "", cleaned)
+            if cleaned:
+                name = cleaned
+
+        is_organiser = bool(organiser_guid and guid == organiser_guid)
+        role = "organiser" if is_organiser else "member"
+        members.append(
+            RosterMember(
+                name=name,
+                email=m.get("email", ""),
+                object_id=guid,
+                role=role,
+            )
+        )
+    return members
+
+
+def _normalise_object_id(value: str) -> str:
+    """Return a bare object GUID from a Teams MRI-like identifier."""
+    if not value:
+        return ""
+    return value.rsplit(":", 1)[-1]
+
+
+# ---------------------------------------------------------------------------
+# Chat message extraction
+# ---------------------------------------------------------------------------
+
+
+async def extract_chat_messages(
+    browser: BrowserPort,
+    target_id: str,
+    target_date: str,
+    logger: Logger,
+    shutdown: ShutdownCoordinator,
+    *,
+    meeting_time_text: str = "",
+    member_map: dict[str, str] | None = None,
+    speaker_map: dict[str, str] | None = None,
+) -> tuple[list[ChatMessage], list[str]]:
+    """Extract meeting chat messages and Event/Call content from the Chat tab.
+
+    Navigates to the Chat tab, walks the React fibre tree, and extracts
+    user messages within the meeting time window.  Also collects the raw
+    ``content`` strings from Event/Call messages (which contain
+    ``<partlist>`` attendance data for use by the caller).
+
+    Args:
+        browser: Browser port.
+        target_id: CDP target ID for the main Teams target.
+        target_date: Target date as ``YYYY-MM-DD``.
+        logger: Logger instance.
+        shutdown: Shutdown coordinator.
+        meeting_time_text: Recap header meeting time text (optional).
+        member_map: Combined GUID-to-name mapping (roster + speakers).
+        speaker_map: Recap GUID-to-name mapping (fallback).
+
+    Returns:
+        Tuple of ``(chat_messages, event_call_contents)``:
+            - ``chat_messages``: sorted list of :class:`ChatMessage`.
+            - ``event_call_contents``: raw content strings from Event/Call
+              messages matching the target date (for partlist parsing).
+    """
+    await browser.connect(target_id)
+    try:
+        # Click the Chat tab
+        chat_tab_result = await browser.evaluate(r"""
+            (function() {
+                var tabs = Array.from(document.querySelectorAll('[role="tab"]'));
+                var chatTab = tabs.find(function(t) {
+                    return t.getAttribute('data-tid') ===
+                        'tab-item-com.microsoft.chattabs.chat';
+                });
+                if (!chatTab) return 'no_tab';
+                chatTab.click();
+                return 'clicked';
+            })()
+        """)
+
+        if chat_tab_result != "clicked":
+            logger.log("chat", "Chat tab not found -- skipping chat extraction.")
+            return [], []
+
+        await shutdown.interruptible_sleep(2)
+
+        # Extract all messages from the React fibre tree
+        raw = await browser.evaluate(r"""
+            (function() {
+                var els = document.querySelectorAll('[data-tid="chat-pane-item"]');
+                if (!els.length) return JSON.stringify({error: 'no_items'});
+
+                var el = els[0];
+                var fk = Object.keys(el).find(function(k) {
+                    return k.startsWith('__reactFiber$');
+                });
+                if (!fk) return JSON.stringify({error: 'no_fiber'});
+
+                var fiber = el[fk];
+                var c = fiber;
+                var itemsArr = null;
+                var loadPrev = null;
+                var loadNext = null;
+                for (var d = 0; d < 30 && c; d++) {
+                    var p = c.memoizedProps || {};
+                    if (p.items && Array.isArray(p.items) && p.items.length > 0
+                            && p.items[0] && p.items[0].originalArrivalTime) {
+                        itemsArr = p.items;
+                        loadPrev = p.loadPrev;
+                        loadNext = p.loadNext;
+                        break;
+                    }
+                    c = c.return;
+                }
+
+                if (!itemsArr) return JSON.stringify({error: 'no_items_array'});
+
+                var messages = [];
+                for (var i = 0; i < itemsArr.length; i++) {
+                    var m = itemsArr[i];
+                    messages.push({
+                        id: m.id,
+                        time: m.originalArrivalTime,
+                        itemType: m.itemType,
+                        messageType: m.messageType,
+                        fromUserId: m.fromUserId || '',
+                        displayName: m.imDisplayName || '',
+                        content: m.content || '',
+                        emotions: m.emotions,
+                        emotionsSummary: m.emotionsSummary,
+                        files: m.files ? m.files.length : 0,
+                        mentions: m.mentions
+                    });
+                }
+
+                return JSON.stringify({
+                    total: itemsArr.length,
+                    hasPagination: !!(loadPrev || loadNext),
+                    messages: messages
+                });
+            })()
+        """)
+
+        if not raw:
+            logger.log("chat", "Failed to extract chat data from React fibre tree.")
+            return [], []
+
+        data = json.loads(str(raw))
+
+        if "error" in data:
+            logger.log("chat", f"Chat extraction error: {data['error']}")
+            return [], []
+
+        if data.get("hasPagination"):
+            logger.log(
+                "chat",
+                f"WARNING: Chat has pagination ({data['total']} items loaded). "
+                "Some messages may be missing.",
+            )
+
+        logger.log("chat", f"Total items in chat: {data['total']}")
+
+    finally:
+        await browser.disconnect()
+
+    # Determine meeting time window from Event/Call control messages
+    candidate_dates = [target_date]
+    if meeting_time_text:
+        recap_start, _ = parse_meeting_times(meeting_time_text, target_date)
+        recap_date = recap_start[:10]
+        if recap_date != target_date:
+            candidate_dates.insert(0, recap_date)
+
+    event_calls = []
+    matched_date = None
+    for cdate in candidate_dates:
+        event_calls = [
+            m
+            for m in data["messages"]
+            if m.get("messageType") == "Event/Call" and m.get("time", "").startswith(cdate)
+        ]
+        if event_calls:
+            matched_date = cdate
+            break
+
+    if event_calls:
+        event_calls.sort(key=lambda m: m["time"])
+        start_iso = event_calls[0]["time"]
+        end_iso = event_calls[-1]["time"]
+        if start_iso == end_iso:
+            dt = datetime.fromisoformat(start_iso.replace("Z", "+00:00"))
+            start_iso = (dt - timedelta(hours=2)).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+            end_iso = (dt + timedelta(hours=2)).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+        logger.log(
+            "chat",
+            f"Time window (from Event/Call on {matched_date}): {start_iso} to {end_iso}",
+        )
+    else:
+        fallback_date = candidate_dates[0]
+        logger.log(
+            "chat",
+            f"No Event/Call markers found; falling back to {fallback_date}",
+        )
+        start_iso = f"{fallback_date}T00:00:00Z"
+        end_iso = f"{fallback_date}T23:59:59Z"
+        logger.log(
+            "chat",
+            f"Time window (full day fallback): {start_iso} to {end_iso}",
+        )
+
+    # Prefer member_map for resolving authors; fall back to speaker_map
+    name_map = member_map or speaker_map
+
+    results: list[ChatMessage] = []
+    for msg in data["messages"]:
+        if msg["itemType"] != 3:
+            continue
+        if msg["messageType"] != "RichText/Html":
+            continue
+        if msg["files"] and msg["files"] > 0:
+            text = strip_html_to_text(msg["content"])
+            if not text:
+                continue
+
+        msg_time = msg["time"]
+        if not msg_time:
+            continue
+        if msg_time < start_iso or msg_time > end_iso:
+            continue
+
+        text = strip_html_to_text(msg["content"])
+        if not text:
+            continue
+
+        author = resolve_chat_author(msg["fromUserId"], msg["displayName"], name_map)
+
+        # Parse reactions
+        reactions: list[Reaction] | None = None
+        emotions_list = msg.get("emotions") or []
+        if emotions_list:
+            reactions = []
+            for emo in emotions_list:
+                reaction_type = emo.get("key", "")
+                users: list[str] = []
+                for u in emo.get("users") or []:
+                    uid = u.get("userId", "")
+                    display = u.get("displayName", "")
+                    name = resolve_chat_author(uid, display, name_map)
+                    users.append(name)
+                reactions.append(Reaction(type=reaction_type, users=users))
+        elif msg.get("emotionsSummary"):
+            reactions = []
+            for r in msg["emotionsSummary"]:
+                reactions.append(Reaction(type=r.get("key", ""), users=[]))
+
+        results.append(
+            ChatMessage(
+                timestamp=utc_to_local_iso(msg_time),
+                author=author,
+                text=text,
+                reactions=reactions,
+            )
+        )
+
+    results.sort(key=lambda m: m.timestamp)
+
+    logger.log("chat", f"Extracted {len(results)} chat message(s) in meeting window")
+
+    # Collect Event/Call content strings for attendance extraction.
+    # These are the raw `content` fields from Event/Call messages matching
+    # the target date.  The caller can parse <partlist> XML from them.
+    event_call_contents: list[str] = [
+        m["content"]
+        for m in data["messages"]
+        if m.get("messageType") == "Event/Call"
+        and m.get("time", "").startswith(matched_date or target_date)
+        and m.get("content")
+    ]
+    if event_call_contents:
+        logger.log("chat", f"Collected {len(event_call_contents)} Event/Call content string(s)")
+
+    return results, event_call_contents
+
+
+# ---------------------------------------------------------------------------
+# Step 9b: Tracking/RSVP extraction from Details tab
+# ---------------------------------------------------------------------------
+
+
+async def extract_tracking_data(
+    browser: BrowserPort,
+    target_id: str,
+    logger: Logger,
+    shutdown: ShutdownCoordinator,
+) -> list[str]:
+    """Extract RSVP tracking data from the meeting Details tab.
+
+    Navigates to the Details tab, finds the Tracking panel, clicks
+    "Show more attendees" to load all entries, and collects the
+    ``aria-label`` strings from each tracking list item.
+
+    This is a **soft-failure** function: if any step fails (no Details
+    tab, no Tracking panel, etc.), it logs the reason and returns an
+    empty list.  The pipeline continues without RSVP data.
+
+    Args:
+        browser: Browser port.
+        target_id: CDP target ID for the main Teams target.
+        logger: Logger instance.
+        shutdown: Shutdown coordinator.
+
+    Returns:
+        List of raw aria-label strings from the Tracking panel.  Each
+        label has the format:
+        ``"Name Status, N of M, in a list of M items, Dialogue Pop-up Button"``
+    """
+    await browser.connect(target_id)
+    try:
+        return await _do_extract_tracking(browser, logger, shutdown)
+    except Exception as exc:  # soft failure by design
+        logger.log("tracking", f"Tracking extraction failed: {exc}")
+        return []
+    finally:
+        await browser.disconnect()
+
+
+async def _do_extract_tracking(
+    browser: BrowserPort,
+    logger: Logger,
+    shutdown: ShutdownCoordinator,
+) -> list[str]:
+    """Inner implementation of tracking extraction (connected browser).
+
+    Separated from :func:`extract_tracking_data` to keep the
+    connect/disconnect lifecycle in one place.
+    """
+    # --- Step 1: Click the Details tab ---
+    tab_result = await browser.evaluate("""
+        (function() {
+            var tabs = Array.from(document.querySelectorAll('[role="tab"]'));
+            var detailsTab = tabs.find(function(t) {
+                return t.textContent.trim() === 'Details';
+            });
+            if (detailsTab) {
+                detailsTab.click();
+                return 'clicked_details';
+            }
+            // Check overflow menu
+            var overflow = document.querySelector('[data-tid="tab-overflow-button"]');
+            if (overflow) return 'check_overflow';
+            return 'no_details_tab';
+        })()
+    """)
+    logger.log("tracking", f"Details tab navigation: {tab_result}")
+
+    if tab_result == "check_overflow":
+        # Click overflow menu and look for Details
+        overflow_rect_raw = await browser.evaluate("""
+            JSON.stringify(
+                document.querySelector('[data-tid="tab-overflow-button"]')
+                    .getBoundingClientRect()
+            )
+        """)
+        if overflow_rect_raw:
+            rect = json.loads(str(overflow_rect_raw))
+            ox = int(rect["x"] + rect["width"] / 2)
+            oy = int(rect["y"] + rect["height"] / 2)
+            await browser.send_command(
+                "Input.dispatchMouseEvent",
+                {"type": "mousePressed", "x": ox, "y": oy, "button": "left", "clickCount": 1},
+            )
+            await browser.send_command(
+                "Input.dispatchMouseEvent",
+                {"type": "mouseReleased", "x": ox, "y": oy, "button": "left", "clickCount": 1},
+            )
+            await shutdown.interruptible_sleep(1)
+
+            tab_result = await browser.evaluate("""
+                (function() {
+                    var menus = document.querySelectorAll('[role="menu"]');
+                    for (var i = 0; i < menus.length; i++) {
+                        var items = menus[i].querySelectorAll(
+                            '[role="menuitem"], [role="menuitemradio"]'
+                        );
+                        for (var j = 0; j < items.length; j++) {
+                            if (items[j].textContent.trim() === 'Details') {
+                                items[j].click();
+                                return 'clicked_details';
+                            }
+                        }
+                    }
+                    return 'no_details_tab';
+                })()
+            """)
+            logger.log("tracking", f"Overflow menu result: {tab_result}")
+
+    if tab_result == "no_details_tab":
+        logger.log("tracking", "No Details tab found; skipping RSVP extraction")
+        return []
+
+    # Wait for Details tab content to load
+    await shutdown.interruptible_sleep(2)
+    shutdown.check_shutdown()
+
+    # --- Step 2: Find the Tracking panel ---
+    tracking_present = await browser.evaluate("""
+        (function() {
+            var tv = document.querySelector('[aria-label*="Tracking view"]');
+            if (tv) return 'found';
+            // Also check for any element with "Tracking" heading
+            var headings = Array.from(document.querySelectorAll('h2, h3, [role="heading"]'));
+            var trackingH = headings.find(function(h) {
+                return h.textContent.trim() === 'Tracking';
+            });
+            return trackingH ? 'found_heading' : 'not_found';
+        })()
+    """)
+    logger.log("tracking", f"Tracking panel: {tracking_present}")
+
+    if tracking_present == "not_found":
+        logger.log("tracking", "No Tracking panel on Details tab; skipping RSVP extraction")
+        return []
+
+    # --- Step 3: Click "Show more attendees" to load all entries ---
+    # There may be multiple "Show more" buttons (one per section).
+    # Click them all, waiting between each.
+    for attempt in range(3):
+        show_more_result = await browser.evaluate("""
+            (function() {
+                var buttons = Array.from(document.querySelectorAll('button'));
+                var showMore = buttons.filter(function(b) {
+                    var label = b.getAttribute('aria-label') || b.textContent || '';
+                    return label.indexOf('Show more attendees') !== -1
+                        || label.indexOf('Show more') !== -1;
+                });
+                if (showMore.length === 0) return 'none';
+                for (var i = 0; i < showMore.length; i++) {
+                    showMore[i].click();
+                }
+                return 'clicked_' + showMore.length;
+            })()
+        """)
+        logger.log("tracking", f"Show more (attempt {attempt + 1}): {show_more_result}")
+
+        if show_more_result == "none":
+            break
+
+        await shutdown.interruptible_sleep(1.5)
+        shutdown.check_shutdown()
+
+    # --- Step 4: Collect all tracking aria-labels ---
+    labels_raw = await browser.evaluate("""
+        (function() {
+            var items = document.querySelectorAll(
+                '[aria-label*="Dialogue Pop-up Button"]'
+            );
+            var labels = [];
+            for (var i = 0; i < items.length; i++) {
+                var label = items[i].getAttribute('aria-label');
+                if (label) labels.push(label);
+            }
+            return JSON.stringify(labels);
+        })()
+    """)
+
+    if not labels_raw:
+        logger.log("tracking", "No tracking labels collected")
+        return []
+
+    labels: list[str] = json.loads(str(labels_raw))
+    logger.log("tracking", f"Collected {len(labels)} tracking label(s)")
+
+    # --- Step 5: Navigate back to Chat tab ---
+    # The pipeline expects to be on the Chat tab for subsequent operations.
+    await browser.evaluate("""
+        (function() {
+            var tabs = Array.from(document.querySelectorAll('[role="tab"]'));
+            var chatTab = tabs.find(function(t) {
+                return t.textContent.trim() === 'Chat';
+            });
+            if (chatTab) chatTab.click();
+        })()
+    """)
+    await shutdown.interruptible_sleep(1)
+
+    return labels
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+async def _async_sleep(seconds: float) -> None:
+    """Thin wrapper around asyncio.sleep for clarity."""
+    import asyncio
+
+    await asyncio.sleep(seconds)