@angular/core 18.1.0-next.3 → 18.1.0-next.4

package/fesm2022/core.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v18.1.0-next.3
+ * @license Angular v18.1.0-next.4
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -5317,6 +5317,7 @@ function toTNodeTypeAsString(tNodeType) {
     tNodeType & 16 /* TNodeType.Projection */ && (text += '|Projection');
     tNodeType & 32 /* TNodeType.Icu */ && (text += '|IcuContainer');
     tNodeType & 64 /* TNodeType.Placeholder */ && (text += '|Placeholder');
+    tNodeType & 128 /* TNodeType.LetDeclaration */ && (text += '|LetDeclaration');
     return text.length > 0 ? text.substring(1) : text;
 }
 /**
@@ -5392,13 +5393,14 @@ function assertTNodeType(tNode, expectedTypes, message) {
     }
 }
 function assertPureTNodeType(type) {
-    if (!(type === 2 /* TNodeType.Element */ || //
-        type === 1 /* TNodeType.Text */ || //
-        type === 4 /* TNodeType.Container */ || //
-        type === 8 /* TNodeType.ElementContainer */ || //
-        type === 32 /* TNodeType.Icu */ || //
-        type === 16 /* TNodeType.Projection */ || //
-        type === 64 /* TNodeType.Placeholder */)) {
+    if (!(type === 2 /* TNodeType.Element */ ||
+        type === 1 /* TNodeType.Text */ ||
+        type === 4 /* TNodeType.Container */ ||
+        type === 8 /* TNodeType.ElementContainer */ ||
+        type === 32 /* TNodeType.Icu */ ||
+        type === 16 /* TNodeType.Projection */ ||
+        type === 64 /* TNodeType.Placeholder */ ||
+        type === 128 /* TNodeType.LetDeclaration */)) {
         throwError(`Expected TNodeType to have only a single type selected, but got ${toTNodeTypeAsString(type)}.`);
     }
 }
