@angular/compiler-cli 17.1.0-next.2 → 17.1.0-next.4

package/bundles/{chunk-OYL5JDZA.js → chunk-HQUXRCDO.js}

@@ -36,17 +36,18 @@ import {
   aliasTransformFactory,
   declarationTransformFactory,
   ivyTransformFactory
-} from "./chunk-VOXK3NAL.js";
+} from "./chunk-U4EFDEE4.js";
 import {
   ImportManager,
   TypeEmitter,
   canEmitType,
   translateExpression,
   translateType
-} from "./chunk-6GUXR7F5.js";
+} from "./chunk-MFE4YVWE.js";
 import {
   AbsoluteModuleStrategy,
   AliasStrategy,
+  AmbientImport,
   COMPILER_ERRORS_WITH_GUIDES,
   DefaultImportTracker,
   DeferredSymbolTracker,
@@ -85,7 +86,7 @@ import {
   relativePathBetween,
   replaceTsWithNgInErrors,
   toUnredirectedSourceFile
-} from "./chunk-RLZPCAR3.js";
+} from "./chunk-EFMKZSXJ.js";
 import {
   ActivePerfRecorder,
   DelegatingPerfRecorder,
@@ -1393,6 +1394,12 @@ var ShimReferenceTagger = class {
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/program_driver/src/ts_create_program_driver.mjs
 var DelegatingCompilerHost = class {
+  get jsDocParsingMode() {
+    return this.delegate.jsDocParsingMode;
+  }
+  set jsDocParsingMode(mode) {
+    this.delegate.jsDocParsingMode = mode;
+  }
   constructor(delegate) {
     this.delegate = delegate;
     this.createHash = this.delegateMethod("createHash");
@@ -1418,7 +1425,6 @@ var DelegatingCompilerHost = class {
     this.hasInvalidatedResolutions = this.delegateMethod("hasInvalidatedResolutions");
     this.resolveModuleNameLiterals = this.delegateMethod("resolveModuleNameLiterals");
     this.resolveTypeReferenceDirectiveReferences = this.delegateMethod("resolveTypeReferenceDirectiveReferences");
-    this.jsDocParsingMode = this.delegateMethod("jsDocParsingMode");
   }
   delegateMethod(name) {
     return this.delegate[name] !== void 0 ? this.delegate[name].bind(this.delegate) : void 0;
@@ -1432,10 +1438,10 @@ var UpdatedProgramHost = class extends DelegatingCompilerHost {
     this.shimTagger = new ShimReferenceTagger(this.shimExtensionPrefixes);
     this.sfMap = sfMap;
   }
-  getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile) {
+  getSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) {
     let delegateSf = this.originalProgram.getSourceFile(fileName);
     if (delegateSf === void 0) {
-      delegateSf = this.delegate.getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+      delegateSf = this.delegate.getSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
     }
     if (delegateSf === void 0) {
       return void 0;
@@ -2480,7 +2486,7 @@ var StandaloneComponentScopeReader = class {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/checker.mjs
-import { CssSelector as CssSelector2, DomElementSchemaRegistry as DomElementSchemaRegistry2, ExternalExpr as ExternalExpr2, WrappedNodeExpr } from "@angular/compiler";
+import { CssSelector as CssSelector2, DomElementSchemaRegistry as DomElementSchemaRegistry2, ExternalExpr as ExternalExpr2, WrappedNodeExpr as WrappedNodeExpr2 } from "@angular/compiler";
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/diagnostics/src/diagnostic.mjs
 import ts15 from "typescript";
@@ -2954,9 +2960,39 @@ var RegistryDomSchemaChecker = class {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/environment.mjs
-import { ExpressionType, ExternalExpr, TypeModifier } from "@angular/compiler";
 import ts23 from "typescript";
 
+// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/reference_emit_environment.mjs
+import { ExpressionType, ExternalExpr, TypeModifier } from "@angular/compiler";
+var ReferenceEmitEnvironment = class {
+  constructor(importManager, refEmitter, reflector, contextFile) {
+    this.importManager = importManager;
+    this.refEmitter = refEmitter;
+    this.reflector = reflector;
+    this.contextFile = contextFile;
+  }
+  canReferenceType(ref, flags = ImportFlags.NoAliasing | ImportFlags.AllowTypeImports | ImportFlags.AllowRelativeDtsImports) {
+    const result = this.refEmitter.emit(ref, this.contextFile, flags);
+    return result.kind === 0;
+  }
+  referenceType(ref, flags = ImportFlags.NoAliasing | ImportFlags.AllowTypeImports | ImportFlags.AllowRelativeDtsImports) {
+    const ngExpr = this.refEmitter.emit(ref, this.contextFile, flags);
+    assertSuccessfulReferenceEmit(ngExpr, this.contextFile, "symbol");
+    return translateType(new ExpressionType(ngExpr.expression), this.contextFile, this.reflector, this.refEmitter, this.importManager);
+  }
+  referenceExternalSymbol(moduleName, name) {
+    const external = new ExternalExpr({ moduleName, name });
+    return translateExpression(external, this.importManager);
+  }
+  referenceExternalType(moduleName, name, typeParams) {
+    const external = new ExternalExpr({ moduleName, name });
+    return translateType(new ExpressionType(external, TypeModifier.None, typeParams), this.contextFile, this.reflector, this.refEmitter, this.importManager);
+  }
+  referenceTransplantedType(type) {
+    return translateType(type, this.contextFile, this.reflector, this.refEmitter, this.importManager);
+  }
+};
+
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/ts_util.mjs
 import ts19 from "typescript";
 var SAFE_TO_CAST_WITHOUT_PARENS = /* @__PURE__ */ new Set([
@@ -3043,9 +3079,11 @@ function tsNumericExpression(value) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/type_constructor.mjs
+import { ExpressionType as ExpressionType2, R3Identifiers as R3Identifiers2, WrappedNodeExpr } from "@angular/compiler";
 import ts22 from "typescript";
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/tcb_util.mjs
+import { R3Identifiers } from "@angular/compiler";
 import ts21 from "typescript";
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/type_parameter_emitter.mjs
@@ -3099,13 +3137,13 @@ var TypeParameterEmitter = class {
       return type;
     }
     let owningModule = null;
-    if (declaration.viaModule !== null) {
+    if (typeof declaration.viaModule === "string") {
       owningModule = {
         specifier: declaration.viaModule,
         resolutionContext: type.getSourceFile().fileName
       };
     }
-    return new Reference(declaration.node, owningModule);
+    return new Reference(declaration.node, declaration.viaModule === AmbientImport ? AmbientImport : owningModule);
   }
   translateTypeReference(type, emitReference) {
     const reference = this.resolveTypeReference(type);
@@ -3127,6 +3165,9 @@ var TypeParameterEmitter = class {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/tcb_util.mjs
+var TCB_FILE_IMPORT_GRAPH_PREPARE_MODULES = [
+  R3Identifiers.InputSignalBrandWriteType.moduleName
+];
 var TcbInliningRequirement;
 (function(TcbInliningRequirement2) {
   TcbInliningRequirement2[TcbInliningRequirement2["MustInline"] = 0] = "MustInline";
@@ -3201,16 +3242,21 @@ function getTemplateId2(node, sourceFile, isDiagnosticRequest) {
     return commentText;
   }) || null;
 }
+function ensureTypeCheckFilePreparationImports(env) {
+  for (const moduleName of TCB_FILE_IMPORT_GRAPH_PREPARE_MODULES) {
+    env.importManager.generateNamespaceImport(moduleName);
+  }
+}
 function checkIfGenericTypeBoundsCanBeEmitted(node, reflector, env) {
   const emitter = new TypeParameterEmitter(node.typeParameters, reflector);
   return emitter.canEmit((ref) => env.canReferenceType(ref));
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/type_constructor.mjs
-function generateTypeCtorDeclarationFn(node, meta, nodeTypeRef, typeParams) {
+function generateTypeCtorDeclarationFn(env, meta, nodeTypeRef, typeParams) {
   const rawTypeArgs = typeParams !== void 0 ? generateGenericArgs(typeParams) : void 0;
   const rawType = ts22.factory.createTypeReferenceNode(nodeTypeRef, rawTypeArgs);
-  const initParam = constructTypeCtorParameter(node, meta, rawType);
+  const initParam = constructTypeCtorParameter(env, meta, rawType);
   const typeParameters = typeParametersWithDefaultTypes(typeParams);
   if (meta.body) {
     const fnType = ts22.factory.createFunctionTypeNode(
@@ -3241,10 +3287,10 @@ function generateTypeCtorDeclarationFn(node, meta, nodeTypeRef, typeParams) {
     );
   }
 }
-function generateInlineTypeCtor(node, meta) {
+function generateInlineTypeCtor(env, node, meta) {
   const rawTypeArgs = node.typeParameters !== void 0 ? generateGenericArgs(node.typeParameters) : void 0;
   const rawType = ts22.factory.createTypeReferenceNode(node.name, rawTypeArgs);
-  const initParam = constructTypeCtorParameter(node, meta, rawType);
+  const initParam = constructTypeCtorParameter(env, meta, rawType);
   let body = void 0;
   if (meta.body) {
     body = ts22.factory.createBlock([
@@ -3262,19 +3308,23 @@ function generateInlineTypeCtor(node, meta) {
     body
   );
 }
-function constructTypeCtorParameter(node, meta, rawType) {
+function constructTypeCtorParameter(env, meta, rawType) {
   let initType = null;
   const plainKeys = [];
   const coercedKeys = [];
-  for (const { classPropertyName, transform } of meta.fields.inputs) {
-    if (!meta.coercedInputFields.has(classPropertyName)) {
+  const signalInputKeys = [];
+  for (const { classPropertyName, transform, isSignal } of meta.fields.inputs) {
+    if (isSignal) {
+      signalInputKeys.push(ts22.factory.createLiteralTypeNode(ts22.factory.createStringLiteral(classPropertyName)));
+    } else if (!meta.coercedInputFields.has(classPropertyName)) {
       plainKeys.push(ts22.factory.createLiteralTypeNode(ts22.factory.createStringLiteral(classPropertyName)));
     } else {
+      const coercionType = transform != null ? transform.type.node : tsCreateTypeQueryForCoercedInput(rawType.typeName, classPropertyName);
       coercedKeys.push(ts22.factory.createPropertySignature(
         void 0,
         classPropertyName,
         void 0,
-        transform == null ? tsCreateTypeQueryForCoercedInput(rawType.typeName, classPropertyName) : transform.type.node
+        coercionType
       ));
     }
   }
@@ -3286,6 +3336,14 @@ function constructTypeCtorParameter(node, meta, rawType) {
     const coercedLiteral = ts22.factory.createTypeLiteralNode(coercedKeys);
     initType = initType !== null ? ts22.factory.createIntersectionTypeNode([initType, coercedLiteral]) : coercedLiteral;
   }
+  if (signalInputKeys.length > 0) {
+    const keyTypeUnion = ts22.factory.createUnionTypeNode(signalInputKeys);
+    const unwrapDirectiveSignalInputsExpr = env.referenceExternalType(R3Identifiers2.UnwrapDirectiveSignalInputs.moduleName, R3Identifiers2.UnwrapDirectiveSignalInputs.name, [
+      new ExpressionType2(new WrappedNodeExpr(rawType)),
+      new ExpressionType2(new WrappedNodeExpr(keyTypeUnion))
+    ]);
+    initType = initType !== null ? ts22.factory.createIntersectionTypeNode([initType, unwrapDirectiveSignalInputsExpr]) : unwrapDirectiveSignalInputsExpr;
+  }
   if (initType === null) {
     initType = ts22.factory.createTypeLiteralNode([]);
   }
@@ -3318,13 +3376,10 @@ function typeParametersWithDefaultTypes(params) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/environment.mjs
-var Environment = class {
+var Environment = class extends ReferenceEmitEnvironment {
   constructor(config, importManager, refEmitter, reflector, contextFile) {
+    super(importManager, refEmitter, reflector, contextFile);
     this.config = config;
-    this.importManager = importManager;
-    this.refEmitter = refEmitter;
-    this.reflector = reflector;
-    this.contextFile = contextFile;
     this.nextIds = {
       pipeInst: 1,
       typeCtor: 1
@@ -3361,7 +3416,7 @@ var Environment = class {
         coercedInputFields: dir.coercedInputFields
       };
       const typeParams = this.emitTypeParameters(node);
-      const typeCtor = generateTypeCtorDeclarationFn(node, meta, nodeTypeRef.typeName, typeParams);
+      const typeCtor = generateTypeCtorDeclarationFn(this, meta, nodeTypeRef.typeName, typeParams);
       this.typeCtorStatements.push(typeCtor);
       const fnId = ts23.factory.createIdentifier(fnName);
       this.typeCtors.set(node, fnId);
@@ -3383,26 +3438,10 @@ var Environment = class {
     assertSuccessfulReferenceEmit(ngExpr, this.contextFile, "class");
     return translateExpression(ngExpr.expression, this.importManager);
   }
-  canReferenceType(ref) {
-    const result = this.refEmitter.emit(ref, this.contextFile, ImportFlags.NoAliasing | ImportFlags.AllowTypeImports | ImportFlags.AllowRelativeDtsImports);
-    return result.kind === 0;
-  }
-  referenceType(ref) {
-    const ngExpr = this.refEmitter.emit(ref, this.contextFile, ImportFlags.NoAliasing | ImportFlags.AllowTypeImports | ImportFlags.AllowRelativeDtsImports);
-    assertSuccessfulReferenceEmit(ngExpr, this.contextFile, "symbol");
-    return translateType(new ExpressionType(ngExpr.expression), this.contextFile, this.reflector, this.refEmitter, this.importManager);
-  }
   emitTypeParameters(declaration) {
     const emitter = new TypeParameterEmitter(declaration.typeParameters, this.reflector);
     return emitter.emit((ref) => this.referenceType(ref));
   }
-  referenceExternalType(moduleName, name, typeParams) {
-    const external = new ExternalExpr({ moduleName, name });
-    return translateType(new ExpressionType(external, TypeModifier.None, typeParams), this.contextFile, this.reflector, this.refEmitter, this.importManager);
-  }
-  referenceTransplantedType(type) {
-    return translateType(type, this.contextFile, this.reflector, this.refEmitter, this.importManager);
-  }
   getPreludeStatements() {
     return [
       ...this.pipeInstStatements,
@@ -3558,7 +3597,7 @@ Deferred blocks can only access triggers in same view, a parent embedded view or
     }
     this._diagnostics.push(makeTemplateDiagnostic(templateId, this.resolver.getSourceMapping(templateId), trigger.sourceSpan, ts24.DiagnosticCategory.Error, ngErrorCode(ErrorCode.INACCESSIBLE_DEFERRED_TRIGGER_ELEMENT), message));
   }
-  controlFlowPreventingContentProjection(templateId, projectionNode, componentName, slotSelector, controlFlowNode, preservesWhitespaces) {
+  controlFlowPreventingContentProjection(templateId, category, projectionNode, componentName, slotSelector, controlFlowNode, preservesWhitespaces) {
     const blockName = controlFlowNode instanceof TmplAstIfBlockBranch ? "@if" : "@for";
     const lines = [
       `Node matches the "${slotSelector}" slot of the "${componentName}" component, but will not be projected into the specific slot because the surrounding ${blockName} has more than one node at its root. To project the node in the right slot, you can:
@@ -3568,9 +3607,10 @@ Deferred blocks can only access triggers in same view, a parent embedded view or
       `3. Remove all content from the ${blockName} block, except for the node being projected.`
     ];
     if (preservesWhitespaces) {
-      lines.push(`Note: the host component has \`preserveWhitespaces: true\` which may cause whitespace to affect content projection.`);
+      lines.push("Note: the host component has `preserveWhitespaces: true` which may cause whitespace to affect content projection.");
     }
-    this._diagnostics.push(makeTemplateDiagnostic(templateId, this.resolver.getSourceMapping(templateId), projectionNode.startSourceSpan, ts24.DiagnosticCategory.Warning, ngErrorCode(ErrorCode.CONTROL_FLOW_PREVENTING_CONTENT_PROJECTION), lines.join("\n")));
+    lines.push("", 'This check can be disabled using the `extendedDiagnostics.checks.controlFlowPreventingContentProjection = "suppress" compiler option.`');
+    this._diagnostics.push(makeTemplateDiagnostic(templateId, this.resolver.getSourceMapping(templateId), projectionNode.startSourceSpan, category, ngErrorCode(ErrorCode.CONTROL_FLOW_PREVENTING_CONTENT_PROJECTION), lines.join("\n")));
   }
 };
 function makeInlineDiagnostic(templateId, code, node, messageText, relatedInformation) {
@@ -3600,7 +3640,7 @@ var TypeCheckShimGenerator = class {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/type_check_block.mjs
-import { BindingPipe, Call as Call2, createCssSelectorFromNode, CssSelector, DYNAMIC_TYPE, ImplicitReceiver as ImplicitReceiver4, PropertyRead as PropertyRead4, PropertyWrite as PropertyWrite3, SafeCall, SafePropertyRead as SafePropertyRead3, SelectorMatcher, ThisReceiver, TmplAstBoundAttribute, TmplAstBoundText, TmplAstDeferredBlock, TmplAstElement as TmplAstElement3, TmplAstForLoopBlock, TmplAstIcu, TmplAstIfBlock, TmplAstIfBlockBranch as TmplAstIfBlockBranch2, TmplAstReference as TmplAstReference3, TmplAstSwitchBlock, TmplAstTemplate as TmplAstTemplate2, TmplAstText, TmplAstTextAttribute as TmplAstTextAttribute2, TmplAstVariable as TmplAstVariable2, TransplantedType } from "@angular/compiler";
+import { BindingPipe, Call as Call2, createCssSelectorFromNode, CssSelector, DYNAMIC_TYPE, ImplicitReceiver as ImplicitReceiver4, PropertyRead as PropertyRead4, PropertyWrite as PropertyWrite3, R3Identifiers as R3Identifiers3, SafeCall, SafePropertyRead as SafePropertyRead3, SelectorMatcher, ThisReceiver, TmplAstBoundAttribute, TmplAstBoundText, TmplAstDeferredBlock, TmplAstElement as TmplAstElement3, TmplAstForLoopBlock, TmplAstIcu, TmplAstIfBlock, TmplAstIfBlockBranch as TmplAstIfBlockBranch2, TmplAstReference as TmplAstReference3, TmplAstSwitchBlock, TmplAstTemplate as TmplAstTemplate2, TmplAstText, TmplAstTextAttribute as TmplAstTextAttribute2, TmplAstVariable as TmplAstVariable2, TransplantedType } from "@angular/compiler";
 import ts28 from "typescript";
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/typecheck/src/diagnostics.mjs
@@ -4320,7 +4360,12 @@ var TcbDirectiveCtorOp = class extends TcbOp {
           continue;
         }
         const expression = translateInput(attr.attribute, this.tcb, this.scope);
-        genericInputs.set(fieldName, { type: "binding", field: fieldName, expression, sourceSpan: attr.attribute.sourceSpan });
+        genericInputs.set(fieldName, {
+          type: "binding",
+          field: fieldName,
+          expression,
+          sourceSpan: attr.attribute.sourceSpan
+        });
       }
     }
     for (const { classPropertyName } of this.dir.inputs) {
@@ -4355,7 +4400,7 @@ var TcbDirectiveInputsOp = class extends TcbOp {
     for (const attr of boundAttrs) {
       const expr = widenBinding(translateInput(attr.attribute, this.tcb, this.scope), this.tcb);
       let assignment = wrapForDiagnostics(expr);
-      for (const { fieldName, required, transformType } of attr.inputs) {
+      for (const { fieldName, required, transformType, isSignal } of attr.inputs) {
         let target;
         if (required) {
           seenRequiredInputs.add(fieldName);
@@ -4395,6 +4440,13 @@ var TcbDirectiveInputsOp = class extends TcbOp {
           }
           target = this.dir.stringLiteralInputFields.has(fieldName) ? ts28.factory.createElementAccessExpression(dirId, ts28.factory.createStringLiteral(fieldName)) : ts28.factory.createPropertyAccessExpression(dirId, ts28.factory.createIdentifier(fieldName));
         }
+        if (isSignal) {
+          const inputSignalBrandWriteSymbol = this.tcb.env.referenceExternalSymbol(R3Identifiers3.InputSignalBrandWriteType.moduleName, R3Identifiers3.InputSignalBrandWriteType.name);
+          if (!ts28.isIdentifier(inputSignalBrandWriteSymbol) && !ts28.isPropertyAccessExpression(inputSignalBrandWriteSymbol)) {
+            throw new Error(`Expected identifier or property access for reference to ${R3Identifiers3.InputSignalBrandWriteType.name}`);
+          }
+          target = ts28.factory.createElementAccessExpression(target, inputSignalBrandWriteSymbol);
+        }
         if (attr.attribute.keySpan !== void 0) {
           addParseSpanInfo(target, attr.attribute.keySpan);
         }
@@ -4478,6 +4530,7 @@ var TcbControlFlowContentProjectionOp = class extends TcbOp {
     this.ngContentSelectors = ngContentSelectors;
     this.componentName = componentName;
     this.optional = false;
+    this.category = tcb.env.config.controlFlowPreventingContentProjection === "error" ? ts28.DiagnosticCategory.Error : ts28.DiagnosticCategory.Warning;
   }
   execute() {
     const controlFlowToCheck = this.findPotentialControlFlowNodes();
@@ -4492,7 +4545,7 @@ var TcbControlFlowContentProjectionOp = class extends TcbOp {
         for (const child of root.children) {
           if (child instanceof TmplAstElement3 || child instanceof TmplAstTemplate2) {
             matcher.match(createCssSelectorFromNode(child), (_, originalSelector) => {
-              this.tcb.oobRecorder.controlFlowPreventingContentProjection(this.tcb.id, child, this.componentName, originalSelector, root, this.tcb.hostPreserveWhitespaces);
+              this.tcb.oobRecorder.controlFlowPreventingContentProjection(this.tcb.id, this.category, child, this.componentName, originalSelector, root, this.tcb.hostPreserveWhitespaces);
             });
           }
         }
@@ -4706,9 +4759,7 @@ var TcbBlockImplicitVariableOp = class extends TcbOp {
     this.scope = scope;
     this.type = type;
     this.variable = variable;
-  }
-  get optional() {
-    return false;
+    this.optional = true;
   }
   execute() {
     const id = this.tcb.allocateId();
@@ -4844,7 +4895,11 @@ var TcbForOfOp = class extends TcbOp {
   }
   execute() {
     const loopScope = Scope.forNodes(this.tcb, this.scope, this.block, this.block.children, null);
-    const initializer = ts28.factory.createVariableDeclarationList([ts28.factory.createVariableDeclaration(this.block.item.name)], ts28.NodeFlags.Const);
+    const initializerId = loopScope.resolve(this.block.item);
+    if (!ts28.isIdentifier(initializerId)) {
+      throw new Error(`Could not resolve for loop variable ${this.block.item.name} to an identifier`);
+    }
+    const initializer = ts28.factory.createVariableDeclarationList([ts28.factory.createVariableDeclaration(initializerId)], ts28.NodeFlags.Const);
     const expression = ts28.factory.createNonNullExpression(tcbExpression(this.block.expression, this.tcb, loopScope));
     const trackTranslator = new TcbForLoopTrackTranslator(this.tcb, loopScope, this.block);
     const trackExpression = trackTranslator.translate(this.block.trackBy);
@@ -4915,7 +4970,9 @@ var _Scope = class {
         this.registerVariable(scope, expressionAlias, new TcbBlockVariableOp(tcb, scope, tcbExpression(expression, tcb, scope), expressionAlias));
       }
     } else if (scopedNode instanceof TmplAstForLoopBlock) {
-      this.registerVariable(scope, scopedNode.item, new TcbBlockVariableOp(tcb, scope, ts28.factory.createIdentifier(scopedNode.item.name), scopedNode.item));
+      const loopInitializer = tcb.allocateId();
+      addParseSpanInfo(loopInitializer, scopedNode.item.sourceSpan);
+      scope.varMap.set(scopedNode.item, loopInitializer);
       for (const [name, variable] of Object.entries(scopedNode.contextVariables)) {
         if (!this.forLoopContextVariableTypes.has(name)) {
           throw new Error(`Unrecognized for loop context variable ${name}`);
@@ -4980,7 +5037,8 @@ var _Scope = class {
     if (ref instanceof TmplAstReference3 && this.referenceOpMap.has(ref)) {
       return this.resolveOp(this.referenceOpMap.get(ref));
     } else if (ref instanceof TmplAstVariable2 && this.varMap.has(ref)) {
-      return this.resolveOp(this.varMap.get(ref));
+      const opIndexOrNode = this.varMap.get(ref);
+      return typeof opIndexOrNode === "number" ? this.resolveOp(opIndexOrNode) : opIndexOrNode;
     } else if (ref instanceof TmplAstTemplate2 && directive === void 0 && this.templateCtxOpMap.has(ref)) {
       return this.resolveOp(this.templateCtxOpMap.get(ref));
     } else if ((ref instanceof TmplAstElement3 || ref instanceof TmplAstTemplate2) && directive !== void 0 && this.directiveOpMap.has(ref)) {
@@ -5020,7 +5078,9 @@ var _Scope = class {
     if (node instanceof TmplAstElement3) {
       const opIndex = this.opQueue.push(new TcbElementOp(this.tcb, this, node)) - 1;
       this.elementOpMap.set(node, opIndex);
-      this.appendContentProjectionCheckOp(node);
+      if (this.tcb.env.config.controlFlowPreventingContentProjection !== "suppress") {
+        this.appendContentProjectionCheckOp(node);
+      }
       this.appendDirectivesAndInputsOfNode(node);
       this.appendOutputsOfNode(node);
       this.appendChildren(node);
@@ -5344,7 +5404,8 @@ function getBoundAttributes(directive, node) {
           return {
             fieldName: input.classPropertyName,
             required: input.required,
-            transformType: ((_a = input.transform) == null ? void 0 : _a.type) || null
+            transformType: ((_a = input.transform) == null ? void 0 : _a.type) || null,
+            isSignal: input.isSignal
           };
         })
       });
@@ -5474,6 +5535,7 @@ var TypeCheckFile = class extends Environment {
     this.tcbStatements.push(fn);
   }
   render(removeComments) {
+    ensureTypeCheckFilePreparationImports(this);
     let source = this.importManager.getAllImports(this.contextFile.fileName).map((i) => `import * as ${i.qualifier.text} from '${i.specifier}';`).join("\n") + "\n\n";
     const printer = ts29.createPrinter({ removeComments });
     source += "\n";
@@ -5591,7 +5653,7 @@ var TypeCheckContextImpl = class {
       this.opMap.set(sf, []);
     }
     const ops = this.opMap.get(sf);
-    ops.push(new TypeCtorOp(ref, ctorMeta));
+    ops.push(new TypeCtorOp(ref, this.reflector, ctorMeta));
     fileData.hasInlines = true;
   }
   transform(sf) {
@@ -5706,15 +5768,17 @@ var InlineTcbOp = class {
   }
 };
 var TypeCtorOp = class {
-  constructor(ref, meta) {
+  constructor(ref, reflector, meta) {
     this.ref = ref;
+    this.reflector = reflector;
     this.meta = meta;
   }
   get splitPoint() {
     return this.ref.node.end - 1;
   }
   execute(im, sf, refEmitter, printer) {
-    const tcb = generateInlineTypeCtor(this.ref.node, this.meta);
+    const emitEnv = new ReferenceEmitEnvironment(im, refEmitter, this.reflector, sf);
+    const tcb = generateInlineTypeCtor(emitEnv, this.ref.node, this.meta);
     return printer.printNode(ts30.EmitHint.Unspecified, tcb, sf);
   }
 };
@@ -6809,7 +6873,7 @@ var TemplateTypeCheckerImpl = class {
       return null;
     }
     const emitted = emittedRef.expression;
-    if (emitted instanceof WrappedNodeExpr) {
+    if (emitted instanceof WrappedNodeExpr2) {
       if (refTo.node === inContext) {
         return null;
       }
@@ -7504,6 +7568,10 @@ var ALL_DIAGNOSTIC_FACTORIES = [
   factory7,
   factory
 ];
+var SUPPORTED_DIAGNOSTIC_NAMES = /* @__PURE__ */ new Set([
+  ExtendedTemplateDiagnosticName.CONTROL_FLOW_PREVENTING_CONTENT_PROJECTION,
+  ...ALL_DIAGNOSTIC_FACTORIES.map((factory9) => factory9.name)
+]);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/core/src/compiler.mjs
 var CompilationTicketKind;
@@ -7839,6 +7907,7 @@ var NgCompiler = class {
     return strictTemplates || !!this.options.fullTemplateTypeCheck;
   }
   getTypeCheckingConfig() {
+    var _a, _b, _c, _d;
     const strictTemplates = !!this.options.strictTemplates;
     const useInlineTypeConstructors = this.programDriver.supportsInlineOperations;
     let typeCheckingConfig;
@@ -7864,7 +7933,8 @@ var NgCompiler = class {
         strictLiteralTypes: true,
         enableTemplateTypeChecker: this.enableTemplateTypeChecker,
         useInlineTypeConstructors,
-        suggestionsForSuboptimalTypeInference: this.enableTemplateTypeChecker && !strictTemplates
+        suggestionsForSuboptimalTypeInference: this.enableTemplateTypeChecker && !strictTemplates,
+        controlFlowPreventingContentProjection: ((_a = this.options.extendedDiagnostics) == null ? void 0 : _a.defaultCategory) || DiagnosticCategoryLabel.Warning
       };
     } else {
       typeCheckingConfig = {
@@ -7888,7 +7958,8 @@ var NgCompiler = class {
         strictLiteralTypes: false,
         enableTemplateTypeChecker: this.enableTemplateTypeChecker,
         useInlineTypeConstructors,
-        suggestionsForSuboptimalTypeInference: false
+        suggestionsForSuboptimalTypeInference: false,
+        controlFlowPreventingContentProjection: ((_b = this.options.extendedDiagnostics) == null ? void 0 : _b.defaultCategory) || DiagnosticCategoryLabel.Warning
       };
     }
     if (this.options.strictInputTypes !== void 0) {
@@ -7923,6 +7994,9 @@ var NgCompiler = class {
     if (this.options.strictLiteralTypes !== void 0) {
       typeCheckingConfig.strictLiteralTypes = this.options.strictLiteralTypes;
     }
+    if (((_d = (_c = this.options.extendedDiagnostics) == null ? void 0 : _c.checks) == null ? void 0 : _d.controlFlowPreventingContentProjection) !== void 0) {
+      typeCheckingConfig.controlFlowPreventingContentProjection = this.options.extendedDiagnostics.checks.controlFlowPreventingContentProjection;
+    }
     return typeCheckingConfig;
   }
   getTemplateDiagnostics() {
@@ -8181,9 +8255,8 @@ ${allowedCategoryLabels.join("\n")}
       `.trim()
     });
   }
-  const allExtendedDiagnosticNames = ALL_DIAGNOSTIC_FACTORIES.map((factory9) => factory9.name);
   for (const [checkName, category] of Object.entries((_c = (_b = options.extendedDiagnostics) == null ? void 0 : _b.checks) != null ? _c : {})) {
-    if (!allExtendedDiagnosticNames.includes(checkName)) {
+    if (!SUPPORTED_DIAGNOSTIC_NAMES.has(checkName)) {
       yield makeConfigDiagnostic({
         category: ts35.DiagnosticCategory.Error,
         code: ErrorCode.CONFIG_EXTENDED_DIAGNOSTICS_UNKNOWN_CHECK,
@@ -8191,7 +8264,7 @@ ${allowedCategoryLabels.join("\n")}
 Angular compiler option "extendedDiagnostics.checks" has an unknown check: "${checkName}".
 
 Allowed check names are:
-${allExtendedDiagnosticNames.join("\n")}
+${Array.from(SUPPORTED_DIAGNOSTIC_NAMES).join("\n")}
         `.trim()
       });
     }
@@ -8866,4 +8939,4 @@ export {
  * 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
  */
-//# sourceMappingURL=chunk-OYL5JDZA.js.map
+//# sourceMappingURL=chunk-HQUXRCDO.js.map