fix(gxt): tie classic-tag reactors to instance/owner destroy chains

Three idiomatic hooks for the classic-tag reactor leak path that
diagnostic instrumentation (commit 34f9515) confirmed:

1. renderLinkToElement (manager.ts:9519): the LinkTo instance owns
   the reactor's lifetime. Eager unsub via Phase 0 of
   __gxtDestroyTrackedInstances + willDestroy override on the
   instance. The Phase 0 path matters because Ember's classic
   destroy chain is async via the runloop, and willDestroy can fire
   too late to prevent the reactor from leaking across the
   testStart/testDone boundary.

2. _renderComponentGxt (renderer.ts:2287): split doDestroy into
   cleanupReactor (reactor unsub only, no DOM) and full doDestroy
   (also wipes innerHTML). Caller-invoked result.destroy() runs the
   full path; owner-destruction cascades fire only the reactor
   cleanup so a synthetic owner's destroy doesn't wipe a target the
   caller still needs.

3. _gxtPendingRenderCleanups (renderer.ts): a global Set drained by
   __gxtCleanupActiveComponents (the existing cleanup hook fired by
   QUnit testStart and test-case afterEach). This is the layer that
   actually catches the synthetic-owner case: the renderComponent API
   documents `owner = {}` as the default, that synthetic plain object
   is never in any destroy chain, so registerDestructor on it records
   the destructor but it never runs. The pending-cleanup set fires
   eagerly at known cleanup boundaries regardless.

For renderer.ts the wiring also includes the standard
associateDestroyableChild(parentOwner, syntheticOwner) so that callers
who DO destroy their owner properly cascade through the synthetic.
That's the same pattern as the classic GlimmerVM render path
(line 2330) — kept for callers with real destroyable owners.

Diagnostic instrumentation remains in the branch (commit 34f9515)
behind __GXT_LEAK_DEBUG__. Force-enable still set in index.html for
this CI run; will be flipped off once CI confirms the fix.

Smoke (14 modules / 333 tests) green. Local cumulative reproducer
shows leak count reduced significantly (LinkTo source from runaway
to bounded; renderComponent source partially drained — testem CI
tests will show whether the remaining tail still causes test
failures vs the prior 8-failure + browser-hang baseline).

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

Author: lifeart

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

@@ -1746,6 +1746,90 @@ function intoTarget(into: IntoTarget): Cursor {
   }
 }
 