@@ -6596,6 +6598,9 @@ function getDevModeNodeName(tNode) {
     else if (tNode.type & 4 /* TNodeType.Container */) {
         return 'an <ng-template>';
     }
+    else if (tNode.type & 128 /* TNodeType.LetDeclaration */) {
+        return 'an @let declaration';
+    }
     else {
         return 'a node';
     }
@@ -10840,8 +10845,10 @@ function getParentRElement(tView, tNode, lView) {
 function getClosestRElement(tView, tNode, lView) {
     let parentTNode = tNode;
     // Skip over element and ICU containers as those are represented by a comment node and
-    // can't be used as a render parent.
-    while (parentTNode !== null && parentTNode.type & (8 /* TNodeType.ElementContainer */ | 32 /* TNodeType.Icu */)) {
+    // can't be used as a render parent. Also skip let declarations since they don't have a
+    // corresponding DOM node at all.
+    while (parentTNode !== null &&
+        parentTNode.type & (8 /* TNodeType.ElementContainer */ | 32 /* TNodeType.Icu */ | 128 /* TNodeType.LetDeclaration */)) {
         tNode = parentTNode;
         parentTNode = tNode.parent;
     }
@@ -11091,6 +11098,11 @@ function clearElementContents(rElement) {
 function applyNodes(renderer, action, tNode, lView, parentRElement, beforeNode, isProjection) {
     while (tNode != null) {
         ngDevMode && assertTNodeForLView(tNode, lView);
+        // Let declarations don't have corresponding DOM nodes so we skip over them.
+        if (tNode.type === 128 /* TNodeType.LetDeclaration */) {
+            tNode = tNode.next;
+            continue;
+        }
         ngDevMode &&
             assertTNodeType(tNode, 3 /* TNodeType.AnyRNode */ | 12 /* TNodeType.AnyContainer */ | 16 /* TNodeType.Projection */ | 32 /* TNodeType.Icu */);
         const rawSlotValue = lView[tNode.index];
@@ -12941,6 +12953,11 @@ function removeLViewFromLContainer(lContainer, index) {
 
 function collectNativeNodes(tView, lView, tNode, result, isProjection = false) {
     while (tNode !== null) {
+        // Let declarations don't have corresponding DOM nodes so we skip over them.
+        if (tNode.type === 128 /* TNodeType.LetDeclaration */) {
+            tNode = isProjection ? tNode.projectionNext : tNode.next;
+            continue;
+        }
         ngDevMode &&
             assertTNodeType(tNode, 3 /* TNodeType.AnyRNode */ | 12 /* TNodeType.AnyContainer */ | 16 /* TNodeType.Projection */ | 32 /* TNodeType.Icu */);
         const lNode = lView[tNode.index];
@@ -13882,6 +13899,8 @@ function getFriendlyStringFromTNodeType(tNodeType) {
             return 'projection';
         case 1 /* TNodeType.Text */:
             return 'text';
+        case 128 /* TNodeType.LetDeclaration */:
+            return '@let';
         default:
             // This should not happen as we cover all possible TNode types above.
             return '<unknown>';
@@ -14476,6 +14495,89 @@ function isRootTemplateMessage(subTemplateIndex) {
     return subTemplateIndex === -1;
 }
 
+function enterIcu(state, tIcu, lView) {
+    state.index = 0;
+    const currentCase = getCurrentICUCaseIndex(tIcu, lView);
+    if (currentCase !== null) {
+        ngDevMode && assertNumberInRange(currentCase, 0, tIcu.cases.length - 1);
+        state.removes = tIcu.remove[currentCase];
+    }
+    else {
+        state.removes = EMPTY_ARRAY;
+    }
+}
+function icuContainerIteratorNext(state) {
+    if (state.index < state.removes.length) {
+        const removeOpCode = state.removes[state.index++];
+        ngDevMode && assertNumber(removeOpCode, 'Expecting OpCode number');
+        if (removeOpCode > 0) {
+            const rNode = state.lView[removeOpCode];
+            ngDevMode && assertDomNode(rNode);
+            return rNode;
+        }
+        else {
+            state.stack.push(state.index, state.removes);
+            // ICUs are represented by negative indices
+            const tIcuIndex = ~removeOpCode;
+            const tIcu = state.lView[TVIEW].data[tIcuIndex];
+            ngDevMode && assertTIcu(tIcu);
+            enterIcu(state, tIcu, state.lView);
+            return icuContainerIteratorNext(state);
+        }
+    }
+    else {
+        if (state.stack.length === 0) {
+            return null;
+        }
+        else {
+            state.removes = state.stack.pop();
+            state.index = state.stack.pop();
+            return icuContainerIteratorNext(state);
+        }
+    }
+}
+function loadIcuContainerVisitor() {
+    const _state = {
+        stack: [],
+        index: -1,
+    };
+    /**
+     * Retrieves a set of root nodes from `TIcu.remove`. Used by `TNodeType.ICUContainer`
+     * to determine which root belong to the ICU.
+     *
+     * Example of usage.
+     * ```
+     * const nextRNode = icuContainerIteratorStart(tIcuContainerNode, lView);
+     * let rNode: RNode|null;
+     * while(rNode = nextRNode()) {
+     *   console.log(rNode);
+     * }
+     * ```
+     *
+     * @param tIcuContainerNode Current `TIcuContainerNode`
+     * @param lView `LView` where the `RNode`s should be looked up.
+     */
+    function icuContainerIteratorStart(tIcuContainerNode, lView) {
+        _state.lView = lView;
+        while (_state.stack.length)
+            _state.stack.pop();
+        ngDevMode && assertTNodeForLView(tIcuContainerNode, lView);
+        enterIcu(_state, tIcuContainerNode.value, lView);
+        return icuContainerIteratorNext.bind(null, _state);
+    }
+    return icuContainerIteratorStart;
+}
+function createIcuIterator(tIcu, lView) {
+    const state = {
+        stack: [],
+        index: -1,
+        lView,
+    };
+    ngDevMode && assertTIcu(tIcu);
+    enterIcu(state, tIcu, lView);
+    return icuContainerIteratorNext.bind(null, state);
+}
+
 /**
  * Regexp that extracts a reference node information from the compressed node location.
  * The reference node is represented as either:
@@ -14547,15 +14649,21 @@ function getNoOffsetIndex(tNode) {
 }
 /**
  * Check whether a given node exists, but is disconnected from the DOM.
+ */
+function isDisconnectedNode(tNode, lView) {
+    return (!(tNode.type & (16 /* TNodeType.Projection */ | 128 /* TNodeType.LetDeclaration */)) &&
+        !!lView[tNode.index] &&
+        isDisconnectedRNode(unwrapRNode(lView[tNode.index])));
+}
+/**
+ * Check whether the given node exists, but is disconnected from the DOM.
  *
  * Note: we leverage the fact that we have this information available in the DOM emulation
  * layer (in Domino) for now. Longer-term solution should not rely on the DOM emulation and
  * only use internal data structures and state to compute this information.
  */
-function isDisconnectedNode(tNode, lView) {
-    return (!(tNode.type & 16 /* TNodeType.Projection */) &&
-        !!lView[tNode.index] &&
-        !unwrapRNode(lView[tNode.index])?.isConnected);
+function isDisconnectedRNode(rNode) {
+    return !!rNode && !rNode.isConnected;
 }
 /**
  * Locate a node in an i18n tree that corresponds to a given instruction index.
@@ -14819,7 +14927,7 @@ function calcPathForNode(tNode, lView, excludedParentNodes) {
         referenceNodeName = renderStringify(parentIndex - HEADER_OFFSET);
     }
     let rNode = unwrapRNode(lView[tNode.index]);
-    if (tNode.type & 12 /* TNodeType.AnyContainer */) {
+    if (tNode.type & (12 /* TNodeType.AnyContainer */ | 32 /* TNodeType.Icu */)) {
         // For <ng-container> nodes, instead of serializing a reference
         // to the anchor comment node, serialize a location of the first
         // DOM element. Paired with the container size (serialized as a part
@@ -14951,30 +15059,104 @@ function trySerializeI18nBlock(lView, index, context) {
     if (!tI18n || !tI18n.ast) {
         return null;
     }
-    const caseQueue = [];
-    tI18n.ast.forEach((node) => serializeI18nBlock(lView, caseQueue, context, node));
-    return caseQueue.length > 0 ? caseQueue : null;
+    const serializedI18nBlock = {
+        caseQueue: [],
+        disconnectedNodes: new Set(),
+        disjointNodes: new Set(),
+    };
+    serializeI18nBlock(lView, serializedI18nBlock, context, tI18n.ast);
+    return serializedI18nBlock.caseQueue.length === 0 &&
+        serializedI18nBlock.disconnectedNodes.size === 0 &&
+        serializedI18nBlock.disjointNodes.size === 0
+        ? null
+        : serializedI18nBlock;
+}
+function serializeI18nBlock(lView, serializedI18nBlock, context, nodes) {
+    let prevRNode = null;
+    for (const node of nodes) {
+        const nextRNode = serializeI18nNode(lView, serializedI18nBlock, context, node);
+        if (nextRNode) {
+            if (isDisjointNode(prevRNode, nextRNode)) {
+                serializedI18nBlock.disjointNodes.add(node.index - HEADER_OFFSET);
+            }
+            prevRNode = nextRNode;
+        }
+    }
+    return prevRNode;
 }
-function serializeI18nBlock(lView, caseQueue, context, node) {
+/**
+ * Helper to determine whether the given nodes are "disjoint".
+ *
+ * The i18n hydration process walks through the DOM and i18n nodes
+ * at the same time. It expects the sibling DOM node of the previous
+ * i18n node to be the first node of the next i18n node.
+ *
+ * In cases of content projection, this won't always be the case. So
+ * when we detect that, we mark the node as "disjoint", ensuring that
+ * we will serialize the path to the node. This way, when we hydrate the
+ * i18n node, we will be able to find the correct place to start.
+ */
+function isDisjointNode(prevNode, nextNode) {
+    return prevNode && prevNode.nextSibling !== nextNode;
+}
+/**
+ * Process the given i18n node for serialization.
+ * Returns the first RNode for the i18n node to begin hydration.
+ */
+function serializeI18nNode(lView, serializedI18nBlock, context, node) {
+    const maybeRNode = unwrapRNode(lView[node.index]);
+    if (!maybeRNode || isDisconnectedRNode(maybeRNode)) {
+        serializedI18nBlock.disconnectedNodes.add(node.index - HEADER_OFFSET);
+        return null;
+    }
+    const rNode = maybeRNode;
     switch (node.kind) {
-        case 0 /* I18nNodeKind.TEXT */:
-            const rNode = unwrapRNode(lView[node.index]);
+        case 0 /* I18nNodeKind.TEXT */: {
             processTextNodeBeforeSerialization(context, rNode);
             break;
+        }
         case 1 /* I18nNodeKind.ELEMENT */:
-        case 2 /* I18nNodeKind.PLACEHOLDER */:
-            node.children.forEach((node) => serializeI18nBlock(lView, caseQueue, context, node));
+        case 2 /* I18nNodeKind.PLACEHOLDER */: {
+            serializeI18nBlock(lView, serializedI18nBlock, context, node.children);
             break;
-        case 3 /* I18nNodeKind.ICU */:
+        }
+        case 3 /* I18nNodeKind.ICU */: {
             const currentCase = lView[node.currentCaseLViewIndex];
             if (currentCase != null) {
                 // i18n uses a negative value to signal a change to a new case, so we
                 // need to invert it to get the proper value.
                 const caseIdx = currentCase < 0 ? ~currentCase : currentCase;
-                caseQueue.push(caseIdx);
-                node.cases[caseIdx].forEach((node) => serializeI18nBlock(lView, caseQueue, context, node));
+                serializedI18nBlock.caseQueue.push(caseIdx);
+                serializeI18nBlock(lView, serializedI18nBlock, context, node.cases[caseIdx]);
             }
             break;
+        }
+    }
+    return getFirstNativeNodeForI18nNode(lView, node);
+}
+/**
+ * Helper function to get the first native node to begin hydrating
+ * the given i18n node.
+ */
+function getFirstNativeNodeForI18nNode(lView, node) {
+    const tView = lView[TVIEW];
+    const maybeTNode = tView.data[node.index];
+    if (isTNodeShape(maybeTNode)) {
+        // If the node is backed by an actual TNode, we can simply delegate.
+        return getFirstNativeNode(lView, maybeTNode);
+    }
+    else if (node.kind === 3 /* I18nNodeKind.ICU */) {
+        // A nested ICU container won't have an actual TNode. In that case, we can use
+        // an iterator to find the first child.
+        const icuIterator = createIcuIterator(maybeTNode, lView);
+        let rNode = icuIterator();
+        // If the ICU container has no nodes, then we use the ICU anchor as the node.
+        return rNode ?? unwrapRNode(lView[node.index]);
+    }
+    else {
+        // Otherwise, the node is a text or trivial element in an ICU container,
+        // and we can just use the RNode directly.
+        return unwrapRNode(lView[node.index]) ?? null;
     }
 }
 function setCurrentNode(state, node) {
@@ -15067,16 +15249,24 @@ function prepareI18nBlockForHydrationImpl(lView, index, parentTNode, subTemplate
 }
 function collectI18nNodesFromDom(context, state, nodeOrNodes) {
     if (Array.isArray(nodeOrNodes)) {
+        let nextState = state;
         for (const node of nodeOrNodes) {
-            // If the node is being projected elsewhere, we need to temporarily
-            // branch the state to that location to continue hydration.
-            // Otherwise, we continue hydration from the current location.
+            // Whenever a node doesn't directly follow the previous RNode, it
+            // is given a path. We need to resume collecting nodes from that location
+            // until and unless we find another disjoint node.
             const targetNode = tryLocateRNodeByPath(context.hydrationInfo, context.lView, node.index - HEADER_OFFSET);
-            const nextState = targetNode ? forkHydrationState(state, targetNode) : state;
+            if (targetNode) {
+                nextState = forkHydrationState(state, targetNode);
+            }
             collectI18nNodesFromDom(context, nextState, node);
         }
     }
     else {
+        if (context.disconnectedNodes.has(nodeOrNodes.index - HEADER_OFFSET)) {
+            // i18n nodes can be considered disconnected if e.g. they were projected.
+            // In that case, we have to make sure to skip over them.
+            return;
+        }
         switch (nodeOrNodes.kind) {
             case 0 /* I18nNodeKind.TEXT */: {
                 // Claim a text node for hydration
@@ -17011,7 +17201,7 @@ function createRootComponent(componentView, rootComponentDef, rootDirectives, ho
 function setRootNodeAttributes(hostRenderer, componentDef, hostRNode, rootSelectorOrNode) {
     if (rootSelectorOrNode) {
         // The placeholder will be replaced with the actual version at build time.
-        setUpAttributes(hostRenderer, hostRNode, ['ng-version', '18.1.0-next.3']);
+        setUpAttributes(hostRenderer, hostRNode, ['ng-version', '18.1.0-next.4']);
     }
     else {
         // If host element is created as a part of this function call (i.e. `rootSelectorOrNode`
@@ -20813,7 +21003,7 @@ function triggerResourceLoading(tDetails, lView, tNode) {
         if (failed) {
             tDetails.loadingState = DeferDependenciesLoadingState.FAILED;
             if (tDetails.errorTmplIndex === null) {
-                const templateLocation = getTemplateLocationDetails(lView);
+                const templateLocation = ngDevMode ? getTemplateLocationDetails(lView) : '';
                 const error = new RuntimeError(750 /* RuntimeErrorCode.DEFER_LOADING_FAILED */, ngDevMode &&
                     'Loading dependencies for `@defer` block failed, ' +
                         `but no \`@error\` block was configured${templateLocation}. ` +
@@ -25096,79 +25286,6 @@ function getCaseIndex(icuExpression, bindingValue) {
     return index === -1 ? null : index;
 }
 
-function loadIcuContainerVisitor() {
-    const _stack = [];
-    let _index = -1;
-    let _lView;
-    let _removes;
-    /**
-     * Retrieves a set of root nodes from `TIcu.remove`. Used by `TNodeType.ICUContainer`
-     * to determine which root belong to the ICU.
-     *
-     * Example of usage.
-     * ```
-     * const nextRNode = icuContainerIteratorStart(tIcuContainerNode, lView);
-     * let rNode: RNode|null;
-     * while(rNode = nextRNode()) {
-     *   console.log(rNode);
-     * }
-     * ```
-     *
-     * @param tIcuContainerNode Current `TIcuContainerNode`
-     * @param lView `LView` where the `RNode`s should be looked up.
-     */
-    function icuContainerIteratorStart(tIcuContainerNode, lView) {
-        _lView = lView;
-        while (_stack.length)
-            _stack.pop();
-        ngDevMode && assertTNodeForLView(tIcuContainerNode, lView);
-        enterIcu(tIcuContainerNode.value, lView);
-        return icuContainerIteratorNext;
-    }
-    function enterIcu(tIcu, lView) {
-        _index = 0;
-        const currentCase = getCurrentICUCaseIndex(tIcu, lView);
-        if (currentCase !== null) {
-            ngDevMode && assertNumberInRange(currentCase, 0, tIcu.cases.length - 1);
-            _removes = tIcu.remove[currentCase];
-        }
-        else {
-            _removes = EMPTY_ARRAY;
-        }
-    }
-    function icuContainerIteratorNext() {
-        if (_index < _removes.length) {
-            const removeOpCode = _removes[_index++];
-            ngDevMode && assertNumber(removeOpCode, 'Expecting OpCode number');
-            if (removeOpCode > 0) {
-                const rNode = _lView[removeOpCode];
-                ngDevMode && assertDomNode(rNode);
-                return rNode;
-            }
-            else {
-                _stack.push(_index, _removes);
-                // ICUs are represented by negative indices
-                const tIcuIndex = ~removeOpCode;
-                const tIcu = _lView[TVIEW].data[tIcuIndex];
-                ngDevMode && assertTIcu(tIcu);
-                enterIcu(tIcu, _lView);
-                return icuContainerIteratorNext();
-            }
-        }
-        else {
-            if (_stack.length === 0) {
-                return null;
-            }
-            else {
-                _removes = _stack.pop();
-                _index = _stack.pop();
-                return icuContainerIteratorNext();
-            }
-        }
-    }
-    return icuContainerIteratorStart;
-}
-
 /**
  * Converts `I18nCreateOpCodes` array into a human readable format.
  *
@@ -26621,17 +26738,20 @@ function ɵɵprojectionDef(projectionSlots) {
         const tails = projectionHeads.slice();
         let componentChild = componentNode.child;
         while (componentChild !== null) {
-            const slotIndex = projectionSlots
-                ? matchingProjectionSlotIndex(componentChild, projectionSlots)
-                : 0;
-            if (slotIndex !== null) {
-                if (tails[slotIndex]) {
-                    tails[slotIndex].projectionNext = componentChild;
-                }
-                else {
-                    projectionHeads[slotIndex] = componentChild;
+            // Do not project let declarations so they don't occupy a slot.
+            if (componentChild.type !== 128 /* TNodeType.LetDeclaration */) {
+                const slotIndex = projectionSlots
+                    ? matchingProjectionSlotIndex(componentChild, projectionSlots)
+                    : 0;
+                if (slotIndex !== null) {
+                    if (tails[slotIndex]) {
+                        tails[slotIndex].projectionNext = componentChild;
+                    }
+                    else {
+                        projectionHeads[slotIndex] = componentChild;
+                    }
+                    tails[slotIndex] = componentChild;
                 }
-                tails[slotIndex] = componentChild;
             }
             componentChild = componentChild.next;
         }
@@ -28360,36 +28480,52 @@ function ɵɵtwoWayListener(eventName, listenerFn) {
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
+/** Object that indicates the value of a `@let` declaration that hasn't been initialized yet. */
+const UNINITIALIZED_LET = {};
 /**
- * Declares an `@let` at a specific data slot.
+ * Declares an `@let` at a specific data slot. Returns itself to allow chaining.
  *
  * @param index Index at which to declare the `@let`.
  *
  * @codeGenApi
  */
 function ɵɵdeclareLet(index) {
-    // TODO(crisbeto): implement this
+    const tView = getTView();
+    const lView = getLView();
+    const adjustedIndex = index + HEADER_OFFSET;
+    const tNode = getOrCreateTNode(tView, adjustedIndex, 128 /* TNodeType.LetDeclaration */, null, null);
+    setCurrentTNode(tNode, false);
+    store(tView, lView, adjustedIndex, UNINITIALIZED_LET);
     return ɵɵdeclareLet;
 }
 /**
  * Instruction that stores the value of a `@let` declaration on the current view.
+ * Returns the value to allow usage inside variable initializers.
  *
  * @codeGenApi
  */
 function ɵɵstoreLet(value) {
-    // TODO(crisbeto): implement this
+    performanceMarkFeature('NgLet');
+    const tView = getTView();
+    const lView = getLView();
+    const index = getSelectedIndex();
+    store(tView, lView, index, value);
     return value;
 }
 /**
- * Retrieves the value of a `@let` declaration defined within the same view.
+ * Retrieves the value of a `@let` declaration defined in a parent view.
  *
  * @param index Index of the declaration within the view.
  *
  * @codeGenApi
  */
 function ɵɵreadContextLet(index) {
-    // TODO(crisbeto): implement this
-    return null;
+    const contextLView = getContextLView();
+    const value = load(contextLView, HEADER_OFFSET + index);
+    if (value === UNINITIALIZED_LET) {
+        throw new RuntimeError(314 /* RuntimeErrorCode.UNINITIALIZED_LET_ACCESS */, ngDevMode && 'Attempting to access a @let declaration whose value is not available yet');
+    }
+    return value;
 }
 
 /*
@@ -30845,7 +30981,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('18.1.0-next.3');
+const VERSION = new Version('18.1.0-next.4');
 
 /*
  * This file exists to support compilation of @angular/core in Ivy mode.
@@ -34045,7 +34181,8 @@ function createViewRef(tNode, lView, isPipe) {
         const componentView = getComponentLViewByIndex(tNode.index, lView); // look down
         return new ViewRef$1(componentView, componentView);
     }
-    else if (tNode.type & (3 /* TNodeType.AnyRNode */ | 12 /* TNodeType.AnyContainer */ | 32 /* TNodeType.Icu */)) {
+    else if (tNode.type &
+        (3 /* TNodeType.AnyRNode */ | 12 /* TNodeType.AnyContainer */ | 32 /* TNodeType.Icu */ | 128 /* TNodeType.LetDeclaration */)) {
         // The LView represents the location where the injection is requested from.
         // We need to locate the containing LView (in case where the `lView` is an embedded view)
         const hostComponentView = lView[DECLARATION_COMPONENT_VIEW]; // look up
@@ -36660,7 +36797,8 @@ const initGlobalEventDelegation = (eventDelegation, injector) => {
     if (injector.get(IS_EVENT_REPLAY_ENABLED, EVENT_REPLAY_ENABLED_DEFAULT)) {
         return;
     }
-    eventDelegation.eventContract = new EventContract(new EventContractContainer(document.body));
+    eventDelegation.eventContract = new EventContract(new EventContractContainer(document.body), 
+    /* useActionResolver= */ false);
     const dispatcher = new EventDispatcher(invokeRegisteredListeners);
     registerDispatcher(eventDelegation.eventContract, dispatcher);
 };
@@ -36754,7 +36892,8 @@ const initEventReplay = (eventDelegation, injector) => {
     // This is set in packages/platform-server/src/utils.ts
     const container = globalThis[CONTRACT_PROPERTY]?.[appId];
     const earlyJsactionData = getJsactionData(container);
-    const eventContract = (eventDelegation.eventContract = new EventContract(new EventContractContainer(earlyJsactionData.c)));
+    const eventContract = (eventDelegation.eventContract = new EventContract(new EventContractContainer(earlyJsactionData.c), 
+    /* useActionResolver= */ false));
     for (const et of earlyJsactionData.et) {
         eventContract.addEvent(et);
     }
@@ -37053,15 +37192,18 @@ function serializeLContainer(lContainer, context) {
 function appendSerializedNodePath(ngh, tNode, lView, excludedParentNodes) {
     const noOffsetIndex = tNode.index - HEADER_OFFSET;
     ngh[NODES] ??= {};
-    ngh[NODES][noOffsetIndex] = calcPathForNode(tNode, lView, excludedParentNodes);
+    // Ensure we don't calculate the path multiple times.
+    ngh[NODES][noOffsetIndex] ??= calcPathForNode(tNode, lView, excludedParentNodes);
 }
 /**
  * Helper function to append information about a disconnected node.
  * This info is needed at runtime to avoid DOM lookups for this element
  * and instead, the element would be created from scratch.
  */
-function appendDisconnectedNodeIndex(ngh, tNode) {
-    const noOffsetIndex = tNode.index - HEADER_OFFSET;
+function appendDisconnectedNodeIndex(ngh, tNodeOrNoOffsetIndex) {
+    const noOffsetIndex = typeof tNodeOrNoOffsetIndex === 'number'
+        ? tNodeOrNoOffsetIndex
+        : tNodeOrNoOffsetIndex.index - HEADER_OFFSET;
     ngh[DISCONNECTED_NODES] ??= [];
     if (!ngh[DISCONNECTED_NODES].includes(noOffsetIndex)) {
         ngh[DISCONNECTED_NODES].push(noOffsetIndex);
@@ -37092,7 +37234,15 @@ function serializeLView(lView, context) {
         const i18nData = trySerializeI18nBlock(lView, i, context);
         if (i18nData) {
             ngh[I18N_DATA] ??= {};
-            ngh[I18N_DATA][noOffsetIndex] = i18nData;
+            ngh[I18N_DATA][noOffsetIndex] = i18nData.caseQueue;
+            for (const nodeNoOffsetIndex of i18nData.disconnectedNodes) {
+                appendDisconnectedNodeIndex(ngh, nodeNoOffsetIndex);
+            }
+            for (const nodeNoOffsetIndex of i18nData.disjointNodes) {
+                const tNode = tView.data[nodeNoOffsetIndex + HEADER_OFFSET];
+                ngDevMode && assertTNode(tNode);
+                appendSerializedNodePath(ngh, tNode, lView, i18nChildren);
+            }
             continue;
         }
         // Skip processing of a given slot in the following cases:
@@ -37205,13 +37355,14 @@ function serializeLView(lView, context) {
                 ngh[ELEMENT_CONTAINERS] ??= {};
                 ngh[ELEMENT_CONTAINERS][noOffsetIndex] = calcNumRootNodes(tView, lView, tNode.child);
             }
-            else if (tNode.type & 16 /* TNodeType.Projection */) {
-                // Current TNode represents an `<ng-content>` slot, thus it has no
-                // DOM elements associated with it, so the **next sibling** node would
-                // not be able to find an anchor. In this case, use full path instead.
+            else if (tNode.type & (16 /* TNodeType.Projection */ | 128 /* TNodeType.LetDeclaration */)) {
+                // Current TNode represents an `<ng-content>` slot or `@let` declaration,
+                // thus it has no DOM elements associated with it, so the **next sibling**
+                // node would not be able to find an anchor. In this case, use full path instead.
                 let nextTNode = tNode.next;
-                // Skip over all `<ng-content>` slots in a row.
-                while (nextTNode !== null && nextTNode.type & 16 /* TNodeType.Projection */) {
+                // Skip over all `<ng-content>` slots and `@let` declarations in a row.
+                while (nextTNode !== null &&
+                    nextTNode.type & (16 /* TNodeType.Projection */ | 128 /* TNodeType.LetDeclaration */)) {
                     nextTNode = nextTNode.next;
                 }
                 if (nextTNode && !isInSkipHydrationBlock(nextTNode)) {
@@ -37219,11 +37370,9 @@ function serializeLView(lView, context) {
                     appendSerializedNodePath(ngh, nextTNode, lView, i18nChildren);
                 }
             }
-            else {
-                if (tNode.type & 1 /* TNodeType.Text */) {
-                    const rNode = unwrapRNode(lView[i]);
-                    processTextNodeBeforeSerialization(context, rNode);
-                }
+            else if (tNode.type & 1 /* TNodeType.Text */) {
+                const rNode = unwrapRNode(lView[i]);
+                processTextNodeBeforeSerialization(context, rNode);
             }
         }
     }