@playdrop/playdrop-cli 0.11.8 → 0.12.0

package/dist/apps/loadCheck.js

@@ -0,0 +1,874 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSoftwareWebGlRenderer = isSoftwareWebGlRenderer;
+exports.normalizeProjectCheckActions = normalizeProjectCheckActions;
+exports.focusProjectCheckGameFrame = focusProjectCheckGameFrame;
+exports.dispatchProjectCheckActionsToFrame = dispatchProjectCheckActionsToFrame;
+exports.formatHostedLoadCheckFailure = formatHostedLoadCheckFailure;
+exports.runLocalHostedLoadCheck = runLocalHostedLoadCheck;
+exports.runUploadedHostedLoadCheck = runUploadedHostedLoadCheck;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const appUrls_1 = require("../appUrls");
+const devShared_1 = require("../commands/devShared");
+const dev_1 = require("../commands/dev");
+const devServer_1 = require("../commands/devServer");
+const devRuntimeAssets_1 = require("../commands/devRuntimeAssets");
+const devAuth_1 = require("../devAuth");
+const playwright_1 = require("../playwright");
+const sessionCookie_1 = require("../sessionCookie");
+const registration_1 = require("./registration");
+const FRAME_SELECTOR = 'iframe[title="Game"]';
+const DEFAULT_HOSTED_LOAD_TIMEOUT_MS = 15000;
+const POST_READY_SETTLE_MS = 750;
+const MOBILE_USER_AGENT = 'Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1';
+const LOAD_CHECK_SURFACE_ORDER = ['DESKTOP', 'MOBILE_LANDSCAPE', 'MOBILE_PORTRAIT'];
+const LOAD_CHECK_SURFACE_CONTEXT_OPTIONS = {
+    DESKTOP: {
+        viewport: { width: 1280, height: 720 },
+        deviceScaleFactor: 1,
+        isMobile: false,
+        hasTouch: false,
+    },
+    MOBILE_LANDSCAPE: {
+        viewport: { width: 896, height: 414 },
+        deviceScaleFactor: 2,
+        isMobile: true,
+        hasTouch: true,
+        userAgent: MOBILE_USER_AGENT,
+    },
+    MOBILE_PORTRAIT: {
+        viewport: { width: 414, height: 896 },
+        deviceScaleFactor: 2,
+        isMobile: true,
+        hasTouch: true,
+        userAgent: MOBILE_USER_AGENT,
+    },
+};
+const GOOGLE_TELEMETRY_HOSTS = [
+    'analytics.google.com',
+    'googletagmanager.com',
+    'google-analytics.com',
+    'googleadservices.com',
+    'doubleclick.net',
+];
+const SOFTWARE_WEBGL_RENDERER_PATTERNS = [
+    /\bswiftshader\b/i,
+    /\bllvmpipe\b/i,
+    /\bsoftware\b/i,
+    /\bswrast\b/i,
+    /\bmesa offscreen\b/i,
+    /\bsoftpipe\b/i,
+    /\bchromium rasterizer\b/i,
+];
+function isHostOrSubdomain(hostname, domain) {
+    return hostname === domain || hostname.endsWith(`.${domain}`);
+}
+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));
+}
+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 === '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 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 normalizeLoadCheckSurface(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const normalized = value.trim().toUpperCase();
+    return LOAD_CHECK_SURFACE_ORDER.includes(normalized)
+        ? normalized
+        : null;
+}
+function normalizeLoadCheckSurfaceTargets(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return Array.from(new Set(value.map(normalizeLoadCheckSurface).filter((entry) => Boolean(entry))));
+}
+function resolveLoadCheckSurface(surfaceTargets) {
+    const targets = normalizeLoadCheckSurfaceTargets(surfaceTargets);
+    for (const surface of LOAD_CHECK_SURFACE_ORDER) {
+        if (targets.includes(surface)) {
+            return surface;
+        }
+    }
+    return 'DESKTOP';
+}
+function cloneLoadCheckContextOptions(surface) {
+    const source = LOAD_CHECK_SURFACE_CONTEXT_OPTIONS[surface];
+    return {
+        ...source,
+        viewport: source.viewport ? { ...source.viewport } : source.viewport,
+    };
+}
+function resolvePostAuthHostedLaunchState(controllerMode) {
+    return controllerMode === 'REQUIRED' ? 'controller_required' : 'ready';
+}
+function resolveAnonymousHostedLaunchState(input) {
+    const surfaceTargets = normalizeLoadCheckSurfaceTargets(input.surfaceTargets);
+    if (!surfaceTargets.includes(input.captureSurface)) {
+        return 'surface_unsupported';
+    }
+    if (input.authMode === 'REQUIRED') {
+        return 'login_required';
+    }
+    return resolvePostAuthHostedLaunchState(input.controllerMode);
+}
+function normalizeLoadCheckMessage(message) {
+    const normalized = typeof message === 'string' ? message.trim() : '';
+    return normalized || 'Hosted app failed to launch.';
+}
+function buildPassedLoadCheckResult(input) {
+    return {
+        status: 'PASSED',
+        errorCode: null,
+        message: null,
+        checkedAt: new Date().toISOString(),
+        artifactFingerprint: input.artifactFingerprint,
+        screenshotPath: input.screenshotPath ?? null,
+        webglRenderer: input.webglRenderer ?? null,
+        targetUrl: input.targetUrl ?? null,
+        warnings: input.warnings ?? [],
+        errors: [],
+    };
+}
+function buildFailedLoadCheckResult(errorCode, message, artifactFingerprint, extra = {}) {
+    return {
+        status: 'FAILED',
+        errorCode,
+        message,
+        checkedAt: new Date().toISOString(),
+        artifactFingerprint,
+        screenshotPath: extra.screenshotPath ?? null,
+        webglRenderer: extra.webglRenderer ?? null,
+        targetUrl: extra.targetUrl ?? null,
+        errors: extra.errors ?? [],
+        warnings: extra.warnings ?? [],
+    };
+}
+function formatLoadCheckErrors(errors) {
+    if (!Array.isArray(errors) || errors.length === 0) {
+        return '';
+    }
+    const normalized = errors
+        .map((entry) => entry.replace(/\s+/g, ' ').trim())
+        .filter(Boolean)
+        .slice(0, 3)
+        .map((entry) => entry.length > 240 ? `${entry.slice(0, 237)}...` : entry);
+    if (normalized.length === 0) {
+        return '';
+    }
+    return ` First error${normalized.length === 1 ? '' : 's'}: ${normalized.join(' | ')}`;
+}
+function isSoftwareWebGlRenderer(renderer) {
+    const normalized = typeof renderer === 'string' ? renderer.trim() : '';
+    return normalized.length > 0 && SOFTWARE_WEBGL_RENDERER_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+function normalizeProjectCheckActions(value) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error('project_check_actions_invalid: expected a JSON array.');
+    }
+    return value.map((entry, index) => {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            throw new Error(`project_check_action_invalid:${index}`);
+        }
+        const type = typeof entry.type === 'string'
+            ? entry.type.trim().toLowerCase()
+            : '';
+        if (type === 'click') {
+            const x = Number(entry.x);
+            const y = Number(entry.y);
+            if (!Number.isFinite(x) || !Number.isFinite(y)) {
+                throw new Error(`project_check_action_invalid:${index}:click_coordinates_required`);
+            }
+            const rawButton = typeof entry.button === 'string'
+                ? entry.button.trim().toLowerCase()
+                : '';
+            const button = rawButton === 'right' || rawButton === 'middle' ? rawButton : 'left';
+            return { type: 'click', x, y, button };
+        }
+        if (type === 'press') {
+            const key = typeof entry.key === 'string'
+                ? entry.key.trim()
+                : '';
+            if (!key) {
+                throw new Error(`project_check_action_invalid:${index}:key_required`);
+            }
+            return { type: 'press', key };
+        }
+        if (type === 'wait') {
+            const ms = Number(entry.ms);
+            if (!Number.isInteger(ms) || ms < 0 || ms > 60000) {
+                throw new Error(`project_check_action_invalid:${index}:wait_ms_invalid`);
+            }
+            return { type: 'wait', ms };
+        }
+        throw new Error(`project_check_action_type_unknown:${index}`);
+    });
+}
+async function focusProjectCheckGameFrame(page, frame) {
+    const element = await frame.frameElement();
+    try {
+        await element.scrollIntoViewIfNeeded().catch(() => { });
+        const box = await element.boundingBox();
+        if (!box) {
+            throw new Error('project_check_game_frame_not_visible');
+        }
+        await page.mouse.click(box.x + (box.width / 2), box.y + (box.height / 2), { button: 'left' });
+        await frame.evaluate(() => window.focus()).catch(() => { });
+        return box;
+    }
+    finally {
+        await element.dispose().catch(() => { });
+    }
+}
+async function dispatchProjectCheckActionsToFrame(page, frame, actions) {
+    for (const action of actions) {
+        if (action.type === 'wait') {
+            await page.waitForTimeout(action.ms);
+            continue;
+        }
+        const box = await focusProjectCheckGameFrame(page, frame);
+        if (action.type === 'click') {
+            await page.mouse.click(box.x + action.x, box.y + action.y, { button: action.button ?? 'left' });
+            continue;
+        }
+        if (action.type === 'press') {
+            await page.keyboard.press(action.key);
+            continue;
+        }
+        throw new Error('project_check_action_type_unknown');
+    }
+}
+async function findGameFrame(page, timeoutMs) {
+    const handle = await page.waitForSelector(FRAME_SELECTOR, { timeout: timeoutMs });
+    const frame = await handle.contentFrame();
+    await handle.dispose().catch(() => { });
+    if (!frame) {
+        throw new Error('project_check_game_frame_missing');
+    }
+    return frame;
+}
+async function readWebGlRenderer(frame) {
+    const renderer = await frame.evaluate(() => {
+        const canvas = document.createElement('canvas');
+        const gl = (canvas.getContext('webgl2') || canvas.getContext('webgl') || canvas.getContext('experimental-webgl'));
+        if (!gl) {
+            return '';
+        }
+        const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
+        if (debugInfo) {
+            const unmaskedRenderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
+            if (typeof unmaskedRenderer === 'string' && unmaskedRenderer.trim()) {
+                return unmaskedRenderer;
+            }
+        }
+        const rendererValue = gl.getParameter(gl.RENDERER);
+        return typeof rendererValue === 'string' ? rendererValue : String(rendererValue ?? '');
+    });
+    const normalized = typeof renderer === 'string' ? renderer.trim() : '';
+    if (!normalized) {
+        throw new Error('project_check_webgl_renderer_missing');
+    }
+    return normalized;
+}
+async function saveScreenshot(page, screenshotPath) {
+    const normalizedPath = typeof screenshotPath === 'string' ? screenshotPath.trim() : '';
+    if (!normalizedPath) {
+        return null;
+    }
+    await (0, promises_1.mkdir)((0, node_path_1.dirname)(normalizedPath), { recursive: true });
+    await page.screenshot({ path: normalizedPath, fullPage: true });
+    console.log(`[check] Saved screenshot to ${(0, node_path_1.relative)(process.cwd(), normalizedPath) || normalizedPath}`);
+    return normalizedPath;
+}
+function normalizeLoadCheckFailure(error, artifactFingerprint) {
+    const rawMessage = error instanceof Error ? error.message : String(error);
+    const message = normalizeLoadCheckMessage(rawMessage);
+    const errorCodeMatch = message.match(/\berrorCode=([a-z0-9_]+)\b/i);
+    if (errorCodeMatch?.[1]) {
+        return buildFailedLoadCheckResult(errorCodeMatch[1], message, artifactFingerprint);
+    }
+    const prefixedCodeMatch = message.match(/^([a-z0-9_]+):/i);
+    if (prefixedCodeMatch?.[1]
+        && (prefixedCodeMatch[1].startsWith('hosted_app_')
+            || prefixedCodeMatch[1].startsWith('local_dev_')
+            || prefixedCodeMatch[1].startsWith('dev_auth_')
+            || prefixedCodeMatch[1].startsWith('project_check_'))) {
+        return buildFailedLoadCheckResult(prefixedCodeMatch[1], message, artifactFingerprint);
+    }
+    if (/missing_init\b/i.test(message) || /hosted_app_missing_client_init:/i.test(message)) {
+        return buildFailedLoadCheckResult('missing_init', message, artifactFingerprint);
+    }
+    if (/missing_ready\b/i.test(message) || /hosted_app_missing_ready:/i.test(message)) {
+        return buildFailedLoadCheckResult('missing_ready', message, artifactFingerprint);
+    }
+    if (/sdk_mismatch\b/i.test(message) || /hosted_app_sdk_version_mismatch:/i.test(message)) {
+        return buildFailedLoadCheckResult('sdk_mismatch', message, artifactFingerprint);
+    }
+    if (/software renderer|swiftshader|webgl_renderer_software/i.test(message)) {
+        return buildFailedLoadCheckResult('webgl_renderer_software', message, artifactFingerprint);
+    }
+    return buildFailedLoadCheckResult('startup_failure', message, artifactFingerprint);
+}
+function formatHostedLoadCheckFailure(taskName, result, scope = 'local') {
+    const scopeLabel = scope === 'final'
+        ? 'final owner play route'
+        : scope === 'staged'
+            ? 'staged upload preview'
+            : 'local hosted preview';
+    const errorCode = result.errorCode?.trim() || 'startup_failure';
+    const message = normalizeLoadCheckMessage(result.message);
+    return `hosted_load_check_failed: ${taskName} failed the ${scopeLabel} check (${errorCode}). ${message}`;
+}
+async function runHostedLoadCheck(options) {
+    const expectedHostedLaunchState = options.expectedHostedLaunchState ?? 'ready';
+    const artifactFingerprint = options.artifactFingerprint ?? null;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_HOSTED_LOAD_TIMEOUT_MS;
+    const errors = [];
+    const warnings = [];
+    let finalUrl = options.targetUrl;
+    let screenshotPath = null;
+    let webglRenderer = null;
+    try {
+        await (0, playwright_1.withInstalledChromePage)(async ({ context, page }) => {
+            const hasExplicitToken = Boolean(options.token?.trim());
+            const shouldBootstrapSavedSession = options.savedSessionBootstrap !== false && hasExplicitToken;
+            const bootstrapToken = shouldBootstrapSavedSession ? options.token?.trim() || null : null;
+            const bootstrapUser = shouldBootstrapSavedSession ? options.user ?? null : null;
+            let hostedLaunchWaiterSettled = false;
+            let resolveHostedLaunchWaiter = null;
+            const hostedLaunchWaiter = new Promise((resolve) => {
+                resolveHostedLaunchWaiter = resolve;
+            });
+            const settleHostedLaunchWaiter = (state) => {
+                if (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 {
+                        // Storage can be blocked by browser policy; the cookie remains authoritative.
+                    }
+                    try {
+                        if (user) {
+                            window.localStorage.setItem('playdrop.user', JSON.stringify(user));
+                        }
+                    }
+                    catch {
+                        // Storage can be blocked by browser policy; the cookie remains authoritative.
+                    }
+                    try {
+                        window.sessionStorage.removeItem('playdrop.logoutReason');
+                    }
+                    catch {
+                        // Ignore session storage failures.
+                    }
+                }, { token: bootstrapToken, user: bootstrapUser });
+            }
+            await page.exposeBinding('__playdropCaptureLog', async (_source, type, payload) => {
+                if (type === 'hosted-launch-state') {
+                    const normalizedHostedState = normalizeHostedLaunchStatePayload(payload);
+                    if (normalizedHostedState) {
+                        settleHostedLaunchWaiter(normalizedHostedState);
+                    }
+                }
+                const serialized = serializePayload(payload);
+                const line = ['[check][custom]', typeof type === 'string' ? type.toLowerCase() : 'info', serialized].filter(Boolean).join(' ');
+                console.log(line);
+            });
+            await page.addInitScript(() => {
+                window.addEventListener('unhandledrejection', (event) => {
+                    try {
+                        console.error('[check][unhandledrejection]', event.reason);
+                    }
+                    catch {
+                        console.error('[check][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('[check][bridge-error]', error);
+                    }
+                };
+                Object.defineProperty(bridgeWindow.playdrop, 'capture', {
+                    value: bridge,
+                    configurable: true,
+                    writable: true,
+                });
+            });
+            const handleConsoleMessage = async (message) => {
+                const type = message.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 = `[check][console:${type}] ${rendered}`;
+                if (type === 'error' || type === 'assert' || type === 'trace') {
+                    errors.push(line);
+                    console.error(line);
+                    return;
+                }
+                console.log(line);
+            };
+            page.on('console', (message) => {
+                void handleConsoleMessage(message).catch((error) => {
+                    const text = error instanceof Error ? error.message : String(error);
+                    errors.push(`[check][console-handler] ${text}`);
+                });
+            });
+            page.on('pageerror', (error) => {
+                const text = error?.message ?? String(error);
+                errors.push(`[check][pageerror] ${text}`);
+                console.error(`[check][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())) {
+                    warnings.push(`[check][requestfailed] ${text}`);
+                    return;
+                }
+                if (/ERR_ABORTED/i.test(errorText) || /ERR_HTTP2_PROTOCOL_ERROR/i.test(errorText)) {
+                    return;
+                }
+                errors.push(`[check][requestfailed] ${text}`);
+                console.error(`[check][requestfailed] ${text}`);
+            });
+            page.on('response', (response) => {
+                const status = response.status();
+                if (status < 400) {
+                    return;
+                }
+                const text = `${status} ${response.statusText()} ${response.url()}`;
+                if (isKnownGoogleTelemetryUrl(response.url())) {
+                    warnings.push(`[check][response] ${text}`);
+                    return;
+                }
+                errors.push(`[check][response] ${text}`);
+                console.error(`[check][response] ${text}`);
+            });
+            console.log(`[check] Opening ${options.targetUrl}`);
+            const response = await page.goto(options.targetUrl, { waitUntil: 'domcontentloaded', timeout: 30000 });
+            if (response && !response.ok()) {
+                errors.push(`[check][navigation] ${response.status()} ${response.statusText()} ${options.targetUrl}`);
+            }
+            const readinessTimeoutMs = Math.min(Math.max(timeoutMs, 1000), 30000);
+            await page.waitForFunction(({ frameSelector }) => {
+                const frame = document.querySelector(frameSelector);
+                const state = window.__playdropCaptureHostedLaunchState;
+                if (frame) {
+                    return 'frame';
+                }
+                if (state && typeof state.state === 'string' && state.state.trim().length > 0) {
+                    return `hosted:${state.state.trim().toLowerCase()}`;
+                }
+                return null;
+            }, { frameSelector: FRAME_SELECTOR }, { timeout: readinessTimeoutMs });
+            const launchState = await Promise.race([
+                hostedLaunchWaiter,
+                page.waitForTimeout(timeoutMs).then(() => {
+                    throw new Error(expectedHostedLaunchState === 'ready'
+                        ? 'hosted_app_missing_ready: Hosted app did not report ready before the load-check timeout.'
+                        : `hosted_app_gate_missing: Hosted app did not report ${expectedHostedLaunchState} before the load-check timeout.`);
+                }),
+            ]);
+            if (launchState.state === 'error') {
+                throw new Error(formatHostedLaunchError(launchState));
+            }
+            if (launchState.state !== expectedHostedLaunchState) {
+                throw new Error(formatHostedLaunchStateMismatch(launchState.state, expectedHostedLaunchState));
+            }
+            finalUrl = page.url();
+            if (expectedHostedLaunchState !== 'ready') {
+                screenshotPath = await saveScreenshot(page, options.screenshotPath);
+                return;
+            }
+            const frame = await findGameFrame(page, readinessTimeoutMs);
+            webglRenderer = await readWebGlRenderer(frame);
+            console.log(`[check] WebGL renderer: ${webglRenderer}`);
+            if (isSoftwareWebGlRenderer(webglRenderer)) {
+                throw new Error(`project_check_webgl_renderer_software: WebGL renderer is "${webglRenderer}". Real hardware acceleration is required.`);
+            }
+            if (options.actions?.length) {
+                await dispatchProjectCheckActionsToFrame(page, frame, options.actions);
+                await page.waitForTimeout(POST_READY_SETTLE_MS);
+            }
+            screenshotPath = await saveScreenshot(page, options.screenshotPath);
+        }, {
+            ...options.contextOptions,
+            automationOrigin: new URL(options.targetUrl).origin,
+        });
+    }
+    catch (error) {
+        const launchFailureMessage = error instanceof Error ? error.message : String(error);
+        if (/Failed to launch installed Google Chrome/i.test(launchFailureMessage)) {
+            throw error;
+        }
+        const normalized = normalizeLoadCheckFailure(error, artifactFingerprint);
+        return {
+            ...normalized,
+            screenshotPath,
+            webglRenderer,
+            targetUrl: finalUrl,
+            errors: errors.length > 0 ? errors : normalized.errors,
+            warnings,
+            message: normalized.message ? `${normalized.message}${formatLoadCheckErrors(errors)}` : normalized.message,
+        };
+    }
+    if (errors.length > 0) {
+        return buildFailedLoadCheckResult('startup_failure', `Hosted app emitted ${errors.length} console, page, or network error(s) during startup.${formatLoadCheckErrors(errors)}`, artifactFingerprint, {
+            screenshotPath,
+            webglRenderer,
+            targetUrl: finalUrl,
+            errors,
+            warnings,
+        });
+    }
+    return buildPassedLoadCheckResult({
+        artifactFingerprint,
+        screenshotPath,
+        webglRenderer,
+        targetUrl: finalUrl,
+        warnings,
+    });
+}
+async function startOrReuseMountedDevRuntime(input) {
+    const appTypeSlug = (0, appUrls_1.getAppTypeSlug)(input.task.type ?? 'GAME');
+    const devRouterPort = input.devRouterPort ?? devServer_1.DEV_ROUTER_PORT;
+    const runtimeAssetManifest = input.task.hostingMode === 'EXTERNAL' || input.task.externalUrl
+        ? (0, devRuntimeAssets_1.createEmptyDevRuntimeAssetManifest)()
+        : await (0, devRuntimeAssets_1.buildDevRuntimeAssetManifest)({
+            client: input.client,
+            apiBase: input.apiBase,
+            task: input.task,
+            creatorUsername: input.creatorUsername,
+            appBaseUrl: `http://127.0.0.1:${devRouterPort}/apps/dev/${encodeURIComponent(input.creatorUsername)}/${encodeURIComponent(appTypeSlug)}/${encodeURIComponent(input.task.name)}/`,
+        });
+    const serverAlreadyRunning = await (0, devServer_1.isDevServerAvailable)({
+        creatorUsername: input.creatorUsername,
+        appType: appTypeSlug,
+        appName: input.task.name,
+        port: devRouterPort,
+    }, 750);
+    if (serverAlreadyRunning) {
+        await (0, devServer_1.updateMountedDevRuntimeAssetManifest)({
+            creatorUsername: input.creatorUsername,
+            appName: input.task.name,
+            runtimeAssetManifest,
+            port: devRouterPort,
+        });
+        return { handle: null, runtimeAssetManifest };
+    }
+    try {
+        const handle = await (0, devServer_1.startDevServer)({
+            appName: input.task.name,
+            appType: appTypeSlug,
+            creatorUsername: input.creatorUsername,
+            htmlPath: input.task.filePath,
+            port: devRouterPort,
+            projectInfo: (0, devShared_1.findProjectInfo)(input.task.filePath),
+            runtimeAssetManifest,
+        });
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        return { handle, runtimeAssetManifest };
+    }
+    catch (error) {
+        const formatted = (0, dev_1.formatDevRuntimeAssetManifestFailure)(error);
+        const mountConflict = (0, devServer_1.parseMountConflictError)(error instanceof Error ? error.message : '');
+        if (mountConflict) {
+            throw new Error(`A different dev session already owns ${mountConflict.ref}. Active owner pid: ${mountConflict.ownerPid}.`);
+        }
+        throw new Error(formatted.message);
+    }
+}
+async function runLocalHostedLoadCheck(input) {
+    let mountedRuntime = null;
+    try {
+        mountedRuntime = await startOrReuseMountedDevRuntime({
+            client: input.client,
+            apiBase: input.apiBase,
+            creatorUsername: input.creatorUsername,
+            task: input.task,
+            devRouterPort: input.devRouterPort,
+        });
+        const localDevPort = input.devRouterPort === undefined || input.devRouterPort === devServer_1.DEV_ROUTER_PORT
+            ? null
+            : input.devRouterPort;
+        const localAppMetadata = mountedRuntime.runtimeAssetManifest.response.localAppMetadata;
+        const captureSurface = resolveLoadCheckSurface(localAppMetadata.surfaceTargets);
+        const contextOptions = cloneLoadCheckContextOptions(captureSurface);
+        const anonymousExpectedState = resolveAnonymousHostedLaunchState({
+            ...localAppMetadata,
+            captureSurface,
+        });
+        if (anonymousExpectedState === 'login_required') {
+            const registeredApp = await (0, registration_1.fetchRegisteredAppShell)(input.client, input.creatorUsername, input.task.name);
+            const canLaunchUnregisteredViewer = input.allowUnregisteredViewerLaunch === true
+                && Boolean(input.token)
+                && Boolean(input.currentUser);
+            if (!registeredApp?.id && !canLaunchUnregisteredViewer) {
+                return buildFailedLoadCheckResult('app_registration_required_for_auth_validation', `Auth-required hosted app "${input.task.name}" must be registered on PlayDrop before viewer load-check can run. Run "playdrop project create app ${input.task.name}" and try again.`, null);
+            }
+            const anonymousGateResult = await runHostedLoadCheck({
+                targetUrl: (0, appUrls_1.buildPlatformDevUrl)(input.webBase, {
+                    creatorUsername: input.creatorUsername,
+                    appName: input.task.name,
+                    appType: input.task.type ?? 'GAME',
+                    devAuth: 'anonymous',
+                    launchCheck: true,
+                    localDevPort,
+                }),
+                timeoutMs: input.timeoutMs,
+                expectedHostedLaunchState: anonymousExpectedState,
+                contextOptions,
+            });
+            if (anonymousGateResult.status !== 'PASSED') {
+                return anonymousGateResult;
+            }
+            return await runHostedLoadCheck({
+                targetUrl: (0, appUrls_1.buildPlatformDevUrl)(input.webBase, {
+                    creatorUsername: input.creatorUsername,
+                    appName: input.task.name,
+                    appType: input.task.type ?? 'GAME',
+                    devAuth: 'viewer',
+                    launchCheck: true,
+                    localDevPort,
+                }),
+                timeoutMs: input.timeoutMs,
+                expectedHostedLaunchState: resolvePostAuthHostedLaunchState(localAppMetadata.controllerMode),
+                token: input.token ?? null,
+                user: input.currentUser ?? null,
+                savedSessionBootstrap: true,
+                contextOptions,
+                screenshotPath: input.screenshotPath,
+                actions: input.actions,
+            });
+        }
+        return await runHostedLoadCheck({
+            targetUrl: (0, appUrls_1.buildPlatformDevUrl)(input.webBase, {
+                creatorUsername: input.creatorUsername,
+                appName: input.task.name,
+                appType: input.task.type ?? 'GAME',
+                devAuth: 'anonymous',
+                launchCheck: true,
+                localDevPort,
+            }),
+            timeoutMs: input.timeoutMs,
+            expectedHostedLaunchState: anonymousExpectedState,
+            contextOptions,
+            screenshotPath: input.screenshotPath,
+            actions: input.actions,
+        });
+    }
+    finally {
+        if (mountedRuntime?.handle) {
+            await mountedRuntime.handle.close().catch(() => { });
+        }
+    }
+}
+function appendLoadCheckParams(targetUrl, devAuth) {
+    return (0, devAuth_1.applyHostedDevAuthSelectionToUrl)(targetUrl, {
+        devAuth,
+        player: null,
+    });
+}
+async function runUploadedHostedLoadCheck(input) {
+    const preview = await input.client.fetchAppUploadLaunchCheckPreview(input.creatorUsername, input.task.name, input.sessionId);
+    const captureSurface = resolveLoadCheckSurface(preview.localAppMetadata.surfaceTargets);
+    const contextOptions = cloneLoadCheckContextOptions(captureSurface);
+    const anonymousExpectedState = resolveAnonymousHostedLaunchState({
+        ...preview.localAppMetadata,
+        captureSurface,
+    });
+    let result;
+    if (anonymousExpectedState === 'login_required') {
+        if (!preview.app?.id) {
+            result = buildFailedLoadCheckResult('app_registration_required_for_auth_validation', `Auth-required hosted app "${input.task.name}" must be registered on PlayDrop before viewer load-check can run.`, preview.session.manifestHash);
+        }
+        else {
+            const anonymousGateResult = await runHostedLoadCheck({
+                targetUrl: appendLoadCheckParams(preview.launchUrl, 'anonymous'),
+                artifactFingerprint: preview.session.manifestHash,
+                timeoutMs: input.timeoutMs,
+                expectedHostedLaunchState: anonymousExpectedState,
+                contextOptions,
+            });
+            if (anonymousGateResult.status !== 'PASSED') {
+                result = anonymousGateResult;
+            }
+            else {
+                result = await runHostedLoadCheck({
+                    targetUrl: appendLoadCheckParams(preview.launchUrl, 'viewer'),
+                    artifactFingerprint: preview.session.manifestHash,
+                    timeoutMs: input.timeoutMs,
+                    expectedHostedLaunchState: resolvePostAuthHostedLaunchState(preview.localAppMetadata.controllerMode),
+                    token: input.token ?? null,
+                    user: input.currentUser ?? null,
+                    savedSessionBootstrap: true,
+                    contextOptions,
+                    screenshotPath: input.screenshotPath,
+                });
+            }
+        }
+    }
+    else {
+        result = await runHostedLoadCheck({
+            targetUrl: appendLoadCheckParams(preview.launchUrl, 'anonymous'),
+            artifactFingerprint: preview.session.manifestHash,
+            timeoutMs: input.timeoutMs,
+            expectedHostedLaunchState: anonymousExpectedState,
+            contextOptions,
+            screenshotPath: input.screenshotPath,
+        });
+    }
+    const recorded = await input.client.recordAppUploadLaunchCheck(input.creatorUsername, input.task.name, input.sessionId, {
+        status: result.status,
+        artifactFingerprint: preview.session.manifestHash,
+        errorCode: result.errorCode,
+        message: result.message,
+    });
+    const recordedLaunchCheck = recorded.session.launchCheck;
+    if (recordedLaunchCheck.status !== 'PASSED' && recordedLaunchCheck.status !== 'FAILED') {
+        return buildFailedLoadCheckResult('startup_failure', 'Upload load-check was not recorded on the staged session.', preview.session.manifestHash);
+    }
+    return {
+        ...result,
+        status: recordedLaunchCheck.status,
+        errorCode: recordedLaunchCheck.errorCode,
+        message: recordedLaunchCheck.message,
+        checkedAt: recordedLaunchCheck.checkedAt ?? new Date().toISOString(),
+        artifactFingerprint: recordedLaunchCheck.artifactFingerprint,
+    };
+}