refactor(gxt-backend): graduate __gxtInTriggerReRender to typed withInTriggerReRender + isInTriggerReRender bridge pair (Cluster B slice 18)

Promotes the `__gxtInTriggerReRender` save-restore writers (`compile.ts`'s
in-line toggle inside the canonical `triggerReRender` body, slice-15 fold of
core.ts's pre-slice-15 wrap; `metal/property_events.ts:96-101` caller-side
toggle around `gxtTrigger(obj, keyName)`) to a typed
`compilePipeline.withInTriggerReRender<T>(fn): T` helper on the gxt-bridge.
Adds the paired `compilePipeline.isInTriggerReRender(): boolean` read-side
predicate and routes the `metal/computed.ts:522` CP.get re-entrance guard
through it. The two writers used the same `wasInside`-save / set-true /
restore pattern; this helper folds that pattern into one documented bridge
surface.

Writer + reader audit (pre-slice-18):
  Writers (set the flag, save+restore via try/finally):
    - compile.ts:3130-3136 — wraps `_gxtTriggerReRenderBody` inside the
      canonical `_gxtTriggerReRender` body. This is the slice-15 fold of
      core.ts's pre-slice-15 `ensureTriggerReRenderWrapped` wrap.
    - metal/property_events.ts:96-101 — wraps the `gxtTrigger(obj, keyName)`
      call inside `notifyPropertyChange`. Mirrors the canonical-body wrap
      so callers that invoke the trigger via globalThis (rather than through
      the bridge) still observe `true` for the duration of the synchronous
      notify cascade — including any nested `notifyPropertyChange` calls
      produced by `__gxtTriggerReRender`'s cellFor cascades.
  Readers (read the flag as `=== true`):
    - metal/computed.ts:522 — `CP.get` short-circuits cache misses when
      `__gxtInTriggerReRender === true && revision === undefined`. Preserves
      classic Ember's "don't eagerly evaluate never-consumed CPs during a
      change notification" semantic. MIGRATED to
      `compilePipeline.isInTriggerReRender()` with globalThis fallback.
    - @ember/object/core.ts:325 — DEBUG proxy trap's `_isInternalPath`
      predicate. NOT migrated in this slice — `@ember/object/core.ts` has
      no pre-existing `gxt-bridge` import edge, and the surrounding
      predicate already reads other globalThis flags (`__gxtSyncing`,
      `__gxtIsRendering`) raw. Migrating one flag while leaving the others
      would not improve the edge count net. Slice 18 keeps this reader on
      globalThis, matching slice-15/17's "RETAINED for cross-package
      readers" precedent.

Bridge shape decision: save-restore wrapper (`withInTriggerReRender<T>(fn): T`)
+ read-only predicate (`isInTriggerReRender(): boolean`). The writers both
do the save-set-true-restore dance — a wrapper captures that exactly. The
readers want a fast boolean check — a predicate is the minimal surface.
The "three-method begin/end/is" alternative was rejected: the writers
ALWAYS save+restore in `try/finally`, so a method pair without enforced
pairing would invite drift. The wrapper enforces the pairing structurally.

Namespace decision: `compilePipeline`. The flag is semantically a scope-
modifier on the `triggerReRender` trigger — the compile.ts writer lives
inside the canonical `triggerReRender` body, the property_events.ts writer
wraps the call to `triggerReRender`, the computed.ts reader gates a CP.get
short-circuit specifically for the "are we inside a trigger" question.
Same namespace as slice 17's `withTriggerSuppressed` (the structural twin —
both are scope-modifiers on the trigger; one suppresses the function, the
other toggles the predicate).

Bridge interface evolution (slice 18 — thirteenth API change):
`GxtCompilePipelineCapabilities` extended with two new optional generic
methods:
  - `withInTriggerReRender?<T>(fn: () => T): T`
  - `isInTriggerReRender?(): boolean`
