debug(gxt): instrument cumulative-state leak path

Adds opt-in diagnostic logging behind globalThis.__GXT_LEAK_DEBUG__
(force-enabled in index.html for this CI run; revert once diagnosed).

Instrumentation:
- validator.ts: tags every classic reactor with {id, source, registered-
  AtTest} via WeakMap. _fireClassicReactors logs cross-test fires as
  "LEAK reactor #N src=… regAt=… firedIn=…". __gxtLeakSnapshot dumps
  the live reactor population grouped by source/origin-test.
- renderer.ts: tags _renderComponentGxt's reactor with source=
  "_renderComponentGxt".
- manager.ts: tags renderLinkToElement's reactor with source=
  "renderLinkToElement"; logs every cache-HIT __syncFromUpstream call
  with the live/upstream textarea values — the actual clobber site
  identified for the Textarea cluster.
- index.html: snapshots the reactor Set at testStart / testDone so
  growth between adjacent tests is visible.

Also adds scripts/gxt-test-runner/leak-debug.mjs — a Playwright helper
that opens the dev server, captures browser console.log output, and
prints "[leak-debug]" lines so the multi-module cumulative-state run
can be reproduced locally without testem.

This is a debugging commit, not a fix. Prior 14+ attempts treated the
classic-reactor leak as the root cause but neither global drains nor
self-unsub via isConnected/marker tracking improved the failing 8
testem tests; the actual leak source still needs to be identified
from CI evidence.

Co-Authored-By: Claude Opus 4.7 (1M context) <[email protected]>

Author: lifeart

index.html

@@ -60,6 +60,16 @@
       // after each test, preventing phantom failures from leaked state.
 
       QUnit.testStart(function () {
+        // Leak-debug: record reactor population at start of each test
+        // so the cross-test leak signal becomes visible against a known
+        // baseline. The label includes the upcoming test's name.
+        try {
+          if (typeof globalThis.__gxtLeakSnapshot === 'function') {
+            globalThis.__gxtLeakSnapshot('testStart:' + (QUnit.config.current?.testName || ''));
+          }
+        } catch (_e) {
+          /* ignore */
+        }
         // Signal that we're no longer in a test transition
         globalThis.__gxtTestTransition = false;
         // Reset the operation counter so each test gets a fresh budget
@@ -91,6 +101,15 @@
       });
 
       QUnit.testDone(function () {
+        // Leak-debug: record reactor population at end of each test.
+        // A reactor that survives the cleanup hook is a confirmed leak.
+        try {
+          if (typeof globalThis.__gxtLeakSnapshot === 'function') {
+            globalThis.__gxtLeakSnapshot('testDone:' + (QUnit.config.current?.testName || ''));
+          }
+        } catch (_e) {
+          /* ignore */
+        }
         // Signal that we're between tests — interval timer should not fire
         globalThis.__gxtTestTransition = true;
         // Safety net: reset syncing flag after each test in case it got stuck
@@ -111,6 +130,22 @@
       // during module initialization (before compile.ts sets it)
       globalThis.__GXT_MODE__ = true;
 
+      // Leak diagnostics: enable via QUnit URL param (?gxtLeakDebug=true)
+      // or by setting globalThis.__GXT_LEAK_DEBUG__ before tests start.
+      // When on, validator.ts tags every classic reactor with the test
+      // it was registered in and logs cross-test leaks at fire time.
+      try {
+        var _u = new URL(location.href);
+        if (_u.searchParams.get('gxtLeakDebug') === 'true') {
+          globalThis.__GXT_LEAK_DEBUG__ = true;
+        }
+      } catch (_e) {
+        /* ignore */
+      }
+      // TEMPORARY: force-enable leak diagnostics for CI debugging.
+      // Remove this line once the cumulative-state failures are diagnosed.
+      globalThis.__GXT_LEAK_DEBUG__ = true;
+
       // Global operation counter to detect infinite synchronous loops
       // Any tight loop will increment this. When it exceeds the limit,
       // we throw to break out of the loop.

packages/@ember/-internals/glimmer/lib/renderer.ts

@@ -114,10 +114,10 @@ const touchClassicBridge: () => void =
   typeof (_glimmerValidator as any).touchClassicBridge === 'function'
     ? (_glimmerValidator as any).touchClassicBridge
     : () => {};
-const registerClassicReactor: (cb: () => void) => () => void =
+const registerClassicReactor: (cb: () => void, source?: string) => () => void =
   typeof (_glimmerValidator as any).registerClassicReactor === 'function'
     ? (_glimmerValidator as any).registerClassicReactor
-    : (_: () => void) => () => {};
+    : (_: () => void, _src?: string) => () => {};
 import { tagForObject } from '@ember/-internals/metal';
 import type { SimpleDocument, SimpleElement, SimpleNode } from '@simple-dom/interface';
 import RSVP from 'rsvp';
@@ -2148,7 +2148,7 @@ function _renderComponentGxt(
           // detached-element use case).
         }
         fireReactor();
-      });
+      }, '_renderComponentGxt');
     }
 
     try {

packages/@ember/-internals/gxt-backend/manager.ts

@@ -9516,7 +9516,7 @@ function renderLinkToElement(instance: any, args: any, fw: any): HTMLAnchorEleme
         }
       }
     };
