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

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

@@ -1,51 +1,38 @@
-import { angularFullVersion, cjt, createAngularCompilation, sourceFileCache } from "./utils/devkit.js";
+import { angularFullVersion, cjt, 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 { activateDeferredDebug, applyDebugOption, debugCompiler, debugCompilerV, debugEmit, debugEmitV, debugHmr, debugHmrV, debugStyles, debugStylesV } from "./utils/debug.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 { AnalogStylesheetRegistry, preprocessStylesheet, 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 { TsconfigResolver } from "./utils/tsconfig-resolver.js";
+import { configureStylePipelineRegistry } from "./style-pipeline.js";
+import { describeStylesheetContent, injectViteIgnoreForHmrMetadata, isIgnoredHmrFile, isTestWatchMode, refreshStylesheetRegistryForFile } from "./utils/compilation-shared.js";
+import { compilationAPIPlugin } from "./compilation-api/compilation-api-plugin.js";
+import "./compilation-api/index.js";
 import { fastCompilePlugin } from "./fast-compile-plugin.js";
+import { removeActiveGraphMetadata, removeStyleOwnerMetadata, templateClassBindingGuardPlugin } from "./template-class-binding-guard-plugin.js";
+import { buildStylePreprocessor, tailwindReferencePlugin, validateTailwindConfig } from "./tailwind-plugin.js";
+import { encapsulationPlugin, getComponentStyleSheetMeta, isComponentStyleSheet } from "./encapsulation-plugin.js";
+import { virtualModulesPlugin } from "./virtual-modules-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 { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, 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]);
@@ -54,63 +41,6 @@ function evictDeletedFileMetadata(file, { removeActiveGraphMetadata, removeStyle
 	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;
@@ -146,17 +76,21 @@ function angular(options) {
 	const ts = require("typescript");
 	let builder;
 	let nextProgram;
-	const tsconfigOptionsCache = /* @__PURE__ */ new Map();
-	const tsconfigGraphRootCache = /* @__PURE__ */ new Map();
 	let cachedHost;
 	let cachedHostKey;
-	let includeCache = [];
+	const isTest = process.env.NODE_ENV === "test" || !!process.env["VITEST"];
+	const tsconfigResolver = new TsconfigResolver({
+		workspaceRoot: pluginOptions.workspaceRoot,
+		include: pluginOptions.include,
+		liveReload: pluginOptions.liveReload,
+		hasTailwindCss: pluginOptions.hasTailwindCss,
+		isTest
+	});
 	function invalidateFsCaches() {
-		includeCache = [];
+		tsconfigResolver.invalidateIncludeCache();
 	}
 	function invalidateTsconfigCaches() {
-		tsconfigOptionsCache.clear();
-		tsconfigGraphRootCache.clear();
+		tsconfigResolver.invalidateTsconfigCaches();
 		cachedHost = void 0;
 		cachedHostKey = void 0;
 	}
@@ -193,140 +127,26 @@ function angular(options) {
 		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);
-		}
+	function validateNoDuplicateAnalogPlugins(config) {
+		const analogInstances = (config.plugins ?? []).filter((p) => p.name === "@analogjs/vite-plugin-angular");
+		if (analogInstances.length > 1 && !config.build?.ssr) throw new Error(`[@analogjs/vite-plugin-angular] analog() is registered ${analogInstances.length} times. Each instance creates separate style maps, causing component styles to be lost. Remove duplicate registrations.`);
 	}
 	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 guardContext = {
+		styleUrlsResolver,
+		activeGraphComponentMetadata,
+		selectorOwners,
+		classNameOwners,
+		transformedStyleOwnerMetadata,
+		styleSourceOwners
+	};
 	const templateUrlsResolver = new TemplateUrlsResolver();
 	let outputFile;
 	const outputFiles = /* @__PURE__ */ new Map();
@@ -367,7 +187,6 @@ function angular(options) {
 	let styleTransform;
 	let pendingCompilation;
 	let compilationLock = Promise.resolve();
-	let angularCompilation;
 	function angularPlugin() {
 		let isProd = false;
 		if (angularFullVersion < 19e4 && pluginOptions.liveReload) {
@@ -385,11 +204,6 @@ function angular(options) {
 				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 }) {
@@ -402,9 +216,8 @@ function angular(options) {
 					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 esbuild = config.esbuild ?? false;
+				const oxc = config.oxc ?? false;
 				const defineOptions = {
 					ngJitMode: "false",
 					ngI18nClosureMode: "false",
@@ -446,11 +259,16 @@ function angular(options) {
 			},
 			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 (config.logger?.warnOnce) {
+					const originalWarnOnce = config.logger.warnOnce;
+					config.logger.warnOnce = (msg, options) => {
+						if (typeof msg === "string" && msg.includes("Sourcemap") && msg.includes("node_modules")) return;
+						originalWarnOnce(msg, options);
+					};
+				}
+				if (pluginOptions.hasTailwindCss) {
+					validateTailwindConfig(pluginOptions.tailwindCss, config, watchMode);
+					validateNoDuplicateAnalogPlugins(config);
 				}
 				if (!jit) styleTransform = (code, filename) => preprocessCSS(code, filename, config);
 				if (isTest) testWatchMode = !(config.server.watch === null) || config.test?.watch === true || testWatchMode;
@@ -461,8 +279,8 @@ function angular(options) {
 				server.watcher.on("add", invalidateCompilationOnFsChange);
 				server.watcher.on("unlink", (file) => {
 					evictDeletedFileMetadata(file, {
-						removeActiveGraphMetadata,
-						removeStyleOwnerMetadata,
+						removeActiveGraphMetadata: (f) => removeActiveGraphMetadata(guardContext, f),
+						removeStyleOwnerMetadata: (f) => removeStyleOwnerMetadata(guardContext, f),
 						classNamesMap: classNames,
 						fileTransformMap
 					});
@@ -773,24 +591,7 @@ function angular(options) {
 				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);
-				}
+			resolveId(id) {
 				if (isComponentStyleSheet(id)) {
 					const filename = getFilenameFromPath(id);
 					if (stylesheetRegistry?.hasServed(filename)) {
@@ -813,17 +614,6 @@ function angular(options) {
 				}
 			},
 			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);
@@ -859,12 +649,6 @@ function angular(options) {
 					* 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
 					*/
@@ -961,12 +745,29 @@ function angular(options) {
 					mkdirSync(declarationFileDir, { recursive: true });
 					writeFileSync(declarationPath, data, "utf-8");
 				});
-				angularCompilation?.close?.();
-				angularCompilation = void 0;
 			}
 		};
 	}
-	const compilationPlugin = pluginOptions.fastCompile ? fastCompilePlugin({
+	const compilationPlugin = pluginOptions.useAngularCompilationAPI ? compilationAPIPlugin({
+		tsconfigGetter: pluginOptions.tsconfigGetter,
+		workspaceRoot: pluginOptions.workspaceRoot,
+		inlineStylesExtension: pluginOptions.inlineStylesExtension,
+		jit,
+		liveReload: pluginOptions.liveReload,
+		disableTypeChecking: pluginOptions.disableTypeChecking,
+		supportedBrowsers: pluginOptions.supportedBrowsers,
+		transformFilter: options?.transformFilter,
+		fileReplacements: pluginOptions.fileReplacements,
+		stylePreprocessor: pluginOptions.stylePreprocessor,
+		stylePipeline: options?.stylePipeline,
+		hasTailwindCss: pluginOptions.hasTailwindCss,
+		tailwindCss: pluginOptions.tailwindCss,
+		isTest,
+		isAstroIntegration,
+		include: pluginOptions.include,
+		additionalContentDirs: pluginOptions.additionalContentDirs,
+		debug: options?.debug
+	}) : pluginOptions.fastCompile ? fastCompilePlugin({
 		tsconfigGetter: pluginOptions.tsconfigGetter,
 		workspaceRoot: pluginOptions.workspaceRoot,
 		inlineStylesExtension: pluginOptions.inlineStylesExtension,
@@ -980,104 +781,9 @@ function angular(options) {
 	}) : 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}`;
-				}
-			}
-		},
+		virtualModulesPlugin({ jit }),
+		templateClassBindingGuardPlugin(guardContext),
+		pluginOptions.hasTailwindCss && tailwindReferencePlugin({ tailwindCss: pluginOptions.tailwindCss }),
 		angularPlugin(),
 		pluginOptions.liveReload && liveReloadPlugin({
 			classNames,
@@ -1097,457 +803,12 @@ function angular(options) {
 		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
-						};
-					}
-				}
-			}
-		}
+		encapsulationPlugin(shouldExternalizeStyles)
 	].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;
@@ -1566,16 +827,12 @@ function angular(options) {
 	* 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 resolvedTsConfigPath = resolveTsConfigPath();
+		const cached = tsconfigResolver.getCachedTsconfigOptions(resolvedTsConfigPath, config);
 		const tsCompilerOptions = { ...cached.options };
 		let rootNames = [...cached.rootNames];
 		if (shouldExternalizeStyles()) tsCompilerOptions["externalRuntimeStyles"] = true;
@@ -1601,7 +858,7 @@ function angular(options) {
 		}
 		if (isTest) tsCompilerOptions["supportTestBed"] = true;
 		const replacements = pluginOptions.fileReplacements.map((rp) => join(pluginOptions.workspaceRoot, rp.ssr || rp.with));
-		rootNames = union(rootNames, ensureIncludeCache(), replacements);
+		rootNames = union(rootNames, tsconfigResolver.ensureIncludeCache(), replacements);
 		const hostKey = JSON.stringify(tsCompilerOptions);
 		let host;
 		if (cachedHost && cachedHostKey === hostKey) host = cachedHost;
@@ -1716,47 +973,6 @@ function createFsWatcherCacheInvalidator(invalidateFsCaches, invalidateTsconfigC
 	};
 }
 /**
-* 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.
 *
@@ -1805,13 +1021,6 @@ function isModuleForChangedResource(mod, changedFile, stylesheetRegistry) {
 	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;
@@ -1819,50 +1028,6 @@ function safeStatMtimeMs(file) {
 		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);
@@ -1996,83 +1161,6 @@ function resolveComponentClassNamesForStyleOwner(ownerFile, sourcePath) {
 	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 = [];
@@ -2188,20 +1276,6 @@ function markModuleSelfAccepting(mod) {
 		isSelfAccepting: true
 	};
 }
-function isComponentStyleSheet(id) {
-	return id.includes("ngcomp=");
-}
-function getComponentStyleSheetMeta(id) {
-	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
@@ -2219,15 +1293,6 @@ function getFilenameFromPath(id) {
 * 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 };