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

package/dist/internal/src/manifest-facade.js

@@ -0,0 +1,68 @@
+// ../internal/src/manifest-facade.ts
+const MANIFEST_ASSET_FILE = "master-css-manifest.json";
+function toInlineManifestModule(json) {
+	return `export default ${json};`;
+}
+/**
+* Server facades read the emitted manifest file, so their URL must stay relative to
+* the chunk. Vite 8.3 renders plugin file URLs as public `base` URLs, server builds
+* included; a `resolveFileUrl` hook returns this expression for server references.
+*/
+function toServerManifestFileURL(relativePath, format) {
+	const path = JSON.stringify(relativePath);
+	if (format === "es") return `new URL(${path}, import.meta.url).href`;
+	if (format === "cjs") return `new URL(${path}, require('node:url').pathToFileURL(__filename).href).href`;
+}
+function toBrowserManifestFacadeModule(urlExpression) {
+	return [
+		`const masterCSSManifestURL = ${urlExpression};`,
+		`const masterCSSManifestSpecifier = typeof masterCSSManifestURL === 'string' ? masterCSSManifestURL : masterCSSManifestURL.href;`,
+		`let loadMasterCSSManifestModule;`,
+		`try {`,
+		`    loadMasterCSSManifestModule = new Function('specifier', "return import(specifier, { with: { type: 'json' } })");`,
+		`} catch (error) {`,
+		`    if (error?.name !== 'SyntaxError') throw error;`,
+		`}`,
+		`let masterCSSManifest;`,
+		`if (loadMasterCSSManifestModule) {`,
+		`    masterCSSManifest = (await loadMasterCSSManifestModule(masterCSSManifestSpecifier)).default;`,
+		`} else {`,
+		`    const response = await fetch(masterCSSManifestSpecifier);`,
+		`    if (!response.ok) throw new Error(\`Cannot load the Master CSS manifest from \${masterCSSManifestSpecifier} (HTTP \${response.status}).\`);`,
+		`    masterCSSManifest = await response.json();`,
+		`}`,
+		`export default masterCSSManifest;`,
+		``
+	].join("\n");
+}
+function toUniversalManifestFacadeModule(urlExpression) {
+	return [
+		`const masterCSSManifestURL = ${urlExpression};`,
+		``,
+		`async function loadMasterCSSManifestFromFile(url) {`,
+		`    const load = new Function('specifier', 'options', 'return import(specifier, options)');`,
+		`    const specifier = typeof url === 'string' ? url : url.href;`,
+		`    return (await load(specifier, { with: { type: 'json' } })).default;`,
+		`}`,
+		``,
+		`async function loadMasterCSSManifestFromImport(url) {`,
+		`    const specifier = typeof url === 'string' ? url : url.href;`,
+		`    let load;`,
+		`    try {`,
+		`        load = new Function('specifier', "return import(specifier, { with: { type: 'json' } })");`,
+		`    } catch (error) {`,
+		`        if (error?.name !== 'SyntaxError') throw error;`,
+		`        const response = await fetch(specifier);`,
+		`        if (!response.ok) throw new Error(\`Cannot load the Master CSS manifest from \${specifier} (HTTP \${response.status}).\`);`,
+		`        return response.json();`,
+		`    }`,
+		`    return (await load(specifier)).default;`,
+		`}`,
+		``,
+		`export default typeof window === 'undefined'`,
+		`    ? await loadMasterCSSManifestFromFile(masterCSSManifestURL)`,
+		`    : await loadMasterCSSManifestFromImport(masterCSSManifestURL);`,
+		``
+	].join("\n");
+}
+export { MANIFEST_ASSET_FILE, toBrowserManifestFacadeModule, toInlineManifestModule, toServerManifestFileURL, toUniversalManifestFacadeModule };

package/dist/internal/src/manifest-loader.js

