loop-benchmarking

tests.ts (59551B)

---

 // Continuous observation session approach adapted from
 // mikhail-vlasenko/Tetris-AI (MIT License) -- polling loop concept
 
 import type { Page } from "@playwright/test";
 import type {
   TestResult,
   CalibrationResult,
   GameplayStats,
   GameSession,
   GridEvent,
   PieceType,
   CompetitivePlayResult,
   SurveyData,
 } from "./types";
 import {
   readGrid,
   gridsAreDifferent,
   countFilled,
   countFilledInBottomRows,
   hasFilledInTopRows,
   detectActivePieceCells,
   identifyPieceType,
   countCompleteRows,
 } from "./grid-reader";
 import { hardDrop, playGame, tryFillRow } from "./player";
 import { calibrate, surveyPage } from "./calibrate";
 
 /**
  * Run the gameplay bot as one continuous observation session with 8 conditional phases.
  *
  * Phase 1: Page load
  * Phase 2: Game start detection (falling piece detector)
  * Phase 3: Mechanics tests (conditional on Phase 2)
  * Phase 4: Piece lifecycle (conditional on Phase 3)
  * Phase 5: Gameplay with score tracking (conditional on Phase 4)
  * Phase 6: Game over (conditional on Phase 4)
  * Phase 7: Endurance (conditional on Phase 5)
  * Phase 8: Competitive play (conditional on Phase 5)
  *
  * NO FALSE POSITIVES: if the grid reader cannot verify a mechanic,
  * the test is marked as failed with detail explaining why, not passed
  * based on screenshot-only evidence.
  */
 export async function runAllTests(
   page: Page,
   serverUrl: string
 ): Promise<{
   testResults: TestResult[];
   calibration: CalibrationResult;
   gameplay: GameplayStats;
   session: GameSession;
   survey: SurveyData;
   competitivePlay: CompetitivePlayResult | null;
 }> {
   const gameplay: GameplayStats = {
     pieces_placed: 0,
     lines_cleared: 0,
     max_score_observed: 0,
     play_duration_seconds: 0,
     errors_during_play: 0,
   };
 
   const session: GameSession = {
     started: false,
     startMechanism: "unknown",
     piecesSpawned: 0,
     piecesLocked: 0,
     linesCleared: 0,
     rotationsObserved: 0,
     movementsObserved: 0,
     hardDropsObserved: 0,
     gameOverDetected: false,
     consoleErrors: [],
     durationSeconds: 0,
     pieceTypes: new Set<string>(),
     scoreValues: [],
     gridReadSuccess: 0,
     gridReadFail: 0,
     frames: 0,
     events: [],
     skippedPhases: [],
   };
 
   let survey: SurveyData = {
     has_overlay: false,
     has_canvas: false,
     has_dom_grid: false,
     visible_text: [],
     clickable_elements: 0,
   };
 
   let competitivePlay: CompetitivePlayResult | null = null;
 
   const consoleErrors: string[] = [];
   page.on("pageerror", (err) => {
     consoleErrors.push(err.message);
     session.consoleErrors.push(err.message);
   });
 
   // ---- Phase 1: Load the page ----
   const loadResult = await loadAndCheckPage(page, serverUrl, consoleErrors);
   if (!loadResult.loaded) {
     const failedTests = ALL_TEST_NAMES.map((name) => ({
       name,
       pass: false,
       detail: loadResult.detail,
     }));
     return {
       testResults: failedTests,
       calibration: emptyCalibration(consoleErrors),
       gameplay,
       session,
       survey,
       competitivePlay,
     };
   }
 
   // ---- Pre-test survey ----
   survey = await surveyPage(page);
 
   // ---- Phase 2: Calibrate + detect start (falling piece detector) ----
   let cal: CalibrationResult;
   try {
     cal = await calibrate(page);
     session.started = cal.startMechanism !== "unknown";
     session.startMechanism = cal.startMechanism;
   } catch (err) {
     cal = emptyCalibration(consoleErrors);
   }
 
   // Merge console errors from calibration
   for (const e of cal.consoleErrors) {
     if (!consoleErrors.includes(e)) consoleErrors.push(e);
     if (!session.consoleErrors.includes(e)) session.consoleErrors.push(e);
   }
 
   // Phase gate: if game didn't start, skip all downstream
   let gameStarted = session.started;
   if (!gameStarted) {
     session.skippedPhases.push(
       "mechanics: game did not start",
       "pieces: game did not start",
       "gameplay: game did not start",
       "gameover: game did not start",
       "endurance: game did not start",
       "competitive: game did not start"
     );
   }
 
   // Re-sample calibration after start: the game may have created DOM
   // elements (grid cells, score displays) that didn't exist on page load
   const initialGridDetected = cal.gridDetected;
   if (gameStarted && !cal.gridDetected) {
     try {
       await page.waitForTimeout(500); // Let game render after start
       const recal = await calibrate(page);
       if (recal.gridDetected) {
         // Grid appeared after start -- upgrade calibration
         cal = recal;
         (cal as any).grid_detected_at = "after_start";
       }
     } catch { /* keep original calibration */ }
   }
 
   // ---- Phase 3: Basic mechanics -- ONLY if game started ----
   let mechanicsWork = false;
   if (gameStarted && cal.gridDetected) {
     await runBasicMechanicsPhase(page, cal, session);
     mechanicsWork =
       session.movementsObserved > 0 ||
       session.rotationsObserved > 0 ||
       session.hardDropsObserved > 0 ||
       session.events.some((e) => e.type === "piece_moved");
   }
 
   if (gameStarted && !mechanicsWork) {
     session.skippedPhases.push(
       "pieces: mechanics failed",
       "gameplay: mechanics failed",
       "gameover: mechanics failed",
       "endurance: mechanics failed",
       "competitive: mechanics failed"
     );
   }
 
   // ---- Phase 4: Piece lifecycle -- ONLY if mechanics worked ----
   let piecesWork = false;
   if (mechanicsWork) {
     // Piece lifecycle is tested as part of mechanics phase (piece_locks, new_piece_spawns, multiple_pieces)
     // We consider it working if we have locked pieces and spawned pieces
     piecesWork = session.piecesLocked > 0 || session.hardDropsObserved > 0;
   }
 
   if (mechanicsWork && !piecesWork) {
     session.skippedPhases.push(
       "gameplay: piece lifecycle failed",
       "gameover: piece lifecycle failed",
       "endurance: piece lifecycle failed",
       "competitive: piece lifecycle failed"
     );
   }
 
   // ---- Phase 5: Gameplay (play to win) -- ONLY if pieces work ----
   let gameplayWorks = false;
   if (piecesWork) {
     try {
       await loadGamePage(page, serverUrl);
       cal = await calibrate(page);
       session.started = session.started || cal.startMechanism !== "unknown";
     } catch { /* continue with existing state */ }
 
     await runGameplayPhase(page, cal, session, gameplay);
     gameplayWorks = gameplay.pieces_placed > 0;
   }
 
   if (piecesWork && !gameplayWorks) {
     session.skippedPhases.push(
       "endurance: gameplay failed",
       "competitive: gameplay failed"
     );
   }
 
   // ---- Phase 6: Game over -- ONLY if pieces work ----
   if (piecesWork) {
     try {
       await loadGamePage(page, serverUrl);
       cal = await calibrate(page);
     } catch { /* continue */ }
 
     await runGameOverPhase(page, cal, session);
   }
 
   // ---- Phase 7: Endurance -- ONLY if gameplay worked ----
   if (gameplayWorks) {
     try {
       await loadGamePage(page, serverUrl);
       cal = await calibrate(page);
     } catch { /* continue */ }
 
     await runEndurancePhase(page, cal, session, gameplay, consoleErrors);
   }
 
   // ---- Phase 8: Competitive play -- ONLY if gameplay worked ----
   if (gameplayWorks) {
     try {
       await loadGamePage(page, serverUrl);
       cal = await calibrate(page);
     } catch { /* continue */ }
 
     competitivePlay = await runCompetitivePlayPhase(page, cal, session, gameplay);
   } else if (!session.skippedPhases.some((p) => p.startsWith("competitive:"))) {
     session.skippedPhases.push("competitive: gameplay failed");
   }
 
   session.durationSeconds = gameplay.play_duration_seconds;
 
   // ---- Derive test results from session data ----
   const phaseState = {
     gameStarted,
     mechanicsWork,
     piecesWork,
     gameplayWorks,
   };
   const testResults = deriveTestResults(session, cal, loadResult, consoleErrors, gameplay, phaseState, competitivePlay);
 
   return { testResults, calibration: cal, gameplay, session, survey, competitivePlay };
 }
 
 // ---- Phase implementations ----
 
 interface LoadResult {
   loaded: boolean;
   detail: string;
   errorsOnLoad: number;
 }
 
 async function loadAndCheckPage(
   page: Page,
   serverUrl: string,
   consoleErrors: string[]
 ): Promise<LoadResult> {
   const errorsBefore = consoleErrors.length;
 
   try {
     await loadGamePage(page, serverUrl);
     await page.waitForTimeout(3000);
   } catch (err) {
     return {
       loaded: false,
       detail: `page load failed: ${err instanceof Error ? err.message : String(err)}`,
       errorsOnLoad: consoleErrors.length - errorsBefore,
     };
   }
 
   const newErrors = consoleErrors.slice(errorsBefore);
   return {
     loaded: true,
     detail: newErrors.length === 0
       ? "no console errors"
       : `${newErrors.length} console error(s): ${newErrors[0]}`,
     errorsOnLoad: newErrors.length,
   };
 }
 
 /**
  * Test basic mechanics by reading the grid before and after each action.
  * Each test MUST verify via grid reader, not just screenshots.
  */
 async function runBasicMechanicsPhase(
   page: Page,
   cal: CalibrationResult,
   session: GameSession
 ): Promise<void> {
   // Auto-drop test: read grid twice with 5s gap, no input
   const gridT0 = await readGrid(page, cal);
   if (gridT0) session.gridReadSuccess++;
   else session.gridReadFail++;
   session.frames++;
 
   await page.waitForTimeout(5000);
 
   const gridT1 = await readGrid(page, cal);
   if (gridT1) session.gridReadSuccess++;
   else session.gridReadFail++;
   session.frames++;
 
   if (gridT0 && gridT1 && gridsAreDifferent(gridT0, gridT1)) {
     // Auto-drop confirmed via grid reader: cells actually moved
     // Verify a piece moved DOWN (more filled cells in lower rows, fewer in upper)
     const topBefore = countFilledInTopRows(gridT0, 10);
     const topAfter = countFilledInTopRows(gridT1, 10);
     const bottomBefore = countFilledInBottomRows(gridT0, 10);
     const bottomAfter = countFilledInBottomRows(gridT1, 10);
     if (bottomAfter > bottomBefore || topAfter < topBefore || gridsAreDifferent(gridT0, gridT1)) {
       session.events.push({ type: "piece_moved", direction: "down", frame: session.frames });
     }
   }
 
   // Movement tests: press key and verify grid change
   for (const dir of ["left", "right", "down"] as const) {
     const keyMap = {
       left: cal.controls.left,
       right: cal.controls.right,
       down: cal.controls.down,
     };
 
     const gridBefore = await readGrid(page, cal);
     if (gridBefore) session.gridReadSuccess++;
     else session.gridReadFail++;
     session.frames++;
 
     await page.keyboard.press(keyMap[dir]);
     await page.waitForTimeout(300);
 
     const gridAfter = await readGrid(page, cal);
     if (gridAfter) session.gridReadSuccess++;
     else session.gridReadFail++;
     session.frames++;
 
     if (gridBefore && gridAfter && gridsAreDifferent(gridBefore, gridAfter)) {
       session.movementsObserved++;
       session.events.push({ type: "piece_moved", direction: dir, frame: session.frames });
     }
   }
 
   // Rotation test: press rotate and verify grid change via shape detection
   const gridBeforeRot = await readGrid(page, cal);
   if (gridBeforeRot) session.gridReadSuccess++;
   else session.gridReadFail++;
   session.frames++;
 
   await page.keyboard.press(cal.controls.rotate);
   await page.waitForTimeout(300);
 
   const gridAfterRot = await readGrid(page, cal);
   if (gridAfterRot) session.gridReadSuccess++;
   else session.gridReadFail++;
   session.frames++;
 
   if (gridBeforeRot && gridAfterRot && gridsAreDifferent(gridBeforeRot, gridAfterRot)) {
     // Verify shape actually changed (not just position shift from gravity)
     const cellsBefore = detectActivePieceCells(gridBeforeRot, null);
     const cellsAfter = detectActivePieceCells(gridAfterRot, null);
     if (cellsBefore && cellsAfter) {
       const bbBefore = boundingBox(cellsBefore);
       const bbAfter = boundingBox(cellsAfter);
       // Rotation changes bounding box dimensions (w/h swap) for non-O pieces
       if (bbBefore.w !== bbAfter.w || bbBefore.h !== bbAfter.h) {
         session.rotationsObserved++;
         session.events.push({ type: "piece_rotated", frame: session.frames });
       } else {
         // Bounding box same size but cells may have moved within it
         // Accept as rotation if grid changed and piece cells differ
         const keyBefore = cellsBefore.map(([r, c]) => `${r},${c}`).sort().join("|");
         const keyAfter = cellsAfter.map(([r, c]) => `${r},${c}`).sort().join("|");
         if (keyBefore !== keyAfter) {
           session.rotationsObserved++;
           session.events.push({ type: "piece_rotated", frame: session.frames });
         }
       }
     } else {
       // Could not detect piece cells but grid changed after rotate key.
       // Mark as rotation observed (grid-verified change, just can't confirm shape).
       session.rotationsObserved++;
       session.events.push({ type: "piece_rotated", frame: session.frames });
     }
   }
 
   // Hard drop test: press drop and verify piece appeared at bottom
   const gridBeforeDrop = await readGrid(page, cal);
   if (gridBeforeDrop) session.gridReadSuccess++;
   else session.gridReadFail++;
   session.frames++;
 
   await page.keyboard.press(cal.controls.drop);
   await page.waitForTimeout(500);
 
   const gridAfterDrop = await readGrid(page, cal);
   if (gridAfterDrop) session.gridReadSuccess++;
   else session.gridReadFail++;
   session.frames++;
 
   if (gridBeforeDrop && gridAfterDrop && gridsAreDifferent(gridBeforeDrop, gridAfterDrop)) {
     const bottomFilled = countFilledInBottomRows(gridAfterDrop, 5);
     if (bottomFilled > 0) {
       session.hardDropsObserved++;
       session.piecesLocked++;
       session.events.push({ type: "hard_drop", frame: session.frames });
       session.events.push({ type: "piece_locked", frame: session.frames, filledDelta: bottomFilled });
     }
   }
 
   // New piece spawns: after hard drop, check if piece appeared at top
   await page.waitForTimeout(500);
   const gridAfterSpawn = await readGrid(page, cal);
   if (gridAfterSpawn) {
     session.gridReadSuccess++;
     session.frames++;
     if (hasFilledInTopRows(gridAfterSpawn, 4)) {
       session.piecesSpawned++;
       const cells = detectActivePieceCells(gridAfterSpawn, gridAfterDrop);
       if (cells) {
         const pt = identifyPieceType(cells);
         session.pieceTypes.add(pt);
         session.events.push({ type: "piece_spawned", pieceType: pt, frame: session.frames });
       }
     }
   } else {
     session.gridReadFail++;
     session.frames++;
   }
 
   // Piece locks test: verify filled cells persist
   const gridPersist1 = await readGrid(page, cal);
   await page.waitForTimeout(2000);
   const gridPersist2 = await readGrid(page, cal);
   if (gridPersist1 && gridPersist2) {
     session.gridReadSuccess += 2;
     session.frames += 2;
     const bottom1 = countFilledInBottomRows(gridPersist1, 4);
     const bottom2 = countFilledInBottomRows(gridPersist2, 4);
     if (bottom1 > 0 && bottom2 >= bottom1) {
       // Cells persisted -- piece is locked
       if (session.piecesLocked === 0) session.piecesLocked++;
     }
   }
 }
 
 /**
  * Extended gameplay phase with integrated score tracking.
  * Plays up to 60 pieces / 45 seconds using the AI, reads score on every
  * poll cycle, and falls back to brute-force line clearing if needed.
  */
 async function runGameplayPhase(
   page: Page,
   cal: CalibrationResult,
   session: GameSession,
   gameplay: GameplayStats
 ): Promise<void> {
   const gridBefore = await readGrid(page, cal);
   const filledBefore = gridBefore ? countFilled(gridBefore) : 0;
   if (gridBefore) {
     session.gridReadSuccess++;
   } else {
     session.gridReadFail++;
   }
   session.frames++;
 
   // Read initial score before play begins
   if (cal.scoreElementSelector) {
     try {
       const scoreText = await page.textContent(cal.scoreElementSelector);
       const nums = extractScoreFromText(scoreText);
       const val = Math.max(...nums);
       session.scoreValues.push(val);
     } catch { /* ignore */ }
   }
 
   // Play strategically using the AI with integrated score tracking
   const result = await playGame(page, cal, {
     maxPieces: 60,
     maxDurationMs: 45000,
     scoreSelector: cal.scoreElementSelector ?? undefined,
   });
   gameplay.pieces_placed += result.piecesPlaced;
   gameplay.errors_during_play += result.errors;
   session.gridReadSuccess += result.gridReads;
   session.gridReadFail += result.gridReadFails;
   session.frames += result.gridReads + result.gridReadFails;
   session.piecesLocked += result.piecesPlaced;
 
   // Merge score values collected during play
   for (const sv of result.scoreValues) {
     session.scoreValues.push(sv);
     if (sv > gameplay.max_score_observed) {
       gameplay.max_score_observed = sv;
     }
   }
 
   if (result.linesCleared > 0) {
     session.linesCleared += result.linesCleared;
     gameplay.lines_cleared += result.linesCleared;
     for (let i = 0; i < result.linesCleared; i++) {
       session.events.push({ type: "line_cleared", count: 1, frame: session.frames });
     }
   }
 
   // Read final score after play
   if (cal.scoreElementSelector) {
     try {
       const scoreText = await page.textContent(cal.scoreElementSelector);
       const nums = extractScoreFromText(scoreText);
       const val = Math.max(...nums);
       session.scoreValues.push(val);
       if (val > gameplay.max_score_observed) {
         gameplay.max_score_observed = val;
       }
     } catch { /* ignore */ }
   }
 
   // If no score element found, try to detect changing numbers on page
   if (!cal.scoreElementSelector && session.scoreValues.length === 0) {
     try {
       const textBefore = await page.evaluate(() => document.body.innerText);
       const numbersBefore = (textBefore.match(/\d+/g) || []).map(Number);
 
       await page.keyboard.press(cal.controls.drop);
       await page.waitForTimeout(500);
 
       const textAfter = await page.evaluate(() => document.body.innerText);
       const numbersAfter = (textAfter.match(/\d+/g) || []).map(Number);
 
       for (let i = 0; i < Math.min(numbersBefore.length, numbersAfter.length); i++) {
         if (numbersAfter[i] > numbersBefore[i]) {
           session.scoreValues.push(numbersBefore[i], numbersAfter[i]);
           if (numbersAfter[i] > gameplay.max_score_observed) {
             gameplay.max_score_observed = numbersAfter[i];
           }
           break;
         }
       }
     } catch { /* ignore */ }
   }
 
   // Record pieces for multi-piece detection
   if (result.piecesPlaced > 0) {
     session.events.push({
       type: "piece_locked",
       frame: session.frames,
       filledDelta: result.piecesPlaced * 4,
     });
   }
 
   // If no lines cleared by AI, try brute-force approach
   if (session.linesCleared === 0) {
     const cleared = await tryFillRow(page, cal, 10);
     gameplay.pieces_placed += 10;
     if (cleared) {
       session.linesCleared++;
       gameplay.lines_cleared++;
       session.events.push({ type: "line_cleared", count: 1, frame: session.frames });
     }
   }
 
   // Check if total filled decreased (indicates clearing happened)
   if (session.linesCleared === 0) {
     const gridAfter = await readGrid(page, cal);
     const filledAfter = gridAfter ? countFilled(gridAfter) : 0;
     if (filledAfter < filledBefore && filledBefore > 0) {
       session.linesCleared++;
       gameplay.lines_cleared++;
       session.events.push({ type: "line_cleared", count: 1, frame: session.frames });
     }
   }
 }
 
 /**
  * Stack pieces to trigger game over using grid reader verification.
  *
  * Instead of screenshot comparison (which false-positives on static screens),
  * we:
  * 1. Hard drop 30-40 pieces rapidly in the same column to build a tower
  * 2. After each batch of 5 drops, check grid for filled cells in the top 4 rows
  * 3. If top rows are filled AND new drops don't change the grid, game is over
  * 4. Also check for "game over" text in DOM as a secondary signal
  */
 async function runGameOverPhase(
   page: Page,
   cal: CalibrationResult,
   session: GameSession
 ): Promise<void> {
   const MAX_DROPS = 40;
   const BATCH_SIZE = 5;
 
   for (let i = 0; i < MAX_DROPS; i++) {
     await page.keyboard.press(cal.controls.drop);
     await page.waitForTimeout(150);
 
     // Check after each batch of drops
     if ((i + 1) % BATCH_SIZE === 0) {
       const grid = await readGrid(page, cal);
       if (grid) {
         session.gridReadSuccess++;
         session.frames++;
 
         if (hasFilledInTopRows(grid, 4)) {
           // Top rows are filled -- check if new drops actually change the grid
           await page.keyboard.press(cal.controls.drop);
           await page.waitForTimeout(300);
           const gridAfter = await readGrid(page, cal);
           if (gridAfter) {
             session.gridReadSuccess++;
             session.frames++;
             if (!gridsAreDifferent(grid, gridAfter)) {
               // Grid didn't change after a drop -- game is over
               session.gameOverDetected = true;
               session.events.push({ type: "game_over", frame: session.frames });
               return;
             }
           }
         }
       } else {
         session.gridReadFail++;
         session.frames++;
       }
     }
   }
 
   // Final check: look for game over text in DOM
   try {
     const hasGameOverText = await page.evaluate(() => {
       const text = document.body.innerText.toLowerCase();
       return (
         text.includes("game over") ||
         text.includes("gameover") ||
         text.includes("you lose") ||
         text.includes("try again") ||
         text.includes("play again")
       );
     });
     if (hasGameOverText) {
       // Only trust DOM text if we also saw pieces in the grid (prevents false
       // positives from static pages that happen to have "restart" text)
       const finalGrid = await readGrid(page, cal);
       if (finalGrid && countFilled(finalGrid) > 10) {
         session.gameOverDetected = true;
         session.events.push({ type: "game_over", frame: session.frames });
       }
     }
   } catch { /* ignore */ }
 }
 
 /**
  * Play for 30 seconds and track stability.
  */
 async function runEndurancePhase(
   page: Page,
   cal: CalibrationResult,
   session: GameSession,
   gameplay: GameplayStats,
   consoleErrors: string[]
 ): Promise<void> {
   const errorsBefore = consoleErrors.length;
   const start = Date.now();
 
   const result = await playGame(page, cal, { maxDurationMs: 30000 });
 
   const elapsed = Math.round((Date.now() - start) / 1000);
   gameplay.pieces_placed += result.piecesPlaced;
   gameplay.lines_cleared += result.linesCleared;
   session.linesCleared += result.linesCleared;
   gameplay.play_duration_seconds += elapsed;
   gameplay.errors_during_play += result.errors;
   session.gridReadSuccess += result.gridReads;
   session.gridReadFail += result.gridReadFails;
   session.frames += result.gridReads + result.gridReadFails;
 
   // Record endurance errors
   const newErrors = consoleErrors.slice(errorsBefore);
   for (const e of newErrors) {
     if (!session.consoleErrors.includes(e)) session.consoleErrors.push(e);
   }
 }
 
 /**
  * Phase 8: Competitive play.
  * Play for 60 seconds with the AI, tracking detailed metrics for bug detection.
  */
 async function runCompetitivePlayPhase(
   page: Page,
   cal: CalibrationResult,
   session: GameSession,
   gameplay: GameplayStats
 ): Promise<CompetitivePlayResult> {
   const start = Date.now();
   const maxDuration = 60000;
 
   const result: CompetitivePlayResult = {
     duration_seconds: 0,
     pieces_placed: 0,
     total_lines_cleared: 0,
     single_clears: 0,
     double_clears: 0,
     triple_clears: 0,
     tetris_clears: 0,
     max_combo: 0,
     score_readings: [],
     score_final: 0,
     score_increases: [],
     level_readings: [],
     level_final: 0,
     game_over_reached: false,
     game_over_text_found: null,
     restart_available: false,
     next_piece_visible: false,
     speed_increased: false,
     bugs_detected: [],
   };
 
   // Read initial score
   let lastScore = 0;
   if (cal.scoreElementSelector) {
     try {
       const scoreText = await page.textContent(cal.scoreElementSelector);
       const nums = extractScoreFromText(scoreText);
       lastScore = Math.max(...nums);
       result.score_readings.push(lastScore);
     } catch { /* ignore */ }
   }
 
   // Read initial level
   const initialLevel = await readLevelFromPage(page);
   if (initialLevel !== null) {
     result.level_readings.push(initialLevel);
   }
 
   // Measure initial drop speed (time between auto-drops)
   const initialDropInterval = await measureDropInterval(page, cal);
 
   // Play the game with detailed tracking
   let previousGrid = await readGrid(page, cal);
   let settledGrid = previousGrid;
   let pollCount = 0;
   let consecutiveClears = 0;
   let maxCombo = 0;
   let ccwTestDone = false;
   let ccwResult: boolean | null = null;
   let softDropTestDone = false;
   let softDropDistinct: boolean | null = null;
 
   // Rendering trail detection: track filled cell growth vs pieces placed
   let filledCellSamples: number[] = [];
   let trailCheckPieceMark = 0;
 
   while (Date.now() - start < maxDuration) {
     try {
       const grid = await readGrid(page, cal);
       pollCount++;
 
       if (!grid) {
         await page.waitForTimeout(60);
         continue;
       }
 
       // Score tracking every 5th poll
       if (pollCount % 5 === 0 && cal.scoreElementSelector) {
         try {
           const scoreText = await page.textContent(cal.scoreElementSelector);
           const nums = extractScoreFromText(scoreText);
           const currentScore = Math.max(...nums);
           if (currentScore > 0) {
             result.score_readings.push(currentScore);
             if (currentScore > lastScore) {
               result.score_increases.push(currentScore - lastScore);
               lastScore = currentScore;
             }
           }
         } catch { /* ignore */ }
       }
 
       // Level tracking every 10th poll
       if (pollCount % 10 === 0) {
         const level = await readLevelFromPage(page);
         if (level !== null) {
           result.level_readings.push(level);
         }
       }
 
       // Detect line clears by watching for complete rows then checking if they disappear
       if (previousGrid && grid) {
         const completeRowsBefore = countCompleteRows(previousGrid);
         const completeRowsNow = countCompleteRows(grid);
         const filledBefore = countFilled(previousGrid);
         const filledNow = countFilled(grid);
 
         // Detect a clear: filled count dropped and rows disappeared
         if (filledNow < filledBefore - 5 && filledBefore > 10) {
           // Estimate how many rows were cleared
           const clearedCount = Math.round((filledBefore + 4 - filledNow) / 10);
           if (clearedCount > 0 && clearedCount <= 4) {
             result.total_lines_cleared += clearedCount;
             consecutiveClears++;
             if (consecutiveClears > maxCombo) maxCombo = consecutiveClears;
 
             switch (clearedCount) {
               case 1: result.single_clears++; break;
               case 2: result.double_clears++; break;
               case 3: result.triple_clears++; break;
               case 4: result.tetris_clears++; break;
             }
           }
         } else {
           consecutiveClears = 0;
         }
       }
 
       // Try to detect and place pieces
       const activeCells = detectActivePieceCells(grid, settledGrid);
       if (activeCells && activeCells.length === 4) {
         const pieceType = identifyPieceType(activeCells);
         session.pieceTypes.add(pieceType);
 
         // Counter-clockwise rotation test: press Z and compare
         if (!ccwTestDone && result.pieces_placed > 5 && result.pieces_placed % 7 === 0) {
           const gridBeforeZ = await readGrid(page, cal);
           await page.keyboard.press("z");
           await page.waitForTimeout(60);
           const gridAfterZ = await readGrid(page, cal);
 
           if (gridBeforeZ && gridAfterZ && gridsAreDifferent(gridBeforeZ, gridAfterZ)) {
             // Z key caused a change -- now check if it's different from ArrowUp
             const gridBeforeUp = await readGrid(page, cal);
             await page.keyboard.press(cal.controls.rotate);
             await page.waitForTimeout(60);
             const gridAfterUp = await readGrid(page, cal);
 
             if (gridBeforeUp && gridAfterUp) {
               // If Z and Up produce different results, Z is counter-clockwise
               ccwResult = gridsAreDifferent(gridAfterZ, gridAfterUp);
               ccwTestDone = true;
             }
           } else {
             ccwResult = false; // Z did nothing
             ccwTestDone = true;
           }
         }
 
         // Soft drop test: press Down and check it moves 1 row, not to bottom
         if (!softDropTestDone && result.pieces_placed > 3 && result.pieces_placed % 5 === 0) {
           const gridBeforeDown = await readGrid(page, cal);
           await page.keyboard.press(cal.controls.down);
           await page.waitForTimeout(60);
           const gridAfterDown = await readGrid(page, cal);
 
           if (gridBeforeDown && gridAfterDown) {
             const cellsBefore = detectActivePieceCells(gridBeforeDown, settledGrid);
             const cellsAfter = detectActivePieceCells(gridAfterDown, settledGrid);
             if (cellsBefore && cellsAfter) {
               const avgRowBefore = cellsBefore.reduce((s, [r]) => s + r, 0) / cellsBefore.length;
               const avgRowAfter = cellsAfter.reduce((s, [r]) => s + r, 0) / cellsAfter.length;
               const rowDelta = avgRowAfter - avgRowBefore;
               // Soft drop should move ~1 row, hard drop moves many rows
               softDropDistinct = rowDelta >= 0.5 && rowDelta <= 3;
               softDropTestDone = true;
             }
           }
         }
 
         // Rendering trail sampling: every ~10 pieces, snapshot filled count
         if (result.pieces_placed > 0 && result.pieces_placed % 10 === 0 && result.pieces_placed !== trailCheckPieceMark) {
           trailCheckPieceMark = result.pieces_placed;
           const sampleGrid = await readGrid(page, cal);
           if (sampleGrid) {
             filledCellSamples.push(countFilled(sampleGrid));
           }
         }
 
         // Execute the AI placement
         await page.keyboard.press(cal.controls.drop);
         await page.waitForTimeout(100);
         result.pieces_placed++;
 
         const afterGrid = await readGrid(page, cal);
         if (afterGrid) settledGrid = afterGrid;
       }
 
       previousGrid = grid;
       await page.waitForTimeout(60);
     } catch {
       await page.waitForTimeout(60);
     }
   }
 
   result.duration_seconds = Math.round((Date.now() - start) / 1000);
   result.max_combo = maxCombo;
 
   // Read final score
   if (cal.scoreElementSelector) {
     try {
       const scoreText = await page.textContent(cal.scoreElementSelector);
       const nums = extractScoreFromText(scoreText);
       result.score_final = Math.max(...nums);
       result.score_readings.push(result.score_final);
     } catch { /* ignore */ }
   }
 
   // Read final level
   const finalLevel = await readLevelFromPage(page);
   if (finalLevel !== null) {
     result.level_final = finalLevel;
     result.level_readings.push(finalLevel);
   }
 
   // Measure final drop speed
   const finalDropInterval = await measureDropInterval(page, cal);
   if (initialDropInterval > 0 && finalDropInterval > 0 && finalDropInterval < initialDropInterval * 0.8) {
     result.speed_increased = true;
   }
 
   // Check for game over
   try {
     const gameOverText = await page.evaluate(() => {
       const text = document.body.innerText.toLowerCase();
       if (text.includes("game over")) return "Game Over";
       if (text.includes("gameover")) return "GameOver";
       if (text.includes("you lose")) return "You Lose";
       return null;
     });
     if (gameOverText) {
       result.game_over_reached = true;
       result.game_over_text_found = gameOverText;
     }
   } catch { /* ignore */ }
 
   // Check for restart button
   try {
     result.restart_available = await page.evaluate(() => {
       const text = document.body.innerText.toLowerCase();
       const buttons = document.querySelectorAll("button");
       for (const btn of buttons) {
         const btnText = (btn.textContent || "").toLowerCase();
         if (btnText.includes("restart") || btnText.includes("play again") || btnText.includes("new game")) {
           return true;
         }
       }
       return text.includes("restart") || text.includes("play again") || text.includes("press") || text.includes("try again");
     });
   } catch { /* ignore */ }
 
   // Check for next piece preview
   result.next_piece_visible = await detectNextPiecePreview(page);
 
   // Bug detection
   // Multi-line clear bug: if we had multi-line opportunities but only single clears happened
   if (result.double_clears + result.triple_clears + result.tetris_clears === 0 &&
       result.single_clears > 5 && result.total_lines_cleared > 5) {
     // This might not be a bug -- maybe no multi-line opportunities arose
     // Only flag if we detect specific evidence
   }
 
   // Score scaling bug
   if (result.score_increases.length > 3) {
     const singleDeltas = result.score_increases.filter((d) => d > 0 && d <= 200);
     const multiDeltas = result.score_increases.filter((d) => d > 200);
     if (singleDeltas.length > 0 && multiDeltas.length === 0 &&
         (result.double_clears + result.triple_clears + result.tetris_clears) > 0) {
       result.bugs_detected.push("score_does_not_scale_with_simultaneous_clears");
     }
   }
 
   // Level progression bug
   if (result.level_readings.length > 1) {
     const uniqueLevels = [...new Set(result.level_readings)];
     if (uniqueLevels.length === 1 && result.total_lines_cleared >= 10) {
       result.bugs_detected.push("level_does_not_increase");
     }
   }
 
   // Speed progression bug
   if (result.level_readings.length > 1) {
     const uniqueLevels = [...new Set(result.level_readings)];
     if (uniqueLevels.length > 1 && !result.speed_increased) {
       result.bugs_detected.push("speed_does_not_increase");
     }
   }
 
   // Rendering trail detection: if filled cells grow much faster than pieces placed,
   // the renderer is leaving trails (old piece positions not cleared)
   if (result.pieces_placed >= 10 && filledCellSamples.length >= 2) {
     // In a normal game, filled cells = locked cells - cleared cells.
     // Each piece adds 4 cells, each line clear removes 10.
     // With trails, filled cells grow unchecked because old positions stay colored.
     // Heuristic: if filled count exceeds pieces_placed * 8, trails are likely.
     // (Normal max without any clears would be pieces * 4; * 8 gives 2x headroom.)
     const maxFilled = Math.max(...filledCellSamples);
     if (maxFilled > result.pieces_placed * 8) {
       result.rendering_trail_detected = true;
       result.bugs_detected.push("rendering_trail");
     } else {
       // Also check if filled cells only ever increase across samples (never decrease
       // from line clears) AND the latest sample is unreasonably high
       const onlyIncreasing = filledCellSamples.every((v, i) =>
         i === 0 || v >= filledCellSamples[i - 1]
       );
       if (onlyIncreasing && filledCellSamples.length >= 3 && maxFilled > result.pieces_placed * 6) {
         result.rendering_trail_detected = true;
         result.bugs_detected.push("rendering_trail");
       } else {
         result.rendering_trail_detected = false;
       }
     }
   }
 
   // Store CCW and soft drop results for test derivation
   (result as any)._ccwResult = ccwResult;
   (result as any)._ccwTestDone = ccwTestDone;
   (result as any)._softDropDistinct = softDropDistinct;
   (result as any)._softDropTestDone = softDropTestDone;
 
   return result;
 }
 
 // ---- Derive test results from session data ----
 
 const ALL_TEST_NAMES = [
   // Phase 1
   "game_loads",
   // Phase 2
   "game_starts",
   "auto_drop",
   // Phase 3: Mechanics
   "move_left",
   "move_right",
   "move_down",
   "rotate",
   "hard_drop",
   "all_pieces_rotate",
   // Phase 4: Piece lifecycle
   "piece_locks",
   "new_piece_spawns",
   "multiple_pieces",
   // Phase 5: Gameplay
   "line_clear",
   "score_changes",
   // Phase 6: Game over
   "game_over",
   // Phase 7: Endurance
   "playable_30s",
   // Phase 8: Competitive play (tests 17-24)
   "multi_line_clear",
   "score_scaling",
   "level_progression",
   "speed_progression",
   "next_piece_preview",
   "game_over_display",
   "counter_clockwise_rotation",
   "soft_drop_distinct",
   // Phase 8 continued: rendering quality (test 25)
   "rendering_clean",
 ];
 
 interface PhaseState {
   gameStarted: boolean;
   mechanicsWork: boolean;
   piecesWork: boolean;
   gameplayWorks: boolean;
 }
 
 function deriveTestResults(
   session: GameSession,
   cal: CalibrationResult,
   loadResult: LoadResult,
   consoleErrors: string[],
   gameplay: GameplayStats,
   phaseState: PhaseState,
   competitivePlay: CompetitivePlayResult | null
 ): TestResult[] {
   const results: TestResult[] = [];
   const gridReliable = session.gridReadSuccess > 0 &&
     session.gridReadSuccess / (session.gridReadSuccess + session.gridReadFail) > 0.5;
 
   // Helper: produce a skip result for tests whose prerequisite phase was skipped
   const skipResult = (name: string, reason: string): TestResult => ({
     name,
     pass: false,
     detail: `skipped: ${reason}`,
   });
 
   // 1. game_loads
   results.push({
     name: "game_loads",
     pass: loadResult.loaded && loadResult.errorsOnLoad === 0,
     detail: loadResult.detail,
   });
 
   // 2. game_starts
   {
     let startDetail: string;
     if (session.started) {
       startDetail = `started via ${session.startMechanism}`;
       if (cal.startButton) {
         const btn = cal.startButton;
         startDetail += ` (${btn.selector}, "${btn.text}"${btn.disappeared ? ", disappeared after click" : ""})`;
       }
     } else {
       startDetail = "could not start game with any mechanism";
     }
     results.push({
       name: "game_starts",
       pass: session.started,
       detail: startDetail,
     });
   }
 
   // 3. auto_drop -- MUST be verified via grid reader
   if (!phaseState.gameStarted) {
     results.push(skipResult("auto_drop", "game did not start"));
   } else {
     const autoDropEvents = session.events.filter(
       (e) => e.type === "piece_moved" && e.direction === "down" &&
         // Only count the first few frames (before we sent any input)
         e.frame <= 2
     );
     if (autoDropEvents.length > 0) {
       results.push({
         name: "auto_drop",
         pass: true,
         detail: "grid state changed after 5s with no input (grid-verified)",
       });
     } else if (!gridReliable) {
       results.push({
         name: "auto_drop",
         pass: false,
         detail: "grid reader unreliable, cannot verify auto-drop",
       });
     } else {
       results.push({
         name: "auto_drop",
         pass: false,
         detail: "piece did not move down in 5 seconds (grid-verified)",
       });
     }
   }
 
   // 4-6. movement tests
   for (const dir of ["left", "right", "down"] as const) {
     if (!phaseState.gameStarted) {
       results.push(skipResult(`move_${dir}`, "game did not start"));
       continue;
     }
     const moveEvents = session.events.filter(
       (e) => e.type === "piece_moved" && e.direction === dir
     );
     if (moveEvents.length > 0) {
       results.push({
         name: `move_${dir}`,
         pass: true,
         detail: "grid state changed after key press (grid-verified)",
       });
     } else if (!gridReliable) {
       results.push({
         name: `move_${dir}`,
         pass: false,
         detail: "grid reader unreliable, cannot verify movement",
       });
     } else {
       results.push({
         name: `move_${dir}`,
         pass: false,
         detail: "no grid change detected after key press",
       });
     }
   }
 
   // 7. rotate
   if (!phaseState.gameStarted) {
     results.push(skipResult("rotate", "game did not start"));
   } else if (session.rotationsObserved > 0) {
     results.push({
       name: "rotate",
       pass: true,
       detail: `piece shape changed after rotate key (grid-verified, ${session.rotationsObserved} rotation(s))`,
     });
   } else if (!gridReliable) {
     results.push({
       name: "rotate",
       pass: false,
       detail: "grid reader unreliable, cannot verify rotation",
     });
   } else {
     results.push({
       name: "rotate",
       pass: false,
       detail: "no shape change detected after rotate key",
     });
   }
 
   // 8. hard_drop
   if (!phaseState.gameStarted) {
     results.push(skipResult("hard_drop", "game did not start"));
   } else if (session.hardDropsObserved > 0) {
     results.push({
       name: "hard_drop",
       pass: true,
       detail: "piece immediately dropped to bottom (grid-verified)",
     });
   } else if (!gridReliable) {
     results.push({
       name: "hard_drop",
       pass: false,
       detail: "grid reader unreliable, cannot verify hard drop",
     });
   } else {
     results.push({
       name: "hard_drop",
       pass: false,
       detail: "no grid change with bottom cells detected after hard drop key",
     });
   }
 
   // 9. all_pieces_rotate -- derived from piece types seen
   if (!phaseState.gameStarted) {
     results.push(skipResult("all_pieces_rotate", "game did not start"));
   } else {
     const nonOPieceTypes = [...session.pieceTypes].filter((t) => t !== "O" && t !== "unknown");
     if (session.rotationsObserved > 0 && nonOPieceTypes.length > 0) {
       results.push({
         name: "all_pieces_rotate",
         pass: true,
         detail: `rotation observed, piece types seen: [${[...session.pieceTypes].join(", ")}]`,
       });
     } else if (session.rotationsObserved > 0) {
       results.push({
         name: "all_pieces_rotate",
         pass: true,
         detail: "rotation confirmed but could not identify individual piece types",
       });
     } else {
       results.push({
         name: "all_pieces_rotate",
         pass: false,
         detail: "could not detect any piece rotations via grid reader",
       });
     }
   }
 
   // 10. piece_locks -- only trust if grid is reliable
   if (!phaseState.gameStarted) {
     results.push(skipResult("piece_locks", "game did not start"));
   } else if (!gridReliable) {
     results.push({
       name: "piece_locks",
       pass: false,
       detail: "grid reader unreliable, cannot verify piece locking",
     });
   } else {
     const lockEvents = session.events.filter((e) => e.type === "piece_locked");
     if (lockEvents.length > 0) {
       results.push({
         name: "piece_locks",
         pass: true,
         detail: `filled cells persist at bottom (grid-verified, ${lockEvents.length} lock event(s))`,
       });
     } else if (session.piecesLocked > 0 && session.piecesSpawned > 0) {
       results.push({
         name: "piece_locks",
         pass: true,
         detail: `${session.piecesLocked} piece(s) locked during play`,
       });
     } else if (session.piecesLocked > 0 && session.piecesSpawned === 0) {
       results.push({
         name: "piece_locks",
         pass: false,
         detail: `${session.piecesLocked} lock event(s) but 0 spawns detected - likely false positive from UI misread`,
       });
     } else {
       results.push({
         name: "piece_locks",
         pass: false,
         detail: "could not verify piece locking via grid reader",
       });
     }
   }
 
   // 11. new_piece_spawns
   if (!phaseState.gameStarted) {
     results.push(skipResult("new_piece_spawns", "game did not start"));
   } else if (session.piecesSpawned > 0) {
     results.push({
       name: "new_piece_spawns",
       pass: true,
       detail: `${session.piecesSpawned} new piece(s) detected at top of grid`,
     });
   } else {
     results.push({
       name: "new_piece_spawns",
       pass: false,
       detail: "could not detect new piece spawning at top via grid reader",
     });
   }
 
   // 12. multiple_pieces
   if (!phaseState.mechanicsWork) {
     results.push(skipResult("multiple_pieces", "mechanics phase failed"));
   } else if (session.piecesLocked >= 3 && session.piecesSpawned > 0) {
     results.push({
       name: "multiple_pieces",
       pass: true,
       detail: `${session.piecesLocked} pieces placed during play session`,
     });
   } else {
     results.push({
       name: "multiple_pieces",
       pass: false,
       detail: `only ${session.piecesLocked} piece(s) detected, need at least 3`,
     });
   }
 
   // 13. line_clear
   if (!phaseState.mechanicsWork) {
     results.push(skipResult("line_clear", "mechanics phase failed"));
   } else if (session.linesCleared > 0) {
     results.push({
       name: "line_clear",
       pass: true,
       detail: `${session.linesCleared} line(s) cleared (grid-verified)`,
     });
   } else {
     results.push({
       name: "line_clear",
       pass: false,
       detail: "could not trigger or detect a line clear via grid reader",
     });
   }
 
   // 14. score_changes
   if (!phaseState.mechanicsWork) {
     results.push(skipResult("score_changes", "mechanics phase failed"));
   } else if (session.scoreValues.length >= 2) {
     const min = Math.min(...session.scoreValues);
     const max = Math.max(...session.scoreValues);
     if (max > min) {
       results.push({
         name: "score_changes",
         pass: true,
         detail: `score changed from ${min} to ${max}`,
       });
     } else {
       results.push({
         name: "score_changes",
         pass: false,
         detail: `score stayed at ${min}`,
       });
     }
   } else if (cal.scoreElementSelector === null) {
     results.push({
       name: "score_changes",
       pass: false,
       detail: "no score element found",
     });
   } else {
     results.push({
       name: "score_changes",
       pass: false,
       detail: "could not read score values",
     });
   }
 
   // 15. game_over -- requires pieces to work
   if (!phaseState.piecesWork) {
     results.push(skipResult("game_over", "piece lifecycle failed"));
   } else {
     results.push({
       name: "game_over",
       pass: session.gameOverDetected,
       detail: session.gameOverDetected
         ? "game stopped after stacking to top (grid-verified)"
         : "could not trigger or detect game over via grid reader",
     });
   }
 
   // 16. playable_30s -- requires gameplay to have worked
   if (!phaseState.gameplayWorks) {
     results.push(skipResult("playable_30s", "gameplay phase failed"));
   } else {
     const crashed = session.consoleErrors.length > 0 || gameplay.errors_during_play > 3;
     if (!crashed && gameplay.play_duration_seconds >= 10) {
       results.push({
         name: "playable_30s",
         pass: true,
         detail: `played for ${gameplay.play_duration_seconds}s, placed ${gameplay.pieces_placed} pieces, no crashes`,
       });
     } else if (crashed) {
       results.push({
         name: "playable_30s",
         pass: false,
         detail: `${session.consoleErrors.length} console error(s), ${gameplay.errors_during_play} play errors`,
       });
     } else {
       results.push({
         name: "playable_30s",
         pass: false,
         detail: `only played for ${gameplay.play_duration_seconds}s`,
       });
     }
   }
 
   // ---- Phase 8: Competitive play tests (17-24) ----
 
   // 17. multi_line_clear
   if (!phaseState.gameplayWorks || !competitivePlay) {
     results.push(skipResult("multi_line_clear", "competitive play phase did not run"));
   } else if (competitivePlay.double_clears + competitivePlay.triple_clears + competitivePlay.tetris_clears > 0) {
     const hasMultiLineBug = competitivePlay.bugs_detected.includes("multi_line_clear_only_removes_one_row");
     results.push({
       name: "multi_line_clear",
       pass: !hasMultiLineBug,
       detail: hasMultiLineBug
         ? "multi-line clear detected but only 1 row was removed"
         : `multi-line clears work: ${competitivePlay.double_clears}x double, ${competitivePlay.triple_clears}x triple, ${competitivePlay.tetris_clears}x tetris`,
     });
   } else {
     results.push(skipResult("multi_line_clear", "no multi-line clear opportunity occurred during play"));
   }
 
   // 18. score_scaling
   if (!phaseState.gameplayWorks || !competitivePlay) {
     results.push(skipResult("score_scaling", "competitive play phase did not run"));
   } else if (competitivePlay.double_clears + competitivePlay.triple_clears + competitivePlay.tetris_clears > 0) {
     const hasBug = competitivePlay.bugs_detected.includes("score_does_not_scale_with_simultaneous_clears");
     results.push({
       name: "score_scaling",
       pass: !hasBug,
       detail: hasBug
         ? "multi-line clears give same points as single clears"
         : `score scales with clear type (${competitivePlay.score_increases.length} score changes observed)`,
     });
   } else {
     results.push(skipResult("score_scaling", "no multi-line clear occurred to test scaling"));
   }
 
   // 19. level_progression
   if (!phaseState.gameplayWorks || !competitivePlay) {
     results.push(skipResult("level_progression", "competitive play phase did not run"));
   } else if (competitivePlay.total_lines_cleared < 10) {
     results.push(skipResult("level_progression", `only ${competitivePlay.total_lines_cleared} lines cleared (need 10+)`));
   } else {
     const hasBug = competitivePlay.bugs_detected.includes("level_does_not_increase");
     if (competitivePlay.level_readings.length < 2) {
       results.push(skipResult("level_progression", "could not read level display"));
     } else {
       results.push({
         name: "level_progression",
         pass: !hasBug,
         detail: hasBug
           ? `level stayed at ${competitivePlay.level_readings[0]} despite ${competitivePlay.total_lines_cleared} lines cleared`
           : `level progressed from ${competitivePlay.level_readings[0]} to ${competitivePlay.level_final}`,
       });
     }
   }
 
   // 20. speed_progression
   if (!phaseState.gameplayWorks || !competitivePlay) {
     results.push(skipResult("speed_progression", "competitive play phase did not run"));
   } else if (competitivePlay.level_readings.length < 2 || new Set(competitivePlay.level_readings).size <= 1) {
     results.push(skipResult("speed_progression", "level did not increase, cannot test speed change"));
   } else {
     const hasBug = competitivePlay.bugs_detected.includes("speed_does_not_increase");
     results.push({
       name: "speed_progression",
       pass: !hasBug && competitivePlay.speed_increased,
       detail: competitivePlay.speed_increased
         ? "drop speed increased with level"
         : "drop speed did not change after level increased",
     });
   }
 
   // 21. next_piece_preview
   if (!phaseState.gameplayWorks || !competitivePlay) {
     results.push(skipResult("next_piece_preview", "competitive play phase did not run"));
   } else {
     results.push({
       name: "next_piece_preview",
       pass: competitivePlay.next_piece_visible,
       detail: competitivePlay.next_piece_visible
         ? "next piece preview display found"
         : "no next piece preview found",
     });
   }
 
   // 22. game_over_display
   if (!phaseState.gameplayWorks || !competitivePlay) {
     results.push(skipResult("game_over_display", "competitive play phase did not run"));
   } else if (!competitivePlay.game_over_reached && !session.gameOverDetected) {
     results.push(skipResult("game_over_display", "game over not reached during play"));
   } else {
     const hasText = competitivePlay.game_over_text_found !== null;
     const hasRestart = competitivePlay.restart_available;
     results.push({
       name: "game_over_display",
       pass: hasText && hasRestart,
       detail: hasText && hasRestart
         ? `game over display: "${competitivePlay.game_over_text_found}", restart available`
         : `missing: ${!hasText ? "game over text" : ""}${!hasText && !hasRestart ? " and " : ""}${!hasRestart ? "restart option" : ""}`,
     });
   }
 
   // 23. counter_clockwise_rotation
   if (!phaseState.gameplayWorks || !competitivePlay) {
     results.push(skipResult("counter_clockwise_rotation", "competitive play phase did not run"));
   } else {
     const ccwTestDone = (competitivePlay as any)._ccwTestDone === true;
     const ccwResult = (competitivePlay as any)._ccwResult;
     if (!ccwTestDone) {
       results.push(skipResult("counter_clockwise_rotation", "could not test rotation direction"));
     } else {
       results.push({
         name: "counter_clockwise_rotation",
         pass: ccwResult === true,
         detail: ccwResult === true
           ? "Z key rotates opposite direction from Up arrow"
           : ccwResult === false
           ? "Z key does same as Up arrow or does not rotate"
           : "could not determine rotation direction",
       });
     }
   }
 
   // 24. soft_drop_distinct
   if (!phaseState.gameplayWorks || !competitivePlay) {
     results.push(skipResult("soft_drop_distinct", "competitive play phase did not run"));
   } else {
     const softDropTestDone = (competitivePlay as any)._softDropTestDone === true;
     const softDropDistinct = (competitivePlay as any)._softDropDistinct;
     if (!softDropTestDone) {
       results.push(skipResult("soft_drop_distinct", "could not test soft drop behavior"));
     } else {
       results.push({
         name: "soft_drop_distinct",
         pass: softDropDistinct === true,
         detail: softDropDistinct === true
           ? "Down arrow moves piece 1 row (distinct from hard drop)"
           : "Down arrow acts like hard drop (drops to bottom)",
       });
     }
   }
 
   // 25. rendering_clean
   if (!phaseState.gameplayWorks || !competitivePlay) {
     results.push(skipResult("rendering_clean", "competitive play phase did not run"));
   } else if (competitivePlay.rendering_trail_detected === undefined) {
     results.push(skipResult("rendering_clean", "not enough data to assess rendering trails"));
   } else {
     results.push({
       name: "rendering_clean",
       pass: !competitivePlay.rendering_trail_detected,
       detail: competitivePlay.rendering_trail_detected
         ? "rendering trail bug: falling piece leaves old cells colored after moving"
         : "piece movement clears old cells correctly",
     });
   }
 
   return results;
 }
 
 // ---- Helpers ----
 
 function countFilledInTopRows(grid: boolean[][], rows: number): number {
   let count = 0;
   for (let r = 0; r < Math.min(rows, grid.length); r++) {
     for (let c = 0; c < grid[r].length; c++) {
       if (grid[r][c]) count++;
     }
   }
   return count;
 }
 
 function boundingBox(cells: [number, number][]): { w: number; h: number } {
   const minRow = Math.min(...cells.map(([r]) => r));
   const maxRow = Math.max(...cells.map(([r]) => r));
   const minCol = Math.min(...cells.map(([, c]) => c));
   const maxCol = Math.max(...cells.map(([, c]) => c));
   return { w: maxCol - minCol + 1, h: maxRow - minRow + 1 };
 }
 
 /**
  * Extract the score number from potentially concatenated text.
  */
 function extractScoreFromText(text: string | null): number[] {
   if (!text) return [0];
 
   const labeledMatch = text.match(/score\s*[:\-=]?\s*(\d+)/i);
   if (labeledMatch) {
     return [parseInt(labeledMatch[1], 10)];
   }
 
   const allNumbers = (text.match(/\d+/g) || []).map(Number);
   return allNumbers.length > 0 ? allNumbers : [0];
 }
 
 async function loadGamePage(page: Page, serverUrl: string): Promise<void> {
   const response = await page.goto(serverUrl, {
     timeout: 15000,
     waitUntil: "networkidle",
   });
   if (!response || !response.ok()) {
     throw new Error(`Failed to load ${serverUrl}: ${response?.status()}`);
   }
   await page.waitForTimeout(1000);
 }
 
 function emptyCalibration(consoleErrors: string[]): CalibrationResult {
   return {
     renderer: "unknown",
     gridDetected: false,
     gridBounds: null,
     cellWidth: 0,
     cellHeight: 0,
     controls: {
       left: "ArrowLeft",
       right: "ArrowRight",
       down: "ArrowDown",
       rotate: "ArrowUp",
       drop: "Space",
     },
     startMechanism: "unknown",
     scoreElementSelector: null,
     backgroundColor: null,
     consoleErrors,
     gridConfidence: 0,
   };
 }
 
 /**
  * Read the level display from the page.
  */
 async function readLevelFromPage(page: Page): Promise<number | null> {
   try {
     return await page.evaluate(() => {
       const allElements = document.querySelectorAll("*");
       for (const el of allElements) {
         const text = ((el as HTMLElement).innerText || "").toLowerCase();
         if (text.includes("level") && el.children.length < 5) {
           const match = text.match(/level\s*[:\-=]?\s*(\d+)/i);
           if (match) return parseInt(match[1], 10);
 
           // Check child elements for a standalone number
           const children = el.querySelectorAll("span, div, p, td, strong, em, b");
           for (const child of children) {
             const childText = (child.textContent || "").trim();
             if (/^\d+$/.test(childText)) return parseInt(childText, 10);
           }
 
           // Check next sibling
           const next = el.nextElementSibling;
           if (next) {
             const nextText = (next.textContent || "").trim();
             if (/^\d+$/.test(nextText)) return parseInt(nextText, 10);
           }
         }
       }
       return null;
     });
   } catch {
     return null;
   }
 }
 
 /**
  * Measure the auto-drop interval by watching for grid changes without input.
  * Returns the average interval in ms, or 0 if unable to measure.
  */
 async function measureDropInterval(
   page: Page,
   cal: CalibrationResult
 ): Promise<number> {
   try {
     const intervals: number[] = [];
     let lastChangeTime = Date.now();
     let prevGrid = await readGrid(page, cal);
 
     for (let i = 0; i < 10; i++) {
       await page.waitForTimeout(100);
       const grid = await readGrid(page, cal);
       if (grid && prevGrid && gridsAreDifferent(grid, prevGrid)) {
         const now = Date.now();
         const interval = now - lastChangeTime;
         if (interval > 50 && interval < 3000) {
           intervals.push(interval);
         }
         lastChangeTime = now;
         prevGrid = grid;
       }
     }
 
     if (intervals.length >= 2) {
       return intervals.reduce((a, b) => a + b, 0) / intervals.length;
     }
   } catch { /* ignore */ }
   return 0;
 }
 
 /**
  * Detect if there's a next piece preview display on the page.
  */
 async function detectNextPiecePreview(page: Page): Promise<boolean> {
   try {
     return await page.evaluate(() => {
       // Check for text mentioning "next"
       const allElements = document.querySelectorAll("*");
       for (const el of allElements) {
         const text = ((el as HTMLElement).innerText || "").toLowerCase();
         if (text.includes("next") && el.children.length < 10) {
           // Check for a canvas or grid-like element nearby
           const rect = (el as HTMLElement).getBoundingClientRect();
           if (rect.width > 20 && rect.height > 20) {
             return true;
           }
         }
       }
 
       // Check for secondary canvases (common next piece implementation)
       const canvases = document.querySelectorAll("canvas");
       if (canvases.length >= 2) {
         // Multiple canvases -- one might be the next piece preview
         const mainCanvas = canvases[0];
         const mainRect = mainCanvas.getBoundingClientRect();
         for (let i = 1; i < canvases.length; i++) {
           const rect = canvases[i].getBoundingClientRect();
           // Next piece preview is typically smaller than the main grid
           if (rect.width < mainRect.width * 0.5 && rect.height < mainRect.height * 0.5 &&
               rect.width > 20 && rect.height > 20) {
             return true;
           }
         }
       }
 
       // Check for a small div/container with "next" in class/id
       const nextContainers = document.querySelectorAll(
         '[class*="next"], [id*="next"], [class*="preview"], [id*="preview"]'
       );
       for (const container of nextContainers) {
         const rect = (container as HTMLElement).getBoundingClientRect();
         if (rect.width > 20 && rect.height > 20) {
           return true;
         }
       }
 
       return false;
     });
   } catch {
     return false;
   }
 }