refactor(gxt-backend): migrate __dcChangeListeners Set + counter via compilePipeline bridge (Cluster B slice 14)

Completes the half-migrated leftover from slice 12: the dynamic-component
change-listener Set (`__dcChangeListeners`) and its string-path counter
(`__dcStringListenerCount`) move from globalThis-shared state to
manager.ts module-local state, exposed as three new methods on
`compilePipeline`. Closes the last cross-file globalThis Set in the
slice-12 family.

Bridge interface evolution (slice 14 — ninth API change since the pilot):
- `GxtCompilePipelineCapabilities` extended with three required members:
  * `addDynamicComponentListener(fn, options?: { stringPath?: boolean })`
    -> `() => void` (off-fn). The `stringPath` option bumps the counter
    consulted by `hasStringDynamicComponentListeners()`.
  * `clearDynamicComponentListeners()` — clears both Set + counter in
    lockstep.
  * `hasStringDynamicComponentListeners(): boolean` — derived getter over
    the manager.ts module-local counter.
- No new install API needed (manager.ts seeds all three via the initial
  `setGxtRenderer` call; no host-hook is contributed from outside
  manager.ts).

Site audit (per slice 12 + 13 deferred notes — all confirmed):
1. Three writer sites in `ember-gxt-wrappers.ts`:
   - L1874-1877 (null path): `_nullListener` added via `add(_nullListener)`.
   - L2034-2037 (curried path): `_dcChangeListener` added.
   - L2302-2307 (string path): `_dcChangeListener` added + counter bumped.
2. Three cleanup sites in same file (L1881 / L2042 / L2312-2313): inline
   `delete(...)` plus the string-path counter decrement at L2313.
3. One Set reader: the dispatch in manager.ts's `_gxtSyncAllWrappers`
   after-body (L3712-3721, folded by slice 12).
4. Two counter readers:
   - manager.ts:3857 — arg-cell update path triggers
     `notifyPropertyChange` when string-path listeners are present.
   - compile.ts:5202 — Phase 1 morph-skip when string-path listeners are
     present.
5. One cross-test clear: compile.ts:5684-5685 plus the counter reset at
   compile.ts:5692.

No external readers (the Set + counter were intra-gxt-backend only —
confirmed by exhaustive grep across packages and tests/HTML), so dual
exposure is NOT retained. The globalThis `__dcChangeListeners` /
`__dcStringListenerCount` keys are removed outright (no orphan reader risk).

Hooks migrated (1 Set + 1 counter -> 3 bridge methods):
1. `__dcChangeListeners` Set + `__dcStringListenerCount` counter ->
   `compilePipeline.addDynamicComponentListener` /
   `clearDynamicComponentListeners` /
   `hasStringDynamicComponentListeners`.
   - manager.ts module-local: `const _dcChangeListeners = new Set<_DcListener>()`
     and `let _dcStringListenerCount = 0`. The three named functions
     `_gxtAddDynamicComponentListener` / `_gxtClearDynamicComponentListeners` /
     `_gxtHasStringDynamicComponentListeners` are seeded into the bridge
     via `setGxtRenderer` at file EOF.
   - The Set dispatch in `_gxtSyncAllWrappers` after-body now iterates the
     module-local Set directly (no globalThis read).
   - The counter check in manager.ts:3857 (notifyPropertyChange dispatch
     after arg-cell updates) now calls `_gxtHasStringDynamicComponentListeners()`.
   - compile.ts:5202's morph-skip check migrates to
     `getGxtRenderer()?.compilePipeline.hasStringDynamicComponentListeners?.()`.
   - compile.ts:5684-5692's cross-test clear block (Set `.clear()` +
     counter reset) collapses into a single
     `getGxtRenderer()?.compilePipeline.clearDynamicComponentListeners?.()`
     call.
   - The three ember-gxt-wrappers.ts writer sites are replaced with a
     single `addDynamicComponentListener(fn, ...)` call returning an off-fn
     used by the existing cleanup paths. The string-path site passes
     `{ stringPath: true }` so the counter increments/decrements stay in
     lockstep with the Set add/delete inside a single bridge surface.