@@ -0,0 +1,33 @@
+import { defaultBuildManifest } from "./project.js";
+// ../internal/src/manifest-loader.ts
+async function loadMasterCSSVirtualManifest(options) {
+	options.signal?.throwIfAborted();
+	const entries = options.entries ?? await options.host.discoverManifestEntries({
+		root: options.root,
+		signal: options.signal
+	});
+	const dependencies = /* @__PURE__ */ new Set();
+	const addDependency = (dependency) => {
+		if (dependencies.has(dependency)) return;
+		dependencies.add(dependency);
+		options.onDependency?.(dependency);
+	};
+	for (const entry of entries) {
+		options.signal?.throwIfAborted();
+		for (const dependency of options.host.collectStylesheetDependencies(entry, { root: options.root })) addDependency(dependency);
+	}
+	const result = await options.host.loadProjectManifest({
+		root: options.root,
+		entries,
+		baseManifest: options.baseManifest ?? defaultBuildManifest,
+		signal: options.signal,
+		onDependency: addDependency
+	});
+	for (const dependency of result.dependencies) addDependency(dependency);
+	return Object.freeze({
+		...result,
+		entries: Object.freeze([...result.entries]),
+		dependencies: Object.freeze([...dependencies])
+	});
+}
+export { loadMasterCSSVirtualManifest };

package/dist/internal/src/manifest-module.js

@@ -0,0 +1,58 @@
+import { serializeMasterCSSManifest } from "@master/css-schema/manifest";
+// ../internal/src/manifest-module.ts
+const VIRTUAL_MANIFEST_ID = "virtual:master-css-manifest";
+const RESOLVED_VIRTUAL_MANIFEST_ID = `\0${VIRTUAL_MANIFEST_ID}`;
+const MASTER_CSS_MANIFEST_QUERY = "?master-css-manifest";
+function isMasterCSSManifestRequest(id) {
+	return id.endsWith(MASTER_CSS_MANIFEST_QUERY);
+}
+function stripMasterCSSManifestQuery(id) {
+	return isMasterCSSManifestRequest(id) ? id.slice(0, -20) : id;
+}
+function toManifestJSON(manifest) {
+	return serializeMasterCSSManifest(manifest);
+}
+function withoutSource({ source: _source, ...value }) {
+	return value;
+}
+function withoutNodeSources(nodes) {
+	return nodes.map((node) => {
+		switch (node.type) {
+			case "declaration": return withoutSource(node);
+			case "apply": return {
+				...withoutSource(node),
+				...node.contents ? { contents: withoutNodeSources(node.contents) } : {}
+			};
+			case "rule":
+			case "condition": return {
+				...node,
+				body: withoutNodeSources(node.body)
+			};
+			case "contents": return {
+				...node,
+				fallback: withoutNodeSources(node.fallback)
+			};
+		}
+	});
+}
+function withoutDefinitionSources(definition) {
+	return {
+		...withoutSource(definition),
+		...definition.parameters ? { parameters: definition.parameters.map(withoutSource) } : {},
+		body: withoutNodeSources(definition.body)
+	};
+}
+/**
+* Production builds deliver manifests only to execute classes. Source
+* provenance locates definitions for tooling and names build-host paths,
+* which would leak them and make the asset vary with the checkout location.
+*/
+function toProductionManifestJSON(manifest) {
+	return toManifestJSON({
+		...manifest,
+		...manifest.keyframes ? { keyframes: manifest.keyframes.map(withoutSource) } : {},
+		...manifest.mixins ? { mixins: manifest.mixins.map(withoutDefinitionSources) } : {},
+		...manifest.utilities ? { utilities: manifest.utilities.map(withoutDefinitionSources) } : {}
+	});
+}
+export { MASTER_CSS_MANIFEST_QUERY, RESOLVED_VIRTUAL_MANIFEST_ID, VIRTUAL_MANIFEST_ID, isMasterCSSManifestRequest, stripMasterCSSManifestQuery, toManifestJSON, toProductionManifestJSON };

package/dist/internal/src/manifest-virtual-module.js

