@analogjs/vite-plugin-angular 3.0.0-alpha.9 → 3.0.0-alpha.90

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

@@ -1,87 +1,126 @@
-import { angularFullVersion, cjt, createAngularCompilation, sourceFileCache } from "./utils/devkit.js";
+import { angularFullVersion, cjt, sourceFileCache } from "./utils/devkit.js";
+import { activateDeferredDebug, applyDebugOption, debugCompiler, debugCompilerV, debugEmit, debugEmitV, debugHmr, debugHmrV, debugStyles, debugStylesV } from "./utils/debug.js";
+import { createCompilerPlugin, createRolldownCompilerPlugin } from "./compiler-plugin.js";
+import { TS_EXT_REGEX, createTsConfigGetter, getTsConfigPath, isProdMode } from "./utils/plugin-config.js";
+import { TsconfigResolver } from "./utils/tsconfig-resolver.js";
 import { getJsTransformConfigKey, isRolldown } from "./utils/rolldown.js";
+import { AnalogStylesheetRegistry, preprocessStylesheet, rewriteRelativeCssImports } from "./stylesheet-registry.js";
+import { discoverAnalogIntegrations } from "./analog-plugin-interop.js";
+import { describeStylesheetContent, injectViteIgnoreForHmrMetadata, isIgnoredHmrFile, isTestWatchMode } from "./utils/compilation-shared.js";
+import { angularVitestPlugins } from "./angular-vitest-plugin.js";
 import { buildOptimizerPlugin } from "./angular-build-optimizer-plugin.js";
+import { toJitInlineStyleId } from "./utils/jit-inline-styles.js";
+import { releaseCssPreprocessorWorkers } from "./utils/css-preprocessor-workers.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 { pendingTasksPlugin } from "./angular-pending-tasks.plugin.js";
 import { liveReloadPlugin } from "./live-reload-plugin.js";
+import { toVirtualRawId } from "./utils/virtual-ids.js";
+import { virtualModulesPlugin } from "./virtual-modules-plugin.js";
+import { encapsulationPlugin, getComponentStyleSheetMeta, isComponentStyleSheet } from "./encapsulation-plugin.js";
 import { nxFolderPlugin } from "./nx-folder-plugin.js";
-import { replaceFiles } from "./plugins/file-replacements.plugin.js";
 import { routerPlugin } from "./router-plugin.js";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { replaceFiles } from "./plugins/file-replacements.plugin.js";
+import { cssExtensionStyleResolverPlugin } from "./utils/css-extension-resolver.js";
+import { loadVirtualRawModule, rewriteHtmlRawImport } from "./utils/virtual-resources.js";
+import { StyleUrlsResolver, TemplateUrlsResolver } from "./component-resolvers.js";
+import { augmentHostWithCaching, augmentHostWithResources, augmentProgramWithVersioning, mergeTransformers } from "./host.js";
+import { markStylePathSafe } from "./utils/safe-module-paths.js";
+import { fastCompilePlugin } from "./fast-compile-plugin.js";
+import { pendingTasksPlugin } from "./angular-pending-tasks.plugin.js";
+import { union } from "es-toolkit";
+import { existsSync, mkdirSync, readFileSync, 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";
-import { createHash } from "node:crypto";
+import { normalizePath, preprocessCSS } from "vite";
+import * as compilerCli from "@angular/compiler-cli";
 //#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;
-}({});
-/**
-* TypeScript file extension regex
-* Match .(c or m)ts, .ts extensions with an optional ? for query params
-* Ignore .tsx extensions
-*/
-var TS_EXT_REGEX = /\.[cm]?(ts)[^x]?\??/;
 var classNames = /* @__PURE__ */ new Map();
