@angular/core 19.0.0-next.5 → 19.0.0-next.7

package/schematics/bundles/{compiler_host-ca7ba733.js → checker-637eee78.js}

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v19.0.0-next.5
+ * @license Angular v19.0.0-next.7
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -8,9 +8,9 @@
 
 var ts = require('typescript');
 require('os');
+var p = require('path');
 var fs$1 = require('fs');
 var module$1 = require('module');
-var p = require('path');
 var url = require('url');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -34,8 +34,8 @@ function _interopNamespace(e) {
 }
 
 var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs$1);
 var p__namespace = /*#__PURE__*/_interopNamespace(p);
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs$1);
 
 const _SELECTOR_REGEXP = new RegExp('(\\:not\\()|' + // 1: ":not("
     '(([\\.\\#]?)[-\\w]+)|' + // 2: "tag"; 3: "."/"#";
@@ -2403,6 +2403,32 @@ class Identifiers {
         name: 'ɵɵdeferPrefetchOnViewport',
         moduleName: CORE,
     }; }
+    static { this.deferHydrateWhen = { name: 'ɵɵdeferHydrateWhen', moduleName: CORE }; }
+    static { this.deferHydrateNever = { name: 'ɵɵdeferHydrateNever', moduleName: CORE }; }
+    static { this.deferHydrateOnIdle = {
+        name: 'ɵɵdeferHydrateOnIdle',
+        moduleName: CORE,
+    }; }
+    static { this.deferHydrateOnImmediate = {
+        name: 'ɵɵdeferHydrateOnImmediate',
+        moduleName: CORE,
+    }; }
+    static { this.deferHydrateOnTimer = {
+        name: 'ɵɵdeferHydrateOnTimer',
+        moduleName: CORE,
+    }; }
+    static { this.deferHydrateOnHover = {
+        name: 'ɵɵdeferHydrateOnHover',
+        moduleName: CORE,
+    }; }
+    static { this.deferHydrateOnInteraction = {
+        name: 'ɵɵdeferHydrateOnInteraction',
+        moduleName: CORE,
+    }; }
+    static { this.deferHydrateOnViewport = {
+        name: 'ɵɵdeferHydrateOnViewport',
+        moduleName: CORE,
+    }; }
     static { this.deferEnableTimerScheduling = {
         name: 'ɵɵdeferEnableTimerScheduling',
         moduleName: CORE,
@@ -4323,49 +4349,52 @@ class Element$1 {
     }
 }
 class DeferredTrigger {
-    constructor(nameSpan, sourceSpan, prefetchSpan, whenOrOnSourceSpan) {
+    constructor(nameSpan, sourceSpan, prefetchSpan, whenOrOnSourceSpan, hydrateSpan) {
         this.nameSpan = nameSpan;
         this.sourceSpan = sourceSpan;
         this.prefetchSpan = prefetchSpan;
         this.whenOrOnSourceSpan = whenOrOnSourceSpan;
+        this.hydrateSpan = hydrateSpan;
     }
     visit(visitor) {
         return visitor.visitDeferredTrigger(this);
     }
 }
 class BoundDeferredTrigger extends DeferredTrigger {
-    constructor(value, sourceSpan, prefetchSpan, whenSourceSpan) {
+    constructor(value, sourceSpan, prefetchSpan, whenSourceSpan, hydrateSpan) {
         // BoundDeferredTrigger is for 'when' triggers. These aren't really "triggers" and don't have a
         // nameSpan. Trigger names are the built in event triggers like hover, interaction, etc.
-        super(/** nameSpan */ null, sourceSpan, prefetchSpan, whenSourceSpan);
+        super(/** nameSpan */ null, sourceSpan, prefetchSpan, whenSourceSpan, hydrateSpan);
         this.value = value;
     }
 }
+class NeverDeferredTrigger extends DeferredTrigger {
+}
 class IdleDeferredTrigger extends DeferredTrigger {
 }
 class ImmediateDeferredTrigger extends DeferredTrigger {
 }
 class HoverDeferredTrigger extends DeferredTrigger {
-    constructor(reference, nameSpan, sourceSpan, prefetchSpan, onSourceSpan) {
-        super(nameSpan, sourceSpan, prefetchSpan, onSourceSpan);
+    constructor(reference, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan) {
+        super(nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
         this.reference = reference;
     }
 }
 class TimerDeferredTrigger extends DeferredTrigger {
-    constructor(delay, nameSpan, sourceSpan, prefetchSpan, onSourceSpan) {
-        super(nameSpan, sourceSpan, prefetchSpan, onSourceSpan);
+    constructor(delay, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan) {
+        super(nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
         this.delay = delay;
     }
 }
 class InteractionDeferredTrigger extends DeferredTrigger {
-    constructor(reference, nameSpan, sourceSpan, prefetchSpan, onSourceSpan) {
-        super(nameSpan, sourceSpan, prefetchSpan, onSourceSpan);
+    constructor(reference, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan) {
+        super(nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
         this.reference = reference;
     }
 }
 class ViewportDeferredTrigger extends DeferredTrigger {
-    constructor(reference, nameSpan, sourceSpan, prefetchSpan, onSourceSpan) {
-        super(nameSpan, sourceSpan, prefetchSpan, onSourceSpan);
+    constructor(reference, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan) {
+        super(nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
         this.reference = reference;
     }
 }
@@ -4411,7 +4440,7 @@ class DeferredBlockError extends BlockNode {
     }
 }
 class DeferredBlock extends BlockNode {
-    constructor(children, triggers, prefetchTriggers, placeholder, loading, error, nameSpan, sourceSpan, mainBlockSpan, startSourceSpan, endSourceSpan, i18n) {
+    constructor(children, triggers, prefetchTriggers, hydrateTriggers, placeholder, loading, error, nameSpan, sourceSpan, mainBlockSpan, startSourceSpan, endSourceSpan, i18n) {
         super(nameSpan, sourceSpan, startSourceSpan, endSourceSpan);
         this.children = children;
         this.placeholder = placeholder;
@@ -4421,15 +4450,19 @@ class DeferredBlock extends BlockNode {
         this.i18n = i18n;
         this.triggers = triggers;
         this.prefetchTriggers = prefetchTriggers;
+        this.hydrateTriggers = hydrateTriggers;
         // We cache the keys since we know that they won't change and we
         // don't want to enumarate them every time we're traversing the AST.
         this.definedTriggers = Object.keys(triggers);
         this.definedPrefetchTriggers = Object.keys(prefetchTriggers);
+        this.definedHydrateTriggers = Object.keys(hydrateTriggers);
     }
     visit(visitor) {
         return visitor.visitDeferredBlock(this);
     }
     visitAll(visitor) {
+        // Visit the hydrate triggers first to match their insertion order.
+        this.visitTriggers(this.definedHydrateTriggers, this.hydrateTriggers, visitor);
         this.visitTriggers(this.definedTriggers, this.triggers, visitor);
         this.visitTriggers(this.definedPrefetchTriggers, this.prefetchTriggers, visitor);
         visitAll$1(visitor, this.children);
@@ -8037,6 +8070,7 @@ var DeferTriggerKind;
     DeferTriggerKind[DeferTriggerKind["Hover"] = 3] = "Hover";
     DeferTriggerKind[DeferTriggerKind["Interaction"] = 4] = "Interaction";
     DeferTriggerKind[DeferTriggerKind["Viewport"] = 5] = "Viewport";
+    DeferTriggerKind[DeferTriggerKind["Never"] = 6] = "Never";
 })(DeferTriggerKind || (DeferTriggerKind = {}));
 /**
  * Kinds of i18n contexts. They can be created because of root i18n blocks, or ICUs.
@@ -8351,12 +8385,12 @@ function createRepeaterOp(repeaterCreate, targetSlot, collection, sourceSpan) {
         ...TRAIT_DEPENDS_ON_SLOT_CONTEXT,
     };
 }
-function createDeferWhenOp(target, expr, prefetch, sourceSpan) {
+function createDeferWhenOp(target, expr, modifier, sourceSpan) {
     return {
         kind: OpKind.DeferWhen,
         target,
         expr,
-        prefetch,
+        modifier,
         sourceSpan,
         ...NEW_OP,
         ...TRAIT_DEPENDS_ON_SLOT_CONTEXT,
@@ -9911,12 +9945,12 @@ function createDeferOp(xref, main, mainSlot, ownResolverFn, resolverFn, sourceSp
         numSlotsUsed: 2,
     };
 }
-function createDeferOnOp(defer, trigger, prefetch, sourceSpan) {
+function createDeferOnOp(defer, trigger, modifier, sourceSpan) {
     return {
         kind: OpKind.DeferOn,
         defer,
         trigger,
-        prefetch,
+        modifier,
         sourceSpan,
         ...NEW_OP,
     };
@@ -11276,6 +11310,7 @@ function resolveDeferTargetNames(job) {
     function resolveTrigger(deferOwnerView, op, placeholderView) {
         switch (op.trigger.kind) {
             case DeferTriggerKind.Idle:
+            case DeferTriggerKind.Never:
             case DeferTriggerKind.Immediate:
             case DeferTriggerKind.Timer:
                 return;
@@ -11335,7 +11370,9 @@ function resolveDeferTargetNames(job) {
                     break;
                 case OpKind.DeferOn:
                     const deferOp = defers.get(op.defer);
-                    resolveTrigger(unit, op, deferOp.placeholderView);
+                    resolveTrigger(unit, op, op.modifier === "hydrate" /* ir.DeferOpModifierKind.HYDRATE */
+                        ? deferOp.mainView
+                        : deferOp.placeholderView);
                     break;
             }
         }
@@ -11756,7 +11793,10 @@ function formatValue(value) {
     // Self-closing tags use a special form that concatenates the start and close tag values.
     if (value.flags & I18nParamValueFlags.OpenTag &&
         value.flags & I18nParamValueFlags.CloseTag) {
-        return `${formatValue({ ...value, flags: value.flags & ~I18nParamValueFlags.CloseTag })}${formatValue({ ...value, flags: value.flags & ~I18nParamValueFlags.OpenTag })}`;
+        return `${formatValue({
+            ...value,
+            flags: value.flags & ~I18nParamValueFlags.CloseTag,
+        })}${formatValue({ ...value, flags: value.flags & ~I18nParamValueFlags.OpenTag })}`;
     }
     // If there are no special flags, just return the raw value.
     if (value.flags === I18nParamValueFlags.None) {
@@ -12148,13 +12188,17 @@ class IcuSerializerVisitor {
     visitTagPlaceholder(ph) {
         return ph.isVoid
             ? this.formatPh(ph.startName)
-            : `${this.formatPh(ph.startName)}${ph.children.map((child) => child.visit(this)).join('')}${this.formatPh(ph.closeName)}`;
+            : `${this.formatPh(ph.startName)}${ph.children
+                .map((child) => child.visit(this))
+                .join('')}${this.formatPh(ph.closeName)}`;
     }
     visitPlaceholder(ph) {
         return this.formatPh(ph.name);
     }
     visitBlockPlaceholder(ph) {
-        return `${this.formatPh(ph.startName)}${ph.children.map((child) => child.visit(this)).join('')}${this.formatPh(ph.closeName)}`;
+        return `${this.formatPh(ph.startName)}${ph.children
+            .map((child) => child.visit(this))
+            .join('')}${this.formatPh(ph.closeName)}`;
     }
     visitIcuPlaceholder(ph, context) {
         return this.formatPh(ph.name);
@@ -19486,13 +19530,17 @@ class GetMsgSerializerVisitor {
     visitTagPlaceholder(ph) {
         return ph.isVoid
             ? this.formatPh(ph.startName)
-            : `${this.formatPh(ph.startName)}${ph.children.map((child) => child.visit(this)).join('')}${this.formatPh(ph.closeName)}`;
+            : `${this.formatPh(ph.startName)}${ph.children
+                .map((child) => child.visit(this))
+                .join('')}${this.formatPh(ph.closeName)}`;
     }
     visitPlaceholder(ph) {
         return this.formatPh(ph.name);
     }
     visitBlockPlaceholder(ph) {
-        return `${this.formatPh(ph.startName)}${ph.children.map((child) => child.visit(this)).join('')}${this.formatPh(ph.closeName)}`;
+        return `${this.formatPh(ph.startName)}${ph.children
+            .map((child) => child.visit(this))
+            .join('')}${this.formatPh(ph.closeName)}`;
     }
     visitIcuPlaceholder(ph, context) {
         return this.formatPh(ph.name);
@@ -21047,28 +21095,68 @@ function defer(selfSlot, primarySlot, dependencyResolverFn, loadingSlot, placeho
     return call(Identifiers.defer, args, sourceSpan);
 }
 const deferTriggerToR3TriggerInstructionsMap = new Map([
-    [DeferTriggerKind.Idle, [Identifiers.deferOnIdle, Identifiers.deferPrefetchOnIdle]],
+    [
+        DeferTriggerKind.Idle,
+        {
+            ["none" /* ir.DeferOpModifierKind.NONE */]: Identifiers.deferOnIdle,
+            ["prefetch" /* ir.DeferOpModifierKind.PREFETCH */]: Identifiers.deferPrefetchOnIdle,
+            ["hydrate" /* ir.DeferOpModifierKind.HYDRATE */]: Identifiers.deferHydrateOnIdle,
+        },
+    ],
     [
         DeferTriggerKind.Immediate,
-        [Identifiers.deferOnImmediate, Identifiers.deferPrefetchOnImmediate],
+        {
+            ["none" /* ir.DeferOpModifierKind.NONE */]: Identifiers.deferOnImmediate,
+            ["prefetch" /* ir.DeferOpModifierKind.PREFETCH */]: Identifiers.deferPrefetchOnImmediate,
+            ["hydrate" /* ir.DeferOpModifierKind.HYDRATE */]: Identifiers.deferHydrateOnImmediate,
+        },
+    ],
+    [
+        DeferTriggerKind.Timer,
+        {
+            ["none" /* ir.DeferOpModifierKind.NONE */]: Identifiers.deferOnTimer,
+            ["prefetch" /* ir.DeferOpModifierKind.PREFETCH */]: Identifiers.deferPrefetchOnTimer,
+            ["hydrate" /* ir.DeferOpModifierKind.HYDRATE */]: Identifiers.deferHydrateOnTimer,
+        },
+    ],
+    [
+        DeferTriggerKind.Hover,
+        {
+            ["none" /* ir.DeferOpModifierKind.NONE */]: Identifiers.deferOnHover,
+            ["prefetch" /* ir.DeferOpModifierKind.PREFETCH */]: Identifiers.deferPrefetchOnHover,
+            ["hydrate" /* ir.DeferOpModifierKind.HYDRATE */]: Identifiers.deferHydrateOnHover,
+        },
     ],
-    [DeferTriggerKind.Timer, [Identifiers.deferOnTimer, Identifiers.deferPrefetchOnTimer]],
-    [DeferTriggerKind.Hover, [Identifiers.deferOnHover, Identifiers.deferPrefetchOnHover]],
     [
         DeferTriggerKind.Interaction,
-        [Identifiers.deferOnInteraction, Identifiers.deferPrefetchOnInteraction],
+        {
+            ["none" /* ir.DeferOpModifierKind.NONE */]: Identifiers.deferOnInteraction,
+            ["prefetch" /* ir.DeferOpModifierKind.PREFETCH */]: Identifiers.deferPrefetchOnInteraction,
+            ["hydrate" /* ir.DeferOpModifierKind.HYDRATE */]: Identifiers.deferHydrateOnInteraction,
+        },
     ],
     [
         DeferTriggerKind.Viewport,
-        [Identifiers.deferOnViewport, Identifiers.deferPrefetchOnViewport],
+        {
+            ["none" /* ir.DeferOpModifierKind.NONE */]: Identifiers.deferOnViewport,
+            ["prefetch" /* ir.DeferOpModifierKind.PREFETCH */]: Identifiers.deferPrefetchOnViewport,
+            ["hydrate" /* ir.DeferOpModifierKind.HYDRATE */]: Identifiers.deferHydrateOnViewport,
+        },
+    ],
+    [
+        DeferTriggerKind.Never,
+        {
+            ["none" /* ir.DeferOpModifierKind.NONE */]: Identifiers.deferHydrateNever,
+            ["prefetch" /* ir.DeferOpModifierKind.PREFETCH */]: Identifiers.deferHydrateNever,
+            ["hydrate" /* ir.DeferOpModifierKind.HYDRATE */]: Identifiers.deferHydrateNever,
+        },
     ],
 ]);
-function deferOn(trigger, args, prefetch, sourceSpan) {
-    const instructions = deferTriggerToR3TriggerInstructionsMap.get(trigger);
-    if (instructions === undefined) {
+function deferOn(trigger, args, modifier, sourceSpan) {
+    const instructionToCall = deferTriggerToR3TriggerInstructionsMap.get(trigger)?.[modifier];
+    if (instructionToCall === undefined) {
         throw new Error(`Unable to determine instruction for trigger ${trigger}`);
     }
-    const instructionToCall = prefetch ? instructions[1] : instructions[0];
     return call(instructionToCall, args.map((a) => literal$1(a)), sourceSpan);
 }
 function projectionDef(def) {
@@ -21124,8 +21212,14 @@ function repeaterCreate(slot, viewFnName, decls, vars, tag, constIndex, trackByF
 function repeater(collection, sourceSpan) {
     return call(Identifiers.repeater, [collection], sourceSpan);
 }
-function deferWhen(prefetch, expr, sourceSpan) {
-    return call(prefetch ? Identifiers.deferPrefetchWhen : Identifiers.deferWhen, [expr], sourceSpan);
+function deferWhen(modifier, expr, sourceSpan) {
+    if (modifier === "prefetch" /* ir.DeferOpModifierKind.PREFETCH */) {
+        return call(Identifiers.deferPrefetchWhen, [expr], sourceSpan);
+    }
+    else if (modifier === "hydrate" /* ir.DeferOpModifierKind.HYDRATE */) {
+        return call(Identifiers.deferHydrateWhen, [expr], sourceSpan);
+    }
+    return call(Identifiers.deferWhen, [expr], sourceSpan);
 }
 function declareLet(slot, sourceSpan) {
     return call(Identifiers.declareLet, [literal$1(slot)], sourceSpan);
@@ -21589,6 +21683,7 @@ function reifyCreateOperations(unit, ops) {
             case OpKind.DeferOn:
                 let args = [];
                 switch (op.trigger.kind) {
+                    case DeferTriggerKind.Never:
                     case DeferTriggerKind.Idle:
                     case DeferTriggerKind.Immediate:
                         break;
@@ -21598,18 +21693,24 @@ function reifyCreateOperations(unit, ops) {
                     case DeferTriggerKind.Interaction:
                     case DeferTriggerKind.Hover:
                     case DeferTriggerKind.Viewport:
-                        if (op.trigger.targetSlot?.slot == null || op.trigger.targetSlotViewSteps === null) {
-                            throw new Error(`Slot or view steps not set in trigger reification for trigger kind ${op.trigger.kind}`);
+                        // `hydrate` triggers don't support targets.
+                        if (op.modifier === "hydrate" /* ir.DeferOpModifierKind.HYDRATE */) {
+                            args = [];
                         }
-                        args = [op.trigger.targetSlot.slot];
-                        if (op.trigger.targetSlotViewSteps !== 0) {
-                            args.push(op.trigger.targetSlotViewSteps);
+                        else {
+                            if (op.trigger.targetSlot?.slot == null || op.trigger.targetSlotViewSteps === null) {
+                                throw new Error(`Slot or view steps not set in trigger reification for trigger kind ${op.trigger.kind}`);
+                            }
+                            args = [op.trigger.targetSlot.slot];
+                            if (op.trigger.targetSlotViewSteps !== 0) {
+                                args.push(op.trigger.targetSlotViewSteps);
+                            }
                         }
                         break;
                     default:
                         throw new Error(`AssertionError: Unsupported reification of defer trigger kind ${op.trigger.kind}`);
                 }
-                OpList.replace(op, deferOn(op.trigger.kind, args, op.prefetch, op.sourceSpan));
+                OpList.replace(op, deferOn(op.trigger.kind, args, op.modifier, op.sourceSpan));
                 break;
             case OpKind.ProjectionDef:
                 OpList.replace(op, projectionDef(op.def));
@@ -21767,7 +21868,7 @@ function reifyUpdateOperations(_unit, ops) {
                 OpList.replace(op, repeater(op.collection, op.sourceSpan));
                 break;
             case OpKind.DeferWhen:
-                OpList.replace(op, deferWhen(op.prefetch, op.expr, op.sourceSpan));
+                OpList.replace(op, deferWhen(op.modifier, op.expr, op.sourceSpan));
                 break;
             case OpKind.StoreLet:
                 throw new Error(`AssertionError: unexpected storeLet ${op.declaredName}`);
@@ -23550,7 +23651,7 @@ function wrapI18nIcus(job) {
  * Copyright Google LLC All Rights Reserved.
  *
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 /**
  * Removes any `storeLet` calls that aren't referenced outside of the current view.
@@ -23633,7 +23734,7 @@ function generateLocalLetReferences(job) {
  * Copyright Google LLC All Rights Reserved.
  *
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 const phases = [
     { kind: CompilationJobKind.Tmpl, fn: removeContentSelectors },
@@ -24160,73 +24261,81 @@ function ingestDeferBlock(unit, deferBlock) {
     // Configure all defer `on` conditions.
     // TODO: refactor prefetch triggers to use a separate op type, with a shared superclass. This will
     // make it easier to refactor prefetch behavior in the future.
-    let prefetch = false;
-    let deferOnOps = [];
-    let deferWhenOps = [];
-    for (const triggers of [deferBlock.triggers, deferBlock.prefetchTriggers]) {
-        if (triggers.idle !== undefined) {
-            const deferOnOp = createDeferOnOp(deferXref, { kind: DeferTriggerKind.Idle }, prefetch, triggers.idle.sourceSpan);
-            deferOnOps.push(deferOnOp);
-        }
-        if (triggers.immediate !== undefined) {
-            const deferOnOp = createDeferOnOp(deferXref, { kind: DeferTriggerKind.Immediate }, prefetch, triggers.immediate.sourceSpan);
-            deferOnOps.push(deferOnOp);
-        }
-        if (triggers.timer !== undefined) {
-            const deferOnOp = createDeferOnOp(deferXref, { kind: DeferTriggerKind.Timer, delay: triggers.timer.delay }, prefetch, triggers.timer.sourceSpan);
-            deferOnOps.push(deferOnOp);
-        }
-        if (triggers.hover !== undefined) {
-            const deferOnOp = createDeferOnOp(deferXref, {
-                kind: DeferTriggerKind.Hover,
-                targetName: triggers.hover.reference,
-                targetXref: null,
-                targetSlot: null,
-                targetView: null,
-                targetSlotViewSteps: null,
-            }, prefetch, triggers.hover.sourceSpan);
-            deferOnOps.push(deferOnOp);
-        }
-        if (triggers.interaction !== undefined) {
-            const deferOnOp = createDeferOnOp(deferXref, {
-                kind: DeferTriggerKind.Interaction,
-                targetName: triggers.interaction.reference,
-                targetXref: null,
-                targetSlot: null,
-                targetView: null,
-                targetSlotViewSteps: null,
-            }, prefetch, triggers.interaction.sourceSpan);
-            deferOnOps.push(deferOnOp);
-        }
-        if (triggers.viewport !== undefined) {
-            const deferOnOp = createDeferOnOp(deferXref, {
-                kind: DeferTriggerKind.Viewport,
-                targetName: triggers.viewport.reference,
-                targetXref: null,
-                targetSlot: null,
-                targetView: null,
-                targetSlotViewSteps: null,
-            }, prefetch, triggers.viewport.sourceSpan);
-            deferOnOps.push(deferOnOp);
-        }
-        if (triggers.when !== undefined) {
-            if (triggers.when.value instanceof Interpolation$1) {
-                // TemplateDefinitionBuilder supports this case, but it's very strange to me. What would it
-                // even mean?
-                throw new Error(`Unexpected interpolation in defer block when trigger`);
-            }
-            const deferOnOp = createDeferWhenOp(deferXref, convertAst(triggers.when.value, unit.job, triggers.when.sourceSpan), prefetch, triggers.when.sourceSpan);
-            deferWhenOps.push(deferOnOp);
-        }
-        // If no (non-prefetching) defer triggers were provided, default to `idle`.
-        if (deferOnOps.length === 0 && deferWhenOps.length === 0) {
-            deferOnOps.push(createDeferOnOp(deferXref, { kind: DeferTriggerKind.Idle }, false, null));
-        }
-        prefetch = true;
+    const deferOnOps = [];
+    const deferWhenOps = [];
+    // Ingest the hydrate triggers first since they set up all the other triggers during SSR.
+    ingestDeferTriggers("hydrate" /* ir.DeferOpModifierKind.HYDRATE */, deferBlock.hydrateTriggers, deferOnOps, deferWhenOps, unit, deferXref);
+    ingestDeferTriggers("none" /* ir.DeferOpModifierKind.NONE */, deferBlock.triggers, deferOnOps, deferWhenOps, unit, deferXref);
+    ingestDeferTriggers("prefetch" /* ir.DeferOpModifierKind.PREFETCH */, deferBlock.prefetchTriggers, deferOnOps, deferWhenOps, unit, deferXref);
+    // If no (non-prefetching or hydrating) defer triggers were provided, default to `idle`.
+    const hasConcreteTrigger = deferOnOps.some((op) => op.modifier === "none" /* ir.DeferOpModifierKind.NONE */) ||
+        deferWhenOps.some((op) => op.modifier === "none" /* ir.DeferOpModifierKind.NONE */);
+    if (!hasConcreteTrigger) {
+        deferOnOps.push(createDeferOnOp(deferXref, { kind: DeferTriggerKind.Idle }, "none" /* ir.DeferOpModifierKind.NONE */, null));
     }
     unit.create.push(deferOnOps);
     unit.update.push(deferWhenOps);
 }
+function ingestDeferTriggers(modifier, triggers, onOps, whenOps, unit, deferXref) {
+    if (triggers.idle !== undefined) {
+        const deferOnOp = createDeferOnOp(deferXref, { kind: DeferTriggerKind.Idle }, modifier, triggers.idle.sourceSpan);
+        onOps.push(deferOnOp);
+    }
+    if (triggers.immediate !== undefined) {
+        const deferOnOp = createDeferOnOp(deferXref, { kind: DeferTriggerKind.Immediate }, modifier, triggers.immediate.sourceSpan);
+        onOps.push(deferOnOp);
+    }
+    if (triggers.timer !== undefined) {
+        const deferOnOp = createDeferOnOp(deferXref, { kind: DeferTriggerKind.Timer, delay: triggers.timer.delay }, modifier, triggers.timer.sourceSpan);
+        onOps.push(deferOnOp);
+    }
+    if (triggers.hover !== undefined) {
+        const deferOnOp = createDeferOnOp(deferXref, {
+            kind: DeferTriggerKind.Hover,
+            targetName: triggers.hover.reference,
+            targetXref: null,
+            targetSlot: null,
+            targetView: null,
+            targetSlotViewSteps: null,
+        }, modifier, triggers.hover.sourceSpan);
+        onOps.push(deferOnOp);
+    }
+    if (triggers.interaction !== undefined) {
+        const deferOnOp = createDeferOnOp(deferXref, {
+            kind: DeferTriggerKind.Interaction,
+            targetName: triggers.interaction.reference,
+            targetXref: null,
+            targetSlot: null,
+            targetView: null,
+            targetSlotViewSteps: null,
+        }, modifier, triggers.interaction.sourceSpan);
+        onOps.push(deferOnOp);
+    }
+    if (triggers.viewport !== undefined) {
+        const deferOnOp = createDeferOnOp(deferXref, {
+            kind: DeferTriggerKind.Viewport,
+            targetName: triggers.viewport.reference,
+            targetXref: null,
+            targetSlot: null,
+            targetView: null,
+            targetSlotViewSteps: null,
+        }, modifier, triggers.viewport.sourceSpan);
+        onOps.push(deferOnOp);
+    }
+    if (triggers.never !== undefined) {
+        const deferOnOp = createDeferOnOp(deferXref, { kind: DeferTriggerKind.Never }, modifier, triggers.never.sourceSpan);
+        onOps.push(deferOnOp);
+    }
+    if (triggers.when !== undefined) {
+        if (triggers.when.value instanceof Interpolation$1) {
+            // TemplateDefinitionBuilder supports this case, but it's very strange to me. What would it
+            // even mean?
+            throw new Error(`Unexpected interpolation in defer block when trigger`);
+        }
+        const deferOnOp = createDeferWhenOp(deferXref, convertAst(triggers.when.value, unit.job, triggers.when.sourceSpan), modifier, triggers.when.sourceSpan);
+        whenOps.push(deferOnOp);
+    }
+}
 function ingestIcu(unit, icu) {
     if (icu.i18n instanceof Message && isSingleI18nIcu(icu.i18n)) {
         const xref = unit.job.allocateXrefId();
@@ -25970,12 +26079,29 @@ var OnTriggerType;
     OnTriggerType["IMMEDIATE"] = "immediate";
     OnTriggerType["HOVER"] = "hover";
     OnTriggerType["VIEWPORT"] = "viewport";
+    OnTriggerType["NEVER"] = "never";
 })(OnTriggerType || (OnTriggerType = {}));
 /** Parses a `when` deferred trigger. */
+function parseNeverTrigger({ expression, sourceSpan }, triggers, errors) {
+    const neverIndex = expression.indexOf('never');
+    const neverSourceSpan = new ParseSourceSpan(sourceSpan.start.moveBy(neverIndex), sourceSpan.start.moveBy(neverIndex + 'never'.length));
+    const prefetchSpan = getPrefetchSpan(expression, sourceSpan);
+    const hydrateSpan = getHydrateSpan(expression, sourceSpan);
+    // This is here just to be safe, we shouldn't enter this function
+    // in the first place if a block doesn't have the "on" keyword.
+    if (neverIndex === -1) {
+        errors.push(new ParseError(sourceSpan, `Could not find "never" keyword in expression`));
+    }
+    else {
+        trackTrigger('never', triggers, errors, new NeverDeferredTrigger(neverSourceSpan, sourceSpan, prefetchSpan, null, hydrateSpan));
+    }
+}
+/** Parses a `when` deferred trigger. */
 function parseWhenTrigger({ expression, sourceSpan }, bindingParser, triggers, errors) {
     const whenIndex = expression.indexOf('when');
     const whenSourceSpan = new ParseSourceSpan(sourceSpan.start.moveBy(whenIndex), sourceSpan.start.moveBy(whenIndex + 'when'.length));
     const prefetchSpan = getPrefetchSpan(expression, sourceSpan);
+    const hydrateSpan = getHydrateSpan(expression, sourceSpan);
     // This is here just to be safe, we shouldn't enter this function
     // in the first place if a block doesn't have the "when" keyword.
     if (whenIndex === -1) {
@@ -25984,7 +26110,7 @@ function parseWhenTrigger({ expression, sourceSpan }, bindingParser, triggers, e
     else {
         const start = getTriggerParametersStart(expression, whenIndex + 1);
         const parsed = bindingParser.parseBinding(expression.slice(start), false, sourceSpan, sourceSpan.start.offset + start);
-        trackTrigger('when', triggers, errors, new BoundDeferredTrigger(parsed, sourceSpan, prefetchSpan, whenSourceSpan));
+        trackTrigger('when', triggers, errors, new BoundDeferredTrigger(parsed, sourceSpan, prefetchSpan, whenSourceSpan, hydrateSpan));
     }
 }
 /** Parses an `on` trigger */
@@ -25992,6 +26118,7 @@ function parseOnTrigger({ expression, sourceSpan }, triggers, errors, placeholde
     const onIndex = expression.indexOf('on');
     const onSourceSpan = new ParseSourceSpan(sourceSpan.start.moveBy(onIndex), sourceSpan.start.moveBy(onIndex + 'on'.length));
     const prefetchSpan = getPrefetchSpan(expression, sourceSpan);
+    const hydrateSpan = getHydrateSpan(expression, sourceSpan);
     // This is here just to be safe, we shouldn't enter this function
     // in the first place if a block doesn't have the "on" keyword.
     if (onIndex === -1) {
@@ -25999,7 +26126,9 @@ function parseOnTrigger({ expression, sourceSpan }, triggers, errors, placeholde
     }
     else {
         const start = getTriggerParametersStart(expression, onIndex + 1);
-        const parser = new OnTriggerParser(expression, start, sourceSpan, triggers, errors, placeholder, prefetchSpan, onSourceSpan);
+        const parser = new OnTriggerParser(expression, start, sourceSpan, triggers, errors, expression.startsWith('hydrate')
+            ? validateHydrateReferenceBasedTrigger
+            : validatePlainReferenceBasedTrigger, placeholder, prefetchSpan, onSourceSpan, hydrateSpan);
         parser.parse();
     }
 }
@@ -26009,16 +26138,24 @@ function getPrefetchSpan(expression, sourceSpan) {
     }
     return new ParseSourceSpan(sourceSpan.start, sourceSpan.start.moveBy('prefetch'.length));
 }
+function getHydrateSpan(expression, sourceSpan) {
+    if (!expression.startsWith('hydrate')) {
+        return null;
+    }
+    return new ParseSourceSpan(sourceSpan.start, sourceSpan.start.moveBy('hydrate'.length));
+}
 class OnTriggerParser {
-    constructor(expression, start, span, triggers, errors, placeholder, prefetchSpan, onSourceSpan) {
+    constructor(expression, start, span, triggers, errors, validator, placeholder, prefetchSpan, onSourceSpan, hydrateSpan) {
         this.expression = expression;
         this.start = start;
         this.span = span;
         this.triggers = triggers;
         this.errors = errors;
+        this.validator = validator;
         this.placeholder = placeholder;
         this.prefetchSpan = prefetchSpan;
         this.onSourceSpan = onSourceSpan;
+        this.hydrateSpan = hydrateSpan;
         this.index = 0;
         this.tokens = new Lexer().tokenize(expression.slice(start));
     }
@@ -26073,26 +26210,27 @@ class OnTriggerParser {
         const isFirstTrigger = identifier.index === 0;
         const onSourceSpan = isFirstTrigger ? this.onSourceSpan : null;
         const prefetchSourceSpan = isFirstTrigger ? this.prefetchSpan : null;
+        const hydrateSourceSpan = isFirstTrigger ? this.hydrateSpan : null;
         const sourceSpan = new ParseSourceSpan(isFirstTrigger ? this.span.start : triggerNameStartSpan, endSpan);
         try {
             switch (identifier.toString()) {
                 case OnTriggerType.IDLE:
-                    this.trackTrigger('idle', createIdleTrigger(parameters, nameSpan, sourceSpan, prefetchSourceSpan, onSourceSpan));
+                    this.trackTrigger('idle', createIdleTrigger(parameters, nameSpan, sourceSpan, prefetchSourceSpan, onSourceSpan, hydrateSourceSpan));
                     break;
                 case OnTriggerType.TIMER:
-                    this.trackTrigger('timer', createTimerTrigger(parameters, nameSpan, sourceSpan, this.prefetchSpan, this.onSourceSpan));
+                    this.trackTrigger('timer', createTimerTrigger(parameters, nameSpan, sourceSpan, this.prefetchSpan, this.onSourceSpan, this.hydrateSpan));
                     break;
                 case OnTriggerType.INTERACTION:
-                    this.trackTrigger('interaction', createInteractionTrigger(parameters, nameSpan, sourceSpan, this.prefetchSpan, this.onSourceSpan, this.placeholder));
+                    this.trackTrigger('interaction', createInteractionTrigger(parameters, nameSpan, sourceSpan, this.prefetchSpan, this.onSourceSpan, this.hydrateSpan, this.placeholder, this.validator));
                     break;
                 case OnTriggerType.IMMEDIATE:
-                    this.trackTrigger('immediate', createImmediateTrigger(parameters, nameSpan, sourceSpan, this.prefetchSpan, this.onSourceSpan));
+                    this.trackTrigger('immediate', createImmediateTrigger(parameters, nameSpan, sourceSpan, this.prefetchSpan, this.onSourceSpan, this.hydrateSpan));
                     break;
                 case OnTriggerType.HOVER:
-                    this.trackTrigger('hover', createHoverTrigger(parameters, nameSpan, sourceSpan, this.prefetchSpan, this.onSourceSpan, this.placeholder));
+                    this.trackTrigger('hover', createHoverTrigger(parameters, nameSpan, sourceSpan, this.prefetchSpan, this.onSourceSpan, this.hydrateSpan, this.placeholder, this.validator));
                     break;
                 case OnTriggerType.VIEWPORT:
-                    this.trackTrigger('viewport', createViewportTrigger(parameters, nameSpan, sourceSpan, this.prefetchSpan, this.onSourceSpan, this.placeholder));
+                    this.trackTrigger('viewport', createViewportTrigger(parameters, nameSpan, sourceSpan, this.prefetchSpan, this.onSourceSpan, this.hydrateSpan, this.placeholder, this.validator));
                     break;
                 default:
                     throw new Error(`Unrecognized trigger type "${identifier}"`);
@@ -26182,13 +26320,13 @@ function trackTrigger(name, allTriggers, errors, trigger) {
         allTriggers[name] = trigger;
     }
 }
-function createIdleTrigger(parameters, nameSpan, sourceSpan, prefetchSpan, onSourceSpan) {
+function createIdleTrigger(parameters, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan) {
     if (parameters.length > 0) {
         throw new Error(`"${OnTriggerType.IDLE}" trigger cannot have parameters`);
     }
-    return new IdleDeferredTrigger(nameSpan, sourceSpan, prefetchSpan, onSourceSpan);
+    return new IdleDeferredTrigger(nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
 }
-function createTimerTrigger(parameters, nameSpan, sourceSpan, prefetchSpan, onSourceSpan) {
+function createTimerTrigger(parameters, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan) {
     if (parameters.length !== 1) {
         throw new Error(`"${OnTriggerType.TIMER}" trigger must have exactly one parameter`);
     }
@@ -26196,27 +26334,33 @@ function createTimerTrigger(parameters, nameSpan, sourceSpan, prefetchSpan, onSo
     if (delay === null) {
         throw new Error(`Could not parse time value of trigger "${OnTriggerType.TIMER}"`);
     }
-    return new TimerDeferredTrigger(delay, nameSpan, sourceSpan, prefetchSpan, onSourceSpan);
+    return new TimerDeferredTrigger(delay, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
 }
-function createImmediateTrigger(parameters, nameSpan, sourceSpan, prefetchSpan, onSourceSpan) {
+function createImmediateTrigger(parameters, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan) {
     if (parameters.length > 0) {
         throw new Error(`"${OnTriggerType.IMMEDIATE}" trigger cannot have parameters`);
     }
-    return new ImmediateDeferredTrigger(nameSpan, sourceSpan, prefetchSpan, onSourceSpan);
+    return new ImmediateDeferredTrigger(nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
 }
-function createHoverTrigger(parameters, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, placeholder) {
-    validateReferenceBasedTrigger(OnTriggerType.HOVER, parameters, placeholder);
-    return new HoverDeferredTrigger(parameters[0] ?? null, nameSpan, sourceSpan, prefetchSpan, onSourceSpan);
+function createHoverTrigger(parameters, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan, placeholder, validator) {
+    validator(OnTriggerType.HOVER, parameters, placeholder);
+    return new HoverDeferredTrigger(parameters[0] ?? null, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
 }
-function createInteractionTrigger(parameters, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, placeholder) {
-    validateReferenceBasedTrigger(OnTriggerType.INTERACTION, parameters, placeholder);
-    return new InteractionDeferredTrigger(parameters[0] ?? null, nameSpan, sourceSpan, prefetchSpan, onSourceSpan);
+function createInteractionTrigger(parameters, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan, placeholder, validator) {
+    validator(OnTriggerType.INTERACTION, parameters, placeholder);
+    return new InteractionDeferredTrigger(parameters[0] ?? null, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
 }
-function createViewportTrigger(parameters, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, placeholder) {
-    validateReferenceBasedTrigger(OnTriggerType.VIEWPORT, parameters, placeholder);
-    return new ViewportDeferredTrigger(parameters[0] ?? null, nameSpan, sourceSpan, prefetchSpan, onSourceSpan);
+function createViewportTrigger(parameters, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan, placeholder, validator) {
+    validator(OnTriggerType.VIEWPORT, parameters, placeholder);
+    return new ViewportDeferredTrigger(parameters[0] ?? null, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
 }
-function validateReferenceBasedTrigger(type, parameters, placeholder) {
+/**
+ * Checks whether the structure of a non-hydrate reference-based trigger is valid.
+ * @param type Type of the trigger being validated.
+ * @param parameters Parameters of the trigger.
+ * @param placeholder Placeholder of the defer block.
+ */
+function validatePlainReferenceBasedTrigger(type, parameters, placeholder) {
     if (parameters.length > 1) {
         throw new Error(`"${type}" trigger can only have zero or one parameters`);
     }
@@ -26230,6 +26374,16 @@ function validateReferenceBasedTrigger(type, parameters, placeholder) {
         }
     }
 }
+/**
+ * Checks whether the structure of a hydrate trigger is valid.
+ * @param type Type of the trigger being validated.
+ * @param parameters Parameters of the trigger.
+ */
+function validateHydrateReferenceBasedTrigger(type, parameters) {
+    if (parameters.length > 0) {
+        throw new Error(`Hydration trigger "${type}" cannot have parameters`);
+    }
+}
 /** Gets the index within an expression at which the trigger parameters start. */
 function getTriggerParametersStart(value, startPosition = 0) {
     let hasFoundSeparator = false;
@@ -26260,6 +26414,12 @@ function parseDeferredTime(value) {
 const PREFETCH_WHEN_PATTERN = /^prefetch\s+when\s/;
 /** Pattern to identify a `prefetch on` trigger. */
 const PREFETCH_ON_PATTERN = /^prefetch\s+on\s/;
+/** Pattern to identify a `hydrate when` trigger. */
+const HYDRATE_WHEN_PATTERN = /^hydrate\s+when\s/;
+/** Pattern to identify a `hydrate on` trigger. */
+const HYDRATE_ON_PATTERN = /^hydrate\s+on\s/;
+/** Pattern to identify a `hydrate never` trigger. */
+const HYDRATE_NEVER_PATTERN = /^hydrate\s+never\s*/;
 /** Pattern to identify a `minimum` parameter in a block. */
 const MINIMUM_PARAMETER_PATTERN = /^minimum\s/;
 /** Pattern to identify a `after` parameter in a block. */
@@ -26279,7 +26439,7 @@ function isConnectedDeferLoopBlock(name) {
 function createDeferredBlock(ast, connectedBlocks, visitor, bindingParser) {
     const errors = [];
     const { placeholder, loading, error } = parseConnectedBlocks(connectedBlocks, errors, visitor);
-    const { triggers, prefetchTriggers } = parsePrimaryTriggers(ast.parameters, bindingParser, errors, placeholder);
+    const { triggers, prefetchTriggers, hydrateTriggers } = parsePrimaryTriggers(ast, bindingParser, errors, placeholder);
     // The `defer` block has a main span encompassing all of the connected branches as well.
     let lastEndSourceSpan = ast.endSourceSpan;
     let endOfLastSourceSpan = ast.sourceSpan.end;
@@ -26289,7 +26449,7 @@ function createDeferredBlock(ast, connectedBlocks, visitor, bindingParser) {
         endOfLastSourceSpan = lastConnectedBlock.sourceSpan.end;
     }
     const sourceSpanWithConnectedBlocks = new ParseSourceSpan(ast.sourceSpan.start, endOfLastSourceSpan);
-    const node = new DeferredBlock(visitAll(visitor, ast.children, ast.children), triggers, prefetchTriggers, placeholder, loading, error, ast.nameSpan, sourceSpanWithConnectedBlocks, ast.sourceSpan, ast.startSourceSpan, lastEndSourceSpan, ast.i18n);
+    const node = new DeferredBlock(visitAll(visitor, ast.children, ast.children), triggers, prefetchTriggers, hydrateTriggers, placeholder, loading, error, ast.nameSpan, sourceSpanWithConnectedBlocks, ast.sourceSpan, ast.startSourceSpan, lastEndSourceSpan, ast.i18n);
     return { node, errors };
 }
 function parseConnectedBlocks(connectedBlocks, errors, visitor) {
@@ -26390,10 +26550,11 @@ function parseErrorBlock(ast, visitor) {
     }
     return new DeferredBlockError(visitAll(visitor, ast.children, ast.children), ast.nameSpan, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan, ast.i18n);
 }
-function parsePrimaryTriggers(params, bindingParser, errors, placeholder) {
+function parsePrimaryTriggers(ast, bindingParser, errors, placeholder) {
     const triggers = {};
     const prefetchTriggers = {};
-    for (const param of params) {
+    const hydrateTriggers = {};
+    for (const param of ast.parameters) {
         // The lexer ignores the leading spaces so we can assume
         // that the expression starts with a keyword.
         if (WHEN_PARAMETER_PATTERN.test(param.expression)) {
@@ -26408,11 +26569,23 @@ function parsePrimaryTriggers(params, bindingParser, errors, placeholder) {
         else if (PREFETCH_ON_PATTERN.test(param.expression)) {
             parseOnTrigger(param, prefetchTriggers, errors, placeholder);
         }
+        else if (HYDRATE_WHEN_PATTERN.test(param.expression)) {
+            parseWhenTrigger(param, bindingParser, hydrateTriggers, errors);
+        }
+        else if (HYDRATE_ON_PATTERN.test(param.expression)) {
+            parseOnTrigger(param, hydrateTriggers, errors, placeholder);
+        }
+        else if (HYDRATE_NEVER_PATTERN.test(param.expression)) {
+            parseNeverTrigger(param, hydrateTriggers, errors);
+        }
         else {
             errors.push(new ParseError(param.sourceSpan, 'Unrecognized trigger'));
         }
     }
-    return { triggers, prefetchTriggers };
+    if (hydrateTriggers.never && Object.keys(hydrateTriggers).length > 1) {
+        errors.push(new ParseError(ast.startSourceSpan, 'Cannot specify additional `hydrate` triggers if `hydrate never` is present'));
+    }
+    return { triggers, prefetchTriggers, hydrateTriggers };
 }
 
 const BIND_NAME_REGEXP = /^(?:(bind-)|(let-)|(ref-|#)|(on-)|(bindon-)|(@))(.*)$/;
@@ -28125,6 +28298,8 @@ class TemplateBinder extends RecursiveAstVisitor {
         this.ingestScopedNode(deferred);
         deferred.triggers.when?.value.visit(this);
         deferred.prefetchTriggers.when?.value.visit(this);
+        deferred.hydrateTriggers.when?.value.visit(this);
+        deferred.hydrateTriggers.never?.visit(this);
         deferred.placeholder && this.visitNode(deferred.placeholder);
         deferred.loading && this.visitNode(deferred.loading);
         deferred.error && this.visitNode(deferred.error);
@@ -29070,7 +29245,7 @@ function publishFacade(global) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-new Version('19.0.0-next.5');
+new Version('19.0.0-next.7');
 
 const _I18N_ATTR = 'i18n';
 const _I18N_ATTR_PREFIX = 'i18n-';
@@ -30414,7 +30589,7 @@ class NodeJSPathManipulation {
 // G3-ESM-MARKER: G3 uses CommonJS, but externally everything in ESM.
 // CommonJS/ESM interop for determining the current file name and containing dir.
 const isCommonJS = typeof __filename !== 'undefined';
-const currentFileUrl = isCommonJS ? null : (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('compiler_host-ca7ba733.js', document.baseURI).href));
+const currentFileUrl = isCommonJS ? null : (typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('checker-637eee78.js', document.baseURI).href));
 const currentFileName = isCommonJS ? __filename : url.fileURLToPath(currentFileUrl);
 /**
  * A wrapper around the Node.js file-system that supports readonly operations and path manipulation.
@@ -35219,7 +35394,7 @@ class TypeEmitter {
  * Copyright Google LLC All Rights Reserved.
  *
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
 /**
  * Creates a TypeScript node representing a numeric value.
@@ -41727,6 +41902,10 @@ class Scope {
     appendDeferredBlock(block) {
         this.appendDeferredTriggers(block, block.triggers);
         this.appendDeferredTriggers(block, block.prefetchTriggers);
+        // Only the `when` hydration trigger needs to be checked.
+        if (block.hydrateTriggers.when) {
+            this.opQueue.push(new TcbExpressionOp(this.tcb, this, block.hydrateTriggers.when.value));
+        }
         this.appendChildren(block);
         if (block.placeholder !== null) {
             this.appendChildren(block.placeholder);
@@ -44201,285 +44380,6 @@ class SingleShimTypeCheckingHost extends SingleFileTypeCheckingHost {
     }
 }
 
-/** Tracks changes that have to be made for specific files. */
-class ChangeTracker {
-    _printer;
-    _importRemapper;
-    _changes = new Map();
-    _importManager;
-    _quotesCache = new WeakMap();
-    constructor(_printer, _importRemapper) {
-        this._printer = _printer;
-        this._importRemapper = _importRemapper;
-        this._importManager = new ImportManager({
-            shouldUseSingleQuotes: (file) => this._getQuoteKind(file) === 0 /* QuoteKind.SINGLE */,
-        });
-    }
-    /**
-     * Tracks the insertion of some text.
-     * @param sourceFile File in which the text is being inserted.
-     * @param start Index at which the text is insert.
-     * @param text Text to be inserted.
-     */
-    insertText(sourceFile, index, text) {
-        this._trackChange(sourceFile, { start: index, text });
-    }
-    /**
-     * Replaces text within a file.
-     * @param sourceFile File in which to replace the text.
-     * @param start Index from which to replace the text.
-     * @param removeLength Length of the text being replaced.
-     * @param text Text to be inserted instead of the old one.
-     */
-    replaceText(sourceFile, start, removeLength, text) {
-        this._trackChange(sourceFile, { start, removeLength, text });
-    }
-    /**
-     * Replaces the text of an AST node with a new one.
-     * @param oldNode Node to be replaced.
-     * @param newNode New node to be inserted.
-     * @param emitHint Hint when formatting the text of the new node.
-     * @param sourceFileWhenPrinting File to use when printing out the new node. This is important
-     * when copying nodes from one file to another, because TypeScript might not output literal nodes
-     * without it.
-     */
-    replaceNode(oldNode, newNode, emitHint = ts__default["default"].EmitHint.Unspecified, sourceFileWhenPrinting) {
-        const sourceFile = oldNode.getSourceFile();
-        this.replaceText(sourceFile, oldNode.getStart(), oldNode.getWidth(), this._printer.printNode(emitHint, newNode, sourceFileWhenPrinting || sourceFile));
-    }
-    /**
-     * Removes the text of an AST node from a file.
-     * @param node Node whose text should be removed.
-     */
-    removeNode(node) {
-        this._trackChange(node.getSourceFile(), {
-            start: node.getStart(),
-            removeLength: node.getWidth(),
-            text: '',
-        });
-    }
-    /**
-     * Adds an import to a file.
-     * @param sourceFile File to which to add the import.
-     * @param symbolName Symbol being imported.
-     * @param moduleName Module from which the symbol is imported.
-     * @param alias Alias to use for the import.
-     */
-    addImport(sourceFile, symbolName, moduleName, alias) {
-        if (this._importRemapper) {
-            moduleName = this._importRemapper(moduleName, sourceFile.fileName);
-        }
-        // It's common for paths to be manipulated with Node's `path` utilties which
-        // can yield a path with back slashes. Normalize them since outputting such
-        // paths will also cause TS to escape the forward slashes.
-        moduleName = normalizePath(moduleName);
-        if (!this._changes.has(sourceFile)) {
-            this._changes.set(sourceFile, []);
-        }
-        return this._importManager.addImport({
-            requestedFile: sourceFile,
-            exportSymbolName: symbolName,
-            exportModuleSpecifier: moduleName,
-            unsafeAliasOverride: alias,
-        });
-    }
-    /**
-     * Removes an import from a file.
-     * @param sourceFile File from which to remove the import.
-     * @param symbolName Original name of the symbol to be removed. Used even if the import is aliased.
-     * @param moduleName Module from which the symbol is imported.
-     */
-    removeImport(sourceFile, symbolName, moduleName) {
-        // It's common for paths to be manipulated with Node's `path` utilties which
-        // can yield a path with back slashes. Normalize them since outputting such
-        // paths will also cause TS to escape the forward slashes.
-        moduleName = normalizePath(moduleName);
-        if (!this._changes.has(sourceFile)) {
-            this._changes.set(sourceFile, []);
-        }
-        this._importManager.removeImport(sourceFile, symbolName, moduleName);
-    }
-    /**
-     * Gets the changes that should be applied to all the files in the migration.
-     * The changes are sorted in the order in which they should be applied.
-     */
-    recordChanges() {
-        this._recordImports();
-        return this._changes;
-    }
-    /**
-     * Clear the tracked changes
-     */
-    clearChanges() {
-        this._changes.clear();
-    }
-    /**
-     * Adds a change to a `ChangesByFile` map.
-     * @param file File that the change is associated with.
-     * @param change Change to be added.
-     */
-    _trackChange(file, change) {
-        const changes = this._changes.get(file);
-        if (changes) {
-            // Insert the changes in reverse so that they're applied in reverse order.
-            // This ensures that the offsets of subsequent changes aren't affected by
-            // previous changes changing the file's text.
-            const insertIndex = changes.findIndex((current) => current.start <= change.start);
-            if (insertIndex === -1) {
-                changes.push(change);
-            }
-            else {
-                changes.splice(insertIndex, 0, change);
-            }
-        }
-        else {
-            this._changes.set(file, [change]);
-        }
-    }
-    /** Determines what kind of quotes to use for a specific file. */
-    _getQuoteKind(sourceFile) {
-        if (this._quotesCache.has(sourceFile)) {
-            return this._quotesCache.get(sourceFile);
-        }
-        let kind = 0 /* QuoteKind.SINGLE */;
-        for (const statement of sourceFile.statements) {
-            if (ts__default["default"].isImportDeclaration(statement) && ts__default["default"].isStringLiteral(statement.moduleSpecifier)) {
-                kind = statement.moduleSpecifier.getText()[0] === '"' ? 1 /* QuoteKind.DOUBLE */ : 0 /* QuoteKind.SINGLE */;
-                this._quotesCache.set(sourceFile, kind);
-                break;
-            }
-        }
-        return kind;
-    }
-    /** Records the pending import changes from the import manager. */
-    _recordImports() {
-        const { newImports, updatedImports, deletedImports } = this._importManager.finalize();
-        for (const [original, replacement] of updatedImports) {
-            this.replaceNode(original, replacement);
-        }
-        for (const node of deletedImports) {
-            this.removeNode(node);
-        }
-        for (const [sourceFile] of this._changes) {
-            const importsToAdd = newImports.get(sourceFile.fileName);
-            if (!importsToAdd) {
-                continue;
-            }
-            const importLines = [];
-            let lastImport = null;
-            for (const statement of sourceFile.statements) {
-                if (ts__default["default"].isImportDeclaration(statement)) {
-                    lastImport = statement;
-                }
-            }
-            for (const decl of importsToAdd) {
-                importLines.push(this._printer.printNode(ts__default["default"].EmitHint.Unspecified, decl, sourceFile));
-            }
-            this.insertText(sourceFile, lastImport ? lastImport.getEnd() : 0, (lastImport ? '\n' : '') + importLines.join('\n'));
-        }
-    }
-}
-/** Normalizes a path to use posix separators. */
-function normalizePath(path) {
-    return path.replace(/\\/g, '/');
-}
-
-function parseTsconfigFile(tsconfigPath, basePath) {
-    const { config } = ts__default["default"].readConfigFile(tsconfigPath, ts__default["default"].sys.readFile);
-    const parseConfigHost = {
-        useCaseSensitiveFileNames: ts__default["default"].sys.useCaseSensitiveFileNames,
-        fileExists: ts__default["default"].sys.fileExists,
-        readDirectory: ts__default["default"].sys.readDirectory,
-        readFile: ts__default["default"].sys.readFile,
-    };
-    // Throw if incorrect arguments are passed to this function. Passing relative base paths
-    // results in root directories not being resolved and in later type checking runtime errors.
-    // More details can be found here: https://github.com/microsoft/TypeScript/issues/37731.
-    if (!p__namespace.isAbsolute(basePath)) {
-        throw Error('Unexpected relative base path has been specified.');
-    }
-    return ts__default["default"].parseJsonConfigFileContent(config, parseConfigHost, basePath, {});
-}
-
-/**
- * Creates a TypeScript program instance for a TypeScript project within
- * the virtual file system tree.
- * @param tree Virtual file system tree that contains the source files.
- * @param tsconfigPath Virtual file system path that resolves to the TypeScript project.
- * @param basePath Base path for the virtual file system tree.
- * @param fakeFileRead Optional file reader function. Can be used to overwrite files in
- *   the TypeScript program, or to add in-memory files (e.g. to add global types).
- * @param additionalFiles Additional file paths that should be added to the program.
- */
-function createMigrationProgram(tree, tsconfigPath, basePath, fakeFileRead, additionalFiles) {
-    const { rootNames, options, host } = createProgramOptions(tree, tsconfigPath, basePath, fakeFileRead, additionalFiles);
-    return ts__default["default"].createProgram(rootNames, options, host);
-}
-/**
- * Creates the options necessary to instantiate a TypeScript program.
- * @param tree Virtual file system tree that contains the source files.
- * @param tsconfigPath Virtual file system path that resolves to the TypeScript project.
- * @param basePath Base path for the virtual file system tree.
- * @param fakeFileRead Optional file reader function. Can be used to overwrite files in
- *   the TypeScript program, or to add in-memory files (e.g. to add global types).
- * @param additionalFiles Additional file paths that should be added to the program.
- * @param optionOverrides Overrides of the parsed compiler options.
- */
-function createProgramOptions(tree, tsconfigPath, basePath, fakeFileRead, additionalFiles, optionOverrides) {
-    // Resolve the tsconfig path to an absolute path. This is needed as TypeScript otherwise
-    // is not able to resolve root directories in the given tsconfig. More details can be found
-    // in the following issue: https://github.com/microsoft/TypeScript/issues/37731.
-    tsconfigPath = p.resolve(basePath, tsconfigPath);
-    const parsed = parseTsconfigFile(tsconfigPath, p.dirname(tsconfigPath));
-    const options = optionOverrides ? { ...parsed.options, ...optionOverrides } : parsed.options;
-    const host = createMigrationCompilerHost(tree, options, basePath, fakeFileRead);
-    return { rootNames: parsed.fileNames.concat(additionalFiles || []), options, host };
-}
-function createMigrationCompilerHost(tree, options, basePath, fakeRead) {
-    const host = ts__default["default"].createCompilerHost(options, true);
-    const defaultReadFile = host.readFile;
-    // We need to overwrite the host "readFile" method, as we want the TypeScript
-    // program to be based on the file contents in the virtual file tree. Otherwise
-    // if we run multiple migrations we might have intersecting changes and
-    // source files.
-    host.readFile = (fileName) => {
-        const treeRelativePath = p.relative(basePath, fileName);
-        let result = fakeRead?.(treeRelativePath);
-        if (typeof result !== 'string') {
-            // If the relative path resolved to somewhere outside of the tree, fall back to
-            // TypeScript's default file reading function since the `tree` will throw an error.
-            result = treeRelativePath.startsWith('..')
-                ? defaultReadFile.call(host, fileName)
-                : tree.read(treeRelativePath)?.toString();
-        }
-        // Strip BOM as otherwise TSC methods (Ex: getWidth) will return an offset,
-        // which breaks the CLI UpdateRecorder.
-        // See: https://github.com/angular/angular/pull/30719
-        return typeof result === 'string' ? result.replace(/^\uFEFF/, '') : undefined;
-    };
-    return host;
-}
-/**
- * Checks whether a file can be migrate by our automated migrations.
- * @param basePath Absolute path to the project.
- * @param sourceFile File being checked.
- * @param program Program that includes the source file.
- */
-function canMigrateFile(basePath, sourceFile, program) {
-    // We shouldn't migrate .d.ts files, files from an external library or type checking files.
-    if (sourceFile.fileName.endsWith('.ngtypecheck.ts') ||
-        sourceFile.isDeclarationFile ||
-        program.isSourceFileFromExternalLibrary(sourceFile)) {
-        return false;
-    }
-    // Our migrations are set up to create a `Program` from the project's tsconfig and to migrate all
-    // the files within the program. This can include files that are outside of the Angular CLI
-    // project. We can't migrate files outside of the project, because our file system interactions
-    // go through the CLI's `Tree` which assumes that all files are within the project. See:
-    // https://github.com/angular/angular-cli/blob/0b0961c9c233a825b6e4bb59ab7f0790f9b14676/packages/angular_devkit/schematics/src/tree/host-tree.ts#L131
-    return !p.relative(basePath, sourceFile.fileName).startsWith('..');
-}
-
 exports.AST = AST;
 exports.ASTWithSource = ASTWithSource;
 exports.AbsoluteModuleStrategy = AbsoluteModuleStrategy;
@@ -44495,7 +44395,6 @@ exports.CR = CR;
 exports.CUSTOM_ELEMENTS_SCHEMA = CUSTOM_ELEMENTS_SCHEMA;
 exports.Call = Call;
 exports.Chain = Chain;
-exports.ChangeTracker = ChangeTracker;
 exports.CloneVisitor = CloneVisitor;
 exports.CompoundMetadataReader = CompoundMetadataReader;
 exports.Conditional = Conditional;
@@ -44590,7 +44489,6 @@ exports.absoluteFromSourceFile = absoluteFromSourceFile;
 exports.arrowFn = arrowFn;
 exports.asLiteral = asLiteral;
 exports.assertSuccessfulReferenceEmit = assertSuccessfulReferenceEmit;
-exports.canMigrateFile = canMigrateFile;
 exports.combineResolvers = combineResolvers;
 exports.compileComponentFromMetadata = compileComponentFromMetadata;
 exports.compileDeferResolverFunction = compileDeferResolverFunction;
@@ -44611,10 +44509,8 @@ exports.createHostDirectivesMappingArray = createHostDirectivesMappingArray;
 exports.createInjectableType = createInjectableType;
 exports.createInjectorType = createInjectorType;
 exports.createMayBeForwardRefExpression = createMayBeForwardRefExpression;
-exports.createMigrationProgram = createMigrationProgram;
 exports.createNgModuleType = createNgModuleType;
 exports.createPipeType = createPipeType;
-exports.createProgramOptions = createProgramOptions;
 exports.createSourceSpan = createSourceSpan;
 exports.decimalDigest = decimalDigest;
 exports.devOnlyGuardedExpression = devOnlyGuardedExpression;
@@ -44655,6 +44551,7 @@ exports.isFatalDiagnosticError = isFatalDiagnosticError;
 exports.isFileShimSourceFile = isFileShimSourceFile;
 exports.isFromDtsFile = isFromDtsFile;
 exports.isHostDirectiveMetaForGlobalMode = isHostDirectiveMetaForGlobalMode;
+exports.isLocalRelativePath = isLocalRelativePath;
 exports.isNamedClassDeclaration = isNamedClassDeclaration;
 exports.isNonDeclarationTsPath = isNonDeclarationTsPath;
 exports.isShim = isShim;
@@ -44670,7 +44567,6 @@ exports.mapLiteral = mapLiteral;
 exports.ngErrorCode = ngErrorCode;
 exports.nodeDebugInfo = nodeDebugInfo;
 exports.nodeNameForError = nodeNameForError;
-exports.normalizePath = normalizePath;
 exports.parseHostBindings = parseHostBindings;
 exports.parseTemplate = parseTemplate;
 exports.presetImportManagerForceNamespaceImports = presetImportManagerForceNamespaceImports;