+/**
+ * Set of cleanup functions for active GXT renderComponent calls, drained
+ * by __gxtCleanupActiveComponents (called from QUnit testStart and from
+ * test-case afterEach in internal-test-helpers). Without this, reactors
+ * registered by _renderComponentGxt leak across tests because the
+ * synthetic `{}` owner default is not in any destroy chain — nobody
+ * ever calls destroy() on a freshly-allocated plain object.
+ */
+const _gxtPendingRenderCleanups = new Set<() => void>();
+(globalThis as any).__gxtDrainPendingRenderCleanups = function () {
+  if (_gxtPendingRenderCleanups.size === 0) return;
+  for (const fn of Array.from(_gxtPendingRenderCleanups)) {
+    try {
+      fn();
+    } catch {
+      /* ignore */
+    }
+  }
+  _gxtPendingRenderCleanups.clear();
+};
+
+/**
+ * Wire `owner` into the destroyable chain so the registered cleanup
+ * actually fires on teardown.
+ *
+ * The renderComponent API documents `owner = {}` as the default. That
+ * synthetic plain object isn't in any destroy chain by itself — calling
+ * registerDestructor on it records the destructor but it never runs,
+ * because nothing ever calls destroy() on the synthetic owner.
+ *
+ * Three layers of cleanup, all pointing at the same cleanupFn:
+ *
+ * 1. Ambient parent owner via associateDestroyableChild — when the
+ *    parent owner is destroyed via the standard glimmer/destroyable
+ *    chain, the synthetic descends with it.
+ * 2. registerDestructor on owner — covers callers that do call
+ *    destroy(owner) directly.
+ * 3. _gxtPendingRenderCleanups Set — eagerly drained by
+ *    __gxtCleanupActiveComponents at QUnit testStart and from
+ *    test-case afterEach; this is the only layer that fires
+ *    synchronously regardless of the runloop, which is what
+ *    actually prevents the cross-test reactor leak.
+ *
+ * Idempotent — safe to call from both _renderComponentGxt return paths.
+ */
+function _wireOwnerDestroyChain(owner: object, parentOwner: unknown, cleanupFn: () => void): void {
+  // Wrap so each layer fires the underlying cleanup exactly once and
+  // removing from the pending Set is automatic.
+  let fired = false;
+  const oneShot = () => {
+    if (fired) return;
+    fired = true;
+    _gxtPendingRenderCleanups.delete(oneShot);
+    try {
+      cleanupFn();
+    } catch {
+      /* ignore */
+    }
+  };
+  _gxtPendingRenderCleanups.add(oneShot);
+  if (
+    parentOwner &&
+    parentOwner !== owner &&
+    typeof owner === 'object' &&
+    owner !== null &&
+    Object.getPrototypeOf(owner) === Object.prototype &&
+    !isDestroyed(parentOwner) &&
+    !isDestroying(parentOwner) &&
+    !isDestroyed(owner) &&
+    !isDestroying(owner)
+  ) {
+    try {
+      associateDestroyableChild(parentOwner as any, owner as any);
+    } catch {
+      // parent may not accept association; fall through to register
+    }
+  }
+  try {
+    registerDestructor(owner, oneShot);
+  } catch {
+    // owner may not be destroyable; nothing else to do
+  }
+}
+
 /**
  * GXT-specific renderComponent implementation.
  * Bypasses Glimmer VM bytecode compilation entirely.
@@ -1779,11 +1863,18 @@ function _renderComponentGxt(
   ensureGxtContext();
 
   let destroyed = false;
+  let reactorCleanedUp = false;
   let classicReactorUnsub: (() => void) | null = null;
 
-  const doDestroy = () => {
-    if (destroyed) return;
-    destroyed = true;
+  // Reactor-only cleanup. Fires when the owner is destroyed via the
+  // standard destroyable chain (registered below). Cleaning up the
+  // classic-tag reactor is critical to prevent cross-test leaks; the
+  // DOM is not touched here because owner destruction does not imply
+  // the caller wants the rendered nodes removed (that is what
+  // result.destroy() means, see doDestroy).
+  const cleanupReactor = () => {
+    if (reactorCleanedUp) return;
+    reactorCleanedUp = true;
     if (classicReactorUnsub) {
       try {
         classicReactorUnsub();
@@ -1792,6 +1883,14 @@ function _renderComponentGxt(
       }
       classicReactorUnsub = null;
     }
+  };
+
+  // Full destroy. Returned to the caller as result.destroy(). Cleans
+  // the reactor and wipes the rendered content.
+  const doDestroy = () => {
+    if (destroyed) return;
+    destroyed = true;
+    cleanupReactor();
     if (targetElement instanceof Element) {
       targetElement.innerHTML = '';
     }
@@ -1866,12 +1965,7 @@ function _renderComponentGxt(
 
       const result: RenderResult = { destroy: doDestroy };
       RENDER_CACHE.set(into, { result, glimmerResult: undefined });
-      // Register destructor on owner so owner.destroy() cleans up DOM
-      try {
-        registerDestructor(owner, doDestroy);
-      } catch {
-        // owner may not be destroyable
-      }
+      _wireOwnerDestroyChain(owner, prevOwner, cleanupReactor);
       return result;
     }
 
@@ -2183,13 +2277,7 @@ function _renderComponentGxt(
 
   const result: RenderResult = { destroy: doDestroy };
   RENDER_CACHE.set(into, { result, glimmerResult: undefined });
-
-  // Register destructor on owner so that destroying the owner cleans up the DOM
-  try {
-    registerDestructor(owner, doDestroy);
-  } catch {
-    // owner may not be destroyable
-  }
+  _wireOwnerDestroyChain(owner, prevOwner, cleanupReactor);
 
   return result;
 }

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

@@ -5784,6 +5784,16 @@ setInterval(() => {
   if (typeof destroyTracked === 'function') {
     destroyTracked();
   }
+  // Eagerly drain any classic-tag reactor cleanups for renderComponent
+  // calls whose synthetic plain-object owner ({}) isn't otherwise in a
+  // destroy chain (the renderComponent API documents `owner = {}` as the
+  // default — see _wireOwnerDestroyChain in renderer.ts). Without this
+  // drain, those reactors leak across the QUnit testStart/testDone
+  // boundary and clobber shared GXT sync state on subsequent tests.
+  const drainPending = (globalThis as any).__gxtDrainPendingRenderCleanups;
+  if (typeof drainPending === 'function') {
+    drainPending();
+  }
   // Reset block params stack
   blockParamsStack.length = 0;
   // Reset current slot params

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

@@ -4134,6 +4134,26 @@ let _preRerenderSnapshot: Set<any> = new Set();
     }
   }
 
+  // Phase 0 (eager): drain any classic-tag reactor unsubs registered
+  // on instances. These unsubs (set by renderLinkToElement) need to
+  // fire SYNCHRONOUSLY here, before Ember's async runloop-based
+  // destroy chain runs — otherwise the reactor stays in
+  // _classicReactors across the testStart/testDone boundary and
+  // fires on the next test's tag dirties. The willDestroy monkey-
+  // patch in renderLinkToElement is a fallback for instances not
+  // reached by this phase.
+  for (const instance of instances) {
+    const unsub = instance && instance.__gxtClassicReactorUnsub;
+    if (typeof unsub === 'function') {
+      try {
+        unsub();
+      } catch {
+        /* ignore */
+      }
+      instance.__gxtClassicReactorUnsub = null;
+    }
+  }
+
   // Phase 1: willDestroyElement + willClearRender (top-down, element still present)
   for (const instance of instances) {
     try {
@@ -9517,6 +9537,36 @@ function renderLinkToElement(instance: any, args: any, fw: any): HTMLAnchorEleme
       }
     };
     unsub = (_gxtRegisterClassicReactor as any)(wrapped, 'renderLinkToElement');
