@playdrop/playdrop-cli 0.16.5 → 0.16.12

package/dist/apps/loadCheck.js

@@ -6,14 +6,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PLAYDROP_SURFACE_CONTEXT_OPTIONS = void 0;
 exports.formatConsoleValue = formatConsoleValue;
 exports.formatBrowserConsoleMessage = formatBrowserConsoleMessage;
+exports.isDuplicateBrowserResourceConsoleError = isDuplicateBrowserResourceConsoleError;
+exports.isExpectedAnonymousSessionProbe = isExpectedAnonymousSessionProbe;
+exports.waitForHostedLaunchState = waitForHostedLaunchState;
 exports.resolveLoadCheckSurface = resolveLoadCheckSurface;
 exports.cloneLoadCheckContextOptions = cloneLoadCheckContextOptions;
 exports.isSoftwareWebGlRenderer = isSoftwareWebGlRenderer;
 exports.dispatchPlaytestTapeToFrame = dispatchPlaytestTapeToFrame;
+exports.findGameFrame = findGameFrame;
+exports.describeHostedLaunchTimeout = describeHostedLaunchTimeout;
 exports.verifyHostedEditorPhaseRoundTrip = verifyHostedEditorPhaseRoundTrip;
 exports.formatHostedLoadCheckFailure = formatHostedLoadCheckFailure;
 exports.redactHostedLoadCheckSecrets = redactHostedLoadCheckSecrets;
 exports.runLocalHostedLoadCheck = runLocalHostedLoadCheck;
+exports.buildUploadedHostedLoadCheckUrl = buildUploadedHostedLoadCheckUrl;
+exports.buildUploadedHostedLoadCheckScreenshotPath = buildUploadedHostedLoadCheckScreenshotPath;
 exports.runUploadedHostedLoadCheck = runUploadedHostedLoadCheck;
 exports.comparePlaytestFrames = comparePlaytestFrames;
 exports.runUploadedHostedPlaytestSmokeCheck = runUploadedHostedPlaytestSmokeCheck;
@@ -37,15 +44,16 @@ var surfaceProfiles_2 = require("./surfaceProfiles");
 Object.defineProperty(exports, "PLAYDROP_SURFACE_CONTEXT_OPTIONS", { enumerable: true, get: function () { return surfaceProfiles_2.PLAYDROP_SURFACE_CONTEXT_OPTIONS; } });
 const FRAME_SELECTOR = 'iframe[title="Game"]';
 const DEFAULT_HOSTED_LOAD_TIMEOUT_MS = 15000;
+const HOSTED_LAUNCH_DIAGNOSTIC_TIMEOUT_MS = 1000;
 const PLAYTEST_INTERACTIVE_MEAN_DELTA_MIN = 0.002;
 const PLAYTEST_INTERACTIVE_CHANGED_PIXEL_RATIO_MIN = 0.01;