Approach decision: (a) module-local + bridge methods, NOT (b) host-hook
or (c) relocation. The Set + counter are pure state; there is no wrap-by-
reassignment to break apart. The natural shape is "registry + register-fn
+ clear-fn + size-fn" — mechanically identical to slice 6's compile-side
state-bridging, but flipped (the state lives in manager.ts, not compile.ts,
because the dispatch already lives in manager.ts's `_gxtSyncAllWrappers`).

Verification (all 6 baseline gates green post-slice-14):
- smoke: 333/333 (16.8s)
- Errors thrown during render: 4/4
- Tracked Properties: 33/36 (3 pre-existing)
- computed: 147/148 (1 pre-existing)
- Lifecycle: 40/42 (2 pre-existing)
- render: 977/981 (4 pre-existing)

Net: 0 regressions, 0 new fixes. Cluster B progress: 14 slices migrated
covering 30 hooks (29 -> 30: the Set + counter count as a single logical
hook expressed as 3 bridge methods) across ~76 call sites + 9 orphan
cleanups + 9 wrap-by-reassignment installers eliminated (cumulative).
Bridge interface evolved NINE times total (slices 6/7/8/9/10/11/12/13/14).
All 8 capabilities namespaces remain stable.

Slice 14 validates a SIXTH migration shape on the bridge pattern: pure
state migration with a registry-style API (register-fn returning off-fn +
clear-fn + size-fn). Previous shapes: slice 3 = relocation, slice 6/7/9 =
install-API contribution, slice 8/10/11 = host-hook, slice 12/13 = wrap-
relocation. Slice 14's shape is the first to expose mutable state behind
typed methods without any host-hook or relocation pattern.

Suggested next slice (slice 15): `__gxtTriggerReRender` — multi-contributor
wrap (DEFERRED since slice 10 candidate ranking). The function is defined
in compile.ts; manager.ts wraps it at runtime to record dirtied nested
objects (`_dirtiedNestedObjectsForHooks` Set, an intra-manager.ts closure).
Audit needed: count of additional wrappers (beyond manager.ts's),
contributor location for each, and closure inventory. If manager.ts is the
only wrap contributor, this is a clean host-hook migration (slice 8/10/11
pattern: `__gxtTriggerReRender` becomes the canonical function in
`compilePipeline`, manager.ts contributes a `beforeTriggerReRender` host
hook via `installCompilePipelinePart`). If multiple files wrap it,
consider promoting to a chain pattern (extension of slice 8's host-hook
shape) or do a multi-slice migration. Alternative: `__gxtOriginalManagers`
(slice 7-deferred dual-writer) — `gxt-with-runtime-hbs.ts:219` AND
`compile.ts:6023` both write it. A dedicated slice can handle the dual-
write semantics via a chain or last-writer-wins discriminator.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: lifeart

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

@@ -5199,7 +5199,12 @@ function _resetTemplateOnlyState() {
           // via cell tracking. Skip the force-rerender morph (Phase 2b) only when
           // cell-based listeners exist. CurriedComponent listeners use manual DOM
           // swap and need the morph for other property changes to propagate.
-          if ((globalThis as any).__dcStringListenerCount > 0) {
+          // Slice-14 (Cluster B): consult the bridge-exposed
+          // `hasStringDynamicComponentListeners()` rather than the pre-slice-14
+          // globalThis counter.
+          if (
+            getGxtRenderer()?.compilePipeline.hasStringDynamicComponentListeners?.()
+          ) {
             (globalThis as any).__gxtHadPendingSync = false;
           }
         }
@@ -5679,17 +5684,17 @@ setInterval(() => {
   }
   // Clear pending if-watcher notifications from the previous test
   _pendingIfWatcherNotifications.length = 0;
-  // Clear dynamic component change listeners and stale getter from $_dc_ember
+  // Clear dynamic component change listeners and stale getter from $_dc_ember.
+  // Slice-14 (Cluster B): the Set + string-path counter migrated to manager.ts
+  // module-local state behind the bridge's
+  // `clearDynamicComponentListeners()` method. The bridge clear resets both
+  // the Set and the counter in lockstep — without that lockstep, orphaned
+  // listener count leaks across tests and makes __gxtSyncDomNow incorrectly
+  // clear __gxtHadPendingSync in Phase 1, which then causes
+  // __gxtForceEmberRerender to skip the morph for tests that need it (e.g.,
+  // classic Component.extend properties changed via set()).
   (globalThis as any).__dcComponentGetter = null;
-  if ((globalThis as any).__dcChangeListeners) {
-    (globalThis as any).__dcChangeListeners.clear();
-  }
-  // Reset the string-path listener counter in lockstep with clearing the Set.
-  // Without this, orphaned listener count leaks across tests and makes
-  // __gxtSyncDomNow incorrectly clear __gxtHadPendingSync in Phase 1, which
-  // then causes __gxtForceEmberRerender to skip the morph for tests that
-  // need it (e.g., classic Component.extend properties changed via set()).
-  (globalThis as any).__dcStringListenerCount = 0;
+  getGxtRenderer()?.compilePipeline.clearDynamicComponentListeners?.();
   // Clear component contexts to prevent stale render contexts accumulating
   if ((globalThis as any).__gxtComponentContexts) {
     (globalThis as any).__gxtComponentContexts = new WeakMap();

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

@@ -1868,17 +1868,21 @@ function createEmberDc(original: Function) {
       // Slice-12 (Cluster B): the pre-slice-12 wrap-by-reassignment that
       // installed an inline `__gxtSyncAllWrappers` wrapper to dispatch DC
       // change listeners has been REMOVED. The canonical `_gxtSyncAllWrappers`
-      // in manager.ts now dispatches `g.__dcChangeListeners` itself in its
-      // after-body (slice-3 relocation pattern). Only the Set creation + the
-      // `add` registration remain here.
-      if (!g.__dcChangeListeners) {
-        g.__dcChangeListeners = new Set();
-      }
-      g.__dcChangeListeners.add(_nullListener);
+      // in manager.ts now dispatches the change-listener Set itself in its
+      // after-body (slice-3 relocation pattern).
+      // Slice-14 (Cluster B): the Set itself moved to manager.ts module-local
+      // state behind the bridge's `addDynamicComponentListener` method, which
+      // returns an off-fn for symmetric cleanup. The pre-slice-14 inline
+      // `g.__dcChangeListeners.add(...)` writer + `.delete(...)` cleanup are
+      // replaced by `off()`.
+      const _offNullListener =
+        getGxtRenderer()?.compilePipeline.addDynamicComponentListener?.(
+          _nullListener
+        );
 
       const _nullCleanup = () => {
         _nullDestroyed = true;
-        g.__dcChangeListeners?.delete(_nullListener);
+        _offNullListener?.();
       };
       if (ctx && typeof gxtModule.registerDestructor === 'function') {
         try {
@@ -2027,19 +2031,23 @@ function createEmberDc(original: Function) {
         return true;
       };
 
-      // Add listener to __dcChangeListeners (shared with null/string paths).
-      // Slice-12 (Cluster B): the pre-slice-12 wrap-by-reassignment installer
-      // has been REMOVED — `_gxtSyncAllWrappers` in manager.ts dispatches the
-      // Set itself in its after-body (slice-3 relocation pattern).
-      if (!g.__dcChangeListeners) {
-        g.__dcChangeListeners = new Set();
-      }
-      g.__dcChangeListeners.add(_dcChangeListener);
+      // Add listener to the DC-change-listener registry (shared with
+      // null/string paths). Slice-12 (Cluster B): the pre-slice-12
+      // wrap-by-reassignment installer has been REMOVED —
+      // `_gxtSyncAllWrappers` in manager.ts dispatches the listener Set
+      // itself in its after-body (slice-3 relocation pattern). Slice-14
+      // (Cluster B): the Set moved from globalThis to manager.ts
+      // module-local state behind the bridge's `addDynamicComponentListener`
+      // method, which returns an off-fn for symmetric cleanup.
+      const _offDcListener =
+        getGxtRenderer()?.compilePipeline.addDynamicComponentListener?.(
+          _dcChangeListener
+        );
 
       // Cleanup destructor
       const _cleanupDcListener = () => {
         _dcDestroyed = true;
-        g.__dcChangeListeners?.delete(_dcChangeListener);
+        _offDcListener?.();
       };
       if (ctx && typeof gxtModule.registerDestructor === 'function') {
         try {
@@ -2295,22 +2303,28 @@ function createEmberDc(original: Function) {
         return true;
       };
 
-      // Add listener to __dcChangeListeners (shared with null/curried paths).
-      // Slice-12 (Cluster B): the pre-slice-12 wrap-by-reassignment installer
-      // has been REMOVED — `_gxtSyncAllWrappers` in manager.ts dispatches the
-      // Set itself in its after-body (slice-3 relocation pattern).
-      if (!g.__dcChangeListeners) {
-        g.__dcChangeListeners = new Set();
-      }
-      g.__dcChangeListeners.add(_dcChangeListener);
-      // Track string-path listener count for morph skip logic in compile.ts
-      g.__dcStringListenerCount = (g.__dcStringListenerCount || 0) + 1;
+      // Add listener to the DC-change-listener registry (shared with
+      // null/curried paths). Slice-12 (Cluster B): the pre-slice-12
+      // wrap-by-reassignment installer has been REMOVED —
+      // `_gxtSyncAllWrappers` in manager.ts dispatches the listener Set
+      // itself in its after-body (slice-3 relocation pattern). Slice-14
+      // (Cluster B): the Set + string-path counter moved from globalThis to
+      // manager.ts module-local state behind the bridge's
+      // `addDynamicComponentListener` method. The `stringPath: true` option
+      // bumps the counter consulted by morph-skip logic in
+      // `__gxtSyncDomNow` / arg-cell notifyPropertyChange dispatch in
+      // `_gxtSyncAllWrappersBody`; the returned off-fn handles both the Set
+      // delete and counter decrement in lockstep.
+      const _offDcListener =
+        getGxtRenderer()?.compilePipeline.addDynamicComponentListener?.(
+          _dcChangeListener,
+          { stringPath: true }
+        );
 
       // Cleanup destructor
       const _cleanupDcListener = () => {
         _dcDestroyed = true;
-        g.__dcChangeListeners?.delete(_dcChangeListener);
-        if (g.__dcStringListenerCount > 0) g.__dcStringListenerCount--;
+        _offDcListener?.();
         // NOTE: we do NOT call destroyCurrentDcInstance here — the surrounding
         // render tree is being torn down by Ember, which will fire destroy
         // hooks through its normal path. Calling it here would double-destroy.

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

@@ -401,6 +401,19 @@ export interface GxtFormatCapabilities {
  *    state — even cleaner than slice 12's globalThis-shared state — so the
  *    relocation collapsed into a single intra-file function with zero cross-
  *    file state references.
+ *  - `__dcChangeListeners` Set + `__dcStringListenerCount` counter — MIGRATED
+ *    IN SLICE 14 to `addDynamicComponentListener` /
+ *    `clearDynamicComponentListeners` / `hasStringDynamicComponentListeners`
+ *    on this namespace. The half-migrated leftover from slice 12: the Set's
+ *    reader was folded into manager.ts's `_gxtSyncAllWrappers` by slice 12 but
+ *    its writer sites stayed inline in ember-gxt-wrappers.ts (L1868 / L2039 /
+ *    L2317) plus a cross-test clear at compile.ts:5800-5801 and counter readers
+ *    at compile.ts:5317 + manager.ts:3713. Slice 14 promotes the Set + counter
+ *    to manager.ts module-local state and exposes typed bridge methods. NO
+ *    external readers (the Set + counter are intra-gxt-backend only —
+ *    confirmed by exhaustive grep), so dual exposure is NOT retained — the
+ *    `__dcChangeListeners` / `__dcStringListenerCount` globals are removed
+ *    outright.
  */
 export interface GxtCompilePipelineCapabilities {
   /**
@@ -498,6 +511,79 @@ export interface GxtCompilePipelineCapabilities {
    */
   clearInstancePools(): void;
 
+  /**
+   * Register a dynamic-component change listener that fires AFTER every
+   * sync-all pass (in `_gxtSyncAllWrappers`'s after-body). Listeners are
+   * notified when dynamic-component swaps need to perform manual DOM updates
+   * — used by the three `$_dc_ember` paths in ember-gxt-wrappers.ts:
+   *   - null path (L1862): `_nullListener` performs the null-DOM swap.
+   *   - curried path (L2024): `_dcChangeListener` performs curried swap.
+   *   - string path (L2292): `_dcChangeListener` performs string-name swap.
+   *
+   * Returns an "off" function the caller invokes from its destructor to
+   * de-register the listener. The off-fn is idempotent.
+   *
+   * Pass `{ stringPath: true }` for the string-component path so the bridge
+   * tracks a counter consulted by `hasStringDynamicComponentListeners()`
+   * (compile.ts's `__gxtSyncDomNow` morph-skip logic; manager.ts's
+   * notifyPropertyChange dispatch when string-path listeners are present).
+   *
+   * Slice-14 design: the listener Set + string-path counter live as
+   * manager.ts module-local state (`_dcChangeListeners` Set,
+   * `_dcStringListenerCount` number). The pre-slice-14 globalThis Set + counter
+   * (`__dcChangeListeners`, `__dcStringListenerCount`) are removed outright —
+   * no external readers exist (intra-gxt-backend only). Replaces three inline
+   * `g.__dcChangeListeners.add(...)` writer sites at
+   * ember-gxt-wrappers.ts:1877 / :2037 / :2305 plus the counter increment at
+   * :2307, the cleanup `.delete(...)` sites at :1881 / :2042 / :2312, and the
+   * decrement at :2313 — all replaced by a single `addDynamicComponentListener`
+   * call returning the appropriate off-fn.
+   *
+   * Previously: `(globalThis as any).__dcChangeListeners` Set + the
+   * `(globalThis as any).__dcStringListenerCount` counter.
+   */
+  addDynamicComponentListener(
+    fn: () => boolean,
+    options?: { stringPath?: boolean }
+  ): () => void;
+
+  /**
+   * Clear all registered dynamic-component change listeners and reset the
+   * string-path listener counter to zero. Called from compile.ts's
+   * `__gxtSyncDomNow` test-teardown Phase 2 (the cross-test reset block at
+   * compile.ts:5800-5801) so listeners registered by a previous test do not
+   * fire (and are not counted) during the next test.
+   *
+   * Slice-14 design: replaces the pre-slice-14 inline
+   * `(globalThis as any).__dcChangeListeners.clear()` plus
+   * `(globalThis as any).__dcStringListenerCount = 0` at compile.ts:5800-5801
+   * with a single bridge call.
+   *
+   * Previously: `(globalThis as any).__dcChangeListeners.clear()` +
+   * `(globalThis as any).__dcStringListenerCount = 0`.
+   */
+  clearDynamicComponentListeners(): void;
+
+  /**
+   * Return `true` if any STRING-path dynamic-component listener is currently
+   * registered. Used by compile.ts's `__gxtSyncDomNow` Phase 1 to decide
+   * whether to skip the force-rerender morph (Phase 2b) — cell-based string-
+   * path swaps already handled dynamic-component identity via the bridge
+   * dispatch, so the morph would re-apply already-applied changes. Also used
+   * by manager.ts's arg-cell update path to dispatch
+   * `notifyPropertyChange` so Ember's tag-driven @computed properties on
+   * classic components recompute after arg updates via syncAll (the Ember tag
+   * isn't dirtied by direct property assignment).
+   *
+   * Slice-14 design: derived getter over the manager.ts module-local
+   * `_dcStringListenerCount` number. Replaces the pre-slice-14 inline
+   * `(globalThis as any).__dcStringListenerCount > 0` checks at
+   * compile.ts:5317 and manager.ts:3713 (the two reader sites).
+   *
+   * Previously: `(globalThis as any).__dcStringListenerCount > 0` inline.
+   */
+  hasStringDynamicComponentListeners(): boolean;
+
   /**
    * Compile a template string to a gxt-compatible template factory.
    * Contributed by compile.ts (the function definition's home file).

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

@@ -3617,6 +3617,48 @@ function _installTriggerReRenderWrapper() {
 // dispatch) into the canonical body below. All state crossed via globalThis
 // (`__gxtAllPoolArrays`, `__gxtSyncCycleId`, `__gxtSyncAllInFlightCycle`,
 // `__dcChangeListeners`) so no closures needed to be moved.
+
+// Slice-14 (Cluster B): the `__dcChangeListeners` Set and
+// `__dcStringListenerCount` counter that were left as globalThis-shared
+// semaphores by slice 12 are now manager.ts module-local. Writers
+// (`ember-gxt-wrappers.ts:1877 / :2037 / :2305`), counter readers
+// (`compile.ts:5202` morph-skip, `manager.ts:3857` notifyPropertyChange
+// dispatch), and the cross-test clear (`compile.ts:5684-5692`) all go through
+// the bridge methods `addDynamicComponentListener` /
+// `hasStringDynamicComponentListeners` / `clearDynamicComponentListeners`.
+// The Set's reader (the after-body dispatch in `_gxtSyncAllWrappers`)
+// iterates the module-local Set directly. No external readers exist (the Set
+// + counter were intra-gxt-backend only — confirmed by exhaustive grep), so
+// dual exposure is NOT retained.
+type _DcListener = () => boolean;
+const _dcChangeListeners = new Set<_DcListener>();
+let _dcStringListenerCount = 0;
+function _gxtAddDynamicComponentListener(
+  fn: _DcListener,
+  options?: { stringPath?: boolean }
+): () => void {
+  _dcChangeListeners.add(fn);
+  const isStringPath = options?.stringPath === true;
+  if (isStringPath) {
+    _dcStringListenerCount++;
+  }
+  let removed = false;
+  return function off(): void {
+    if (removed) return;
+    removed = true;
+    _dcChangeListeners.delete(fn);
+    if (isStringPath && _dcStringListenerCount > 0) {
+      _dcStringListenerCount--;
+    }
+  };
+}
+function _gxtClearDynamicComponentListeners(): void {
+  _dcChangeListeners.clear();
+  _dcStringListenerCount = 0;
+}
+function _gxtHasStringDynamicComponentListeners(): boolean {
+  return _dcStringListenerCount > 0;
+}
 //
 // AROUND-shape relocation (slice-3 relocation pattern, FIRST application to a
 // wrap-by-reassignment exclusion — prior wraps slices 8/10/11 used the
@@ -3706,17 +3748,15 @@ function _gxtSyncAllWrappers(): void {
   } finally {
     // === AFTER: clear in-flight state and dispatch DC change listeners
     // (relocated from compile.ts wrap finally + ember-gxt-wrappers.ts
-    // L1872 / L2043 / L2321 wrap bodies) ===
+    // L1872 / L2043 / L2321 wrap bodies; slice-14 moves the Set from
+    // globalThis to manager.ts module-local `_dcChangeListeners`) ===
     g.__gxtSyncAllInFlightPass = 0;
     g.__gxtSyncAllInFlightCycle = 0;
-    const dcListeners = g.__dcChangeListeners;
-    if (dcListeners) {
-      for (const listener of dcListeners) {
-        try {
-          listener();
-        } catch {
-          /* ignore */
-        }
+    for (const listener of _dcChangeListeners) {
+      try {
+        listener();
+      } catch {
+        /* ignore */
       }
     }
   }
@@ -3854,7 +3894,7 @@ function _gxtSyncAllWrappersBody(): void {
               // updates via syncAll (the Ember tag isn't dirtied by direct
               // property assignment).
               if (
-                (globalThis as any).__dcStringListenerCount > 0 &&
+                _gxtHasStringDynamicComponentListeners() &&
                 entry.instance &&
                 typeof entry.instance.trigger === 'function'
               ) {
@@ -12709,6 +12749,21 @@ setGxtRenderer({
     // state only, so the slice-3 relocation pattern applies — second
     // wrap-by-reassignment slice to use relocation after slice 12.
     clearInstancePools: _gxtClearInstancePools,
+    // Slice-14 (Cluster B): seeded here with the dynamic-component listener
+    // bridge methods. The Set (`_dcChangeListeners`) and counter
+    // (`_dcStringListenerCount`) live as manager.ts module-local state; the
+    // pre-slice-14 globalThis `__dcChangeListeners` / `__dcStringListenerCount`
+    // were intra-gxt-backend only (no external readers — confirmed by
+    // exhaustive grep), so dual exposure is NOT retained. Writers move from
+    // inline `g.__dcChangeListeners.add(...)` (ember-gxt-wrappers.ts L1877 /
+    // L2037 / L2305) to a single `addDynamicComponentListener` call that
+    // returns an off-fn for symmetric cleanup. The `stringPath: true`
+    // variant also bumps a counter consulted by
+    // `hasStringDynamicComponentListeners()` for compile.ts's morph-skip
+    // logic and manager.ts's notifyPropertyChange dispatch.
+    addDynamicComponentListener: _gxtAddDynamicComponentListener,
+    clearDynamicComponentListeners: _gxtClearDynamicComponentListeners,
+    hasStringDynamicComponentListeners: _gxtHasStringDynamicComponentListeners,
   },
   renderPass: {
     // Slice-8: triad seeded here; the `beforeBeginRenderPass` host hook is