@master/css-vite 0.0.0-site.1793659883.g69c9aebcf628

package/dist/plugins/runtime-bootstrap.js

@@ -0,0 +1,14 @@
+import { RESOLVED_MASTER_CSS_RUNTIME_BOOTSTRAP_ID, createMasterCSSRuntimeBootstrapSource } from "../internal/src/runtime-bootstrap.js";
+// src/plugins/runtime-bootstrap.ts
+function RuntimeBootstrapPlugin(progressive) {
+	return {
+		name: "master-css:runtime-bootstrap",
+		resolveId(id) {
+			if (id === "virtual:master-css-runtime") return RESOLVED_MASTER_CSS_RUNTIME_BOOTSTRAP_ID;
+		},
+		load(id) {
+			if (id === "\0virtual:master-css-runtime") return createMasterCSSRuntimeBootstrapSource({ progressive });
+		}
+	};
+}
+export { RuntimeBootstrapPlugin as default };

package/dist/plugins/runtime-preload.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from "vite";
+import { MasterCSSVitePluginContext } from "../core.js";
+declare function RuntimePreloadPlugin(context: MasterCSSVitePluginContext): Plugin;
+export { RuntimePreloadPlugin as default };

package/dist/plugins/runtime-preload.js

@@ -0,0 +1,38 @@
+import "../internal/src/runtime-bootstrap.js";
+import { DEV_RUNTIME_ENTRY_ID, RUNTIME_ENTRY_ID } from "../common.js";
+import { hasModulePreloadLink, toAssetHref } from "../utils/html.js";
+// src/plugins/runtime-preload.ts
+function isRuntimeModuleId(id) {
+	const normalized = id.replace(/\\/g, "/");
+	return normalized === RUNTIME_ENTRY_ID || normalized === "\0virtual:master-css-runtime";
+}
+function findRuntimeChunkFileName(bundle) {
+	for (const output of Object.values(bundle)) if (output.type === "chunk" && output.fileName && output.moduleIds?.some(isRuntimeModuleId)) return output.fileName;
+}
+function RuntimePreloadPlugin(context) {
+	return {
+		name: "master-css:runtime-preload",
+		transformIndexHtml: {
+			order: "post",
+			handler(html, htmlContext) {
+				const bundle = htmlContext.bundle;
+				const fileName = bundle ? findRuntimeChunkFileName(bundle) : void 0;
+				const href = fileName ? toAssetHref(fileName, context.config?.base, htmlContext.path) : htmlContext.server ? toAssetHref(DEV_RUNTIME_ENTRY_ID, htmlContext.server.config?.base ?? context.config?.base, htmlContext.path) : void 0;
+				if (!href || hasModulePreloadLink(html, href)) return;
+				return {
+					html,
+					tags: [{
+						tag: "link",
+						attrs: {
+							rel: "modulepreload",
+							crossorigin: "",
+							href
+						},
+						injectTo: "head-prepend"
+					}]
+				};
+			}
+		}
+	};
+}
+export { RuntimePreloadPlugin as default };

package/dist/plugins/sass-source.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from "vite";
+import { MasterCSSVitePluginContext } from "../core.js";
+/** Sass and CSS Modules enter the CSS pipeline after host preprocessing. */
+declare function SassSourcePlugin(context: MasterCSSVitePluginContext): Plugin;
+export { SassSourcePlugin as default };

package/dist/plugins/sass-source.js

