@angular/core 19.1.0-rc.0 → 19.1.1

package/fesm2022/core.mjs

@@ -1,10 +1,10 @@
 /**
- * @license Angular v19.1.0-rc.0
+ * @license Angular v19.1.1
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
 
-import { SIGNAL_NODE as SIGNAL_NODE$1, signalSetFn as signalSetFn$1, producerAccessed as producerAccessed$1, SIGNAL as SIGNAL$1, getActiveConsumer as getActiveConsumer$1, setActiveConsumer as setActiveConsumer$1, consumerDestroy as consumerDestroy$1, REACTIVE_NODE as REACTIVE_NODE$1, consumerBeforeComputation as consumerBeforeComputation$1, consumerAfterComputation as consumerAfterComputation$1, consumerPollProducersForChange as consumerPollProducersForChange$1, createSignal as createSignal$1, signalUpdateFn as signalUpdateFn$1, createComputed as createComputed$1, setThrowInvalidWriteToSignalError as setThrowInvalidWriteToSignalError$1, producerUpdateValueVersion as producerUpdateValueVersion$1, producerMarkClean as producerMarkClean$1, defaultEquals as defaultEquals$1, createWatch as createWatch$1, isInNotificationPhase as isInNotificationPhase$1 } from '@angular/core/primitives/signals';
+import { SIGNAL_NODE as SIGNAL_NODE$1, signalSetFn as signalSetFn$1, producerAccessed as producerAccessed$1, SIGNAL as SIGNAL$1, getActiveConsumer as getActiveConsumer$1, setActiveConsumer as setActiveConsumer$1, createSignal as createSignal$1, signalUpdateFn as signalUpdateFn$1, consumerDestroy as consumerDestroy$1, REACTIVE_NODE as REACTIVE_NODE$1, consumerBeforeComputation as consumerBeforeComputation$1, consumerAfterComputation as consumerAfterComputation$1, consumerPollProducersForChange as consumerPollProducersForChange$1, createComputed as createComputed$1, setThrowInvalidWriteToSignalError as setThrowInvalidWriteToSignalError$1, producerUpdateValueVersion as producerUpdateValueVersion$1, producerMarkClean as producerMarkClean$1, defaultEquals as defaultEquals$1, createWatch as createWatch$1, isInNotificationPhase as isInNotificationPhase$1 } from '@angular/core/primitives/signals';
 export { SIGNAL as ɵSIGNAL } from '@angular/core/primitives/signals';
 import { BehaviorSubject, Subject, Subscription } from 'rxjs';
 import { Attribute as Attribute$1, EventContract, EventContractContainer, getAppScopedQueuedEventInfos, clearAppScopedEarlyEventContract, EventDispatcher, registerDispatcher, isEarlyEventType, isCaptureEventType, EventPhase } from '@angular/core/primitives/event-dispatch';
@@ -2902,7 +2902,6 @@ const ON_DESTROY_HOOKS = 21;
 const EFFECTS_TO_SCHEDULE = 22;
 const EFFECTS = 23;
 const REACTIVE_TEMPLATE_CONSUMER = 24;
-const AFTER_RENDER_SEQUENCES_TO_ADD = 25;
 /**
  * Size of LView's header. Necessary to adjust for it when setting slots.
  *
@@ -2910,7 +2909,7 @@ const AFTER_RENDER_SEQUENCES_TO_ADD = 25;
  * instruction index into `LView` index. All other indexes should be in the `LView` index space and
  * there should be no need to refer to `HEADER_OFFSET` anywhere else.
  */
-const HEADER_OFFSET = 26;
+const HEADER_OFFSET = 25;
 
 /**
  * Special location which allows easy identification of type. If we have an array which was
@@ -2936,18 +2935,6 @@ const MOVED_VIEWS = 9;
  * remove views from the DOM when they are no longer required.
  */
 const CONTAINER_HEADER_OFFSET = 10;
