@analogjs/vite-plugin-angular 3.0.0-alpha.4 → 3.0.0-alpha.41

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

@@ -1,982 +1,2234 @@
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
-import { basename, dirname, isAbsolute, join, relative, resolve, } from 'node:path';
-import * as vite from 'vite';
-import * as compilerCli from '@angular/compiler-cli';
-import { createRequire } from 'node:module';
-import * as ngCompiler from '@angular/compiler';
-import { globSync } from 'tinyglobby';
-import { defaultClientConditions, normalizePath, preprocessCSS, } from 'vite';
-import { buildOptimizerPlugin } from './angular-build-optimizer-plugin.js';
-import { jitPlugin } from './angular-jit-plugin.js';
-import { createCompilerPlugin, createRolldownCompilerPlugin, } from './compiler-plugin.js';
-import { StyleUrlsResolver, TemplateUrlsResolver, } from './component-resolvers.js';
-import { augmentHostWithCaching, augmentHostWithResources, augmentProgramWithVersioning, mergeTransformers, } from './host.js';
-import { angularVitestPlugins } from './angular-vitest-plugin.js';
-import { createAngularCompilation, createJitResourceTransformer, SourceFileCache, angularFullVersion, } from './utils/devkit.js';
-const require = createRequire(import.meta.url);
-import { pendingTasksPlugin } from './angular-pending-tasks.plugin.js';
-import { liveReloadPlugin } from './live-reload-plugin.js';
-import { nxFolderPlugin } from './nx-folder-plugin.js';
-import { replaceFiles, } from './plugins/file-replacements.plugin.js';
-import { routerPlugin } from './router-plugin.js';
-import { createHash } from 'node:crypto';
-export var DiagnosticModes;
-(function (DiagnosticModes) {
-    DiagnosticModes[DiagnosticModes["None"] = 0] = "None";
-    DiagnosticModes[DiagnosticModes["Option"] = 1] = "Option";
-    DiagnosticModes[DiagnosticModes["Syntactic"] = 2] = "Syntactic";
-    DiagnosticModes[DiagnosticModes["Semantic"] = 4] = "Semantic";
-    DiagnosticModes[DiagnosticModes["All"] = 7] = "All";
-})(DiagnosticModes || (DiagnosticModes = {}));
+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, debugEmit, debugEmitV, debugHmr, debugHmrV, debugStyles, debugStylesV, debugTailwind, debugTailwindV } from "./utils/debug.js";
+import { inspectCssTailwindDirectives, isTailwindReferenceError, throwTailwindReferenceTextError } from "./utils/tailwind-reference.js";
+import { toVirtualRawId, toVirtualStyleId } from "./utils/virtual-ids.js";
+import { loadVirtualRawModule, loadVirtualStyleModule, shouldPreprocessTestCss } from "./utils/virtual-resources.js";
+import { jitPlugin } from "./angular-jit-plugin.js";
+import { createCompilerPlugin, createRolldownCompilerPlugin } from "./compiler-plugin.js";
+import { StyleUrlsResolver, TemplateUrlsResolver, getAngularComponentMetadata } from "./component-resolvers.js";
+import { composeStylePreprocessors, normalizeStylesheetDependencies } from "./style-preprocessor.js";
+import { AnalogStylesheetRegistry, preprocessStylesheet, preprocessStylesheetResult, registerStylesheetContent, rewriteRelativeCssImports } from "./stylesheet-registry.js";
+import { augmentHostWithCaching, augmentHostWithResources, augmentProgramWithVersioning, mergeTransformers } from "./host.js";
+import { TS_EXT_REGEX, createTsConfigGetter, getTsConfigPath } from "./utils/plugin-config.js";
+import { fastCompilePlugin } from "./fast-compile-plugin.js";
+import { angularVitestPlugins } from "./angular-vitest-plugin.js";
+import { pendingTasksPlugin } from "./angular-pending-tasks.plugin.js";
+import { liveReloadPlugin } from "./live-reload-plugin.js";
+import { nxFolderPlugin } from "./nx-folder-plugin.js";
+import { replaceFiles } from "./plugins/file-replacements.plugin.js";
+import { routerPlugin } from "./router-plugin.js";
+import { configureStylePipelineRegistry, stylePipelinePreprocessorFromPlugins } from "./style-pipeline.js";
+import { union } from "es-toolkit";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, promises, readFileSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import * as compilerCli from "@angular/compiler-cli";
+import { createRequire } from "node:module";
+import * as ngCompiler from "@angular/compiler";
+import { globSync } from "tinyglobby";
+import { defaultClientConditions, normalizePath, preprocessCSS } from "vite";
+//#region packages/vite-plugin-angular/src/lib/angular-vite-plugin.ts
+var require = createRequire(import.meta.url);
+var DiagnosticModes = /* @__PURE__ */ function(DiagnosticModes) {
+	DiagnosticModes[DiagnosticModes["None"] = 0] = "None";
+	DiagnosticModes[DiagnosticModes["Option"] = 1] = "Option";
+	DiagnosticModes[DiagnosticModes["Syntactic"] = 2] = "Syntactic";
+	DiagnosticModes[DiagnosticModes["Semantic"] = 4] = "Semantic";
+	DiagnosticModes[DiagnosticModes["All"] = 7] = "All";
+	return DiagnosticModes;
+}({});
+function normalizeIncludeGlob(workspaceRoot, glob) {
+	const normalizedWorkspaceRoot = normalizePath(resolve(workspaceRoot));
+	const normalizedGlob = normalizePath(glob);
+	if (normalizedGlob === normalizedWorkspaceRoot || normalizedGlob.startsWith(`${normalizedWorkspaceRoot}/`)) return normalizedGlob;
+	if (normalizedGlob.startsWith("/")) return `${normalizedWorkspaceRoot}${normalizedGlob}`;
+	return normalizePath(resolve(normalizedWorkspaceRoot, normalizedGlob));
+}
+var classNames = /* @__PURE__ */ new Map();
+function evictDeletedFileMetadata(file, { removeActiveGraphMetadata, removeStyleOwnerMetadata, classNamesMap, fileTransformMap }) {
+	const normalizedFile = normalizePath(file.split("?")[0]);
+	removeActiveGraphMetadata(normalizedFile);
+	removeStyleOwnerMetadata(normalizedFile);
+	classNamesMap.delete(normalizedFile);
+	fileTransformMap.delete(normalizedFile);
+}
+function injectViteIgnoreForHmrMetadata(code) {
+	let patched = code.replace(/\bimport\(([a-zA-Z_$][\w$]*\.\u0275\u0275getReplaceMetadataURL)/g, "import(/* @vite-ignore */ $1");
+	if (patched === code) patched = patched.replace(/import\((\S+getReplaceMetadataURL)/g, "import(/* @vite-ignore */ $1");
+	return patched;
+}
+function isIgnoredHmrFile(file) {
+	return file.endsWith(".tsbuildinfo");
+}
+/**
+* Builds a resolved stylePreprocessor function from plugin options.
+*
+* When `tailwindCss` is configured, creates an injector that prepends
+* `@reference "<rootStylesheet>"` into component CSS that uses Tailwind
+* utilities. Uses absolute paths because Angular's externalRuntimeStyles
+* serves component CSS as virtual modules (hash-based IDs) with no
+* meaningful directory — relative paths can't resolve from a hash.
+*
+* If both `tailwindCss` and `stylePreprocessor` are provided, they are
+* chained: Tailwind reference injection runs first, then the user's
+* custom preprocessor.
+*/
+function buildStylePreprocessor(options) {
+	const userPreprocessor = options?.stylePreprocessor;
+	const stylePipelinePreprocessor = stylePipelinePreprocessorFromPlugins(options?.stylePipeline);
+	const tw = options?.tailwindCss;
+	if (!tw && !userPreprocessor && !stylePipelinePreprocessor) return;
+	let tailwindPreprocessor;
+	if (tw) {
+		const rootStylesheet = tw.rootStylesheet;
+		const prefixes = tw.prefixes;
+		debugTailwind("configured", {
+			rootStylesheet,
+			prefixes
+		});
+		if (!existsSync(rootStylesheet)) console.warn(`[@analogjs/vite-plugin-angular] tailwindCss.rootStylesheet not found at "${rootStylesheet}". @reference directives will point to a non-existent file, which will cause Tailwind CSS errors. Ensure the path is absolute and the file exists.`);
+		tailwindPreprocessor = (code, filename) => {
+			const directiveState = inspectCssTailwindDirectives(code);
+			if (directiveState.hasReferenceDirective || directiveState.hasTailwindImportDirective) {
+				debugTailwindV("skip (already has @reference or is root)", { filename });
+				return code;
+			}
+			if (!(prefixes ? prefixes.some((prefix) => directiveState.commentlessCode.includes(prefix)) : directiveState.commentlessCode.includes("@apply"))) {
+				debugTailwindV("skip (no Tailwind usage detected)", { filename });
+				return code;
+			}
+			if (directiveState.hasReferenceText) throwTailwindReferenceTextError(filename, rootStylesheet);
+			debugTailwind("injected @reference via preprocessor", { filename });
+			return `@reference "${rootStylesheet.replace(/\\/g, "/")}";\n${code}`;
+		};
+	}
+	if (tailwindPreprocessor && (stylePipelinePreprocessor || userPreprocessor)) debugTailwind("chained with style pipeline or user stylePreprocessor");
+	return composeStylePreprocessors([
+		tailwindPreprocessor,
+		stylePipelinePreprocessor,
+		userPreprocessor
+	]);
+}
+function angular(options) {
+	applyDebugOption(options?.debug, options?.workspaceRoot);
+	const liveReload = options?.liveReload ?? true;
+	/**
+	* Normalize plugin options so defaults
+	* are used for values not provided.
+	*/
+	const pluginOptions = {
+		tsconfigGetter: createTsConfigGetter(options?.tsconfig),
+		workspaceRoot: options?.workspaceRoot ?? process.cwd(),
+		inlineStylesExtension: options?.inlineStylesExtension ?? "css",
+		advanced: { tsTransformers: {
+			before: options?.advanced?.tsTransformers?.before ?? [],
+			after: options?.advanced?.tsTransformers?.after ?? [],
+			afterDeclarations: options?.advanced?.tsTransformers?.afterDeclarations ?? []
+		} },
+		supportedBrowsers: options?.supportedBrowsers ?? ["safari 15"],
+		jit: options?.jit,
+		include: options?.include ?? [],
+		additionalContentDirs: options?.additionalContentDirs ?? [],
+		liveReload,
+		disableTypeChecking: options?.disableTypeChecking ?? true,
+		fileReplacements: options?.fileReplacements ?? [],
+		useAngularCompilationAPI: options?.experimental?.useAngularCompilationAPI ?? false,
+		fastCompile: options?.fastCompile ?? false,
+		fastCompileMode: options?.fastCompileMode ?? "full",
+		hasTailwindCss: !!options?.tailwindCss,
+		tailwindCss: options?.tailwindCss,
+		stylePreprocessor: buildStylePreprocessor(options)
+	};
+	let resolvedConfig;
+	let tsConfigResolutionContext = null;
+	const ts = require("typescript");
+	let builder;
+	let nextProgram;
+	const tsconfigOptionsCache = /* @__PURE__ */ new Map();
+	const tsconfigGraphRootCache = /* @__PURE__ */ new Map();
+	let cachedHost;
+	let cachedHostKey;
+	let includeCache = [];
+	function invalidateFsCaches() {
+		includeCache = [];
+	}
+	function invalidateTsconfigCaches() {
+		tsconfigOptionsCache.clear();
+		tsconfigGraphRootCache.clear();
+		cachedHost = void 0;
+		cachedHostKey = void 0;
+	}
+	let watchMode = false;
+	let testWatchMode = isTestWatchMode();
+	const activeGraphComponentMetadata = /* @__PURE__ */ new Map();
+	const selectorOwners = /* @__PURE__ */ new Map();
+	const classNameOwners = /* @__PURE__ */ new Map();
+	const transformedStyleOwnerMetadata = /* @__PURE__ */ new Map();
+	const styleSourceOwners = /* @__PURE__ */ new Map();
+	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.
+	*
+	* When true, Angular emits style references (hash-based IDs) instead of
+	* inlining CSS strings. Vite's resolveId → load → transform pipeline
+	* then serves these virtual modules, allowing @tailwindcss/vite to
+	* process @reference directives.
+	*
+	* Required for TWO independent use-cases:
+	*   1. HMR — Vite needs external modules for hot replacement
+	*   2. Tailwind CSS (hasTailwindCss) — styles must pass through Vite's
+	*      CSS pipeline so @tailwindcss/vite can resolve @apply directives
+	*
+	* In production builds (!watchMode), styles are NOT externalized — they
+	* are inlined after preprocessCSS runs eagerly in transformStylesheet.
+	*/
+	function shouldExternalizeStyles() {
+		if (!(isTest ? testWatchMode : watchMode)) return false;
+		return !!(shouldEnableLiveReload() || pluginOptions.hasTailwindCss);
+	}
+	/**
+	* Validates the Tailwind CSS integration configuration and emits actionable
+	* warnings for common misconfigurations that cause silent failures.
+	*
+	* Called once during `configResolved` when `tailwindCss` is configured.
+	*/
+	function validateTailwindConfig(config, isWatchMode) {
+		const PREFIX = "[@analogjs/vite-plugin-angular]";
+		const tw = pluginOptions.tailwindCss;
+		if (!tw) return;
+		if (!isAbsolute(tw.rootStylesheet)) console.warn(`${PREFIX} tailwindCss.rootStylesheet must be an absolute path. Got: "${tw.rootStylesheet}". Use path.resolve(__dirname, '...') in your vite.config to convert it.`);
+		const resolvedPlugins = config.plugins;
+		const hasTailwindPlugin = resolvedPlugins.some((p) => p.name.startsWith("@tailwindcss/vite") || p.name.startsWith("tailwindcss"));
+		if (isWatchMode && !hasTailwindPlugin) throw new Error(`${PREFIX} tailwindCss is configured but no @tailwindcss/vite plugin was found. Component CSS with @apply directives will not be processed.\n\n  Fix: npm install @tailwindcss/vite --save-dev\n  Then add tailwindcss() to your vite.config plugins array.\n`);
+		if (isWatchMode && tw.rootStylesheet) {
+			const projectRoot = normalizePath(config.root);
+			const normalizedRootStylesheet = normalizePath(tw.rootStylesheet);
+			if (!normalizedRootStylesheet.startsWith(projectRoot)) {
+				if (!(config.server?.fs?.allow ?? []).some((allowed) => normalizedRootStylesheet.startsWith(normalizePath(allowed)))) console.warn(`${PREFIX} tailwindCss.rootStylesheet is outside the Vite project root. The dev server may reject it with 403.\n\n  Root: ${projectRoot}\n  Stylesheet: ${tw.rootStylesheet}\n\n  Fix: server.fs.allow: ['${dirname(tw.rootStylesheet)}']\n`);
+			}
+		}
+		if (tw.prefixes !== void 0 && tw.prefixes.length === 0) console.warn(`${PREFIX} tailwindCss.prefixes is an empty array. No component stylesheets will receive @reference injection. Either remove the prefixes option (to use @apply detection) or specify your prefixes: ['tw:']\n`);
+		/**
+		* Duplicate analog() registrations are a real bug for the non-SSR/client
+		* build because each plugin instance creates its own component-style state.
+		*
+		* That state includes the style maps/registries used to:
+		* - track transformed component styles
+		* - map owner components back to stylesheet requests
+		* - coordinate Tailwind/@reference processing and style reload behavior
+		*
+		* If two plugin instances are active for the same client build, one
+		* instance can record stylesheet metadata while the other services the
+		* request. The result is "missing" component CSS even though compilation
+		* appeared to succeed.
+		*
+		* SSR is different. Analog's Nitro/SSR build path reuses the already
+		* resolved plugin graph and then runs an additional `build.ssr === true`
+		* pass for the server bundle. In that flow Vite can expose multiple
+		* `@analogjs/vite-plugin-angular` entries in `config.plugins`, but that is
+		* not the same failure mode as a duplicated client build. The server build
+		* does not rely on the client-side style maps that this guard is protecting.
+		*
+		* Because of that, we only throw for duplicate registrations on non-SSR
+		* builds. Throwing during SSR would be a false positive that breaks valid
+		* Analog SSR/Nitro builds.
+		*/
+		const analogInstances = resolvedPlugins.filter((p) => p.name === "@analogjs/vite-plugin-angular");
+		if (analogInstances.length > 1 && !config.build?.ssr) throw new Error(`${PREFIX} analog() is registered ${analogInstances.length} times. Each instance creates separate style maps, causing component styles to be lost. Remove duplicate registrations.`);
+		if (existsSync(tw.rootStylesheet)) try {
+			const rootContent = readFileSync(tw.rootStylesheet, "utf-8");
+			if (!rootContent.includes("@import \"tailwindcss\"") && !rootContent.includes("@import 'tailwindcss'")) console.warn(`${PREFIX} tailwindCss.rootStylesheet does not contain @import "tailwindcss". The @reference directive will point to a file without Tailwind configuration.\n\n  File: ${tw.rootStylesheet}\n`);
+		} catch {}
+	}
+	function isLikelyPageOnlyComponent(id) {
+		return id.includes("/pages/") || /\.page\.[cm]?[jt]sx?$/i.test(id) || /\([^/]+\)\.page\.[cm]?[jt]sx?$/i.test(id);
+	}
+	function removeActiveGraphMetadata(file) {
+		const previous = activeGraphComponentMetadata.get(file);
+		if (!previous) return;
+		for (const record of previous) {
+			const location = `${record.file}#${record.className}`;
+			if (record.selector) {
+				const selectorSet = selectorOwners.get(record.selector);
+				selectorSet?.delete(location);
+				if (selectorSet?.size === 0) selectorOwners.delete(record.selector);
+			}
+			const classNameSet = classNameOwners.get(record.className);
+			classNameSet?.delete(location);
+			if (classNameSet?.size === 0) classNameOwners.delete(record.className);
+		}
+		activeGraphComponentMetadata.delete(file);
+	}
+	function registerActiveGraphMetadata(file, records) {
+		removeActiveGraphMetadata(file);
+		if (records.length === 0) return;
+		activeGraphComponentMetadata.set(file, records);
+		for (const record of records) {
+			const location = `${record.file}#${record.className}`;
+			if (record.selector) {
+				let selectorSet = selectorOwners.get(record.selector);
+				if (!selectorSet) {
+					selectorSet = /* @__PURE__ */ new Set();
+					selectorOwners.set(record.selector, selectorSet);
+				}
+				selectorSet.add(location);
+			}
+			let classNameSet = classNameOwners.get(record.className);
+			if (!classNameSet) {
+				classNameSet = /* @__PURE__ */ new Set();
+				classNameOwners.set(record.className, classNameSet);
+			}
+			classNameSet.add(location);
+		}
+	}
+	function removeStyleOwnerMetadata(file) {
+		const previous = transformedStyleOwnerMetadata.get(file);
+		if (!previous) return;
+		for (const record of previous) {
+			const owners = styleSourceOwners.get(record.sourcePath);
+			owners?.delete(record.ownerFile);
+			if (owners?.size === 0) styleSourceOwners.delete(record.sourcePath);
+		}
+		transformedStyleOwnerMetadata.delete(file);
+	}
+	function registerStyleOwnerMetadata(file, styleUrls) {
+		removeStyleOwnerMetadata(file);
+		const records = styleUrls.map((urlSet) => {
+			const [, absoluteFileUrl] = urlSet.split("|");
+			return absoluteFileUrl ? {
+				ownerFile: file,
+				sourcePath: normalizePath(absoluteFileUrl)
+			} : void 0;
+		}).filter((record) => !!record);
+		if (records.length === 0) return;
+		transformedStyleOwnerMetadata.set(file, records);
+		for (const record of records) {
+			let owners = styleSourceOwners.get(record.sourcePath);
+			if (!owners) {
+				owners = /* @__PURE__ */ new Set();
+				styleSourceOwners.set(record.sourcePath, owners);
+			}
+			owners.add(record.ownerFile);
+		}
+	}
+	let stylesheetRegistry;
+	const sourceFileCache$1 = new sourceFileCache();
+	const isTest = process.env.NODE_ENV === "test" || !!process.env["VITEST"];
+	const isVitestVscode = !!process.env["VITEST_VSCODE"];
+	const isStackBlitz = !!process.versions["webcontainer"];
+	const isAstroIntegration = process.env["ANALOG_ASTRO"] === "true";
+	const jit = typeof pluginOptions?.jit !== "undefined" ? pluginOptions.jit : isTest;
+	let viteServer;
+	const styleUrlsResolver = new StyleUrlsResolver();
+	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) => {
+		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 = [];
+	const fileTransformMap = /* @__PURE__ */ new Map();
+	let styleTransform;
+	let pendingCompilation;
+	let compilationLock = Promise.resolve();
+	let angularCompilation;
+	function angularPlugin() {
+		let isProd = false;
+		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.liveReload = false;
+		}
+		if (isTest) {
+			pluginOptions.liveReload = false;
+			debugHmr("hmr disabled", {
+				angularVersion: angularFullVersion,
+				isTest
+			});
+		}
+		if (pluginOptions.useAngularCompilationAPI) if (angularFullVersion < 200100) {
+			pluginOptions.useAngularCompilationAPI = false;
+			debugCompilationApi("disabled: Angular version %s < 20.1", angularFullVersion);
+			console.warn("[@analogjs/vite-plugin-angular]: The Angular Compilation API is only available with Angular v20.1 and later");
+		} else debugCompilationApi("enabled (Angular %s)", angularFullVersion);
+		return {
+			name: "@analogjs/vite-plugin-angular",
+			async config(config, { command }) {
+				activateDeferredDebug(command);
+				watchMode = command === "serve";
+				isProd = config.mode === "production" || process.env.NODE_ENV === "production";
+				tsConfigResolutionContext = {
+					root: config.root || ".",
+					isProd,
+					isLib: !!config?.build?.lib
+				};
+				const preliminaryTsConfigPath = resolveTsConfigPath();
+				const esbuild = pluginOptions.useAngularCompilationAPI ? void 0 : config.esbuild ?? false;
+				const oxc = pluginOptions.useAngularCompilationAPI ? void 0 : config.oxc ?? false;
+				if (pluginOptions.useAngularCompilationAPI) debugCompilationApi("esbuild/oxc disabled, Angular handles transforms");
+				const defineOptions = {
+					ngJitMode: "false",
+					ngI18nClosureMode: "false",
+					...watchMode ? {} : { ngDevMode: "false" }
+				};
+				const useRolldown = isRolldown();
+				const jsTransformConfigKey = getJsTransformConfigKey();
+				const jsTransformConfigValue = jsTransformConfigKey === "oxc" ? oxc : esbuild;
+				const rolldownOptions = { plugins: [createRolldownCompilerPlugin({
+					tsconfig: preliminaryTsConfigPath,
+					sourcemap: !isProd,
+					advancedOptimizations: isProd,
+					jit,
+					incremental: watchMode
+				}, !isAstroIntegration)] };
+				const esbuildOptions = {
+					plugins: [createCompilerPlugin({
+						tsconfig: preliminaryTsConfigPath,
+						sourcemap: !isProd,
+						advancedOptimizations: isProd,
+						jit,
+						incremental: watchMode
+					}, isTest, !isAstroIntegration)],
+					define: defineOptions
+				};
+				return {
+					[jsTransformConfigKey]: jsTransformConfigValue,
+					optimizeDeps: {
+						include: [
+							"rxjs/operators",
+							"rxjs",
+							"tslib"
+						],
+						exclude: ["@angular/platform-server"],
+						...useRolldown ? { rolldownOptions } : { esbuildOptions }
+					},
+					resolve: { conditions: ["style", ...config.resolve?.conditions || defaultClientConditions] }
+				};
+			},
+			configResolved(config) {
+				resolvedConfig = config;
+				if (pluginOptions.hasTailwindCss) validateTailwindConfig(config, watchMode);
+				if (pluginOptions.useAngularCompilationAPI) {
+					stylesheetRegistry = new AnalogStylesheetRegistry();
+					configureStylePipelineRegistry(pluginOptions.stylePipeline, stylesheetRegistry, { workspaceRoot: pluginOptions.workspaceRoot });
+					debugStyles("stylesheet registry initialized (Angular Compilation API)");
+				}
+				if (!jit) styleTransform = (code, filename) => preprocessCSS(code, filename, config);
+				if (isTest) testWatchMode = !(config.server.watch === null) || config.test?.watch === true || testWatchMode;
+			},
+			configureServer(server) {
+				viteServer = server;
+				const invalidateCompilationOnFsChange = createFsWatcherCacheInvalidator(invalidateFsCaches, invalidateTsconfigCaches, () => performCompilation(resolvedConfig));
+				server.watcher.on("add", invalidateCompilationOnFsChange);
+				server.watcher.on("unlink", (file) => {
+					evictDeletedFileMetadata(file, {
+						removeActiveGraphMetadata,
+						removeStyleOwnerMetadata,
+						classNamesMap: classNames,
+						fileTransformMap
+					});
+					return invalidateCompilationOnFsChange();
+				});
+				server.watcher.on("change", (file) => {
+					if (file.includes("tsconfig")) invalidateTsconfigCaches();
+				});
+			},
+			async buildStart() {
+				if (!isVitestVscode) {
+					await performCompilation(resolvedConfig);
+					pendingCompilation = null;
+					initialCompilation = true;
+				}
+			},
+			async handleHotUpdate(ctx) {
+				if (isIgnoredHmrFile(ctx.file)) {
+					debugHmr("ignored file change", { file: ctx.file });
+					return [];
+				}
+				if (TS_EXT_REGEX.test(ctx.file)) {
+					const [fileId] = ctx.file.split("?");
+					debugHmr("TS file changed", {
+						file: ctx.file,
+						fileId
+					});
+					pendingCompilation = performCompilation(resolvedConfig, [fileId]);
+					let result;
+					if (shouldEnableLiveReload()) {
+						await pendingCompilation;
+						pendingCompilation = null;
+						result = fileEmitter(fileId);
+						debugHmr("TS file emitted", {
+							fileId,
+							hmrEligible: !!result?.hmrEligible,
+							hasClassName: !!classNames.get(fileId)
+						});
+						debugHmrV("ts hmr evaluation", {
+							file: ctx.file,
+							fileId,
+							hasResult: !!result,
+							hmrEligible: !!result?.hmrEligible,
+							hasClassName: !!classNames.get(fileId),
+							className: classNames.get(fileId),
+							updateCode: result?.hmrUpdateCode ? describeStylesheetContent(result.hmrUpdateCode) : void 0,
+							errors: result?.errors?.length ?? 0,
+							warnings: result?.warnings?.length ?? 0,
+							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 (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", {
+							file: ctx.file,
+							fileId,
+							relativeFileId,
+							className: classNames.get(fileId)
+						});
+						sendHMRComponentUpdate(ctx.server, relativeFileId);
+						return ctx.modules.map((mod) => {
+							if (mod.id === ctx.file) return markModuleSelfAccepting(mod);
+							return mod;
+						});
+					}
+				}
+				if (/\.(html|htm|css|less|sass|scss)$/.test(ctx.file)) {
+					debugHmr("resource file changed", { file: ctx.file });
+					fileTransformMap.delete(ctx.file.split("?")[0]);
+					if (/\.(css|less|sass|scss)$/.test(ctx.file)) refreshStylesheetRegistryForFile(ctx.file, stylesheetRegistry, pluginOptions.stylePreprocessor);
+					if (/\.(css|less|sass|scss)$/.test(ctx.file) && existsSync(ctx.file)) try {
+						const rawResource = readFileSync(ctx.file, "utf-8");
+						debugHmrV("resource source snapshot", {
+							file: ctx.file,
+							mtimeMs: safeStatMtimeMs(ctx.file),
+							...describeStylesheetContent(rawResource)
+						});
+					} catch (error) {
+						debugHmrV("resource source snapshot failed", {
+							file: ctx.file,
+							error: String(error)
+						});
+					}
+					const fileModules = await getModulesForChangedFile(ctx.server, ctx.file, ctx.modules, stylesheetRegistry);
+					debugHmrV("resource modules resolved", {
+						file: ctx.file,
+						eventModuleCount: ctx.modules.length,
+						fileModuleCount: fileModules.length,
+						modules: fileModules.map((mod) => ({
+							id: mod.id,
+							file: mod.file,
+							type: mod.type,
+							url: mod.url
+						}))
+					});
+					/**
+					* Check to see if this was a direct request
+					* for an external resource (styles, html).
+					*/
+					const isDirect = fileModules.find((mod) => !!mod.id && mod.id.includes("?direct") && isModuleForChangedResource(mod, ctx.file, stylesheetRegistry));
+					const isInline = fileModules.find((mod) => !!mod.id && mod.id.includes("?inline") && isModuleForChangedResource(mod, ctx.file, stylesheetRegistry));
+					debugHmrV("resource direct/inline detection", {
+						file: ctx.file,
+						hasDirect: !!isDirect,
+						directId: isDirect?.id,
+						hasInline: !!isInline,
+						inlineId: isInline?.id
+					});
+					if (isDirect || isInline) {
+						if (shouldExternalizeStyles() && isDirect?.id && isDirect.file) {
+							const isComponentStyle = isDirect.type === "css" && isComponentStyleSheet(isDirect.id);
+							debugHmrV("resource direct branch", {
+								file: ctx.file,
+								directId: isDirect.id,
+								directType: isDirect.type,
+								shouldExternalize: shouldExternalizeStyles(),
+								isComponentStyle
+							});
+							if (isComponentStyle) {
+								const { encapsulation } = getComponentStyleSheetMeta(isDirect.id);
+								const wrapperModules = await findComponentStylesheetWrapperModules(ctx.server, ctx.file, isDirect, fileModules, stylesheetRegistry);
+								const stylesheetDiagnosis = diagnoseComponentStylesheetPipeline(ctx.file, isDirect, stylesheetRegistry, wrapperModules, pluginOptions.stylePreprocessor);
+								debugStylesV("HMR: component stylesheet changed", {
+									file: isDirect.file,
+									encapsulation
+								});
+								debugHmrV("component stylesheet wrapper modules", {
+									file: ctx.file,
+									wrapperCount: wrapperModules.length,
+									wrapperIds: wrapperModules.map((mod) => mod.id),
+									availableModuleIds: fileModules.map((mod) => mod.id)
+								});
+								debugHmrV("component stylesheet pipeline diagnosis", stylesheetDiagnosis);
+								ctx.server.moduleGraph.invalidateModule(isDirect);
+								debugHmrV("component stylesheet direct module invalidated", {
+									file: ctx.file,
+									directModuleId: isDirect.id,
+									directModuleUrl: isDirect.url,
+									reason: "Ensure Vite drops stale direct CSS transform results before wrapper or fallback handling continues."
+								});
+								const trackedWrapperRequestIds = stylesheetDiagnosis.trackedRequestIds.filter((id) => id.includes("?ngcomp="));
+								if (encapsulation !== "shadow" && (wrapperModules.length > 0 || trackedWrapperRequestIds.length > 0)) {
+									wrapperModules.forEach((mod) => ctx.server.moduleGraph.invalidateModule(mod));
+									debugHmrV("sending css-update for component stylesheet", {
+										file: ctx.file,
+										path: isDirect.url,
+										acceptedPath: isDirect.file,
+										wrapperCount: wrapperModules.length,
+										trackedWrapperRequestIds,
+										hint: wrapperModules.length > 0 ? "Live wrapper modules were found and invalidated before sending the CSS update." : "No live wrapper ModuleNode was available, but the wrapper request id is already tracked, so Analog is trusting the browser-visible wrapper identity and patching the direct stylesheet instead of forcing a reload."
+									});
+									sendCssUpdate(ctx.server, {
+										path: isDirect.url,
+										acceptedPath: isDirect.file
+									});
+									logComponentStylesheetHmrOutcome({
+										file: ctx.file,
+										encapsulation,
+										diagnosis: stylesheetDiagnosis,
+										outcome: "css-update",
+										directModuleId: isDirect.id,
+										wrapperIds: wrapperModules.map((mod) => mod.id)
+									});
+									return union(fileModules.filter((mod) => {
+										return mod.file !== ctx.file || mod.id !== isDirect.id;
+									}).map((mod) => {
+										if (mod.file === ctx.file) return markModuleSelfAccepting(mod);
+										return mod;
+									}), wrapperModules.map((mod) => markModuleSelfAccepting(mod)));
+								}
+								debugHmrV("component stylesheet hmr fallback: full reload", {
+									file: ctx.file,
+									encapsulation,
+									reason: trackedWrapperRequestIds.length === 0 ? "missing-wrapper-module" : encapsulation === "shadow" ? "shadow-encapsulation" : "tracked-wrapper-still-not-patchable",
+									directId: isDirect.id,
+									trackedRequestIds: stylesheetRegistry?.getRequestIdsForSource(ctx.file) ?? []
+								});
+								const ownerModules = findStyleOwnerModules(ctx.server, ctx.file, styleSourceOwners);
+								debugHmrV("component stylesheet owner fallback lookup", {
+									file: ctx.file,
+									ownerCount: ownerModules.length,
+									ownerIds: ownerModules.map((mod) => mod.id),
+									ownerFiles: [...styleSourceOwners.get(normalizePath(ctx.file)) ?? []]
+								});
+								if (ownerModules.length > 0) {
+									pendingCompilation = performCompilation(resolvedConfig, [...ownerModules.map((mod) => mod.id).filter(Boolean)]);
+									await pendingCompilation;
+									pendingCompilation = null;
+									const updates = ownerModules.map((mod) => mod.id).filter((id) => !!id && !!classNames.get(id));
+									const derivedUpdates = ownerModules.map((mod) => mod.id).filter((id) => !!id).flatMap((ownerId) => resolveComponentClassNamesForStyleOwner(ownerId, ctx.file).map((className) => ({
+										ownerId,
+										className,
+										via: "raw-component-metadata"
+									})));
+									debugHmrV("component stylesheet owner fallback compilation", {
+										file: ctx.file,
+										ownerIds: ownerModules.map((mod) => mod.id),
+										updateIds: updates,
+										classNames: updates.map((id) => ({
+											id,
+											className: classNames.get(id)
+										})),
+										derivedUpdates
+									});
+									if (derivedUpdates.length > 0) debugHmrV("component stylesheet owner fallback derived updates", {
+										file: ctx.file,
+										updates: derivedUpdates,
+										hint: "Angular did not repopulate classNames during CSS-only owner recompilation, so Analog derived component identities from raw component metadata."
+									});
+								}
+								logComponentStylesheetHmrOutcome({
+									file: ctx.file,
+									encapsulation,
+									diagnosis: stylesheetDiagnosis,
+									outcome: "full-reload",
+									directModuleId: isDirect.id,
+									wrapperIds: wrapperModules.map((mod) => mod.id),
+									ownerIds: ownerModules.map((mod) => mod.id)
+								});
+								sendFullReload(ctx.server, {
+									file: ctx.file,
+									encapsulation,
+									reason: wrapperModules.length === 0 ? "missing-wrapper-module-and-no-owner-updates" : "shadow-encapsulation",
+									directId: isDirect.id,
+									trackedRequestIds: stylesheetRegistry?.getRequestIdsForSource(ctx.file) ?? []
+								});
+								return [];
+							}
+						}
+						return fileModules;
+					}
+					if (shouldEnableLiveReload() && /\.(html|htm)$/.test(ctx.file) && fileModules.length === 0) {
+						const ownerModules = findTemplateOwnerModules(ctx.server, ctx.file);
+						debugHmrV("template owner lookup", {
+							file: ctx.file,
+							ownerCount: ownerModules.length,
+							ownerIds: ownerModules.map((mod) => mod.id),
+							hint: ownerModules.length > 0 ? "The external template has candidate TS owner modules that can be recompiled for HMR." : "No TS owner modules were visible for this external template change; HMR will fall through to the generic importer path."
+						});
+						if (ownerModules.length > 0) {
+							const ownerIds = ownerModules.map((mod) => mod.id).filter(Boolean);
+							ownerModules.forEach((mod) => ctx.server.moduleGraph.invalidateModule(mod));
+							pendingCompilation = performCompilation(resolvedConfig, ownerIds);
+							await pendingCompilation;
+							pendingCompilation = null;
+							const updates = ownerIds.filter((id) => classNames.get(id));
+							debugHmrV("template owner recompilation result", {
+								file: ctx.file,
+								ownerIds,
+								updates,
+								updateClassNames: updates.map((id) => ({
+									id,
+									className: classNames.get(id)
+								})),
+								hint: updates.length > 0 ? "External template recompilation produced Angular component update targets." : "External template recompilation completed, but no Angular component update targets were surfaced."
+							});
+							if (updates.length > 0) {
+								debugHmr("template owner module invalidation", {
+									file: ctx.file,
+									ownerIds,
+									updateCount: updates.length
+								});
+								updates.forEach((updateId) => {
+									const relativeFileId = `${normalizePath(relative(process.cwd(), updateId))}@${classNames.get(updateId)}`;
+									sendHMRComponentUpdate(ctx.server, relativeFileId);
+								});
+								return ownerModules.map((mod) => markModuleSelfAccepting(mod));
+							}
+						}
+					}
+					const mods = [];
+					const updates = [];
+					fileModules.forEach((mod) => {
+						mod.importers.forEach((imp) => {
+							ctx.server.moduleGraph.invalidateModule(imp);
+							if (shouldExternalizeStyles() && classNames.get(imp.id)) updates.push(imp.id);
+							else mods.push(imp);
+						});
+					});
+					debugHmrV("resource importer analysis", {
+						file: ctx.file,
+						fileModuleCount: fileModules.length,
+						importerCount: fileModules.reduce((count, mod) => count + mod.importers.size, 0),
+						updates,
+						mods: mods.map((mod) => mod.id)
+					});
+					pendingCompilation = performCompilation(resolvedConfig, [...mods.map((mod) => mod.id).filter(Boolean), ...updates]);
+					if (updates.length > 0) {
+						await pendingCompilation;
+						pendingCompilation = null;
+						debugHmr("resource importer component updates", {
+							file: ctx.file,
+							updateCount: updates.length
+						});
+						updates.forEach((updateId) => {
+							const impRelativeFileId = `${normalizePath(relative(process.cwd(), updateId))}@${classNames.get(updateId)}`;
+							sendHMRComponentUpdate(ctx.server, impRelativeFileId);
+						});
+						return fileModules.map((mod) => {
+							if (mod.id === ctx.file) return markModuleSelfAccepting(mod);
+							return mod;
+						});
+					}
+					return mods;
+				}
+				debugHmr("full reload — unrecognized file type", { file: ctx.file });
+				classNames.clear();
+				return ctx.modules;
+			},
+			resolveId(id, importer) {
+				if (id.startsWith("virtual:@analogjs/vite-plugin-angular:inline-style:") || id.startsWith("virtual:@analogjs/vite-plugin-angular:raw:")) return `\0${id}`;
+				if (jit && id.startsWith("angular:jit:")) {
+					const path = id.split(";")[1];
+					const resolved = normalizePath(resolve(dirname(importer), path));
+					if (id.includes(":style")) return toVirtualStyleId(resolved);
+					return toVirtualRawId(resolved);
+				}
+				if (id.includes(".html?raw")) {
+					const filePath = id.split("?")[0];
+					const resolved = isAbsolute(filePath) ? normalizePath(filePath) : importer ? normalizePath(resolve(dirname(importer), filePath)) : void 0;
+					if (resolved) return toVirtualRawId(resolved);
+				}
+				if (/\.(css|scss|sass|less)\?inline$/.test(id)) {
+					const filePath = id.split("?")[0];
+					const resolved = isAbsolute(filePath) ? normalizePath(filePath) : importer ? normalizePath(resolve(dirname(importer), filePath)) : void 0;
+					if (resolved) return toVirtualStyleId(resolved);
+				}
+				if (isComponentStyleSheet(id)) {
+					const filename = getFilenameFromPath(id);
+					if (stylesheetRegistry?.hasServed(filename)) {
+						debugStylesV("resolveId: kept preprocessed ID", { filename });
+						return id;
+					}
+					const componentStyles = stylesheetRegistry?.resolveExternalSource(filename);
+					if (componentStyles) {
+						debugStylesV("resolveId: mapped external stylesheet", {
+							filename,
+							resolvedPath: componentStyles
+						});
+						return componentStyles + new URL(id, "http://localhost").search;
+					}
+					debugStyles("resolveId: component stylesheet NOT FOUND in either map", {
+						filename,
+						inlineMapSize: stylesheetRegistry?.servedCount ?? 0,
+						externalMapSize: stylesheetRegistry?.externalCount ?? 0
+					});
+				}
+			},
+			async load(id) {
+				const styleModule = await loadVirtualStyleModule(this, id, resolvedConfig);
+				if (styleModule !== void 0) return styleModule;
+				const rawModule = await loadVirtualRawModule(this, id);
+				if (rawModule !== void 0) return rawModule;
+				if (/\.(css|scss|sass|less)\?inline$/.test(id)) {
+					const filePath = id.split("?")[0];
+					const code = await promises.readFile(filePath, "utf-8");
+					if (!shouldPreprocessTestCss(resolvedConfig, filePath)) return `export default ${JSON.stringify(code)}`;
+					const result = await preprocessCSS(code, filePath, resolvedConfig);
+					return `export default ${JSON.stringify(result.code)}`;
+				}
+				if (isComponentStyleSheet(id)) {
+					const filename = getFilenameFromPath(id);
+					const componentStyles = stylesheetRegistry?.getServedContent(filename);
+					if (componentStyles) {
+						stylesheetRegistry?.registerActiveRequest(id);
+						debugHmrV("stylesheet active request registered", {
+							requestId: id,
+							filename,
+							sourcePath: stylesheetRegistry?.resolveExternalSource(filename) ?? stylesheetRegistry?.resolveExternalSource(filename.replace(/^\//, "")),
+							trackedRequestIds: stylesheetRegistry?.getRequestIdsForSource(stylesheetRegistry?.resolveExternalSource(filename) ?? stylesheetRegistry?.resolveExternalSource(filename.replace(/^\//, "")) ?? "") ?? []
+						});
+						debugStylesV("load: served inline component stylesheet", {
+							filename,
+							length: componentStyles.length,
+							requestId: id,
+							...describeStylesheetContent(componentStyles)
+						});
+						return componentStyles;
+					}
+				}
+			},
+			transform: {
+				filter: { id: {
+					include: [TS_EXT_REGEX],
+					exclude: [
+						/node_modules/,
+						"type=script",
+						"@ng/component"
+					]
+				} },
+				async handler(code, id) {
+					/**
+					* Check for options.transformFilter
+					*/
+					if (options?.transformFilter && !(options?.transformFilter(code, id) ?? true)) return;
+					if (pluginOptions.useAngularCompilationAPI) {
+						if (!/(Component|Directive|Pipe|Injectable|NgModule)\(/.test(code)) {
+							debugCompilationApi("transform skip (non-Angular file)", { id });
+							return;
+						}
+					}
+					/**
+					* Skip transforming content files
+					*/
+					if (id.includes("?") && id.includes("analog-content-")) return;
+					if (id.includes(".ts?")) id = id.replace(/\?(.*)/, "");
+					fileTransformMap.set(id, code);
+					/**
+					* Re-analyze on each transform
+					* for test(Vitest)
+					*/
+					if (isTest) {
+						if (isVitestVscode && !initialCompilation) {
+							pendingCompilation = performCompilation(resolvedConfig);
+							initialCompilation = true;
+						}
+						const tsMod = viteServer?.moduleGraph.getModuleById(id);
+						if (tsMod) {
+							const invalidated = tsMod.lastInvalidationTimestamp;
+							if (testWatchMode && invalidated) pendingCompilation = performCompilation(resolvedConfig, [id]);
+						}
+					}
+					const hasComponent = code.includes("@Component");
+					debugCompilerV("transform", {
+						id,
+						codeLength: code.length,
+						hasComponent
+					});
+					const templateUrls = hasComponent ? templateUrlsResolver.resolve(code, id) : [];
+					const styleUrls = hasComponent ? styleUrlsResolver.resolve(code, id) : [];
+					if (hasComponent && watchMode) for (const urlSet of [...templateUrls, ...styleUrls]) {
+						const [, absoluteFileUrl] = urlSet.split("|");
+						this.addWatchFile(absoluteFileUrl);
+					}
+					if (pendingCompilation) {
+						await pendingCompilation;
+						pendingCompilation = null;
+					}
+					const typescriptResult = fileEmitter(id);
+					if (!typescriptResult) {
+						debugCompilerV("transform skip (file not emitted by Angular)", { id });
+						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) => {
+							const [templateFile, resolvedTemplateUrl] = templateUrlSet.split("|");
+							data = data.replace(`angular:jit:template:file;${templateFile}`, toVirtualRawId(resolvedTemplateUrl));
+						});
+						styleUrls.forEach((styleUrlSet) => {
+							const [styleFile, resolvedStyleUrl] = styleUrlSet.split("|");
+							data = data.replace(`angular:jit:style:file;${styleFile}`, toVirtualStyleId(resolvedStyleUrl));
+						});
+					}
+					if (data.includes("HmrLoad")) {
+						const hasMetaUrl = data.includes("getReplaceMetadataURL");
+						debugHmrV("vite-ignore injection", {
+							id,
+							dataLength: data.length,
+							hasMetaUrl
+						});
+						if (hasMetaUrl) {
+							const patched = injectViteIgnoreForHmrMetadata(data);
+							if (patched !== data && !patched.includes("@vite-ignore")) debugHmrV("vite-ignore regex fallback", { id });
+							data = patched;
+						}
+					}
+					return {
+						code: data,
+						map: null
+					};
+				}
+			},
+			closeBundle() {
+				declarationFiles.forEach(({ declarationFileDir, declarationPath, data }) => {
+					mkdirSync(declarationFileDir, { recursive: true });
+					writeFileSync(declarationPath, data, "utf-8");
+				});
+				angularCompilation?.close?.();
+				angularCompilation = void 0;
+			}
+		};
+	}
+	const compilationPlugin = pluginOptions.fastCompile ? fastCompilePlugin({
+		tsconfigGetter: pluginOptions.tsconfigGetter,
+		workspaceRoot: pluginOptions.workspaceRoot,
+		inlineStylesExtension: pluginOptions.inlineStylesExtension,
+		jit,
+		liveReload: pluginOptions.liveReload,
+		supportedBrowsers: pluginOptions.supportedBrowsers,
+		transformFilter: options?.transformFilter,
+		isTest,
+		isAstroIntegration,
+		fastCompileMode: pluginOptions.fastCompileMode
+	}) : angularPlugin();
+	return [
+		replaceFiles(pluginOptions.fileReplacements, pluginOptions.workspaceRoot),
+		{
+			name: "@analogjs/vite-plugin-angular:template-class-binding-guard",
+			enforce: "pre",
+			transform(code, id) {
+				if (id.includes("node_modules")) return;
+				const cleanId = id.split("?")[0];
+				if (/\.(html|htm)$/i.test(cleanId)) {
+					const staticClassIssue = findStaticClassAndBoundClassConflicts(code)[0];
+					if (staticClassIssue) throwTemplateClassBindingConflict(cleanId, staticClassIssue);
+					const mixedClassIssue = findBoundClassAndNgClassConflicts(code)[0];
+					if (mixedClassIssue) this.warn([
+						"[Analog Angular] Conflicting class composition.",
+						`File: ${cleanId}:${mixedClassIssue.line}:${mixedClassIssue.column}`,
+						"This element mixes `[class]` and `[ngClass]`.",
+						"Prefer a single class-binding strategy so class merging stays predictable.",
+						"Use one `[ngClass]` expression or explicit `[class.foo]` bindings.",
+						`Snippet: ${mixedClassIssue.snippet}`
+					].join("\n"));
+					return;
+				}
+				if (TS_EXT_REGEX.test(cleanId)) {
+					const rawStyleUrls = styleUrlsResolver.resolve(code, cleanId);
+					registerStyleOwnerMetadata(cleanId, rawStyleUrls);
+					debugHmrV("component stylesheet owner metadata registered", {
+						file: cleanId,
+						styleUrlCount: rawStyleUrls.length,
+						styleUrls: rawStyleUrls,
+						ownerSources: [...transformedStyleOwnerMetadata.get(cleanId)?.map((record) => record.sourcePath) ?? []]
+					});
+					const components = getAngularComponentMetadata(code);
+					const inlineTemplateIssue = components.flatMap((component) => component.inlineTemplates.flatMap((template) => findStaticClassAndBoundClassConflicts(template)))[0];
+					if (inlineTemplateIssue) throwTemplateClassBindingConflict(cleanId, inlineTemplateIssue);
+					const mixedInlineClassIssue = components.flatMap((component) => component.inlineTemplates.flatMap((template) => findBoundClassAndNgClassConflicts(template)))[0];
+					if (mixedInlineClassIssue) this.warn([
+						"[Analog Angular] Conflicting class composition.",
+						`File: ${cleanId}:${mixedInlineClassIssue.line}:${mixedInlineClassIssue.column}`,
+						"This element mixes `[class]` and `[ngClass]`.",
+						"Prefer a single class-binding strategy so class merging stays predictable.",
+						"Use one `[ngClass]` expression or explicit `[class.foo]` bindings.",
+						`Snippet: ${mixedInlineClassIssue.snippet}`
+					].join("\n"));
+					registerActiveGraphMetadata(cleanId, components.map((component) => ({
+						file: cleanId,
+						className: component.className,
+						selector: component.selector
+					})));
+					for (const component of components) {
+						if (!component.selector && !isLikelyPageOnlyComponent(cleanId)) throw new Error([
+							"[Analog Angular] Selectorless component detected.",
+							`File: ${cleanId}`,
+							`Component: ${component.className}`,
+							"This component has no `selector`, so Angular will render it as `ng-component`.",
+							"That increases the chance of component ID collisions and makes diagnostics harder to interpret.",
+							"Add an explicit selector for reusable components.",
+							"Selectorless components are only supported for page and route-only files."
+						].join("\n"));
+						if (component.selector) {
+							const selectorEntries = selectorOwners.get(component.selector);
+							if (selectorEntries && selectorEntries.size > 1) throw new Error([
+								"[Analog Angular] Duplicate component selector detected.",
+								`Selector: ${component.selector}`,
+								"Multiple components in the active application graph use the same selector.",
+								"Selectors must be unique within the active graph to avoid ambiguous rendering and confusing diagnostics.",
+								`Locations:\n${formatActiveGraphLocations(selectorEntries)}`
+							].join("\n"));
+						}
+						const classNameEntries = classNameOwners.get(component.className);
+						if (classNameEntries && classNameEntries.size > 1) this.warn([
+							"[Analog Angular] Duplicate component class name detected.",
+							`Class name: ${component.className}`,
+							"Two or more Angular components in the active graph share the same exported class name.",
+							"Rename one of them to keep HMR, stack traces, and compiler diagnostics unambiguous.",
+							`Locations:\n${formatActiveGraphLocations(classNameEntries)}`
+						].join("\n"));
+					}
+				}
+			}
+		},
+		pluginOptions.hasTailwindCss && {
+			name: "@analogjs/vite-plugin-angular:tailwind-reference",
+			enforce: "pre",
+			transform(code, id) {
+				const tw = pluginOptions.tailwindCss;
+				if (!tw || !id.includes(".css")) return;
+				if (id.split("?")[0] === tw.rootStylesheet) return;
+				const directiveState = inspectCssTailwindDirectives(code);
+				if (directiveState.hasReferenceDirective || directiveState.hasTailwindImportDirective) return;
+				const rootBasename = basename(tw.rootStylesheet);
+				if (directiveState.commentlessCode.includes(rootBasename)) return;
+				const prefixes = tw.prefixes;
+				const needsRef = prefixes ? prefixes.some((p) => directiveState.commentlessCode.includes(p)) : directiveState.commentlessCode.includes("@apply");
+				if (needsRef && directiveState.hasReferenceText) throwTailwindReferenceTextError(id, tw.rootStylesheet);
+				if (needsRef) {
+					debugTailwind("injected @reference via pre-transform", { id: id.split("/").slice(-2).join("/") });
+					return `@reference "${tw.rootStylesheet.replace(/\\/g, "/")}";\n${code}`;
+				}
+			}
+		},
+		angularPlugin(),
+		pluginOptions.liveReload && liveReloadPlugin({
+			classNames,
+			fileEmitter
+		}),
+		compilationPlugin,
+		!pluginOptions.fastCompile && pluginOptions.liveReload && liveReloadPlugin({
+			classNames,
+			fileEmitter
+		}),
+		...isTest && !isStackBlitz ? angularVitestPlugins() : [],
+		jit && jitPlugin({ inlineStylesExtension: pluginOptions.inlineStylesExtension }),
+		buildOptimizerPlugin({
+			supportedBrowsers: pluginOptions.supportedBrowsers,
+			jit
+		}),
+		routerPlugin(),
+		angularFullVersion < 190004 && pendingTasksPlugin(),
+		nxFolderPlugin(),
+		{
+			name: "@analogjs/vite-plugin-angular:encapsulation",
+			enforce: "post",
+			transform(code, id) {
+				if (shouldExternalizeStyles() && isComponentStyleSheet(id)) {
+					const { encapsulation, componentId } = getComponentStyleSheetMeta(id);
+					if (encapsulation === "emulated" && componentId) {
+						debugStylesV("applying emulated view encapsulation (post)", {
+							stylesheet: id.split("?")[0],
+							componentId
+						});
+						return {
+							code: ngCompiler.encapsulateStyle(code, componentId),
+							map: null
+						};
+					}
+				}
+			}
+		}
+	].filter(Boolean);
+	function findIncludes() {
+		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();
+			debugEmit("include cache populated", { fileCount: includeCache.length });
+		}
+		return includeCache;
+	}
+	function getTsconfigCacheKey(resolvedTsConfigPath, config) {
+		return [
+			resolvedTsConfigPath,
+			config.mode === "production" ? "prod" : "dev",
+			isTest ? "test" : "app",
+			config.build?.lib ? "lib" : "nolib",
+			pluginOptions.liveReload ? "live-reload" : "no-live-reload",
+			pluginOptions.hasTailwindCss ? "tw" : "notw"
+		].join("|");
+	}
+	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 = 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();
+		const cached = getCachedTsconfigOptions(resolvedTsConfigPath, config);
+		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 ?? {};
+		const wrapperPayload = {
+			extends: normalizePath(resolvedTsConfigPath),
+			files: [...mergedRootNames].sort(),
+			...rawTsconfig.references ? { references: rawTsconfig.references } : {}
+		};
+		const wrapperPath = join(wrapperDir, `tsconfig.includes.${createHash("sha1").update(JSON.stringify(wrapperPayload)).digest("hex").slice(0, 12)}.json`);
+		mkdirSync(wrapperDir, { recursive: true });
+		if (!existsSync(wrapperPath)) writeFileSync(wrapperPath, `${JSON.stringify(wrapperPayload, null, 2)}\n`, "utf-8");
+		debugCompilationApi("generated include wrapper tsconfig", {
+			originalTsconfig: resolvedTsConfigPath,
+			wrapperTsconfig: wrapperPath,
+			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() {
+		const tsconfigValue = pluginOptions.tsconfigGetter();
+		return getTsConfigPath(tsConfigResolutionContext.root, tsconfigValue, tsConfigResolutionContext.isProd, isTest, tsConfigResolutionContext.isLib);
+	}
+	/**
+	* Perform compilation using Angular's private Compilation API.
+	*
+	* Key differences from the standard `performCompilation` path:
+	*  1. The compilation instance is reused across rebuilds (nullish-coalescing
+	*     assignment below) so Angular retains prior state and can diff it to
+	*     produce `templateUpdates` for HMR.
+	*  2. `ids` (modified files) are forwarded to both the source-file cache and
+	*     `angularCompilation.update()` so that incremental re-analysis is
+	*     scoped to what actually changed.
+	*  3. `fileReplacements` are converted and passed into Angular's host via
+	*     `toAngularCompilationFileReplacements`.
+	*  4. `templateUpdates` from the compilation result are mapped back to
+	*     file-level HMR metadata (`hmrUpdateCode`, `hmrEligible`, `classNames`).
+	*/
+	async function performAngularCompilation(config, ids) {
+		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 && compilation.update) {
+			debugCompilationApi("incremental update", { files: [...modifiedFiles] });
+			await compilation.update(modifiedFiles);
+		}
+		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) {
+				const filename = resourceFile ?? containingFile.replace(".ts", `.${pluginOptions.inlineStylesExtension}`);
+				const preprocessed = preprocessStylesheetResult(data, filename, pluginOptions.stylePreprocessor, {
+					filename,
+					containingFile,
+					resourceFile,
+					className,
+					order,
+					inline: !resourceFile
+				});
+				if (shouldEnableLiveReload() && className && containingFile) classNames.set(normalizePath(containingFile), className);
+				if (shouldExternalizeStyles()) {
+					const stylesheetId = registerStylesheetContent(stylesheetRegistry, {
+						code: preprocessed.code,
+						dependencies: normalizeStylesheetDependencies(preprocessed.dependencies),
+						diagnostics: preprocessed.diagnostics,
+						tags: preprocessed.tags,
+						containingFile,
+						className,
+						order,
+						inlineStylesExtension: pluginOptions.inlineStylesExtension,
+						resourceFile: resourceFile ?? void 0
+					});
+					debugStyles("stylesheet deferred to Vite pipeline", {
+						stylesheetId,
+						resourceFile: resourceFile ?? "(inline)"
+					});
+					debugStylesV("stylesheet deferred content snapshot", {
+						stylesheetId,
+						filename,
+						resourceFile: resourceFile ?? "(inline)",
+						dependencies: preprocessed.dependencies,
+						diagnostics: preprocessed.diagnostics,
+						tags: preprocessed.tags,
+						...describeStylesheetContent(preprocessed.code)
+					});
+					return stylesheetId;
+				}
+				debugStyles("stylesheet processed inline via preprocessCSS", {
+					filename,
+					resourceFile: resourceFile ?? "(inline)",
+					dataLength: preprocessed.code.length
+				});
+				if (!shouldPreprocessTestCss(resolvedConfig, filename)) return "";
+				let stylesheetResult;
+				try {
+					stylesheetResult = await preprocessCSS(preprocessed.code, `${filename}?direct`, resolvedConfig);
+				} catch (e) {
+					if (isTailwindReferenceError(e)) throw e;
+					debugStyles("preprocessCSS error", {
+						filename,
+						resourceFile: resourceFile ?? "(inline)",
+						error: String(e)
+					});
+				}
+				return stylesheetResult?.code || "";
+			},
+			processWebWorker(workerFile, containingFile) {
+				return "";
+			}
+		}, (tsCompilerOptions) => {
+			if (shouldExternalizeStyles()) tsCompilerOptions["externalRuntimeStyles"] = true;
+			if (shouldEnableLiveReload()) {
+				tsCompilerOptions["_enableHmr"] = true;
+				tsCompilerOptions["supportTestBed"] = true;
+			}
+			debugCompiler("tsCompilerOptions (compilation API)", {
+				liveReload: pluginOptions.liveReload,
+				viteHmr: hasViteHmrTransport(),
+				hasTailwindCss: pluginOptions.hasTailwindCss,
+				watchMode,
+				shouldExternalize: shouldExternalizeStyles(),
+				externalRuntimeStyles: !!tsCompilerOptions["externalRuntimeStyles"],
+				hmrEnabled: !!tsCompilerOptions["_enableHmr"]
+			});
+			if (tsCompilerOptions.compilationMode === "partial") {
+				tsCompilerOptions["supportTestBed"] = true;
+				tsCompilerOptions["supportJitMode"] = true;
+			}
+			if (!isTest && config.build?.lib) {
+				tsCompilerOptions["declaration"] = true;
+				tsCompilerOptions["declarationMap"] = watchMode;
+				tsCompilerOptions["inlineSources"] = true;
+			}
+			if (isTest) tsCompilerOptions["supportTestBed"] = true;
+			return tsCompilerOptions;
+		});
+		debugStyles("external stylesheets from compilation API", {
+			count: compilationResult.externalStylesheets?.size ?? 0,
+			hasPreprocessor: !!pluginOptions.stylePreprocessor,
+			hasInlineMap: !!stylesheetRegistry
+		});
+		const preprocessStats = {
+			total: 0,
+			injected: 0,
+			skipped: 0,
+			errors: 0
+		};
+		for (const [key, value] of compilationResult.externalStylesheets ?? []) {
+			preprocessStats.total++;
+			const angularHash = `${value}.css`;
+			stylesheetRegistry?.registerExternalRequest(angularHash, key);
+			if (stylesheetRegistry && pluginOptions.stylePreprocessor && existsSync(key)) try {
+				const rawCss = readFileSync(key, "utf-8");
+				const preprocessed = preprocessStylesheetResult(rawCss, key, pluginOptions.stylePreprocessor);
+				debugStylesV("external stylesheet raw snapshot", {
+					angularHash,
+					resolvedPath: key,
+					mtimeMs: safeStatMtimeMs(key),
+					...describeStylesheetContent(rawCss)
+				});
+				const servedCss = rewriteRelativeCssImports(preprocessed.code, key);
+				stylesheetRegistry.registerServedStylesheet({
+					publicId: angularHash,
+					sourcePath: key,
+					originalCode: rawCss,
+					normalizedCode: servedCss,
+					dependencies: normalizeStylesheetDependencies(preprocessed.dependencies),
+					diagnostics: preprocessed.diagnostics,
+					tags: preprocessed.tags
+				}, [
+					key,
+					normalizePath(key),
+					basename(key),
+					key.replace(/^\//, "")
+				]);
+				if (servedCss && servedCss !== rawCss) {
+					preprocessStats.injected++;
+					debugStylesV("preprocessed external stylesheet for Tailwind @reference", {
+						angularHash,
+						resolvedPath: key,
+						mtimeMs: safeStatMtimeMs(key),
+						raw: describeStylesheetContent(rawCss),
+						served: describeStylesheetContent(servedCss),
+						dependencies: preprocessed.dependencies,
+						diagnostics: preprocessed.diagnostics,
+						tags: preprocessed.tags
+					});
+				} else {
+					preprocessStats.skipped++;
+					debugStylesV("external stylesheet unchanged after preprocessing", {
+						angularHash,
+						resolvedPath: key,
+						mtimeMs: safeStatMtimeMs(key),
+						raw: describeStylesheetContent(rawCss),
+						served: describeStylesheetContent(servedCss),
+						dependencies: preprocessed.dependencies,
+						diagnostics: preprocessed.diagnostics,
+						tags: preprocessed.tags,
+						hint: "Registry mapping is still registered so Angular component stylesheet HMR can track and refresh this file even when preprocessing makes no textual changes."
+					});
+				}
+			} catch (e) {
+				preprocessStats.errors++;
+				console.warn(`[@analogjs/vite-plugin-angular] failed to preprocess external stylesheet: ${key}: ${e}`);
+			}
+			else {
+				preprocessStats.skipped++;
+				debugStylesV("external stylesheet preprocessing skipped", {
+					filename: angularHash,
+					resolvedPath: key,
+					reason: !stylesheetRegistry ? "no stylesheetRegistry" : !pluginOptions.stylePreprocessor ? "no stylePreprocessor" : "file not found on disk"
+				});
+			}
+			debugStylesV("external stylesheet registered for resolveId mapping", {
+				filename: angularHash,
+				resolvedPath: key
+			});
+		}
+		debugStyles("external stylesheet preprocessing complete", preprocessStats);
+		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()]
+		});
+		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);
+			outputFiles.set(normalizedFilename, {
+				content: file.contents,
+				dependencies: [],
+				errors: errors.map((error) => error.text || ""),
+				warnings: warnings.map((warning) => warning.text || ""),
+				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) {
+		let resolve;
+		const previousLock = compilationLock;
+		compilationLock = new Promise((r) => {
+			resolve = r;
+		});
+		try {
+			await previousLock;
+			await _doPerformCompilation(config, ids);
+		} finally {
+			resolve();
+		}
+	}
+	/**
+	* This method share mutable state and performs the actual compilation work.
+	* It should not be called concurrently. Use `performCompilation` which wraps this method in a lock to ensure only one compilation runs at a time.
+	*/
+	async function _doPerformCompilation(config, ids) {
+		if (pluginOptions.useAngularCompilationAPI) {
+			debugCompilationApi("using compilation API path", { modifiedFiles: ids?.length ?? 0 });
+			await performAngularCompilation(config, ids);
+			return;
+		}
+		const isProd = config.mode === "production";
+		const modifiedFiles = new Set(ids ?? []);
+		sourceFileCache$1.invalidate(modifiedFiles);
+		if (ids?.length) for (const id of ids || []) fileTransformMap.delete(id);
+		const cached = getCachedTsconfigOptions(resolveTsConfigPath(), config);
+		const tsCompilerOptions = { ...cached.options };
+		let rootNames = [...cached.rootNames];
+		if (shouldExternalizeStyles()) tsCompilerOptions["externalRuntimeStyles"] = true;
+		if (shouldEnableLiveReload()) {
+			tsCompilerOptions["_enableHmr"] = true;
+			tsCompilerOptions["supportTestBed"] = true;
+		}
+		debugCompiler("tsCompilerOptions (NgtscProgram path)", {
+			liveReload: pluginOptions.liveReload,
+			viteHmr: hasViteHmrTransport(),
+			shouldExternalize: shouldExternalizeStyles(),
+			externalRuntimeStyles: !!tsCompilerOptions["externalRuntimeStyles"],
+			hmrEnabled: !!tsCompilerOptions["_enableHmr"]
+		});
+		if (tsCompilerOptions["compilationMode"] === "partial") {
+			tsCompilerOptions["supportTestBed"] = true;
+			tsCompilerOptions["supportJitMode"] = true;
+		}
+		if (!isTest && config.build?.lib) {
+			tsCompilerOptions["declaration"] = true;
+			tsCompilerOptions["declarationMap"] = watchMode;
+			tsCompilerOptions["inlineSources"] = true;
+		}
+		if (isTest) tsCompilerOptions["supportTestBed"] = true;
+		const replacements = pluginOptions.fileReplacements.map((rp) => join(pluginOptions.workspaceRoot, rp.ssr || rp.with));
+		rootNames = union(rootNames, ensureIncludeCache(), replacements);
+		const hostKey = JSON.stringify(tsCompilerOptions);
+		let host;
+		if (cachedHost && cachedHostKey === hostKey) host = cachedHost;
+		else {
+			host = ts.createIncrementalCompilerHost(tsCompilerOptions, {
+				...ts.sys,
+				readFile(path, encoding) {
+					if (fileTransformMap.has(path)) return fileTransformMap.get(path);
+					const file = ts.sys.readFile.call(null, path, encoding);
+					if (file) fileTransformMap.set(path, file);
+					return file;
+				}
+			});
+			cachedHost = host;
+			cachedHostKey = hostKey;
+			if (watchMode) augmentHostWithCaching(host, sourceFileCache$1);
+		}
+		if (!jit) {
+			const externalizeStyles = !!tsCompilerOptions["externalRuntimeStyles"];
+			stylesheetRegistry = externalizeStyles ? new AnalogStylesheetRegistry() : void 0;
+			if (stylesheetRegistry) configureStylePipelineRegistry(pluginOptions.stylePipeline, stylesheetRegistry, { workspaceRoot: pluginOptions.workspaceRoot });
+			debugStyles("stylesheet registry initialized (NgtscProgram path)", { externalizeStyles });
+			augmentHostWithResources(host, styleTransform, {
+				inlineStylesExtension: pluginOptions.inlineStylesExtension,
+				isProd,
+				stylesheetRegistry,
+				sourceFileCache: sourceFileCache$1,
+				stylePreprocessor: pluginOptions.stylePreprocessor
+			});
+		}
+		/**
+		* Creates a new NgtscProgram to analyze/re-analyze
+		* the source files and create a file emitter.
+		* This is shared between an initial build and a hot update.
+		*/
+		let typeScriptProgram;
+		let angularCompiler;
+		const oldBuilder = builder ?? ts.readBuilderProgram(tsCompilerOptions, host);
+		if (!jit) {
+			const angularProgram = new compilerCli.NgtscProgram(rootNames, tsCompilerOptions, host, nextProgram);
+			angularCompiler = angularProgram.compiler;
+			typeScriptProgram = angularProgram.compiler.getCurrentProgram();
+			augmentProgramWithVersioning(typeScriptProgram);
+			builder = ts.createEmitAndSemanticDiagnosticsBuilderProgram(typeScriptProgram, host, oldBuilder);
+			nextProgram = angularProgram;
+		} else {
+			builder = ts.createEmitAndSemanticDiagnosticsBuilderProgram(rootNames, tsCompilerOptions, host, oldBuilder);
+			typeScriptProgram = builder.getProgram();
+		}
+		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.liveReload, pluginOptions.disableTypeChecking);
+		const writeFileCallback = (_filename, content, _a, _b, sourceFiles) => {
+			if (!sourceFiles?.length) return;
+			const filename = normalizePath(sourceFiles[0].fileName);
+			if (filename.includes("ngtypecheck.ts") || filename.includes(".d.")) return;
+			const metadata = watchMode ? fileMetadata(filename) : {};
+			outputFiles.set(filename, {
+				content,
+				dependencies: [],
+				errors: metadata.errors,
+				warnings: metadata.warnings,
+				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);
+			if (!sourceFile) return;
+			let content = "";
+			builder.emit(sourceFile, (filename, data) => {
+				if (/\.[cm]?js$/.test(filename)) content = data;
+				if (!watchMode && !isTest && /\.d\.ts/.test(filename) && !filename.includes(".ngtypecheck.")) {
+					const declarationPath = resolve(config.root, config.build.outDir, relative(config.root, filename)).replace("/src/", "/");
+					const declarationFileDir = declarationPath.replace(basename(filename), "").replace("/src/", "/");
+					declarationFiles.push({
+						declarationFileDir,
+						declarationPath,
+						data
+					});
+				}
+			}, void 0, void 0, transformers);
+			writeFileCallback(id, content, false, void 0, [sourceFile]);
+			if (angularCompiler) angularCompiler.incrementalCompilation.recordSuccessfulEmit(sourceFile);
+		};
+		if (watchMode) {
+			if (ids && ids.length > 0) ids.forEach((id) => writeOutputFile(id));
+			else if (isTest) while (builder.emitNextAffectedFile(writeFileCallback, void 0, void 0, transformers));
+		}
+		if (!isTest)
+ /**
+		* Perf: Output files on demand so the dev server
+		* isn't blocked when emitting files.
+		*/
+		outputFile = writeOutputFile;
+	}
+}
+function createFsWatcherCacheInvalidator(invalidateFsCaches, invalidateTsconfigCaches, performCompilation) {
+	return async () => {
+		invalidateFsCaches();
+		invalidateTsconfigCaches();
+		await performCompilation();
+	};
+}
 /**
- * TypeScript file extension regex
- * Match .(c or m)ts, .ts extensions with an optional ? for query params
- * Ignore .tsx extensions
- */
-const TS_EXT_REGEX = /\.[cm]?(ts)[^x]?\??/;
-const classNames = new Map();
-export function angular(options) {
-    /**
-     * Normalize plugin options so defaults
-     * are used for values not provided.
-     */
-    const pluginOptions = {
-        tsconfigGetter: createTsConfigGetter(options?.tsconfig),
-        workspaceRoot: options?.workspaceRoot ?? process.cwd(),
-        inlineStylesExtension: options?.inlineStylesExtension ?? 'css',
-        advanced: {
-            tsTransformers: {
-                before: options?.advanced?.tsTransformers?.before ?? [],
-                after: options?.advanced?.tsTransformers?.after ?? [],
-                afterDeclarations: options?.advanced?.tsTransformers?.afterDeclarations ?? [],
-            },
-        },
-        supportedBrowsers: options?.supportedBrowsers ?? ['safari 15'],
-        jit: options?.jit,
-        include: options?.include ?? [],
-        additionalContentDirs: options?.additionalContentDirs ?? [],
-        liveReload: options?.liveReload ?? false,
-        disableTypeChecking: options?.disableTypeChecking ?? true,
-        fileReplacements: options?.fileReplacements ?? [],
-        useAngularCompilationAPI: options?.experimental?.useAngularCompilationAPI ?? false,
-    };
-    let resolvedConfig;
-    // Store config context needed for getTsConfigPath resolution
-    let tsConfigResolutionContext = null;
-    const ts = require('typescript');
-    let builder;
-    let nextProgram;
-    // Caches (always rebuild Angular program per user request)
-    const tsconfigOptionsCache = new Map();
-    let cachedHost;
-    let cachedHostKey;
-    let includeCache = [];
-    function invalidateFsCaches() {
-        includeCache = [];
-    }
-    function invalidateTsconfigCaches() {
-        tsconfigOptionsCache.clear();
-        cachedHost = undefined;
-        cachedHostKey = undefined;
-    }
-    let watchMode = false;
-    let testWatchMode = isTestWatchMode();
-    let inlineComponentStyles;
-    let externalComponentStyles;
-    const sourceFileCache = new SourceFileCache();
-    const isTest = process.env['NODE_ENV'] === 'test' || !!process.env['VITEST'];
-    const isVitestVscode = !!process.env['VITEST_VSCODE'];
-    const isStackBlitz = !!process.versions['webcontainer'];
-    const isAstroIntegration = process.env['ANALOG_ASTRO'] === 'true';
-    const jit = typeof pluginOptions?.jit !== 'undefined' ? pluginOptions.jit : isTest;
-    let viteServer;
-    const styleUrlsResolver = new StyleUrlsResolver();
-    const templateUrlsResolver = new TemplateUrlsResolver();
-    let outputFile;
-    const outputFiles = new Map();
-    const fileEmitter = (file) => {
-        outputFile?.(file);
-        return outputFiles.get(normalizePath(file));
-    };
-    let initialCompilation = false;
-    const declarationFiles = [];
-    const fileTransformMap = new Map();
-    let styleTransform;
-    let pendingCompilation;
-    let compilationLock = Promise.resolve();
-    function angularPlugin() {
-        let isProd = false;
-        if (angularFullVersion < 190000 || isTest) {
-            pluginOptions.liveReload = false;
-        }
-        if (pluginOptions.useAngularCompilationAPI) {
-            if (angularFullVersion < 200100) {
-                pluginOptions.useAngularCompilationAPI = false;
-                console.warn('[@analogjs/vite-plugin-angular]: The Angular Compilation API is only available with Angular v20.1 and later');
-            }
-            if (pluginOptions.liveReload) {
-                pluginOptions.liveReload = false;
-                console.warn('[@analogjs-vite-plugin-angular]: Live reload is currently not compatible with the Angular Compilation API option');
-            }
-            if (pluginOptions.fileReplacements.length) {
-                pluginOptions.fileReplacements = [];
-                console.warn('[@analogjs-vite-plugin-angular]: File replacements are currently not compatible with the Angular Compilation API option');
-            }
-        }
-        return {
-            name: '@analogjs/vite-plugin-angular',
-            async config(config, { command }) {
-                watchMode = command === 'serve';
-                isProd =
-                    config.mode === 'production' ||
-                        process.env['NODE_ENV'] === 'production';
-                // Store the config context for later resolution in configResolved
-                tsConfigResolutionContext = {
-                    root: config.root || '.',
-                    isProd,
-                    isLib: !!config?.build?.lib,
-                };
-                // Do a preliminary resolution for esbuild plugin (before configResolved)
-                const preliminaryTsConfigPath = resolveTsConfigPath();
-                const esbuild = pluginOptions.useAngularCompilationAPI
-                    ? undefined
-                    : (config.esbuild ?? false);
-                const oxc = pluginOptions.useAngularCompilationAPI
-                    ? undefined
-                    : (config.oxc ?? false);
-                const defineOptions = {
-                    ngJitMode: 'false',
-                    ngI18nClosureMode: 'false',
-                    ...(watchMode ? {} : { ngDevMode: 'false' }),
-                };
-                const rolldownOptions = {
-                    plugins: [
-                        createRolldownCompilerPlugin({
-                            tsconfig: preliminaryTsConfigPath,
-                            sourcemap: !isProd,
-                            advancedOptimizations: isProd,
-                            jit,
-                            incremental: watchMode,
-                        }),
-                    ],
-                };
-                const esbuildOptions = {
-                    plugins: [
-                        createCompilerPlugin({
-                            tsconfig: preliminaryTsConfigPath,
-                            sourcemap: !isProd,
-                            advancedOptimizations: isProd,
-                            jit,
-                            incremental: watchMode,
-                        }, isTest, !isAstroIntegration),
-                    ],
-                    define: defineOptions,
-                };
-                return {
-                    ...(vite.rolldownVersion ? { oxc } : { esbuild }),
-                    optimizeDeps: {
-                        include: ['rxjs/operators', 'rxjs'],
-                        exclude: ['@angular/platform-server'],
-                        ...(vite.rolldownVersion
-                            ? { rolldownOptions }
-                            : { esbuildOptions }),
-                    },
-                    resolve: {
-                        conditions: [
-                            'style',
-                            ...(config.resolve?.conditions || defaultClientConditions),
-                        ],
-                    },
-                };
-            },
-            configResolved(config) {
-                resolvedConfig = config;
-                if (pluginOptions.useAngularCompilationAPI) {
-                    externalComponentStyles = new Map();
-                    inlineComponentStyles = new Map();
-                }
-                if (!jit) {
-                    styleTransform = (code, filename) => preprocessCSS(code, filename, config);
-                }
-                if (isTest) {
-                    // set test watch mode
-                    // - vite override from vitest-angular
-                    // - @nx/vite executor set server.watch explicitly to undefined (watch)/null (watch=false)
-                    // - vite config for test.watch variable
-                    // - vitest watch mode detected from the command line
-                    testWatchMode =
-                        !(config.server.watch === null) ||
-                            config.test?.watch === true ||
-                            testWatchMode;
-                }
-            },
-            configureServer(server) {
-                viteServer = server;
-                server.watcher.on('add', async () => {
-                    invalidateFsCaches();
-                    await performCompilation(resolvedConfig);
-                });
-                server.watcher.on('unlink', async () => {
-                    invalidateFsCaches();
-                    await performCompilation(resolvedConfig);
-                });
-                server.watcher.on('change', (file) => {
-                    if (file.includes('tsconfig')) {
-                        invalidateTsconfigCaches();
-                    }
-                });
-            },
-            async buildStart() {
-                // Defer the first compilation in test mode
-                if (!isVitestVscode) {
-                    await performCompilation(resolvedConfig);
-                    pendingCompilation = null;
-                    initialCompilation = true;
-                }
-            },
-            async handleHotUpdate(ctx) {
-                if (TS_EXT_REGEX.test(ctx.file)) {
-                    const [fileId] = ctx.file.split('?');
-                    pendingCompilation = performCompilation(resolvedConfig, [fileId]);
-                    let result;
-                    if (pluginOptions.liveReload) {
-                        await pendingCompilation;
-                        pendingCompilation = null;
-                        result = fileEmitter(fileId);
-                    }
-                    if (pluginOptions.liveReload &&
-                        result?.hmrEligible &&
-                        classNames.get(fileId)) {
-                        const relativeFileId = `${relative(process.cwd(), fileId)}@${classNames.get(fileId)}`;
-                        sendHMRComponentUpdate(ctx.server, relativeFileId);
-                        return ctx.modules.map((mod) => {
-                            if (mod.id === ctx.file) {
-                                return markModuleSelfAccepting(mod);
-                            }
-                            return mod;
-                        });
-                    }
-                }
-                if (/\.(html|htm|css|less|sass|scss)$/.test(ctx.file)) {
-                    fileTransformMap.delete(ctx.file.split('?')[0]);
-                    /**
-                     * Check to see if this was a direct request
-                     * for an external resource (styles, html).
-                     */
-                    const isDirect = ctx.modules.find((mod) => ctx.file === mod.file && mod.id?.includes('?direct'));
-                    const isInline = ctx.modules.find((mod) => ctx.file === mod.file && mod.id?.includes('?inline'));
-                    if (isDirect || isInline) {
-                        if (pluginOptions.liveReload && isDirect?.id && isDirect.file) {
-                            const isComponentStyle = isDirect.type === 'css' && isComponentStyleSheet(isDirect.id);
-                            if (isComponentStyle) {
-                                const { encapsulation } = getComponentStyleSheetMeta(isDirect.id);
-                                // Track if the component uses ShadowDOM encapsulation
-                                // Shadow DOM components currently require a full reload.
-                                // Vite's CSS hot replacement does not support shadow root searching.
-                                if (encapsulation !== 'shadow') {
-                                    ctx.server.ws.send({
-                                        type: 'update',
-                                        updates: [
-                                            {
-                                                type: 'css-update',
-                                                timestamp: Date.now(),
-                                                path: isDirect.url,
-                                                acceptedPath: isDirect.file,
-                                            },
-                                        ],
-                                    });
-                                    return ctx.modules
-                                        .filter((mod) => {
-                                        // Component stylesheets will have 2 modules (*.component.scss and *.component.scss?direct&ngcomp=xyz&e=x)
-                                        // We remove the module with the query params to prevent vite double logging the stylesheet name "hmr update *.component.scss, *.component.scss?direct&ngcomp=xyz&e=x"
-                                        return mod.file !== ctx.file || mod.id !== isDirect.id;
-                                    })
-                                        .map((mod) => {
-                                        if (mod.file === ctx.file) {
-                                            return markModuleSelfAccepting(mod);
-                                        }
-                                        return mod;
-                                    });
-                                }
-                            }
-                        }
-                        return ctx.modules;
-                    }
-                    const mods = [];
-                    const updates = [];
-                    ctx.modules.forEach((mod) => {
-                        mod.importers.forEach((imp) => {
-                            ctx.server.moduleGraph.invalidateModule(imp);
-                            if (pluginOptions.liveReload && classNames.get(imp.id)) {
-                                updates.push(imp.id);
-                            }
-                            else {
-                                mods.push(imp);
-                            }
-                        });
-                    });
-                    pendingCompilation = performCompilation(resolvedConfig, [
-                        ...mods.map((mod) => mod.id),
-                        ...updates,
-                    ]);
-                    if (updates.length > 0) {
-                        await pendingCompilation;
-                        pendingCompilation = null;
-                        updates.forEach((updateId) => {
-                            const impRelativeFileId = `${relative(process.cwd(), updateId)}@${classNames.get(updateId)}`;
-                            sendHMRComponentUpdate(ctx.server, impRelativeFileId);
-                        });
-                        return ctx.modules.map((mod) => {
-                            if (mod.id === ctx.file) {
-                                return markModuleSelfAccepting(mod);
-                            }
-                            return mod;
-                        });
-                    }
-                    return mods;
-                }
-                // clear HMR updates with a full reload
-                classNames.clear();
-                return ctx.modules;
-            },
-            resolveId(id, importer) {
-                if (jit && id.startsWith('angular:jit:')) {
-                    const path = id.split(';')[1];
-                    return `${normalizePath(resolve(dirname(importer), path))}?${id.includes(':style') ? 'inline' : 'raw'}`;
-                }
-                // Map angular external styleUrls to the source file
-                if (isComponentStyleSheet(id)) {
-                    const componentStyles = externalComponentStyles?.get(getFilenameFromPath(id));
-                    if (componentStyles) {
-                        return componentStyles + new URL(id, 'http://localhost').search;
-                    }
-                }
-                return undefined;
-            },
-            async load(id) {
-                // Map angular inline styles to the source text
-                if (isComponentStyleSheet(id)) {
-                    const componentStyles = inlineComponentStyles?.get(getFilenameFromPath(id));
-                    if (componentStyles) {
-                        return componentStyles;
-                    }
-                }
-                return;
-            },
-            transform: {
-                filter: {
-                    id: {
-                        include: [TS_EXT_REGEX],
-                        exclude: [/node_modules/, 'type=script', '@ng/component'],
-                    },
-                },
-                async handler(code, id) {
-                    /**
-                     * Check for options.transformFilter
-                     */
-                    if (options?.transformFilter &&
-                        !(options?.transformFilter(code, id) ?? true)) {
-                        return;
-                    }
-                    if (pluginOptions.useAngularCompilationAPI) {
-                        const isAngular = /(Component|Directive|Pipe|Injectable|NgModule)\(/.test(code);
-                        if (!isAngular) {
-                            return;
-                        }
-                    }
-                    /**
-                     * Skip transforming content files
-                     */
-                    if (id.includes('?') && id.includes('analog-content-')) {
-                        return;
-                    }
-                    /**
-                     * Encapsulate component stylesheets that use emulated encapsulation
-                     */
-                    if (pluginOptions.liveReload && isComponentStyleSheet(id)) {
-                        const { encapsulation, componentId } = getComponentStyleSheetMeta(id);
-                        if (encapsulation === 'emulated' && componentId) {
-                            const encapsulated = ngCompiler.encapsulateStyle(code, componentId);
-                            return {
-                                code: encapsulated,
-                                map: null,
-                            };
-                        }
-                    }
-                    if (id.includes('.ts?')) {
-                        // Strip the query string off the ID
-                        // in case of a dynamically loaded file
-                        id = id.replace(/\?(.*)/, '');
-                    }
-                    fileTransformMap.set(id, code);
-                    /**
-                     * Re-analyze on each transform
-                     * for test(Vitest)
-                     */
-                    if (isTest) {
-                        if (isVitestVscode && !initialCompilation) {
-                            // Do full initial compilation
-                            pendingCompilation = performCompilation(resolvedConfig);
-                            initialCompilation = true;
-                        }
-                        const tsMod = viteServer?.moduleGraph.getModuleById(id);
-                        if (tsMod) {
-                            const invalidated = tsMod.lastInvalidationTimestamp;
-                            if (testWatchMode && invalidated) {
-                                pendingCompilation = performCompilation(resolvedConfig, [id]);
-                            }
-                        }
-                    }
-                    const hasComponent = code.includes('@Component');
-                    const templateUrls = hasComponent
-                        ? templateUrlsResolver.resolve(code, id)
-                        : [];
-                    const styleUrls = hasComponent
-                        ? styleUrlsResolver.resolve(code, id)
-                        : [];
-                    if (hasComponent && watchMode) {
-                        for (const urlSet of [...templateUrls, ...styleUrls]) {
-                            // `urlSet` is a string where a relative path is joined with an
-                            // absolute path using the `|` symbol.
-                            // For example: `./app.component.html|/home/projects/analog/src/app/app.component.html`.
-                            const [, absoluteFileUrl] = urlSet.split('|');
-                            this.addWatchFile(absoluteFileUrl);
-                        }
-                    }
-                    if (pendingCompilation) {
-                        await pendingCompilation;
-                        pendingCompilation = null;
-                    }
-                    const typescriptResult = fileEmitter(id);
-                    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')}`);
-                    }
-                    // return fileEmitter
-                    let data = typescriptResult?.content ?? '';
-                    if (jit && data.includes('angular:jit:')) {
-                        data = data.replace(/angular:jit:style:inline;/g, 'virtual:angular:jit:style:inline;');
-                        templateUrls.forEach((templateUrlSet) => {
-                            const [templateFile, resolvedTemplateUrl] = templateUrlSet.split('|');
-                            data = data.replace(`angular:jit:template:file;${templateFile}`, `${resolvedTemplateUrl}?raw`);
-                        });
-                        styleUrls.forEach((styleUrlSet) => {
-                            const [styleFile, resolvedStyleUrl] = styleUrlSet.split('|');
-                            data = data.replace(`angular:jit:style:file;${styleFile}`, `${resolvedStyleUrl}?inline`);
-                        });
-                    }
-                    return {
-                        code: data,
-                        map: null,
-                    };
-                },
-            },
-            closeBundle() {
-                declarationFiles.forEach(({ declarationFileDir, declarationPath, data }) => {
-                    mkdirSync(declarationFileDir, { recursive: true });
-                    writeFileSync(declarationPath, data, 'utf-8');
-                });
-            },
-        };
-    }
-    return [
-        replaceFiles(pluginOptions.fileReplacements, pluginOptions.workspaceRoot),
-        angularPlugin(),
-        pluginOptions.liveReload && liveReloadPlugin({ classNames, fileEmitter }),
-        ...(isTest && !isStackBlitz ? angularVitestPlugins() : []),
-        (jit &&
-            jitPlugin({
-                inlineStylesExtension: pluginOptions.inlineStylesExtension,
-            })),
-        buildOptimizerPlugin({
-            supportedBrowsers: pluginOptions.supportedBrowsers,
-            jit,
-        }),
-        routerPlugin(),
-        angularFullVersion < 190004 && pendingTasksPlugin(),
-        nxFolderPlugin(),
-    ].filter(Boolean);
-    function findIncludes() {
-        const workspaceRoot = normalizePath(resolve(pluginOptions.workspaceRoot));
-        // Map include patterns to absolute workspace paths
-        const globs = [
-            ...pluginOptions.include.map((glob) => `${workspaceRoot}${glob}`),
-        ];
-        // Discover TypeScript files using tinyglobby
-        return globSync(globs, {
-            dot: true,
-            absolute: true,
-        });
-    }
-    function createTsConfigGetter(tsconfigOrGetter) {
-        if (typeof tsconfigOrGetter === 'function') {
-            return tsconfigOrGetter;
-        }
-        return () => tsconfigOrGetter || '';
-    }
-    function getTsConfigPath(root, tsconfig, isProd, isTest, isLib) {
-        if (tsconfig && isAbsolute(tsconfig)) {
-            if (!existsSync(tsconfig)) {
-                console.error(`[@analogjs/vite-plugin-angular]: Unable to resolve tsconfig at ${tsconfig}. This causes compilation issues. Check the path or set the "tsconfig" property with an absolute path.`);
-            }
-            return tsconfig;
-        }
-        let tsconfigFilePath = './tsconfig.app.json';
-        if (isLib) {
-            tsconfigFilePath = isProd
-                ? './tsconfig.lib.prod.json'
-                : './tsconfig.lib.json';
-        }
-        if (isTest) {
-            tsconfigFilePath = './tsconfig.spec.json';
-        }
-        if (tsconfig) {
-            tsconfigFilePath = tsconfig;
-        }
-        const resolvedPath = resolve(root, tsconfigFilePath);
-        if (!existsSync(resolvedPath)) {
-            console.error(`[@analogjs/vite-plugin-angular]: Unable to resolve tsconfig at ${resolvedPath}. This causes compilation issues. Check the path or set the "tsconfig" property with an absolute path.`);
-        }
-        return resolvedPath;
-    }
-    function resolveTsConfigPath() {
-        const tsconfigValue = pluginOptions.tsconfigGetter();
-        return getTsConfigPath(tsConfigResolutionContext.root, tsconfigValue, tsConfigResolutionContext.isProd, isTest, tsConfigResolutionContext.isLib);
-    }
-    async function performAngularCompilation(config) {
-        const compilation = await createAngularCompilation(!!pluginOptions.jit, false);
-        const resolvedTsConfigPath = resolveTsConfigPath();
-        const compilationResult = await compilation.initialize(resolvedTsConfigPath, {
-            async transformStylesheet(data, containingFile, resourceFile, order, className) {
-                if (pluginOptions.liveReload) {
-                    const id = createHash('sha256')
-                        .update(containingFile)
-                        .update(className)
-                        .update(String(order))
-                        .update(data)
-                        .digest('hex');
-                    const filename = id + '.' + pluginOptions.inlineStylesExtension;
-                    inlineComponentStyles.set(filename, data);
-                    return filename;
-                }
-                const filename = resourceFile ??
-                    containingFile.replace('.ts', `.${options?.inlineStylesExtension}`);
-                let stylesheetResult;
-                try {
-                    stylesheetResult = await preprocessCSS(data, `${filename}?direct`, resolvedConfig);
-                }
-                catch (e) {
-                    console.error(`${e}`);
-                }
-                return stylesheetResult?.code || '';
-            },
-            processWebWorker(workerFile, containingFile) {
-                return '';
-            },
-        }, (tsCompilerOptions) => {
-            if (pluginOptions.liveReload && watchMode) {
-                tsCompilerOptions['_enableHmr'] = true;
-                tsCompilerOptions['externalRuntimeStyles'] = true;
-                // Workaround for https://github.com/angular/angular/issues/59310
-                // Force extra instructions to be generated for HMR w/defer
-                tsCompilerOptions['supportTestBed'] = true;
-            }
-            if (tsCompilerOptions.compilationMode === 'partial') {
-                // These options can't be false in partial mode
-                tsCompilerOptions['supportTestBed'] = true;
-                tsCompilerOptions['supportJitMode'] = true;
-            }
-            if (!isTest && config.build?.lib) {
-                tsCompilerOptions['declaration'] = true;
-                tsCompilerOptions['declarationMap'] = watchMode;
-                tsCompilerOptions['inlineSources'] = true;
-            }
-            if (isTest) {
-                // Allow `TestBed.overrideXXX()` APIs.
-                tsCompilerOptions['supportTestBed'] = true;
-            }
-            return tsCompilerOptions;
-        });
-        compilationResult.externalStylesheets?.forEach((value, key) => {
-            externalComponentStyles?.set(`${value}.css`, key);
-        });
-        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 : [];
-        for (const file of await compilation.emitAffectedFiles()) {
-            outputFiles.set(file.filename, {
-                content: file.contents,
-                dependencies: [],
-                errors: errors.map((error) => error.text || ''),
-                warnings: warnings.map((warning) => warning.text || ''),
-            });
-        }
-        compilation.close?.();
-    }
-    async function performCompilation(config, ids) {
-        let resolve;
-        const previousLock = compilationLock;
-        compilationLock = new Promise((r) => {
-            resolve = r;
-        });
-        try {
-            await previousLock;
-            await _doPerformCompilation(config, ids);
-        }
-        finally {
-            resolve();
-        }
-    }
-    /**
-     * This method share mutable state and performs the actual compilation work.
-     * It should not be called concurrently. Use `performCompilation` which wraps this method in a lock to ensure only one compilation runs at a time.
-     */
-    async function _doPerformCompilation(config, ids) {
-        if (pluginOptions.useAngularCompilationAPI) {
-            await performAngularCompilation(config);
-            return;
-        }
-        const isProd = config.mode === 'production';
-        const modifiedFiles = new Set(ids ?? []);
-        sourceFileCache.invalidate(modifiedFiles);
-        if (ids?.length) {
-            for (const id of ids || []) {
-                fileTransformMap.delete(id);
-            }
-        }
-        // Cached include discovery (invalidated only on FS events)
-        if (pluginOptions.include.length > 0 && includeCache.length === 0) {
-            includeCache = findIncludes();
-        }
-        const resolvedTsConfigPath = resolveTsConfigPath();
-        const tsconfigKey = [
-            resolvedTsConfigPath,
-            isProd ? 'prod' : 'dev',
-            isTest ? 'test' : 'app',
-            config.build?.lib ? 'lib' : 'nolib',
-        ].join('|');
-        let cached = tsconfigOptionsCache.get(tsconfigKey);
-        if (!cached) {
-            const read = compilerCli.readConfiguration(resolvedTsConfigPath, {
-                suppressOutputPathCheck: true,
-                outDir: undefined,
-                sourceMap: false,
-                inlineSourceMap: !isProd,
-                inlineSources: !isProd,
-                declaration: false,
-                declarationMap: false,
-                allowEmptyCodegenFiles: false,
-                annotationsAs: 'decorators',
-                enableResourceInlining: false,
-                noEmitOnError: false,
-                mapRoot: undefined,
-                sourceRoot: undefined,
-                supportTestBed: false,
-                supportJitMode: false,
-            });
-            cached = { options: read.options, rootNames: read.rootNames };
-            tsconfigOptionsCache.set(tsconfigKey, cached);
-        }
-        // Clone options before mutation (preserve cache purity)
-        const tsCompilerOptions = { ...cached.options };
-        let rootNames = [...cached.rootNames];
-        if (pluginOptions.liveReload && watchMode) {
-            tsCompilerOptions['_enableHmr'] = true;
-            tsCompilerOptions['externalRuntimeStyles'] = true;
-            // Workaround for https://github.com/angular/angular/issues/59310
-            // Force extra instructions to be generated for HMR w/defer
-            tsCompilerOptions['supportTestBed'] = true;
-        }
-        if (tsCompilerOptions['compilationMode'] === 'partial') {
-            // These options can't be false in partial mode
-            tsCompilerOptions['supportTestBed'] = true;
-            tsCompilerOptions['supportJitMode'] = true;
-        }
-        if (!isTest && config.build?.lib) {
-            tsCompilerOptions['declaration'] = true;
-            tsCompilerOptions['declarationMap'] = watchMode;
-            tsCompilerOptions['inlineSources'] = true;
-        }
-        if (isTest) {
-            // Allow `TestBed.overrideXXX()` APIs.
-            tsCompilerOptions['supportTestBed'] = true;
-        }
-        const replacements = pluginOptions.fileReplacements.map((rp) => join(pluginOptions.workspaceRoot, rp.ssr || rp.with));
-        // Merge + dedupe root names
-        rootNames = [...new Set([...rootNames, ...includeCache, ...replacements])];
-        const hostKey = JSON.stringify(tsCompilerOptions);
-        let host;
-        if (cachedHost && cachedHostKey === hostKey) {
-            host = cachedHost;
-        }
-        else {
-            host = ts.createIncrementalCompilerHost(tsCompilerOptions, {
-                ...ts.sys,
-                readFile(path, encoding) {
-                    if (fileTransformMap.has(path)) {
-                        return fileTransformMap.get(path);
-                    }
-                    const file = ts.sys.readFile.call(null, path, encoding);
-                    if (file) {
-                        fileTransformMap.set(path, file);
-                    }
-                    return file;
-                },
-            });
-            cachedHost = host;
-            cachedHostKey = hostKey;
-            // Only store cache if in watch mode
-            if (watchMode) {
-                augmentHostWithCaching(host, sourceFileCache);
-            }
-        }
-        if (!jit) {
-            inlineComponentStyles = tsCompilerOptions['externalRuntimeStyles']
-                ? new Map()
-                : undefined;
-            externalComponentStyles = tsCompilerOptions['externalRuntimeStyles']
-                ? new Map()
-                : undefined;
-            augmentHostWithResources(host, styleTransform, {
-                inlineStylesExtension: pluginOptions.inlineStylesExtension,
-                isProd,
-                inlineComponentStyles,
-                externalComponentStyles,
-                sourceFileCache,
-            });
-        }
-        /**
-         * Creates a new NgtscProgram to analyze/re-analyze
-         * the source files and create a file emitter.
-         * This is shared between an initial build and a hot update.
-         */
-        let typeScriptProgram;
-        let angularCompiler;
-        const oldBuilder = builder ?? ts.readBuilderProgram(tsCompilerOptions, host);
-        if (!jit) {
-            // Create the Angular specific program that contains the Angular compiler
-            const angularProgram = new compilerCli.NgtscProgram(rootNames, tsCompilerOptions, host, nextProgram);
-            angularCompiler = angularProgram.compiler;
-            typeScriptProgram = angularProgram.compiler.getCurrentProgram();
-            augmentProgramWithVersioning(typeScriptProgram);
-            builder = ts.createEmitAndSemanticDiagnosticsBuilderProgram(typeScriptProgram, host, oldBuilder);
-            nextProgram = angularProgram;
-        }
-        else {
-            builder = ts.createEmitAndSemanticDiagnosticsBuilderProgram(rootNames, tsCompilerOptions, host, oldBuilder);
-            typeScriptProgram = builder.getProgram();
-        }
-        if (!watchMode) {
-            // When not in watch mode, the startup cost of the incremental analysis can be avoided by
-            // using an abstract builder that only wraps a TypeScript program.
-            builder = ts.createAbstractBuilder(typeScriptProgram, host, oldBuilder);
-        }
-        if (angularCompiler) {
-            await angularCompiler.analyzeAsync();
-        }
-        const beforeTransformers = jit
-            ? [
-                compilerCli.constructorParametersDownlevelTransform(builder.getProgram()),
-                createJitResourceTransformer(() => builder.getProgram().getTypeChecker()),
-            ]
-            : [];
-        const transformers = mergeTransformers({ before: beforeTransformers }, jit ? {} : angularCompiler.prepareEmit().transformers);
-        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);
-            if (filename.includes('ngtypecheck.ts') || filename.includes('.d.')) {
-                return;
-            }
-            const metadata = watchMode ? fileMetadata(filename) : {};
-            outputFiles.set(filename, {
-                content,
-                dependencies: [],
-                errors: metadata.errors,
-                warnings: metadata.warnings,
-                hmrUpdateCode: metadata.hmrUpdateCode,
-                hmrEligible: metadata.hmrEligible,
-            });
-        };
-        const writeOutputFile = (id) => {
-            const sourceFile = builder.getSourceFile(id);
-            if (!sourceFile) {
-                return;
-            }
-            let content = '';
-            builder.emit(sourceFile, (filename, data) => {
-                if (/\.[cm]?js$/.test(filename)) {
-                    content = data;
-                }
-                if (!watchMode &&
-                    !isTest &&
-                    /\.d\.ts/.test(filename) &&
-                    !filename.includes('.ngtypecheck.')) {
-                    // output to library root instead /src
-                    const declarationPath = resolve(config.root, config.build.outDir, relative(config.root, filename)).replace('/src/', '/');
-                    const declarationFileDir = declarationPath
-                        .replace(basename(filename), '')
-                        .replace('/src/', '/');
-                    declarationFiles.push({
-                        declarationFileDir,
-                        declarationPath,
-                        data,
-                    });
-                }
-            }, undefined /* cancellationToken */, undefined /* emitOnlyDtsFiles */, transformers);
-            writeFileCallback(id, content, false, undefined, [sourceFile]);
-            if (angularCompiler) {
-                angularCompiler.incrementalCompilation.recordSuccessfulEmit(sourceFile);
-            }
-        };
-        if (watchMode) {
-            if (ids && ids.length > 0) {
-                ids.forEach((id) => writeOutputFile(id));
-            }
-            else {
-                /**
-                 * Only block the server from starting up
-                 * during testing.
-                 */
-                if (isTest) {
-                    // TypeScript will loop until there are no more affected files in the program
-                    while (builder.emitNextAffectedFile(writeFileCallback, undefined, undefined, transformers)) {
-                        /* empty */
-                    }
-                }
-            }
-        }
-        if (!isTest) {
-            /**
-             * Perf: Output files on demand so the dev server
-             * isn't blocked when emitting files.
-             */
-            outputFile = writeOutputFile;
-        }
-    }
+* Convert Analog/Angular CLI-style file replacements into the flat record
+* expected by `AngularHostOptions.fileReplacements`.
+*
+* Only browser replacements (`{ replace, with }`) are converted. SSR-only
+* replacements (`{ replace, ssr }`) are left for the Vite runtime plugin to
+* handle — they should not be baked into the Angular compilation host because
+* that would apply them to both browser and server builds.
+*
+* Relative paths are resolved against `workspaceRoot` so that the host
+* receives the same absolute paths it would get from the Angular CLI.
+*/
+function toAngularCompilationFileReplacements(replacements, workspaceRoot) {
+	const mappedReplacements = replacements.flatMap((replacement) => {
+		if (!("with" in replacement)) return [];
+		return [[isAbsolute(replacement.replace) ? replacement.replace : resolve(workspaceRoot, replacement.replace), isAbsolute(replacement.with) ? replacement.with : resolve(workspaceRoot, replacement.with)]];
+	});
+	return mappedReplacements.length ? Object.fromEntries(mappedReplacements) : void 0;
+}
+/**
+* Map Angular's `templateUpdates` (keyed by `encodedFilePath@ClassName`)
+* back to absolute file paths with their associated HMR code and component
+* class name.
+*
+* Angular's private Compilation API emits template update keys in the form
+* `encodeURIComponent(relativePath + '@' + className)`. We decode and resolve
+* them so the caller can look up updates by the same normalized absolute path
+* used elsewhere in the plugin (`outputFiles`, `classNames`, etc.).
+*/
+function mapTemplateUpdatesToFiles(templateUpdates) {
+	const updatesByFile = /* @__PURE__ */ new Map();
+	templateUpdates?.forEach((code, encodedUpdateId) => {
+		const [file, className = ""] = decodeURIComponent(encodedUpdateId).split("@");
+		const resolvedFile = normalizePath(resolve(process.cwd(), file));
+		updatesByFile.set(resolvedFile, {
+			className,
+			code
+		});
+	});
+	return updatesByFile;
+}
+/**
+* Returns every live Vite module that can legitimately represent a changed
+* Angular resource file.
+*
+* For normal files, `getModulesByFile()` is enough. For Angular component
+* stylesheets, it is not: the browser often holds virtual hashed requests
+* (`/abc123.css?direct&ngcomp=...` and `/abc123.css?ngcomp=...`) that are no
+* longer discoverable from the original source path alone. We therefore merge:
+* - watcher event modules
+* - module-graph modules by source file
+* - registry-tracked live request ids resolved back through the module graph
+*/
+async function getModulesForChangedFile(server, file, eventModules = [], stylesheetRegistry) {
+	const normalizedFile = normalizePath(file.split("?")[0]);
+	const modules = /* @__PURE__ */ new Map();
+	for (const mod of eventModules) if (mod.id) modules.set(mod.id, mod);
+	server.moduleGraph.getModulesByFile(normalizedFile)?.forEach((mod) => {
+		if (mod.id) modules.set(mod.id, mod);
+	});
+	const stylesheetRequestIds = stylesheetRegistry?.getRequestIdsForSource(normalizedFile) ?? [];
+	const requestIdHits = [];
+	for (const requestId of stylesheetRequestIds) {
+		const candidates = [requestId, requestId.startsWith("/") ? requestId : `/${requestId}`];
+		for (const candidate of candidates) {
+			const mod = await server.moduleGraph.getModuleByUrl(candidate) ?? server.moduleGraph.getModuleById(candidate);
+			requestIdHits.push({
+				requestId,
+				candidate,
+				via: mod?.url === candidate ? "url" : "id",
+				moduleId: mod?.id
+			});
+			if (mod?.id) modules.set(mod.id, mod);
+		}
+	}
+	debugHmrV("getModulesForChangedFile registry lookup", {
+		file: normalizedFile,
+		stylesheetRequestIds,
+		requestIdHits,
+		resolvedModuleIds: [...modules.keys()]
+	});
+	return [...modules.values()];
+}
+function isModuleForChangedResource(mod, changedFile, stylesheetRegistry) {
+	const normalizedChangedFile = normalizePath(changedFile.split("?")[0]);
+	if (normalizePath((mod.file ?? "").split("?")[0]) === normalizedChangedFile) return true;
+	if (!mod.id) return false;
+	const requestPath = getFilenameFromPath(mod.id);
+	return normalizePath((stylesheetRegistry?.resolveExternalSource(requestPath) ?? stylesheetRegistry?.resolveExternalSource(requestPath.replace(/^\//, "")) ?? "").split("?")[0]) === normalizedChangedFile;
+}
+function describeStylesheetContent(code) {
+	return {
+		length: code.length,
+		digest: createHash("sha256").update(code).digest("hex").slice(0, 12),
+		preview: code.replace(/\s+/g, " ").trim().slice(0, 160)
+	};
+}
+function safeStatMtimeMs(file) {
+	try {
+		return statSync(file).mtimeMs;
+	} catch {
+		return;
+	}
+}
+/**
+* Refreshes any already-served stylesheet records that map back to a changed
+* source file.
+*
+* This is the critical bridge for externalized Angular component styles during
+* HMR. Angular's resource watcher can notice that `/src/...component.css`
+* changed before Angular recompilation has had a chance to repopulate the
+* stylesheet registry. If we emit a CSS update against the existing virtual
+* stylesheet id without first refreshing the registry content, the browser gets
+* a hot update containing stale CSS. By rewriting the existing served records
+* from disk up front, HMR always pushes the latest source content.
+*/
+function refreshStylesheetRegistryForFile(file, stylesheetRegistry, stylePreprocessor) {
+	const normalizedFile = normalizePath(file.split("?")[0]);
+	if (!stylesheetRegistry || !existsSync(normalizedFile)) return;
+	const publicIds = stylesheetRegistry.getPublicIdsForSource(normalizedFile);
+	if (publicIds.length === 0) return;
+	const rawCss = readFileSync(normalizedFile, "utf-8");
+	const preprocessed = preprocessStylesheetResult(rawCss, normalizedFile, stylePreprocessor);
+	const servedCss = rewriteRelativeCssImports(preprocessed.code, normalizedFile);
+	for (const publicId of publicIds) stylesheetRegistry.registerServedStylesheet({
+		publicId,
+		sourcePath: normalizedFile,
+		originalCode: rawCss,
+		normalizedCode: servedCss,
+		dependencies: normalizeStylesheetDependencies(preprocessed.dependencies),
+		diagnostics: preprocessed.diagnostics,
+		tags: preprocessed.tags
+	}, [
+		normalizedFile,
+		normalizePath(normalizedFile),
+		basename(normalizedFile),
+		normalizedFile.replace(/^\//, "")
+	]);
+	debugStylesV("stylesheet registry refreshed from source file", {
+		file: normalizedFile,
+		publicIds,
+		dependencies: preprocessed.dependencies,
+		diagnostics: preprocessed.diagnostics,
+		tags: preprocessed.tags,
+		source: describeStylesheetContent(rawCss),
+		served: describeStylesheetContent(servedCss)
+	});
+}
+function diagnoseComponentStylesheetPipeline(changedFile, directModule, stylesheetRegistry, wrapperModules, stylePreprocessor) {
+	const normalizedFile = normalizePath(changedFile.split("?")[0]);
+	const sourceExists = existsSync(normalizedFile);
+	const sourceCode = sourceExists ? readFileSync(normalizedFile, "utf-8") : void 0;
+	const directRequestPath = directModule.id ? getFilenameFromPath(directModule.id) : void 0;
+	const sourcePath = directRequestPath ? stylesheetRegistry?.resolveExternalSource(directRequestPath) ?? stylesheetRegistry?.resolveExternalSource(directRequestPath.replace(/^\//, "")) : normalizedFile;
+	const registryCode = directRequestPath ? stylesheetRegistry?.getServedContent(directRequestPath) : void 0;
+	const trackedRequestIds = stylesheetRegistry?.getRequestIdsForSource(sourcePath ?? "") ?? [];
+	const dependencies = stylesheetRegistry?.getDependenciesForSource(sourcePath ?? "") ?? [];
+	const diagnostics = stylesheetRegistry?.getDiagnosticsForSource(sourcePath ?? "") ?? [];
+	const tags = stylesheetRegistry?.getTagsForSource(sourcePath ?? "") ?? [];
+	const anomalies = [];
+	const hints = [];
+	if (!sourceExists) {
+		anomalies.push("source_file_missing");
+		hints.push("The stylesheet watcher fired for a file that no longer exists on disk.");
+	}
+	if (!registryCode) {
+		anomalies.push("registry_content_missing");
+		hints.push("The stylesheet registry has no served content for the direct module request path.");
+	}
+	if (sourceCode && registryCode) {
+		let expectedRegistryCode = preprocessStylesheet(sourceCode, normalizedFile, stylePreprocessor);
+		expectedRegistryCode = rewriteRelativeCssImports(expectedRegistryCode, normalizedFile);
+		if (describeStylesheetContent(expectedRegistryCode).digest !== describeStylesheetContent(registryCode).digest) {
+			anomalies.push("source_registry_mismatch");
+			hints.push("The source file changed, but the served stylesheet content in the registry is still stale.");
+		}
+	}
+	if (trackedRequestIds.length === 0) {
+		anomalies.push("no_tracked_requests");
+		hints.push("No live stylesheet requests are tracked for this source file, so HMR has no browser-facing target.");
+	}
+	if (trackedRequestIds.some((id) => id.includes("?ngcomp=")) && wrapperModules.length === 0) {
+		anomalies.push("tracked_wrapper_missing_from_module_graph");
+		hints.push("A wrapper request id is known, but Vite did not expose a live wrapper module during this HMR pass.");
+	}
+	if (trackedRequestIds.every((id) => !id.includes("?ngcomp=")) && wrapperModules.length === 0) {
+		anomalies.push("wrapper_not_yet_tracked");
+		hints.push("Only direct stylesheet requests were tracked during this HMR pass; the wrapper request may be appearing too late.");
+	}
+	return {
+		file: changedFile,
+		sourcePath,
+		source: sourceCode ? describeStylesheetContent(rewriteRelativeCssImports(preprocessStylesheet(sourceCode, normalizedFile, stylePreprocessor), normalizedFile)) : void 0,
+		registry: registryCode ? describeStylesheetContent(registryCode) : void 0,
+		dependencies,
+		diagnostics,
+		tags,
+		directModuleId: directModule.id,
+		directModuleUrl: directModule.url,
+		trackedRequestIds,
+		wrapperCount: wrapperModules.length,
+		anomalies,
+		hints
+	};
+}
+async function findComponentStylesheetWrapperModules(server, changedFile, directModule, fileModules, stylesheetRegistry) {
+	const wrapperModules = /* @__PURE__ */ new Map();
+	for (const mod of fileModules) if (mod.id && mod.type === "js" && isComponentStyleSheet(mod.id) && isModuleForChangedResource(mod, changedFile, stylesheetRegistry)) wrapperModules.set(mod.id, mod);
+	const directRequestIds = /* @__PURE__ */ new Set();
+	if (directModule.id) directRequestIds.add(directModule.id);
+	if (directModule.url) directRequestIds.add(directModule.url);
+	const requestPath = directModule.id ? getFilenameFromPath(directModule.id) : void 0;
+	const sourcePath = requestPath ? stylesheetRegistry?.resolveExternalSource(requestPath) ?? stylesheetRegistry?.resolveExternalSource(requestPath.replace(/^\//, "")) : void 0;
+	for (const requestId of stylesheetRegistry?.getRequestIdsForSource(sourcePath ?? "") ?? []) if (requestId.includes("?ngcomp=")) directRequestIds.add(requestId);
+	const candidateWrapperIds = [...directRequestIds].filter((id) => id.includes("?direct&ngcomp=")).map((id) => id.replace("?direct&ngcomp=", "?ngcomp="));
+	const lookupHits = [];
+	for (const candidate of candidateWrapperIds) {
+		const mod = await server.moduleGraph.getModuleByUrl(candidate) ?? server.moduleGraph.getModuleById(candidate);
+		lookupHits.push({
+			candidate,
+			via: mod?.url === candidate ? "url" : mod ? "id" : void 0,
+			moduleId: mod?.id,
+			moduleType: mod?.type
+		});
+		if (mod?.id && mod.type === "js" && isComponentStyleSheet(mod.id) && isModuleForChangedResource(mod, changedFile, stylesheetRegistry)) wrapperModules.set(mod.id, mod);
+	}
+	debugHmrV("component stylesheet wrapper lookup", {
+		file: changedFile,
+		sourcePath,
+		directModuleId: directModule.id,
+		directModuleUrl: directModule.url,
+		candidateWrapperIds,
+		lookupHits
+	});
+	if (wrapperModules.size === 0) debugHmrV("component stylesheet wrapper lookup empty", {
+		file: changedFile,
+		sourcePath,
+		directModuleId: directModule.id,
+		directModuleUrl: directModule.url,
+		candidateWrapperIds
+	});
+	return [...wrapperModules.values()];
 }
 function sendHMRComponentUpdate(server, id) {
-    server.ws.send('angular:component-update', {
-        id: encodeURIComponent(id),
-        timestamp: Date.now(),
-    });
-    classNames.delete(id);
-}
-export function getFileMetadata(program, angularCompiler, liveReload, disableTypeChecking) {
-    const ts = require('typescript');
-    return (file) => {
-        const sourceFile = program.getSourceFile(file);
-        if (!sourceFile) {
-            return {};
-        }
-        const diagnostics = getDiagnosticsForSourceFile(sourceFile, !!disableTypeChecking, program, angularCompiler);
-        const errors = diagnostics
-            .filter((d) => d.category === ts.DiagnosticCategory?.Error)
-            .map((d) => typeof d.messageText === 'object'
-            ? d.messageText.messageText
-            : d.messageText);
-        const warnings = diagnostics
-            .filter((d) => d.category === ts.DiagnosticCategory?.Warning)
-            .map((d) => d.messageText);
-        let hmrUpdateCode = undefined;
-        let hmrEligible = false;
-        if (liveReload) {
-            for (const node of sourceFile.statements) {
-                if (ts.isClassDeclaration(node) && node.name != null) {
-                    hmrUpdateCode = angularCompiler?.emitHmrUpdateModule(node);
-                    if (hmrUpdateCode) {
-                        classNames.set(file, node.name.getText());
-                        hmrEligible = true;
-                    }
-                }
-            }
-        }
-        return { errors, warnings, hmrUpdateCode, hmrEligible };
-    };
+	debugHmrV("ws send: angular component update", {
+		id,
+		timestamp: Date.now()
+	});
+	server.ws.send("angular:component-update", {
+		id: encodeURIComponent(id),
+		timestamp: Date.now()
+	});
+	classNames.delete(id);
+}
+function sendCssUpdate(server, update) {
+	const timestamp = Date.now();
+	debugHmrV("ws send: css-update", {
+		...update,
+		timestamp
+	});
+	server.ws.send({
+		type: "update",
+		updates: [{
+			type: "css-update",
+			timestamp,
+			path: update.path,
+			acceptedPath: update.acceptedPath
+		}]
+	});
+}
+function sendFullReload(server, details) {
+	debugHmrV("ws send: full-reload", details);
+	server.ws.send("analog:debug-full-reload", details);
+	server.ws.send({ type: "full-reload" });
+}
+function resolveComponentClassNamesForStyleOwner(ownerFile, sourcePath) {
+	if (!existsSync(ownerFile)) return [];
+	const components = getAngularComponentMetadata(readFileSync(ownerFile, "utf-8"));
+	const normalizedSourcePath = normalizePath(sourcePath);
+	return components.filter((component) => component.styleUrls.some((styleUrl) => normalizePath(resolve(dirname(ownerFile), styleUrl)) === normalizedSourcePath)).map((component) => component.className);
+}
+function findStaticClassAndBoundClassConflicts(template) {
+	const issues = [];
+	for (const { index, snippet } of findOpeningTagSnippets(template)) {
+		if (!snippet.includes("[class]")) continue;
+		const hasStaticClass = /\sclass\s*=\s*(['"])(?:(?!\1)[\s\S])*\1/.test(snippet);
+		const hasBoundClass = /\s\[class\]\s*=\s*(['"])(?:(?!\1)[\s\S])*\1/.test(snippet);
+		if (hasStaticClass && hasBoundClass) {
+			const prefix = template.slice(0, index);
+			const line = prefix.split("\n").length;
+			const column = index - prefix.lastIndexOf("\n");
+			issues.push({
+				line,
+				column,
+				snippet: snippet.replace(/\s+/g, " ").trim()
+			});
+		}
+	}
+	return issues;
+}
+function throwTemplateClassBindingConflict(id, issue) {
+	throw new Error([
+		"[Analog Angular] Invalid template class binding.",
+		`File: ${id}:${issue.line}:${issue.column}`,
+		"The same element uses both a static `class=\"...\"` attribute and a whole-element `[class]=\"...\"` binding.",
+		"That pattern can replace or conflict with static Tailwind classes, which makes styles appear to stop applying.",
+		"Use `[ngClass]` or explicit `[class.foo]` bindings instead of `[class]` when the element also has static classes.",
+		`Snippet: ${issue.snippet}`
+	].join("\n"));
+}
+function findBoundClassAndNgClassConflicts(template) {
+	const issues = [];
+	if (!/\[class\]\s*=/.test(template) || !template.includes("[ngClass]")) return issues;
+	for (const { index, snippet } of findOpeningTagSnippets(template)) {
+		if (!/\[class\]\s*=/.test(snippet) || !snippet.includes("[ngClass]")) continue;
+		const prefix = template.slice(0, index);
+		const line = prefix.split("\n").length;
+		const column = index - prefix.lastIndexOf("\n");
+		issues.push({
+			line,
+			column,
+			snippet: snippet.replace(/\s+/g, " ").trim()
+		});
+	}
+	return issues;
+}
+function findOpeningTagSnippets(template) {
+	const matches = [];
+	for (let index = 0; index < template.length; index++) {
+		if (template[index] !== "<") continue;
+		const tagStart = template[index + 1];
+		if (!tagStart || !/[a-zA-Z]/.test(tagStart)) continue;
+		let quote = null;
+		for (let end = index + 1; end < template.length; end++) {
+			const char = template[end];
+			if (quote) {
+				if (char === quote) quote = null;
+				continue;
+			}
+			if (char === "\"" || char === "'") {
+				quote = char;
+				continue;
+			}
+			if (char === ">") {
+				matches.push({
+					index,
+					snippet: template.slice(index, end + 1)
+				});
+				index = end;
+				break;
+			}
+		}
+	}
+	return matches;
+}
+function formatActiveGraphLocations(entries) {
+	return [...entries].sort().map((entry) => `- ${entry}`).join("\n");
+}
+function logComponentStylesheetHmrOutcome(details) {
+	const pitfalls = [];
+	const rejectedPreferredPaths = [];
+	const hints = [];
+	if (details.encapsulation === "shadow") {
+		pitfalls.push("shadow-encapsulation");
+		rejectedPreferredPaths.push("css-update");
+		rejectedPreferredPaths.push("owner-component-update");
+		hints.push("Shadow DOM styles cannot rely on Vite CSS patching because Angular applies them inside a shadow root.");
+	}
+	if (details.diagnosis.anomalies.includes("wrapper_not_yet_tracked")) {
+		pitfalls.push("wrapper-not-yet-tracked");
+		rejectedPreferredPaths.push("css-update");
+		hints.push("The direct stylesheet module exists, but the browser-visible Angular wrapper module was not available in the live graph during this HMR pass.");
+	}
+	if (details.diagnosis.anomalies.includes("tracked_wrapper_missing_from_module_graph")) {
+		pitfalls.push("tracked-wrapper-missing-from-module-graph");
+		rejectedPreferredPaths.push("css-update");
+		hints.push("A wrapper request id is known, but Vite could not resolve a live wrapper module for targeted CSS HMR.");
+	}
+	if ((details.ownerIds?.filter(Boolean).length ?? 0) === 0) {
+		pitfalls.push("no-owner-modules");
+		if (details.outcome === "full-reload") {
+			rejectedPreferredPaths.push("owner-component-update");
+			hints.push("No owning TS component modules were available in the module graph for owner-based fallback.");
+		}
+	} else if ((details.updateIds?.length ?? 0) === 0) {
+		pitfalls.push("owner-modules-without-class-identities");
+		if (details.outcome === "full-reload") {
+			rejectedPreferredPaths.push("owner-component-update");
+			hints.push("Owner modules were found, but Angular did not expose component class identities after recompilation, so no targeted component update could be sent.");
+		}
+	}
+	debugHmrV("component stylesheet hmr outcome", {
+		file: details.file,
+		outcome: details.outcome,
+		encapsulation: details.encapsulation,
+		directModuleId: details.directModuleId,
+		wrapperIds: details.wrapperIds ?? [],
+		ownerIds: details.ownerIds ?? [],
+		updateIds: details.updateIds ?? [],
+		preferredPath: details.encapsulation === "shadow" ? "full-reload" : "css-update",
+		rejectedPreferredPaths: [...new Set(rejectedPreferredPaths)],
+		pitfalls: [...new Set(pitfalls)],
+		anomalies: details.diagnosis.anomalies,
+		hints: [...new Set([...details.diagnosis.hints, ...hints])]
+	});
+}
+function findTemplateOwnerModules(server, resourceFile) {
+	const candidateTsFiles = [normalizePath(resourceFile.split("?")[0]).replace(/\.(html|htm)$/i, ".ts")];
+	const modules = /* @__PURE__ */ new Map();
+	for (const candidate of candidateTsFiles) server.moduleGraph.getModulesByFile(candidate)?.forEach((mod) => {
+		if (mod.id) modules.set(mod.id, mod);
+	});
+	return [...modules.values()];
+}
+function findStyleOwnerModules(server, resourceFile, styleSourceOwners) {
+	const normalizedResourceFile = normalizePath(resourceFile.split("?")[0]);
+	const candidateOwnerFiles = [...styleSourceOwners.get(normalizedResourceFile) ?? []];
+	const modules = /* @__PURE__ */ new Map();
+	for (const ownerFile of candidateOwnerFiles) server.moduleGraph.getModulesByFile(ownerFile)?.forEach((mod) => {
+		if (mod.id) modules.set(mod.id, mod);
+	});
+	return [...modules.values()];
+}
+function getFileMetadata(program, angularCompiler, hmrEnabled, disableTypeChecking) {
+	const ts = require("typescript");
+	return (file) => {
+		const sourceFile = program.getSourceFile(file);
+		if (!sourceFile) return {};
+		const diagnostics = getDiagnosticsForSourceFile(sourceFile, !!disableTypeChecking, program, angularCompiler);
+		const errors = diagnostics.filter((d) => d.category === ts.DiagnosticCategory?.Error).map((d) => typeof d.messageText === "object" ? d.messageText.messageText : d.messageText);
+		const warnings = diagnostics.filter((d) => d.category === ts.DiagnosticCategory?.Warning).map((d) => d.messageText);
+		let hmrUpdateCode = void 0;
+		let hmrEligible = false;
+		if (hmrEnabled) {
+			for (const node of sourceFile.statements) if (ts.isClassDeclaration(node) && node.name != null) {
+				hmrUpdateCode = angularCompiler?.emitHmrUpdateModule(node);
+				if (hmrUpdateCode) {
+					const className = node.name.getText();
+					classNames.set(file, className);
+					hmrEligible = true;
+					debugHmr("NgtscProgram emitHmrUpdateModule", {
+						file,
+						className
+					});
+				}
+			}
+		}
+		return {
+			errors,
+			warnings,
+			hmrUpdateCode,
+			hmrEligible
+		};
+	};
 }
 function getDiagnosticsForSourceFile(sourceFile, disableTypeChecking, program, angularCompiler) {
-    const syntacticDiagnostics = program.getSyntacticDiagnostics(sourceFile);
-    if (disableTypeChecking) {
-        // Syntax errors are cheap to compute and the app will not run if there are any
-        // So always show these types of errors regardless if type checking is disabled
-        return syntacticDiagnostics;
-    }
-    const semanticDiagnostics = program.getSemanticDiagnostics(sourceFile);
-    const angularDiagnostics = angularCompiler
-        ? angularCompiler.getDiagnosticsForFile(sourceFile, 1)
-        : [];
-    return [
-        ...syntacticDiagnostics,
-        ...semanticDiagnostics,
-        ...angularDiagnostics,
-    ];
+	const syntacticDiagnostics = program.getSyntacticDiagnostics(sourceFile);
+	if (disableTypeChecking) return syntacticDiagnostics;
+	const semanticDiagnostics = program.getSemanticDiagnostics(sourceFile);
+	const angularDiagnostics = angularCompiler ? angularCompiler.getDiagnosticsForFile(sourceFile, 1) : [];
+	return [
+		...syntacticDiagnostics,
+		...semanticDiagnostics,
+		...angularDiagnostics
+	];
 }
 function markModuleSelfAccepting(mod) {
-    // support Vite 6
-    if ('_clientModule' in mod) {
-        mod['_clientModule'].isSelfAccepting = true;
-    }
-    return {
-        ...mod,
-        isSelfAccepting: true,
-    };
+	if ("_clientModule" in mod) mod["_clientModule"].isSelfAccepting = true;
+	return {
+		...mod,
+		isSelfAccepting: true
+	};
 }
 function isComponentStyleSheet(id) {
-    return id.includes('ngcomp=');
+	return id.includes("ngcomp=");
 }
 function getComponentStyleSheetMeta(id) {
-    const params = new URL(id, 'http://localhost').searchParams;
-    const encapsulationMapping = {
-        '0': 'emulated',
-        '2': 'none',
-        '3': 'shadow',
-    };
-    return {
-        componentId: params.get('ngcomp'),
-        encapsulation: encapsulationMapping[params.get('e')],
-    };
+	const params = new URL(id, "http://localhost").searchParams;
+	return {
+		componentId: params.get("ngcomp"),
+		encapsulation: {
+			"0": "emulated",
+			"2": "none",
+			"3": "shadow"
+		}[params.get("e")]
+	};
 }
 /**
- * Removes leading / and query string from a url path
- * e.g. /foo.scss?direct&ngcomp=ng-c3153525609&e=0 returns foo.scss
- * @param id
- */
+* Removes leading / and query string from a url path
+* e.g. /foo.scss?direct&ngcomp=ng-c3153525609&e=0 returns foo.scss
+* @param id
+*/
 function getFilenameFromPath(id) {
-    return new URL(id, 'http://localhost').pathname.replace(/^\//, '');
+	try {
+		return new URL(id, "http://localhost").pathname.replace(/^\//, "");
+	} catch {
+		const queryIndex = id.indexOf("?");
+		return (queryIndex >= 0 ? id.slice(0, queryIndex) : id).replace(/^\//, "");
+	}
 }
 /**
- * Checks for vitest run from the command line
- * @returns boolean
- */
-export function isTestWatchMode(args = process.argv) {
-    // vitest --run
-    const hasRun = args.find((arg) => arg.includes('--run'));
-    if (hasRun) {
-        return false;
-    }
-    // vitest --no-run
-    const hasNoRun = args.find((arg) => arg.includes('--no-run'));
-    if (hasNoRun) {
-        return true;
-    }
-    // check for --watch=false or --no-watch
-    const hasWatch = args.find((arg) => arg.includes('watch'));
-    if (hasWatch && ['false', 'no'].some((neg) => hasWatch.includes(neg))) {
-        return false;
-    }
-    // check for --watch false
-    const watchIndex = args.findIndex((arg) => arg.includes('watch'));
-    const watchArg = args[watchIndex + 1];
-    if (watchArg && watchArg === 'false') {
-        return false;
-    }
-    return true;
+* Checks for vitest run from the command line
+* @returns boolean
+*/
+function isTestWatchMode(args = process.argv) {
+	if (args.find((arg) => arg.includes("--run"))) return false;
+	if (args.find((arg) => arg.includes("--no-run"))) return true;
+	const hasWatch = args.find((arg) => arg.includes("watch"));
+	if (hasWatch && ["false", "no"].some((neg) => hasWatch.includes(neg))) return false;
+	const watchArg = args[args.findIndex((arg) => arg.includes("watch")) + 1];
+	if (watchArg && watchArg === "false") return false;
+	return true;
 }
+//#endregion
+export { angular };
+
 //# sourceMappingURL=angular-vite-plugin.js.map