@playdrop/playdrop-cli 0.11.8 → 0.12.0

package/dist/captureRuntime.js

@@ -1,1021 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_CAPTURE_TIMEOUT_SECONDS = exports.CAPTURE_LOG_LEVEL_VALUES = void 0;
-exports.resolveCaptureLogLevel = resolveCaptureLogLevel;
-exports.validateCaptureTimeout = validateCaptureTimeout;
-exports.runCapture = runCapture;
-const promises_1 = require("node:fs/promises");
-const node_path_1 = require("node:path");
-const sharp_1 = __importDefault(require("sharp"));
-const playwright_1 = require("./playwright");
-const sessionCookie_1 = require("./sessionCookie");
-const FRAME_SELECTOR = 'iframe[title="Game"]';
-exports.CAPTURE_LOG_LEVEL_VALUES = ['debug', 'info', 'warn', 'error'];
-exports.MAX_CAPTURE_TIMEOUT_SECONDS = 600;
-const GOOGLE_TELEMETRY_HOSTS = [
-    'analytics.google.com',
-    'googletagmanager.com',
-    'google-analytics.com',
-    'googleadservices.com',
-    'doubleclick.net',
-];
-const GOOGLE_COUNTRY_SECOND_LEVEL_DOMAINS = new Set(['ac', 'co', 'com', 'edu', 'gov', 'net', 'org']);
-const CANVAS_VISUAL_SAMPLE_SIZE = 64;
-const MIN_VISIBLE_CANVAS_EDGE_PX = 48;
-const MIN_CANVAS_FOREGROUND_RATIO = 0.018;
-const MIN_CANVAS_COLOR_RANGE = 34;
-const CANVAS_BACKGROUND_DISTANCE_THRESHOLD = 28;
-function isHostOrSubdomain(hostname, domain) {
-    return hostname === domain || hostname.endsWith(`.${domain}`);
-}
-function isGoogleSearchAdCollectionUrl(parsed) {
-    const hostname = parsed.hostname.toLowerCase();
-    if (hostname !== 'www.google.com') {
-        const suffix = hostname.startsWith('www.google.') ? hostname.slice('www.google.'.length) : '';
-        const labels = suffix.split('.');
-        const isCountryDomain = labels.length === 1
-            ? /^[a-z]{2}$/.test(labels[0])
-            : labels.length === 2
-                && GOOGLE_COUNTRY_SECOND_LEVEL_DOMAINS.has(labels[0])
-                && /^[a-z]{2}$/.test(labels[1]);
-        if (!isCountryDomain) {
-            return false;
-        }
-    }
-    const pathname = parsed.pathname.toLowerCase();
-    return pathname.startsWith('/ccm/collect')
-        || pathname.startsWith('/rmkt/collect')
-        || pathname.startsWith('/pagead/');
-}
-function isLoopbackOrLocalUrl(rawUrl) {
-    let parsed;
-    try {
-        parsed = new URL(rawUrl);
-    }
-    catch {
-        return false;
-    }
-    const hostname = parsed.hostname.toLowerCase();
-    return hostname === 'localhost'
-        || hostname === '127.0.0.1'
-        || hostname === '::1'
-        || hostname.endsWith('.localhost');
-}
-function isKnownGoogleTelemetryUrl(rawUrl) {
-    let parsed;
-    try {
-        parsed = new URL(rawUrl);
-    }
-    catch {
-        return false;
-    }
-    const hostname = parsed.hostname.toLowerCase();
-    if (hostname === 'accounts.google.com' || hostname.endsWith('.accounts.google.com')) {
-        return false;
-    }
-    return GOOGLE_TELEMETRY_HOSTS.some(domain => isHostOrSubdomain(hostname, domain))
-        || isGoogleSearchAdCollectionUrl(parsed);
-}
-function extractHttpUrls(text) {
-    const matches = text.match(/https?:\/\/[^\s"'<>]+/gi);
-    if (!matches) {
-        return [];
-    }
-    return matches.map(match => match.replace(/[\])}.,;]+$/g, ''));
-}
-function extractRefusedResourceUrls(text) {
-    const urls = [];
-    const refusedPattern = /Refused to [^']*'(https?:\/\/[^']+)'/gi;
-    let match = refusedPattern.exec(text);
-    while (match) {
-        urls.push(match[1]);
-        match = refusedPattern.exec(text);
-    }
-    return urls;
-}
-function isKnownGoogleTelemetryConsoleIssue(text, locationUrl) {
-    if (/Content Security Policy/i.test(text)) {
-        const refusedUrls = extractRefusedResourceUrls(text);
-        if (refusedUrls.some(isKnownGoogleTelemetryUrl)) {
-            return true;
-        }
-        const messageUrls = extractHttpUrls(text);
-        return messageUrls.some(isKnownGoogleTelemetryUrl)
-            && !messageUrls.some(isLoopbackOrLocalUrl);
-    }
-    if (!/ERR_BLOCKED_BY_CLIENT/i.test(text)) {
-        return false;
-    }
-    const messageUrls = extractHttpUrls(text);
-    return (locationUrl !== null && isKnownGoogleTelemetryUrl(locationUrl))
-        || (messageUrls.some(isKnownGoogleTelemetryUrl)
-            && !messageUrls.some(isLoopbackOrLocalUrl));
-}
-function formatConsoleValue(value) {
-    if (typeof value === 'string')
-        return value;
-    if (typeof value === 'number' || typeof value === 'boolean' || value === null) {
-        return String(value);
-    }
-    if (typeof value === 'undefined') {
-        return 'undefined';
-    }
-    if (typeof value === 'function') {
-        return '[function]';
-    }
-    if (typeof value === 'object') {
-        try {
-            return JSON.stringify(value);
-        }
-        catch {
-            return '[object]';
-        }
-    }
-    return String(value);
-}
-function serializePayload(payload) {
-    if (payload === undefined) {
-        return '';
-    }
-    if (typeof payload === 'string') {
-        return payload;
-    }
-    try {
-        return JSON.stringify(payload);
-    }
-    catch {
-        return String(payload);
-    }
-}
-function severityOrder(level) {
-    switch (level) {
-        case 'debug':
-            return 0;
-        case 'info':
-            return 1;
-        case 'warn':
-            return 2;
-        case 'error':
-            return 3;
-        default:
-            return 1;
-    }
-}
-function mapConsoleTypeToLevel(type) {
-    const normalized = type.toLowerCase();
-    if (normalized === 'debug')
-        return 'debug';
-    if (normalized === 'warning' || normalized === 'warn')
-        return 'warn';
-    if (normalized === 'error' || normalized === 'assert' || normalized === 'trace')
-        return 'error';
-    return 'info';
-}
-function shouldEmit(level, threshold) {
-    return severityOrder(level) >= severityOrder(threshold);
-}
-function normalizeComparableUrl(rawUrl) {
-    const parsed = new URL(rawUrl);
-    const pathname = parsed.pathname.replace(/\/+$/, '') || '/';
-    return `${parsed.origin}${pathname}`;
-}
-function resolveAutomationOrigin(targetUrl) {
-    const parsed = new URL(targetUrl);
-    return parsed.searchParams.get('launchCheck') === '1' ? parsed.origin : null;
-}
-function normalizeHostedLaunchStatePayload(payload) {
-    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
-        return null;
-    }
-    const state = typeof payload.state === 'string'
-        ? payload.state.trim().toLowerCase()
-        : '';
-    if (state === 'ready') {
-        return { state: 'ready' };
-    }
-    if (state === 'login_required') {
-        return { state: 'login_required' };
-    }
-    if (state === 'controller_required') {
-        return { state: 'controller_required' };
-    }
-    if (state === 'surface_unsupported') {
-        return { state: 'surface_unsupported' };
-    }
-    if (state !== 'error') {
-        return null;
-    }
-    const errorCode = typeof payload.errorCode === 'string'
-        ? payload.errorCode.trim() || null
-        : null;
-    const message = typeof payload.message === 'string'
-        ? payload.message.trim() || null
-        : null;
-    return {
-        state: 'error',
-        errorCode,
-        message,
-    };
-}
-function formatHostedLaunchError(state) {
-    const parts = ['Hosted app failed to launch.'];
-    if (state.errorCode) {
-        parts.push(`errorCode=${state.errorCode}.`);
-    }
-    if (state.message) {
-        parts.push(state.message);
-    }
-    return parts.join(' ');
-}
-function formatHostedLaunchStateMismatch(actualState, expectedState) {
-    if (expectedState === "login_required") {
-        return `Hosted app reported ${actualState} instead of login_required.`;
-    }
-    if (expectedState === "controller_required") {
-        return `Hosted app reported ${actualState} instead of controller_required.`;
-    }
-    if (expectedState === "surface_unsupported") {
-        return `Hosted app reported ${actualState} instead of surface_unsupported.`;
-    }
-    return `Hosted app reported ${actualState} instead of ready.`;
-}
-function shouldSettleHostedLaunchWaiter(state, expectedState) {
-    if (state.state === "error" || !expectedState) {
-        return true;
-    }
-    return state.state === expectedState;
-}
-function shouldAssertHostedVisualReadiness(input) {
-    return Boolean(input.requireHostedLaunchReady) && (input.expectedHostedLaunchState ?? 'ready') === 'ready';
-}
-function summarizeRgbaPixels(pixels, pixelCount, channels) {
-    let bgR = 0;
-    let bgG = 0;
-    let bgB = 0;
-    const edge = Math.max(1, Math.round(Math.sqrt(pixelCount)));
-    const cornerIndexes = [
-        0,
-        edge - 1,
-        edge * (edge - 1),
-        (edge * edge) - 1,
-    ].filter(index => index >= 0 && index < pixelCount);
-    for (const index of cornerIndexes) {
-        const offset = index * channels;
-        bgR += pixels[offset] ?? 0;
-        bgG += pixels[offset + 1] ?? 0;
-        bgB += pixels[offset + 2] ?? 0;
-    }
-    bgR /= cornerIndexes.length || 1;
-    bgG /= cornerIndexes.length || 1;
-    bgB /= cornerIndexes.length || 1;
-    let minLuma = 255;
-    let maxLuma = 0;
-    let foreground = 0;
-    let opaque = 0;
-    for (let index = 0; index < pixelCount; index += 1) {
-        const offset = index * channels;
-        const r = pixels[offset] ?? 0;
-        const g = pixels[offset + 1] ?? 0;
-        const b = pixels[offset + 2] ?? 0;
-        const alpha = channels >= 4 ? pixels[offset + 3] ?? 255 : 255;
-        if (alpha > 8) {
-            opaque += 1;
-        }
-        const luma = (0.2126 * r) + (0.7152 * g) + (0.0722 * b);
-        minLuma = Math.min(minLuma, luma);
-        maxLuma = Math.max(maxLuma, luma);
-        const distance = Math.hypot(r - bgR, g - bgG, b - bgB);
-        if (distance >= CANVAS_BACKGROUND_DISTANCE_THRESHOLD && alpha > 8) {
-            foreground += 1;
-        }
-    }
-    const foregroundRatio = foreground / pixelCount;
-    const opaqueRatio = opaque / pixelCount;
-    const colorRange = maxLuma - minLuma;
-    return {
-        foregroundRatio,
-        colorRange,
-        opaqueRatio,
-        pass: opaqueRatio > 0.05
-            && (foregroundRatio >= MIN_CANVAS_FOREGROUND_RATIO || colorRange >= MIN_CANVAS_COLOR_RANGE),
-    };
-}
-async function summarizeVisibleCanvases(frame) {
-    return await frame.evaluate((config) => {
-        const canvases = Array.from(document.querySelectorAll('canvas'));
-        const visibleCanvases = canvases.filter((canvas) => {
-            const rect = canvas.getBoundingClientRect();
-            const style = window.getComputedStyle(canvas);
-            const opacity = Number.parseFloat(style.opacity || '1');
-            return rect.width >= config.minEdge
-                && rect.height >= config.minEdge
-                && style.display !== 'none'
-                && style.visibility !== 'hidden'
-                && opacity > 0.05;
-        });
-        const summaries = visibleCanvases.map((canvas) => {
-            const rect = canvas.getBoundingClientRect();
-            const sample = document.createElement('canvas');
-            sample.width = config.sampleSize;
-            sample.height = config.sampleSize;
-            const context = sample.getContext('2d', { willReadFrequently: true });
-            if (!context) {
-                return {
-                    x: Math.round(rect.left),
-                    y: Math.round(rect.top),
-                    width: Math.round(rect.width),
-                    height: Math.round(rect.height),
-                    foregroundRatio: 0,
-                    colorRange: 0,
-                    opaqueRatio: 0,
-                    readable: false,
-                    pass: false,
-                    error: 'canvas_2d_context_unavailable',
-                };
-            }
-            try {
-                context.drawImage(canvas, 0, 0, config.sampleSize, config.sampleSize);
-                const pixels = context.getImageData(0, 0, config.sampleSize, config.sampleSize).data;
-                const cornerIndexes = [
-                    0,
-                    config.sampleSize - 1,
-                    config.sampleSize * (config.sampleSize - 1),
-                    (config.sampleSize * config.sampleSize) - 1,
-                ];
-                let bgR = 0;
-                let bgG = 0;
-                let bgB = 0;
-                for (const index of cornerIndexes) {
-                    const offset = index * 4;
-                    bgR += pixels[offset] ?? 0;
-                    bgG += pixels[offset + 1] ?? 0;
-                    bgB += pixels[offset + 2] ?? 0;
-                }
-                bgR /= cornerIndexes.length;
-                bgG /= cornerIndexes.length;
-                bgB /= cornerIndexes.length;
-                let minLuma = 255;
-                let maxLuma = 0;
-                let foreground = 0;
-                let opaque = 0;
-                const total = config.sampleSize * config.sampleSize;
-                for (let offset = 0; offset < pixels.length; offset += 4) {
-                    const r = pixels[offset] ?? 0;
-                    const g = pixels[offset + 1] ?? 0;
-                    const b = pixels[offset + 2] ?? 0;
-                    const alpha = pixels[offset + 3] ?? 0;
-                    if (alpha > 8) {
-                        opaque += 1;
-                    }
-                    const luma = (0.2126 * r) + (0.7152 * g) + (0.0722 * b);
-                    minLuma = Math.min(minLuma, luma);
-                    maxLuma = Math.max(maxLuma, luma);
-                    const distance = Math.hypot(r - bgR, g - bgG, b - bgB);
-                    if (distance >= config.backgroundDistanceThreshold && alpha > 8) {
-                        foreground += 1;
-                    }
-                }
-                const foregroundRatio = foreground / total;
-                const opaqueRatio = opaque / total;
-                const colorRange = maxLuma - minLuma;
-                return {
-                    x: Math.round(rect.left),
-                    y: Math.round(rect.top),
-                    width: Math.round(rect.width),
-                    height: Math.round(rect.height),
-                    foregroundRatio,
-                    colorRange,
-                    opaqueRatio,
-                    readable: true,
-                    pass: opaqueRatio > 0.05
-                        && (foregroundRatio >= config.minForegroundRatio || colorRange >= config.minColorRange),
-                };
-            }
-            catch (error) {
-                return {
-                    x: Math.round(rect.left),
-                    y: Math.round(rect.top),
-                    width: Math.round(rect.width),
-                    height: Math.round(rect.height),
-                    foregroundRatio: 0,
-                    colorRange: 0,
-                    opaqueRatio: 0,
-                    readable: false,
-                    pass: false,
-                    error: error instanceof Error ? error.message : String(error),
-                };
-            }
-        });
-        return {
-            canvasCount: canvases.length,
-            visibleCanvasCount: visibleCanvases.length,
-            readableCanvasCount: summaries.filter((summary) => summary.readable).length,
-            passingCanvasCount: summaries.filter((summary) => summary.pass).length,
-            canvases: summaries,
-        };
-    }, {
-        sampleSize: CANVAS_VISUAL_SAMPLE_SIZE,
-        minEdge: MIN_VISIBLE_CANVAS_EDGE_PX,
-        minForegroundRatio: MIN_CANVAS_FOREGROUND_RATIO,
-        minColorRange: MIN_CANVAS_COLOR_RANGE,
-        backgroundDistanceThreshold: CANVAS_BACKGROUND_DISTANCE_THRESHOLD,
-    });
-}
-function formatCanvasVisualSummary(summary) {
-    const readable = summary.canvases.filter(canvas => canvas.readable);
-    const first = readable[0];
-    if (!first) {
-        return `${summary.visibleCanvasCount} visible canvas(es), none readable`;
-    }
-    return `${summary.visibleCanvasCount} visible canvas(es), foregroundRatio=${first.foregroundRatio.toFixed(3)}, colorRange=${first.colorRange.toFixed(1)}, opaqueRatio=${first.opaqueRatio.toFixed(3)}`;
-}
-async function getFramePageOffset(frame) {
-    try {
-        const element = await frame.frameElement();
-        try {
-            const box = await element.boundingBox();
-            return box ? { x: box.x, y: box.y } : null;
-        }
-        finally {
-            await element.dispose().catch(() => { });
-        }
-    }
-    catch {
-        return null;
-    }
-}
-function buildCanvasScreenshotClip(frameOffset, canvas, viewport) {
-    if (!Number.isFinite(canvas.x) || !Number.isFinite(canvas.y)) {
-        return null;
-    }
-    const x = Math.max(0, frameOffset.x + Number(canvas.x));
-    const y = Math.max(0, frameOffset.y + Number(canvas.y));
-    const viewportWidth = viewport?.width ?? Number.POSITIVE_INFINITY;
-    const viewportHeight = viewport?.height ?? Number.POSITIVE_INFINITY;
-    const width = Math.min(canvas.width, viewportWidth - x);
-    const height = Math.min(canvas.height, viewportHeight - y);
-    if (width < MIN_VISIBLE_CANVAS_EDGE_PX || height < MIN_VISIBLE_CANVAS_EDGE_PX) {
-        return null;
-    }
-    return { x, y, width, height };
-}
-async function summarizeScreenshotClip(page, clip) {
-    try {
-        const png = await page.screenshot({ type: 'png', clip });
-        const { data, info } = await (0, sharp_1.default)(png)
-            .ensureAlpha()
-            .resize(CANVAS_VISUAL_SAMPLE_SIZE, CANVAS_VISUAL_SAMPLE_SIZE, { fit: 'fill' })
-            .raw()
-            .toBuffer({ resolveWithObject: true });
-        const pixelSummary = summarizeRgbaPixels(data, info.width * info.height, info.channels);
-        return {
-            x: Math.round(clip.x),
-            y: Math.round(clip.y),
-            width: Math.round(clip.width),
-            height: Math.round(clip.height),
-            foregroundRatio: pixelSummary.foregroundRatio,
-            colorRange: pixelSummary.colorRange,
-            opaqueRatio: pixelSummary.opaqueRatio,
-            readable: true,
-            pass: pixelSummary.pass,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-async function summarizeCanvasScreenshots(page, frames, summaries) {
-    const viewport = typeof page.viewportSize === 'function' ? page.viewportSize() : null;
-    const screenshotSummaries = [];
-    for (let index = 0; index < frames.length; index += 1) {
-        const frame = frames[index];
-        const summary = summaries[index];
-        if (!frame || !summary || summary.visibleCanvasCount === 0 || summary.passingCanvasCount > 0) {
-            continue;
-        }
-        const frameOffset = await getFramePageOffset(frame);
-        if (!frameOffset) {
-            continue;
-        }
-        for (const canvas of summary.canvases) {
-            const clip = buildCanvasScreenshotClip(frameOffset, canvas, viewport);
-            if (!clip) {
-                continue;
-            }
-            const screenshotSummary = await summarizeScreenshotClip(page, clip);
-            if (screenshotSummary) {
-                screenshotSummaries.push(screenshotSummary);
-            }
-        }
-    }
-    return screenshotSummaries;
-}
-async function runCaptureActions(page, actions) {
-    if (!actions?.length) {
-        return;
-    }
-    for (const action of actions) {
-        if (action.type === 'click') {
-            await page.mouse.click(action.x, action.y, { button: action.button ?? 'left' });
-            continue;
-        }
-        if (action.type === 'press') {
-            await page.keyboard.press(action.key);
-            continue;
-        }
-        if (action.type === 'wait') {
-            await page.waitForTimeout(action.ms);
-            continue;
-        }
-        throw new Error('capture_action_type_unknown');
-    }
-}
-async function sampleFrameRate(page, sampleMs) {
-    if (!Number.isInteger(sampleMs) || sampleMs <= 0) {
-        throw new Error('capture_fps_sample_invalid');
-    }
-    const childFrames = page.frames().filter(frame => frame.parentFrame() !== null);
-    const target = childFrames[0] ?? page;
-    const sample = await target.evaluate((durationMs) => new Promise((resolve) => {
-        const startedAt = performance.now();
-        let frameCount = 0;
-        const tick = (timestamp) => {
-            frameCount += 1;
-            const elapsedMs = Math.max(timestamp - startedAt, 0);
-            if (elapsedMs >= durationMs) {
-                resolve({
-                    fps: frameCount > 0 && elapsedMs > 0 ? frameCount * 1000 / elapsedMs : 0,
-                    sampleMs: elapsedMs,
-                    frameCount,
-                });
-                return;
-            }
-            requestAnimationFrame(tick);
-        };
-        requestAnimationFrame(tick);
-    }), sampleMs);
-    return {
-        fps: Number(sample.fps.toFixed(2)),
-        sampleMs: Math.round(sample.sampleMs),
-        frameCount: sample.frameCount,
-    };
-}
-async function assertHostedFrameVisualReadiness(page) {
-    const childFrames = page.frames().filter(frame => frame.parentFrame() !== null);
-    if (childFrames.length === 0) {
-        throw new Error('hosted_app_visual_blank: The hosted app reported ready but no game frame was available for visual validation.');
-    }
-    const summaries = await Promise.all(childFrames.map(frame => summarizeVisibleCanvases(frame)));
-    const framesWithCanvases = summaries.filter(summary => summary.visibleCanvasCount > 0);
-    if (framesWithCanvases.length === 0) {
-        return;
-    }
-    if (framesWithCanvases.some(summary => summary.passingCanvasCount > 0)) {
-        return;
-    }
-    const screenshotSummaries = await summarizeCanvasScreenshots(page, childFrames, summaries);
-    if (screenshotSummaries.some(summary => summary.pass)) {
-        return;
-    }
-    const readableFrames = framesWithCanvases.filter(summary => summary.readableCanvasCount > 0);
-    if (readableFrames.length === 0) {
-        return;
-    }
-    const screenshotDetail = screenshotSummaries.length > 0
-        ? `; screenshot foregroundRatio=${screenshotSummaries[0].foregroundRatio.toFixed(3)}, colorRange=${screenshotSummaries[0].colorRange.toFixed(1)}, opaqueRatio=${screenshotSummaries[0].opaqueRatio.toFixed(3)}`
-        : '';
-    const detail = `${readableFrames.map(formatCanvasVisualSummary).join('; ')}${screenshotDetail}`;
-    throw new Error(`hosted_app_visual_blank: The hosted app reported ready, but its visible canvas looked empty or background-only after startup. ${detail}. Make the playable objects visible in the initial ready state.`);
-}
-async function writeLogFile(logPath, lines) {
-    if (!logPath || logPath.trim().length === 0) {
-        return;
-    }
-    await (0, promises_1.mkdir)((0, node_path_1.dirname)(logPath), { recursive: true });
-    await (0, promises_1.writeFile)(logPath, `${lines.join('\n')}\n`, 'utf8');
-    console.log(`[capture] Saved logs to ${(0, node_path_1.relative)(process.cwd(), logPath) || logPath}`);
-}
-function resolveCaptureLogLevel(value) {
-    if (!value)
-        return 'info';
-    const normalized = value.trim().toLowerCase();
-    if (exports.CAPTURE_LOG_LEVEL_VALUES.includes(normalized)) {
-        return normalized;
-    }
-    throw new Error(`Unsupported log level "${value}". Choose one of: ${exports.CAPTURE_LOG_LEVEL_VALUES.join(', ')}`);
-}
-function validateCaptureTimeout(value) {
-    if (value === undefined || Number.isNaN(value)) {
-        return 5;
-    }
-    if (!Number.isFinite(value) || value <= 0) {
-        throw new Error('Timeout must be a positive number of seconds.');
-    }
-    if (value > exports.MAX_CAPTURE_TIMEOUT_SECONDS) {
-        throw new Error(`Timeout cannot exceed ${exports.MAX_CAPTURE_TIMEOUT_SECONDS} seconds (10 minutes).`);
-    }
-    return value;
-}
-async function runCapture(options) {
-    const errors = [];
-    const warnings = [];
-    const outputLines = [];
-    const expectedUrl = options.expectedUrl ? normalizeComparableUrl(options.expectedUrl) : null;
-    const expectedHostedLaunchState = options.requireHostedLaunchReady
-        ? options.expectedHostedLaunchState ?? 'ready'
-        : null;
-    const hasExplicitLogin = Boolean(options.login?.username);
-    const shouldBootstrapSavedSession = options.savedSessionBootstrap !== false && !hasExplicitLogin;
-    const bootstrapToken = shouldBootstrapSavedSession ? options.token?.trim() || null : null;
-    const bootstrapUser = shouldBootstrapSavedSession ? options.user ?? null : null;
-    let finalUrl = options.targetUrl;
-    let hostedLaunchState = null;
-    let frameRate = null;
-    const record = (level, message) => {
-        const line = `[capture][${level}] ${message}`;
-        outputLines.push(line);
-        if (level === 'error') {
-            console.error(line);
-            return;
-        }
-        if (level === 'warn') {
-            console.warn(line);
-            return;
-        }
-        if (level === 'debug') {
-            console.debug(line);
-            return;
-        }
-        console.log(line);
-    };
-    const recordError = (message) => {
-        errors.push(message);
-        record('error', message);
-    };
-    const recordWarning = (line, lineAlreadyRecorded = false) => {
-        warnings.push(line);
-        if (!lineAlreadyRecorded) {
-            outputLines.push(line);
-        }
-        if (shouldEmit('warn', options.minimumLogLevel)) {
-            console.warn(line);
-        }
-    };
-    try {
-        await (0, playwright_1.withChromiumPage)(async ({ context, page }) => {
-            const targetOrigin = new URL(options.targetUrl).origin;
-            let hostedLaunchWaiterSettled = false;
-            let resolveHostedLaunchWaiter = null;
-            const hostedLaunchWaiter = options.requireHostedLaunchReady
-                ? new Promise((resolve) => {
-                    resolveHostedLaunchWaiter = resolve;
-                })
-                : null;
-            const settleHostedLaunchWaiter = (state) => {
-                hostedLaunchState = state;
-                if (!hostedLaunchWaiter || hostedLaunchWaiterSettled) {
-                    return;
-                }
-                if (!shouldSettleHostedLaunchWaiter(state, expectedHostedLaunchState)) {
-                    return;
-                }
-                hostedLaunchWaiterSettled = true;
-                resolveHostedLaunchWaiter?.(state);
-            };
-            if (bootstrapToken) {
-                await context.addCookies((0, sessionCookie_1.buildCaptureAccessTokenCookies)(options.targetUrl, bootstrapToken));
-            }
-            if (bootstrapToken || bootstrapUser) {
-                await page.addInitScript(({ token, user }) => {
-                    try {
-                        if (token) {
-                            window.localStorage.setItem('playdrop.accessToken', token);
-                        }
-                    }
-                    catch {
-                        // ignore storage errors
-                    }
-                    try {
-                        if (user) {
-                            window.localStorage.setItem('playdrop.user', JSON.stringify(user));
-                        }
-                    }
-                    catch {
-                        // ignore storage errors
-                    }
-                    try {
-                        window.sessionStorage.removeItem('playdrop.logoutReason');
-                    }
-                    catch {
-                        // ignore storage errors
-                    }
-                }, { token: bootstrapToken, user: bootstrapUser });
-            }
-            if (options.enableCaptureBridge) {
-                await page.exposeBinding('__playdropCaptureLog', async (_source, type, payload) => {
-                    if (type === 'hosted-launch-state') {
-                        const normalizedHostedState = normalizeHostedLaunchStatePayload(payload);
-                        if (normalizedHostedState) {
-                            settleHostedLaunchWaiter(normalizedHostedState);
-                        }
-                    }
-                    const normalized = typeof type === 'string' ? type.toLowerCase() : 'info';
-                    const level = normalized === 'error' || normalized === 'fatal'
-                        ? 'error'
-                        : normalized === 'warn' || normalized === 'warning'
-                            ? 'warn'
-                            : normalized === 'debug'
-                                ? 'debug'
-                                : 'info';
-                    const serialized = serializePayload(payload);
-                    const line = ['[capture][custom]', normalized, serialized].filter(Boolean).join(' ');
-                    if (level === 'error') {
-                        errors.push(line);
-                        if (shouldEmit(level, options.minimumLogLevel)) {
-                            console.error(line);
-                        }
-                        outputLines.push(line);
-                        return;
-                    }
-                    outputLines.push(line);
-                    if (!shouldEmit(level, options.minimumLogLevel)) {
-                        return;
-                    }
-                    if (level === 'warn') {
-                        console.warn(line);
-                    }
-                    else if (level === 'debug') {
-                        console.debug(line);
-                    }
-                    else {
-                        console.log(line);
-                    }
-                });
-                await page.addInitScript(() => {
-                    window.addEventListener('unhandledrejection', event => {
-                        try {
-                            console.error('[capture][unhandledrejection]', event.reason);
-                        }
-                        catch {
-                            console.error('[capture][unhandledrejection]');
-                        }
-                    });
-                    const bridgeWindow = window;
-                    bridgeWindow.playdrop = bridgeWindow.playdrop || {};
-                    bridgeWindow.__playdropCaptureHostedLaunchState = null;
-                    const bridge = (type, payload) => {
-                        if (type === 'hosted-launch-state') {
-                            bridgeWindow.__playdropCaptureHostedLaunchState = payload;
-                        }
-                        try {
-                            const binding = bridgeWindow.__playdropCaptureLog;
-                            if (typeof binding === 'function') {
-                                binding(type, payload);
-                            }
-                        }
-                        catch (error) {
-                            console.error('[capture][bridge-error]', error);
-                        }
-                    };
-                    Object.defineProperty(bridgeWindow.playdrop, 'capture', {
-                        value: bridge,
-                        configurable: true,
-                        writable: true,
-                    });
-                });
-            }
-            const handleConsoleMessage = async (message) => {
-                const type = message.type();
-                const level = mapConsoleTypeToLevel(type);
-                const args = await Promise.all(message.args().map(arg => arg.jsonValue().catch(() => arg.toString())));
-                const rendered = args.length > 0 ? args.map(formatConsoleValue).join(' ') : message.text();
-                const line = `[capture][console:${type}] ${rendered}`;
-                outputLines.push(line);
-                let effectiveLevel = level;
-                if (level === 'warn' && line.includes('GL Driver Message')) {
-                    effectiveLevel = 'debug';
-                }
-                if (type === 'error' || type === 'assert' || type === 'trace') {
-                    const location = typeof message.location === 'function' ? message.location() : null;
-                    const locationUrl = typeof location?.url === 'string' && location.url.trim().length > 0
-                        ? location.url
-                        : null;
-                    if (isKnownGoogleTelemetryConsoleIssue(rendered, locationUrl)) {
-                        recordWarning(line, true);
-                        return;
-                    }
-                    errors.push(line);
-                    if (shouldEmit(effectiveLevel, options.minimumLogLevel)) {
-                        console.error(line);
-                    }
-                    return;
-                }
-                if (!shouldEmit(effectiveLevel, options.minimumLogLevel)) {
-                    return;
-                }
-                if (effectiveLevel === 'warn') {
-                    console.warn(line);
-                }
-                else if (effectiveLevel === 'debug') {
-                    console.debug(line);
-                }
-                else if (effectiveLevel === 'info') {
-                    console.info(line);
-                }
-                else {
-                    console.log(line);
-                }
-            };
-            page.on('console', message => {
-                void handleConsoleMessage(message).catch((error) => {
-                    const text = error instanceof Error ? error.message : String(error);
-                    recordError(`[console-handler] Failed to inspect console message: ${text}`);
-                });
-            });
-            page.on('pageerror', error => {
-                const text = error?.message ?? String(error);
-                errors.push(text);
-                outputLines.push(`[capture][pageerror] ${text}`);
-                if (shouldEmit('error', options.minimumLogLevel)) {
-                    console.error(`[capture][pageerror] ${text}`);
-                }
-            });
-            page.on('requestfailed', request => {
-                const failure = request.failure();
-                const errorText = failure?.errorText ?? '';
-                const text = `${request.method()} ${request.url()} - ${errorText || 'failed'}`;
-                if (isKnownGoogleTelemetryUrl(request.url())) {
-                    recordWarning(`[capture][requestfailed] ${text}`);
-                    return;
-                }
-                if (/ERR_ABORTED/i.test(errorText) || /ERR_HTTP2_PROTOCOL_ERROR/i.test(errorText)) {
-                    const line = `[capture][requestcancelled] ${text}`;
-                    outputLines.push(line);
-                    if (shouldEmit('debug', options.minimumLogLevel)) {
-                        console.debug(line);
-                    }
-                    return;
-                }
-                errors.push(text);
-                outputLines.push(`[capture][requestfailed] ${text}`);
-                if (shouldEmit('warn', options.minimumLogLevel)) {
-                    console.error(`[capture][requestfailed] ${text}`);
-                }
-            });
-            page.on('response', response => {
-                const status = response.status();
-                if (status < 400) {
-                    return;
-                }
-                const text = `${status} ${response.statusText()} ${response.url()}`;
-                if (status === 404 && /\\?playdrop_channel=/.test(response.url())) {
-                    const line = `[capture][response-reload] ${text}`;
-                    outputLines.push(line);
-                    if (shouldEmit('debug', options.minimumLogLevel)) {
-                        console.debug(line);
-                    }
-                    return;
-                }
-                if (isKnownGoogleTelemetryUrl(response.url())) {
-                    recordWarning(`[capture][response] ${text}`);
-                    return;
-                }
-                errors.push(text);
-                outputLines.push(`[capture][response] ${text}`);
-                if (shouldEmit('warn', options.minimumLogLevel)) {
-                    console.error(`[capture][response] ${text}`);
-                }
-            });
-            if (options.login?.username) {
-                const loginUrl = options.login.loginUrl?.trim() || `${targetOrigin}/login`;
-                record('info', `Opening login page ${loginUrl}`);
-                await page.goto(loginUrl, { waitUntil: 'domcontentloaded', timeout: 30000 });
-                await page.waitForLoadState('networkidle', { timeout: 30000 });
-                await page.fill('input[name="username"]', options.login.username);
-                await page.fill('input[name="password"]', options.login.password);
-                await page.getByRole('button', { name: 'Login' }).click();
-                await page.waitForURL((url) => {
-                    try {
-                        return !new URL(url.toString()).pathname.startsWith('/login');
-                    }
-                    catch {
-                        return false;
-                    }
-                }, { timeout: 30000 });
-                await page.waitForLoadState('networkidle', { timeout: 30000 });
-                record('info', 'Login succeeded');
-            }
-            record('info', `Opening ${options.targetUrl}`);
-            const response = await page.goto(options.targetUrl, { waitUntil: 'domcontentloaded', timeout: 30000 });
-            if (response && !response.ok()) {
-                recordError(`[navigation] ${response.status()} ${response.statusText()} ${options.targetUrl}`);
-            }
-            const readinessTimeoutMs = Math.min(Math.max(options.timeoutMs, 1000), 30000);
-            const readinessHandle = await page.waitForFunction(({ frameSelector, waitForHostedLaunchState }) => {
-                const frame = document.querySelector(frameSelector);
-                if (frame) {
-                    return 'frame';
-                }
-                if (waitForHostedLaunchState) {
-                    const state = window.__playdropCaptureHostedLaunchState;
-                    if (state && typeof state.state === 'string' && state.state.trim().length > 0) {
-                        return `hosted:${state.state.trim().toLowerCase()}`;
-                    }
-                }
-                return null;
-            }, { frameSelector: FRAME_SELECTOR, waitForHostedLaunchState: Boolean(expectedHostedLaunchState) }, { timeout: readinessTimeoutMs });
-            await readinessHandle.jsonValue();
-            const assertPageState = async () => {
-                const currentUrl = page.url();
-                if (!currentUrl) {
-                    throw new Error('Capture page did not finish loading a URL.');
-                }
-                const finalComparableUrl = normalizeComparableUrl(currentUrl);
-                if (expectedUrl && finalComparableUrl !== expectedUrl) {
-                    throw new Error(`Capture landed on ${finalComparableUrl} instead of ${expectedUrl}.`);
-                }
-                const finalPathname = new URL(currentUrl).pathname;
-                if (finalPathname.startsWith('/login')) {
-                    throw new Error(`Capture landed on the login page (${currentUrl}).`);
-                }
-                const frameCount = await page.locator(FRAME_SELECTOR).count();
-                if ((expectedHostedLaunchState ?? 'ready') === 'ready' && frameCount === 0) {
-                    throw new Error('The Playdrop app frame never appeared.');
-                }
-                if (expectedHostedLaunchState === 'login_required' && frameCount > 0) {
-                    throw new Error('The Playdrop auth gate booted the app frame unexpectedly.');
-                }
-                if (expectedHostedLaunchState === 'controller_required' && frameCount > 0) {
-                    throw new Error('The Playdrop controller gate booted the app frame unexpectedly.');
-                }
-                if (expectedHostedLaunchState === 'surface_unsupported' && frameCount > 0) {
-                    throw new Error('The Playdrop surface gate booted the app frame unexpectedly.');
-                }
-                return currentUrl;
-            };
-            if (hostedLaunchWaiter) {
-                const launchState = await Promise.race([
-                    hostedLaunchWaiter,
-                    page.waitForTimeout(options.timeoutMs).then(() => {
-                        if (hostedLaunchState && expectedHostedLaunchState && hostedLaunchState.state !== expectedHostedLaunchState) {
-                            throw new Error(formatHostedLaunchStateMismatch(hostedLaunchState.state, expectedHostedLaunchState));
-                        }
-                        throw new Error(expectedHostedLaunchState === 'login_required'
-                            ? 'Hosted app did not stop at the PlayDrop sign-in gate before the launch-check timeout.'
-                            : expectedHostedLaunchState === 'controller_required'
-                                ? 'Hosted app did not stop at the PlayDrop controller gate before the launch-check timeout.'
-                                : expectedHostedLaunchState === 'surface_unsupported'
-                                    ? 'Hosted app did not stop at the PlayDrop unsupported-surface gate before the launch-check timeout.'
-                                    : 'Hosted app did not reach the ready state before the launch-check timeout.');
-                    }),
-                ]);
-                if (launchState.state === 'error') {
-                    throw new Error(formatHostedLaunchError(launchState));
-                }
-                if (expectedHostedLaunchState && launchState.state !== expectedHostedLaunchState) {
-                    throw new Error(formatHostedLaunchStateMismatch(launchState.state, expectedHostedLaunchState));
-                }
-            }
-            finalUrl = await assertPageState();
-            await runCaptureActions(page, options.actions);
-            await page.waitForTimeout(options.settleAfterReadyMs ?? options.timeoutMs);
-            finalUrl = await assertPageState();
-            if (shouldAssertHostedVisualReadiness({
-                requireHostedLaunchReady: options.requireHostedLaunchReady,
-                expectedHostedLaunchState,
-            })) {
-                await assertHostedFrameVisualReadiness(page);
-            }
-            if (options.screenshotPath) {
-                const targetDir = (0, node_path_1.dirname)(options.screenshotPath);
-                if (targetDir && targetDir !== '.' && targetDir !== '/') {
-                    await (0, promises_1.mkdir)(targetDir, { recursive: true });
-                }
-                await page.screenshot({ path: options.screenshotPath, fullPage: true });
-                console.log(`[capture] Saved screenshot to ${(0, node_path_1.relative)(process.cwd(), options.screenshotPath) || options.screenshotPath}`);
-            }
-            if (options.frameRateSampleMs && options.frameRateSampleMs > 0) {
-                frameRate = await sampleFrameRate(page, options.frameRateSampleMs);
-                record('info', `Frame-rate sample: ${frameRate.fps.toFixed(2)} fps over ${frameRate.sampleMs}ms (${frameRate.frameCount} frames).`);
-            }
-        }, {
-            ...(options.contextOptions ?? {}),
-            automationOrigin: resolveAutomationOrigin(options.targetUrl),
-        });
-    }
-    finally {
-        await writeLogFile(options.logPath, outputLines);
-    }
-    return {
-        errorCount: errors.length,
-        errors: errors.slice(0, 10),
-        warningCount: warnings.length,
-        warnings,
-        finalUrl,
-        hostedLaunchState,
-        frameRate,
-    };
-}