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

package/dist/plugins/local-styles.js

@@ -0,0 +1,214 @@
+import { defaultBuildManifest } from "../internal/src/project.js";
+import { includesFile } from "../utils/path.js";
+import { withStylesheetDependencies } from "../utils/failed-stylesheet-dependencies.js";
+import { getPreparedSassSource, getPreparedSassSourceMap, getSassSourceFile, isRawStyleRequest } from "../utils/build-sass-source.js";
+import { withSassDiagnostics } from "../utils/sass-diagnostics.js";
+import { getBuildStylesheetDelivery } from "../utils/build-stylesheet-delivery.js";
+import { getDevStylesheetDelivery, publishDevGlobalStylesheet, publishDevStylesheets } from "../utils/dev-stylesheet-delivery.js";
+import { captureBuildStylesheetSource, clearBuildStylesheetSources, getBuildImportResolver } from "../utils/build-import-resolver.js";
+import { inlineDelivery, isInlineStylesheet, registerLocalInlineStylesheet } from "../utils/inline-stylesheet.js";
+import { clearLocalStylesheets, registerLocalStylesheet } from "../utils/local-stylesheet.js";
+import { readFileSync } from "node:fs";
+import { discoverManifestEntries, loadProjectManifest } from "@master/css-compiler/project";
+import { collectStylesheetDependenciesSync, inspectCSSSync } from "@master/css-compiler/node";
+import { resolveStylesheet, transformStylesheet } from "@master/css-compiler/stylesheet";
+// src/plugins/local-styles.ts
+function declaresManifestEntry(file) {
+	try {
+		return inspectCSSSync(readFileSync(file, "utf8")).hasMasterEntry;
+	} catch {
+		return false;
+	}
+}
+function LocalStylesPlugin(options, context) {
+	let projectManifest;
+	let projectManifestEntries = [];
+	let projectManifestDependencies = [];
+	let manifestGeneration = 0;
+	let loadingManifest;
+	const localStyleModules = /* @__PURE__ */ new Set();
+	const addServerAllow = (paths) => {
+		const allow = context.config?.server.fs.allow;
+		if (!allow) return;
+		for (const path of paths) if (!allow.includes(path)) allow.push(path);
+	};
+	const loadStyleContext = async (pluginContext) => {
+		if (projectManifest) {
+			for (const dependency of projectManifestDependencies) pluginContext.addWatchFile?.(dependency);
+			return projectManifest;
+		}
+		if (!loadingManifest) {
+			const generation = manifestGeneration;
+			const dependencies = /* @__PURE__ */ new Set();
+			const hosts = /* @__PURE__ */ new Set();
+			const observe = (file) => {
+				if (dependencies.has(file)) return;
+				dependencies.add(file);
+				for (const host of hosts) host.addWatchFile?.(file);
+			};
+			loadingManifest = {
+				generation,
+				dependencies,
+				hosts,
+				promise: (async () => {
+					const root = context.config?.root;
+					const entries = await discoverManifestEntries({ root });
+					if (generation === manifestGeneration) projectManifestEntries = [...entries];
+					try {
+						for (const entry of entries) for (const dependency of collectStylesheetDependenciesSync(entry, void 0, { projectDir: root })) observe(dependency);
+						const result = await loadProjectManifest({
+							root,
+							entries,
+							baseManifest: defaultBuildManifest,
+							onDependency: observe
+						});
+						for (const dependency of result.dependencies) observe(dependency);
+						if (generation === manifestGeneration) projectManifest = result;
+						return result;
+					} finally {
+						if (generation === manifestGeneration) {
+							projectManifestDependencies = [...dependencies];
+							addServerAllow(projectManifestDependencies);
+						}
+					}
+				})()
+			};
+		}
+		const operation = loadingManifest;
+		operation.hosts.add(pluginContext);
+		for (const dependency of operation.dependencies) pluginContext.addWatchFile?.(dependency);
+		try {
+			const result = await operation.promise;
+			if (operation.generation !== manifestGeneration) return loadStyleContext(pluginContext);
+			return result;
+		} finally {
+			for (const dependency of operation.dependencies) pluginContext.addWatchFile?.(dependency);
+			operation.hosts.delete(pluginContext);
+			if (loadingManifest === operation) loadingManifest = void 0;
+		}
+	};
+	return {
+		name: "master-css:local-styles",
+		enforce: "pre",
+		async buildStart() {
+			clearBuildStylesheetSources(context);
+			if (context.config?.command === "build") clearLocalStylesheets(context);
+			projectManifest = void 0;
+			manifestGeneration++;
+			loadingManifest = void 0;
+			projectManifestEntries = [];
+			projectManifestDependencies = [];
+		},
+		async transform(code, id) {
+			return withStylesheetDependencies(context, this, id, (onDependency) => withSassDiagnostics(context, async () => {
+				if (isRawStyleRequest(id)) return;
+				const dependencyHost = {
+					addWatchFile: onDependency,
+					resolve: this.resolve?.bind(this),
+					load: this.load?.bind(this)
+				};
+				const sourceMeta = captureBuildStylesheetSource(context, id, code);
+				if (id.startsWith("\0") && context.config?.command !== "build") return;
+				const resolution = await resolveStylesheet(id, code, {
+					projectDir: context.config?.root,
+					baseFile: getSassSourceFile(id),
+					preserveImports: true,
+					resolveImport: getBuildImportResolver(context, dependencyHost),
+					onDependency
+				}).catch((error) => {
+					onDependency(getSassSourceFile(id) ?? id.replace(/[?#].*$/, ""));
+					throw error;
+				});
+				const prepared = getPreparedSassSource(context, id);
+				const moduleGraph = prepared && (await prepared.prepared).moduleSources;
+				const nativeModuleGraph = resolution?.kind === "plain" && Boolean(moduleGraph && moduleGraph.size > 1);
+				if (resolution?.kind !== "local" && resolution?.kind !== "plain") return sourceMeta ? { meta: sourceMeta } : void 0;
+				const dependencies = new Set(resolution.dependencies);
+				for (const dependency of dependencies) onDependency(dependency);
+				const manifestResult = await loadStyleContext(dependencyHost);
+				localStyleModules.add(id);
+				if (!projectManifestEntries.length && resolution.kind === "plain" && !nativeModuleGraph) return sourceMeta ? { meta: sourceMeta } : void 0;
+				const scopedVueStyle = id.includes("?vue&") && /(?:^|[?&])scoped(?:=|&|$)/u.test(id);
+				const compileOptions = {
+					baseManifest: manifestResult.manifest,
+					projectDir: context.config?.root,
+					referenceFiles: projectManifestEntries,
+					transformNativeStylesheets: true,
+					baseFile: getSassSourceFile(id),
+					sourceMap: await getPreparedSassSourceMap(context, id),
+					onDependency,
+					generatedGlobals: scopedVueStyle ? "separate" : "inline"
+				};
+				const inline = context.config?.command === "build" && isInlineStylesheet(id);
+				const delivery = inline ? inlineDelivery(context) : getBuildStylesheetDelivery(context) ?? getDevStylesheetDelivery(context);
+				const result = await transformStylesheet(id, code, {
+					...compileOptions,
+					preserveUnchangedNativeCSS: resolution.kind === "plain" && !nativeModuleGraph,
+					...delivery ? { delivery: {
+						...delivery,
+						baseFile: getSassSourceFile(id),
+						sourceMap: await getPreparedSassSourceMap(context, id),
+						resolveImport: getBuildImportResolver(context, dependencyHost),
+						onDependency
+					} } : {}
+				});
+				if (!result.transformed) return sourceMeta ? { meta: sourceMeta } : void 0;
+				localStyleModules.add(id);
+				for (const dependency of result.dependencies) {
+					if (dependencies.has(dependency)) continue;
+					onDependency(dependency);
+				}
+				let output = result.code;
+				if (inline) registerLocalInlineStylesheet(context, id, result);
+				else if (context.config?.command === "build") {
+					if (scopedVueStyle && !result.stylesheets?.length) {
+						if (result.globalStylesheet) {
+							const slot = registerLocalStylesheet(context, id, {
+								...result,
+								code: result.globalStylesheet.css,
+								globalStylesheet: void 0
+							});
+							output = `${result.code}\n:global(${slot.slice(0, slot.indexOf("{"))})${slot.slice(slot.indexOf("{"))}`;
+						} else output = result.code;
+					} else output = registerLocalStylesheet(context, id, result);
+				} else if (context.config?.command === "serve") {
+					output = publishDevStylesheets(context, {
+						...result,
+						css: result.code,
+						emittedGlobals: {
+							variables: {},
+							keyframes: {}
+						}
+					}, "#master-css-local-slot{--slot:0}");
+					if (result.globalStylesheet) output = publishDevGlobalStylesheet(context, result.globalStylesheet.css) + "\n" + output;
+				}
+				return {
+					code: output,
+					map: null,
+					...sourceMeta ? { meta: sourceMeta } : {}
+				};
+			}));
+		},
+		async hotUpdate({ type, file, modules }) {
+			const entriesChanged = file.endsWith(".css") && (declaresManifestEntry(file) || projectManifestEntries.some((entry) => !declaresManifestEntry(entry))) && JSON.stringify(await discoverManifestEntries({ root: context.config?.root })) !== JSON.stringify(projectManifestEntries);
+			if (!includesFile(projectManifestDependencies, file) && !includesFile([...loadingManifest?.dependencies ?? []], file) && !entriesChanged) return;
+			projectManifest = void 0;
+			manifestGeneration++;
+			loadingManifest = void 0;
+			const affected = new Set(modules);
+			for (const moduleId of localStyleModules) {
+				const module = this.environment.moduleGraph.getModuleById(moduleId);
+				if (!module) continue;
+				this.environment.moduleGraph.invalidateModule(module);
+				affected.add(module);
+			}
+			const hasSvelteStyle = [...affected].some((module) => /\.svelte\?svelte&type=style(?:&|$)/u.test(module.id ?? ""));
+			if (type === "delete" && entriesChanged && hasSvelteStyle) {
+				if (this.environment.name === "client") this.environment.hot.send({ type: "full-reload" });
+				return [];
+			}
+			return [...affected];
+		}
+	};
+}
+export { LocalStylesPlugin as default };

package/dist/plugins/manifest-loader.d.ts

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

package/dist/plugins/manifest-loader.js

@@ -0,0 +1,102 @@
+import { MANIFEST_ASSET_FILE, toBrowserManifestFacadeModule, toInlineManifestModule, toServerManifestFileURL, toUniversalManifestFacadeModule } from "../internal/src/manifest-facade.js";
+import { isMasterCSSManifestRequest, stripMasterCSSManifestQuery, toProductionManifestJSON } from "../internal/src/manifest-module.js";
+import { isMasterCSSProgramRequest, stripMasterCSSProgramQuery } from "../internal/src/program-module.js";
+import { fromResolvedMasterCSSManifestId, fromResolvedMasterCSSProgramId, toResolvedMasterCSSManifestId, toResolvedMasterCSSProgramId } from "../internal/src/node.js";
+import { createMasterCSSProgramModule } from "../internal/src/manifest-virtual-module.js";
+import { defaultBuildManifest, isManifestStylesheetRequest } from "../internal/src/project.js";
+import { includesFile } from "../utils/path.js";
+import { serializeMasterCSSManifest } from "@master/css-schema/manifest";
+import { compileRuntimeProgram } from "@master/css/node";
+import { compileProjectManifest } from "@master/css-compiler/project";
+import { collectStylesheetDependenciesSync } from "@master/css-compiler/node";
+// src/plugins/manifest-loader.ts
+function invalidateManifestModule(module, server) {
+	if (!module) return [];
+	server.moduleGraph.invalidateModule(module);
+	return [module];
+}
+function isProductionBuild(context) {
+	return context.config?.command === "build";
+}
+function isServerBuild(context, pluginContext) {
+	if (pluginContext.environment) return pluginContext.environment.config.consumer === "server";
+	return Boolean(context.config?.build.ssr);
+}
+function createManifestModule(context, pluginContext, manifest, serverReferences) {
+	if (!isProductionBuild(context)) return toInlineManifestModule(serializeMasterCSSManifest(manifest));
+	const json = toProductionManifestJSON(manifest);
+	if (!pluginContext.emitFile) return toInlineManifestModule(json);
+	const referenceId = pluginContext.emitFile({
+		type: "asset",
+		name: MANIFEST_ASSET_FILE,
+		source: json
+	});
+	const urlExpression = `import.meta.ROLLUP_FILE_URL_${referenceId}`;
+	const server = isServerBuild(context, pluginContext);
+	if (server) serverReferences.add(referenceId);
+	return server ? toUniversalManifestFacadeModule(urlExpression) : toBrowserManifestFacadeModule(urlExpression);
+}
+function ManifestLoaderPlugin(context) {
+	const cssManifestDependencies = /* @__PURE__ */ new Map();
+	const serverManifestReferences = /* @__PURE__ */ new Set();
+	const addServerAllow = (paths) => {
+		const allow = context.config?.server.fs.allow;
+		if (!allow) return;
+		for (const path of paths) if (!allow.includes(path)) allow.push(path);
+	};
+	const watchManifestDependencies = (manifestPath, dependencies = []) => {
+		cssManifestDependencies.set(manifestPath, dependencies);
+		addServerAllow(dependencies);
+	};
+	return {
+		name: "master-css:manifest-loader",
+		enforce: "pre",
+		async resolveId(id, importer) {
+			const program = isMasterCSSProgramRequest(id);
+			if (!program && !isMasterCSSManifestRequest(id)) return;
+			const sourceId = program ? stripMasterCSSProgramQuery(id) : stripMasterCSSManifestQuery(id);
+			const resolved = await this.resolve(sourceId, importer, { skipSelf: true });
+			if (!resolved) return;
+			return program ? toResolvedMasterCSSProgramId(resolved.id) : toResolvedMasterCSSManifestId(resolved.id);
+		},
+		async load(id) {
+			const programPath = fromResolvedMasterCSSProgramId(id);
+			const manifestPath = programPath ?? fromResolvedMasterCSSManifestId(id);
+			if (!manifestPath) return;
+			if (!isManifestStylesheetRequest(manifestPath)) throw new TypeError(`Master CSS ${programPath ? "program" : "manifest"} queries only support CSS entry files.`);
+			const dependencies = new Set(collectStylesheetDependenciesSync(manifestPath, void 0, { projectDir: context.config?.root }));
+			for (const dependency of dependencies) this.addWatchFile(dependency);
+			watchManifestDependencies(manifestPath, [...dependencies]);
+			const result = await compileProjectManifest({
+				root: context.config?.root,
+				entries: [manifestPath],
+				baseManifest: defaultBuildManifest
+			});
+			for (const dependency of result.dependencies) {
+				if (dependencies.has(dependency)) continue;
+				dependencies.add(dependency);
+				this.addWatchFile(dependency);
+			}
+			watchManifestDependencies(manifestPath, [...dependencies]);
+			if (programPath) return (await createMasterCSSProgramModule(context, this, result.manifest, compileRuntimeProgram)).code;
+			return createManifestModule(context, this, result.manifest, serverManifestReferences);
+		},
+		resolveFileUrl({ referenceId, relativePath, format }) {
+			if (serverManifestReferences.has(referenceId)) return toServerManifestFileURL(relativePath, format);
+		},
+		async handleHotUpdate({ file, server }) {
+			let handled = false;
+			const modules = [];
+			const queryManifestPaths = /* @__PURE__ */ new Set([file]);
+			for (const [manifestPath, dependencies] of cssManifestDependencies) if (includesFile(dependencies, file)) queryManifestPaths.add(manifestPath);
+			for (const manifestPath of queryManifestPaths) for (const queryId of [toResolvedMasterCSSManifestId(manifestPath), toResolvedMasterCSSProgramId(manifestPath)]) {
+				const queryModule = server.moduleGraph.getModuleById(queryId);
+				if (!queryModule) continue;
+				handled = true;
+				modules.push(...invalidateManifestModule(queryModule, server));
+			}
+			if (handled) return modules;
+		}
+	};
+}
+export { ManifestLoaderPlugin as default };

package/dist/plugins/manifest-virtual-module.d.ts

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

package/dist/plugins/manifest-virtual-module.js

@@ -0,0 +1,70 @@
+import { RESOLVED_VIRTUAL_MANIFEST_ID, RESOLVED_VIRTUAL_PROGRAM_ID } from "../common.js";
+import { createMasterCSSManifestVirtualModulePlugin } from "../internal/src/manifest-virtual-module.js";
+import { loadMasterCSSVirtualManifest } from "../internal/src/manifest-loader.js";
+import { createManifestRecovery } from "../utils/manifest-recovery.js";
+import { compileRuntimeProgram } from "@master/css/node";
+import { discoverManifestEntries, loadProjectManifest } from "@master/css-compiler/project";
+import { collectStylesheetDependenciesSync } from "@master/css-compiler/node";
+import { normalizePath } from "vite";
+// src/plugins/manifest-virtual-module.ts
+const manifestHost = {
+	discoverManifestEntries,
+	loadProjectManifest,
+	collectStylesheetDependencies(entry, options) {
+		return collectStylesheetDependenciesSync(entry, void 0, { projectDir: options.root });
+	}
+};
+function ManifestVirtualModulePlugin(context) {
+	const plugin = createMasterCSSManifestVirtualModulePlugin(async (options) => {
+		const result = await loadMasterCSSVirtualManifest({
+			...options,
+			onDependency: (file) => options.onDependency(normalizePath(file)),
+			host: manifestHost
+		});
+		return {
+			...result,
+			dependencies: result.dependencies.map(normalizePath)
+		};
+	}, context, (manifest) => compileRuntimeProgram(manifest));
+	const createRecovery = (id) => createManifestRecovery(context, id, (onDependency, host) => plugin.load.call({
+		environment: host.environment,
+		addWatchFile: onDependency,
+		emitFile: host.emitFile?.bind(host)
+	}, id));
+	const recovery = createRecovery(RESOLVED_VIRTUAL_MANIFEST_ID);
+	const programRecovery = createRecovery(RESOLVED_VIRTUAL_PROGRAM_ID);
+	return {
+		...plugin,
+		async buildStart() {
+			if (programRecovery.failed) try {
+				await programRecovery.run(this);
+			} catch {}
+			if (context.config?.command === "build" && !recovery.failed) return;
+			try {
+				await recovery.run(this);
+			} catch {}
+		},
+		async load(id) {
+			if (id === RESOLVED_VIRTUAL_MANIFEST_ID) return recovery.run(this);
+			if (id === RESOLVED_VIRTUAL_PROGRAM_ID) return programRecovery.run(this);
+		},
+		transformIndexHtml: {
+			order: "pre",
+			handler() {
+				recovery.assertReady();
+				programRecovery.assertReady();
+			}
+		},
+		closeBundle() {
+			if (context.config?.build?.watch || !this.environment) return;
+			recovery.close(this.environment);
+			programRecovery.close(this.environment);
+		},
+		closeWatcher() {
+			if (!this.environment) return;
+			recovery.close(this.environment);
+			programRecovery.close(this.environment);
+		}
+	};
+}
+export { ManifestVirtualModulePlugin as default };

package/dist/plugins/pre-render.d.ts

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

package/dist/plugins/pre-render.js

@@ -0,0 +1,224 @@
+import { toHashedManifestAssetFileName } from "../internal/src/node.js";
+import { defaultBuildManifest } from "../internal/src/project.js";
+import { includesFile } from "../utils/path.js";
+import { createManifestRecovery } from "../utils/manifest-recovery.js";
+import { toAssetHref } from "../utils/html.js";
+import { relative } from "node:path";
+import { discoverManifestEntries, loadProjectManifest } from "@master/css-compiler/project";
+import { collectStylesheetEmittedGlobals, describeLinkedStylesheet } from "@master/css-compiler/stylesheet";
+import { createServerRenderer } from "@master/css-server";
+import { MASTER_CSS_HYDRATION_MANIFEST_ASSET_BASE, MASTER_CSS_HYDRATION_MANIFEST_FILE_BASENAME } from "@master/css-schema/hydration-manifest";
+// src/plugins/pre-render.ts
+const HYDRATION_MANIFEST_ASSET_DIR = "_master-css/hydration";
+function PreRenderPlugin(options, context) {
+	let cssManifest = void 0;
+	let cssManifestDependencies = [];
+	let manifestSignature;
+	let enabled = true;
+	let renderer;
+	let devServer;
+	const hydrationManifestAssets = /* @__PURE__ */ new Map();
+	const addServerAllow = (paths) => {
+		const allow = context.config?.server.fs.allow;
+		if (!allow) return;
+		for (const path of paths) if (!allow.includes(path)) allow.push(path);
+	};
+	const recovery = createManifestRecovery(context, "\0master-css:pre-render-manifest", async (onDependency, _host, active) => {
+		try {
+			const root = context.config?.root;
+			const entries = await discoverManifestEntries({ root });
+			const dependencies = /* @__PURE__ */ new Set();
+			const addDependency = (file) => {
+				if (dependencies.has(file)) return;
+				dependencies.add(file);
+				if (active()) {
+					cssManifestDependencies = [...dependencies];
+					addServerAllow([file]);
+				}
+				onDependency(file);
+			};
+			const result = await loadProjectManifest({
+				root,
+				entries,
+				baseManifest: defaultBuildManifest,
+				onDependency: addDependency
+			});
+			const emittedGlobalsResult = await collectStylesheetEmittedGlobals([...entries], {
+				baseManifest: result.manifest,
+				projectDir: root
+			});
+			const nextSignature = JSON.stringify([result.manifest, emittedGlobalsResult.emittedGlobals]);
+			const changed = manifestSignature !== void 0 && manifestSignature !== nextSignature;
+			const nextRenderer = createServerRenderer({
+				manifest: result.manifest,
+				emittedGlobals: emittedGlobalsResult.emittedGlobals,
+				maxCachedClasses: context.config?.command === "build" ? Infinity : void 0
+			});
+			if (active()) {
+				manifestSignature = nextSignature;
+				cssManifest = result.manifest;
+				renderer?.dispose();
+				renderer = nextRenderer;
+			} else nextRenderer.dispose();
+			for (const dependency of result.dependencies) {
+				if (dependencies.has(dependency)) continue;
+				dependencies.add(dependency);
+				onDependency(dependency);
+			}
+			for (const dependency of emittedGlobalsResult.dependencies) {
+				if (dependencies.has(dependency)) continue;
+				dependencies.add(dependency);
+				onDependency(dependency);
+			}
+			if (active()) {
+				cssManifestDependencies = [...dependencies];
+				addServerAllow(cssManifestDependencies);
+			}
+			return changed;
+		} catch (error) {
+			if (active()) {
+				renderer?.dispose();
+				renderer = void 0;
+				cssManifest = void 0;
+			}
+			throw error;
+		}
+	});
+	const loadCSSManifest = (host = { environment: devServer?.environments.client }) => recovery.run(host);
+	const toBuildHydrationManifestAssetFileName = (fileName) => {
+		return [
+			(context.config?.build.assetsDir ?? "assets").replace(/\/$/, ""),
+			HYDRATION_MANIFEST_ASSET_DIR,
+			fileName
+		].filter(Boolean).join("/");
+	};
+	const addHydrationManifestAsset = (json, htmlPath) => {
+		const fileName = toHashedManifestAssetFileName(json, MASTER_CSS_HYDRATION_MANIFEST_FILE_BASENAME);
+		hydrationManifestAssets.set(fileName, json);
+		return context.config?.command === "build" ? toAssetHref(toBuildHydrationManifestAssetFileName(fileName), context.config?.base, htmlPath) : `${MASTER_CSS_HYDRATION_MANIFEST_ASSET_BASE}${fileName}`;
+	};
+	const renderHTML = (html, htmlPath, stylesheets) => renderer?.renderHTML(html, {
+		stylesheets,
+		documentURL: new URL(htmlPath || "/", "https://master-css-render.invalid/").href,
+		hydrationManifest: options.mode === "progressive" ? {
+			type: "external",
+			source: (json) => addHydrationManifestAsset(json, htmlPath)
+		} : false
+	});
+	return {
+		name: "master-css:pre-render",
+		enforce: "pre",
+		async configResolved(config) {
+			if (config.plugins.some((p) => p.name?.startsWith("vite-plugin-svelte"))) {
+				enabled = false;
+				if (process.env.DEBUG) console.log("[@master/css-vite] SvelteKit detected, skipping pre-render plugin");
+				return;
+			}
+			if (config.command === "build" && config.build?.watch) return;
+			try {
+				await loadCSSManifest();
+			} catch (error) {
+				if (config.command !== "serve") throw error;
+			}
+		},
+		async buildStart() {
+			if (!enabled) return;
+			try {
+				await loadCSSManifest(this);
+			} catch (error) {
+				if (context.config?.command !== "serve") throw error;
+			}
+		},
+		async handleHotUpdate({ file, server }) {
+			if (!enabled || !includesFile(cssManifestDependencies, file)) return;
+			const environment = devServer?.environments.client;
+			const wasFailed = recovery.failed;
+			try {
+				const changed = await loadCSSManifest({ environment });
+				if (!recovery.isActive(environment)) return;
+				if (wasFailed || changed && options.mode === "pre-render") server.ws.send({ type: "full-reload" });
+			} catch (error) {
+				if (recovery.isActive(environment)) throw error;
+			}
+		},
+		configureServer(server) {
+			devServer = server;
+			server.httpServer?.once("close", () => renderer?.dispose());
+			server.middlewares.use((request, response, next) => {
+				const requestURL = request.url ? new URL(request.url, "http://localhost") : void 0;
+				if (!requestURL?.pathname.startsWith(MASTER_CSS_HYDRATION_MANIFEST_ASSET_BASE)) {
+					next();
+					return;
+				}
+				const fileName = decodeURIComponent(requestURL.pathname.slice(MASTER_CSS_HYDRATION_MANIFEST_ASSET_BASE.length));
+				const source = hydrationManifestAssets.get(fileName);
+				if (source === void 0) {
+					next();
+					return;
+				}
+				response.statusCode = 200;
+				response.setHeader("Content-Type", "application/json; charset=utf-8");
+				response.end(source);
+			});
+		},
+		transformIndexHtml(html, htmlContext) {
+			if (!enabled) return;
+			recovery.assertReady();
+			if (!cssManifest || !renderer) return;
+			const rendered = renderHTML(html, htmlContext?.path);
+			if (!rendered) return;
+			return {
+				html: rendered.html,
+				tags: []
+			};
+		},
+		transform(code, id) {
+			if (!enabled) return;
+			if (id.endsWith(".html")) {
+				recovery.assertReady();
+				if (!cssManifest || !renderer) return null;
+				const htmlPath = context.config?.root ? relative(context.config.root, id).replace(/\\/g, "/") : void 0;
+				const rendered = renderHTML(code, htmlPath);
+				if (!rendered) return null;
+				return {
+					code: rendered.html,
+					map: null
+				};
+			}
+			return null;
+		},
+		generateBundle(_options, bundle) {
+			if (!enabled) return;
+			const cssAssets = Object.values(bundle).filter((asset) => asset.type === "asset" && asset.fileName.endsWith(".css"));
+			for (const output of Object.values(bundle)) {
+				if (output.type !== "asset" || !output.fileName.endsWith(".html")) continue;
+				const urls = cssAssets.map((asset) => toAssetHref(asset.fileName, context.config?.base, output.fileName));
+				const stylesheets = cssAssets.flatMap((asset, index) => {
+					if (asset.type !== "asset") return [];
+					const source = typeof asset.source === "string" ? asset.source : new TextDecoder().decode(asset.source);
+					return [describeLinkedStylesheet(source, urls[index], urls)];
+				});
+				const source = typeof output.source === "string" ? output.source : new TextDecoder().decode(output.source);
+				const rendered = renderHTML(source, output.fileName, stylesheets);
+				if (rendered) output.source = rendered.html;
+			}
+			for (const [fileName, source] of hydrationManifestAssets) this.emitFile({
+				type: "asset",
+				fileName: toBuildHydrationManifestAssetFileName(fileName),
+				source
+			});
+		},
+		buildEnd(error) {
+			if (error && context.config?.command === "build") renderer?.dispose();
+		},
+		closeBundle() {
+			if (!context.config?.build?.watch && this.environment) recovery.close(this.environment);
+			if (context.config?.command === "build") renderer?.dispose();
+		},
+		closeWatcher() {
+			if (this.environment) recovery.close(this.environment);
+			renderer?.dispose();
+		}
+	};
+}
+export { PreRenderPlugin as default };

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

@@ -0,0 +1,5 @@
+import { Plugin } from "vite";
+import { MasterCSSVitePluginContext } from "../core.js";
+/** Runtime-mode pages start fetching the runtime program with the HTML. */
+declare function ProgramPreloadPlugin(context: MasterCSSVitePluginContext): Plugin;
+export { ProgramPreloadPlugin as default };

package/dist/plugins/program-preload.js

@@ -0,0 +1,37 @@
+import { toProgramPreloadLinkAttrs } from "../internal/src/program-module.js";
+import { hasFetchPreloadLink, toAssetHref } from "../utils/html.js";
+// src/plugins/program-preload.ts
+function sameBytes(left, right) {
+	return left instanceof Uint8Array && left.length === right.length && left.every((byte, index) => byte === right[index]);
+}
+function findDefaultProgramAssetFileName(context, bundle) {
+	const source = context.defaultProgramAssetSource;
+	if (!source) return;
+	for (const output of Object.values(bundle)) if (output.type === "asset" && (output.name === "master-css-program.bin" || output.names?.includes("master-css-program.bin")) && sameBytes(output.source, source)) return output.fileName;
+}
+/** Runtime-mode pages start fetching the runtime program with the HTML. */
+function ProgramPreloadPlugin(context) {
+	return {
+		name: "master-css:program-preload",
+		apply: "build",
+		transformIndexHtml: {
+			order: "post",
+			handler(html, htmlContext) {
+				if (!context.defaultProgramAssetReferenceId || !htmlContext.bundle) return;
+				const fileName = findDefaultProgramAssetFileName(context, htmlContext.bundle);
+				if (!fileName) return;
+				const href = toAssetHref(fileName, context.config?.base, htmlContext.path);
+				if (hasFetchPreloadLink(html, href)) return;
+				return {
+					html,
+					tags: [{
+						tag: "link",
+						attrs: { ...toProgramPreloadLinkAttrs(href) },
+						injectTo: "head-prepend"
+					}]
+				};
+			}
+		}
+	};
+}
+export { ProgramPreloadPlugin as default };

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

@@ -0,0 +1,3 @@
+import { Plugin } from "vite";
+declare function RuntimeBootstrapPlugin(progressive: boolean): Plugin;
+export { RuntimeBootstrapPlugin as default };