-    unsub = _gxtRegisterClassicReactor(wrapped);
+    unsub = (_gxtRegisterClassicReactor as any)(wrapped, 'renderLinkToElement');
   };
 
   // id attribute (doesn't change over the element's lifetime, so no reactor)
@@ -10067,6 +10067,26 @@ function handleManagedComponent(
       // primitive value equals (a new LocalValue may have been assigned
       // and the old effect is disconnected from it).
       if (inst && inst._value && typeof inst._value.__syncFromUpstream === 'function') {
+        // Leak-debug: this is the final clobber site for typed input
+        // values. A cache HIT here on the next test (after a leaked
+        // reactor triggered re-render) wipes user input.
+        if ((globalThis as any).__GXT_LEAK_DEBUG__) {
+          try {
+            const Q = (globalThis as any).QUnit;
+            const t = Q?.config?.current;
+            const liveVal =
+              cached.liveEl && cached.liveEl.isConnected
+                ? (cached.liveEl as HTMLInputElement).value
+                : '<no-live>';
+            const upstreamVal = inst.value;
+            // eslint-disable-next-line no-console
+            console.log(
+              `[leak-debug] cacheHIT __syncFromUpstream slot=${slotKey} test="${t?.module?.name || ''}::${t?.testName || ''}" live=${JSON.stringify(liveVal)} upstream=${JSON.stringify(upstreamVal)}`
+            );
+          } catch {
+            /* ignore */
+          }
+        }
         inst._value.__syncFromUpstream();
         if (cached.liveEl && cached.liveEl.isConnected) {
           try {

packages/@ember/-internals/gxt-backend/validator.ts

@@ -648,18 +648,84 @@ export function touchClassicBridge(): void {
 // invoked synchronously at the end of dirtyTagFor after the classic tag
 // has been updated but before the runloop flush. Registrants are expected
 // to be idempotent and cheap.
+// === LEAK DIAGNOSTICS ===
+// Each reactor is tagged with metadata at registration time so we can
+// detect cross-test leakage: a reactor registered during test A that
+// fires during test B is by definition a leak. Enabled via the global
+// flag `__GXT_LEAK_DEBUG__` (set in index.html or via URL param).
+interface ReactorMeta {
+  id: number;
+  source: string;
+  registeredAtTest: string;
+  registeredAtTime: number;
+  fireCount: number;
+}
+let _reactorIdCounter = 0;
+const _reactorMeta = new WeakMap<() => void, ReactorMeta>();
 const _classicReactors = new Set<() => void>();
-export function registerClassicReactor(cb: () => void): () => void {
+
+function _currentTestName(): string {
+  try {
+    const Q = (globalThis as any).QUnit;
+    const t = Q?.config?.current;
+    if (t) return `${t.module?.name || ''} :: ${t.testName || ''}`;
+  } catch {
+    /* ignore */
+  }
+  return '<no-test>';
+}
+
+export function registerClassicReactor(cb: () => void, source?: string): () => void {
   _classicReactors.add(cb);
+  if ((globalThis as any).__GXT_LEAK_DEBUG__) {
+    const id = ++_reactorIdCounter;
+    _reactorMeta.set(cb, {
+      id,
+      source: source || '<unknown>',
+      registeredAtTest: _currentTestName(),
+      registeredAtTime: Date.now(),
+      fireCount: 0,
+    });
+    if (id <= 50 || id % 100 === 0) {
+      // eslint-disable-next-line no-console
+      console.log(
+        `[leak-debug] registerClassicReactor #${id} source=${source || '?'} test="${_currentTestName()}" total=${_classicReactors.size}`
+      );
+    }
+  }
   return () => {
     _classicReactors.delete(cb);
+    if ((globalThis as any).__GXT_LEAK_DEBUG__) {
+      _reactorMeta.delete(cb);
+    }
   };
 }
+
 function _fireClassicReactors() {
   if (_classicReactors.size === 0) return;
   // Copy to avoid mutation during iteration
   const snapshot = Array.from(_classicReactors);
+  const debug = (globalThis as any).__GXT_LEAK_DEBUG__;
+  const currentTest = debug ? _currentTestName() : '';
   for (const cb of snapshot) {
+    if (debug) {
+      const meta = _reactorMeta.get(cb);
+      if (meta) {
+        meta.fireCount++;
+        // Cross-test leak: reactor registered during a different test
+        // than the one currently executing.
+        if (
+          meta.registeredAtTest !== '<no-test>' &&
+          currentTest !== '<no-test>' &&
+          meta.registeredAtTest !== currentTest
+        ) {
+          // eslint-disable-next-line no-console
+          console.log(
+            `[leak-debug] LEAK reactor #${meta.id} src=${meta.source} regAt="${meta.registeredAtTest}" firedIn="${currentTest}" fires=${meta.fireCount}`
+          );
+        }
+      }
+    }
     try {
       cb();
     } catch {
@@ -668,6 +734,25 @@ function _fireClassicReactors() {
   }
 }
 
+// Snapshot the reactor population at a checkpoint (testStart / testDone).
+(globalThis as any).__gxtLeakSnapshot = function (label: string) {
+  if (!(globalThis as any).__GXT_LEAK_DEBUG__) return;
+  const buckets = new Map<string, number>();
+  for (const cb of _classicReactors) {
+    const meta = _reactorMeta.get(cb);
+    const key = meta
+      ? `src=${meta.source} regAt="${meta.registeredAtTest}"`
+      : '<no-meta>';
+    buckets.set(key, (buckets.get(key) || 0) + 1);
+  }
+  // eslint-disable-next-line no-console
+  console.log(`[leak-debug] === ${label} === total reactors=${_classicReactors.size}`);
+  for (const [key, count] of buckets) {
+    // eslint-disable-next-line no-console
+    console.log(`[leak-debug]   ${count}× ${key}`);
+  }
+};
+
 // Wrap dirtyTagFor to also bump the global revision AND mark the specific tag as dirty
 const gxtDirtyTagFor = validator.dirtyTagFor;
 

scripts/gxt-test-runner/leak-debug.mjs

@@ -0,0 +1,61 @@
+// Open the local vite dev server in a single browser context, let QUnit run
+// all tests naturally, and capture browser console output to stdout. The
+// __GXT_LEAK_DEBUG__ flag in index.html turns on the instrumentation in
+// validator.ts/manager.ts/renderer.ts.
+//
+// Usage:
+//   node scripts/gxt-test-runner/leak-debug.mjs > /tmp/leak.log
+//   grep -E 'LEAK|cacheHIT' /tmp/leak.log
+//
+// Tunable: GXT_LEAK_TIMEOUT_MS (default 1800000 = 30min).
+
+import { chromium } from 'playwright';
+
+const URL = process.env.GXT_URL || 'http://localhost:5180/';
+const TIMEOUT = Number(process.env.GXT_LEAK_TIMEOUT_MS || 1_800_000);
+
+const browser = await chromium.launch({ headless: true });
+const ctx = await browser.newContext();
+const page = await ctx.newPage();
+
+let lines = 0;
+let leaks = 0;
+let cacheHits = 0;
+page.on('console', (msg) => {
+  const text = msg.text();
+  if (
+    text.includes('[leak-debug]') ||
+    text.includes(' LEAK ') ||
+    text.includes('cacheHIT')
+  ) {
+    if (text.includes('LEAK')) leaks++;
+    if (text.includes('cacheHIT')) cacheHits++;
+    lines++;
+    process.stdout.write(text + '\n');
+  }
+});
+
+page.on('pageerror', (err) => {
+  process.stderr.write('[pageerror] ' + err.message + '\n');
+});
+
+await page.goto(URL, { waitUntil: 'load', timeout: 60_000 });
+
+// Wait for QUnit to complete OR our wall-clock timeout.
+const result = await page.evaluate((timeoutMs) => {
+  return new Promise((resolve) => {
+    if (typeof QUnit === 'undefined') {
+      resolve({ status: 'no-qunit' });
+      return;
+    }
+    const t = setTimeout(() => resolve({ status: 'timeout' }), timeoutMs);
+    QUnit.done((rec) => {
+      clearTimeout(t);
+      resolve({ status: 'done', failed: rec.failed, passed: rec.passed, total: rec.total });
+    });
+  });
+}, TIMEOUT);
+
+process.stdout.write(`---summary--- ${JSON.stringify(result)} lines=${lines} leaks=${leaks} cacheHits=${cacheHits}\n`);
+
+await browser.close();