@@ -0,0 +1,123 @@
+import { MANIFEST_ASSET_FILE, toBrowserManifestFacadeModule, toInlineManifestModule, toServerManifestFileURL, toUniversalManifestFacadeModule } from "./manifest-facade.js";
+import { RESOLVED_VIRTUAL_MANIFEST_ID, toManifestJSON, toProductionManifestJSON } from "./manifest-module.js";
+import { PROGRAM_ASSET_FILE, RESOLVED_VIRTUAL_PROGRAM_ID, toBrowserProgramFacadeModule, toInlineProgramModule } from "./program-module.js";
+// ../internal/src/manifest-virtual-module.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) {
+	context.defaultManifestAssetReferenceId = void 0;
+	context.defaultManifestAssetSource = void 0;
+	if (!isProductionBuild(context)) return toInlineManifestModule(toManifestJSON(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);
+	else {
+		context.defaultManifestAssetReferenceId = referenceId;
+		context.defaultManifestAssetSource = json;
+	}
+	return server ? toUniversalManifestFacadeModule(urlExpression) : toBrowserManifestFacadeModule(urlExpression);
+}
+/**
+* Development and server builds inline the program; browser builds emit it with
+* production manifest provenance removed and fetch it.
+*/
+async function createMasterCSSProgramModule(context, pluginContext, manifest, compileProgram) {
+	if (!isProductionBuild(context)) return { code: toInlineProgramModule(await compileProgram(manifest)) };
+	const program = await compileProgram(JSON.parse(toProductionManifestJSON(manifest)));
+	if (!pluginContext.emitFile || isServerBuild(context, pluginContext)) return { code: toInlineProgramModule(program) };
+	const referenceId = pluginContext.emitFile({
+		type: "asset",
+		name: PROGRAM_ASSET_FILE,
+		source: program
+	});
+	return {
+		code: toBrowserProgramFacadeModule(`import.meta.ROLLUP_FILE_URL_${referenceId}`),
+		asset: {
+			referenceId,
+			source: program
+		}
+	};
+}
+/**
+* Serves `virtual:master-css-manifest` and, given a compiler, the
+* `virtual:master-css-program` that browsers execute.
+*/
+function createMasterCSSManifestVirtualModulePlugin(loadManifest, context = {}, compileProgram) {
+	let cssManifestDependencies = [];
+	const serverManifestReferences = /* @__PURE__ */ new Set();
+	const addServerAllow = (dependency) => {
+		const allow = context.config?.server?.fs?.allow;
+		if (allow && !allow.includes(dependency)) allow.push(dependency);
+	};
+	const loadDefaultManifest = async (pluginContext) => {
+		const dependencies = /* @__PURE__ */ new Set();
+		const result = await loadManifest({
+			root: context.config?.root,
+			onDependency(dependency) {
+				dependencies.add(dependency);
+				cssManifestDependencies = Object.freeze([...dependencies]);
+				addServerAllow(dependency);
+				pluginContext.addWatchFile?.(dependency);
+			}
+		});
+		cssManifestDependencies = result.dependencies;
+		return result;
+	};
+	return {
+		name: "master-css:virtual-module:manifest",
+		enforce: "pre",
+		configResolved(config) {
+			context.config = config;
+		},
+		async buildStart() {
+			if (isProductionBuild(context)) return;
+			await loadDefaultManifest(this);
+		},
+		resolveId(id) {
+			if (id === "virtual:master-css-manifest") return RESOLVED_VIRTUAL_MANIFEST_ID;
+			if (id === "virtual:master-css-program" && compileProgram) return RESOLVED_VIRTUAL_PROGRAM_ID;
+		},
+		async load(id) {
+			if (id === "\0virtual:master-css-manifest") {
+				const result = await loadDefaultManifest(this);
+				return createManifestModule(context, this, result.manifest, serverManifestReferences);
+			}
+			if (id === "\0virtual:master-css-program" && compileProgram) {
+				const result = await loadDefaultManifest(this);
+				const module = await createMasterCSSProgramModule(context, this, result.manifest, compileProgram);
+				context.defaultProgramAssetReferenceId = module.asset?.referenceId;
+				context.defaultProgramAssetSource = module.asset?.source;
+				return module.code;
+			}
+		},
+		resolveFileUrl({ referenceId, relativePath, format }) {
+			if (serverManifestReferences.has(referenceId)) return toServerManifestFileURL(relativePath, format);
+		},
+		handleHotUpdate({ file, modules = [], server }) {
+			if (!cssManifestDependencies.includes(file)) return;
+			return [.../* @__PURE__ */ new Set([
+				...modules,
+				...invalidateManifestModule(server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_MANIFEST_ID), server),
+				...invalidateManifestModule(server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_PROGRAM_ID), server)
+			])];
+		}
+	};
+}
+export { createMasterCSSManifestVirtualModulePlugin, createMasterCSSProgramModule };

package/dist/internal/src/node.js