+function evictDeletedFileMetadata(file, { classNamesMap, fileTransformMap }) {
+	const normalizedFile = normalizePath(file.split("?")[0]);
+	classNamesMap.delete(normalizedFile);
+	fileTransformMap.delete(normalizedFile);
+}
 function angular(options) {
+	applyDebugOption(options?.debug, options?.workspaceRoot);
+	const liveReload = options?.liveReload ?? true;
+	let externalizeStylesRequested = false;
+	let configureStylesheetRegistry;
+	let transformFilter;
 	/**
 	* Normalize plugin options so defaults
 	* are used for values not provided.
 	*/
 	const pluginOptions = {
 		tsconfigGetter: createTsConfigGetter(options?.tsconfig),
-		workspaceRoot: options?.workspaceRoot ?? process.cwd(),
+		workspaceRoot: options?.workspaceRoot ?? process.env["NX_WORKSPACE_ROOT"] ?? 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,
+		liveReload,
 		disableTypeChecking: options?.disableTypeChecking ?? true,
 		fileReplacements: options?.fileReplacements ?? [],
-		useAngularCompilationAPI: options?.experimental?.useAngularCompilationAPI ?? false
+		fastCompile: options?.fastCompile ?? false,
+		fastCompileMode: options?.fastCompileMode ?? "full",
+		stylePreprocessor: void 0
 	};
 	let resolvedConfig;
 	let tsConfigResolutionContext = null;
 	const ts = require("typescript");
 	let builder;
 	let nextProgram;
-	const tsconfigOptionsCache = /* @__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,
+		isTest
+	});
 	function invalidateFsCaches() {
-		includeCache = [];
+		tsconfigResolver.invalidateIncludeCache();
 	}
 	function invalidateTsconfigCaches() {
-		tsconfigOptionsCache.clear();
+		tsconfigResolver.invalidateTsconfigCaches();
 		cachedHost = void 0;
 		cachedHostKey = void 0;
 	}
 	let watchMode = false;
 	let testWatchMode = isTestWatchMode();
-	let inlineComponentStyles;
-	let externalComponentStyles;
+	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. A Vite plugin asked for it through `analog.setup()` so its styles
+	*      pass through Vite's CSS pipeline (e.g. @tailwindcss/vite)
+	*
+	* 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() || externalizeStylesRequested);
+	}
+	let stylesheetRegistry;
 	const sourceFileCache$1 = new sourceFileCache();
-	const isTest = process.env.NODE_ENV === "test" || !!process.env["VITEST"];
+	const tsSourceFileCache = /* @__PURE__ */ new Map();
+	function invalidateSourceFiles(files) {
+		for (const file of files) tsSourceFileCache.delete(normalizePath(file));
+		sourceFileCache$1.invalidate(files);
+	}
 	const isVitestVscode = !!process.env["VITEST_VSCODE"];
 	const isStackBlitz = !!process.versions["webcontainer"];
 	const isAstroIntegration = process.env["ANALOG_ASTRO"] === "true";
@@ -91,9 +130,36 @@ function angular(options) {
 	const templateUrlsResolver = new TemplateUrlsResolver();
 	let outputFile;
 	const outputFiles = /* @__PURE__ */ new Map();
+	const normalizeEmitterLookupId = (file) => {
+		const normalizedFile = normalizePath(file);
+		if (!normalizedFile.startsWith("/@fs/")) return normalizedFile;
+		return normalizePath(normalizedFile.slice(4).replace(/^\/([A-Za-z]:\/)/, "$1"));
+	};
+	const describeEmitMarkers = (content) => ({
+		contentLength: content.length,
+		hasCmp: content.includes("ɵcmp"),
+		hasFac: content.includes("ɵfac"),
+		hasProv: content.includes("ɵprov"),
+		hasDecorate: content.includes("__decorate"),
+		hasMetadata: content.includes("__metadata")
+	});
 	const fileEmitter = (file) => {
-		outputFile?.(file);
-		return outputFiles.get(normalizePath(file));
+		const normalizedFile = normalizeEmitterLookupId(file);
+		const hadCachedEmit = outputFiles.has(normalizedFile);
+		outputFile?.(normalizedFile);
+		const emittedResult = outputFiles.get(normalizedFile);
+		debugEmitV("fileEmitter lookup", {
+			requestFile: file,
+			normalizedFile,
+			hadCachedEmit,
+			hasOutputFileHook: !!outputFile,
+			emitted: !!emittedResult,
+			knownOutputCount: outputFiles.size,
+			contentLength: emittedResult?.content?.length ?? 0,
+			errorCount: emittedResult?.errors?.length ?? 0,
+			warningCount: emittedResult?.warnings?.length ?? 0
+		});
+		return emittedResult;
 	};
 	let initialCompilation = false;
 	const declarationFiles = [];
@@ -101,29 +167,37 @@ function angular(options) {
 	let styleTransform;
 	let pendingCompilation;
 	let compilationLock = Promise.resolve();
-	let angularCompilation;
 	function angularPlugin() {
 		let isProd = false;
-		if (angularFullVersion < 19e4 || 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 (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
+			});
 		}
 		return {
 			name: "@analogjs/vite-plugin-angular",
 			async config(config, { command }) {
+				activateDeferredDebug(command);
 				watchMode = command === "serve";
-				isProd = config.mode === "production" || process.env.NODE_ENV === "production";
+				isProd = isProdMode(config.mode);
 				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;
+				const esbuild = config.esbuild ?? false;
+				const oxc = config.oxc ?? false;
 				const defineOptions = {
 					ngJitMode: "false",
 					ngI18nClosureMode: "false",
@@ -138,7 +212,7 @@ function angular(options) {
 					advancedOptimizations: isProd,
 					jit,
 					incremental: watchMode
-				})] };
+				}, isTest, !isAstroIntegration)] };
 				const esbuildOptions = {
 					plugins: [createCompilerPlugin({
 						tsconfig: preliminaryTsConfigPath,
@@ -152,18 +226,24 @@ function angular(options) {
 				return {
 					[jsTransformConfigKey]: jsTransformConfigValue,
 					optimizeDeps: {
-						include: ["rxjs/operators", "rxjs"],
+						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.useAngularCompilationAPI) {
-					externalComponentStyles = /* @__PURE__ */ new Map();
-					inlineComponentStyles = /* @__PURE__ */ new Map();
+				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 (!jit) styleTransform = (code, filename) => preprocessCSS(code, filename, config);
 				if (isTest) testWatchMode = !(config.server.watch === null) || config.test?.watch === true || testWatchMode;
@@ -172,30 +252,90 @@ function angular(options) {
 				viteServer = server;
 				const invalidateCompilationOnFsChange = createFsWatcherCacheInvalidator(invalidateFsCaches, invalidateTsconfigCaches, () => performCompilation(resolvedConfig));
 				server.watcher.on("add", invalidateCompilationOnFsChange);
-				server.watcher.on("unlink", invalidateCompilationOnFsChange);
+				server.watcher.on("unlink", (file) => {
+					const id = normalizePath(file);
+					outputFiles.delete(id);
+					tsSourceFileCache.delete(id);
+					sourceFileCache$1.invalidate(new Set([id]));
+					evictDeletedFileMetadata(file, {
+						classNamesMap: classNames,
+						fileTransformMap
+					});
+					return invalidateCompilationOnFsChange();
+				});
 				server.watcher.on("change", (file) => {
 					if (file.includes("tsconfig")) invalidateTsconfigCaches();
 				});
 			},
 			async buildStart() {
 				if (!isVitestVscode) {
-					await performCompilation(resolvedConfig);
+					pendingCompilation = performCompilation(this.environment?.config ?? resolvedConfig);
+					await pendingCompilation;
 					pendingCompilation = null;
 					initialCompilation = true;
 				}
 			},
+			buildEnd() {
+				if (watchMode) return;
+				nextProgram = void 0;
+				cachedHost = void 0;
+				cachedHostKey = void 0;
+				outputFile = void 0;
+				outputFiles.clear();
+				fileTransformMap.clear();
+				tsSourceFileCache.clear();
+				sourceFileCache$1.clear();
+				sourceFileCache$1.modifiedFiles.clear();
+				sourceFileCache$1.babelFileCache?.clear();
+				sourceFileCache$1.typeScriptFileCache?.clear();
+				sourceFileCache$1.referencedFiles = void 0;
+				tsconfigResolver.invalidateAll();
+				releaseCssPreprocessorWorkers();
+			},
 			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 (pluginOptions.liveReload) {
+					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 (pluginOptions.liveReload && result?.hmrEligible && classNames.get(fileId)) {
+					if (shouldEnableLiveReload() && result?.hmrEligible && classNames.get(fileId)) {
 						const relativeFileId = `${normalizePath(relative(process.cwd(), fileId))}@${classNames.get(fileId)}`;
+						debugHmr("sending component update", { relativeFileId });
+						debugHmrV("ts hmr component update payload", {
+							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);
@@ -204,79 +344,260 @@ function angular(options) {
 					}
 				}
 				if (/\.(html|htm|css|less|sass|scss)$/.test(ctx.file)) {
+					debugHmr("resource file changed", { file: ctx.file });
 					fileTransformMap.delete(ctx.file.split("?")[0]);
+					const fileModules = await getModulesForChangedFile(ctx.server, ctx.file, ctx.modules, stylesheetRegistry);
 					/**
 					* 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"));
+					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 (pluginOptions.liveReload && isDirect?.id && isDirect.file) {
-							if (isDirect.type === "css" && isComponentStyleSheet(isDirect.id)) {
+						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);
-								if (encapsulation !== "shadow") {
-									ctx.server.ws.send({
-										type: "update",
-										updates: [{
-											type: "css-update",
-											timestamp: Date.now(),
-											path: isDirect.url,
-											acceptedPath: isDirect.file
-										}]
+								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."
 									});
-									return ctx.modules.filter((mod) => {
+									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) ?? []
+								});
+								logComponentStylesheetHmrOutcome({
+									file: ctx.file,
+									encapsulation,
+									diagnosis: stylesheetDiagnosis,
+									outcome: "full-reload",
+									directModuleId: isDirect.id,
+									wrapperIds: wrapperModules.map((mod) => mod.id)
+								});
+								sendFullReload(ctx.server, {
+									file: ctx.file,
+									encapsulation,
+									reason: wrapperModules.length === 0 ? "missing-wrapper-module" : "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));
 							}
 						}
-						return ctx.modules;
 					}
 					const mods = [];
 					const updates = [];
-					ctx.modules.forEach((mod) => {
+					fileModules.forEach((mod) => {
 						mod.importers.forEach((imp) => {
 							ctx.server.moduleGraph.invalidateModule(imp);
-							if (pluginOptions.liveReload && classNames.get(imp.id)) updates.push(imp.id);
+							if (shouldExternalizeStyles() && classNames.get(imp.id)) updates.push(imp.id);
 							else mods.push(imp);
 						});
 					});
-					pendingCompilation = performCompilation(resolvedConfig, [...mods.map((mod) => mod.id), ...updates]);
+					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 ctx.modules.map((mod) => {
+						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:raw:")) return `\0${id}`;
 				if (jit && id.startsWith("angular:jit:")) {
-					const path = id.split(";")[1];
-					return `${normalizePath(resolve(dirname(importer), path))}?${id.includes(":style") ? "inline" : "raw"}`;
+					const filePath = normalizePath(resolve(dirname(importer), id.split(";")[1]));
+					if (id.includes(":style")) {
+						markStylePathSafe(resolvedConfig, filePath);
+						return filePath + "?inline";
+					}
+					return toVirtualRawId(filePath);
+				}
+				const rawRewrite = rewriteHtmlRawImport(id, importer);
+				if (rawRewrite) return rawRewrite;
+				if (/\.(css|scss|sass|less)\?inline$/.test(id) && importer) {
+					const filePath = id.split("?")[0];
+					const resolved = isAbsolute(filePath) ? normalizePath(filePath) : normalizePath(resolve(dirname(importer), filePath));
+					markStylePathSafe(resolvedConfig, resolved);
+					return resolved + "?inline";
 				}
 				if (isComponentStyleSheet(id)) {
-					const componentStyles = externalComponentStyles?.get(getFilenameFromPath(id));
-					if (componentStyles) return componentStyles + new URL(id, "http://localhost").search;
+					const filename = getFilenameFromPath(id);
+					const search = new URL(id, "http://localhost").search;
+					const servedSourcePath = stylesheetRegistry?.getServedSourcePath(filename);
+					if (servedSourcePath) {
+						debugStylesV("resolveId: mapped served stylesheet to source", {
+							filename,
+							resolvedPath: servedSourcePath
+						});
+						return servedSourcePath + search;
+					}
+					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 rawModule = await loadVirtualRawModule(this, id);
+				if (rawModule !== void 0) return rawModule;
+				if (/\.(css|scss|sass|less)\?inline$/.test(id)) markStylePathSafe(resolvedConfig, id.split("?")[0]);
 				if (isComponentStyleSheet(id)) {
-					const componentStyles = inlineComponentStyles?.get(getFilenameFromPath(id));
-					if (componentStyles) return componentStyles;
+					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(/^\//, "")) ?? stylesheetRegistry?.getServedSourcePath(filename) ?? stylesheetRegistry?.getServedSourcePath(filename.replace(/^\//, "")),
+							trackedRequestIds: stylesheetRegistry?.getRequestIdsForSource(stylesheetRegistry?.resolveExternalSource(filename) ?? stylesheetRegistry?.resolveExternalSource(filename.replace(/^\//, "")) ?? stylesheetRegistry?.getServedSourcePath(filename) ?? stylesheetRegistry?.getServedSourcePath(filename.replace(/^\//, "")) ?? "") ?? []
+						});
+						debugStylesV("load: served inline component stylesheet", {
+							filename,
+							length: componentStyles.length,
+							requestId: id,
+							...describeStylesheetContent(componentStyles)
+						});
+						return componentStyles;
+					}
 				}
 			},
 			transform: {
@@ -289,27 +610,7 @@ function angular(options) {
 					]
 				} },
 				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)) 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) return {
-							code: ngCompiler.encapsulateStyle(code, componentId),
-							map: null
-						};
-					}
+					if (transformFilter && !transformFilter(code, id)) return;
 					if (id.includes(".ts?")) id = id.replace(/\?(.*)/, "");
 					fileTransformMap.set(id, code);
 					/**
@@ -318,19 +619,25 @@ function angular(options) {
 					*/
 					if (isTest) {
 						if (isVitestVscode && !initialCompilation) {
-							pendingCompilation = performCompilation(resolvedConfig);
+							pendingCompilation = performCompilation(this.environment?.config ?? resolvedConfig);
 							initialCompilation = true;
 						}
 						const tsMod = viteServer?.moduleGraph.getModuleById(id);
 						if (tsMod) {
 							const invalidated = tsMod.lastInvalidationTimestamp;
-							if (testWatchMode && invalidated) pendingCompilation = performCompilation(resolvedConfig, [id]);
+							if (testWatchMode && invalidated) pendingCompilation = performCompilation(this.environment?.config ?? 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]) {
+					debugCompilerV("transform", {
+						id,
+						codeLength: code.length,
+						hasComponent
+					});
+					const resolveResourceUrls = hasComponent && (watchMode || jit);
+					const templateUrls = resolveResourceUrls ? templateUrlsResolver.resolve(code, id) : [];
+					const styleUrls = resolveResourceUrls ? styleUrlsResolver.resolve(code, id) : [];
+					if (resolveResourceUrls && watchMode) for (const urlSet of [...templateUrls, ...styleUrls]) {
 						const [, absoluteFileUrl] = urlSet.split("|");
 						this.addWatchFile(absoluteFileUrl);
 					}
@@ -339,23 +646,58 @@ function angular(options) {
 						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")}`);
-					let data = typescriptResult?.content ?? "";
+					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;");
+						data = data.replace(/angular:jit:style:inline;([A-Za-z0-9+/=]*)/g, (_match, encodedStyles) => toJitInlineStyleId(encodedStyles));
 						templateUrls.forEach((templateUrlSet) => {
 							const [templateFile, resolvedTemplateUrl] = templateUrlSet.split("|");
-							data = data.replace(`angular:jit:template:file;${templateFile}`, `${resolvedTemplateUrl}?raw`);
+							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}`, `${resolvedStyleUrl}?inline`);
+							markStylePathSafe(resolvedConfig, resolvedStyleUrl);
+							data = data.replace(`angular:jit:style:file;${styleFile}`, resolvedStyleUrl + "?inline");
 						});
 					}
+					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;
+						}
+					}
+					if (typescriptResult.map) data = data.replace(/\s*\/\/# sourceMappingURL=[^\r\n]*\s*$/, "");
 					return {
 						code: data,
-						map: null
+						map: typescriptResult.map ? normalizeSourceMapSources(typescriptResult.map, id) : null
 					};
 				}
 			},
@@ -364,19 +706,47 @@ function angular(options) {
 					mkdirSync(declarationFileDir, { recursive: true });
 					writeFileSync(declarationPath, data, "utf-8");
 				});
-				angularCompilation?.close?.();
-				angularCompilation = void 0;
+				declarationFiles.length = 0;
+				if (!watchMode) releaseCssPreprocessorWorkers();
 			}
 		};
 	}
+	function normalizeSourceMapSources(map, id) {
+		const sourceMap = JSON.parse(map);
+		const sourceDirectory = dirname(id);
+		const sourceRoot = sourceMap.sourceRoot ?? "";
+		sourceMap.sources = sourceMap.sources?.map((source) => {
+			if (isAbsolute(source) || /^[a-z][a-z\d+.-]*:/i.test(source)) return normalizePath(source);
+			return normalizePath(resolve(sourceDirectory, sourceRoot, source));
+		});
+		delete sourceMap.sourceRoot;
+		return JSON.stringify(sourceMap);
+	}
+	const compilationPlugin = pluginOptions.fastCompile ? fastCompilePlugin({
+		tsconfigGetter: pluginOptions.tsconfigGetter,
+		workspaceRoot: pluginOptions.workspaceRoot,
+		inlineStylesExtension: pluginOptions.inlineStylesExtension,
+		jit,
+		liveReload: pluginOptions.liveReload,
+		supportedBrowsers: pluginOptions.supportedBrowsers,
+		isTest,
+		isAstroIntegration,
+		fastCompileMode: pluginOptions.fastCompileMode
+	}) : angularPlugin();
 	return [
+		cssExtensionStyleResolverPlugin(),
 		replaceFiles(pluginOptions.fileReplacements, pluginOptions.workspaceRoot),
-		angularPlugin(),
+		virtualModulesPlugin({ jit }),
 		pluginOptions.liveReload && liveReloadPlugin({
 			classNames,
 			fileEmitter
 		}),
-		...isTest && !isStackBlitz ? angularVitestPlugins() : [],
+		compilationPlugin,
+		!pluginOptions.fastCompile && pluginOptions.liveReload && liveReloadPlugin({
+			classNames,
+			fileEmitter
+		}),
+		...isTest && !isStackBlitz ? angularVitestPlugins((id) => outputFiles.get(normalizePath(id))?.map) : [],
 		jit && jitPlugin({ inlineStylesExtension: pluginOptions.inlineStylesExtension }),
 		buildOptimizerPlugin({
 			supportedBrowsers: pluginOptions.supportedBrowsers,
@@ -384,116 +754,12 @@ function angular(options) {
 		}),
 		routerPlugin(),
 		angularFullVersion < 190004 && pendingTasksPlugin(),
-		nxFolderPlugin()
+		nxFolderPlugin(),
+		encapsulationPlugin()
 	].filter(Boolean);
-	function findIncludes() {
-		const workspaceRoot = normalizePath(resolve(pluginOptions.workspaceRoot));
-		return globSync([...pluginOptions.include.map((glob) => `${workspaceRoot}${glob}`)], {
-			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);
-	}
-	/**
-	* 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) {
-		angularCompilation ??= await createAngularCompilation(!!pluginOptions.jit, false);
-		const modifiedFiles = ids?.length ? new Set(ids.map((file) => normalizePath(file))) : void 0;
-		if (modifiedFiles?.size) sourceFileCache$1.invalidate(modifiedFiles);
-		if (modifiedFiles?.size && angularCompilation.update) await angularCompilation.update(modifiedFiles);
-		const resolvedTsConfigPath = resolveTsConfigPath();
-		const compilationResult = await angularCompilation.initialize(resolvedTsConfigPath, {
-			fileReplacements: toAngularCompilationFileReplacements(pluginOptions.fileReplacements, pluginOptions.workspaceRoot),
-			modifiedFiles,
-			async transformStylesheet(data, containingFile, resourceFile, order, className) {
-				if (pluginOptions.liveReload) {
-					const filename = createHash("sha256").update(containingFile).update(className).update(String(order)).update(data).digest("hex") + "." + 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;
-				tsCompilerOptions["supportTestBed"] = true;
-			}
-			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;
-		});
-		compilationResult.externalStylesheets?.forEach((value, key) => {
-			externalComponentStyles?.set(`${value}.css`, key);
-		});
-		const diagnostics = await angularCompilation.diagnoseFiles(pluginOptions.disableTypeChecking ? DiagnosticModes.All & ~DiagnosticModes.Semantic : DiagnosticModes.All);
-		const errors = diagnostics.errors?.length ? diagnostics.errors : [];
-		const warnings = diagnostics.warnings?.length ? diagnostics.warnings : [];
-		const templateUpdates = mapTemplateUpdatesToFiles(compilationResult.templateUpdates);
-		for (const file of await angularCompilation.emitAffectedFiles()) {
-			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
-			});
-		}
+		return getTsConfigPath(tsConfigResolutionContext.root, tsconfigValue, tsConfigResolutionContext.isProd, isTest, tsConfigResolutionContext.isLib, pluginOptions.workspaceRoot);
 	}
 	async function performCompilation(config, ids) {
 		let resolve;
@@ -503,6 +769,12 @@ function angular(options) {
 		});
 		try {
 			await previousLock;
+			const integrations = await discoverAnalogIntegrations(config);
+			pluginOptions.stylePreprocessor = integrations.stylePreprocessor;
+			externalizeStylesRequested = integrations.externalizeStyles;
+			configureStylesheetRegistry = integrations.configureStylesheetRegistry;
+			transformFilter = integrations.transformFilter;
+			tsconfigResolver.setIntegrationIncludes(integrations.include);
 			await _doPerformCompilation(config, ids);
 		} finally {
 			resolve();
@@ -513,54 +785,27 @@ 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) {
-			await performAngularCompilation(config, ids);
-			return;
-		}
+		if (!jit) styleTransform = (code, filename) => preprocessCSS(code, filename, config);
 		const isProd = config.mode === "production";
-		const modifiedFiles = new Set(ids ?? []);
-		sourceFileCache$1.invalidate(modifiedFiles);
+		invalidateSourceFiles(new Set(ids ?? []));
 		if (ids?.length) for (const id of ids || []) fileTransformMap.delete(id);
-		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: 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
-			});
-			cached = {
-				options: read.options,
-				rootNames: read.rootNames
-			};
-			tsconfigOptionsCache.set(tsconfigKey, cached);
-		}
+		const cached = tsconfigResolver.getCachedTsconfigOptions(resolvedTsConfigPath, config);
 		const tsCompilerOptions = { ...cached.options };
 		let rootNames = [...cached.rootNames];
-		if (pluginOptions.liveReload && watchMode) {
+		if (shouldExternalizeStyles()) tsCompilerOptions["externalRuntimeStyles"] = true;
+		if (shouldEnableLiveReload()) {
 			tsCompilerOptions["_enableHmr"] = true;
-			tsCompilerOptions["externalRuntimeStyles"] = true;
 			tsCompilerOptions["supportTestBed"] = true;
 		}
+		debugCompiler("tsCompilerOptions (NgtscProgram path)", {
+			liveReload: pluginOptions.liveReload,
+			viteHmr: hasViteHmrTransport(),
+			externalizeStylesRequested,
+			shouldExternalize: shouldExternalizeStyles(),
+			externalRuntimeStyles: !!tsCompilerOptions["externalRuntimeStyles"],
+			hmrEnabled: !!tsCompilerOptions["_enableHmr"]
+		});
 		if (tsCompilerOptions["compilationMode"] === "partial") {
 			tsCompilerOptions["supportTestBed"] = true;
 			tsCompilerOptions["supportJitMode"] = true;
@@ -572,11 +817,7 @@ function angular(options) {
 		}
 		if (isTest) tsCompilerOptions["supportTestBed"] = true;
 		const replacements = pluginOptions.fileReplacements.map((rp) => join(pluginOptions.workspaceRoot, rp.ssr || rp.with));
-		rootNames = [...new Set([
-			...rootNames,
-			...includeCache,
-			...replacements
-		])];
+		rootNames = union(rootNames, tsconfigResolver.ensureIncludeCache(), replacements);
 		const hostKey = JSON.stringify(tsCompilerOptions);
 		let host;
 		if (cachedHost && cachedHostKey === hostKey) host = cachedHost;
@@ -592,17 +833,19 @@ function angular(options) {
 			});
 			cachedHost = host;
 			cachedHostKey = hostKey;
-			if (watchMode) augmentHostWithCaching(host, sourceFileCache$1);
+			if (watchMode) augmentHostWithCaching(host, tsSourceFileCache);
 		}
 		if (!jit) {
-			inlineComponentStyles = tsCompilerOptions["externalRuntimeStyles"] ? /* @__PURE__ */ new Map() : void 0;
-			externalComponentStyles = tsCompilerOptions["externalRuntimeStyles"] ? /* @__PURE__ */ new Map() : void 0;
+			const externalizeStyles = !!tsCompilerOptions["externalRuntimeStyles"];
+			stylesheetRegistry = externalizeStyles ? new AnalogStylesheetRegistry() : void 0;
+			if (stylesheetRegistry) configureStylesheetRegistry?.(stylesheetRegistry, { workspaceRoot: pluginOptions.workspaceRoot });
+			debugStyles("stylesheet registry initialized (NgtscProgram path)", { externalizeStyles });
 			augmentHostWithResources(host, styleTransform, {
 				inlineStylesExtension: pluginOptions.inlineStylesExtension,
 				isProd,
-				inlineComponentStyles,
-				externalComponentStyles,
-				sourceFileCache: sourceFileCache$1
+				stylesheetRegistry,
+				sourceFileCache: sourceFileCache$1,
+				stylePreprocessor: pluginOptions.stylePreprocessor
 			});
 		}
 		/**
@@ -631,9 +874,19 @@ function angular(options) {
 		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;
+			if (filename.includes("ngtypecheck.ts") || filename.includes(".d.") || _filename.endsWith(".d.ts") || _filename.endsWith(".d.mts") || _filename.endsWith(".d.cts")) return;
+			if (/\.[cm]?js\.map$/.test(_filename)) {
+				const existing = outputFiles.get(filename);
+				outputFiles.set(filename, {
+					...existing ?? { dependencies: [] },
+					map: content
+				});
+				return;
+			}
 			const metadata = watchMode ? fileMetadata(filename) : {};
+			const existing = outputFiles.get(filename);
 			outputFiles.set(filename, {
+				...existing ?? {},
 				content,
 				dependencies: [],
 				errors: metadata.errors,
@@ -641,13 +894,27 @@ function angular(options) {
 				hmrUpdateCode: metadata.hmrUpdateCode,
 				hmrEligible: metadata.hmrEligible
 			});
+			debugEmitV("registered ngtsc output", {
+				filename,
+				...describeEmitMarkers(content),
+				errorCount: metadata.errors?.length ?? 0,
+				warningCount: metadata.warnings?.length ?? 0,
+				hmrEligible: !!metadata.hmrEligible,
+				knownOutputCount: outputFiles.size
+			});
 		};
 		const writeOutputFile = (id) => {
 			const sourceFile = builder.getSourceFile(id);
 			if (!sourceFile) return;
 			let content = "";
+			let map;
+			let mapFilename;
 			builder.emit(sourceFile, (filename, data) => {
 				if (/\.[cm]?js$/.test(filename)) content = data;
+				if (/\.[cm]?js\.map$/.test(filename)) {
+					map = data;
+					mapFilename = filename;
+				}
 				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/", "/");
@@ -659,6 +926,7 @@ function angular(options) {
 				}
 			}, void 0, void 0, transformers);
 			writeFileCallback(id, content, false, void 0, [sourceFile]);
+			if (map !== void 0 && mapFilename !== void 0) writeFileCallback(mapFilename, map, false, void 0, [sourceFile]);
 			if (angularCompiler) angularCompiler.incrementalCompilation.recordSuccessfulEmit(sourceFile);
 		};
 		if (watchMode) {
@@ -681,54 +949,225 @@ function createFsWatcherCacheInvalidator(invalidateFsCaches, invalidateTsconfigC
 	};
 }
 /**
-* Convert Analog/Angular CLI-style file replacements into the flat record
-* expected by `AngularHostOptions.fileReplacements`.
+* Returns every live Vite module that can legitimately represent a changed
+* Angular resource file.
 *
-* 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.
+* 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
 */
-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)]];
+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 mappedReplacements.length ? Object.fromEntries(mappedReplacements) : void 0;
+	return [...modules.values()];
 }
-/**
-* 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
+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(/^\//, "")) ?? stylesheetRegistry?.getServedSourcePath(requestPath) ?? stylesheetRegistry?.getServedSourcePath(requestPath.replace(/^\//, "")) ?? "").split("?")[0]) === normalizedChangedFile;
+}
+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(/^\//, "")) ?? stylesheetRegistry?.getServedSourcePath(directRequestPath) ?? stylesheetRegistry?.getServedSourcePath(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(/^\//, "")) ?? stylesheetRegistry?.getServedSourcePath(requestPath) ?? stylesheetRegistry?.getServedSourcePath(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
 	});
-	return updatesByFile;
+	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) {
+	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 getFileMetadata(program, angularCompiler, liveReload, disableTypeChecking) {
+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 logComponentStylesheetHmrOutcome(details) {
+	const pitfalls = [];
+	const rejectedPreferredPaths = [];
+	const hints = [];
+	if (details.encapsulation === "shadow") {
+		pitfalls.push("shadow-encapsulation");
+		rejectedPreferredPaths.push("css-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.");
+	}
+	debugHmrV("component stylesheet hmr outcome", {
+		file: details.file,
+		outcome: details.outcome,
+		encapsulation: details.encapsulation,
+		directModuleId: details.directModuleId,
+		wrapperIds: details.wrapperIds ?? [],
+		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()];
+}
+/**
+* @internal
+*/
+function getFileMetadata(program, angularCompiler, hmrEnabled, disableTypeChecking) {
 	const ts = require("typescript");
 	return (file) => {
 		const sourceFile = program.getSourceFile(file);
@@ -738,12 +1177,17 @@ function getFileMetadata(program, angularCompiler, liveReload, disableTypeChecki
 		const warnings = diagnostics.filter((d) => d.category === ts.DiagnosticCategory?.Warning).map((d) => d.messageText);
 		let hmrUpdateCode = void 0;
 		let hmrEligible = false;
-		if (liveReload) {
+		if (hmrEnabled) {
 			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());
+					const className = node.name.getText();
+					classNames.set(file, className);
 					hmrEligible = true;
+					debugHmr("NgtscProgram emitHmrUpdateModule", {
+						file,
+						className
+					});
 				}
 			}
 		}
@@ -773,40 +1217,18 @@ 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
 * @param id
 */
 function getFilenameFromPath(id) {
-	return new URL(id, "http://localhost").pathname.replace(/^\//, "");
-}
-/**
-* 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;
+	try {
+		return new URL(id, "http://localhost").pathname.replace(/^\//, "");
+	} catch {
+		const queryIndex = id.indexOf("?");
+		return (queryIndex >= 0 ? id.slice(0, queryIndex) : id).replace(/^\//, "");
+	}
 }
 //#endregion
 export { angular };