No new install API needed (reuses slice-6's `installCompilePipelinePart`).
The `withTriggerSuppressed` doc comment is preserved as-is.

Sites moved:
  - packages/@ember/-internals/gxt-backend/compile.ts: add
    `_gxtWithInTriggerReRender<T>` + `_gxtIsInTriggerReRender` definitions;
    replace the in-line save-restore inside `_gxtTriggerReRender` with a
    `_gxtWithInTriggerReRender(() => _gxtTriggerReRenderBody(...))` call;
    contribute both helpers via `installCompilePipelinePart`.
  - packages/@ember/-internals/gxt-backend/gxt-bridge.ts: add
    `withInTriggerReRender?<T>(fn): T` + `isInTriggerReRender?(): boolean`
    to `GxtCompilePipelineCapabilities` with slice-18 doc comments
    covering the writer + reader audit and the unmigrated
    `@ember/object/core.ts:325` reader.
  - packages/@ember/-internals/metal/lib/property_events.ts: import
    `getGxtRenderer` from `@ember/-internals/gxt-backend/gxt-bridge`
    (new intra-metal-lib edge — joins property_set.ts and tracked.ts's
    existing edges); route the `gxtTrigger(obj, keyName)` wrap through
    `compilePipeline.withInTriggerReRender(fn)` with inline save-restore
    fallback for the bridge-not-yet-installed window.
  - packages/@ember/-internals/metal/lib/computed.ts: import
    `getGxtRenderer` from `@ember/-internals/gxt-backend/gxt-bridge`
    (new intra-metal-lib edge); read the `__gxtInTriggerReRender` flag
    via `compilePipeline.isInTriggerReRender()` with raw-globalThis
    fallback for the bridge-not-yet-installed window.

The `__gxtInTriggerReRender` globalThis writer is RETAINED post-slice-18
because of the unmigrated `@ember/object/core.ts:325` reader. Both bridge
writers continue to mirror to the globalThis slot so the unmigrated reader
observes the same value as the bridge-route readers.

Verification (all 6 baseline gates green):
  - smoke:                              333/333
  - Errors thrown during render:        4/4
  - Tracked Properties:                 33/36 (matches baseline — 3 pre-existing Helper failures)
  - computed:                           147/148 (matches baseline — 1 pre-existing)
  - Lifecycle:                          40/42 (matches baseline — 2 pre-existing Component Context failures)
  - render:                             977/981 (matches baseline — 4 pre-existing)

Count delta: +2 bridge methods (`withInTriggerReRender` +
`isInTriggerReRender`); 0 globalThis writers removed (writer retained for
unmigrated core.ts reader); +2 new intra-metal-lib import edges to
`gxt-bridge` (property_events.ts, computed.ts). Cumulative across
Cluster B: 18 slices migrated, bridge API evolved 13 times. All 8
capabilities namespaces stable; the two new edges join the existing
metal-lib edges (property_set.ts, tracked.ts) — pattern is established.

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

Author: lifeart

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

@@ -3109,6 +3109,38 @@ function _gxtAddAfterTriggerReRender(fn: _TriggerReRenderHook): () => void {
   };
 }
 
