Fixes #69291

Summary

animate.leave is skipped — the element is removed from the DOM synchronously instead of running its leave animation — whenever a sibling instance of the same template enters in a different DOM parent during the same change-detection tick. This is the common "close section A while opening section B" pattern: accordions, tab groups, exclusive-expansion menus, master/detail navigation, where A and B are two instances of the same child component. It is a regression introduced in 21.2.0; it worked in 21.1.x.

Root cause

leavingNodes (packages/core/src/animation/utils.ts) is keyed by TNode, which is part of the compiled TView and is therefore shared by every instance of a template. So the animated element in instance A and the one in instance B map to the same TNode bucket.

On insert, applyToElementOrContainer calls cancelLeavingNodes(tNode, enteringEl). Its cross-parent branch:

} else if (
  (prevSibling && leavingEl === prevSibling) ||
  (leavingParent && newParent && leavingParent !== newParent)   // ← the problem
) {
  nodes.splice(i, 1);
  leavingEl.dispatchEvent(new CustomEvent('animationend', {detail: {cancel: true}}));
  leavingEl.parentNode?.removeChild(leavingEl);                 // ← synchronous removal
}

The leavingParent !== newParent removal was added in #67032 to de-duplicate a single dynamic component re-rendered into a fresh overlay/portal parent (e.g. CDK Overlay). But "different parent" is also the normal situation for two legitimate sibling instances, so it produces a false positive: A's still-animating element is force-removed because its host differs from B's host. (#67361 later rescued the node-move case via leavingEl === newElement, but the cross-parent removal for distinct sibling elements was untouched.)

The fix

The collision is purely a matter of tracking by TNode with no instance identity. We add instance identity:

• leavingNodes now stores {el, declarationView} per leaving node instead of a bare HTMLElement.
• trackLeavingNodes (called from the Detach branch, which has the leaving node's LView) records the declaration view (lView[DECLARATION_VIEW] ?? lView) of the leaving element.
• cancelLeavingNodes (called from the Insert branch, which has the entering node's LView) resolves the entering node's declaration view and only performs the cross-parent removal when it matches the leaving node's declaration view — i.e. the same logical view re-rendered. Distinct instances of a shared template have different declaration views, so they are left alone and their animate.leave runs to completion.

The declaration view (rather than the rendered LView, which is a fresh object on every re-render) is used so the same logical insertion point compares equal across re-renders while distinct instances compare unequal. When no owning view is known on either side, the original (conservative) removal behavior is kept.

The prevSibling (same-position @if/VCR toggle) branch and the leavingEl === newElement (drag-and-drop node move, #67361) branch are unchanged.

Why this preserves #67032 and #67361

• fix(core): prevent animated element duplication with dynamic components in zoneless mode #67032 (dynamic component in overlay-like containers): each open() re-creates the embedded view from the same ViewContainerRef on the same component instance, so every embedded view's DECLARATION_VIEW is the same component LView. newDeclarationView === leavingDeclarationView holds, so the cross-parent removal still fires and the duplicate is removed. Its acceptance test ("should not duplicate elements when using dynamic components in overlay-like containers") passes.
• fix(core): Prevent removal of elements during drag and drop #67361 (drag-and-drop node move): handled by the earlier leavingEl === newElement branch, which is untouched.

New regression test

Added to packages/core/test/acceptance/animation_spec.ts in the existing animation element duplication suite: "should run animate.leave for a sibling instance when another instance of the same template enters". It renders two instances of one component (panels sharing a TNode), closes A and opens B in the same tick, and asserts A's panel stays connected to the DOM (leave animation running) until its animationend, instead of being removed synchronously.

I verified this test fails on main ("Expected false to be true" at the leavingPanelA.isConnected assertion — A removed synchronously) and passes with the fix.

Local verification

Built and tested with Bazel locally (Node 22.22.3, pnpm 11.5.2):

• //packages/core/test/acceptance:acceptance_web_chromium — PASS (2658 passed incl. the new test; the existing fix(core): prevent animated element duplication with dynamic components in zoneless mode #67032 overlay-dedup test green)
• //packages/core/test/acceptance:acceptance_web_firefox — PASS
• //packages/core/test/acceptance:acceptance (Node/jasmine) — PASS
• Confirmed the new test fails without the source fix and passes with it.
• Bundle-size golden symbol tests: the new internal helper getDeclarationView survives tree-shaking, so the 8 affected bundle.golden_symbols.json files were updated via the :symbol_test.accept targets; all 8 symbol_tests pass.
• prettier --check passes on all changed source/test files.

Not run locally: the full repository test matrix and the integration/animations e2e harness (could not bring up the integration browser tooling in this environment). CI will cover those.

Uncertainty for reviewers

• The discriminator is the declaration view. I confirmed empirically (via the two acceptance tests passing simultaneously) that it distinguishes the overlay re-render case from distinct sibling instances. If there is an overlay/portal scenario where the duplicate is re-rendered from a different declaring view than the leaving one, the cross-parent removal would no longer fire for it; I could not construct such a case, and the existing fix(core): prevent animated element duplication with dynamic components in zoneless mode #67032 test does not exercise one, but maintainers may know of one.
• The new helper adds one symbol (getDeclarationView) to the animation-containing bundles. The golden updates are mechanical, but flagging the size delta explicitly.