@@ -0,0 +1,22 @@
+import { createHash } from "node:crypto";
+import "node:fs";
+import "node:path";
+// ../internal/src/node.ts
+const RESOLVED_MASTER_CSS_MANIFEST_QUERY_PREFIX = "\0master-css-manifest:";
+const RESOLVED_MASTER_CSS_PROGRAM_QUERY_PREFIX = "\0master-css-program:";
+function toHashedManifestAssetFileName(json, basename = "master-css-manifest") {
+	return `${basename}.${createHash("sha256").update(json).digest("hex").slice(0, 8)}.json`;
+}
+function toResolvedMasterCSSManifestId(file) {
+	return RESOLVED_MASTER_CSS_MANIFEST_QUERY_PREFIX + Buffer.from(file).toString("base64url");
+}
+function fromResolvedMasterCSSManifestId(id) {
+	return id.startsWith("\0master-css-manifest:") ? Buffer.from(id.slice(21), "base64url").toString() : void 0;
+}
+function toResolvedMasterCSSProgramId(file) {
+	return RESOLVED_MASTER_CSS_PROGRAM_QUERY_PREFIX + Buffer.from(file).toString("base64url");
+}
+function fromResolvedMasterCSSProgramId(id) {
+	return id.startsWith("\0master-css-program:") ? Buffer.from(id.slice(20), "base64url").toString() : void 0;
+}
+export { RESOLVED_MASTER_CSS_MANIFEST_QUERY_PREFIX, RESOLVED_MASTER_CSS_PROGRAM_QUERY_PREFIX, fromResolvedMasterCSSManifestId, fromResolvedMasterCSSProgramId, toHashedManifestAssetFileName, toResolvedMasterCSSManifestId, toResolvedMasterCSSProgramId };

package/dist/internal/src/program-module.js

@@ -0,0 +1,50 @@
+// ../internal/src/program-module.ts
+/**
+* Runtime programs are manifests compiled for the browser engine. Browsers import
+* `virtual:master-css-program`, whose default export is the program bytes; server
+* rendering keeps importing the manifest.
+*/
+const VIRTUAL_PROGRAM_ID = "virtual:master-css-program";
+const RESOLVED_VIRTUAL_PROGRAM_ID = `\0${VIRTUAL_PROGRAM_ID}`;
+const MASTER_CSS_PROGRAM_QUERY = "?master-css-program";
+const PROGRAM_ASSET_FILE = "master-css-program.bin";
+const MASTER_CSS_PROGRAM_PRELOAD_REL = "preload";
+const MASTER_CSS_PROGRAM_PRELOAD_AS = "fetch";
+function isMasterCSSProgramRequest(id) {
+	return id.endsWith(MASTER_CSS_PROGRAM_QUERY);
+}
+function stripMasterCSSProgramQuery(id) {
+	return isMasterCSSProgramRequest(id) ? id.slice(0, -19) : id;
+}
+function toBase64(program) {
+	let binary = "";
+	for (let index = 0; index < program.length; index += 32768) binary += String.fromCharCode(...program.subarray(index, index + 32768));
+	return btoa(binary);
+}
+/** Development and server builds inline the program instead of emitting an asset. */
+function toInlineProgramModule(program) {
+	return [
+		`const masterCSSProgram = atob(${JSON.stringify(toBase64(program))});`,
+		`export default Uint8Array.from(masterCSSProgram, character => character.charCodeAt(0));`,
+		``
+	].join("\n");
+}
+/** Browser builds fetch the emitted program, which `<link rel="preload" as="fetch">` can start early. */
+function toBrowserProgramFacadeModule(urlExpression) {
+	return [
+		`const masterCSSProgramURL = ${urlExpression};`,
+		`const masterCSSProgramResponse = await fetch(masterCSSProgramURL);`,
+		`if (!masterCSSProgramResponse.ok) throw new Error(\`Cannot load the Master CSS runtime program from \${masterCSSProgramURL} (HTTP \${masterCSSProgramResponse.status}).\`);`,
+		`export default new Uint8Array(await masterCSSProgramResponse.arrayBuffer());`,
+		``
+	].join("\n");
+}
+function toProgramPreloadLinkAttrs(href) {
+	return {
+		rel: MASTER_CSS_PROGRAM_PRELOAD_REL,
+		as: MASTER_CSS_PROGRAM_PRELOAD_AS,
+		crossorigin: "",
+		href
+	};
+}
+export { MASTER_CSS_PROGRAM_PRELOAD_AS, MASTER_CSS_PROGRAM_PRELOAD_REL, MASTER_CSS_PROGRAM_QUERY, PROGRAM_ASSET_FILE, RESOLVED_VIRTUAL_PROGRAM_ID, VIRTUAL_PROGRAM_ID, isMasterCSSProgramRequest, stripMasterCSSProgramQuery, toBrowserProgramFacadeModule, toInlineProgramModule, toProgramPreloadLinkAttrs };

