@analogjs/vite-plugin-angular 3.0.0-alpha.34 → 3.0.0-alpha.36

package/README.md

@@ -89,3 +89,9 @@ Create a `tsconfig.app.json` in the root of the project.
   "include": ["src/**/*.ts"]
 }
 ```
+
+## Tailwind CSS v4
+
+For Angular component styles that use Tailwind utilities like `@apply`, configure `tailwindCss.rootStylesheet` and follow the Tailwind guide for Analog:
+
+- https://analogjs.org/docs/integrations/tailwind

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@analogjs/vite-plugin-angular",
-  "version": "3.0.0-alpha.34",
+  "version": "3.0.0-alpha.36",
   "description": "Vite Plugin for Angular",
   "type": "module",
   "keywords": [
@@ -36,7 +36,7 @@
     }
   },
   "dependencies": {
-    "@analogjs/angular-compiler": "3.0.0-alpha.34",
+    "@analogjs/angular-compiler": "3.0.0-alpha.36",
     "es-toolkit": "^1.45.1",
     "obug": "^2.1.1",
     "oxc-parser": "^0.124.0",

package/src/lib/angular-vite-plugin.d.ts

@@ -32,14 +32,14 @@ export interface PluginOptions {
 	include?: string[];
 	additionalContentDirs?: string[];
 	/**
-	* Enables Angular's HMR during development/watch mode.
+	* Enables Analog's Angular live-reload/HMR pipeline during development/watch mode.
 	*
-	* Defaults to `true` for watch mode. Set to `false` to disable HMR while
-	* keeping other stylesheet externalization behavior available when needed.
-	*/
-	hmr?: boolean;
-	/**
-	* @deprecated Use `hmr` instead. Kept as a compatibility alias.
+	* This is separate from Vite's `server.hmr` option, which configures the
+	* HMR client transport.
+	*
+	* Defaults to `true` for watch mode. Set to `false` to disable Angular
+	* reload updates while keeping other stylesheet externalization behavior
+	* available when needed.
 	*/
 	liveReload?: boolean;
 	disableTypeChecking?: boolean;

package/src/lib/angular-vite-plugin.js

@@ -1,7 +1,7 @@
 import { angularFullVersion, cjt, createAngularCompilation, sourceFileCache } from "./utils/devkit.js";
 import { getJsTransformConfigKey, isRolldown } from "./utils/rolldown.js";
 import { buildOptimizerPlugin } from "./angular-build-optimizer-plugin.js";
-import { activateDeferredDebug, applyDebugOption, debugCompilationApi, debugCompiler, debugCompilerV, debugHmr, debugHmrV, debugStyles, debugStylesV, debugTailwind, debugTailwindV } from "./utils/debug.js";
+import { activateDeferredDebug, applyDebugOption, debugCompilationApi, debugCompiler, debugCompilerV, debugEmit, debugEmitV, debugHmr, debugHmrV, debugStyles, debugStylesV, debugTailwind, debugTailwindV } from "./utils/debug.js";
 import { inspectCssTailwindDirectives, isTailwindReferenceError, throwTailwindReferenceTextError } from "./utils/tailwind-reference.js";
 import { jitPlugin } from "./angular-jit-plugin.js";
 import { createCompilerPlugin, createRolldownCompilerPlugin } from "./compiler-plugin.js";
@@ -113,6 +113,7 @@ function buildStylePreprocessor(options) {
 }
 function angular(options) {
 	applyDebugOption(options?.debug, options?.workspaceRoot);
+	const liveReload = options?.liveReload ?? true;
 	/**
 	* Normalize plugin options so defaults
 	* are used for values not provided.
@@ -130,7 +131,7 @@ function angular(options) {
 		jit: options?.jit,
 		include: options?.include ?? [],
 		additionalContentDirs: options?.additionalContentDirs ?? [],
-		hmr: options?.hmr ?? options?.liveReload ?? true,
+		liveReload,
 		disableTypeChecking: options?.disableTypeChecking ?? true,
 		fileReplacements: options?.fileReplacements ?? [],
 		useAngularCompilationAPI: options?.experimental?.useAngularCompilationAPI ?? false,
@@ -144,6 +145,7 @@ function angular(options) {
 	let builder;
 	let nextProgram;
 	const tsconfigOptionsCache = /* @__PURE__ */ new Map();
+	const tsconfigGraphRootCache = /* @__PURE__ */ new Map();
 	let cachedHost;
 	let cachedHostKey;
 	let includeCache = [];
@@ -152,6 +154,7 @@ function angular(options) {
 	}
 	function invalidateTsconfigCaches() {
 		tsconfigOptionsCache.clear();
+		tsconfigGraphRootCache.clear();
 		cachedHost = void 0;
 		cachedHostKey = void 0;
 	}
@@ -162,8 +165,11 @@ function angular(options) {
 	const classNameOwners = /* @__PURE__ */ new Map();
 	const transformedStyleOwnerMetadata = /* @__PURE__ */ new Map();
 	const styleSourceOwners = /* @__PURE__ */ new Map();
-	function shouldEnableHmr() {
-		return !!((isTest ? testWatchMode : watchMode) && pluginOptions.hmr);
+	function hasViteHmrTransport() {
+		return resolvedConfig ? resolvedConfig.server.hmr !== false : true;
+	}
+	function shouldEnableLiveReload() {
+		return !!((isTest ? testWatchMode : watchMode) && pluginOptions.liveReload && hasViteHmrTransport());
 	}
 	/**
 	* Determines whether Angular should externalize component styles.
@@ -183,7 +189,7 @@ function angular(options) {
 	*/
 	function shouldExternalizeStyles() {
 		if (!(isTest ? testWatchMode : watchMode)) return false;
-		return !!(shouldEnableHmr() || pluginOptions.hasTailwindCss);
+		return !!(shouldEnableLiveReload() || pluginOptions.hasTailwindCss);
 	}
 	/**
 	* Validates the Tailwind CSS integration configuration and emits actionable
@@ -321,9 +327,36 @@ function angular(options) {
 	const templateUrlsResolver = new TemplateUrlsResolver();
 	let outputFile;
 	const outputFiles = /* @__PURE__ */ new Map();
+	const normalizeEmitterLookupId = (file) => {
+		const normalizedFile = normalizePath(file);
+		if (!normalizedFile.startsWith("/@fs/")) return normalizedFile;
+		return normalizePath(normalizedFile.slice(4).replace(/^\/([A-Za-z]:\/)/, "$1"));
+	};
+	const describeEmitMarkers = (content) => ({
+		contentLength: content.length,
+		hasCmp: content.includes("ɵcmp"),
+		hasFac: content.includes("ɵfac"),
+		hasProv: content.includes("ɵprov"),
+		hasDecorate: content.includes("__decorate"),
+		hasMetadata: content.includes("__metadata")
+	});
 	const fileEmitter = (file) => {
-		outputFile?.(file);
-		return outputFiles.get(normalizePath(file));
+		const normalizedFile = normalizeEmitterLookupId(file);
+		const hadCachedEmit = outputFiles.has(normalizedFile);
+		outputFile?.(normalizedFile);
+		const emittedResult = outputFiles.get(normalizedFile);
+		debugEmitV("fileEmitter lookup", {
+			requestFile: file,
+			normalizedFile,
+			hadCachedEmit,
+			hasOutputFileHook: !!outputFile,
+			emitted: !!emittedResult,
+			knownOutputCount: outputFiles.size,
+			contentLength: emittedResult?.content?.length ?? 0,
+			errorCount: emittedResult?.errors?.length ?? 0,
+			warningCount: emittedResult?.warnings?.length ?? 0
+		});
+		return emittedResult;
 	};
 	let initialCompilation = false;
 	const declarationFiles = [];
@@ -334,16 +367,16 @@ function angular(options) {
 	let angularCompilation;
 	function angularPlugin() {
 		let isProd = false;
-		if (angularFullVersion < 19e4 && pluginOptions.hmr) {
+		if (angularFullVersion < 19e4 && pluginOptions.liveReload) {
 			debugHmr("hmr disabled: Angular version does not support HMR APIs", {
 				angularVersion: angularFullVersion,
 				isTest
 			});
 			console.warn("[@analogjs/vite-plugin-angular]: HMR was disabled because Angular v19+ is required for externalRuntimeStyles/_enableHmr support. Detected Angular version: %s.", angularFullVersion);
-			pluginOptions.hmr = false;
+			pluginOptions.liveReload = false;
 		}
 		if (isTest) {
-			pluginOptions.hmr = false;
+			pluginOptions.liveReload = false;
 			debugHmr("hmr disabled", {
 				angularVersion: angularFullVersion,
 				isTest
@@ -456,7 +489,7 @@ function angular(options) {
 					});
 					pendingCompilation = performCompilation(resolvedConfig, [fileId]);
 					let result;
-					if (shouldEnableHmr()) {
+					if (shouldEnableLiveReload()) {
 						await pendingCompilation;
 						pendingCompilation = null;
 						result = fileEmitter(fileId);
@@ -478,7 +511,7 @@ function angular(options) {
 							hint: result?.hmrEligible ? "A TS-side component change, including inline template edits, produced an Angular HMR payload." : "No Angular HMR payload was emitted for this TS change; the change may not affect component template state."
 						});
 					}
-					if (shouldEnableHmr() && result?.hmrEligible && classNames.get(fileId)) {
+					if (shouldEnableLiveReload() && result?.hmrEligible && classNames.get(fileId)) {
 						const relativeFileId = `${normalizePath(relative(process.cwd(), fileId))}@${classNames.get(fileId)}`;
 						debugHmr("sending component update", { relativeFileId });
 						debugHmrV("ts hmr component update payload", {
@@ -659,7 +692,7 @@ function angular(options) {
 						}
 						return fileModules;
 					}
-					if (shouldEnableHmr() && /\.(html|htm)$/.test(ctx.file) && fileModules.length === 0) {
+					if (shouldEnableLiveReload() && /\.(html|htm)$/.test(ctx.file) && fileModules.length === 0) {
 						const ownerModules = findTemplateOwnerModules(ctx.server, ctx.file);
 						debugHmrV("template owner lookup", {
 							file: ctx.file,
@@ -886,12 +919,27 @@ function angular(options) {
 					const typescriptResult = fileEmitter(id);
 					if (!typescriptResult) {
 						debugCompilerV("transform skip (file not emitted by Angular)", { id });
-						if (!id.includes("@ng/component") && /(Component|Directive|Pipe|Injectable|NgModule)\(/.test(code)) this.warn(`[@analogjs/vite-plugin-angular]: "${id}" contains Angular decorators but is not in the TypeScript program. Ensure it is included in your tsconfig.`);
+						const isAngular = !id.includes("@ng/component") && /(Component|Directive|Pipe|Injectable|NgModule)\(/.test(code);
+						debugEmit("transform emit miss", {
+							id,
+							normalizedId: normalizeEmitterLookupId(id),
+							knownOutputCount: outputFiles.size,
+							hasOutputFileHook: !!outputFile,
+							isAngular
+						});
+						if (isAngular) this.warn(`[@analogjs/vite-plugin-angular]: "${id}" contains Angular decorators but is not in the TypeScript program. Ensure it is included in your tsconfig.`);
 						return;
 					}
 					if (typescriptResult.warnings && typescriptResult.warnings.length > 0) this.warn(`${typescriptResult.warnings.join("\n")}`);
 					if (typescriptResult.errors && typescriptResult.errors.length > 0) this.error(`${typescriptResult.errors.join("\n")}`);
 					let data = typescriptResult.content ?? "";
+					debugEmitV("transform emit hit", {
+						id,
+						normalizedId: normalizeEmitterLookupId(id),
+						...describeEmitMarkers(data),
+						errorCount: typescriptResult.errors?.length ?? 0,
+						warningCount: typescriptResult.warnings?.length ?? 0
+					});
 					if (jit && data.includes("angular:jit:")) {
 						data = data.replace(/angular:jit:style:inline;/g, "virtual:angular:jit:style:inline;");
 						templateUrls.forEach((templateUrlSet) => {
@@ -1045,7 +1093,7 @@ function angular(options) {
 			}
 		},
 		angularPlugin(),
-		pluginOptions.hmr && liveReloadPlugin({
+		pluginOptions.liveReload && liveReloadPlugin({
 			classNames,
 			fileEmitter
 		}),
@@ -1060,13 +1108,26 @@ function angular(options) {
 		nxFolderPlugin()
 	].filter(Boolean);
 	function findIncludes() {
-		return globSync(pluginOptions.include.map((glob) => normalizeIncludeGlob(pluginOptions.workspaceRoot, glob)), {
+		const globs = pluginOptions.include.map((glob) => normalizeIncludeGlob(pluginOptions.workspaceRoot, glob));
+		const files = globSync(globs, {
 			dot: true,
 			absolute: true
 		});
+		debugEmit("include discovery", {
+			patternCount: globs.length,
+			fileCount: files.length
+		});
+		debugEmitV("include discovery files", {
+			globs,
+			files: files.map((file) => normalizePath(file))
+		});
+		return files;
 	}
 	function ensureIncludeCache() {
-		if (pluginOptions.include.length > 0 && includeCache.length === 0) includeCache = findIncludes();
+		if (pluginOptions.include.length > 0 && includeCache.length === 0) {
+			includeCache = findIncludes();
+			debugEmit("include cache populated", { fileCount: includeCache.length });
+		}
 		return includeCache;
 	}
 	function getTsconfigCacheKey(resolvedTsConfigPath, config) {
@@ -1075,45 +1136,128 @@ function angular(options) {
 			config.mode === "production" ? "prod" : "dev",
 			isTest ? "test" : "app",
 			config.build?.lib ? "lib" : "nolib",
-			pluginOptions.hmr ? "hmr" : "nohmr",
+			pluginOptions.liveReload ? "live-reload" : "no-live-reload",
 			pluginOptions.hasTailwindCss ? "tw" : "notw"
 		].join("|");
 	}
-	function getCachedTsconfigOptions(resolvedTsConfigPath, config) {
+	function readAngularTsconfigConfiguration(resolvedTsConfigPath, config) {
 		const isProd = config.mode === "production";
+		return compilerCli.readConfiguration(resolvedTsConfigPath, {
+			suppressOutputPathCheck: true,
+			outDir: void 0,
+			sourceMap: false,
+			inlineSourceMap: !isProd,
+			inlineSources: !isProd,
+			declaration: false,
+			declarationMap: false,
+			allowEmptyCodegenFiles: false,
+			annotationsAs: "decorators",
+			enableResourceInlining: false,
+			noEmitOnError: false,
+			mapRoot: void 0,
+			sourceRoot: void 0,
+			supportTestBed: false,
+			supportJitMode: false
+		});
+	}
+	function getCachedTsconfigOptions(resolvedTsConfigPath, config) {
 		const tsconfigKey = getTsconfigCacheKey(resolvedTsConfigPath, config);
 		let cached = tsconfigOptionsCache.get(tsconfigKey);
 		if (!cached) {
-			const read = compilerCli.readConfiguration(resolvedTsConfigPath, {
-				suppressOutputPathCheck: true,
-				outDir: void 0,
-				sourceMap: false,
-				inlineSourceMap: !isProd,
-				inlineSources: !isProd,
-				declaration: false,
-				declarationMap: false,
-				allowEmptyCodegenFiles: false,
-				annotationsAs: "decorators",
-				enableResourceInlining: false,
-				noEmitOnError: false,
-				mapRoot: void 0,
-				sourceRoot: void 0,
-				supportTestBed: false,
-				supportJitMode: false
-			});
+			const read = readAngularTsconfigConfiguration(resolvedTsConfigPath, config);
 			cached = {
 				options: read.options,
 				rootNames: read.rootNames
 			};
 			tsconfigOptionsCache.set(tsconfigKey, cached);
+			debugEmit("tsconfig root names loaded", {
+				resolvedTsConfigPath,
+				rootNameCount: read.rootNames.length
+			});
+			debugEmitV("tsconfig root names", {
+				resolvedTsConfigPath,
+				rootNames: read.rootNames.map((file) => normalizePath(file))
+			});
 		}
 		return cached;
 	}
+	function resolveReferenceTsconfigPath(referencePath, ownerTsconfigPath) {
+		const ownerDir = dirname(ownerTsconfigPath);
+		const resolvedReference = normalizePath(isAbsolute(referencePath) ? referencePath : resolve(ownerDir, referencePath));
+		if (existsSync(resolvedReference)) {
+			try {
+				if (statSync(resolvedReference).isDirectory()) {
+					const nestedTsconfig = join(resolvedReference, "tsconfig.json");
+					return existsSync(nestedTsconfig) ? normalizePath(nestedTsconfig) : void 0;
+				}
+			} catch {
+				return;
+			}
+			return resolvedReference;
+		}
+		if (!resolvedReference.endsWith(".json")) {
+			const asJson = `${resolvedReference}.json`;
+			if (existsSync(asJson)) return normalizePath(asJson);
+			const nestedTsconfig = join(resolvedReference, "tsconfig.json");
+			if (existsSync(nestedTsconfig)) return normalizePath(nestedTsconfig);
+		}
+	}
+	function collectTsconfigPathRoots(resolvedTsConfigPath, options, rawTsconfig) {
+		const tsPaths = rawTsconfig.compilerOptions?.paths ?? options.paths;
+		if (!tsPaths) return [];
+		const tsconfigDir = dirname(resolvedTsConfigPath);
+		const configuredBaseUrl = typeof options.baseUrl === "string" ? options.baseUrl : typeof rawTsconfig.compilerOptions?.baseUrl === "string" ? rawTsconfig.compilerOptions.baseUrl : void 0;
+		const resolvedBaseUrl = configuredBaseUrl ? isAbsolute(configuredBaseUrl) ? configuredBaseUrl : resolve(tsconfigDir, configuredBaseUrl) : tsconfigDir;
+		const discoveredRoots = /* @__PURE__ */ new Set();
+		for (const targets of Object.values(tsPaths)) for (const target of targets) {
+			const resolvedTarget = normalizePath(isAbsolute(target) ? target : resolve(resolvedBaseUrl, target));
+			if (target.includes("*")) {
+				for (const match of globSync(resolvedTarget, {
+					dot: true,
+					absolute: true
+				})) discoveredRoots.add(normalizePath(match));
+				continue;
+			}
+			if (existsSync(resolvedTarget)) discoveredRoots.add(resolvedTarget);
+		}
+		return [...discoveredRoots];
+	}
+	function collectExpandedTsconfigRoots(resolvedTsConfigPath, config, visited = /* @__PURE__ */ new Set()) {
+		const normalizedTsConfigPath = normalizePath(resolvedTsConfigPath);
+		if (visited.has(normalizedTsConfigPath)) return [];
+		const tsconfigKey = `${getTsconfigCacheKey(normalizedTsConfigPath, config)}|graph`;
+		const cached = tsconfigGraphRootCache.get(tsconfigKey);
+		if (cached) return cached;
+		visited.add(normalizedTsConfigPath);
+		const read = readAngularTsconfigConfiguration(normalizedTsConfigPath, config);
+		const rawTsconfig = ts.readConfigFile(normalizedTsConfigPath, ts.sys.readFile).config ?? {};
+		const expandedRoots = new Set(read.rootNames.map((file) => normalizePath(file)));
+		const pathRoots = collectTsconfigPathRoots(normalizedTsConfigPath, read.options, rawTsconfig);
+		for (const pathRoot of pathRoots) expandedRoots.add(pathRoot);
+		const referenceConfigs = (rawTsconfig.references ?? []).flatMap((reference) => typeof reference.path === "string" ? [resolveReferenceTsconfigPath(reference.path, normalizedTsConfigPath)] : []).filter((reference) => !!reference);
+		for (const referenceConfig of referenceConfigs) for (const referenceRoot of collectExpandedTsconfigRoots(referenceConfig, config, visited)) expandedRoots.add(referenceRoot);
+		const expandedRootList = [...expandedRoots];
+		tsconfigGraphRootCache.set(tsconfigKey, expandedRootList);
+		debugEmit("expanded tsconfig graph roots", {
+			resolvedTsConfigPath: normalizedTsConfigPath,
+			directRootNameCount: read.rootNames.length,
+			pathRootCount: pathRoots.length,
+			referenceConfigCount: referenceConfigs.length,
+			expandedRootCount: expandedRootList.length
+		});
+		debugEmitV("expanded tsconfig graph root files", {
+			resolvedTsConfigPath: normalizedTsConfigPath,
+			pathRoots,
+			referenceConfigs,
+			rootNames: expandedRootList
+		});
+		return expandedRootList;
+	}
 	function resolveCompilationApiTsConfigPath(resolvedTsConfigPath, config) {
 		const includedFiles = ensureIncludeCache();
-		if (includedFiles.length === 0) return resolvedTsConfigPath;
 		const cached = getCachedTsconfigOptions(resolvedTsConfigPath, config);
-		const mergedRootNames = union(cached.rootNames, includedFiles).map((file) => normalizePath(file));
+		const expandedGraphRoots = collectExpandedTsconfigRoots(resolvedTsConfigPath, config);
+		const mergedRootNames = union(cached.rootNames, expandedGraphRoots, includedFiles).map((file) => normalizePath(file));
 		if (mergedRootNames.length === cached.rootNames.length) return resolvedTsConfigPath;
 		const wrapperDir = join(isAbsolute(config.cacheDir) ? config.cacheDir : resolve(config.root, config.cacheDir), "analog-angular", "compilation-api");
 		const rawTsconfig = ts.readConfigFile(resolvedTsConfigPath, ts.sys.readFile).config ?? {};
@@ -1131,6 +1275,19 @@ function angular(options) {
 			includeCount: includedFiles.length,
 			rootNameCount: mergedRootNames.length
 		});
+		debugEmit("wrapper tsconfig root merge", {
+			originalTsconfig: resolvedTsConfigPath,
+			wrapperTsconfig: wrapperPath,
+			baseRootNameCount: cached.rootNames.length,
+			expandedGraphRootCount: expandedGraphRoots.length,
+			includeCount: includedFiles.length,
+			mergedRootNameCount: mergedRootNames.length,
+			referenceCount: rawTsconfig.references?.length ?? 0
+		});
+		debugEmitV("wrapper tsconfig root names", {
+			wrapperTsconfig: wrapperPath,
+			rootNames: mergedRootNames
+		});
 		return wrapperPath;
 	}
 	function resolveTsConfigPath() {
@@ -1153,15 +1310,21 @@ function angular(options) {
 	*     file-level HMR metadata (`hmrUpdateCode`, `hmrEligible`, `classNames`).
 	*/
 	async function performAngularCompilation(config, ids) {
-		angularCompilation ??= await createAngularCompilation(!!pluginOptions.jit, false);
+		const compilation = angularCompilation ??= await createAngularCompilation(!!pluginOptions.jit, false);
 		const modifiedFiles = ids?.length ? new Set(ids.map((file) => normalizePath(file))) : void 0;
 		if (modifiedFiles?.size) sourceFileCache$1.invalidate(modifiedFiles);
-		if (modifiedFiles?.size && angularCompilation.update) {
+		if (modifiedFiles?.size && compilation.update) {
 			debugCompilationApi("incremental update", { files: [...modifiedFiles] });
-			await angularCompilation.update(modifiedFiles);
+			await compilation.update(modifiedFiles);
 		}
-		const compilationApiTsConfigPath = resolveCompilationApiTsConfigPath(resolveTsConfigPath(), config);
-		const compilationResult = await angularCompilation.initialize(compilationApiTsConfigPath, {
+		const resolvedTsConfigPath = resolveTsConfigPath();
+		const compilationApiTsConfigPath = resolveCompilationApiTsConfigPath(resolvedTsConfigPath, config);
+		debugEmit("compilation initialize", {
+			resolvedTsConfigPath,
+			compilationApiTsConfigPath,
+			modifiedFileCount: modifiedFiles?.size ?? 0
+		});
+		const compilationResult = await compilation.initialize(compilationApiTsConfigPath, {
 			fileReplacements: toAngularCompilationFileReplacements(pluginOptions.fileReplacements, pluginOptions.workspaceRoot),
 			modifiedFiles,
 			async transformStylesheet(data, containingFile, resourceFile, order, className) {
@@ -1174,7 +1337,7 @@ function angular(options) {
 					order,
 					inline: !resourceFile
 				});
-				if (shouldEnableHmr() && className && containingFile) classNames.set(normalizePath(containingFile), className);
+				if (shouldEnableLiveReload() && className && containingFile) classNames.set(normalizePath(containingFile), className);
 				if (shouldExternalizeStyles()) {
 					const stylesheetId = registerStylesheetContent(stylesheetRegistry, {
 						code: preprocessed.code,
@@ -1225,12 +1388,13 @@ function angular(options) {
 			}
 		}, (tsCompilerOptions) => {
 			if (shouldExternalizeStyles()) tsCompilerOptions["externalRuntimeStyles"] = true;
-			if (shouldEnableHmr()) {
+			if (shouldEnableLiveReload()) {
 				tsCompilerOptions["_enableHmr"] = true;
 				tsCompilerOptions["supportTestBed"] = true;
 			}
 			debugCompiler("tsCompilerOptions (compilation API)", {
-				hmr: pluginOptions.hmr,
+				liveReload: pluginOptions.liveReload,
+				viteHmr: hasViteHmrTransport(),
 				hasTailwindCss: pluginOptions.hasTailwindCss,
 				watchMode,
 				shouldExternalize: shouldExternalizeStyles(),
@@ -1241,7 +1405,6 @@ function angular(options) {
 				tsCompilerOptions["supportTestBed"] = true;
 				tsCompilerOptions["supportJitMode"] = true;
 			}
-			if (angularFullVersion >= 2e5) tsCompilerOptions["_enableSelectorless"] = true;
 			if (!isTest && config.build?.lib) {
 				tsCompilerOptions["declaration"] = true;
 				tsCompilerOptions["declarationMap"] = watchMode;
@@ -1261,7 +1424,7 @@ function angular(options) {
 			skipped: 0,
 			errors: 0
 		};
-		compilationResult.externalStylesheets?.forEach((value, key) => {
+		for (const [key, value] of compilationResult.externalStylesheets ?? []) {
 			preprocessStats.total++;
 			const angularHash = `${value}.css`;
 			stylesheetRegistry?.registerExternalRequest(angularHash, key);
@@ -1331,17 +1494,28 @@ function angular(options) {
 				filename: angularHash,
 				resolvedPath: key
 			});
-		});
+		}
 		debugStyles("external stylesheet preprocessing complete", preprocessStats);
-		const diagnostics = await angularCompilation.diagnoseFiles(pluginOptions.disableTypeChecking ? DiagnosticModes.All & ~DiagnosticModes.Semantic : DiagnosticModes.All);
+		const diagnostics = await compilation.diagnoseFiles(pluginOptions.disableTypeChecking ? DiagnosticModes.All & ~DiagnosticModes.Semantic : DiagnosticModes.All);
 		const errors = diagnostics.errors?.length ? diagnostics.errors : [];
 		const warnings = diagnostics.warnings?.length ? diagnostics.warnings : [];
+		debugEmit("compilation diagnostics", {
+			errorCount: errors.length,
+			warningCount: warnings.length
+		});
 		const templateUpdates = mapTemplateUpdatesToFiles(compilationResult.templateUpdates);
 		if (templateUpdates.size > 0) debugHmr("compilation API template updates", {
 			count: templateUpdates.size,
 			files: [...templateUpdates.keys()]
 		});
-		for (const file of await angularCompilation.emitAffectedFiles()) {
+		const affectedFiles = await compilation.emitAffectedFiles();
+		debugEmit("emitAffectedFiles summary", {
+			count: affectedFiles.length,
+			templateUpdateCount: templateUpdates.size,
+			knownOutputCountBefore: outputFiles.size
+		});
+		debugEmitV("emitAffectedFiles files", { files: affectedFiles.map((file) => normalizePath(file.filename)) });
+		for (const file of affectedFiles) {
 			const normalizedFilename = normalizePath(file.filename);
 			const templateUpdate = templateUpdates.get(normalizedFilename);
 			if (templateUpdate) classNames.set(normalizedFilename, templateUpdate.className);
@@ -1353,6 +1527,14 @@ function angular(options) {
 				hmrUpdateCode: templateUpdate?.code,
 				hmrEligible: !!templateUpdate?.code
 			});
+			debugEmitV("registered compilation API output", {
+				filename: normalizedFilename,
+				...describeEmitMarkers(file.contents),
+				hasTemplateUpdate: !!templateUpdate,
+				errorCount: errors.length,
+				warningCount: warnings.length,
+				knownOutputCount: outputFiles.size
+			});
 		}
 	}
 	async function performCompilation(config, ids) {
@@ -1386,12 +1568,13 @@ function angular(options) {
 		const tsCompilerOptions = { ...cached.options };
 		let rootNames = [...cached.rootNames];
 		if (shouldExternalizeStyles()) tsCompilerOptions["externalRuntimeStyles"] = true;
-		if (shouldEnableHmr()) {
+		if (shouldEnableLiveReload()) {
 			tsCompilerOptions["_enableHmr"] = true;
 			tsCompilerOptions["supportTestBed"] = true;
 		}
 		debugCompiler("tsCompilerOptions (NgtscProgram path)", {
-			hmr: pluginOptions.hmr,
+			liveReload: pluginOptions.liveReload,
+			viteHmr: hasViteHmrTransport(),
 			shouldExternalize: shouldExternalizeStyles(),
 			externalRuntimeStyles: !!tsCompilerOptions["externalRuntimeStyles"],
 			hmrEnabled: !!tsCompilerOptions["_enableHmr"]
@@ -1400,7 +1583,6 @@ function angular(options) {
 			tsCompilerOptions["supportTestBed"] = true;
 			tsCompilerOptions["supportJitMode"] = true;
 		}
-		if (angularFullVersion >= 2e5) tsCompilerOptions["_enableSelectorless"] = true;
 		if (!isTest && config.build?.lib) {
 			tsCompilerOptions["declaration"] = true;
 			tsCompilerOptions["declarationMap"] = watchMode;
@@ -1461,7 +1643,7 @@ function angular(options) {
 		if (!watchMode) builder = ts.createAbstractBuilder(typeScriptProgram, host, oldBuilder);
 		if (angularCompiler) await angularCompiler.analyzeAsync();
 		const transformers = mergeTransformers({ before: jit ? [compilerCli.constructorParametersDownlevelTransform(builder.getProgram()), cjt(() => builder.getProgram().getTypeChecker())] : [] }, jit ? {} : angularCompiler.prepareEmit().transformers);
-		const fileMetadata = getFileMetadata(builder, angularCompiler, pluginOptions.hmr, pluginOptions.disableTypeChecking);
+		const fileMetadata = getFileMetadata(builder, angularCompiler, pluginOptions.liveReload, pluginOptions.disableTypeChecking);
 		const writeFileCallback = (_filename, content, _a, _b, sourceFiles) => {
 			if (!sourceFiles?.length) return;
 			const filename = normalizePath(sourceFiles[0].fileName);
@@ -1475,6 +1657,14 @@ function angular(options) {
 				hmrUpdateCode: metadata.hmrUpdateCode,
 				hmrEligible: metadata.hmrEligible
 			});
+			debugEmitV("registered ngtsc output", {
+				filename,
+				...describeEmitMarkers(content),
+				errorCount: metadata.errors?.length ?? 0,
+				warningCount: metadata.warnings?.length ?? 0,
+				hmrEligible: !!metadata.hmrEligible,
+				knownOutputCount: outputFiles.size
+			});
 		};
 		const writeOutputFile = (id) => {
 			const sourceFile = builder.getSourceFile(id);