+// Slice-18 (Cluster B): typed save-restore helper that graduates the two
+// pre-slice-18 writers of `__gxtInTriggerReRender` to a bridge method:
+//   - the in-line toggle wrapped around `_gxtTriggerReRenderBody` below
+//     (the slice-15 fold of core.ts's pre-slice-15 wrap), AND
+//   - `metal/property_events.ts:96-101` (caller-side around `gxtTrigger`).
+// Both writers used the same `wasInside`-save / set-true / restore pattern;
+// this helper encapsulates it. Re-entrancy-safe because the saved value is
+// whatever the enclosing frame wrote (nested calls stack correctly). The
+// globalThis slot is also written so the unmigrated reader at
+// `@ember/object/core.ts:325` (DEBUG proxy trap) keeps observing the same
+// value as the bridge-route readers. See `withInTriggerReRender` doc in
+// gxt-bridge.ts.
+function _gxtWithInTriggerReRender<T>(fn: () => T): T {
+  const g: any = globalThis as any;
+  const wasInside = g.__gxtInTriggerReRender;
+  g.__gxtInTriggerReRender = true;
+  try {
+    return fn();
+  } finally {
+    g.__gxtInTriggerReRender = wasInside;
+  }
+}
+
+// Slice-18 (Cluster B): read-side predicate paired with
+// `withInTriggerReRender`. Returns `true` iff the current sync stack is
+// nested inside a `withInTriggerReRender(fn)` frame (which always wraps the
+// canonical `triggerReRender` body). Used by `metal/computed.ts:522`'s
+// CP.get re-entrance guard. Hot path: one boolean compare, zero allocations.
+function _gxtIsInTriggerReRender(): boolean {
+  return (globalThis as any).__gxtInTriggerReRender === true;
+}
+
 const _gxtTriggerReRender = function (obj: object, keyName: string) {
   // Slice-15: dispatch the BEFORE-chain (empty-chain check is a
   // length-zero short-circuit so per-call overhead stays at one cmp + one
@@ -3127,13 +3159,18 @@ const _gxtTriggerReRender = function (obj: object, keyName: string) {
   // `@ember/object/core.ts:70` that wrapped the global trigger; subsuming the
   // toggle here lets us delete that wrap entirely. The save/restore is
   // re-entrancy-safe (`wasInside` preserves an enclosing toggle if any).
-  const _g_around: any = globalThis as any;
-  const _wasInside = _g_around.__gxtInTriggerReRender;
-  _g_around.__gxtInTriggerReRender = true;
+  //
+  // Slice-18 (Cluster B): the in-line save-restore is replaced with the
+  // typed `_gxtWithInTriggerReRender` helper (which is also published on
+  // the bridge as `compilePipeline.withInTriggerReRender`). The flag is
+  // restored before the AFTER-hook chain dispatches (matching the
+  // pre-slice-18 ordering — AFTER hooks run with the flag already
+  // restored).
   try {
-    _gxtTriggerReRenderBody(obj, keyName);
+    _gxtWithInTriggerReRender(() => {
+      _gxtTriggerReRenderBody(obj, keyName);
+    });
   } finally {
-    _g_around.__gxtInTriggerReRender = _wasInside;
     if (_afterTriggerReRender.length > 0) {
       for (let i = 0; i < _afterTriggerReRender.length; i++) {
         try {
@@ -14331,6 +14368,17 @@ installCompilePipelinePart({
   // { g.__gxtTriggerReRender = saved; }` dance at `validator.ts:117` and
   // `manager.ts:11219`. See `withTriggerSuppressed` doc in gxt-bridge.ts.
   withTriggerSuppressed: _gxtWithTriggerSuppressed,
+  // Slice-18 (Cluster B): typed save-restore helper for the two
+  // `__gxtInTriggerReRender` writers (this file's canonical-body fold of
+  // core.ts's pre-slice-15 wrap, and `metal/property_events.ts:96-101`'s
+  // caller-side toggle). The paired read-only predicate
+  // `isInTriggerReRender()` serves `metal/computed.ts:522`'s CP.get
+  // re-entrance guard. The globalThis writer is RETAINED post-slice-18
+  // because of the unmigrated `@ember/object/core.ts:325` DEBUG proxy-trap
+  // reader. See `withInTriggerReRender` / `isInTriggerReRender` doc in
+  // gxt-bridge.ts.
+  withInTriggerReRender: _gxtWithInTriggerReRender,
+  isInTriggerReRender: _gxtIsInTriggerReRender,
 });
 
 // Slice-8 (Cluster B): replaces the pre-slice-8 `_installTemplateOnlyResetHook`

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

@@ -786,6 +786,71 @@ export interface GxtCompilePipelineCapabilities {
    * Removing the globalThis writer is a separate (larger) migration.
    */
   withTriggerSuppressed?<T>(fn: () => T): T;
+
+  /**
+   * Run `fn` with `__gxtInTriggerReRender` set to `true` (save the prior
+   * value, set the flag, invoke `fn`, then restore the prior value via
+   * `try/finally`). Returns whatever `fn` returns. Re-entrancy-safe because
+   * an enclosing frame's value is preserved by the save-restore pattern.
+   *
+   * Slice-18 (Cluster B): graduates the two save-restore writer sites for
+   * `__gxtInTriggerReRender` to a typed bridge helper:
+   *  - `compile.ts:3130-3136` (folded inside the canonical `triggerReRender`
+   *    body — see slice-15 doc above): wraps the entire trigger body so any
+   *    nested `CP.get` short-circuit reads `true`.
+   *  - `metal/property_events.ts:96-101` (caller-side around the
+   *    `gxtTrigger(obj, keyName)` call in `notifyPropertyChange`): wraps the
+   *    trigger invocation so the call sites observe `true` for the duration
+   *    of the synchronous notify cascade (including any nested
+   *    `notifyPropertyChange` calls produced by `__gxtTriggerReRender`).
+   * Both writers used to manually inline
+   * `wasInside = g.__gxtInTriggerReRender; g.__gxtInTriggerReRender = true;
+   * try { ... } finally { g.__gxtInTriggerReRender = wasInside; }`. This
+   * helper folds that pattern into one documented bridge surface.
+   *
+   * Reader contract: the flag is consumed by:
+   *  - `metal/computed.ts:522` — `CP.get` short-circuits cache misses when
+   *    `__gxtInTriggerReRender === true && revision === undefined` (preserves
+   *    classic Ember's "don't eagerly evaluate never-consumed CPs during a
+   *    change notification" semantic). Migrated to `isInTriggerReRender()`
+   *    in slice 18 (with globalThis fallback for the bridge-not-yet-installed
+   *    edge).
+   *  - `@ember/object/core.ts:325` — DEBUG proxy trap's `_isInternalPath`
+   *    predicate. NOT migrated in slice 18 — `@ember/object/core.ts` has no
+   *    pre-existing `gxt-bridge` import edge, and the surrounding predicate
+   *    already reads other globalThis flags (`__gxtSyncing`,
+   *    `__gxtIsRendering`) raw. Migrating one flag while leaving the others
+   *    would not improve the edge count net. Slice 18 keeps this reader on
+   *    globalThis, matching slice-15/17's "RETAINED for cross-package
+   *    readers" precedent. A future cluster-D pass over the proxy trap could
+   *    migrate the whole predicate at once.
+   *
+   * The globalThis writer for `__gxtInTriggerReRender` is RETAINED post-
+   * slice-18 because of the unmigrated `@ember/object/core.ts:325` reader.
+   * Both bridge writers continue to mirror to the globalThis slot so the
+   * unmigrated reader observes the same value as the bridge-route readers.
+   * See `isInTriggerReRender()` below for the read-side surface.
+   */
+  withInTriggerReRender?<T>(fn: () => T): T;
+
+  /**
+   * Read-only predicate for `__gxtInTriggerReRender`. Returns `true` iff the
+   * current synchronous stack is nested inside a `withInTriggerReRender(fn)`
+   * frame (or inside the canonical `triggerReRender` body, which is itself
+   * wrapped by `withInTriggerReRender`).
+   *
+   * Slice-18 (Cluster B): exposes the read side of the flag as a bridge
+   * predicate so `metal/computed.ts`'s `CP.get` re-entrance guard can avoid
+   * touching `globalThis` directly. The implementation reads the same
+   * `globalThis.__gxtInTriggerReRender` slot that `withInTriggerReRender`
+   * writes, so semantics are preserved across the unmigrated
+   * `@ember/object/core.ts:325` reader.
+   *
+   * Fast-check: the implementation is `return g.__gxtInTriggerReRender ===
+   * true` — one boolean comparison; zero allocations. Suitable for the
+   * `CP.get` hot path.
+   */
+  isInTriggerReRender?(): boolean;
 }
 
 /**

packages/@ember/-internals/metal/lib/computed.ts

@@ -40,6 +40,12 @@ import {
   notifyPropertyChange,
   PROPERTY_DID_CHANGE,
 } from './property_events';
+// Slice-18 (Cluster B): CP.get's `__gxtInTriggerReRender` re-entrance guard
+// reads through the typed `compilePipeline.isInTriggerReRender()` bridge
+// predicate. The globalThis fallback is preserved for the (rare) case where
+// the bridge hasn't been populated yet (early CP reads during module init).
+// See `isInTriggerReRender` doc in gxt-bridge.ts.
+import { getGxtRenderer } from '@ember/-internals/gxt-backend/gxt-bridge';
 
 export type ComputedPropertyGetterFunction = (this: any, key: string) => unknown;
 export type ComputedPropertySetterFunction = (
@@ -519,7 +525,18 @@ export class ComputedProperty extends ComputedDescriptor {
         // dependent keys, which causes async observers that were registered
         // on CPs the caller never read to fire spuriously. Return the stored
         // (or undefined) value and let the next genuine lazy read recompute.
-        if (g.__gxtInTriggerReRender === true && revision === undefined) {
+        //
+        // Slice-18 (Cluster B): read the flag through the typed
+        // `compilePipeline.isInTriggerReRender()` bridge predicate. Falls
+        // back to the raw `g.__gxtInTriggerReRender === true` slot read for
+        // the (rare) case where the bridge hasn't been populated yet (the
+        // bridge writer at compile.ts module-init mirrors the same slot, so
+        // the two are equivalent post-install). See `isInTriggerReRender`
+        // doc in gxt-bridge.ts.
+        const _isIn = getGxtRenderer()?.compilePipeline.isInTriggerReRender;
+        const _inTrigger =
+          typeof _isIn === 'function' ? _isIn() : g.__gxtInTriggerReRender === true;
+        if (_inTrigger && revision === undefined) {
           let stored = meta.valueFor(keyName);
           consumeTag(propertyTag);
           return stored;

packages/@ember/-internals/metal/lib/property_events.ts

@@ -1,6 +1,15 @@
 import type { Meta } from '@ember/-internals/meta';
 import { peekMeta } from '@ember/-internals/meta';
 import { assert } from '@ember/debug';
+// Slice-18 (Cluster B): `notifyPropertyChange` routes its
+// `__gxtInTriggerReRender` save-restore writer through the typed
+// `compilePipeline.withInTriggerReRender(fn)` bridge helper. The inline
+// save-restore fallback is preserved for the (rare) case where the bridge
+// hasn't been populated yet — should only happen before compile.ts's
+// module-init `installCompilePipelinePart` call has fired, and
+// `notifyPropertyChange` is not reachable during that window in any known
+// entry point. See `withInTriggerReRender` doc in gxt-bridge.ts.
+import { getGxtRenderer } from '@ember/-internals/gxt-backend/gxt-bridge';
 import {
   flushSyncObservers,
   resumeObserverDeactivation,
@@ -92,13 +101,31 @@ function notifyPropertyChange(
         // evaluate never-consumed CPs during a change notification" semantics.
         // (core.ts's lazy wrapper is only installed for proxied CoreObjects,
         // which misses plain `class Foo { @computed ... }` cases.)
-        const gRoot: any = globalThis as any;
-        const wasInside = gRoot.__gxtInTriggerReRender;
-        gRoot.__gxtInTriggerReRender = true;
-        try {
-          gxtTrigger(obj, keyName);
-        } finally {
-          gRoot.__gxtInTriggerReRender = wasInside;
+        //
+        // Slice-18 (Cluster B): the `__gxtInTriggerReRender` save-restore
+        // toggle that wraps the `gxtTrigger(obj, keyName)` call is routed
+        // through the typed `compilePipeline.withInTriggerReRender(fn)`
+        // bridge helper. The inline save-restore fallback is preserved for
+        // the (rare) case where the bridge hasn't been populated yet (the
+        // canonical body's wrap in compile.ts also sets the flag, so a
+        // dropped caller-side wrap would only matter for the
+        // `gxtTrigger === undefined`-after-suppression path which short-
+        // circuits this branch anyway). See `withInTriggerReRender` doc in
+        // gxt-bridge.ts.
+        const _withIn = getGxtRenderer()?.compilePipeline.withInTriggerReRender;
+        if (_withIn) {
+          _withIn(() => {
+            gxtTrigger(obj, keyName);
+          });
+        } else {
+          const gRoot: any = globalThis as any;
+          const wasInside = gRoot.__gxtInTriggerReRender;
+          gRoot.__gxtInTriggerReRender = true;
+          try {
+            gxtTrigger(obj, keyName);
+          } finally {
+            gRoot.__gxtInTriggerReRender = wasInside;
+          }
         }
       }
     }