-const LOAD_CHECK_SURFACE_ORDER = ['DESKTOP', 'MOBILE_LANDSCAPE', 'MOBILE_PORTRAIT'];
+const LOAD_CHECK_SURFACE_ORDER = ["DESKTOP", "MOBILE_LANDSCAPE", "MOBILE_PORTRAIT"];
 const GOOGLE_TELEMETRY_HOSTS = [
-    'analytics.google.com',
-    'googletagmanager.com',
-    'google-analytics.com',
-    'googleadservices.com',
-    'doubleclick.net',
+    "analytics.google.com",
+    "googletagmanager.com",
+    "google-analytics.com",
+    "googleadservices.com",
+    "doubleclick.net",
 ];
 const SOFTWARE_WEBGL_RENDERER_PATTERNS = [
     /\bswiftshader\b/i,
@@ -68,7 +76,7 @@ function isKnownGoogleTelemetryUrl(rawUrl) {
         return false;
     }
     const hostname = parsed.hostname.toLowerCase();
-    if (hostname === 'accounts.google.com' || hostname.endsWith('.accounts.google.com')) {
+    if (hostname === "accounts.google.com" || hostname.endsWith(".accounts.google.com")) {
         return false;
     }
     return GOOGLE_TELEMETRY_HOSTS.some((domain) => isHostOrSubdomain(hostname, domain));
@@ -77,24 +85,24 @@ function formatConsoleValue(value) {
     if (value instanceof Error) {
         return `${value.name}: ${value.message}`;
     }
-    if (typeof value === 'string')
+    if (typeof value === "string")
         return value;
-    if (typeof value === 'number' || typeof value === 'boolean' || value === null) {
+    if (typeof value === "number" || typeof value === "boolean" || value === null) {
         return String(value);
     }
-    if (typeof value === 'undefined') {
-        return 'undefined';
+    if (typeof value === "undefined") {
+        return "undefined";
     }
-    if (typeof value === 'object') {
+    if (typeof value === "object") {
         const namedError = value;
-        if (typeof namedError.message === 'string') {
-            return `${typeof namedError.name === 'string' ? `${namedError.name}: ` : ''}${namedError.message}`;
+        if (typeof namedError.message === "string") {
+            return `${typeof namedError.name === "string" ? `${namedError.name}: ` : ""}${namedError.message}`;
         }
         try {
             return JSON.stringify(value);
         }
         catch {
-            return '[object]';
+            return "[object]";
         }
     }
     return String(value);
@@ -103,14 +111,29 @@ function formatBrowserConsoleMessage(values, fallbackText) {
     if (values.length === 0) {
         return fallbackText;
     }
-    const rendered = values.map(formatConsoleValue).join(' ');
-    return rendered === '{}' || rendered === '[object]' ? fallbackText : rendered;
+    const rendered = values.map(formatConsoleValue).join(" ");
+    return rendered === "{}" || rendered === "[object]" ? fallbackText : rendered;
+}
+function isDuplicateBrowserResourceConsoleError(type, message) {
+    return (type === "error" &&
+        /^Failed to load resource: the server responded with a status of \d{3}(?: \([^)]*\))?$/i.test(message.trim()));
+}
+function isExpectedAnonymousSessionProbe(input) {
+    if (input.hasExplicitToken || input.status !== 401 || input.method.toUpperCase() !== "GET") {
+        return false;
+    }
+    try {
+        return new URL(input.url).pathname === "/me";
+    }
+    catch {
+        return false;
+    }
 }
 function serializePayload(payload) {
     if (payload === undefined) {
-        return '';
+        return "";
     }
-    if (typeof payload === 'string') {
+    if (typeof payload === "string") {
         return payload;
     }
     try {
@@ -121,75 +144,74 @@ function serializePayload(payload) {
     }
 }
 function normalizeHostedLaunchStatePayload(payload) {
-    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
         return null;
     }
-    const state = typeof payload.state === 'string'
+    const state = typeof payload.state === "string"
         ? payload.state.trim().toLowerCase()
-        : '';
-    if (state === 'ready') {
-        return { state: 'ready' };
+        : "";
+    if (state === "ready") {
+        return { state: "ready" };
     }
-    if (state === 'login_required') {
-        return { state: 'login_required' };
+    if (state === "login_required") {
+        return { state: "login_required" };
     }
-    if (state === 'controller_required') {
-        return { state: 'controller_required' };
+    if (state === "controller_required") {
+        return { state: "controller_required" };
     }
-    if (state === 'surface_unsupported') {
-        return { state: 'surface_unsupported' };
+    if (state === "surface_unsupported") {
+        return { state: "surface_unsupported" };
     }
-    if (state !== 'error') {
+    if (state !== "error") {
         return null;
     }
-    const errorCode = typeof payload.errorCode === 'string'
+    const errorCode = typeof payload.errorCode === "string"
         ? payload.errorCode.trim() || null
         : null;
-    const message = typeof payload.message === 'string'
+    const message = typeof payload.message === "string"
         ? payload.message.trim() || null
         : null;
     return {
-        state: 'error',
+        state: "error",
         errorCode,
         message,
     };
 }
 function formatHostedLaunchError(state) {
-    const parts = ['Hosted app failed to launch.'];
+    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.`;
+    return parts.join(" ");
 }
 function shouldSettleHostedLaunchWaiter(state, expectedState) {
-    if (state.state === 'error' || !expectedState) {
-        return true;
-    }
-    return state.state === expectedState;
+    return state.state === "error" || state.state === expectedState;
+}
+function waitForHostedLaunchState(waiter, expectedState, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            reject(new Error(expectedState === "ready"
+                ? "hosted_app_missing_ready: instrument_error:game_ready_timeout: Hosted app did not report sdk.host.ready() before the instrument timeout."
+                : `hosted_app_gate_missing: Hosted app did not report ${expectedState} before the load-check timeout.`));
+        }, timeoutMs);
+        waiter.then((state) => {
+            clearTimeout(timeout);
+            resolve(state);
+        }, (error) => {
+            clearTimeout(timeout);
+            reject(error);
+        });
+    });
 }
 function normalizeLoadCheckSurface(value) {
-    if (typeof value !== 'string') {
+    if (typeof value !== "string") {
         return null;
     }
     const normalized = value.trim().toUpperCase();
-    return LOAD_CHECK_SURFACE_ORDER.includes(normalized)
-        ? normalized
-        : null;
+    return LOAD_CHECK_SURFACE_ORDER.includes(normalized) ? normalized : null;
 }
 function normalizeLoadCheckSurfaceTargets(value) {
     if (!Array.isArray(value)) {
@@ -208,31 +230,31 @@ function resolveLoadCheckSurface(surfaceTargets, primarySurface) {
             return surface;
         }
     }
-    return 'DESKTOP';
+    return "DESKTOP";
 }
 function cloneLoadCheckContextOptions(surface) {
     return (0, surfaceProfiles_1.clonePlaydropSurfaceContextOptions)(surface);
 }
 function resolvePostAuthHostedLaunchState(controllerMode) {
-    return controllerMode === 'REQUIRED' ? 'controller_required' : 'ready';
+    return controllerMode === "REQUIRED" ? "controller_required" : "ready";
 }
 function resolveAnonymousHostedLaunchState(input) {
     const surfaceTargets = normalizeLoadCheckSurfaceTargets(input.surfaceTargets);
     if (!surfaceTargets.includes(input.captureSurface)) {
-        return 'surface_unsupported';
+        return "surface_unsupported";
     }
-    if (input.authMode === 'REQUIRED') {
-        return 'login_required';
+    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.';
+    const normalized = typeof message === "string" ? message.trim() : "";
+    return normalized || "Hosted app failed to launch.";
 }
 function buildPassedLoadCheckResult(input) {
     return {
-        status: 'PASSED',
+        status: "PASSED",
         errorCode: null,
         message: null,
         checkedAt: new Date().toISOString(),
@@ -246,7 +268,7 @@ function buildPassedLoadCheckResult(input) {
 }
 function buildFailedLoadCheckResult(errorCode, message, artifactFingerprint, extra = {}) {
     return {
-        status: 'FAILED',
+        status: "FAILED",
         errorCode,
         message,
         checkedAt: new Date().toISOString(),
@@ -260,20 +282,20 @@ function buildFailedLoadCheckResult(errorCode, message, artifactFingerprint, ext
 }
 function formatLoadCheckErrors(errors) {
     if (!Array.isArray(errors) || errors.length === 0) {
-        return '';
+        return "";
     }
     const normalized = errors
-        .map((entry) => entry.replace(/\s+/g, ' ').trim())
+        .map((entry) => entry.replace(/\s+/g, " ").trim())
         .filter(Boolean)
         .slice(0, 3)
-        .map((entry) => entry.length > 240 ? `${entry.slice(0, 237)}...` : entry);
+        .map((entry) => (entry.length > 240 ? `${entry.slice(0, 237)}...` : entry));
     if (normalized.length === 0) {
-        return '';
+        return "";
     }
-    return ` First error${normalized.length === 1 ? '' : 's'}: ${normalized.join(' | ')}`;
+    return ` First error${normalized.length === 1 ? "" : "s"}: ${normalized.join(" | ")}`;
 }
 function isSoftwareWebGlRenderer(renderer) {
-    const normalized = typeof renderer === 'string' ? renderer.trim() : '';
+    const normalized = typeof renderer === "string" ? renderer.trim() : "";
     return normalized.length > 0 && SOFTWARE_WEBGL_RENDERER_PATTERNS.some((pattern) => pattern.test(normalized));
 }
 async function prepareProjectCheckGameFrame(frame) {
@@ -282,16 +304,18 @@ async function prepareProjectCheckGameFrame(frame) {
         await element.scrollIntoViewIfNeeded().catch(() => { });
         const box = await element.boundingBox();
         if (!box) {
-            throw new Error('project_check_game_frame_not_visible');
+            throw new Error("project_check_game_frame_not_visible");
         }
         await element.focus().catch(() => { });
-        await frame.evaluate(() => {
+        await frame
+            .evaluate(() => {
             window.focus();
             if (document.body) {
                 document.body.tabIndex = document.body.tabIndex >= 0 ? document.body.tabIndex : -1;
                 document.body.focus();
             }
-        }).catch(() => { });
+        })
+            .catch(() => { });
         return box;
     }
     finally {
@@ -300,12 +324,12 @@ async function prepareProjectCheckGameFrame(frame) {
 }
 function resolveTapePoint(box, event) {
     return {
-        x: box.x + (event.x * box.width),
-        y: box.y + (event.y * box.height),
+        x: box.x + event.x * box.width,
+        y: box.y + event.y * box.height,
     };
 }
 async function dispatchTouchPoints(session, type, points) {
-    await session.send('Input.dispatchTouchEvent', {
+    await session.send("Input.dispatchTouchEvent", {
         type,
         touchPoints: Array.from(points.entries()).map(([id, point]) => ({
             id,
@@ -319,7 +343,7 @@ async function dispatchTouchPoints(session, type, points) {
 }
 async function dispatchPlaytestTapeToFrame(page, frame, surface, tape, hooks = {}) {
     const box = await prepareProjectCheckGameFrame(frame);
-    const mobile = surface !== 'DESKTOP';
+    const mobile = surface !== "DESKTOP";
     const session = mobile ? await page.context().newCDPSession(page) : null;
     const touchPoints = new Map();
     const startedAt = Date.now();
@@ -331,71 +355,71 @@ async function dispatchPlaytestTapeToFrame(page, frame, surface, tape, hooks = {
                 if (waitMs > 0) {
                     await page.waitForTimeout(waitMs);
                 }
-                if (event.type === 'keyDown') {
+                if (event.type === "keyDown") {
                     await page.keyboard.down(event.key);
                     continue;
                 }
-                if (event.type === 'keyUp') {
+                if (event.type === "keyUp") {
                     await page.keyboard.up(event.key);
                     continue;
                 }
-                if (!('x' in event) || !('y' in event)) {
+                if (!("x" in event) || !("y" in event)) {
                     throw new Error(`project_check_playtest_event_unsupported:${event.type}`);
                 }
                 const point = resolveTapePoint(box, event);
-                const pointerId = 'pointerId' in event ? event.pointerId ?? 0 : 0;
-                if (event.type === 'tap') {
+                const pointerId = "pointerId" in event ? (event.pointerId ?? 0) : 0;
+                if (event.type === "tap") {
                     if (mobile && session) {
                         touchPoints.set(pointerId, point);
-                        await dispatchTouchPoints(session, 'touchStart', touchPoints);
+                        await dispatchTouchPoints(session, "touchStart", touchPoints);
                         await page.waitForTimeout(event.durationMs ?? types_1.APP_PLAYTEST_DEFAULT_TAP_DURATION_MS);
                         touchPoints.delete(pointerId);
-                        await dispatchTouchPoints(session, 'touchEnd', touchPoints);
+                        await dispatchTouchPoints(session, "touchEnd", touchPoints);
                     }
                     else {
                         await page.mouse.move(point.x, point.y);
-                        await page.mouse.down({ button: 'left' });
+                        await page.mouse.down({ button: "left" });
                         await page.waitForTimeout(event.durationMs ?? types_1.APP_PLAYTEST_DEFAULT_TAP_DURATION_MS);
-                        await page.mouse.up({ button: 'left' });
+                        await page.mouse.up({ button: "left" });
                     }
                     continue;
                 }
-                if (event.type === 'pointerDown') {
+                if (event.type === "pointerDown") {
                     if (mobile && session) {
                         touchPoints.set(pointerId, point);
-                        await dispatchTouchPoints(session, 'touchStart', touchPoints);
+                        await dispatchTouchPoints(session, "touchStart", touchPoints);
                     }
                     else {
                         await page.mouse.move(point.x, point.y);
-                        await page.mouse.down({ button: 'left' });
+                        await page.mouse.down({ button: "left" });
                     }
                     continue;
                 }
-                if (event.type === 'pointerMove') {
+                if (event.type === "pointerMove") {
                     if (mobile && session) {
                         touchPoints.set(pointerId, point);
-                        await dispatchTouchPoints(session, 'touchMove', touchPoints);
+                        await dispatchTouchPoints(session, "touchMove", touchPoints);
                     }
                     else {
                         await page.mouse.move(point.x, point.y);
                     }
                     continue;
                 }
-                if (event.type === 'pointerUp') {
+                if (event.type === "pointerUp") {
                     if (mobile && session) {
                         touchPoints.delete(pointerId);
-                        await dispatchTouchPoints(session, 'touchEnd', touchPoints);
+                        await dispatchTouchPoints(session, "touchEnd", touchPoints);
                     }
                     else {
                         await page.mouse.move(point.x, point.y);
-                        await page.mouse.up({ button: 'left' });
+                        await page.mouse.up({ button: "left" });
                     }
                 }
             }
             catch (error) {
                 const detail = error instanceof Error ? error.message : String(error);
-                throw new Error(`project_check_playtest_action_failed: action ${eventIndex + 1} of ${tape.events.length} `
-                    + `(${event.type} at ${event.atMs} ms) failed: ${detail}`);
+                throw new Error(`project_check_playtest_action_failed: action ${eventIndex + 1} of ${tape.events.length} ` +
+                    `(${event.type} at ${event.atMs} ms) failed: ${detail}`);
             }
         }
         const remainingMs = tape.durationMs - (Date.now() - startedAt);
@@ -410,14 +434,47 @@ async function dispatchPlaytestTapeToFrame(page, frame, surface, tape, hooks = {
     }
 }
 async function findGameFrame(page, timeoutMs) {
-    const handle = await page.waitForSelector(FRAME_SELECTOR, { timeout: timeoutMs });
+    const handle = await page.waitForSelector(FRAME_SELECTOR, {
+        state: "attached",
+        timeout: timeoutMs,
+    });
     const frame = await handle.contentFrame();
     await handle.dispose().catch(() => { });
     if (!frame) {
-        throw new Error('project_check_game_frame_missing');
+        throw new Error("project_check_game_frame_missing");
     }
     return frame;
 }
+async function describeHostedLaunchTimeout(page, lastCapturedState = null, timeoutMs = HOSTED_LAUNCH_DIAGNOSTIC_TIMEOUT_MS) {
+    let diagnosticTimeout = null;
+    const lastCapturedStateLabel = lastCapturedState?.state ?? "none";
+    try {
+        const state = await Promise.race([
+            page.evaluate(({ frameSelector }) => {
+                const hostedState = window.__playdropCaptureHostedLaunchState;
+                return {
+                    documentReadyState: document.readyState,
+                    visibilityState: document.visibilityState,
+                    gameFrameCount: document.querySelectorAll(frameSelector).length,
+                    hostedState: typeof hostedState?.state === "string" ? hostedState.state : null,
+                };
+            }, { frameSelector: FRAME_SELECTOR }),
+            new Promise((_resolve, reject) => {
+                diagnosticTimeout = setTimeout(() => reject(new Error("diagnostic_timeout")), timeoutMs);
+            }),
+        ]);
+        return `[check][timeout] lastCapturedState=${lastCapturedStateLabel} documentReadyState=${state.documentReadyState} visibilityState=${state.visibilityState} gameFrameCount=${state.gameFrameCount} hostedState=${state.hostedState ?? "none"}`;
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        return `[check][timeout] lastCapturedState=${lastCapturedStateLabel} pageStateUnavailable=${detail}`;
+    }
+    finally {
+        if (diagnosticTimeout) {
+            clearTimeout(diagnosticTimeout);
+        }
+    }
+}
 async function verifyHostedEditorPhaseRoundTrip(page, frame, timeoutMs) {
     const armReadySignal = async () => {
         await frame.evaluate(() => {
@@ -432,9 +489,9 @@ async function verifyHostedEditorPhaseRoundTrip(page, frame, timeoutMs) {
                 return;
             }
             state.installed = true;
-            window.addEventListener('playdrop:loading-state', (event) => {
+            window.addEventListener("playdrop:loading-state", (event) => {
                 const detail = event.detail;
-                if (detail?.status === 'ready') {
+                if (detail?.status === "ready") {
                     state.signals.push({ editor: detail.editor === true });
                 }
             });
@@ -443,48 +500,50 @@ async function verifyHostedEditorPhaseRoundTrip(page, frame, timeoutMs) {
     const changePhaseAndWait = async (phase, editor) => {
         await armReadySignal();
         await page.evaluate((nextPhase) => {
-            window.postMessage({ type: 'playdrop-studio-runtime-state', active: true, phase: nextPhase }, window.location.origin);
+            window.postMessage({ type: "playdrop-studio-runtime-state", active: true, phase: nextPhase }, window.location.origin);
         }, phase);
         await frame.waitForFunction((expectedEditor) => {
             const runtimeWindow = window;
-            return runtimeWindow.__playdropEditorPhaseCheck?.signals?.some((signal) => signal.editor === expectedEditor) === true;
+            return (runtimeWindow.__playdropEditorPhaseCheck?.signals?.some((signal) => signal.editor === expectedEditor) === true);
         }, editor, { timeout: timeoutMs });
     };
     try {
-        await changePhaseAndWait('play', false);
-        await changePhaseAndWait('editor', true);
+        await changePhaseAndWait("play", false);
+        await changePhaseAndWait("editor", true);
     }
     catch (error) {
         const detail = error instanceof Error ? error.message : String(error);
-        throw new Error('project_check_editor_phase_switch_failed: The hosted bundle must switch Editor to Playtest and back '
-            + `inside the existing runtime frame. ${detail}`);
+        throw new Error("project_check_editor_phase_switch_failed: The hosted bundle must switch Editor to Playtest and back " +
+            `inside the existing runtime frame. ${detail}`);
     }
 }
 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'));
+        const canvas = document.createElement("canvas");
+        const gl = (canvas.getContext("webgl2") ||
+            canvas.getContext("webgl") ||
+            canvas.getContext("experimental-webgl"));
         if (!gl) {
-            return '';
+            return "";
         }
-        const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
+        const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
         if (debugInfo) {
             const unmaskedRenderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
-            if (typeof unmaskedRenderer === 'string' && unmaskedRenderer.trim()) {
+            if (typeof unmaskedRenderer === "string" && unmaskedRenderer.trim()) {
                 return unmaskedRenderer;
             }
         }
         const rendererValue = gl.getParameter(gl.RENDERER);
-        return typeof rendererValue === 'string' ? rendererValue : String(rendererValue ?? '');
+        return typeof rendererValue === "string" ? rendererValue : String(rendererValue ?? "");
     });
-    const normalized = typeof renderer === 'string' ? renderer.trim() : '';
+    const normalized = typeof renderer === "string" ? renderer.trim() : "";
     if (!normalized) {
-        throw new Error('project_check_webgl_renderer_missing');
+        throw new Error("project_check_webgl_renderer_missing");
     }
     return normalized;
 }
 async function saveScreenshot(page, screenshotPath) {
-    const normalizedPath = typeof screenshotPath === 'string' ? screenshotPath.trim() : '';
+    const normalizedPath = typeof screenshotPath === "string" ? screenshotPath.trim() : "";
     if (!normalizedPath) {
         return null;
     }
@@ -493,11 +552,11 @@ async function saveScreenshot(page, screenshotPath) {
     return normalizedPath;
 }
 async function saveGameFrameScreenshot(page, screenshotPath) {
-    const normalizedPath = typeof screenshotPath === 'string' ? screenshotPath.trim() : '';
+    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.locator(FRAME_SELECTOR).screenshot({ path: normalizedPath, type: 'png' });
+    await page.locator(FRAME_SELECTOR).screenshot({ path: normalizedPath, type: "png" });
     return normalizedPath;
 }
 function normalizeLoadCheckFailure(error, artifactFingerprint) {
@@ -508,44 +567,45 @@ function normalizeLoadCheckFailure(error, artifactFingerprint) {
         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_'))) {
+    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);
+        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);
+        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);
+        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("webgl_renderer_software", message, artifactFingerprint);
     }
-    return buildFailedLoadCheckResult('startup_failure', message, artifactFingerprint);
+    return buildFailedLoadCheckResult("startup_failure", message, artifactFingerprint);
 }
-function formatHostedLoadCheckFailure(taskName, result, scope = 'local') {
-    const scopeLabel = scope === 'final'
-        ? 'final owner play route'
-        : scope === 'editor'
-            ? 'staged Editor phase'
-            : scope === 'staged'
-                ? 'staged upload preview'
-                : 'local hosted preview';
-    const errorCode = result.errorCode?.trim() || 'startup_failure';
+function formatHostedLoadCheckFailure(taskName, result, scope = "local") {
+    const scopeLabel = scope === "final"
+        ? "final owner play route"
+        : scope === "editor"
+            ? "staged Editor phase"
+            : 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}`;
+    const screenshot = result.screenshotPath ? ` Screenshot: ${result.screenshotPath}.` : "";
+    return `hosted_load_check_failed: ${taskName} failed the ${scopeLabel} check (${errorCode}). ${message}${screenshot}`;
 }
 function redactHostedLoadCheckSecrets(text, sourceUrl) {
-    return (0, appUrls_1.redactTaskCaptureToken)(text, sourceUrl).replace(/("(?:authToken|appAccessToken|captureTaskToken|reviewToken)"\s*:\s*")[^"]+(")/g, '$1<redacted>$2');
+    return (0, appUrls_1.redactTaskCaptureToken)(text, sourceUrl).replace(/("(?:authToken|appAccessToken|captureTaskToken|reviewToken)"\s*:\s*")[^"]+(")/g, "$1<redacted>$2");
 }
 async function runHostedLoadCheck(options) {
-    const expectedHostedLaunchState = options.expectedHostedLaunchState ?? 'ready';
+    const expectedHostedLaunchState = options.expectedHostedLaunchState ?? "ready";
     const artifactFingerprint = options.artifactFingerprint ?? null;
     const timeoutMs = options.timeoutMs ?? DEFAULT_HOSTED_LOAD_TIMEOUT_MS;
     const errors = [];
@@ -560,15 +620,17 @@ async function runHostedLoadCheck(options) {
             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 currentTapeAction = '';
+            const bootstrapUser = shouldBootstrapSavedSession ? (options.user ?? null) : null;
+            let currentTapeAction = "";
             const withTapeAction = (line) => (currentTapeAction ? `${line} after ${currentTapeAction}` : line);
             let hostedLaunchWaiterSettled = false;
+            let lastHostedLaunchState = null;
             let resolveHostedLaunchWaiter = null;
             const hostedLaunchWaiter = new Promise((resolve) => {
                 resolveHostedLaunchWaiter = resolve;
             });
             const settleHostedLaunchWaiter = (state) => {
+                lastHostedLaunchState = state;
                 if (hostedLaunchWaiterSettled) {
                     return;
                 }
@@ -585,7 +647,7 @@ async function runHostedLoadCheck(options) {
                 await page.addInitScript(({ token, user }) => {
                     try {
                         if (token) {
-                            window.localStorage.setItem('playdrop.accessToken', token);
+                            window.localStorage.setItem("playdrop.accessToken", token);
                         }
                     }
                     catch {
@@ -593,60 +655,60 @@ async function runHostedLoadCheck(options) {
                     }
                     try {
                         if (user) {
-                            window.localStorage.setItem('playdrop.user', JSON.stringify(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');
+                        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') {
+            await page.exposeBinding("__playdropCaptureLog", async (_source, type, payload) => {
+                if (type === "hosted-launch-state") {
                     const normalizedHostedState = normalizeHostedLaunchStatePayload(payload);
                     if (normalizedHostedState) {
                         settleHostedLaunchWaiter(normalizedHostedState);
                     }
                 }
-                const normalizedType = typeof type === 'string' ? type.toLowerCase() : 'info';
+                const normalizedType = typeof type === "string" ? type.toLowerCase() : "info";
                 if (/error|failed|denied|unreachable/.test(normalizedType)) {
                     const serialized = serializePayload(payload);
-                    errors.push(redactReportText(['[check][custom]', normalizedType, serialized].filter(Boolean).join(' ')));
+                    errors.push(redactReportText(["[check][custom]", normalizedType, serialized].filter(Boolean).join(" ")));
                 }
             });
             await page.addInitScript(() => {
-                window.addEventListener('unhandledrejection', (event) => {
+                window.addEventListener("unhandledrejection", (event) => {
                     try {
-                        console.error('[check][unhandledrejection]', event.reason);
+                        console.error("[check][unhandledrejection]", event.reason);
                     }
                     catch {
-                        console.error('[check][unhandledrejection]');
+                        console.error("[check][unhandledrejection]");
                     }
                 });
                 const bridgeWindow = window;
                 bridgeWindow.playdrop = bridgeWindow.playdrop || {};
                 bridgeWindow.__playdropCaptureHostedLaunchState = null;
                 const bridge = (type, payload) => {
-                    if (type === 'hosted-launch-state') {
+                    if (type === "hosted-launch-state") {
                         bridgeWindow.__playdropCaptureHostedLaunchState = payload;
                     }
                     try {
                         const binding = bridgeWindow.__playdropCaptureLog;
-                        if (typeof binding === 'function') {
+                        if (typeof binding === "function") {
                             binding(type, payload);
                         }
                     }
                     catch (error) {
-                        console.error('[check][bridge-error]', error);
+                        console.error("[check][bridge-error]", error);
                     }
                 };
-                Object.defineProperty(bridgeWindow.playdrop, 'capture', {
+                Object.defineProperty(bridgeWindow.playdrop, "capture", {
                     value: bridge,
                     configurable: true,
                     writable: true,
@@ -656,26 +718,58 @@ async function runHostedLoadCheck(options) {
                 const type = message.type();
                 const args = await Promise.all(message.args().map((arg) => arg.jsonValue().catch(() => arg.toString())));
                 const rendered = formatBrowserConsoleMessage(args, message.text());
+                if (isDuplicateBrowserResourceConsoleError(type, rendered)) {
+                    return;
+                }
                 const line = redactReportText(withTapeAction(`[check][console:${type}] ${rendered}`));
-                if (type === 'error' || type === 'assert' || type === 'trace') {
+                if (type === "error" || type === "assert" || type === "trace") {
                     errors.push(line);
                 }
             };
-            page.on('console', (message) => {
-                void handleConsoleMessage(message).catch((error) => {
+            const pendingConsoleMessages = new Set();
+            const drainConsoleMessages = async () => {
+                if (pendingConsoleMessages.size === 0)
+                    return;
+                let timeout = null;
+                const settled = await Promise.race([
+                    Promise.allSettled([...pendingConsoleMessages]).then(() => true),
+                    new Promise((resolve) => {
+                        timeout = setTimeout(() => resolve(false), HOSTED_LAUNCH_DIAGNOSTIC_TIMEOUT_MS);
+                    }),
+                ]);
+                if (timeout)
+                    clearTimeout(timeout);
+                if (!settled) {
+                    warnings.push("[check][console-handler] Timed out while collecting browser console diagnostics.");
+                }
+            };
+            page.on("console", (message) => {
+                const pending = handleConsoleMessage(message)
+                    .catch((error) => {
                     const text = redactReportText(error instanceof Error ? error.message : String(error));
-                    errors.push(`[check][console-handler] ${text}`);
-                });
+                    warnings.push(`[check][console-handler] ${text}`);
+                })
+                    .finally(() => pendingConsoleMessages.delete(pending));
+                pendingConsoleMessages.add(pending);
             });
-            page.on('pageerror', (error) => {
+            page.on("pageerror", (error) => {
                 const text = redactReportText(error?.message ?? String(error));
                 const line = withTapeAction(`[check][pageerror] ${text}`);
                 errors.push(line);
             });
-            page.on('requestfailed', (request) => {
+            page.on("crash", () => {
+                const line = withTapeAction("[check][pagecrash] Hosted validator page crashed.");
+                errors.push(line);
+                settleHostedLaunchWaiter({
+                    state: "error",
+                    errorCode: "browser_page_crashed",
+                    message: "The hosted validator page crashed before launch completed.",
+                });
+            });
+            page.on("requestfailed", (request) => {
                 const failure = request.failure();
-                const errorText = failure?.errorText ?? '';
-                const text = redactReportText(`${request.method()} ${request.url()} - ${errorText || 'failed'}`);
+                const errorText = failure?.errorText ?? "";
+                const text = redactReportText(`${request.method()} ${request.url()} - ${errorText || "failed"}`);
                 if (isKnownGoogleTelemetryUrl(request.url())) {
                     warnings.push(`[check][requestfailed] ${text}`);
                     return;
@@ -686,12 +780,21 @@ async function runHostedLoadCheck(options) {
                 const line = withTapeAction(`[check][requestfailed] ${text}`);
                 errors.push(line);
             });
-            page.on('response', (response) => {
+            page.on("response", (response) => {
                 const status = response.status();
                 if (status < 400) {
                     return;
                 }
                 const text = redactReportText(`${status} ${response.statusText()} ${response.url()}`);
+                if (isExpectedAnonymousSessionProbe({
+                    url: response.url(),
+                    status,
+                    method: response.request().method(),
+                    hasExplicitToken,
+                })) {
+                    warnings.push(`[check][response] ${text}`);
+                    return;
+                }
                 if (isKnownGoogleTelemetryUrl(response.url())) {
                     warnings.push(`[check][response] ${text}`);
                     return;
@@ -699,65 +802,83 @@ async function runHostedLoadCheck(options) {
                 const line = withTapeAction(`[check][response] ${text}`);
                 errors.push(line);
             });
-            const response = await page.goto(options.targetUrl, { waitUntil: 'domcontentloaded', timeout: 30000 });
-            if (response && !response.ok()) {
-                errors.push(`[check][navigation] ${response.status()} ${response.statusText()} ${reportTargetUrl}`);
-            }
-            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';
+            const captureFailureScreenshot = async () => {
+                try {
+                    screenshotPath = await saveScreenshot(page, options.failureScreenshotPath ?? options.screenshotPath);
                 }
-                if (state && typeof state.state === 'string' && state.state.trim().length > 0) {
-                    return `hosted:${state.state.trim().toLowerCase()}`;
+                catch (screenshotError) {
+                    const detail = redactReportText(screenshotError instanceof Error ? screenshotError.message : String(screenshotError));
+                    errors.push(`[check][screenshot] Failed to capture staged validation evidence: ${detail}`);
+                }
+            };
+            const captureCompletionScreenshot = async () => {
+                if (errors.length > 0) {
+                    await captureFailureScreenshot();
+                    return;
                 }
-                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: instrument_error:game_ready_timeout: Hosted app did not report sdk.host.ready() before the instrument 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 = (0, appUrls_1.redactTaskCaptureSession)(page.url());
-            if (expectedHostedLaunchState !== 'ready') {
                 screenshotPath = await saveScreenshot(page, options.screenshotPath);
-                return;
-            }
-            const frame = await findGameFrame(page, readinessTimeoutMs);
-            webglRenderer = await readWebGlRenderer(frame);
-            if (isSoftwareWebGlRenderer(webglRenderer)) {
-                throw new Error(`project_check_webgl_renderer_software: WebGL renderer is "${webglRenderer}". Real hardware acceleration is required.`);
-            }
-            if (options.verifyEditorPhaseRoundTrip) {
-                await verifyHostedEditorPhaseRoundTrip(page, frame, readinessTimeoutMs);
-            }
-            await saveGameFrameScreenshot(page, options.readyGameFrameScreenshotPath);
-            if (options.playtestTape) {
-                if (!options.playtestSurface) {
-                    throw new Error('project_check_playtest_surface_required');
+            };
+            try {
+                const response = await page.goto(options.targetUrl, { waitUntil: "domcontentloaded", timeout: 30000 });
+                if (response && !response.ok()) {
+                    errors.push(`[check][navigation] ${response.status()} ${response.statusText()} ${reportTargetUrl}`);
                 }
-                await dispatchPlaytestTapeToFrame(page, frame, options.playtestSurface, options.playtestTape, {
-                    onBeforeEvent: (eventIndex, event) => {
-                        currentTapeAction = `action ${eventIndex + 1} of ${options.playtestTape.events.length} (${event.type} at ${event.atMs} ms)`;
-                    },
-                });
+                const readinessTimeoutMs = Math.min(Math.max(timeoutMs, 1000), 30000);
+                let launchState;
+                try {
+                    launchState = await waitForHostedLaunchState(hostedLaunchWaiter, expectedHostedLaunchState, timeoutMs);
+                }
+                catch (error) {
+                    const timeoutContext = await describeHostedLaunchTimeout(page, lastHostedLaunchState);
+                    const detail = error instanceof Error ? error.message : String(error);
+                    throw new Error(`${detail} ${timeoutContext}`);
+                }
+                if (launchState.state === "error") {
+                    throw new Error(formatHostedLaunchError(launchState));
+                }
+                finalUrl = (0, appUrls_1.redactTaskCaptureSession)(page.url());
+                if (expectedHostedLaunchState !== "ready") {
+                    await drainConsoleMessages();
+                    await captureCompletionScreenshot();
+                    return;
+                }
+                const frame = await findGameFrame(page, readinessTimeoutMs);
+                webglRenderer = await readWebGlRenderer(frame);
+                if (isSoftwareWebGlRenderer(webglRenderer)) {
+                    throw new Error(`project_check_webgl_renderer_software: WebGL renderer is "${webglRenderer}". Real hardware acceleration is required.`);
+                }
+                if (options.verifyEditorPhaseRoundTrip) {
+                    await verifyHostedEditorPhaseRoundTrip(page, frame, readinessTimeoutMs);
+                }
+                await saveGameFrameScreenshot(page, options.readyGameFrameScreenshotPath);
+                if (options.playtestTape) {
+                    if (!options.playtestSurface) {
+                        throw new Error("project_check_playtest_surface_required");
+                    }
+                    await dispatchPlaytestTapeToFrame(page, frame, options.playtestSurface, options.playtestTape, {
+                        onBeforeEvent: (eventIndex, event) => {
+                            currentTapeAction = `action ${eventIndex + 1} of ${options.playtestTape.events.length} (${event.type} at ${event.atMs} ms)`;
+                        },
+                    });
+                }
+                else if (options.postReadyWaitMs && options.postReadyWaitMs > 0) {
+                    await page.waitForTimeout(options.postReadyWaitMs);
+                }
+                await saveGameFrameScreenshot(page, options.gameFrameScreenshotPath);
+                await drainConsoleMessages();
+                await captureCompletionScreenshot();
             }
-            else if (options.postReadyWaitMs && options.postReadyWaitMs > 0) {
-                await page.waitForTimeout(options.postReadyWaitMs);
+            catch (error) {
+                await drainConsoleMessages();
+                try {
+                    finalUrl = (0, appUrls_1.redactTaskCaptureSession)(page.url());
+                }
+                catch {
+                    // Keep the last known URL when the renderer is unavailable.
+                }
+                await captureFailureScreenshot();
+                throw error;
             }
-            await saveGameFrameScreenshot(page, options.gameFrameScreenshotPath);
-            screenshotPath = await saveScreenshot(page, options.screenshotPath);
         }, {
             ...options.contextOptions,
             automationOrigin: new URL(options.targetUrl).origin,
@@ -780,7 +901,7 @@ async function runHostedLoadCheck(options) {
         };
     }
     if (errors.length > 0) {
-        return buildFailedLoadCheckResult('startup_failure', `Hosted app emitted ${errors.length} console, page, or network error(s) during startup.${formatLoadCheckErrors(errors)}`, artifactFingerprint, {
+        return buildFailedLoadCheckResult("startup_failure", `Hosted app emitted ${errors.length} console, page, or network error(s) during startup.${formatLoadCheckErrors(errors)}`, artifactFingerprint, {
             screenshotPath,
             webglRenderer,
             targetUrl: finalUrl,
@@ -797,9 +918,9 @@ async function runHostedLoadCheck(options) {
     });
 }
 async function startOrReuseMountedDevRuntime(input) {
-    const appTypeSlug = (0, appUrls_1.getAppTypeSlug)(input.task.type ?? 'GAME');
+    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
+    const runtimeAssetManifest = input.task.hostingMode === "EXTERNAL" || input.task.externalUrl
         ? (0, devRuntimeAssets_1.createEmptyDevRuntimeAssetManifest)()
         : await (0, devRuntimeAssets_1.buildDevRuntimeAssetManifest)({
             client: input.client,
@@ -838,7 +959,7 @@ async function startOrReuseMountedDevRuntime(input) {
     }
     catch (error) {
         const formatted = (0, dev_1.formatDevRuntimeAssetManifestFailure)(error);
-        const mountConflict = (0, devServer_1.parseMountConflictError)(error instanceof Error ? error.message : '');
+        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}.`);
         }
@@ -855,14 +976,12 @@ async function runLocalHostedLoadCheck(input) {
             task: input.task,
             devRouterPort: input.devRouterPort,
         });
-        const localDevPort = input.devRouterPort === undefined || input.devRouterPort === devServer_1.DEV_ROUTER_PORT
-            ? null
-            : input.devRouterPort;
+        const localDevPort = input.devRouterPort === undefined || input.devRouterPort === devServer_1.DEV_ROUTER_PORT ? null : input.devRouterPort;
         const localAppMetadata = mountedRuntime.runtimeAssetManifest.response.localAppMetadata;
         const declaredSurfaces = normalizeLoadCheckSurfaceTargets(localAppMetadata.surfaceTargets);
         const captureSurface = input.surface ?? resolveLoadCheckSurface(localAppMetadata.surfaceTargets, input.task.primarySurface);
         if (!declaredSurfaces.includes(captureSurface)) {
-            return buildFailedLoadCheckResult('surface_unsupported', `Surface ${captureSurface} is not declared in surfaceTargets for "${input.task.name}".`, null);
+            return buildFailedLoadCheckResult("surface_unsupported", `Surface ${captureSurface} is not declared in surfaceTargets for "${input.task.name}".`, null);
         }
         const contextOptions = cloneLoadCheckContextOptions(captureSurface);
         const anonymousExpectedState = resolveAnonymousHostedLaunchState({
@@ -874,7 +993,7 @@ async function runLocalHostedLoadCheck(input) {
                 targetUrl: (0, appUrls_1.buildPlatformDevUrl)(input.webBase, {
                     creatorUsername: input.creatorUsername,
                     appName: input.task.name,
-                    appType: input.task.type ?? 'GAME',
+                    appType: input.task.type ?? "GAME",
                     launchCheck: true,
                     localDevPort,
                     captureSession: input.captureSession,
@@ -888,20 +1007,18 @@ async function runLocalHostedLoadCheck(input) {
                 postReadyWaitMs: input.postReadyWaitMs,
             });
         }
-        if (anonymousExpectedState === 'login_required') {
+        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);
+            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);
+                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',
+                    appType: input.task.type ?? "GAME",
+                    devAuth: "anonymous",
                     launchCheck: true,
                     localDevPort,
                 }),
@@ -909,15 +1026,15 @@ async function runLocalHostedLoadCheck(input) {
                 expectedHostedLaunchState: anonymousExpectedState,
                 contextOptions,
             });
-            if (anonymousGateResult.status !== 'PASSED') {
+            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',
+                    appType: input.task.type ?? "GAME",
+                    devAuth: "viewer",
                     launchCheck: true,
                     localDevPort,
                 }),
@@ -937,8 +1054,8 @@ async function runLocalHostedLoadCheck(input) {
             targetUrl: (0, appUrls_1.buildPlatformDevUrl)(input.webBase, {
                 creatorUsername: input.creatorUsername,
                 appName: input.task.name,
-                appType: input.task.type ?? 'GAME',
-                devAuth: 'anonymous',
+                appType: input.task.type ?? "GAME",
+                devAuth: "anonymous",
                 launchCheck: true,
                 localDevPort,
             }),
@@ -963,14 +1080,26 @@ function appendLoadCheckParams(targetUrl, devAuth) {
         player: null,
     });
 }
+function buildUploadedHostedLoadCheckUrl(rawUrl, phase) {
+    const url = new URL(rawUrl);
+    url.searchParams.set("launchCheck", "1");
+    if (phase === "editor") {
+        url.searchParams.set("hostPhase", "editor");
+    }
+    return url.toString();
+}
+function buildUploadedHostedLoadCheckScreenshotPath(task, sessionId, phase) {
+    const projectDir = typeof task.projectDir === "string" ? task.projectDir.trim() : "";
+    if (!projectDir)
+        return null;
+    const safeName = task.name.replace(/[^a-zA-Z0-9._-]+/g, "-");
+    const safeSessionId = sessionId.replace(/[^a-zA-Z0-9._-]+/g, "-");
+    return (0, node_path_1.join)(projectDir, ".playdrop", "validation-evidence", `staged-${safeName}-${safeSessionId}-${phase ?? "play"}.png`);
+}
 async function runUploadedHostedLoadCheck(input) {
     const preview = await input.client.fetchAppUploadLaunchCheckPreview(input.creatorUsername, input.task.name, input.sessionId);
-    const withRequestedPhase = (rawUrl) => {
-        const url = new URL(rawUrl);
-        if (input.phase === 'editor')
-            url.searchParams.set('hostPhase', 'editor');
-        return url.toString();
-    };
+    const withRequestedPhase = (rawUrl) => buildUploadedHostedLoadCheckUrl(rawUrl, input.phase);
+    const failureScreenshotPath = input.screenshotPath ?? buildUploadedHostedLoadCheckScreenshotPath(input.task, input.sessionId, input.phase);
     const captureSurface = resolveLoadCheckSurface(preview.localAppMetadata.surfaceTargets, input.task.primarySurface);
     const contextOptions = cloneLoadCheckContextOptions(captureSurface);
     const anonymousExpectedState = resolveAnonymousHostedLaunchState({
@@ -988,6 +1117,7 @@ async function runUploadedHostedLoadCheck(input) {
             expectedHostedLaunchState: resolvePostAuthHostedLaunchState(preview.localAppMetadata.controllerMode),
             contextOptions,
             screenshotPath: input.screenshotPath,
+            failureScreenshotPath,
             readyGameFrameScreenshotPath: input.readyGameFrameScreenshotPath,
             gameFrameScreenshotPath: input.gameFrameScreenshotPath,
             playtestTape: input.playtestTape,
@@ -996,24 +1126,26 @@ async function runUploadedHostedLoadCheck(input) {
             verifyEditorPhaseRoundTrip: input.verifyEditorPhaseRoundTrip,
         });
     }
-    else if (anonymousExpectedState === 'login_required') {
+    else 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);
+            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: withRequestedPhase(appendLoadCheckParams(preview.launchUrl, 'anonymous')),
+                targetUrl: withRequestedPhase(appendLoadCheckParams(preview.launchUrl, "anonymous")),
                 artifactFingerprint: preview.session.manifestHash,
                 timeoutMs: input.timeoutMs,
                 expectedHostedLaunchState: anonymousExpectedState,
                 contextOptions,
+                screenshotPath: input.screenshotPath,
+                failureScreenshotPath,
             });
-            if (anonymousGateResult.status !== 'PASSED') {
+            if (anonymousGateResult.status !== "PASSED") {
                 result = anonymousGateResult;
             }
             else {
                 result = await runHostedLoadCheck({
-                    targetUrl: withRequestedPhase(appendLoadCheckParams(preview.launchUrl, 'viewer')),
+                    targetUrl: withRequestedPhase(appendLoadCheckParams(preview.launchUrl, "viewer")),
                     artifactFingerprint: preview.session.manifestHash,
                     timeoutMs: input.timeoutMs,
                     expectedHostedLaunchState: resolvePostAuthHostedLaunchState(preview.localAppMetadata.controllerMode),
@@ -1022,6 +1154,7 @@ async function runUploadedHostedLoadCheck(input) {
                     savedSessionBootstrap: true,
                     contextOptions,
                     screenshotPath: input.screenshotPath,
+                    failureScreenshotPath,
                     readyGameFrameScreenshotPath: input.readyGameFrameScreenshotPath,
                     gameFrameScreenshotPath: input.gameFrameScreenshotPath,
                     playtestTape: input.playtestTape,
@@ -1034,12 +1167,13 @@ async function runUploadedHostedLoadCheck(input) {
     }
     else {
         result = await runHostedLoadCheck({
-            targetUrl: withRequestedPhase(appendLoadCheckParams(preview.launchUrl, 'anonymous')),
+            targetUrl: withRequestedPhase(appendLoadCheckParams(preview.launchUrl, "anonymous")),
             artifactFingerprint: preview.session.manifestHash,
             timeoutMs: input.timeoutMs,
             expectedHostedLaunchState: anonymousExpectedState,
             contextOptions,
             screenshotPath: input.screenshotPath,
+            failureScreenshotPath,
             readyGameFrameScreenshotPath: input.readyGameFrameScreenshotPath,
             gameFrameScreenshotPath: input.gameFrameScreenshotPath,
             playtestTape: input.playtestTape,
@@ -1055,8 +1189,8 @@ async function runUploadedHostedLoadCheck(input) {
         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);
+    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,
@@ -1068,22 +1202,20 @@ async function runUploadedHostedLoadCheck(input) {
     };
 }
 async function hashFile(path) {
-    return (0, node_crypto_1.createHash)('sha256').update(await (0, promises_1.readFile)(path)).digest('hex');
+    return (0, node_crypto_1.createHash)("sha256")
+        .update(await (0, promises_1.readFile)(path))
+        .digest("hex");
 }
 async function comparePlaytestFrames(firstPath, secondPath, thresholds = {
     meanDeltaMin: PLAYTEST_INTERACTIVE_MEAN_DELTA_MIN,
     changedPixelRatioMin: PLAYTEST_INTERACTIVE_CHANGED_PIXEL_RATIO_MIN,
 }) {
     const readPixels = async (path) => {
-        return await (0, sharp_1.default)(path)
-            .resize(64, 64, { fit: 'fill' })
-            .greyscale()
-            .raw()
-            .toBuffer();
+        return await (0, sharp_1.default)(path).resize(64, 64, { fit: "fill" }).greyscale().raw().toBuffer();
     };
     const [first, second] = await Promise.all([readPixels(firstPath), readPixels(secondPath)]);
     if (first.length !== second.length || first.length === 0) {
-        throw new Error('playtest_smoke_check_frame_shape_mismatch: idle and tape screenshots have different dimensions');
+        throw new Error("playtest_smoke_check_frame_shape_mismatch: idle and tape screenshots have different dimensions");
     }
     let deltaTotal = 0;
     let changedPixels = 0;
@@ -1105,12 +1237,12 @@ async function runUploadedHostedPlaytestSmokeCheck(input) {
     const primarySurface = input.task.primarySurface;
     const fullTape = primarySurface ? input.task.playtestTapes?.[primarySurface] : null;
     if (!primarySurface || !fullTape) {
-        throw new Error('agent_task_playtest_smoke_check_primary_tape_required');
+        throw new Error("agent_task_playtest_smoke_check_primary_tape_required");
     }
-    const tempDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'playdrop-playtest-smoke-'));
+    const tempDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "playdrop-playtest-smoke-"));
     const paths = {
-        zeroInput: (0, node_path_1.join)(tempDir, 'zero-input.png'),
-        fullTape: (0, node_path_1.join)(tempDir, 'full-tape.png'),
+        zeroInput: (0, node_path_1.join)(tempDir, "zero-input.png"),
+        fullTape: (0, node_path_1.join)(tempDir, "full-tape.png"),
     };
     const run = async (label, options) => {
         console.log(`[upload] Playtest smoke check: ${label} from sdk.host.ready().`);
@@ -1125,38 +1257,38 @@ async function runUploadedHostedPlaytestSmokeCheck(input) {
             captureSession: input.captureSession,
             ...options,
         });
-        if (result.status !== 'PASSED') {
-            throw new Error(`agent_task_playtest_smoke_check_runtime_failed: ${label} failed. `
-                + formatHostedLoadCheckFailure(input.task.name, result, 'staged'));
+        if (result.status !== "PASSED") {
+            throw new Error(`agent_task_playtest_smoke_check_runtime_failed: ${label} failed. ` +
+                formatHostedLoadCheckFailure(input.task.name, result, "staged"));
         }
         if (!result.artifactFingerprint) {
-            throw new Error('agent_task_playtest_smoke_check_artifact_fingerprint_missing');
+            throw new Error("agent_task_playtest_smoke_check_artifact_fingerprint_missing");
         }
         return result;
     };
     try {
-        const zeroInput = await run('zero-input', {
+        const zeroInput = await run("zero-input", {
             postReadyWaitMs: fullTape.durationMs,
             gameFrameScreenshotPath: paths.zeroInput,
         });
-        const full = await run('full-tape', {
+        const full = await run("full-tape", {
             playtestTape: fullTape,
             gameFrameScreenshotPath: paths.fullTape,
         });
         const artifactFingerprint = full.artifactFingerprint;
         if (zeroInput.artifactFingerprint !== artifactFingerprint) {
-            throw new Error('agent_task_playtest_smoke_check_artifact_changed_during_check');
+            throw new Error("agent_task_playtest_smoke_check_artifact_changed_during_check");
         }
         const comparison = await comparePlaytestFrames(paths.zeroInput, paths.fullTape);
         if (!comparison.passed) {
-            throw new Error(`agent_task_playtest_smoke_check_not_interactive: The validator completed all ${fullTape.events.length} tape actions `
-                + `without a crash, but the result looked the same as running the game for ${fullTape.durationMs} ms without input `
-                + `(mean pixel change ${comparison.meanDelta.toFixed(4)}, changed pixels ${(comparison.changedPixelRatio * 100).toFixed(2)}%). `
-                + 'Make sure the tape performs the core gameplay action and produces a visible response, then rerun the tape check.');
+            throw new Error(`agent_task_playtest_smoke_check_not_interactive: The validator completed all ${fullTape.events.length} tape actions ` +
+                `without a crash, but the result looked the same as running the game for ${fullTape.durationMs} ms without input ` +
+                `(mean pixel change ${comparison.meanDelta.toFixed(4)}, changed pixels ${(comparison.changedPixelRatio * 100).toFixed(2)}%). ` +
+                "Make sure the tape performs the core gameplay action and produces a visible response, then rerun the tape check.");
         }
         const evidence = {
             version: 2,
-            source: 'CLI_MACHINE',
+            source: "CLI_MACHINE",
             artifactFingerprint,
             primarySurface,
             primaryVerb: fullTape.primaryVerb,
@@ -1167,8 +1299,8 @@ async function runUploadedHostedPlaytestSmokeCheck(input) {
             comparison,
         };
         const recorded = await input.client.recordAppUploadCausalCheck(input.creatorUsername, input.task.name, input.sessionId, { evidence });
-        if (recorded.session.causalCheck.status !== 'PASSED') {
-            throw new Error('agent_task_playtest_smoke_check_not_recorded');
+        if (recorded.session.causalCheck.status !== "PASSED") {
+            throw new Error("agent_task_playtest_smoke_check_not_recorded");
         }
         console.log(`[upload] Playtest smoke check passed for ${input.creatorUsername}/${input.task.name}.`);
         return evidence;