-/** Flags associated with an LContainer (saved in LContainer[FLAGS]) */
-var LContainerFlags;
-(function (LContainerFlags) {
-    LContainerFlags[LContainerFlags["None"] = 0] = "None";
-    /**
-     * Flag to signify that this `LContainer` may have transplanted views which need to be change
-     * detected. (see: `LView[DECLARATION_COMPONENT_VIEW])`.
-     *
-     * This flag, once set, is never unset for the `LContainer`.
-     */
-    LContainerFlags[LContainerFlags["HasTransplantedViews"] = 2] = "HasTransplantedViews";
-})(LContainerFlags || (LContainerFlags = {}));
 
 /**
  * True if `value` is `LView`.
@@ -3431,7 +3418,7 @@ function requiresRefreshOrTraversal(lView) {
  * parents above.
  */
 function updateAncestorTraversalFlagsOnAttach(lView) {
-    lView[ENVIRONMENT].changeDetectionScheduler?.notify(8 /* NotificationSource.ViewAttached */);
+    lView[ENVIRONMENT].changeDetectionScheduler?.notify(9 /* NotificationSource.ViewAttached */);
     if (lView[FLAGS] & 64 /* LViewFlags.Dirty */) {
         lView[FLAGS] |= 1024 /* LViewFlags.RefreshView */;
     }
@@ -3495,6 +3482,40 @@ function getLViewParent(lView) {
     const parent = lView[PARENT];
     return isLContainer(parent) ? parent[PARENT] : parent;
 }
+function getOrCreateLViewCleanup(view) {
+    // top level variables should not be exported for performance reasons (PERF_NOTES.md)
+    return (view[CLEANUP] ??= []);
+}
+function getOrCreateTViewCleanup(tView) {
+    return (tView.cleanup ??= []);
+}
+/**
+ * Saves context for this cleanup function in LView.cleanupInstances.
+ *
+ * On the first template pass, saves in TView:
+ * - Cleanup function
+ * - Index of context we just saved in LView.cleanupInstances
+ */
+function storeCleanupWithContext(tView, lView, context, cleanupFn) {
+    const lCleanup = getOrCreateLViewCleanup(lView);
+    // Historically the `storeCleanupWithContext` was used to register both framework-level and
+    // user-defined cleanup callbacks, but over time those two types of cleanups were separated.
+    // This dev mode checks assures that user-level cleanup callbacks are _not_ stored in data
+    // structures reserved for framework-specific hooks.
+    ngDevMode &&
+        assertDefined(context, 'Cleanup context is mandatory when registering framework-level destroy hooks');
+    lCleanup.push(context);
+    if (tView.firstCreatePass) {
+        getOrCreateTViewCleanup(tView).push(cleanupFn, lCleanup.length - 1);
+    }
+    else {
+        // Make sure that no new framework-level cleanup functions are registered after the first
+        // template pass is done (and TView data structures are meant to fully constructed).
+        if (ngDevMode) {
+            Object.freeze(getOrCreateTViewCleanup(tView));
+        }
+    }
+}
 
 const instructionState = {
     lFrame: createLFrame(null),
@@ -4411,7 +4432,7 @@ class NodeInjectorFactory {
      * Example:
      *
      * If we have a component and directive active an a single element as declared here
-     * ```
+     * ```ts
      * component:
      *   providers: [ {provide: String, useValue: 'component', multi: true} ],
      *   viewProviders: [ {provide: String, useValue: 'componentView', multi: true} ],
@@ -4422,7 +4443,7 @@ class NodeInjectorFactory {
      *
      * Then the expected results are:
      *
-     * ```
+     * ```ts
      * providers: ['component', 'directive']
      * viewProviders: ['component', 'componentView', 'directive']
      * ```
@@ -4445,7 +4466,7 @@ class NodeInjectorFactory {
      * Example:
      *
      * Given:
-     * ```
+     * ```ts
      * providers: [ {provide: String, useValue: 'all', multi: true} ],
      * viewProviders: [ {provide: String, useValue: 'viewOnly', multi: true} ],
      * ```
@@ -6140,14 +6161,14 @@ class PendingTasks {
                 return;
             }
             // Notifying the scheduler will hold application stability open until the next tick.
-            this.scheduler.notify(11 /* NotificationSource.PendingTaskRemoved */);
+            this.scheduler.notify(12 /* NotificationSource.PendingTaskRemoved */);
             this.internalPendingTasks.remove(taskId);
         };
     }
     /**
      * Runs an asynchronous function and blocks the application's stability until the function completes.
      *
-     * ```
+     * ```ts
      * pendingTasks.run(async () => {
      *   const userData = await fetch('/api/user');
      *   this.userData.set(userData);
@@ -6157,7 +6178,7 @@ class PendingTasks {
      * Application stability is at least delayed until the next tick after the `run` method resolves
      * so it is safe to make additional updates to application state that would require UI synchronization:
      *
-     * ```
+     * ```ts
      * const userData = await pendingTasks.run(() => fetch('/api/user'));
      * this.userData.set(userData);
      * ```
@@ -7087,6 +7108,76 @@ function unwrapElementRef(value) {
     return value instanceof ElementRef ? value.nativeElement : value;
 }
 
+const markedFeatures = new Set();
+// tslint:disable:ban
+/**
+ * A guarded `performance.mark` for feature marking.
+ *
+ * This method exists because while all supported browser and node.js version supported by Angular
+ * support performance.mark API. This is not the case for other environments such as JSDOM and
+ * Cloudflare workers.
+ */
+function performanceMarkFeature(feature) {
+    if (markedFeatures.has(feature)) {
+        return;
+    }
+    markedFeatures.add(feature);
+    performance?.mark?.('mark_feature_usage', { detail: { feature } });
+}
+
+/**
+ * Checks if the given `value` is a reactive `Signal`.
+ */
+function isSignal(value) {
+    return typeof value === 'function' && value[SIGNAL$1] !== undefined;
+}
+
+/** Symbol used distinguish `WritableSignal` from other non-writable signals and functions. */
+const ɵWRITABLE_SIGNAL = /* @__PURE__ */ Symbol('WRITABLE_SIGNAL');
+/**
+ * Utility function used during template type checking to extract the value from a `WritableSignal`.
+ * @codeGenApi
+ */
+function ɵunwrapWritableSignal(value) {
+    // Note: the function uses `WRITABLE_SIGNAL` as a brand instead of `WritableSignal<T>`,
+    // because the latter incorrectly unwraps non-signal getter functions.
+    return null;
+}
+/**
+ * Create a `Signal` that can be set or updated directly.
+ */
+function signal(initialValue, options) {
+    performanceMarkFeature('NgSignals');
+    const signalFn = createSignal$1(initialValue);
+    const node = signalFn[SIGNAL$1];
+    if (options?.equal) {
+        node.equal = options.equal;
+    }
+    signalFn.set = (newValue) => signalSetFn$1(node, newValue);
+    signalFn.update = (updateFn) => signalUpdateFn$1(node, updateFn);
+    signalFn.asReadonly = signalAsReadonlyFn.bind(signalFn);
+    if (ngDevMode) {
+        signalFn.toString = () => `[Signal: ${signalFn()}]`;
+        node.debugName = options?.debugName;
+    }
+    return signalFn;
+}
+function signalAsReadonlyFn() {
+    const node = this[SIGNAL$1];
+    if (node.readonlyFn === undefined) {
+        const readonlyFn = () => this();
+        readonlyFn[SIGNAL$1] = node;
+        node.readonlyFn = readonlyFn;
+    }
+    return node.readonlyFn;
+}
+/**
+ * Checks if the given `value` is a writeable signal.
+ */
+function isWritableSignal(value) {
+    return isSignal(value) && typeof value.set === 'function';
+}
+
 function symbolIterator() {
     // @ts-expect-error accessing a private member
     return this._results[Symbol.iterator]();
@@ -8476,15 +8567,8 @@ function retrieveTransferredState(doc, appId) {
 const REFERENCE_NODE_HOST = 'h';
 /** Encodes that the node lookup should start from the document body node. */
 const REFERENCE_NODE_BODY = 'b';
-/**
- * Describes navigation steps that the runtime logic need to perform,
- * starting from a given (known) element.
- */
-var NodeNavigationStep;
-(function (NodeNavigationStep) {
-    NodeNavigationStep["FirstChild"] = "f";
-    NodeNavigationStep["NextSibling"] = "n";
-})(NodeNavigationStep || (NodeNavigationStep = {}));
+const NODE_NAVIGATION_STEP_FIRST_CHILD = 'f';
+const NODE_NAVIGATION_STEP_NEXT_SIBLING = 'n';
 /**
  * Keys within serialized view data structure to represent various
  * parts. See the `SerializedView` interface below for additional information.
@@ -8555,23 +8639,6 @@ var TracingAction;
  */
 const TracingService = new InjectionToken(ngDevMode ? 'TracingService' : '');
 
-const markedFeatures = new Set();
-// tslint:disable:ban
-/**
- * A guarded `performance.mark` for feature marking.
- *
- * This method exists because while all supported browser and node.js version supported by Angular
- * support performance.mark API. This is not the case for other environments such as JSDOM and
- * Cloudflare workers.
- */
-function performanceMarkFeature(feature) {
-    if (markedFeatures.has(feature)) {
-        return;
-    }
-    markedFeatures.add(feature);
-    performance?.mark?.('mark_feature_usage', { detail: { feature } });
-}
-
 /**
  * Asserts that the current stack frame is not within a reactive context. Useful
  * to disallow certain code from running inside a reactive context (see {@link toSignal}).
@@ -8589,23 +8656,6 @@ function assertNotInReactiveContext(debugFn, extraContext) {
     }
 }
 
-class ViewContext {
-    view;
-    node;
-    constructor(view, node) {
-        this.view = view;
-        this.node = node;
-    }
-    /**
-     * @internal
-     * @nocollapse
-     */
-    static __NG_ELEMENT_ID__ = injectViewContext;
-}
-function injectViewContext() {
-    return new ViewContext(getLView(), getCurrentTNode());
-}
-
 /**
  * The phase to run an `afterRender` or `afterNextRender` callback in.
  *
@@ -8736,32 +8786,21 @@ class AfterRenderImpl {
             this.sequences.add(sequence);
         }
         if (this.deferredRegistrations.size > 0) {
-            this.scheduler.notify(7 /* NotificationSource.RenderHook */);
+            this.scheduler.notify(8 /* NotificationSource.DeferredRenderHook */);
         }
         this.deferredRegistrations.clear();
     }
     register(sequence) {
-        const { view } = sequence;
-        if (view !== undefined) {
-            // Delay adding it to the manager, add it to the view instead.
-            (view[AFTER_RENDER_SEQUENCES_TO_ADD] ??= []).push(sequence);
-            // Mark the view for traversal to ensure we eventually schedule the afterNextRender.
-            markAncestorsForTraversal(view);
-            view[FLAGS] |= 8192 /* LViewFlags.HasChildViewsToRefresh */;
-        }
-        else if (!this.executing) {
-            this.addSequence(sequence);
+        if (!this.executing) {
+            this.sequences.add(sequence);
+            // Trigger an `ApplicationRef.tick()` if one is not already pending/running, because we have a
+            // new render hook that needs to run.
+            this.scheduler.notify(7 /* NotificationSource.RenderHook */);
         }
         else {
             this.deferredRegistrations.add(sequence);
         }
     }
-    addSequence(sequence) {
-        this.sequences.add(sequence);
-        // Trigger an `ApplicationRef.tick()` if one is not already pending/running, because we have a
-        // new render hook that needs to run.
-        this.scheduler.notify(7 /* NotificationSource.RenderHook */);
-    }
     unregister(sequence) {
         if (this.executing && this.sequences.has(sequence)) {
             // We can't remove an `AfterRenderSequence` in the middle of iteration.
@@ -8791,7 +8830,6 @@ class AfterRenderImpl {
 class AfterRenderSequence {
     impl;
     hooks;
-    view;
     once;
     snapshot;
     /**
@@ -8805,10 +8843,9 @@ class AfterRenderSequence {
      */
     pipelinedValue = undefined;
     unregisterOnDestroy;
-    constructor(impl, hooks, view, once, destroyRef, snapshot = null) {
+    constructor(impl, hooks, once, destroyRef, snapshot = null) {
         this.impl = impl;
         this.hooks = hooks;
-        this.view = view;
         this.once = once;
         this.snapshot = snapshot;
         this.unregisterOnDestroy = destroyRef?.onDestroy(() => this.destroy());
@@ -8826,10 +8863,6 @@ class AfterRenderSequence {
     destroy() {
         this.impl.unregister(this);
         this.unregisterOnDestroy?.();
-        const scheduled = this.view?.[AFTER_RENDER_SEQUENCES_TO_ADD];
-        if (scheduled) {
-            this.view[AFTER_RENDER_SEQUENCES_TO_ADD] = scheduled.filter((s) => s !== this);
-        }
     }
 }
 
@@ -8880,8 +8913,7 @@ function afterRenderImpl(callbackOrSpec, injector, options, once) {
     const tracing = injector.get(TracingService, null, { optional: true });
     const hooks = options?.phase ?? AfterRenderPhase.MixedReadWrite;
     const destroyRef = options?.manualCleanup !== true ? injector.get(DestroyRef) : null;
-    const viewContext = injector.get(ViewContext, null, { optional: true });
-    const sequence = new AfterRenderSequence(manager.impl, getHooks(callbackOrSpec, hooks), viewContext?.view, once, destroyRef, tracing?.snapshot(null));
+    const sequence = new AfterRenderSequence(manager.impl, getHooks(callbackOrSpec, hooks), once, destroyRef, tracing?.snapshot(null));
     manager.impl.register(sequence);
     return sequence;
 }
@@ -9353,11 +9385,9 @@ function getTriggerElement(triggerLView, triggerIndex) {
 function registerDomTrigger(initialLView, tNode, triggerIndex, walkUpTimes, registerFn, callback, type) {
     const injector = initialLView[INJECTOR];
     const zone = injector.get(NgZone);
-    let poll;
     function pollDomTrigger() {
         // If the initial view was destroyed, we don't need to do anything.
         if (isDestroyed(initialLView)) {
-            poll.destroy();
             return;
         }
         const lDetails = getLDeferBlockDetails(initialLView, tNode);
@@ -9365,16 +9395,14 @@ function registerDomTrigger(initialLView, tNode, triggerIndex, walkUpTimes, regi
         // If the block was loaded before the trigger was resolved, we don't need to do anything.
         if (renderedState !== DeferBlockInternalState.Initial &&
             renderedState !== DeferBlockState.Placeholder) {
-            poll.destroy();
             return;
         }
         const triggerLView = getTriggerLView(initialLView, tNode, walkUpTimes);
         // Keep polling until we resolve the trigger's LView.
         if (!triggerLView) {
-            // Keep polling.
+            afterNextRender({ read: pollDomTrigger }, { injector });
             return;
         }
-        poll.destroy();
         // It's possible that the trigger's view was destroyed before we resolved the trigger element.
         if (isDestroyed(triggerLView)) {
             return;
@@ -9401,7 +9429,7 @@ function registerDomTrigger(initialLView, tNode, triggerIndex, walkUpTimes, regi
         storeTriggerCleanupFn(type, lDetails, cleanup);
     }
     // Begin polling for the trigger.
-    poll = afterRender({ read: pollDomTrigger }, { injector });
+    afterNextRender({ read: pollDomTrigger }, { injector });
 }
 
 const DEFER_BLOCK_SSR_ID_ATTRIBUTE = 'ngb';
@@ -10066,6 +10094,63 @@ function processBlockData(injector) {
     return blockDetails;
 }
 
+/** Refreshes all content queries declared by directives in a given view */
+function refreshContentQueries(tView, lView) {
+    const contentQueries = tView.contentQueries;
+    if (contentQueries !== null) {
+        const prevConsumer = setActiveConsumer$1(null);
+        try {
+            for (let i = 0; i < contentQueries.length; i += 2) {
+                const queryStartIdx = contentQueries[i];
+                const directiveDefIdx = contentQueries[i + 1];
+                if (directiveDefIdx !== -1) {
+                    const directiveDef = tView.data[directiveDefIdx];
+                    ngDevMode && assertDefined(directiveDef, 'DirectiveDef not found.');
+                    ngDevMode &&
+                        assertDefined(directiveDef.contentQueries, 'contentQueries function should be defined');
+                    setCurrentQueryIndex(queryStartIdx);
+                    directiveDef.contentQueries(2 /* RenderFlags.Update */, lView[directiveDefIdx], directiveDefIdx);
+                }
+            }
+        }
+        finally {
+            setActiveConsumer$1(prevConsumer);
+        }
+    }
+}
+function executeViewQueryFn(flags, viewQueryFn, component) {
+    ngDevMode && assertDefined(viewQueryFn, 'View queries function to execute must be defined.');
+    setCurrentQueryIndex(0);
+    const prevConsumer = setActiveConsumer$1(null);
+    try {
+        viewQueryFn(flags, component);
+    }
+    finally {
+        setActiveConsumer$1(prevConsumer);
+    }
+}
+function executeContentQueries(tView, tNode, lView) {
+    if (isContentQueryHost(tNode)) {
+        const prevConsumer = setActiveConsumer$1(null);
+        try {
+            const start = tNode.directiveStart;
+            const end = tNode.directiveEnd;
+            for (let directiveIndex = start; directiveIndex < end; directiveIndex++) {
+                const def = tView.data[directiveIndex];
+                if (def.contentQueries) {
+                    const directiveInstance = lView[directiveIndex];
+                    ngDevMode &&
+                        assertDefined(directiveIndex, 'Incorrect reference to a directive defining a content query');
+                    def.contentQueries(1 /* RenderFlags.Create */, directiveInstance, directiveIndex);
+                }
+            }
+        }
+        finally {
+            setActiveConsumer$1(prevConsumer);
+        }
+    }
+}
+
 /**
  * Defines the CSS styles encapsulation policies for the {@link Component} decorator's
  * `encapsulation` option.
@@ -11715,7 +11800,7 @@ function detachViewFromDOM(tView, lView) {
     // When we remove a view from the DOM, we need to rerun afterRender hooks
     // We don't necessarily needs to run change detection. DOM removal only requires
     // change detection if animations are enabled (this notification is handled by animations).
-    lView[ENVIRONMENT].changeDetectionScheduler?.notify(9 /* NotificationSource.ViewDetachedFromDOM */);
+    lView[ENVIRONMENT].changeDetectionScheduler?.notify(10 /* NotificationSource.ViewDetachedFromDOM */);
     applyView(tView, lView, lView[RENDERER], 2 /* WalkTNodeTreeAction.Detach */, null, null);
 }
 /**
@@ -11825,7 +11910,7 @@ function trackMovedView(declarationContainer, lView) {
     const parent = lView[PARENT];
     ngDevMode && assertDefined(parent, 'missing parent');
     if (isLView(parent)) {
-        declarationContainer[FLAGS] |= LContainerFlags.HasTransplantedViews;
+        declarationContainer[FLAGS] |= 2 /* LContainerFlags.HasTransplantedViews */;
     }
     else {
         const insertedComponentLView = parent[PARENT][DECLARATION_COMPONENT_VIEW];
@@ -11836,7 +11921,7 @@ function trackMovedView(declarationContainer, lView) {
             // At this point the declaration-component is not same as insertion-component; this means that
             // this is a transplanted view. Mark the declared lView as having transplanted views so that
             // those views can participate in CD.
-            declarationContainer[FLAGS] |= LContainerFlags.HasTransplantedViews;
+            declarationContainer[FLAGS] |= 2 /* LContainerFlags.HasTransplantedViews */;
         }
     }
     if (movedViews === null) {
@@ -13117,41 +13202,6 @@ function writeToDirectiveInput(def, instance, publicName, privateName, flags, va
     }
 }
 
-/**
- * Invoke `HostBindingsFunction`s for view.
- *
- * This methods executes `TView.hostBindingOpCodes`. It is used to execute the
- * `HostBindingsFunction`s associated with the current `LView`.
- *
- * @param tView Current `TView`.
- * @param lView Current `LView`.
- */
-function processHostBindingOpCodes(tView, lView) {
-    const hostBindingOpCodes = tView.hostBindingOpCodes;
-    if (hostBindingOpCodes === null)
-        return;
-    try {
-        for (let i = 0; i < hostBindingOpCodes.length; i++) {
-            const opCode = hostBindingOpCodes[i];
-            if (opCode < 0) {
-                // Negative numbers are element indexes.
-                setSelectedIndex(~opCode);
-            }
-            else {
-                // Positive numbers are NumberTuple which store bindingRootIndex and directiveIndex.
-                const directiveIdx = opCode;
-                const bindingRootIndx = hostBindingOpCodes[++i];
-                const hostBindingFn = hostBindingOpCodes[++i];
-                setBindingRootForHostBindings(bindingRootIndx, directiveIdx);
-                const context = lView[directiveIdx];
-                hostBindingFn(2 /* RenderFlags.Update */, context);
-            }
-        }
-    }
-    finally {
-        setSelectedIndex(-1);
-    }
-}
 function createLView(parentLView, tView, context, flags, host, tHostNode, environment, renderer, injector, embeddedViewInjector, hydrationInfo) {
     const lView = tView.blueprint.slice();
     lView[HOST] = host;
@@ -13298,30 +13348,6 @@ function executeTemplate(tView, lView, templateFn, rf, context) {
         profiler(postHookType, context);
     }
 }
-//////////////////////////
-//// Element
-//////////////////////////
-function executeContentQueries(tView, tNode, lView) {
-    if (isContentQueryHost(tNode)) {
-        const prevConsumer = setActiveConsumer$1(null);
-        try {
-            const start = tNode.directiveStart;
-            const end = tNode.directiveEnd;
-            for (let directiveIndex = start; directiveIndex < end; directiveIndex++) {
-                const def = tView.data[directiveIndex];
-                if (def.contentQueries) {
-                    const directiveInstance = lView[directiveIndex];
-                    ngDevMode &&
-                        assertDefined(directiveIndex, 'Incorrect reference to a directive defining a content query');
-                    def.contentQueries(1 /* RenderFlags.Create */, directiveInstance, directiveIndex);
-                }
-            }
-        }
-        finally {
-            setActiveConsumer$1(prevConsumer);
-        }
-    }
-}
 /**
  * Creates directive instances.
  */
@@ -13503,33 +13529,6 @@ function applyRootElementTransformImpl(rootElement) {
 function enableApplyRootElementTransformImpl() {
     _applyRootElementTransformImpl = applyRootElementTransformImpl;
 }
-/**
- * Saves context for this cleanup function in LView.cleanupInstances.
- *
- * On the first template pass, saves in TView:
- * - Cleanup function
- * - Index of context we just saved in LView.cleanupInstances
- */
-function storeCleanupWithContext(tView, lView, context, cleanupFn) {
-    const lCleanup = getOrCreateLViewCleanup(lView);
-    // Historically the `storeCleanupWithContext` was used to register both framework-level and
-    // user-defined cleanup callbacks, but over time those two types of cleanups were separated.
-    // This dev mode checks assures that user-level cleanup callbacks are _not_ stored in data
-    // structures reserved for framework-specific hooks.
-    ngDevMode &&
-        assertDefined(context, 'Cleanup context is mandatory when registering framework-level destroy hooks');
-    lCleanup.push(context);
-    if (tView.firstCreatePass) {
-        getOrCreateTViewCleanup(tView).push(cleanupFn, lCleanup.length - 1);
-    }
-    else {
-        // Make sure that no new framework-level cleanup functions are registered after the first
-        // template pass is done (and TView data structures are meant to fully constructed).
-        if (ngDevMode) {
-            Object.freeze(getOrCreateTViewCleanup(tView));
-        }
-    }
-}
 function createTNode(tView, tParent, type, index, value, attrs) {
     ngDevMode &&
         index !== 0 && // 0 are bogus nodes and they are OK. See `createContainerRef` in
@@ -14273,30 +14272,6 @@ function createLContainer(hostNative, currentView, native, tNode) {
         assertEqual(lContainer.length, CONTAINER_HEADER_OFFSET, 'Should allocate correct number of slots for LContainer header.');
     return lContainer;
 }
-/** Refreshes all content queries declared by directives in a given view */
-function refreshContentQueries(tView, lView) {
-    const contentQueries = tView.contentQueries;
-    if (contentQueries !== null) {
-        const prevConsumer = setActiveConsumer$1(null);
-        try {
-            for (let i = 0; i < contentQueries.length; i += 2) {
-                const queryStartIdx = contentQueries[i];
-                const directiveDefIdx = contentQueries[i + 1];
-                if (directiveDefIdx !== -1) {
-                    const directiveDef = tView.data[directiveDefIdx];
-                    ngDevMode && assertDefined(directiveDef, 'DirectiveDef not found.');
-                    ngDevMode &&
-                        assertDefined(directiveDef.contentQueries, 'contentQueries function should be defined');
-                    setCurrentQueryIndex(queryStartIdx);
-                    directiveDef.contentQueries(2 /* RenderFlags.Update */, lView[directiveDefIdx], directiveDefIdx);
-                }
-            }
-        }
-        finally {
-            setActiveConsumer$1(prevConsumer);
-        }
-    }
-}
 /**
  * Adds LView or LContainer to the end of the current view tree.
  *
@@ -14323,20 +14298,6 @@ function addToEndOfViewTree(lView, lViewOrLContainer) {
     return lViewOrLContainer;
 }
 ///////////////////////////////
-//// Change detection
-///////////////////////////////
-function executeViewQueryFn(flags, viewQueryFn, component) {
-    ngDevMode && assertDefined(viewQueryFn, 'View queries function to execute must be defined.');
-    setCurrentQueryIndex(0);
-    const prevConsumer = setActiveConsumer$1(null);
-    try {
-        viewQueryFn(flags, component);
-    }
-    finally {
-        setActiveConsumer$1(prevConsumer);
-    }
-}
-///////////////////////////////
 //// Bindings & interpolations
 ///////////////////////////////
 /**
@@ -14377,13 +14338,6 @@ function storePropertyBindingMetadata(tData, tNode, propertyName, bindingIndex,
         }
     }
 }
-function getOrCreateLViewCleanup(view) {
-    // top level variables should not be exported for performance reasons (PERF_NOTES.md)
-    return (view[CLEANUP] ??= []);
-}
-function getOrCreateTViewCleanup(tView) {
-    return (tView.cleanup ??= []);
-}
 /**
  * There are cases where the sub component's renderer needs to be included
  * instead of the current renderer (see the componentSyntheticHost* instructions).
@@ -14426,17 +14380,6 @@ function setInputsForProperty(tView, lView, inputs, publicName, value) {
         writeToDirectiveInput(def, instance, publicName, privateName, flags, value);
     }
 }
-/**
- * Updates a text binding at a given index in a given LView.
- */
-function textBindingInternal(lView, index, value) {
-    ngDevMode && assertString(value, 'Value should be a string');
-    ngDevMode && assertNotSame(value, NO_CHANGE, 'value should not be NO_CHANGE');
-    ngDevMode && assertIndexInRange(lView, index);
-    const element = getNativeByIndex(index, lView);
-    ngDevMode && assertDefined(element, 'native element should exist');
-    updateTextNode(lView[RENDERER], element, value);
-}
 
 function renderComponent(hostLView, componentHostIdx) {
     ngDevMode && assertEqual(isCreationMode(hostLView), true, 'Should be run in creation mode');
@@ -14702,15 +14645,6 @@ function collectNativeNodesInLContainer(lContainer, result) {
     }
 }
 
-function addAfterRenderSequencesForView(lView) {
-    if (lView[AFTER_RENDER_SEQUENCES_TO_ADD] !== null) {
-        for (const sequence of lView[AFTER_RENDER_SEQUENCES_TO_ADD]) {
-            sequence.impl.addSequence(sequence);
-        }
-        lView[AFTER_RENDER_SEQUENCES_TO_ADD].length = 0;
-    }
-}
-
 let freeConsumers = [];
 /**
  * Create a new template consumer pointing at the specified LView.
@@ -15056,7 +14990,6 @@ function refreshView(tView, lView, templateFn, context) {
         // no changes cycle, the component would be not be dirty for the next update pass. This would
         // be different in production mode where the component dirty state is not reset.
         if (!isInCheckNoChangesPass) {
-            addAfterRenderSequencesForView(lView);
             lView[FLAGS] &= ~(64 /* LViewFlags.Dirty */ | 8 /* LViewFlags.FirstLViewPass */);
         }
     }
@@ -15099,7 +15032,7 @@ function detectChangesInEmbeddedViews(lView, mode) {
  */
 function markTransplantedViewsForRefresh(lView) {
     for (let lContainer = getFirstLContainer(lView); lContainer !== null; lContainer = getNextLContainer(lContainer)) {
-        if (!(lContainer[FLAGS] & LContainerFlags.HasTransplantedViews))
+        if (!(lContainer[FLAGS] & 2 /* LContainerFlags.HasTransplantedViews */))
             continue;
         const movedViews = lContainer[MOVED_VIEWS];
         ngDevMode && assertDefined(movedViews, 'Transplanted View flags set but missing MOVED_VIEWS');
@@ -15172,17 +15105,12 @@ function detectChangesInView(lView, mode) {
         refreshView(tView, lView, tView.template, lView[CONTEXT]);
     }
     else if (flags & 8192 /* LViewFlags.HasChildViewsToRefresh */) {
-        if (!isInCheckNoChangesPass) {
-            runEffectsInView(lView);
-        }
+        runEffectsInView(lView);
         detectChangesInEmbeddedViews(lView, 1 /* ChangeDetectionMode.Targeted */);
         const components = tView.components;
         if (components !== null) {
             detectChangesInChildComponents(lView, components, 1 /* ChangeDetectionMode.Targeted */);
         }
-        if (!isInCheckNoChangesPass) {
-            addAfterRenderSequencesForView(lView);
-        }
     }
 }
 /** Refreshes child components in the current view (update mode). */
@@ -15191,6 +15119,43 @@ function detectChangesInChildComponents(hostLView, components, mode) {
         detectChangesInComponent(hostLView, components[i], mode);
     }
 }
+/**
+ * Invoke `HostBindingsFunction`s for view.
+ *
+ * This methods executes `TView.hostBindingOpCodes`. It is used to execute the
+ * `HostBindingsFunction`s associated with the current `LView`.
+ *
+ * @param tView Current `TView`.
+ * @param lView Current `LView`.
+ */
+function processHostBindingOpCodes(tView, lView) {
+    const hostBindingOpCodes = tView.hostBindingOpCodes;
+    if (hostBindingOpCodes === null)
+        return;
+    try {
+        for (let i = 0; i < hostBindingOpCodes.length; i++) {
+            const opCode = hostBindingOpCodes[i];
+            if (opCode < 0) {
+                // Negative numbers are element indexes.
+                setSelectedIndex(~opCode);
+            }
+            else {
+                // Positive numbers are NumberTuple which store bindingRootIndex and directiveIndex.
+                const directiveIdx = opCode;
+                const bindingRootIndx = hostBindingOpCodes[++i];
+                const hostBindingFn = hostBindingOpCodes[++i];
+                setBindingRootForHostBindings(bindingRootIndx, directiveIdx);
+                const context = lView[directiveIdx];
+                profiler(24 /* ProfilerEvent.HostBindingsUpdateStart */, context);
+                hostBindingFn(2 /* RenderFlags.Update */, context);
+                profiler(25 /* ProfilerEvent.HostBindingsUpdateEnd */, context);
+            }
+        }
+    }
+    finally {
+        setSelectedIndex(-1);
+    }
+}
 
 /**
  * Marks current view and all ancestors dirty.
@@ -16285,7 +16250,7 @@ function loadIcuContainerVisitor() {
      * to determine which root belong to the ICU.
      *
      * Example of usage.
-     * ```
+     * ```ts
      * const nextRNode = icuContainerIteratorStart(tIcuContainerNode, lView);
      * let rNode: RNode|null;
      * while(rNode = nextRNode()) {
@@ -16516,7 +16481,7 @@ function stringifyNavigationInstructions(instructions) {
         const step = instructions[i];
         const repeat = instructions[i + 1];
         for (let r = 0; r < repeat; r++) {
-            container.push(step === NodeNavigationStep.FirstChild ? 'firstChild' : 'nextSibling');
+            container.push(step === NODE_NAVIGATION_STEP_FIRST_CHILD ? 'firstChild' : 'nextSibling');
         }
     }
     return container.join('.');
@@ -16535,10 +16500,10 @@ function navigateToNode(from, instructions) {
                 throw nodeNotFoundAtPathError(from, stringifyNavigationInstructions(instructions));
             }
             switch (step) {
-                case NodeNavigationStep.FirstChild:
+                case NODE_NAVIGATION_STEP_FIRST_CHILD:
                     node = node.firstChild;
                     break;
-                case NodeNavigationStep.NextSibling:
+                case NODE_NAVIGATION_STEP_NEXT_SIBLING:
                     node = node.nextSibling;
                     break;
             }
@@ -16596,7 +16561,7 @@ function navigateBetween(start, finish) {
             // First navigate to `finish`'s parent
             ...parentPath,
             // Then to its first child.
-            NodeNavigationStep.FirstChild,
+            NODE_NAVIGATION_STEP_FIRST_CHILD,
             // And finally from that node to `finish` (maybe a no-op if we're already there).
             ...childPath,
         ];
@@ -16610,7 +16575,7 @@ function navigateBetweenSiblings(start, finish) {
     const nav = [];
     let node = null;
     for (node = start; node != null && node !== finish; node = node.nextSibling) {
-        nav.push(NodeNavigationStep.NextSibling);
+        nav.push(NODE_NAVIGATION_STEP_NEXT_SIBLING);
     }
     // If the `node` becomes `null` or `undefined` at the end, that means that we
     // didn't find the `end` node, thus return `null` (which would trigger serialization
@@ -18167,7 +18132,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', '19.1.0-rc.0']);
+        setUpAttributes(hostRenderer, hostRNode, ['ng-version', '19.1.1']);
     }
     else {
         // If host element is created as a part of this function call (i.e. `rootSelectorOrNode`
@@ -19079,59 +19044,6 @@ function getQueryResults(lView, queryIndex) {
         : materializeViewResults(tView, lView, tQuery, queryIndex);
 }
 
-/**
- * Checks if the given `value` is a reactive `Signal`.
- */
-function isSignal(value) {
-    return typeof value === 'function' && value[SIGNAL$1] !== undefined;
-}
-
-/** Symbol used distinguish `WritableSignal` from other non-writable signals and functions. */
-const ɵWRITABLE_SIGNAL = /* @__PURE__ */ Symbol('WRITABLE_SIGNAL');
-/**
- * Utility function used during template type checking to extract the value from a `WritableSignal`.
- * @codeGenApi
- */
-function ɵunwrapWritableSignal(value) {
-    // Note: the function uses `WRITABLE_SIGNAL` as a brand instead of `WritableSignal<T>`,
-    // because the latter incorrectly unwraps non-signal getter functions.
-    return null;
-}
-/**
- * Create a `Signal` that can be set or updated directly.
- */
-function signal(initialValue, options) {
-    performanceMarkFeature('NgSignals');
-    const signalFn = createSignal$1(initialValue);
-    const node = signalFn[SIGNAL$1];
-    if (options?.equal) {
-        node.equal = options.equal;
-    }
-    signalFn.set = (newValue) => signalSetFn$1(node, newValue);
-    signalFn.update = (updateFn) => signalUpdateFn$1(node, updateFn);
-    signalFn.asReadonly = signalAsReadonlyFn.bind(signalFn);
-    if (ngDevMode) {
-        signalFn.toString = () => `[Signal: ${signalFn()}]`;
-        node.debugName = options?.debugName;
-    }
-    return signalFn;
-}
-function signalAsReadonlyFn() {
-    const node = this[SIGNAL$1];
-    if (node.readonlyFn === undefined) {
-        const readonlyFn = () => this();
-        readonlyFn[SIGNAL$1] = node;
-        node.readonlyFn = readonlyFn;
-    }
-    return node.readonlyFn;
-}
-/**
- * Checks if the given `value` is a writeable signal.
- */
-function isWritableSignal(value) {
-    return isSignal(value) && typeof value.set === 'function';
-}
-
 /**
  * A signal factory function in charge of creating a new computed signal capturing query
  * results. This centralized creation function is used by all types of queries (child / children,
@@ -23102,77 +23014,6 @@ function isSubscribable(obj) {
     return !!obj && typeof obj.subscribe === 'function';
 }
 
-/**
- * A scheduler which manages the execution of effects.
- */
-class EffectScheduler {
-    /** @nocollapse */
-    static ɵprov = /** @pureOrBreakMyCode */ /* @__PURE__ */ ɵɵdefineInjectable({
-        token: EffectScheduler,
-        providedIn: 'root',
-        factory: () => new ZoneAwareEffectScheduler(),
-    });
-}
-/**
- * A wrapper around `ZoneAwareQueueingScheduler` that schedules flushing via the microtask queue
- * when.
- */
-class ZoneAwareEffectScheduler {
-    queuedEffectCount = 0;
-    queues = new Map();
-    schedule(handle) {
-        this.enqueue(handle);
-    }
-    remove(handle) {
-        const zone = handle.zone;
-        const queue = this.queues.get(zone);
-        if (!queue.has(handle)) {
-            return;
-        }
-        queue.delete(handle);
-        this.queuedEffectCount--;
-    }
-    enqueue(handle) {
-        const zone = handle.zone;
-        if (!this.queues.has(zone)) {
-            this.queues.set(zone, new Set());
-        }
-        const queue = this.queues.get(zone);
-        if (queue.has(handle)) {
-            return;
-        }
-        this.queuedEffectCount++;
-        queue.add(handle);
-    }
-    /**
-     * Run all scheduled effects.
-     *
-     * Execution order of effects within the same zone is guaranteed to be FIFO, but there is no
-     * ordering guarantee between effects scheduled in different zones.
-     */
-    flush() {
-        while (this.queuedEffectCount > 0) {
-            for (const [zone, queue] of this.queues) {
-                // `zone` here must be defined.
-                if (zone === null) {
-                    this.flushQueue(queue);
-                }
-                else {
-                    zone.run(() => this.flushQueue(queue));
-                }
-            }
-        }
-    }
-    flushQueue(queue) {
-        for (const handle of queue) {
-            queue.delete(handle);
-            this.queuedEffectCount--;
-            // TODO: what happens if this throws an error?
-            handle.run();
-        }
-    }
-}
-
 /**
  * A DI token that you can use to provide
  * one or more initialization functions.
@@ -23417,6 +23258,77 @@ class ApplicationInitStatus {
         args: [{ providedIn: 'root' }]
     }], () => [], null); })();
 
+/**
+ * A scheduler which manages the execution of effects.
+ */
+class EffectScheduler {
+    /** @nocollapse */
+    static ɵprov = /** @pureOrBreakMyCode */ /* @__PURE__ */ ɵɵdefineInjectable({
+        token: EffectScheduler,
+        providedIn: 'root',
+        factory: () => new ZoneAwareEffectScheduler(),
+    });
+}
+/**
+ * A wrapper around `ZoneAwareQueueingScheduler` that schedules flushing via the microtask queue
+ * when.
+ */
+class ZoneAwareEffectScheduler {
+    queuedEffectCount = 0;
+    queues = new Map();
+    schedule(handle) {
+        this.enqueue(handle);
+    }
+    remove(handle) {
+        const zone = handle.zone;
+        const queue = this.queues.get(zone);
+        if (!queue.has(handle)) {
+            return;
+        }
+        queue.delete(handle);
+        this.queuedEffectCount--;
+    }
+    enqueue(handle) {
+        const zone = handle.zone;
+        if (!this.queues.has(zone)) {
+            this.queues.set(zone, new Set());
+        }
+        const queue = this.queues.get(zone);
+        if (queue.has(handle)) {
+            return;
+        }
+        this.queuedEffectCount++;
+        queue.add(handle);
+    }
+    /**
+     * Run all scheduled effects.
+     *
+     * Execution order of effects within the same zone is guaranteed to be FIFO, but there is no
+     * ordering guarantee between effects scheduled in different zones.
+     */
+    flush() {
+        while (this.queuedEffectCount > 0) {
+            for (const [zone, queue] of this.queues) {
+                // `zone` here must be defined.
+                if (zone === null) {
+                    this.flushQueue(queue);
+                }
+                else {
+                    zone.run(() => this.flushQueue(queue));
+                }
+            }
+        }
+    }
+    flushQueue(queue) {
+        for (const handle of queue) {
+            queue.delete(handle);
+            this.queuedEffectCount--;
+            // TODO: what happens if this throws an error?
+            handle.run();
+        }
+    }
+}
+
 /**
  * A DI token that provides a set of callbacks to
  * be called for every component that is bootstrapped.
@@ -23594,6 +23506,12 @@ class ApplicationRef {
      * @internal
      */
     dirtyFlags = 0 /* ApplicationRefDirtyFlags.None */;
+    /**
+     * Like `dirtyFlags` but don't cause `tick()` to loop.
+     *
+     * @internal
+     */
+    deferredDirtyFlags = 0 /* ApplicationRefDirtyFlags.None */;
     /**
      * Most recent snapshot from the `TracingService`, if any.
      *
@@ -23800,6 +23718,9 @@ class ApplicationRef {
         if (this._rendererFactory === null && !this._injector.destroyed) {
             this._rendererFactory = this._injector.get(RendererFactory2, null, { optional: true });
         }
+        // When beginning synchronization, all deferred dirtiness becomes active dirtiness.
+        this.dirtyFlags |= this.deferredDirtyFlags;
+        this.deferredDirtyFlags = 0 /* ApplicationRefDirtyFlags.None */;
         let runs = 0;
         while (this.dirtyFlags !== 0 /* ApplicationRefDirtyFlags.None */ && runs++ < MAXIMUM_REFRESH_RERUNS) {
             this.synchronizeOnce();
@@ -23815,6 +23736,9 @@ class ApplicationRef {
      * Perform a single synchronization pass.
      */
     synchronizeOnce() {
+        // If we happened to loop, deferred dirtiness can be processed as active dirtiness again.
+        this.dirtyFlags |= this.deferredDirtyFlags;
+        this.deferredDirtyFlags = 0 /* ApplicationRefDirtyFlags.None */;
         // First, process any dirty root effects.
         if (this.dirtyFlags & 16 /* ApplicationRefDirtyFlags.RootEffects */) {
             this.dirtyFlags &= ~16 /* ApplicationRefDirtyFlags.RootEffects */;
@@ -32340,6 +32264,17 @@ function ɵɵtextInterpolateV(values) {
     }
     return ɵɵtextInterpolateV;
 }
+/**
+ * Updates a text binding at a given index in a given LView.
+ */
+function textBindingInternal(lView, index, value) {
+    ngDevMode && assertString(value, 'Value should be a string');
+    ngDevMode && assertNotSame(value, NO_CHANGE, 'value should not be NO_CHANGE');
+    ngDevMode && assertIndexInRange(lView, index);
+    const element = getNativeByIndex(index, lView);
+    ngDevMode && assertDefined(element, 'native element should exist');
+    updateTextNode(lView[RENDERER], element, value);
+}
 
 /*!
  * @license
@@ -33524,29 +33459,29 @@ function ɵɵreplaceMetadata(type, applyMetadata, namespaces, locals) {
 }
 /**
  * Finds all LViews matching a specific component definition and recreates them.
- * @param def Component definition to search for.
+ * @param oldDef Component definition to search for.
  * @param rootLView View from which to start the search.
  */
-function recreateMatchingLViews(def, rootLView) {
+function recreateMatchingLViews(oldDef, rootLView) {
     ngDevMode &&
-        assertDefined(def.tView, 'Expected a component definition that has been instantiated at least once');
+        assertDefined(oldDef.tView, 'Expected a component definition that has been instantiated at least once');
     const tView = rootLView[TVIEW];
     // Use `tView` to match the LView since `instanceof` can
     // produce false positives when using inheritance.
-    if (tView === def.tView) {
-        ngDevMode && assertComponentDef(def.type);
-        recreateLView(getComponentDef(def.type), rootLView);
+    if (tView === oldDef.tView) {
+        ngDevMode && assertComponentDef(oldDef.type);
+        recreateLView(getComponentDef(oldDef.type), oldDef, rootLView);
         return;
     }
     for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {
         const current = rootLView[i];
         if (isLContainer(current)) {
             for (let i = CONTAINER_HEADER_OFFSET; i < current.length; i++) {
-                recreateMatchingLViews(def, current[i]);
+                recreateMatchingLViews(oldDef, current[i]);
             }
         }
         else if (isLView(current)) {
-            recreateMatchingLViews(def, current);
+            recreateMatchingLViews(oldDef, current);
         }
     }
 }
@@ -33565,10 +33500,11 @@ function clearRendererCache(factory, def) {
 }
 /**
  * Recreates an LView in-place from a new component definition.
- * @param def Definition from which to recreate the view.
+ * @param newDef Definition from which to recreate the view.
+ * @param oldDef Previous component definition being swapped out.
  * @param lView View to be recreated.
  */
-function recreateLView(def, lView) {
+function recreateLView(newDef, oldDef, lView) {
     const instance = lView[CONTEXT];
     const host = lView[HOST];
     // In theory the parent can also be an LContainer, but it appears like that's
@@ -33577,30 +33513,41 @@ function recreateLView(def, lView) {
     ngDevMode && assertLView(parentLView);
     const tNode = lView[T_HOST];
     ngDevMode && assertTNodeType(tNode, 2 /* TNodeType.Element */);
-    // Recreate the TView since the template might've changed.
-    const newTView = getOrCreateComponentTView(def);
-    // Always force the creation of a new renderer to ensure state captured during construction
-    // stays consistent with the new component definition by clearing any old cached factories.
-    const rendererFactory = lView[ENVIRONMENT].rendererFactory;
-    clearRendererCache(rendererFactory, def);
-    // Create a new LView from the new TView, but reusing the existing TNode and DOM node.
-    const newLView = createLView(parentLView, newTView, instance, getInitialLViewFlagsFromDef(def), host, tNode, null, rendererFactory.createRenderer(host, def), null, null, null);
-    // Detach the LView from its current place in the tree so we don't
-    // start traversing any siblings and modifying their structure.
-    replaceLViewInTree(parentLView, lView, newLView, tNode.index);
-    // Destroy the detached LView.
-    destroyLView(lView[TVIEW], lView);
-    // Remove the nodes associated with the destroyed LView. This removes the
-    // descendants, but not the host which we want to stay in place.
-    removeViewFromDOM(lView[TVIEW], lView);
-    // Reset the content projection state of the TNode before the first render.
-    // Note that this has to happen after the LView has been destroyed or we
-    // risk some projected nodes not being removed correctly.
-    resetProjectionState(tNode);
-    // Creation pass for the new view.
-    renderView(newTView, newLView, instance);
-    // Update pass for the new view.
-    refreshView(newTView, newLView, newTView.template, instance);
+    ngDevMode && assertNotEqual(newDef, oldDef, 'Expected different component definition');
+    const zone = lView[INJECTOR].get(NgZone, null);
+    const recreate = () => {
+        // Recreate the TView since the template might've changed.
+        const newTView = getOrCreateComponentTView(newDef);
+        // Always force the creation of a new renderer to ensure state captured during construction
+        // stays consistent with the new component definition by clearing any old cached factories.
+        const rendererFactory = lView[ENVIRONMENT].rendererFactory;
+        clearRendererCache(rendererFactory, oldDef);
+        // Create a new LView from the new TView, but reusing the existing TNode and DOM node.
+        const newLView = createLView(parentLView, newTView, instance, getInitialLViewFlagsFromDef(newDef), host, tNode, null, rendererFactory.createRenderer(host, newDef), null, null, null);
+        // Detach the LView from its current place in the tree so we don't
+        // start traversing any siblings and modifying their structure.
+        replaceLViewInTree(parentLView, lView, newLView, tNode.index);
+        // Destroy the detached LView.
+        destroyLView(lView[TVIEW], lView);
+        // Remove the nodes associated with the destroyed LView. This removes the
+        // descendants, but not the host which we want to stay in place.
+        removeViewFromDOM(lView[TVIEW], lView);
+        // Reset the content projection state of the TNode before the first render.
+        // Note that this has to happen after the LView has been destroyed or we
+        // risk some projected nodes not being removed correctly.
+        resetProjectionState(tNode);
+        // Creation pass for the new view.
+        renderView(newTView, newLView, instance);
+        // Update pass for the new view.
+        refreshView(newTView, newLView, newTView.template, instance);
+    };
+    // The callback isn't guaranteed to be inside the Zone so we need to bring it in ourselves.
+    if (zone === null) {
+        recreate();
+    }
+    else {
+        zone.run(recreate);
+    }
 }
 /**
  * Replaces one LView in the tree with another one.
@@ -35027,7 +34974,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('19.1.0-rc.0');
+const VERSION = new Version('19.1.1');
 
 /**
  * Combination of NgModuleFactory and ComponentFactories.
@@ -35437,6 +35384,13 @@ class ChangeDetectionSchedulerImpl {
                 this.appRef.dirtyFlags |= 4 /* ApplicationRefDirtyFlags.ViewTreeCheck */;
                 break;
             }
+            case 8 /* NotificationSource.DeferredRenderHook */: {
+                // Render hooks are "deferred" when they're triggered from other render hooks. Using the
+                // deferred dirty flags ensures that adding new hooks doesn't automatically trigger a loop
+                // inside tick().
+                this.appRef.deferredDirtyFlags |= 8 /* ApplicationRefDirtyFlags.AfterRender */;
+                break;
+            }
             case 6 /* NotificationSource.CustomElement */: {
                 // We use `ViewTreeTraversal` to ensure we refresh the element even if this is triggered
                 // during CD. In practice this is a no-op since the elements code also calls via a
@@ -35445,7 +35399,7 @@ class ChangeDetectionSchedulerImpl {
                 force = true;
                 break;
             }
-            case 12 /* NotificationSource.RootEffect */: {
+            case 13 /* NotificationSource.RootEffect */: {
                 this.appRef.dirtyFlags |= 16 /* ApplicationRefDirtyFlags.RootEffects */;
                 // Root effects still force a CD, even if the scheduler is disabled. This ensures that
                 // effects always run, even when triggered from outside the zone when the scheduler is
@@ -35453,7 +35407,7 @@ class ChangeDetectionSchedulerImpl {
                 force = true;
                 break;
             }
-            case 13 /* NotificationSource.ViewEffect */: {
+            case 14 /* NotificationSource.ViewEffect */: {
                 // This is technically a no-op, since view effects will also send a
                 // `MarkAncestorsForTraversal` notification. Still, we set this for logical consistency.
                 this.appRef.dirtyFlags |= 2 /* ApplicationRefDirtyFlags.ViewTreeTraversal */;
@@ -35463,7 +35417,7 @@ class ChangeDetectionSchedulerImpl {
                 force = true;
                 break;
             }
-            case 11 /* NotificationSource.PendingTaskRemoved */: {
+            case 12 /* NotificationSource.PendingTaskRemoved */: {
                 // Removing a pending task via the public API forces a scheduled tick, ensuring that
                 // stability is async and delayed until there was at least an opportunity to run
                 // application synchronization. This prevents some footguns when working with the
@@ -35472,10 +35426,10 @@ class ChangeDetectionSchedulerImpl {
                 force = true;
                 break;
             }
-            case 9 /* NotificationSource.ViewDetachedFromDOM */:
-            case 8 /* NotificationSource.ViewAttached */:
+            case 10 /* NotificationSource.ViewDetachedFromDOM */:
+            case 9 /* NotificationSource.ViewAttached */:
             case 7 /* NotificationSource.RenderHook */:
-            case 10 /* NotificationSource.AsyncAnimationsLoaded */:
+            case 11 /* NotificationSource.AsyncAnimationsLoaded */:
             default: {
                 // These notifications only schedule a tick but do not change whether we should refresh
                 // views. Instead, we only need to run render hooks unless another notification from the
@@ -38293,7 +38247,7 @@ class IterableDiffers {
      * which will only be applied to the injector for this component and its children.
      * This step is all that's required to make a new {@link IterableDiffer} available.
      *
-     * ```
+     * ```ts
      * @Component({
      *   viewProviders: [
      *     IterableDiffers.extend([new ImmutableListDiffer()])
@@ -38367,7 +38321,7 @@ class KeyValueDiffers {
      * which will only be applied to the injector for this component and its children.
      * This step is all that's required to make a new {@link KeyValueDiffer} available.
      *
-     * ```
+     * ```ts
      * @Component({
      *   viewProviders: [
      *     KeyValueDiffers.extend([new ImmutableMapDiffer()])
@@ -39489,7 +39443,6 @@ function serializeLContainer(lContainer, tNode, lView, parentDeferBlockId, conte
                     collectNativeNodesInLContainer(lContainer, rootNodes);
                     // Add defer block into info context.deferBlocks
                     const deferBlockInfo = {
-                        [DEFER_PARENT_BLOCK_ID]: parentDeferBlockId,
                         [NUM_ROOT_NODES]: rootNodes.length,
                         [DEFER_BLOCK_STATE$1]: lDetails[DEFER_BLOCK_STATE],
                     };
@@ -39497,6 +39450,10 @@ function serializeLContainer(lContainer, tNode, lView, parentDeferBlockId, conte
                     if (serializedTriggers.length > 0) {
                         deferBlockInfo[DEFER_HYDRATE_TRIGGERS] = serializedTriggers;
                     }
+                    if (parentDeferBlockId !== null) {
+                        // Serialize parent id only when it's present.
+                        deferBlockInfo[DEFER_PARENT_BLOCK_ID] = parentDeferBlockId;
+                    }
                     context.deferBlocks.set(deferBlockId, deferBlockInfo);
                     const node = unwrapRNode(lContainer);
                     if (node !== undefined) {
@@ -40641,6 +40598,23 @@ function untracked(nonReactiveReadsFn) {
     }
 }
 
+class ViewContext {
+    view;
+    node;
+    constructor(view, node) {
+        this.view = view;
+        this.node = node;
+    }
+    /**
+     * @internal
+     * @nocollapse
+     */
+    static __NG_ELEMENT_ID__ = injectViewContext;
+}
+function injectViewContext() {
+    return new ViewContext(getLView(), getCurrentTNode());
+}
+
 /**
  * Controls whether effects use the legacy `microtaskEffect` by default.
  */
@@ -40908,7 +40882,7 @@ const ROOT_EFFECT_NODE =
     ...BASE_EFFECT_NODE,
     consumerMarkedDirty() {
         this.scheduler.schedule(this);
-        this.notifier.notify(12 /* NotificationSource.RootEffect */);
+        this.notifier.notify(13 /* NotificationSource.RootEffect */);
     },
     destroy() {
         consumerDestroy$1(this);
@@ -40923,7 +40897,7 @@ const VIEW_EFFECT_NODE =
     consumerMarkedDirty() {
         this.view[FLAGS] |= 8192 /* LViewFlags.HasChildViewsToRefresh */;
         markAncestorsForTraversal(this.view);
-        this.notifier.notify(13 /* NotificationSource.ViewEffect */);
+        this.notifier.notify(14 /* NotificationSource.ViewEffect */);
     },
     destroy() {
         consumerDestroy$1(this);
@@ -40950,7 +40924,7 @@ function createRootEffect(fn, scheduler, notifier) {
     node.notifier = notifier;
     node.zone = typeof Zone !== 'undefined' ? Zone.current : null;
     node.scheduler.schedule(node);
-    node.notifier.notify(12 /* NotificationSource.RootEffect */);
+    node.notifier.notify(13 /* NotificationSource.RootEffect */);
     return node;
 }
 
@@ -41041,10 +41015,10 @@ class AfterRenderEffectSequence extends AfterRenderSequence {
      * These are initialized to `undefined` but set in the constructor.
      */
     nodes = [undefined, undefined, undefined, undefined];
-    constructor(impl, effectHooks, view, scheduler, destroyRef, snapshot = null) {
+    constructor(impl, effectHooks, scheduler, destroyRef, snapshot = null) {
         // Note that we also initialize the underlying `AfterRenderSequence` hooks to `undefined` and
         // populate them as we create reactive nodes below.
-        super(impl, [undefined, undefined, undefined, undefined], view, false, destroyRef, snapshot);
+        super(impl, [undefined, undefined, undefined, undefined], false, destroyRef, snapshot);
         this.scheduler = scheduler;
         // Setup a reactive node for each phase.
         for (const phase of AFTER_RENDER_PHASES) {
@@ -41103,8 +41077,7 @@ function afterRenderEffect(callbackOrSpec, options) {
     if (typeof spec === 'function') {
         spec = { mixedReadWrite: callbackOrSpec };
     }
-    const viewContext = injector.get(ViewContext, null, { optional: true });
-    const sequence = new AfterRenderEffectSequence(manager.impl, [spec.earlyRead, spec.write, spec.mixedReadWrite, spec.read], viewContext?.view, scheduler, injector.get(DestroyRef), tracing?.snapshot(null));
+    const sequence = new AfterRenderEffectSequence(manager.impl, [spec.earlyRead, spec.write, spec.mixedReadWrite, spec.read], scheduler, injector.get(DestroyRef), tracing?.snapshot(null));
     manager.impl.register(sequence);
     return sequence;
 }
@@ -41520,7 +41493,7 @@ function mergeApplicationConfig(...configs) {
  *
  * @developerPreview
  */
-const REQUEST = new InjectionToken('REQUEST', {
+const REQUEST = new InjectionToken(typeof ngDevMode === 'undefined' || ngDevMode ? 'REQUEST' : '', {
     providedIn: 'platform',
     factory: () => null,
 });
@@ -41542,7 +41515,7 @@ const REQUEST = new InjectionToken('REQUEST', {
  *
  * @developerPreview
  */
-const RESPONSE_INIT = new InjectionToken('RESPONSE_INIT', {
+const RESPONSE_INIT = new InjectionToken(typeof ngDevMode === 'undefined' || ngDevMode ? 'RESPONSE_INIT' : '', {
     providedIn: 'platform',
     factory: () => null,
 });
@@ -41556,7 +41529,7 @@ const RESPONSE_INIT = new InjectionToken('RESPONSE_INIT', {
  *
  * @developerPreview
  */
-const REQUEST_CONTEXT = new InjectionToken('REQUEST_CONTEXT', {
+const REQUEST_CONTEXT = new InjectionToken(typeof ngDevMode === 'undefined' || ngDevMode ? 'REQUEST_CONTEXT' : '', {
     providedIn: 'platform',
     factory: () => null,
 });