refactor(gxt-backend): graduate __gxtIsRendering predicate to compilePipeline.isRendering bridge (Cluster B slice 19)

Promotes the render-pass-depth read-side predicate
(`__gxtIsRendering`) to a typed `compilePipeline.isRendering(): boolean`
method on the gxt-bridge. The single writer is `__gxtSetIsRendering`
(also defined in `compile.ts`, mutated cross-package from
`glimmer/lib/renderer.ts:2236/2272/2283`); it remains on globalThis in
this slice — a future slice 20 can promote the writer to a paired
begin/end (or `withRendering(fn)`) helper.

Writer + reader audit (pre-slice-19):
  Writer (1):
    - `compile.ts:_gxtSetIsRendering` — increment on `true`, decrement
      on `false`. Mutates the module-local `_renderPassDepth` counter
      that backs both `__gxtIsRendering` and `_gxtIsRendering`. Called
      from `glimmer/lib/renderer.ts:2236/2272/2283` via globalThis
      (cross-package writer; renderer wraps each `template.render()`
      with `setIsRendering(true)` + restore in `try/finally`).
  Readers (4):
    - `compile.ts:1903` ($_inElement render-pass detect for deferred
      in-element renders). MIGRATED to intra-file `_gxtIsRendering()`.
    - `compile.ts:2130` ($_inElement self-insert heuristic for in-
      element rendering into an empty target). MIGRATED to intra-file
      `_gxtIsRendering()`.
    - `glimmer/lib/renderer.ts:2233/2271` (renderComponent's
      `wasRendering` save-restore + inner `_doRender` reactor's
      `wasRenderingLocal` check — line 2271 captures the same
      `_isRendering` closure variable as line 2233, so a single edit
      at line 2233 propagates). MIGRATED to
      `compilePipeline.isRendering()` bridge call with globalThis
      fallback.
    - `@ember/object/core.ts:321` (DEBUG proxy trap `_isInternalPath`
      predicate). NOT migrated in this slice — the trap reads three
      globalThis flags together (`__gxtIsRendering`, `__gxtSyncing`,
      `__gxtInTriggerReRender`); migrating only one would not improve
      the edge count net. Slice 18 deferred the same trap for its own
      `__gxtInTriggerReRender` reader. Suggested slice 20 migrates
      the whole 3-flag predicate at once.

Bridge shape decision: single read-only predicate `isRendering():
boolean` mirroring slice-18's `isInTriggerReRender()`. The writer
(`_gxtSetIsRendering`) is paired begin/end via cross-package callers
in `glimmer/lib/renderer.ts`, not a `withRendering(fn)` save-restore
helper. Promoting the writer to a paired begin/end bridge surface is
a separate concern (and touches the cross-package renderer.ts writer
site) — deferred to slice 20.