package/dist/internal/src/project.js

@@ -0,0 +1,10 @@
+import default_manifest_default from "../../preset/src/default-manifest.js";
+// ../internal/src/project.ts
+const defaultBuildManifest = Object.freeze(default_manifest_default);
+function cleanManifestStylesheetRequest(id) {
+	return id.replace(/[?#].*$/, "");
+}
+function isManifestStylesheetRequest(id) {
+	return cleanManifestStylesheetRequest(id).endsWith(".css");
+}
+export { cleanManifestStylesheetRequest, defaultBuildManifest, isManifestStylesheetRequest };

package/dist/internal/src/runtime-bootstrap.js

@@ -0,0 +1,80 @@
+// ../internal/src/runtime-bootstrap.ts
+const MASTER_CSS_RUNTIME_BOOTSTRAP_ID = "virtual:master-css-runtime";
+const RESOLVED_MASTER_CSS_RUNTIME_BOOTSTRAP_ID = `\0${MASTER_CSS_RUNTIME_BOOTSTRAP_ID}`;
+function createMasterCSSRuntimeBootstrapSource({ progressive } = {}) {
+	return [
+		`import { MasterCSSRuntime } from '@master/css-runtime'`,
+		...progressive ? [] : [`import masterCSSProgram from 'virtual:master-css-program'`],
+		`import masterCSSEmittedGlobals from 'virtual:master-css-emitted-globals'`,
+		``,
+		`let masterCSSRuntime`,
+		progressive ? `let currentProgram = () => import('virtual:master-css-program').then(module => module.default)` : `let currentProgram = masterCSSProgram`,
+		`let currentEmittedGlobals = masterCSSEmittedGlobals`,
+		`let startGeneration = 0`,
+		`let pendingStart = import.meta.hot?.data.pendingRuntimeStart ?? Promise.resolve()`,
+		``,
+		`function disposeRuntime() {`,
+		`  startGeneration++`,
+		`  masterCSSRuntime?.dispose()`,
+		`  masterCSSRuntime = undefined`,
+		`}`,
+		``,
+		`async function startRuntime(program = currentProgram, emittedGlobals = currentEmittedGlobals) {`,
+		`  if (typeof document === 'undefined') return`,
+		`  if (masterCSSRuntime) {`,
+		`    // A program loader means only emitted globals changed.`,
+		`    masterCSSRuntime.refresh(typeof program === 'function' ? undefined : program, emittedGlobals)`,
+		`    return`,
+		`  }`,
+		`  disposeRuntime()`,
+		`  const generation = startGeneration`,
+		`  const startup = pendingStart.catch(() => {}).then(async () => {`,
+		`    if (generation !== startGeneration) return`,
+		`    const nextRuntime = await MasterCSSRuntime.start({`,
+		`      program,`,
+		`      emittedGlobals,`,
+		`      onDiagnostic: diagnostic => console.error(diagnostic)`,
+		`    })`,
+		`    if (generation !== startGeneration) {`,
+		`      nextRuntime.dispose()`,
+		`      return`,
+		`    }`,
+		`    masterCSSRuntime = nextRuntime.observe()`,
+		`  })`,
+		`  pendingStart = startup`,
+		`  await startup`,
+		`}`,
+		``,
+		`if (typeof document !== 'undefined') {`,
+		`  void startRuntime().catch(error => console.error(error, error?.cause))`,
+		`}`,
+		``,
+		`if (import.meta.hot) {`,
+		`  import.meta.hot.accept(() => {})`,
+		`  import.meta.hot.accept([`,
+		`    'virtual:master-css-program',`,
+		`    'virtual:master-css-emitted-globals'`,
+		`  ], ([programModule, emittedGlobalsModule]) => {`,
+		`    currentProgram = programModule?.default ?? currentProgram`,
+		`    currentEmittedGlobals = emittedGlobalsModule?.default ?? currentEmittedGlobals`,
+		`    void startRuntime().catch(error => console.error(error, error?.cause))`,
+		`  })`,
+		`  import.meta.hot.dispose(data => {`,
+		`    disposeRuntime()`,
+		`    data.pendingRuntimeStart = pendingStart`,
+		`  })`,
+		`}`,
+		``
+	].join("\n");
+}
+/** Resolve the public delivery contract before any adapter injects code. */
+function resolveIntegrationRuntime(mode, runtime) {
+	const options = typeof runtime === "object" ? runtime : { enabled: runtime };
+	const enabled = mode === "runtime" || mode === "progressive";
+	if (options.enabled !== void 0 && options.enabled !== enabled) throw new TypeError(`Master CSS mode "${mode}" requires runtime.enabled=${enabled}. Select a consistent rendering mode.`);
+	return {
+		...options,
+		enabled
+	};
+}
+export { MASTER_CSS_RUNTIME_BOOTSTRAP_ID, RESOLVED_MASTER_CSS_RUNTIME_BOOTSTRAP_ID, createMasterCSSRuntimeBootstrapSource, resolveIntegrationRuntime };

package/dist/internal/src/style-module.js

@@ -0,0 +1,3 @@
+// ../internal/src/style-module.ts
+const VIRTUAL_CSS_ID = "virtual:master-utilities.css";
+export { VIRTUAL_CSS_ID };

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

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

package/dist/modes/pre-render.js

@@ -0,0 +1,6 @@
+import PreRenderPlugin from "../plugins/pre-render.js";
+// src/modes/pre-render.ts
+function PreRenderMode(options, context) {
+	return [PreRenderPlugin(options, context)];
+}
+export { PreRenderMode as default };

package/dist/modes/progressive.d.ts

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

package/dist/modes/progressive.js

@@ -0,0 +1,12 @@
+import InjectRuntimePlugin, { InjectRuntimeServePlugin } from "../plugins/inject-runtime.js";
+import PreRenderPlugin from "../plugins/pre-render.js";
+// src/modes/progressive.ts
+function ProgressiveMode(options, context) {
+	const plugins = [PreRenderPlugin(options, context)];
+	if (options.injectRuntime) {
+		plugins.push(InjectRuntimePlugin(options));
+		plugins.push(InjectRuntimeServePlugin(options));
+	}
+	return plugins;
+}
+export { ProgressiveMode as default };

package/dist/modes/runtime.d.ts

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

package/dist/modes/runtime.js

@@ -0,0 +1,17 @@
+import InjectRuntimePlugin, { InjectRuntimeServePlugin } from "../plugins/inject-runtime.js";
+import ProgramPreloadPlugin from "../plugins/program-preload.js";
+import RuntimePreloadPlugin from "../plugins/runtime-preload.js";
+import AvoidFOUCPlugin from "../plugins/avoid-fouc.js";
+// src/modes/runtime.ts
+function RuntimeMode(options, context) {
+	const plugins = [];
+	if (options.injectRuntime) {
+		plugins.push(InjectRuntimePlugin(options));
+		plugins.push(InjectRuntimeServePlugin(options));
+		plugins.push(RuntimePreloadPlugin(context));
+		plugins.push(ProgramPreloadPlugin(context));
+	}
+	if (options.avoidFOUC) plugins.push(AvoidFOUCPlugin(options, context));
+	return plugins;
+}
+export { RuntimeMode as default };

package/dist/modes/static.d.ts

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

package/dist/modes/static.js

@@ -0,0 +1,5 @@
+// src/modes/static.ts
+function StaticMode(_options, _context) {
+	return [];
+}
+export { StaticMode as default };

package/dist/options.d.ts

@@ -0,0 +1,20 @@
+import { MasterCSSScannerConfiguration } from "@master/css-tooling/scanner/node";
+import { MasterCSSIntegrationRuntimeOptions, MasterCSSRenderingMode } from "@master/css-schema/integration";
+interface MasterCSSVitePluginOptions {
+  enabled?: boolean;
+  mode?: MasterCSSRenderingMode;
+  pruneNativeCSS?: boolean;
+  scanner?: MasterCSSScannerConfiguration;
+  runtime?: boolean | MasterCSSIntegrationRuntimeOptions;
+}
+interface ResolvedMasterCSSVitePluginOptions {
+  enabled?: boolean;
+  mode?: MasterCSSRenderingMode;
+  pruneNativeCSS?: boolean;
+  scanner?: MasterCSSScannerConfiguration;
+  injectRuntime?: boolean;
+  avoidFOUC?: boolean;
+}
+declare const defaultMasterCSSVitePluginOptions: Readonly<ResolvedMasterCSSVitePluginOptions>;
+declare function resolveMasterCSSVitePluginOptions(options?: MasterCSSVitePluginOptions): ResolvedMasterCSSVitePluginOptions;
+export { MasterCSSVitePluginOptions, ResolvedMasterCSSVitePluginOptions, defaultMasterCSSVitePluginOptions, resolveMasterCSSVitePluginOptions };

package/dist/options.js

@@ -0,0 +1,23 @@
+import { resolveIntegrationRuntime } from "./internal/src/runtime-bootstrap.js";
+// src/options.ts
+const defaultMasterCSSVitePluginOptions = Object.freeze({
+	enabled: true,
+	mode: "static",
+	pruneNativeCSS: false,
+	scanner: Object.freeze({}),
+	injectRuntime: false,
+	avoidFOUC: true
+});
+function resolveMasterCSSVitePluginOptions(options = {}) {
+	const mode = options.mode ?? "static";
+	const runtime = resolveIntegrationRuntime(mode, options.runtime);
+	return {
+		enabled: options.enabled ?? true,
+		mode,
+		pruneNativeCSS: options.pruneNativeCSS ?? false,
+		scanner: options.scanner ?? {},
+		injectRuntime: runtime.enabled,
+		avoidFOUC: runtime.avoidFOUC ?? true
+	};
+}
+export { defaultMasterCSSVitePluginOptions, resolveMasterCSSVitePluginOptions };

package/dist/plugins/avoid-fouc.d.ts

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

package/dist/plugins/avoid-fouc.js

@@ -0,0 +1,48 @@
+import { HTML_ENTRIES } from "../common.js";
+import MagicString from "magic-string";
+// src/plugins/avoid-fouc.ts
+const HTML_OPEN_TAG_RE = /<html(\s[^>]*)?>/gi;
+const HIDDEN_ATTR_RE = /(?:^|\s)hidden(?:[\s=]|$)/i;
+const isInsideComment = (html, index) => {
+	return html.lastIndexOf("<!--", index) > html.lastIndexOf("-->", index);
+};
+const replace = (html) => {
+	HTML_OPEN_TAG_RE.lastIndex = 0;
+	for (const match of html.matchAll(HTML_OPEN_TAG_RE)) {
+		if (match.index === void 0 || isInsideComment(html, match.index)) continue;
+		const attrs = match[1] || "";
+		if (HIDDEN_ATTR_RE.test(attrs)) return html;
+		if (process.env.DEBUG) console.log(`[@master/css-vite] Avoid FOUC by adding hidden attribute to <html>`);
+		const start = match.index;
+		const end = start + match[0].length;
+		return html.slice(0, start) + `<html${attrs} hidden>` + html.slice(end);
+	}
+	return html;
+};
+function AvoidFOUCPlugin(options, context) {
+	return {
+		name: "master-css:avoid-fouc",
+		enforce: "pre",
+		transformIndexHtml(html) {
+			return {
+				html: replace(html),
+				tags: []
+			};
+		},
+		transform(code, id) {
+			for (const entry of HTML_ENTRIES) if (id.endsWith(entry)) {
+				const magicString = new MagicString(code);
+				const replacedCode = replace(code);
+				if (replacedCode !== code) {
+					magicString.overwrite(0, code.length, replacedCode);
+					return {
+						code: magicString.toString(),
+						map: magicString.generateMap({ hires: true })
+					};
+				}
+			}
+			return null;
+		}
+	};
+}
+export { AvoidFOUCPlugin as default };

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

@@ -0,0 +1,5 @@
+import { Plugin } from "vite";
+import { MasterCSSVitePluginContext } from "../core.js";
+/** Recover failed watch builds without changing authored files or dependency data. */
+declare function BuildStylesheetRecoveryPlugin(context: MasterCSSVitePluginContext): Plugin;
+export { BuildStylesheetRecoveryPlugin as default };