learnx-cli 0.3.0__py3-none-any.whl

tutor/visual/__init__.py

@@ -0,0 +1,213 @@
+"""
+Entry point for the v3 visual pipeline.
+Reads from audio/<session>/, writes to video/<session>/.
+"""
+
+import json
+import logging
+import re
+import subprocess
+from collections.abc import Callable
+from pathlib import Path
+
+from tutor.models import DialogueLine
+
+_UNIT_MP3_RE = re.compile(r"^unit_\d+$")  # matches unit_01, unit_02 — not unit_00_intro
+
+log = logging.getLogger(__name__)
+
+
+def run_visual_pipeline(
+    session: str,
+    audio_dir: Path,
+    video_dir: Path,
+    llm_fn: Callable,
+    difficulty: str = "beginner",
+    no_cache: bool = False,
+) -> Path:
+    """
+    Full v3 pipeline for one session.
+    Reads from audio_dir, writes to video_dir.
+    Returns path to full_session.mp4.
+    """
+    from tutor.generation.segment_planner import plan_segments
+    from tutor.generation.visual_planner import plan_visuals
+    from tutor.visual.beat_timer import compute_slide_timings_v3
+    from tutor.visual.slide_renderer import render_all_slides
+    from tutor.visual.subtitle_writer import build_srt
+    from tutor.visual.video_assembler import assemble_session
+
+    units_json = audio_dir / "tutorial.units.json"
+    doc_title = _doc_title_from_units(units_json)
+    unit_mp3s = _get_unit_mp3s(audio_dir)
+    unit_durations = [_mp3_duration(mp3) for mp3 in unit_mp3s]
+    slides_dir = video_dir / "slides"
+    slides_dir.mkdir(parents=True, exist_ok=True)
+
+    print("\n  [1/6] Generating visual specs (title card + outro)...")
+    visuals = plan_visuals(units_json, doc_title, session, llm_fn, difficulty, video_dir, no_cache)
+
+    print("  [2/6] Planning dialogue segments...")
+    segments_by_unit = plan_segments(units_json, video_dir, llm_fn, no_cache)
+
+    print("  [3/6] Rendering slides...")
+    title_spec = next(v for v in visuals if v.slide_type == "title_card")
+    outro_spec = next(v for v in visuals if v.slide_type == "outro")
+    slide_paths = render_all_slides(title_spec, outro_spec, segments_by_unit, slides_dir, session)
+
+    print("  [4/6] Building SRT subtitles...")
+    timing_json = _load_timing_json(audio_dir)
+    all_lines = _load_all_lines(units_json)
+    srt_text = build_srt(all_lines, unit_durations, timing_json)
+    srt_path = video_dir / "subtitles.srt"
+    srt_path.write_text(srt_text, encoding="utf-8")
+
+    print("  [5/6] Computing slide timings...")
+    title_path = slide_paths[0]
+    outro_path = slide_paths[-1]
+    slide_timings = compute_slide_timings_v3(
+        title_path, outro_path, segments_by_unit, timing_json, unit_durations
+    )
+
+    print("  [6/6] Assembling video...")
+    result = assemble_session(
+        video_dir, audio_dir / "tutorial_units", slide_timings, unit_mp3s, srt_path
+    )
+    total_s = sum(dur for _, dur in slide_timings)
+    m, s = divmod(int(total_s), 60)
+    print(f"\n  ✓  {result}  ({m}:{s:02d})")
+    return result
+
+
+def _load_timing_json(audio_dir: Path) -> dict | None:
+    """
+    Load tutorial.timing.json. Returns None if absent, unreadable, or version != 1.
+    Logs a warning on parse failure; does not raise.
+    """
+    path = audio_dir / "tutorial.timing.json"
+    if not path.exists():
+        return None
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+        return data if data.get("version") == 1 else None
+    except Exception:
+        log.warning("Could not parse tutorial.timing.json — using estimated timing")
+        return None
+
+
+def _get_unit_mp3s(audio_dir: Path) -> list[Path]:
+    """Return unit MP3s matching unit_NN.mp3 pattern (teaching units, sorted)."""
+    return sorted(
+        p for p in (audio_dir / "tutorial_units").glob("unit_*.mp3") if _UNIT_MP3_RE.match(p.stem)
+    )
+
+
+def _doc_title_from_units(units_json: Path) -> str:
+    """
+    Priority: H1 from source markdown → source filename stem → first unit concept.
+    Reads tutorial.meta.json (written by /generate) for the source file path.
+    """
+    import re as _re
+
+    meta_path = units_json.parent / "tutorial.meta.json"
+    if meta_path.exists():
+        try:
+            meta = json.loads(meta_path.read_text(encoding="utf-8"))
+            src = Path(meta.get("source_file", ""))
+            if src.exists():
+                text = src.read_text(encoding="utf-8", errors="replace")
+                _SKIP = {"learning objectives", "introduction", "overview", "contents"}
+                for pat in (r"^#\s+(.+)$", r"^##\s+(.+)$"):
+                    for m in _re.finditer(pat, text, _re.MULTILINE):
+                        raw = m.group(1).strip()
+                        raw = _re.sub(r"^\d+[.)]\s*", "", raw)
+                        candidate = _re.sub(r"[^\w\s\-&]", "", raw).strip()
+                        if candidate.lower() not in _SKIP and len(candidate) > 3:
+                            return candidate
+            if src.stem:
+                stem = src.stem.replace("_", " ").replace("-", " ")
+                parent = src.parent.name.replace("_", " ").replace("-", " ")
+                if stem.isdigit() and parent:
+                    return f"{parent.title()} - Part {stem}"
+                return stem.title()
+        except Exception:
+            pass
+    try:
+        units = json.loads(units_json.read_text(encoding="utf-8"))
+        if units:
+            return str(units[0].get("concept", "Tutorial"))
+    except Exception:
+        pass
+    return "Tutorial"
+
+
+def _load_all_lines(units_json: Path) -> list[DialogueLine]:
+    """
+    Load dialogue lines. Tries units JSON `lines` field first;
+    falls back to parsing tutorial.script.txt in the same directory.
+    """
+    import re as _re
+
+    try:
+        units = json.loads(units_json.read_text(encoding="utf-8"))
+        lines: list[DialogueLine] = []
+        for u in units:
+            for raw in u.get("lines", []):
+                lines.append(DialogueLine(**raw))
+        if lines:
+            return lines
+    except Exception:
+        pass
+
+    script_path = units_json.parent / "tutorial.script.txt"
+    if not script_path.exists():
+        log.warning("No dialogue lines source found — subtitles will be empty")
+        return []
+
+    try:
+        n_units = len(json.loads(units_json.read_text(encoding="utf-8")))
+    except Exception:
+        n_units = 1
+
+    raw_lines = [
+        ln.strip() for ln in script_path.read_text(encoding="utf-8").splitlines() if ln.strip()
+    ]
+    speaker_re = _re.compile(r"^(ALEX|MAYA|SAM):\s*(.+)$")
+    valid = [(m.group(1), m.group(2)) for ln in raw_lines if (m := speaker_re.match(ln))]
+
+    if not valid:
+        return []
+
+    per_unit = max(1, len(valid) // max(n_units, 1))
+    result: list[DialogueLine] = []
+    for i, (speaker, text) in enumerate(valid):
+        unit_num = min(i // per_unit + 1, n_units)
+        result.append(DialogueLine(speaker=speaker, text=text, unit_number=unit_num))
+    return result
+
+
+def _mp3_duration(path: Path) -> float:
+    """Return duration in seconds via ffprobe. Falls back to 0.0 on error."""
+    try:
+        result = subprocess.run(
+            [
+                "ffprobe",
+                "-v",
+                "error",
+                "-show_entries",
+                "format=duration",
+                "-of",
+                "default=noprint_wrappers=1:nokey=1",
+                str(path),
+            ],
+            capture_output=True,
+            timeout=10,
+        )
+        return float(result.stdout.strip())
+    except Exception:
+        return 0.0
+
+
+def _format_duration(seconds: float) -> str:
+    m, s = divmod(int(seconds), 60)
+    return f"{m}:{s:02d}"

tutor/visual/beat_timer.py

@@ -0,0 +1,222 @@
+"""
+Map slide PNGs to playback durations based on dialogue beat points.
+No ffmpeg, no Pillow, no LLM here.
+"""
+
+from pathlib import Path
+
+from tutor.constants import SILENCE_TURN_MS
+from tutor.models import DialogueLine, SlideSegment, VisualSpec
+
+MIN_SLIDE_DURATION = 3.0  # seconds
+MAX_HOOK_DURATION = 30.0  # cap hook slide — ALEX can monologue for a long time before MAYA
+TITLE_CARD_DURATION = 4.0
+OUTRO_CARD_DURATION = 6.0
+
+
+def compute_slide_timings_v3(
+    title_path: Path,
+    outro_path: Path,
+    segments_by_unit: dict[int, list[SlideSegment]],
+    timing_json: dict | None,
+    unit_durations_s: list[float],
+) -> list[tuple[Path, float]]:
+    """
+    Return [(png_path, duration_seconds), ...] in video order, ready for the
+    ffmpeg concat script. Prepends title card (4.0 s) and appends outro (6.0 s).
+
+    Duration source per segment:
+      timing_json present  → _exact_duration()
+      timing_json absent   → _proportional_duration()
+
+    Minimum per-segment: MIN_SLIDE_DURATION (3.0 s).
+    """
+    result: list[tuple[Path, float]] = [(title_path, TITLE_CARD_DURATION)]
+
+    units_timing = timing_json.get("units", {}) if timing_json else {}
+
+    for unit_num in sorted(segments_by_unit.keys()):
+        segs = segments_by_unit[unit_num]
+        unit_dur = unit_durations_s[unit_num - 1] if unit_num - 1 < len(unit_durations_s) else 30.0
+        total_lines = max(s.lines_end for s in segs) + 1 if segs else 1
+        unit_timing: list[dict] = units_timing.get(str(unit_num), [])
+
+        for seg in segs:
+            path = Path(seg.png_path)
+            if timing_json and unit_timing:
+                dur = max(_exact_duration(seg, unit_timing), MIN_SLIDE_DURATION)
+            else:
+                dur = _proportional_duration(seg, unit_dur, total_lines)
+            result.append((path, dur))
+
+    result.append((outro_path, OUTRO_CARD_DURATION))
+    return result
+
+
+def _exact_duration(seg: SlideSegment, unit_timing: list[dict]) -> float:
+    """
+    Look up timing entries for lines_start and lines_end in unit_timing.
+    Adds one trailing SILENCE_TURN_MS (inter-line silences are already in the raw span).
+    Falls back to proportional if either index is out of range.
+    """
+    try:
+        start_ms = unit_timing[seg.lines_start]["start_ms"]
+        end_ms = unit_timing[seg.lines_end]["end_ms"]
+        adjusted_ms = (end_ms - start_ms) + SILENCE_TURN_MS
+        return adjusted_ms / 1000.0
+    except (IndexError, KeyError, TypeError):
+        total_lines = len(unit_timing) if unit_timing else 1
+        return _proportional_duration(seg, 30.0, total_lines)
+
+
+def _proportional_duration(seg: SlideSegment, unit_duration_s: float, total_lines: int) -> float:
+    """
+    Segment covers (lines_end - lines_start + 1) / total_lines of unit duration.
+    Return max(computed, MIN_SLIDE_DURATION).
+    """
+    lines_covered = seg.lines_end - seg.lines_start + 1
+    denom = max(total_lines, 1)
+    computed = lines_covered / denom * unit_duration_s
+    return max(computed, MIN_SLIDE_DURATION)
+
+
+def _compute_slide_timings_v2(
+    slides: list[Path],
+    script_lines: list[DialogueLine],
+    line_start_offsets: list[float],
+    visuals: list[VisualSpec],
+    unit_durations_s: list[float],
+) -> list[tuple[Path, float]]:
+    """
+    Return [(slide_path, duration_seconds), ...] ordered for the ffmpeg concat script.
+    Title = 4 s fixed; outro = 6 s fixed; unit slides derived from dialogue beats.
+    """
+    result: list[tuple[Path, float]] = []
+
+    slide_map = _build_slide_map(slides)
+    beat_map = _build_beat_map(script_lines, line_start_offsets, visuals, unit_durations_s)
+
+    # Pre-compute actual cumulative audio end for each unit (no silence inflation)
+    unit_audio_end: dict[int, float] = {}
+    _cursor = 0.0
+    for _ui, _dur in enumerate(unit_durations_s, start=1):
+        _cursor += _dur
+        unit_audio_end[_ui] = _cursor
+    total_audio_end = _cursor
+
+    # Title card
+    title_slide = slide_map.get("title")
+    if title_slide:
+        result.append((title_slide, TITLE_CARD_DURATION))
+
+    # Per-unit slides
+    for unit_idx in sorted(beat_map.keys()):
+        beats = beat_map[unit_idx]  # {"hook": t, "concept": t, "memory": t}
+
+        hook_t = beats.get("hook", 0.0)
+        concept_t = beats.get("concept", hook_t + MIN_SLIDE_DURATION)
+        memory_t = beats.get("memory", concept_t + MIN_SLIDE_DURATION)
+
+        # Use actual MP3 boundary (not inflated line offsets) so slides match audio
+        unit_end = unit_audio_end.get(unit_idx, total_audio_end)
+
+        raw_hook = concept_t - hook_t
+        hook_dur = _clamp(min(raw_hook, MAX_HOOK_DURATION))
+        concept_dur = _clamp(memory_t - concept_t + max(0.0, raw_hook - MAX_HOOK_DURATION))
+        memory_dur = _clamp(unit_end - memory_t)
+
+        hook_slide = slide_map.get(f"{unit_idx:02d}_hook")
+        concept_slide = slide_map.get(f"{unit_idx:02d}_concept")
+        memory_slide = slide_map.get(f"{unit_idx:02d}_memory")
+
+        if hook_slide:
+            result.append((hook_slide, hook_dur))
+        if concept_slide:
+            result.append((concept_slide, concept_dur))
+        if memory_slide:
+            result.append((memory_slide, memory_dur))
+
+    # Outro card
+    outro_slide = slide_map.get("outro")
+    if outro_slide:
+        result.append((outro_slide, OUTRO_CARD_DURATION))
+
+    return result
+
+
+# Backward-compat alias — callers that used compute_slide_timings still work
+compute_slide_timings = _compute_slide_timings_v2
+
+
+# ── Helpers ──────────────────────────────────────────────────────────────────
+
+
+def _clamp(duration: float) -> float:
+    return max(duration, MIN_SLIDE_DURATION)
+
+
+def _build_slide_map(slides: list[Path]) -> dict[str, Path]:
+    """Map stem identifiers to slide paths."""
+    m: dict[str, Path] = {}
+    for s in slides:
+        stem = s.stem  # e.g. "00_title", "01_hook", "99_outro"
+        if "_title" in stem:
+            m["title"] = s
+        elif "_outro" in stem:
+            m["outro"] = s
+        elif "_hook" in stem:
+            m[f"{stem[:2]}_hook"] = s
+        elif "_concept" in stem:
+            m[f"{stem[:2]}_concept"] = s
+        elif "_memory" in stem:
+            m[f"{stem[:2]}_memory"] = s
+    return m
+
+
+def _build_beat_map(
+    script_lines: list[DialogueLine],
+    line_start_offsets: list[float],
+    visuals: list[VisualSpec],
+    unit_durations_s: list[float],
+) -> dict[int, dict[str, float]]:
+    """Return {unit_idx: {hook, concept, memory} in seconds}."""
+    unit_specs = {v.unit_index: v for v in visuals if v.slide_type == "unit"}
+    beats: dict[int, dict[str, float]] = {i: {} for i in unit_specs}
+
+    # Map unit number → (start offset into audio timeline)
+    unit_audio_starts: dict[int, float] = {}
+    cursor = 0.0
+    for ui, dur in enumerate(unit_durations_s, start=1):
+        unit_audio_starts[ui] = cursor
+        cursor += dur
+
+    for _i, (ln, offset) in enumerate(zip(script_lines, line_start_offsets, strict=False)):
+        u = ln.unit_number
+        if u not in beats:
+            continue
+        b = beats[u]
+
+        if "hook" not in b and ln.speaker == "ALEX":
+            b["hook"] = offset
+
+        if "concept" not in b and ln.speaker == "MAYA":
+            b["concept"] = offset
+
+    # Memory = last ALEX line of the unit
+    for i in range(len(script_lines) - 1, -1, -1):
+        ln, offset = script_lines[i], line_start_offsets[i]
+        u = ln.unit_number
+        if u in beats and "memory" not in beats[u] and ln.speaker == "ALEX":
+            beats[u]["memory"] = offset
+
+    # Fill missing beats with audio-based fallbacks
+    for u, b in beats.items():
+        if "hook" not in b:
+            b["hook"] = unit_audio_starts.get(u, 0.0)
+        if "concept" not in b:
+            b["concept"] = b["hook"] + MIN_SLIDE_DURATION
+        if "memory" not in b:
+            unit_dur = unit_durations_s[u - 1] if u - 1 < len(unit_durations_s) else 30.0
+            b["memory"] = b["hook"] + unit_dur * 0.8
+
+    return beats

tutor/visual/slide_renderer.py

@@ -0,0 +1,236 @@
+import logging
+import os
+import tempfile
+import time as _time
+from dataclasses import replace
+from pathlib import Path
+
+from jinja2 import Environment, FileSystemLoader
+
+from tutor.models import SlideSegment, VisualSpec
+
+log = logging.getLogger(__name__)
+
+TEMPLATE_DIR = Path(__file__).parent / "templates"
+ASSET_DIR = Path(__file__).parent.parent / "assets" / "html"
+_ENV = Environment(loader=FileSystemLoader(str(TEMPLATE_DIR)), autoescape=True)
+
+_FALLBACK_VISUAL_TYPE = "key_insight"
+_MIN_PNG_BYTES = 5_120  # 5 KB — any PNG smaller than this is a failed render
+
+
+def _fallback_segment(seg: SlideSegment) -> SlideSegment:
+    """Return a copy of seg reclassified as key_insight for render fallback."""
+    return replace(
+        seg,
+        visual_type=_FALLBACK_VISUAL_TYPE,
+        body=seg.body or f"[diagram: {seg.title}]",
+        mermaid=None,
+    )
+
+
+def render_all_slides(
+    title_spec: VisualSpec,
+    outro_spec: VisualSpec,
+    segments_by_unit: dict[int, list[SlideSegment]],
+    output_dir: Path,
+    session_label: str,
+) -> list[Path]:
+    """
+    Render all slides in video order:
+      title_card, unit_1_segs..., unit_N_segs..., outro
+
+    Populates seg.png_path on every SlideSegment in segments_by_unit.
+    Returns ordered list of PNG paths for the beat timer.
+    One Playwright browser context is opened and reused for all slides.
+    """
+    _prime_msvcp()  # ensure MSVCP140.dll is on the DLL search path before playwright loads
+    from playwright.sync_api import sync_playwright  # lazy: avoid DLL load at import time
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    paths: list[Path] = []
+
+    with sync_playwright() as pw:
+        browser = pw.chromium.launch()
+        page = browser.new_page()
+        page.set_viewport_size({"width": 1920, "height": 1080})
+
+        title_path = output_dir / "00_title.png"
+        _screenshot(
+            page,
+            _render_html("title_card", spec=title_spec),
+            title_path,
+            wait_mermaid=False,
+            wait_hljs=False,
+        )
+        paths.append(title_path)
+
+        for unit_num in sorted(segments_by_unit.keys()):
+            segs = segments_by_unit[unit_num]
+            total = len(segs)
+            for seg in segs:
+                filename = f"{unit_num:02d}_{seg.segment_index:02d}_{seg.visual_type}.png"
+                out = output_dir / filename
+                html = _render_html(
+                    seg.visual_type,
+                    seg=seg,
+                    current_dot=seg.segment_index + 1,
+                    total_dots=total,
+                    asset_dir=ASSET_DIR.as_uri(),
+                )
+                try:
+                    _screenshot(
+                        page,
+                        html,
+                        out,
+                        wait_mermaid=(seg.visual_type == "diagram"),
+                        wait_hljs=(seg.code is not None),
+                    )
+                except Exception as exc:
+                    log.warning(
+                        "Slide render failed for %s (%s): %s — retrying as %s",
+                        out.name,
+                        seg.visual_type,
+                        exc,
+                        _FALLBACK_VISUAL_TYPE,
+                    )
+                    fallback_seg = _fallback_segment(seg)
+                    fallback_html = _render_html(
+                        fallback_seg.visual_type,
+                        seg=fallback_seg,
+                        current_dot=seg.segment_index + 1,
+                        total_dots=total,
+                        asset_dir=ASSET_DIR.as_uri(),
+                    )
+                    _screenshot(
+                        page,
+                        fallback_html,
+                        out,
+                        wait_mermaid=False,
+                        wait_hljs=False,
+                    )
+                    seg.visual_type = _FALLBACK_VISUAL_TYPE
+
+                seg.png_path = str(out)
+                paths.append(out)
+
+        outro_path = output_dir / "99_outro.png"
+        _screenshot(
+            page,
+            _render_html("outro", spec=outro_spec),
+            outro_path,
+            wait_mermaid=False,
+            wait_hljs=False,
+        )
+        paths.append(outro_path)
+
+        browser.close()
+
+    return paths
+
+
+def _render_html(template_name: str, **context: object) -> str:
+    context["asset_dir"] = ASSET_DIR.as_uri()
+    return _ENV.get_template(f"{template_name}.html.j2").render(**context)
+
+
+def _screenshot(
+    page: object,
+    html: str,
+    output: Path,
+    wait_mermaid: bool,
+    wait_hljs: bool,
+) -> None:
+    # Write to a temp file so the page gets a file:// origin and can load
+    # CSS/JS/font assets via file:// URLs (set_content() gives null origin,
+    # which Chromium blocks).
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".html", delete=False, encoding="utf-8") as f:
+        f.write(html)
+        tmp_path = f.name
+
+    try:
+        url = "file:///" + tmp_path.replace(os.sep, "/")
+
+        # Navigate with one retry for transient file:// timing issues.
+        for attempt in range(2):
+            try:
+                page.goto(url, wait_until="domcontentloaded")  # type: ignore[union-attr]
+                break
+            except Exception:
+                if attempt == 0:
+                    _time.sleep(0.2)
+                else:
+                    raise
+
+        if wait_mermaid:
+            try:
+                page.wait_for_function(  # type: ignore[union-attr]
+                    "() => document.querySelector('.mermaid svg') !== null",
+                    timeout=10_000,
+                )
+            except Exception:
+                log.warning(
+                    "Mermaid diagram did not render within 10 s for %s — slide will use fallback",
+                    output.name,
+                )
+                raise  # re-raise so render_all_slides can apply fallback
+
+        if wait_hljs:
+            try:
+                page.wait_for_function(  # type: ignore[union-attr]
+                    "() => document.querySelector('pre code.hljs') !== null",
+                    timeout=5_000,
+                )
+            except Exception:
+                log.warning(
+                    "highlight.js did not render within 5 s for %s — "
+                    "screenshot may show un-highlighted code",
+                    output.name,
+                )
+                # Do not re-raise for hljs; un-highlighted code is acceptable.
+
+        page.screenshot(path=str(output), full_page=False)  # type: ignore[union-attr]
+
+        # Validate the output is a real PNG.
+        if not output.exists() or output.stat().st_size < _MIN_PNG_BYTES:
+            raise RuntimeError(
+                f"Screenshot for {output.name} is missing or too small "
+                f"({output.stat().st_size if output.exists() else 0} bytes); "
+                f"expected ≥ {_MIN_PNG_BYTES} bytes"
+            )
+
+    finally:
+        try:
+            os.unlink(tmp_path)
+        except OSError:
+            pass
+
+
+def _prime_msvcp() -> None:
+    """Add a directory containing MSVCP140.dll to the DLL search path on Windows.
+
+    Python ships vcruntime140.dll but not msvcp140.dll; greenlet (used by
+    playwright's sync API) links against it. The DLL exists on the system
+    in non-standard locations so we find it dynamically.
+    """
+    import sys
+
+    if sys.platform != "win32":
+        return
+    import glob
+
+    candidates = [
+        r"C:\Windows\System32\HealthAttestationClient",
+        r"C:\Windows\System32\Microsoft-Edge-WebView",
+        *glob.glob(r"C:\Windows\WinSxS\amd64_microsoft-edge-webview_*"),
+    ]
+    for directory in candidates:
+        msvcp = os.path.join(directory, "MSVCP140.dll")
+        if os.path.exists(msvcp):
+            try:
+                os.add_dll_directory(directory)
+                log.debug("Added DLL directory for MSVCP140: %s", directory)
+                return
+            except OSError:
+                continue
+    log.debug("MSVCP140.dll not found in known locations — playwright may fail")