Namespace decision: `compilePipeline`. The flag is semantically a
scope-modifier on the GXT template render pipeline — the writer +
depth counter live in `compile.ts` (the pipeline's home file), the
intra-package readers are in `$_inElement` rendering helpers, and the
cross-package reader in `glimmer/lib/renderer.ts` is the renderer's
wrap of `template.render()`. Same namespace as slices 15/17/18.

Bridge interface evolution (slice 19 — fourteenth API change):
`GxtCompilePipelineCapabilities` extended with one new optional method:
  - `isRendering?(): boolean`
No new install API needed (reuses slice-6's `installCompilePipelinePart`).

Sites moved:
  - packages/@ember/-internals/gxt-backend/compile.ts: promote
    `_renderPassDepth` and the two functions
    (`_gxtIsRendering` / `_gxtSetIsRendering`) to module-local scope
    (previously closure-locals inside the `if (typeof
    __gxtIsRendering !== 'function')` guard); preserve the dual-load
    guard around the globalThis writers; migrate the two intra-file
    readers ($_inElement render-pass detect at 1903 and self-insert
    heuristic at 2130) to direct `_gxtIsRendering()` calls; contribute
    `isRendering: _gxtIsRendering` via `installCompilePipelinePart`.
  - packages/@ember/-internals/gxt-backend/gxt-bridge.ts: add
    `isRendering?(): boolean` to `GxtCompilePipelineCapabilities`
    with slice-19 doc comments covering the writer + reader audit and
    the unmigrated `@ember/object/core.ts:321` reader.
  - packages/@ember/-internals/glimmer/lib/renderer.ts: route the
    `_isRendering` capture in renderComponent (line 2233) through
    `getGxtRenderer()?.compilePipeline.isRendering` with globalThis
    fallback. The inner `_doRender` reactor's `wasRenderingLocal`
    check (line 2271 / now 2285) captures the same `_isRendering`
    closure variable, so the single edit propagates.

The `__gxtIsRendering` globalThis writer is RETAINED post-slice-19
because of the unmigrated `@ember/object/core.ts:321` reader. Both
the bridge predicate and the globalThis function reference the same
module-local `_renderPassDepth` counter — they are equivalent post-
install.

Hot-path note: `_gxtIsRendering` is `return _renderPassDepth > 0` —
one integer comparison; zero allocations. The bridge route in
renderer.ts adds one property lookup per `renderComponent` call —
not a tight loop. Intra-compile.ts readers in $_inElement use the
direct function call (no bridge indirection) which is strictly faster
than the pre-slice-19 globalThis lookup.

Verification (all 6 baseline gates green):
  - smoke:                              333/333
  - Errors thrown during render:        4/4
  - Tracked Properties:                 33/36 (baseline)
  - computed:                           147/148 (baseline)
  - Lifecycle:                          40/42 (baseline)
  - render:                             977/981 (baseline)

Count delta: +1 bridge method (`isRendering`); 0 globalThis writers
removed (writer retained for unmigrated core.ts reader); 0 new
import edges (renderer.ts already imports `getGxtRenderer`; intra-
compile.ts readers use module-local function). Cumulative across
Cluster B: 19 slices migrated, bridge API evolved 14 times.

Suggested slice 20: migrate the `@ember/object/core.ts:321-326`
DEBUG proxy trap `_isInternalPath` predicate as a unit. The trap
reads three globalThis flags together (`__gxtIsRendering`,
`__gxtSyncing`, `__gxtInTriggerReRender`) — migrating them
individually has been deferred across slices 18 and 19 because the
edge-count math doesn't improve. A focused slice 20 can either
(a) add a single composite predicate `isInGxtInternalPath(propName):
boolean` to the bridge, or (b) add the missing `isSyncing()`
predicate and have core.ts call all three bridge predicates (which
also enables migrating the `__gxtSyncing` writer separately). After
slice 20 closes the trap, slice 21 can promote `__gxtSetIsRendering`
to a paired `beginRendering()/endRendering()` (or `withRendering(fn)`)
bridge writer surface, dropping the globalThis writer entirely.

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

Author: lifeart

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

@@ -2229,8 +2229,22 @@ function _renderComponentGxt(
     // Save and restore the previous isRendering state to avoid clobbering
     // it when renderComponent is called from within another render pass
     // (e.g., from a component constructor during an outer template render).
+    //
+    // Slice-19 (Cluster B): read the render-pass depth through the typed
+    // `compilePipeline.isRendering()` bridge predicate. Falls back to the
+    // raw `globalThis.__gxtIsRendering` lookup for the (rare) case where
+    // the bridge hasn't been populated yet (the bridge writer at compile.ts
+    // module-init contributes the same `_gxtIsRendering` function reference
+    // as the globalThis writer, so the two are equivalent post-install).
+    // The `__gxtSetIsRendering` writer is left on globalThis pending a
+    // future slice 20 begin/end migration. See `isRendering` doc in
+    // gxt-bridge.ts.
     const _setRendering = (globalThis as any).__gxtSetIsRendering;
-    const _isRendering = (globalThis as any).__gxtIsRendering;
+    const _bridgeIsRendering = getGxtRenderer()?.compilePipeline.isRendering;
+    const _isRendering =
+      typeof _bridgeIsRendering === 'function'
+        ? _bridgeIsRendering
+        : ((globalThis as any).__gxtIsRendering as (() => boolean) | undefined);
     const wasRendering = typeof _isRendering === 'function' ? _isRendering() : false;
     if (typeof _setRendering === 'function') {
       _setRendering(true);

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

@@ -1713,32 +1713,51 @@ if (false as boolean) {
 // a tracked boolean. Also wire compile.ts's own render() wrapper to
 // bump it, because precompileTemplate's render() is called from the
 // renderer.ts code path.
-if (typeof (globalThis as any).__gxtIsRendering !== 'function') {
-  let _renderPassDepth = 0;
-  (globalThis as any).__gxtSetIsRendering = function (on: boolean) {
-    if (on) _renderPassDepth++;
-    else if (_renderPassDepth > 0) {
-      _renderPassDepth--;
-      // When the top-level render pass ends (depth 1 → 0) the parent's
-      // DOM fragment has been committed to its target. Drain any
-      // in-element deferred renders that were queued during this pass —
-      // by now their compile-time literal id targets are resolvable via
-      // document.getElementById. This is the synchronous drain point for
-      // the renderComponent strict-mode path, which does NOT go through
-      // __gxtRebuildViewTreeFromDom or __gxtFlushAfterInsertQueue.
-      if (_renderPassDepth === 0) {
-        try {
-          const drain = (globalThis as any).__gxtInElementDrainDeferred;
-          if (typeof drain === 'function') drain();
-        } catch {
-          /* ignore */
-        }
+//
+// Slice-19 (Cluster B): the read-side predicate `_gxtIsRendering` is
+// promoted to module-local scope and contributed to the bridge as
+// `compilePipeline.isRendering()` (see `installCompilePipelinePart` at the
+// bottom of this file). The globalThis writers (`__gxtIsRendering` /
+// `__gxtSetIsRendering`) are RETAINED:
+//   - `__gxtIsRendering` is retained because the unmigrated reader at
+//     `@ember/object/core.ts:321` (DEBUG proxy trap) reads three flags
+//     together (`__gxtIsRendering`, `__gxtSyncing`, `__gxtInTriggerReRender`);
+//     migrating one flag while leaving the other two raw would not improve
+//     the edge count net. Slice 18 already deferred the same trap for its
+//     own `__gxtInTriggerReRender` reader. A future slice (suggested slice
+//     20) can migrate the whole 3-flag predicate at once.
+//   - `__gxtSetIsRendering` is retained because the cross-package writer at
+//     `glimmer/lib/renderer.ts:2232/2272/2282` toggles it via globalThis and
+//     a future slice should migrate it as a paired `beginRendering()` /
+//     `endRendering()` helper (see suggested slice 20 in the memory notes).
+let _renderPassDepth = 0;
+function _gxtIsRendering(): boolean {
+  return _renderPassDepth > 0;
+}
+function _gxtSetIsRendering(on: boolean): void {
+  if (on) _renderPassDepth++;
+  else if (_renderPassDepth > 0) {
+    _renderPassDepth--;
+    // When the top-level render pass ends (depth 1 → 0) the parent's
+    // DOM fragment has been committed to its target. Drain any
+    // in-element deferred renders that were queued during this pass —
+    // by now their compile-time literal id targets are resolvable via
+    // document.getElementById. This is the synchronous drain point for
+    // the renderComponent strict-mode path, which does NOT go through
+    // __gxtRebuildViewTreeFromDom or __gxtFlushAfterInsertQueue.
+    if (_renderPassDepth === 0) {
+      try {
+        const drain = (globalThis as any).__gxtInElementDrainDeferred;
+        if (typeof drain === 'function') drain();
+      } catch {
+        /* ignore */
       }
     }
-  };
-  (globalThis as any).__gxtIsRendering = function () {
-    return _renderPassDepth > 0;
-  };
+  }
+}
+if (typeof (globalThis as any).__gxtIsRendering !== 'function') {
+  (globalThis as any).__gxtSetIsRendering = _gxtSetIsRendering;
+  (globalThis as any).__gxtIsRendering = _gxtIsRendering;
 }
 
 // Deferred in-element render queue. When $_inElement encounters a null
@@ -1894,15 +1913,17 @@ if (typeof (globalThis as any).__gxtIsRendering !== 'function') {
     // whose outer DOM fragment hasn't been committed to the live document
     // yet, `document.getElementById` returns null even though the target
     // element exists in the pending parent fragment. Detect this by
-    // checking __gxtIsRendering() — if true, we're mid-render and should
+    // checking _gxtIsRendering() — if true, we're mid-render and should
     // defer the block body render until after the parent commits.
     //
     // Outside of an active render pass (classic `this.render` assertion
     // tests that pass `this.someElement = null`), fall through to the
     // synchronous assertion so expectAssertion() still catches the throw.
-    const _gxtIsRenderingFn = (globalThis as any).__gxtIsRendering;
-    const _insideRenderPass =
-      typeof _gxtIsRenderingFn === 'function' && _gxtIsRenderingFn() === true;
+    //
+    // Slice-19 (Cluster B): intra-compile.ts reader — call the module-local
+    // `_gxtIsRendering` directly (which is also published on the bridge as
+    // `compilePipeline.isRendering()`). One call, zero globalThis lookups.
+    const _insideRenderPass = _gxtIsRendering();
     // Only defer if we have a compile-time literal id fallback to
     // re-resolve with. Without one, we cannot distinguish "render-order
     // timing bug" from "user actually passed null" — and deferring
@@ -2127,7 +2148,9 @@ if (typeof (globalThis as any).__gxtIsRendering !== 'function') {
     // We detect self-insertion heuristically: the target is empty AND we
     // are currently inside a render pass. Standard `{{#in-element
     // externalTarget}}` into a non-rendering target is unaffected.
-    const gxtRenderingFn = (globalThis as any).__gxtIsRendering;
+    // Slice-19 (Cluster B): intra-compile.ts reader — call the module-local
+    // `_gxtIsRendering` directly (which is also published on the bridge as
+    // `compilePipeline.isRendering()`).
     // Suppress self-insert when a delegate explicitly tells us the current
     // render target is *not* the in-element destination. The rehydration
     // delegate sets __gxtInElementRenderTarget to the element it's
@@ -2144,8 +2167,7 @@ if (typeof (globalThis as any).__gxtIsRendering !== 'function') {
       insertBefore === null &&
       appendRef.childNodes.length === 0 &&
       !isExternalTarget &&
-      typeof gxtRenderingFn === 'function' &&
-      gxtRenderingFn() === true;
+      _gxtIsRendering();
     if (isSelfInsert) {
       // Return a fragment containing [content..., placeholder]. GXT's
       // outer-template commit will insert this whole fragment at the
@@ -14379,6 +14401,15 @@ installCompilePipelinePart({
   // gxt-bridge.ts.
   withInTriggerReRender: _gxtWithInTriggerReRender,
   isInTriggerReRender: _gxtIsInTriggerReRender,
+  // Slice-19 (Cluster B): read-only predicate for the render-pass depth
+  // counter (`_renderPassDepth` defined near the top of this file). Replaces
+  // the cross-package globalThis lookup at `glimmer/lib/renderer.ts:2233`
+  // (used to decide whether to suppress text-effect creation during nested
+  // renderComponent calls). The globalThis writer `__gxtIsRendering` is
+  // RETAINED post-slice-19 because of the unmigrated
+  // `@ember/object/core.ts:321` DEBUG proxy-trap reader (same trap that
+  // slice 18 deferred). See `isRendering` doc in gxt-bridge.ts.
+  isRendering: _gxtIsRendering,
 });
 
 // Slice-8 (Cluster B): replaces the pre-slice-8 `_installTemplateOnlyResetHook`

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

@@ -851,6 +851,75 @@ export interface GxtCompilePipelineCapabilities {
    * `CP.get` hot path.
    */
   isInTriggerReRender?(): boolean;
+
+  /**
+   * Read-only predicate for the render-pass depth counter at
+   * `compile.ts:_renderPassDepth`. Returns `true` iff at least one render
+   * pass is currently active (i.e., `_gxtSetIsRendering(true)` was called
+   * more often than `_gxtSetIsRendering(false)` since module init).
+   *
+   * Slice-19 (Cluster B): graduates the single-writer / multi-reader render-
+   * pass-detect flag (`__gxtIsRendering`) to a typed read-side predicate.
+   * The writer (`compile.ts:_gxtSetIsRendering`, exposed as
+   * `globalThis.__gxtSetIsRendering`) is the only mutator of the depth
+   * counter; this predicate is the read-side surface.
+   *
+   * Writer + reader audit (pre-slice-19):
+   *   Writer (1):
+   *     - `compile.ts:_gxtSetIsRendering` — increment on `true`, decrement
+   *       on `false`. Called from:
+   *         - `glimmer/lib/renderer.ts:2236/2272/2283` via
+   *           `globalThis.__gxtSetIsRendering` (cross-package writer; the
+   *           renderer wraps each `template.render()` invocation with
+   *           `setIsRendering(true)` + restore).
+   *         - The depth counter is module-local to `compile.ts` so it is
+   *           shared between the in-element `$_inElement` readers and the
+   *           renderer's wraps (which both go through globalThis).
+   *   Readers (4):
+   *     - `compile.ts:1903` ($_inElement render-pass detect for deferred
+   *       in-element renders). MIGRATED in slice 19 to `_gxtIsRendering()`
+   *       intra-file call.
+   *     - `compile.ts:2130` ($_inElement self-insert heuristic). MIGRATED
+   *       in slice 19 to `_gxtIsRendering()` intra-file call.
+   *     - `glimmer/lib/renderer.ts:2233/2271` (renderComponent's
+   *       wasRendering save-restore + the inner `_doRender` reactor's
+   *       wasRenderingLocal check). MIGRATED in slice 19 to
+   *       `compilePipeline.isRendering()` bridge call.
+   *     - `@ember/object/core.ts:321` (DEBUG proxy trap `_isInternalPath`
+   *       predicate). NOT migrated in slice 19 — the trap reads three
+   *       globalThis flags together (`__gxtIsRendering`, `__gxtSyncing`,
+   *       `__gxtInTriggerReRender`); migrating only one would not improve
+   *       the edge count net. Slice 18 deferred the same trap for its own
+   *       `__gxtInTriggerReRender` reader. A future slice 20 can migrate
+   *       the whole 3-flag predicate at once (see suggested slice 20 in
+   *       memory notes).
+   *
+   * Bridge shape decision: read-only predicate (mirroring slice-18's
+   * `isInTriggerReRender()`). The single writer (`_gxtSetIsRendering`)
+   * is paired begin/end through cross-package callers in
+   * `glimmer/lib/renderer.ts`, not a `withRendering(fn)` save-restore
+   * helper. A future slice 20 can promote the writer to a paired
+   * `beginRendering()` / `endRendering()` (or `withRendering(fn)`) bridge
+   * surface, but slice 19 keeps the writer on globalThis to avoid touching
+   * the cross-package renderer.ts writer site at the same time.
+   *
+   * Namespace decision: `compilePipeline`. The flag is semantically a
+   * scope-modifier on the GXT template render pipeline — the writer +
+   * depth counter live in `compile.ts` (the pipeline's home file), the
+   * intra-package readers are in `$_inElement` rendering helpers, and the
+   * cross-package reader in `glimmer/lib/renderer.ts` is the renderer's
+   * wrapping of `template.render()`. Same namespace as slices 15/17/18.
+   *
+   * The globalThis writer `__gxtIsRendering` is RETAINED post-slice-19
+   * because of the unmigrated `@ember/object/core.ts:321` reader. The
+   * bridge predicate reads the same module-local `_renderPassDepth`
+   * counter as the globalThis function — they are equivalent post-install.
+   *
+   * Fast-check: the implementation is `return _renderPassDepth > 0` — one
+   * integer comparison; zero allocations. Suitable for hot-path use in
+   * the `$_inElement` rendering helpers.
+   */
+  isRendering?(): boolean;
 }
 
 /**