@@ -0,0 +1,176 @@
+import { normalizeFilePath } from "../utils/path.js";
+import { onEnvironmentClosing } from "../utils/environment-closing.js";
+import { clearBuildSassSources, getSassSourceFile, invalidatePreparedSassSources, isRawStyleRequest, isSassModuleID, prepareBuildSassSource, sassModuleID, sassSourceID } from "../utils/build-sass-source.js";
+import { getScanner } from "../utils/scanner-context.js";
+import { installSassProxyAccessCheck } from "../utils/sass-proxy-access.js";
+import { isAbsolute } from "node:path";
+// src/plugins/sass-source.ts
+/** Sass and CSS Modules enter the CSS pipeline after host preprocessing. */
+function SassSourcePlugin(context) {
+	let stylesheetURLs = /* @__PURE__ */ new Map();
+	let pendingStylesheetURLs = /* @__PURE__ */ new Set();
+	const lifetimes = /* @__PURE__ */ new WeakMap();
+	return {
+		name: "master-css:sass-source",
+		enforce: "pre",
+		buildStart() {
+			if (context.config?.command !== "serve") clearBuildSassSources(context);
+		},
+		configureServer(server) {
+			installSassProxyAccessCheck(server);
+			clearBuildSassSources(context);
+			const serverStylesheetURLs = /* @__PURE__ */ new Map();
+			const serverPendingURLs = /* @__PURE__ */ new Set();
+			stylesheetURLs = serverStylesheetURLs;
+			pendingStylesheetURLs = serverPendingURLs;
+			server.middlewares.use((request, response, next) => {
+				const requestURL = request.url;
+				if (!requestURL || !request.headers.accept?.includes("text/css")) return next();
+				const url = new URL(requestURL, "http://master-css.invalid");
+				const base = server.config.base;
+				if (base !== "/" && url.pathname.startsWith(base)) url.pathname = "/" + url.pathname.slice(base.length);
+				const servedPath = url.pathname;
+				if (!/\.(?:css|scss|sass)$/.test(servedPath)) return next();
+				let complete, finished = false, aborted = false;
+				const registration = new Promise((resolve) => {
+					complete = resolve;
+				}).finally(() => {
+					serverPendingURLs.delete(registration);
+				});
+				serverPendingURLs.add(registration);
+				response.once("close", () => {
+					if (!finished) {
+						aborted = true;
+						complete();
+					}
+				});
+				response.once("finish", () => {
+					finished = true;
+					if (aborted || response.statusCode !== 200) {
+						complete();
+						return;
+					}
+					let graphURL;
+					try {
+						graphURL = decodeURI(url.pathname) + url.search + (url.searchParams.has("direct") ? "" : url.search ? "&direct" : "?direct");
+					} catch {
+						complete();
+						return;
+					}
+					server.moduleGraph.getModuleByUrl(graphURL).then((module) => {
+						const owner = module?.id && getSassSourceFile(module.id);
+						if (!owner) return;
+						let urls = serverStylesheetURLs.get(normalizeFilePath(owner));
+						if (!urls) {
+							urls = /* @__PURE__ */ new Set();
+							serverStylesheetURLs.set(normalizeFilePath(owner), urls);
+						}
+						urls.add(servedPath);
+					}).catch((error) => server.config.logger.warn(`[master-css] Could not track stylesheet URL ${servedPath}: ${String(error)}`)).finally(complete);
+				});
+				next();
+			});
+		},
+		async hotUpdate({ file, modules, timestamp }) {
+			const { moduleGraph, hot } = this.environment;
+			let lifetime = lifetimes.get(this.environment);
+			if (!lifetime) {
+				let close;
+				const current = {
+					closed: false,
+					promise: new Promise((resolve) => {
+						close = resolve;
+					})
+				};
+				lifetimes.set(this.environment, current);
+				onEnvironmentClosing(this.environment, () => {
+					current.closed = true;
+					close();
+				});
+				lifetime = current;
+			}
+			const urls = stylesheetURLs;
+			await Promise.race([Promise.all(pendingStylesheetURLs), lifetime.promise]);
+			if (lifetime.closed || urls !== stylesheetURLs) return;
+			const owners = new Set(invalidatePreparedSassSources(context, file));
+			const pending = new Set(modules);
+			for (const module of pending) {
+				const owner = getSassSourceFile(module.id ?? "");
+				if (owner) owners.add(normalizeFilePath(owner));
+				else for (const importer of module.importers) pending.add(importer);
+			}
+			if (!owners.size) return;
+			const affected = new Set(modules);
+			for (const module of moduleGraph.idToModuleMap.values()) {
+				const owner = getSassSourceFile(module.id ?? "");
+				if (!owner || !owners.has(normalizeFilePath(owner))) continue;
+				moduleGraph.invalidateModule(module);
+				affected.add(module);
+			}
+			const paths = new Set([...owners].flatMap((owner) => [...urls.get(owner) ?? []]));
+			if (paths.size && this.environment.config.consumer === "client") hot.send({
+				type: "update",
+				updates: [...paths].map((path) => ({
+					type: "css-update",
+					path,
+					acceptedPath: path,
+					timestamp
+				}))
+			});
+			return [...affected];
+		},
+		shouldTransformCachedModule({ id }) {
+			if (isSassModuleID(id)) return true;
+		},
+		async transform(code, id) {
+			if (!isSassModuleID(id)) return;
+			await getScanner(context).scanModule(`${getSassSourceFile(id)}.js`, code);
+		},
+		async resolveId(id, importer) {
+			const proxyOwner = getSassSourceFile(id);
+			if (proxyOwner) {
+				if (context.config?.command !== "serve" || isSassModuleID(id)) return id;
+				const query = id.slice(sassSourceID(proxyOwner).length);
+				const resolved = await this.resolve(proxyOwner + query, importer, { skipSelf: true });
+				if (!resolved || resolved.external) return resolved;
+				const file = resolved.id.replace(/[?#].*$/, "");
+				if (!isAbsolute(file)) return;
+				return {
+					...resolved,
+					id: sassSourceID(file) + resolved.id.slice(file.length)
+				};
+			}
+			const stylesheetURL = context.config?.command === "build" && /[?&]url(?:[=&]|$)/.test(id) && !/[?&]raw(?:[=&]|$)/.test(id) && /\.(?:scss|sass)(?:[?#].*)?$/.test(id) && !/\.module\.(?:scss|sass)(?:[?#].*)?$/.test(id);
+			if (isRawStyleRequest(id) && !stylesheetURL) return;
+			if (!(/\.module\.css(?:[?#].*)?$/.test(id) && context.config?.css.modules !== false) && !/\.(?:scss|sass)(?:[?#].*)?$/.test(id)) return;
+			const resolved = await this.resolve(id, importer, { skipSelf: true });
+			if (!resolved || resolved.external) return;
+			const file = resolved.id.replace(/[?#].*$/, "");
+			if (!isAbsolute(file)) return;
+			const query = resolved.id.slice(file.length);
+			const modules = /\.module\.(?:css|scss|sass)$/.test(file) && context.config?.css.modules !== false && !/[?&]inline(?:[=&]|$)/.test(query);
+			return {
+				...resolved,
+				id: (modules ? sassModuleID(file) : sassSourceID(file)) + query
+			};
+		},
+		async load(id) {
+			if (isRawStyleRequest(id)) return;
+			const file = getSassSourceFile(id);
+			if (!file) return;
+			this.addWatchFile(file);
+			const result = await prepareBuildSassSource(context, file, (dependency) => this.addWatchFile(dependency));
+			for (const dependency of result.deps ?? []) this.addWatchFile(dependency);
+			if (isSassModuleID(id)) {
+				const modules = result.modules ?? {};
+				const exports = Object.entries(modules).filter(([key]) => key !== "default").map(([key, value], index) => `const value${index} = ${JSON.stringify(value)}; export { value${index} as ${JSON.stringify(key)} };`);
+				return `import ${JSON.stringify(sassSourceID(file))};\n${exports.join("\n")}\nexport default ${JSON.stringify(modules)};`;
+			}
+			return {
+				code: result.code,
+				map: result.map
+			};
+		}
+	};
+}
+export { SassSourcePlugin as default };

package/dist/plugins/scanner.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from "vite";
+import { ResolvedMasterCSSVitePluginOptions } from "../options.js";
+import { MasterCSSVitePluginContext } from "../core.js";
+declare function ScannerPlugin(options: ResolvedMasterCSSVitePluginOptions, context: MasterCSSVitePluginContext): Plugin;
+export { ScannerPlugin as default };

package/dist/plugins/scanner.js

@@ -0,0 +1,24 @@
+import { disposeScanner, ensureScanner, releaseScannerEnvironment, trackScannerEnvironments } from "../utils/scanner-context.js";
+// src/plugins/scanner.ts
+function ScannerPlugin(options, context) {
+	return {
+		name: "master-css:scanner",
+		enforce: "pre",
+		async configResolved(config) {
+			context.config = config;
+			await ensureScanner(options, context);
+		},
+		async buildStart() {
+			await ensureScanner(options, context);
+		},
+		configureServer(server) {
+			const config = server.config;
+			trackScannerEnvironments(context, config, () => server.config === config ? Object.values(server.environments) : []);
+		},
+		async closeBundle() {
+			const config = this.environment?.getTopLevelConfig() ?? context.config;
+			if (releaseScannerEnvironment(context, config, this.environment)) await disposeScanner(context, config);
+		}
+	};
+}
+export { ScannerPlugin as default };

package/dist/plugins/style-entry-build.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from "vite";
+import { ResolvedMasterCSSVitePluginOptions } from "../options.js";
+import { MasterCSSVitePluginContext } from "../core.js";
+declare function StyleEntryBuildPlugin(_options: ResolvedMasterCSSVitePluginOptions, context: MasterCSSVitePluginContext): Plugin;
+export { StyleEntryBuildPlugin as default };

package/dist/plugins/style-entry-build.js

@@ -0,0 +1,121 @@
+import { getScanner } from "../utils/scanner-context.js";
+import { prepareBuildStylesheet } from "../utils/build-stylesheet-delivery.js";
+import getExtractedCSS, { getExtractedCSSResult } from "../utils/extracted-css.js";
+import { removeGraphOnlyStylesheetEntries } from "../utils/build-import-resolver.js";
+import { clearLocalStylesheets, localStylesheets } from "../utils/local-stylesheet.js";
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { posix } from "node:path";
+import { createCompilerSync } from "@master/css-compiler/node";
+// src/plugins/style-entry-build.ts
+function replaceSlotCSSRule(source, slotCSSRule, realCSS) {
+	let replaced = false;
+	return {
+		source: source.split(slotCSSRule).map((part, index) => {
+			if (index === 0) return part;
+			if (replaced) return part;
+			replaced = true;
+			return realCSS + part;
+		}).join(""),
+		replaced
+	};
+}
+function StyleEntryBuildPlugin(_options, context) {
+	let renderedCSS;
+	let extracted;
+	let compiler;
+	const prepared = /* @__PURE__ */ new Map();
+	const prepare = (source) => {
+		if (!compiler || !extracted) return;
+		if (!prepared.has(source)) prepared.set(source, prepareBuildStylesheet(compiler, source, getScanner(context).slotCSSRule, extracted, [...localStylesheets(context).values()]));
+		return prepared.get(source);
+	};
+	return {
+		name: "master-css:style-entry:build",
+		enforce: "post",
+		apply: "build",
+		async renderStart() {
+			if (this.getModuleInfo) removeGraphOnlyStylesheetEntries(context, (id) => this.getModuleInfo(id));
+			if (context.stylesheets?.size === 0 && !context.virtualCSSImporters?.size) context.virtualCSSPlaceholderEmitted = false;
+			extracted = await getExtractedCSSResult(context);
+			renderedCSS = extracted.css;
+			compiler?.dispose();
+			compiler = extracted.stylesheets || localStylesheets(context).size ? createCompilerSync() : void 0;
+			prepared.clear();
+		},
+		outputOptions(options) {
+			const assetFileNames = options.assetFileNames;
+			return {
+				...options,
+				assetFileNames(asset) {
+					const cssAsset = (asset.names ?? [asset.name]).some((name) => name?.endsWith(".css"));
+					const graph = cssAsset && typeof asset.source === "string" ? prepare(asset.source) : void 0;
+					const result = graph ? {
+						source: graph.source,
+						replaced: true
+					} : cssAsset && renderedCSS !== void 0 && typeof asset.source === "string" && !extracted?.stylesheets ? replaceSlotCSSRule(asset.source, getScanner(context).slotCSSRule, renderedCSS) : void 0;
+					const pattern = typeof assetFileNames === "function" ? assetFileNames(result?.replaced ? {
+						...asset,
+						source: result.source
+					} : asset) : assetFileNames ?? "[name]-[hash][extname]";
+					if (!result?.replaced) return pattern;
+					const bytes = createHash("sha256").update(result.source).digest();
+					const hash = options.hashCharacters === "hex" ? bytes.toString("hex") : options.hashCharacters === "base36" ? BigInt(`0x${bytes.toString("hex")}`).toString(36) : bytes.toString("base64url");
+					return pattern.replace(/\[hash(?::(\d+))?\]/g, (_token, length) => hash.slice(0, length ? Number(length) : 8));
+				}
+			};
+		},
+		async generateBundle(_options, bundle) {
+			const slotCSSRule = getScanner(context).slotCSSRule;
+			const realCSS = renderedCSS ?? await getExtractedCSS(context);
+			const cssFileNames = Object.keys(bundle).filter((eachFileName) => eachFileName.endsWith(".css"));
+			let replacedAny = false;
+			for (const eachCssFileName of cssFileNames) {
+				const chunk = bundle[eachCssFileName];
+				if (chunk.type === "asset") {
+					const oldSource = String(bundle[eachCssFileName]["source"]);
+					const graph = prepare(oldSource);
+					if (graph) {
+						chunk.source = graph.source;
+						replacedAny = true;
+						for (const asset of graph.assets) {
+							const fileName = posix.join(posix.dirname(eachCssFileName), asset.href);
+							this.emitFile({
+								type: "asset",
+								fileName,
+								name: "master-css-generated",
+								source: asset.css
+							});
+						}
+						for (const resource of graph.resources ?? []) {
+							const fileName = posix.join(posix.dirname(eachCssFileName), resource.href);
+							this.emitFile({
+								type: "asset",
+								fileName,
+								source: readFileSync(resource.file)
+							});
+						}
+						continue;
+					}
+					if (extracted?.stylesheets) continue;
+					const result = replaceSlotCSSRule(oldSource, slotCSSRule, realCSS);
+					if (result.source !== oldSource) bundle[eachCssFileName]["source"] = result.source;
+					if (result.replaced) replacedAny = true;
+				}
+			}
+			if (context.virtualCSSPlaceholderEmitted && !replacedAny && realCSS.length > 0 && !(context.config?.build.ssr && cssFileNames.length === 0)) this.warn(`[master-css.vite] Could not splice managed style CSS into any bundle asset. The placeholder "${slotCSSRule}" was emitted but no CSS chunk in the final bundle still contained it — Vite's downstream CSS pipeline (a PostCSS plugin in your vite config, the bundler's CSS minifier, etc.) most likely rewrote or dropped it. The output will be missing Master CSS output.`);
+		},
+		closeBundle() {
+			compiler?.dispose();
+			compiler = void 0;
+			prepared.clear();
+			clearLocalStylesheets(context);
+		},
+		renderError() {
+			compiler?.dispose();
+			compiler = void 0;
+			prepared.clear();
+		}
+	};
+}
+export { StyleEntryBuildPlugin as default };

package/dist/plugins/style-entry-hmr.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from "vite";
+import { ResolvedMasterCSSVitePluginOptions } from "../options.js";
+import { MasterCSSVitePluginContext } from "../core.js";
+/** HMR when the config and source files changed */
+declare function StyleEntryHMRPlugin(_options: ResolvedMasterCSSVitePluginOptions, context: MasterCSSVitePluginContext): Plugin;
+export { StyleEntryHMRPlugin as default };

package/dist/plugins/style-entry-hmr.js

@@ -0,0 +1,78 @@
+import { ensureScanner, getScanner, releaseScannerEnvironment } from "../utils/scanner-context.js";
+import { refreshGeneratedModule } from "../utils/dev-module-refresh.js";
+import { createCoalescedTask } from "../utils/coalesced-task.js";
+import { existsSync, readFileSync } from "fs";
+// src/plugins/style-entry-hmr.ts
+/** HMR when the config and source files changed */
+function StyleEntryHMRPlugin(_options, context) {
+	let transformedIndexHTMLModule;
+	const servers = /* @__PURE__ */ new Map();
+	const attachedScanners = /* @__PURE__ */ new WeakSet();
+	const updateStylesheetImporters = async ({ server }) => {
+		if (!server) return;
+		const affectedModuleIds = new Set(context.virtualCSSImporters || []);
+		await context.refreshEmittedGlobals?.();
+		await Promise.all(Array.from(affectedModuleIds).map((eachModuleId) => refreshGeneratedModule(server, eachModuleId)));
+	};
+	const handleReset = async ({ server }) => {
+		const scanner = getScanner(context);
+		const tasks = [];
+		if (transformedIndexHTMLModule) tasks.push(scanner.scanModule(transformedIndexHTMLModule.id, transformedIndexHTMLModule.code));
+		tasks.push(...Array.from(server.moduleGraph.idToModuleMap.keys()).filter((eachModuleId) => !eachModuleId.startsWith("\0")).map(async (eachModuleId) => {
+			const eachModule = server.moduleGraph.idToModuleMap.get(eachModuleId);
+			if (eachModule) {
+				let eachModuleCode = eachModule?.transformResult?.code || eachModule?.ssrTransformResult?.code;
+				if (eachModule.file && !eachModuleCode && !eachModule.file.startsWith("virtual:") && existsSync(eachModule.file)) eachModuleCode = readFileSync(eachModule.file, "utf-8");
+				if (eachModuleCode) await scanner.scanModule(eachModuleId, eachModuleCode);
+			}
+		}));
+		await Promise.all(tasks);
+	};
+	return {
+		name: "master-css:style-entry:hmr",
+		enforce: "pre",
+		apply: "serve",
+		buildStart() {
+			const attach = () => {
+				const scanner = getScanner(context);
+				if (attachedScanners.has(scanner)) return;
+				attachedScanners.add(scanner);
+				let resetChain = Promise.resolve();
+				const onError = (label) => (err) => {
+					console.error(`[master-css.vite] ${label} failed:`, err);
+				};
+				const scheduleUpdate = createCoalescedTask(async () => {
+					await resetChain;
+					await Promise.all([...servers.values()].map((server) => updateStylesheetImporters({ server })));
+				}, onError("hmr update"));
+				scanner.on("reset", () => {
+					resetChain = resetChain.then(() => Promise.all([...servers.values()].map((eachServer) => handleReset({ server: eachServer })))).catch(onError("reset")).then(() => {
+						scheduleUpdate();
+					});
+				}).on("change", () => {
+					scheduleUpdate();
+				});
+			};
+			if (context.scanner) return attach();
+			return ensureScanner(_options, context).then(attach);
+		},
+		transformIndexHtml: {
+			order: "pre",
+			handler: async (html, { filename }) => {
+				transformedIndexHTMLModule = {
+					id: filename,
+					code: html
+				};
+				await getScanner(context).scanModule(filename, html);
+			}
+		},
+		closeBundle() {
+			const config = this.environment?.getTopLevelConfig() ?? context.config;
+			if (config && releaseScannerEnvironment(context, config, this.environment)) servers.delete(config);
+		},
+		configureServer(server) {
+			servers.set(server.config, server);
+		}
+	};
+}
+export { StyleEntryHMRPlugin as default };

package/dist/plugins/style-entry.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from "vite";
+import { ResolvedMasterCSSVitePluginOptions } from "../options.js";
+import { MasterCSSVitePluginContext } from "../core.js";
+declare function StyleEntryPlugin(_options: ResolvedMasterCSSVitePluginOptions, context: MasterCSSVitePluginContext): Plugin;
+export { StyleEntryPlugin as default };

package/dist/plugins/style-entry.js

@@ -0,0 +1,89 @@
+import { withStylesheetDependencies } from "../utils/failed-stylesheet-dependencies.js";
+import { getSassSourceFile, isRawStyleRequest } from "../utils/build-sass-source.js";
+import { withSassDiagnostics } from "../utils/sass-diagnostics.js";
+import { getScanner } from "../utils/scanner-context.js";
+import getExtractedCSS from "../utils/extracted-css.js";
+import { registerStylesheetSource } from "../utils/register-style-source.js";
+import { getBuildImportResolver } from "../utils/build-import-resolver.js";
+import { isInlineStylesheet, registerInlineStylesheet } from "../utils/inline-stylesheet.js";
+import { VIRTUAL_CSS_ID } from "../internal/src/style-module.js";
+import { collectStylesheetDependenciesSync } from "@master/css-compiler/node";
+import { resolveStylesheet } from "@master/css-compiler/stylesheet";
+// src/plugins/style-entry.ts
+const RESOLVED_VIRTUAL_CSS_ID = "\0" + VIRTUAL_CSS_ID;
+function StyleEntryPlugin(_options, context) {
+	return {
+		name: "master-css:style-entry",
+		enforce: "pre",
+		resolveId(id) {
+			if (id === "virtual:master-utilities.css" || id === RESOLVED_VIRTUAL_CSS_ID) return RESOLVED_VIRTUAL_CSS_ID;
+		},
+		async load(id) {
+			if (id !== RESOLVED_VIRTUAL_CSS_ID) return;
+			context.virtualCSSImporters ??= /* @__PURE__ */ new Set();
+			context.virtualCSSImporters.add(RESOLVED_VIRTUAL_CSS_ID);
+			if (context.config?.command === "serve") return await getExtractedCSS(context);
+			context.virtualCSSPlaceholderEmitted = true;
+			return getScanner(context).slotCSSRule;
+		},
+		async transform(code, id) {
+			return withStylesheetDependencies(context, this, id, (onDependency) => withSassDiagnostics(context, async () => {
+				if (isRawStyleRequest(id)) return;
+				if (id.startsWith("\0") && context.config?.command !== "build") return;
+				const dependencies = /* @__PURE__ */ new Set();
+				const resolveImport = getBuildImportResolver(context, {
+					addWatchFile: onDependency,
+					resolve: this.resolve?.bind(this),
+					load: this.load?.bind(this)
+				});
+				let resolution;
+				try {
+					resolution = await resolveStylesheet(id, code, {
+						projectDir: context.config?.root,
+						baseFile: getSassSourceFile(id),
+						preserveImports: true,
+						resolveImport,
+						onDependency
+					});
+				} catch (error) {
+					for (const dependency of collectStylesheetDependenciesSync(id, code, { projectDir: context.config?.root })) {
+						dependencies.add(dependency);
+						onDependency(dependency);
+					}
+					throw error;
+				}
+				if (!resolution || resolution.kind !== "entry" && resolution.kind !== "master-package-entry") return;
+				for (const dependency of resolution.dependencies) {
+					dependencies.add(dependency);
+					onDependency(dependency);
+				}
+				if (resolution.kind === "master-package-entry") return {
+					code: resolution.outputSource,
+					map: null
+				};
+				const inline = context.config?.command === "build" && isInlineStylesheet(id);
+				const result = inline ? await registerInlineStylesheet(context, id, code, {
+					resolveImport,
+					onDependency
+				}) : await registerStylesheetSource(context, context.config?.command === "serve" ? resolution.id : id, code, {
+					resolveImport,
+					onDependency
+				});
+				for (const dependency of result.dependencies) {
+					if (dependencies.has(dependency)) continue;
+					onDependency(dependency);
+				}
+				const masterSource = context.config?.command === "serve" ? await getExtractedCSS(context) : getScanner(context).slotCSSRule;
+				if (context.config?.command === "serve") {
+					context.virtualCSSImporters ??= /* @__PURE__ */ new Set();
+					context.virtualCSSImporters.add(id);
+				} else if (!inline) context.virtualCSSPlaceholderEmitted = true;
+				return {
+					code: masterSource,
+					map: null
+				};
+			}), "entry");
+		}
+	};
+}
+export { StyleEntryPlugin as default };

package/dist/plugins/stylesheet-recovery.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from "vite";
+import { MasterCSSVitePluginContext } from "../core.js";
+/** Restore failed dependency edges before Sass invalidation and normal HMR propagation. */
+declare function StylesheetRecoveryPlugin(context: MasterCSSVitePluginContext): Plugin;
+export { StylesheetRecoveryPlugin as default };

package/dist/plugins/stylesheet-recovery.js

@@ -0,0 +1,70 @@
+import { configureFailedDependencyReconciliation } from "../utils/failed-dependency-reconciliation.js";
+import { clearFailedStylesheets, configureStylesheetRecovery, stylesheetDependencyOwners } from "../utils/failed-stylesheet-dependencies.js";
+import { sendRecoveryError } from "../utils/recovery-error.js";
+import { invalidatePreparedSassSources } from "../utils/build-sass-source.js";
+// src/plugins/stylesheet-recovery.ts
+/** Restore failed dependency edges before Sass invalidation and normal HMR propagation. */
+function StylesheetRecoveryPlugin(context) {
+	const closed = /* @__PURE__ */ new WeakSet();
+	const recovering = /* @__PURE__ */ new WeakMap();
+	const recover = (environment, id, files, active = () => true, reportError = false) => {
+		if (closed.has(environment) || !active()) return Promise.resolve();
+		let pending = recovering.get(environment);
+		if (!pending) {
+			pending = /* @__PURE__ */ new Map();
+			recovering.set(environment, pending);
+		}
+		const prior = pending.get(id);
+		if (prior) return prior;
+		const operation = (async () => {
+			const module = environment.moduleGraph.getModuleById(id);
+			if (!module) return;
+			for (const file of files) invalidatePreparedSassSources(context, file);
+			const initialFailure = module.isSelfAccepting === void 0;
+			environment.moduleGraph.invalidateModule(module);
+			try {
+				await environment.transformRequest(module.url);
+			} catch (error) {
+				if (reportError && active() && !closed.has(environment)) sendRecoveryError(environment, error, id);
+				throw error;
+			}
+			if (closed.has(environment) || !active()) return;
+			if (initialFailure && environment.config.consumer === "client") environment.hot.send({
+				type: "full-reload",
+				path: "*"
+			});
+			else await environment.reloadModule(module);
+		})().finally(() => pending.delete(id));
+		pending.set(id, operation);
+		return operation;
+	};
+	return {
+		name: "master-css:stylesheet-recovery",
+		apply: "serve",
+		enforce: "pre",
+		configureServer(server) {
+			configureStylesheetRecovery(context, server.watcher);
+			configureFailedDependencyReconciliation(context, server, (environment, id, files, active) => recover(environment, id, files, active, true));
+		},
+		async hotUpdate({ file, modules }) {
+			const owners = stylesheetDependencyOwners(context, this.environment, file);
+			if (!owners.length) return;
+			invalidatePreparedSassSources(context, file);
+			const affected = new Set(modules);
+			for (const { id, failed } of owners) {
+				const module = this.environment.moduleGraph.getModuleById(id);
+				if (!module) continue;
+				this.environment.moduleGraph.invalidateModule(module);
+				if (failed && module.isSelfAccepting === void 0) await recover(this.environment, id, [file]);
+				affected.add(module);
+			}
+			return [...affected];
+		},
+		closeBundle() {
+			closed.add(this.environment);
+			recovering.delete(this.environment);
+			clearFailedStylesheets(context, this.environment);
+		}
+	};
+}
+export { StylesheetRecoveryPlugin as default };

package/dist/plugins/usage-graph.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from "vite";
+import { ResolvedMasterCSSVitePluginOptions } from "../options.js";
+import { MasterCSSVitePluginContext } from "../core.js";
+declare function UsageGraphPlugin(_options: ResolvedMasterCSSVitePluginOptions, context: MasterCSSVitePluginContext): Plugin;
+export { UsageGraphPlugin as default };