Remove debugging probe and gdb diagnostic steps

Previous iteration confirmed the sqlite3_finalize re-entry deadlock
and routed its fix. The diagnostic probes (capture failing SQL,
createFunction behavior, testFromBase64 gdb, full-main gdb watchdog)
have all served their purpose and collectively eat ~10 minutes of the
30-minute job budget, leaving the main test run no time to complete.

Drop them all. The main test run now has the full budget and can
produce JUnit XML with clean pass/fail per test.

Author: JanJakes

.github/workflows/phpunit-tests-turso.yml

@@ -1074,205 +1074,6 @@ jobs:
           print('patched CHECK TABLE missing-table check')
           PY
 
-      - name: Capture failing SQL from the first failing driver test
-        continue-on-error: true
-        env:
-          LD_PRELOAD: ${{ steps.preload.outputs.value }}
-        working-directory: packages/mysql-on-sqlite
-        run: |
-          # Reproduce the first failing test's setUp path with a query logger
-          # wired up. The driver replaces any logger during construction, so
-          # we install ours on the driver's own connection afterwards.
-          php <<'PHP'
-          <?php
-          require __DIR__ . '/tests/bootstrap.php';
-
-          $pdo = new PDO('sqlite::memory:');
-          $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
-          $conn = new WP_SQLite_Connection([ 'pdo' => $pdo ]);
-
-          $engine = new WP_SQLite_Driver($conn, 'wp');
-          fwrite(STDERR, "Driver construction ok\n");
-
-          $logged = [];
-          $engine->get_connection()->set_query_logger(
-              function (string $sql, array $params) use (&$logged) {
-                  $logged[] = [$sql, $params];
-              }
-          );
-
-          try {
-              $engine->query("CREATE TABLE _options (
-                  ID INTEGER PRIMARY KEY AUTO_INCREMENT NOT NULL,
-                  option_name TEXT NOT NULL default '',
-                  option_value TEXT NOT NULL default ''
-              );");
-              fwrite(STDERR, "CREATE TABLE _options ok\n");
-          } catch (\Throwable $e) {
-              fwrite(STDERR, "EXC: " . $e->getMessage() . "\n");
-              fwrite(STDERR, "--- last 3 SQL statements sent to SQLite ---\n");
-              foreach (array_slice($logged, -3) as $i => $entry) {
-                  [$sql, $params] = $entry;
-                  fwrite(STDERR, "---\nSQL (length " . strlen($sql) . "):\n" . $sql . "\n");
-                  if ($params) {
-                      fwrite(STDERR, "params: " . json_encode($params) . "\n");
-                  }
-                  fwrite(STDERR, sprintf(
-                      "window [offset 180..209]:\n  %s\n",
-                      substr($sql, 180, 30)
-                  ));
-              }
-          }
-          PHP
-
-      - name: Diagnose createFunction behavior
-        continue-on-error: true
-        env:
-          # Intentionally NOT setting LD_PRELOAD at step level — we enable it
-          # only inside the script so gdb itself doesn't link against Turso.
-          PRELOAD: ${{ steps.preload.outputs.value }}
-        working-directory: packages/mysql-on-sqlite
-        run: |
-          # Progress logging goes to STDERR so it's line-buffered and flushed
-          # before any crash. The PHP script is run under gdb so we get a
-          # backtrace if it segfaults.
-          cat > /tmp/diag.php <<'PHP'
-          <?php
-          $log = fn(string $s) => fwrite(STDERR, $s . "\n");
-
-          $pdo_class = PHP_VERSION_ID >= 80400 ? PDO\SQLite::class : PDO::class;
-          $pdo = new $pdo_class('sqlite::memory:');
-          $log("[a] PDO({$pdo_class}) ok");
-
-          // 1) Closure
-          try {
-              $pdo->createFunction('mk_closure', function ($x) { return $x . '!'; });
-              $log('[b] createFunction(closure) ok');
-              $r = $pdo->query("SELECT mk_closure('x') AS v")->fetch(PDO::FETCH_ASSOC);
-              $log('[b.call] ' . json_encode($r));
-          } catch (\Throwable $e) {
-              $log('[b] EXC ' . $e->getMessage());
-          }
-
-          // 2) String callable
-          try {
-              $pdo->createFunction('mk_builtin', 'md5');
-              $log('[c] createFunction("md5") ok');
-              $r = $pdo->query("SELECT mk_builtin('abc') AS v")->fetch(PDO::FETCH_ASSOC);
-              $log('[c.call] ' . json_encode($r));
-          } catch (\Throwable $e) {
-              $log('[c] EXC ' . $e->getMessage());
-          }
-
-          // 3) [object, method] callable
-          try {
-              $obj = new class {
-                  public function greet($x) { return "hi $x"; }
-              };
-              $pdo->createFunction('mk_method', [$obj, 'greet']);
-              $log('[d] createFunction([obj,method]) ok');
-              $r = $pdo->query("SELECT mk_method('bob') AS v")->fetch(PDO::FETCH_ASSOC);
-              $log('[d.call] ' . json_encode($r));
-          } catch (\Throwable $e) {
-              $log('[d] EXC ' . $e->getMessage());
-          }
-
-          // 4) Reproduce testFromBase64Function in a clean Turso FUNC_SLOTS
-          //    state (skipping earlier [e] UDF registrations which would
-          //    consume slots 0..49 globally in the same process).
-          try {
-              require getcwd() . '/tests/bootstrap.php';
-              $pdo2 = new PDO\SQLite('sqlite::memory:');
-              $pdo2->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
-              $engine = new WP_SQLite_Driver(new WP_SQLite_Connection(['pdo' => $pdo2]), 'wp');
-              $log('[f] driver constructed');
-              $r = $engine->query("SELECT FROM_BASE64('SGVsbG8gV29ybGQ=') AS decoded");
-              $log('[f.call] ' . json_encode($r));
-          } catch (\Throwable $e) {
-              $log('[f] EXC: ' . $e->getMessage());
-          }
-
-          $log('[done] script finished cleanly');
-          PHP
-
-          timeout --kill-after=5 60 gdb -batch \
-              -ex "set confirm off" \
-              -ex "set pagination off" \
-              -ex "set environment LD_PRELOAD=$PRELOAD" \
-              -ex "run /tmp/diag.php" \
-              -ex "bt" \
-              --args "$(command -v php)" || true
-
-      - name: Run PHPUnit testFromBase64Function under gdb
-        continue-on-error: true
-        env:
-          PRELOAD: ${{ steps.preload.outputs.value }}
-        working-directory: packages/mysql-on-sqlite
-        run: |
-          timeout --kill-after=10 120 gdb -batch \
-              -ex "set confirm off" \
-              -ex "set pagination off" \
-              -ex "set environment LD_PRELOAD=$PRELOAD" \
-              -ex "run ./vendor/bin/phpunit -c ./phpunit.xml.dist --filter 'WP_SQLite_Driver_Tests::testFromBase64Function$'" \
-              -ex "bt 40" \
-              --args "$(command -v php)" || true
-
-      - name: Probe full main run with Translation unskipped + gdb watchdog
-        continue-on-error: true
-        env:
-          LD_PRELOAD: ${{ steps.preload.outputs.value }}
-        working-directory: packages/mysql-on-sqlite
-        # Reproduce the 4c4f491 main-run state (Translation_Tests unskipped)
-        # and capture what PHP is actually doing during the hang.
-        #
-        # Timeline budget (~7 min total):
-        #   0-30s: build testcases, run PDO_API + Driver_Tests (fast, ~5k tests)
-        #   30-60s: Metadata_Tests + Translation_Tests (completed at 60s in 45)
-        #   60s: testReconstructTable starts and hangs
-        #   360s: first gdb snapshot (5 min in)
-        #   400s: second gdb snapshot (in case first detached/crashed)
-        #   420s: timeout kills php
-        run: |
-          set +e
-          skip_regex='^(?!WP_MySQL_Server_Suite_).+'
-
-          dump_backtraces() {
-            local label=$1
-            # Target the PHP process (not the timeout wrapper). Use exact name.
-            local PHP_PID
-            PHP_PID=$(pgrep -x php | head -1)
-            if [ -z "$PHP_PID" ]; then
-              echo "=== watchdog ($label): no php pid found ==="
-              return
-            fi
-            echo "=== watchdog ($label): attaching gdb to php pid $PHP_PID ==="
-            # /proc/PID/stack shows what the kernel thinks PHP is waiting for
-            # — free even without ptrace and cheap to read.
-            echo "--- /proc/$PHP_PID/wchan: $(cat /proc/$PHP_PID/wchan 2>/dev/null) ---"
-            echo "--- /proc/$PHP_PID/stack ---"
-            sudo cat /proc/$PHP_PID/stack 2>/dev/null | head -30
-            echo "--- gdb bt ---"
-            sudo gdb -p "$PHP_PID" -batch \
-              -ex 'set pagination off' \
-              -ex 'info threads' \
-              -ex 'thread apply all bt 40' \
-              2>&1 | head -400
-            echo "=== watchdog ($label): done ==="
-          }
-
-          (
-            sleep 360 && dump_backtraces "T+360s"
-            sleep 40 && dump_backtraces "T+400s"
-          ) &
-          WATCHDOG=$!
-
-          timeout --kill-after=10 420 \
-              php ./vendor/bin/phpunit -c ./phpunit.xml.dist --debug \
-                  --filter "$skip_regex" 2>&1 | tail -80
-          echo "full-main+Translation exit: $?"
-
-          wait "$WATCHDOG" 2>/dev/null
-
       - name: Run PHPUnit tests against Turso DB
         env:
           LD_PRELOAD: ${{ steps.preload.outputs.value }}