+    // Tie the reactor's lifetime to the LinkTo instance's lifetime.
+    // The element-detachment heuristic above is unreliable in routing
+    // tests that reattach the same <a> across transitions (counter
+    // resets each time); without an additional escape hatch the
+    // reactor lives forever and fires across unrelated tests.
+    //
+    // Two hooks, both pointing at the same unsub:
+    //
+    // 1. instance.__gxtClassicReactorUnsub — picked up SYNCHRONOUSLY
+    //    by Phase 0 of __gxtDestroyTrackedInstances. Ember's async
+    //    runloop-based destroy chain doesn't fire willDestroy soon
+    //    enough to prevent the reactor from leaking across the
+    //    testStart/testDone boundary, so we drain it eagerly there.
+    // 2. willDestroy override — fallback for instances not reached
+    //    by __gxtDestroyTrackedInstances (e.g. component destroyed
+    //    via a route transition rather than test teardown).
+    if (instance && typeof instance === 'object' && !instance.__gxtLinkToReactorUnsubInstalled) {
+      instance.__gxtClassicReactorUnsub = unsub;
+      const prior = instance.willDestroy;
+      const priorBound = typeof prior === 'function' ? prior.bind(instance) : null;
+      instance.willDestroy = function () {
+        try {
+          unsub();
+        } catch {
+          /* ignore */
+        }
+        if (priorBound) return priorBound();
+      };
+      instance.__gxtLinkToReactorUnsubInstalled = true;
+    }
   };
 
   // id attribute (doesn't change over the element's lifetime, so no reactor)