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

package/dist/utils/inline-stylesheet.js

@@ -0,0 +1,129 @@
+import { getSassSourceFile } from "./build-sass-source.js";
+import { getScanner } from "./scanner-context.js";
+import { getBuildStylesheetDelivery } from "./build-stylesheet-delivery.js";
+import { createHash } from "node:crypto";
+import { createStylesheetCollection } from "@master/css-compiler/stylesheet";
+// src/utils/inline-stylesheet.ts
+const states = /* @__PURE__ */ new WeakMap();
+const INLINE_URL_BASE = "https://master-css-inline.invalid/";
+function inlineDigest(value) {
+	return createHash("sha256").update(value).digest("hex").slice(0, 20);
+}
+function isInlineStylesheet(id) {
+	return /[?&]inline(?:[=&]|$)/.test(id);
+}
+function inlineStylesheets(context) {
+	let state = states.get(context);
+	if (!state) {
+		state = /* @__PURE__ */ new Map();
+		states.set(context, state);
+	}
+	return state;
+}
+function disposeInlineStylesheets(context) {
+	for (const entry of inlineStylesheets(context).values()) entry.collection.dispose();
+	states.delete(context);
+}
+function inlineDelivery(context) {
+	const delivery = getBuildStylesheetDelivery(context);
+	return {
+		...delivery,
+		entryURL: INLINE_URL_BASE + "entry.css",
+		stylesheetURL: (file, variant) => INLINE_URL_BASE + delivery.stylesheetURL(file, variant).slice(2),
+		resourceURL: (file) => INLINE_URL_BASE + delivery.resourceURL(file).slice(2),
+		relativeResourceURLs: false
+	};
+}
+async function registerInlineStylesheet(context, id, source, host) {
+	const entries = inlineStylesheets(context);
+	let entry = entries.get(id);
+	if (!entry) {
+		entry = {
+			collection: createStylesheetCollection(),
+			token: `__MASTER_CSS_INLINE_${inlineDigest(id)}__`
+		};
+		entries.set(id, entry);
+	}
+	return entry.collection.register(getScanner(context), id, source, {
+		baseManifest: getScanner(context).css.manifest,
+		projectDir: context.config?.root,
+		delivery: {
+			...inlineDelivery(context),
+			...host,
+			baseFile: getSassSourceFile(id)
+		}
+	});
+}
+function registerLocalInlineStylesheet(context, id, local) {
+	const entries = inlineStylesheets(context);
+	const entry = entries.get(id) ?? {
+		collection: createStylesheetCollection(),
+		token: `__MASTER_CSS_INLINE_${inlineDigest(id)}__`
+	};
+	entry.local = local;
+	entries.set(id, entry);
+}
+/** Return resource/import references using the compiler's source analysis. */
+function inlineURLReferences(compiler, css) {
+	return compiler.prepareStylesheetBundle({
+		source: css,
+		from: "inline-url-source",
+		slotCSSRule: `#master-css-url-scan-${inlineDigest(css)}{--slot:0}`,
+		managed: {
+			entry: "empty",
+			stylesheets: [{
+				id: "empty",
+				href: "/empty.css",
+				css: ""
+			}]
+		}
+	}).sources.flatMap((source) => [...source.resources, ...source.imports]);
+}
+/** Rewrite host-issued URLs only at Rust-reported resource/import ranges. */
+function rewriteInlineURLs(compiler, css, target, ownedURLs) {
+	const bundle = compiler.prepareStylesheetBundle({
+		source: css,
+		from: "inline-url-source",
+		slotCSSRule: `#master-css-url-scan-${inlineDigest(css)}{--slot:0}`,
+		managed: {
+			entry: "empty",
+			stylesheets: [{
+				id: "empty",
+				href: "/empty.css",
+				css: ""
+			}]
+		}
+	});
+	const references = bundle.sources.flatMap((source) => [...source.resources, ...source.imports]);
+	if (!references.some((reference) => ownedURLs.has(reference.url.split(/[?#]/)[0]))) return css;
+	const mappings = new Map(references.map((reference) => [reference.url, ownedURLs.has(reference.url.split(/[?#]/)[0]) ? encodeURI(target(reference.url)).replaceAll("%25", "%") : reference.url]));
+	let prefix = `https://master-css-relocation.invalid/${inlineDigest(css)}/`;
+	while (css.includes(prefix) || [...mappings.values()].some((value) => value.includes(prefix))) prefix += "_";
+	const resourceURLs = Object.fromEntries([...mappings].map(([url, value]) => [url, prefix + value]));
+	const urls = Object.fromEntries(bundle.graph.stylesheets.map((node) => [node.id, "/inline-url-source.css"]));
+	return compiler.renderStylesheetBundle({
+		bundle,
+		urls,
+		resourceURLs
+	}).find((asset) => asset.id === bundle.graph.entry).css.replaceAll(prefix, "");
+}
+/** Apply Vite's public output URL hook to the actual referenced file. */
+function inlineBuiltURL(config, ssr, filename, hostId, hostType) {
+	let relative = config.base === "" || config.base === "./";
+	const result = config.experimental.renderBuiltUrl?.(filename, {
+		hostId,
+		hostType,
+		type: "asset",
+		ssr
+	});
+	if (typeof result === "string" && result) return { url: result };
+	if (result && typeof result === "object") {
+		if (result.runtime) {
+			if (hostType === "css") throw new Error("Vite renderBuiltUrl runtime expressions are not supported in CSS assets");
+			return { runtime: result.runtime };
+		}
+		if (typeof result.relative === "boolean") relative = result.relative;
+	}
+	return relative && (hostType === "css" || !ssr) ? { relative: true } : { url: config.base + filename };
+}
+export { INLINE_URL_BASE, disposeInlineStylesheets, inlineBuiltURL, inlineDelivery, inlineDigest, inlineStylesheets, inlineURLReferences, isInlineStylesheet, registerInlineStylesheet, registerLocalInlineStylesheet, rewriteInlineURLs };

package/dist/utils/local-stylesheet.d.ts

@@ -0,0 +1,10 @@
+import { MasterCSSStylesheetTransformResult } from "@master/css-compiler/stylesheet";
+import { MasterCSSVitePluginContext } from "../core.js";
+interface LocalStylesheet {
+  slot: string;
+  result: MasterCSSStylesheetTransformResult;
+}
+declare function localStylesheets(context: MasterCSSVitePluginContext): Map<string, LocalStylesheet>;
+declare function clearLocalStylesheets(context: MasterCSSVitePluginContext): void;
+declare function registerLocalStylesheet(context: MasterCSSVitePluginContext, id: string, result: MasterCSSStylesheetTransformResult): string;
+export { LocalStylesheet, clearLocalStylesheets, localStylesheets, registerLocalStylesheet };

package/dist/utils/local-stylesheet.js

@@ -0,0 +1,25 @@
+import { toRootRelativeModuleId } from "./path.js";
+import { createHash } from "node:crypto";
+// src/utils/local-stylesheet.ts
+const states = /* @__PURE__ */ new WeakMap();
+function localStylesheets(context) {
+	let entries = states.get(context);
+	if (!entries) {
+		entries = /* @__PURE__ */ new Map();
+		states.set(context, entries);
+	}
+	return entries;
+}
+function clearLocalStylesheets(context) {
+	states.delete(context);
+}
+function registerLocalStylesheet(context, id, result) {
+	const hash = createHash("sha256").update(toRootRelativeModuleId(context.config?.root, id)).digest("hex").slice(0, 20);
+	const slot = `#master-css-local-${hash}{--slot:local-${hash}}`;
+	localStylesheets(context).set(id, {
+		slot,
+		result
+	});
+	return slot;
+}
+export { clearLocalStylesheets, localStylesheets, registerLocalStylesheet };

package/dist/utils/manifest-recovery.d.ts

@@ -0,0 +1,11 @@
+import { MasterCSSVitePluginContext } from "../core.js";
+import { DependencyHost } from "./failed-stylesheet-dependencies.js";
+/** Manifest initialization can fail before an HTML or virtual module exists. */
+declare function createManifestRecovery<T, Host extends DependencyHost = DependencyHost>(context: MasterCSSVitePluginContext, id: string, load: (onDependency: (file: string) => void, host: Host, active: () => boolean) => Promise<T>): {
+  run: (host: Host, isActive?: () => boolean) => Promise<T>;
+  assertReady(): void;
+  readonly failed: boolean;
+  isActive(environment?: object): boolean;
+  close(environment: object): void;
+};
+export { createManifestRecovery };

package/dist/utils/manifest-recovery.js

@@ -0,0 +1,77 @@
+import { clearFailedStylesheets, withStylesheetDependencies } from "./failed-stylesheet-dependencies.js";
+import { sendRecoveryError } from "./recovery-error.js";
+import { onEnvironmentClosing } from "./environment-closing.js";
+// src/utils/manifest-recovery.ts
+/** Manifest initialization can fail before an HTML or virtual module exists. */
+function createManifestRecovery(context, id, load) {
+	let failure;
+	let failed = false;
+	const closed = /* @__PURE__ */ new WeakSet();
+	const tracked = /* @__PURE__ */ new WeakSet();
+	let queue = Promise.resolve();
+	const run = (host, isActive = () => true) => {
+		if (host.environment && !tracked.has(host.environment)) {
+			const environment = host.environment;
+			tracked.add(environment);
+			onEnvironmentClosing(environment, () => {
+				closed.add(environment);
+				clearFailedStylesheets(context, environment);
+			});
+		}
+		const active = () => isActive() && (!host.environment || !closed.has(host.environment));
+		const operation = queue.then(async () => {
+			if (!active()) throw new Error("Master CSS manifest environment closed");
+			try {
+				const result = await withStylesheetDependencies(context, host, id, (onDependency) => load((file) => {
+					if (active()) onDependency(file);
+				}, host, active), "manifest", recover);
+				if (active()) {
+					failed = false;
+					failure = void 0;
+				}
+				return result;
+			} catch (error) {
+				if (active()) {
+					failed = true;
+					failure = error;
+				}
+				throw error;
+			}
+		});
+		queue = operation.catch(() => {});
+		return operation;
+	};
+	const recover = async (owner, _id, _files, active) => {
+		const environment = owner;
+		try {
+			await run({ environment }, active);
+		} catch (error) {
+			if (active() && !closed.has(environment)) sendRecoveryError(environment, error, id);
+			throw error;
+		}
+		if (!active() || closed.has(environment)) return;
+		const module = environment.moduleGraph.getModuleById(id);
+		if (module) environment.moduleGraph.invalidateModule(module);
+		if (module && module.isSelfAccepting !== void 0) await environment.reloadModule(module);
+		else if (environment.config.consumer === "client") environment.hot.send({
+			type: "full-reload",
+			path: "*"
+		});
+	};
+	return {
+		run,
+		assertReady() {
+			if (failed) throw failure;
+		},
+		get failed() {
+			return failed;
+		},
+		isActive(environment) {
+			return !environment || !closed.has(environment);
+		},
+		close(environment) {
+			closed.add(environment);
+		}
+	};
+}
+export { createManifestRecovery };

package/dist/utils/module-sources.d.ts

@@ -0,0 +1,26 @@
+import { CSSOptions } from "vite";
+type InlinePostCSS = Exclude<CSSOptions['postcss'], string | undefined>;
+type HostPlugin = Exclude<Extract<NonNullable<InlinePostCSS['plugins']>[number], {
+  postcssPlugin: string;
+}>, (...args: never[]) => unknown>;
+type AdditionalData = NonNullable<NonNullable<CSSOptions['preprocessorOptions']>['scss']>['additionalData'];
+interface ModuleSourceDiagnostic {
+  source: string;
+  code: string;
+  map?: string;
+}
+declare function moduleSourceID(owner: string, file: string): string;
+declare function moduleSourceOwner(id: string): {
+  owner: string;
+  file: string;
+} | undefined;
+/** Project Vite's Modules AST changes onto its original per-file syntax trees. */
+declare function createModuleSourceProjection(file: string): {
+  plugin: HostPlugin;
+  sources: Map<string, string>;
+  diagnostics: Map<string, ModuleSourceDiagnostic>;
+  sourceFiles: Map<string, string>;
+  copyDuplicate(id: string, source: string): void;
+  additionalData(value: AdditionalData): AdditionalData;
+};
+export { ModuleSourceDiagnostic, createModuleSourceProjection, moduleSourceID, moduleSourceOwner };

package/dist/utils/module-sources.js

@@ -0,0 +1,131 @@
+import { normalizeFilePath } from "./path.js";
+import { createSassSourceMarkers } from "./sass-source-markers.js";
+import { isAbsolute } from "node:path";
+import { inspectCSSSync } from "@master/css-compiler/node";
+import { fileURLToPath, pathToFileURL } from "node:url";
+// src/utils/module-sources.ts
+const PREFIX = "\0master-css:module-source:";
+function moduleSourceID(owner, file) {
+	return `${PREFIX}${encodeURIComponent(owner)}:${encodeURIComponent(file)}.css`;
+}
+function moduleSourceOwner(id) {
+	if (!id.startsWith(PREFIX)) return;
+	const [owner, file] = id.slice(26, -4).split(":");
+	return {
+		owner: decodeURIComponent(owner),
+		file: decodeURIComponent(file)
+	};
+}
+/** Project Vite's Modules AST changes onto its original per-file syntax trees. */
+function createModuleSourceProjection(file) {
+	file = normalizeFilePath(file);
+	const originals = /* @__PURE__ */ new Map();
+	const sources = /* @__PURE__ */ new Map();
+	const projectedInputs = /* @__PURE__ */ new Map();
+	const inputDiagnostics = /* @__PURE__ */ new Map();
+	const diagnostics = /* @__PURE__ */ new Map();
+	const authoredInputs = /* @__PURE__ */ new Map();
+	const preparation = createSassSourceMarkers((id, source) => authoredInputs.set(normalizeFilePath(id), source));
+	const { markers } = preparation;
+	const sourceFiles = /* @__PURE__ */ new Map();
+	const sourceFile = (id) => sourceFiles.get(normalizeFilePath(id)) ?? normalizeFilePath(id);
+	const key = (node) => `${node.type}:${node.source?.start?.offset}:${node.source?.end?.offset}`;
+	return {
+		plugin: {
+			postcssPlugin: "master-css:module-source-projection",
+			prepare({ root }) {
+				if (root.type === "root") originals.set(file, root.clone());
+				root.walkAtRules("import", (rule) => {
+					if (inspectCSSSync(`${rule.toString()};`).hasMasterCSSImport) rule.name = "--master-css-preserved-import";
+				});
+				return {};
+			},
+			Once(root, { postcss }) {
+				root.walk((node) => {
+					const input = node.source?.input;
+					if (input?.file && !originals.has(sourceFile(input.file))) originals.set(sourceFile(input.file), postcss.parse(input.css, { from: sourceFile(input.file) }));
+				});
+				root.walkComments((node) => {
+					if (node.source?.input.file && sourceFiles.has(normalizeFilePath(node.source.input.file)) && node.text.trim().startsWith("# sourceMappingURL=") || markers.has(node.text.trim())) node.remove();
+				});
+			},
+			OnceExit(root) {
+				const transformed = /* @__PURE__ */ new Map();
+				root.walk((node) => {
+					const input = node.source?.input;
+					if (input?.file) transformed.set(`${sourceFile(input.file)}:${key(node)}`, node);
+				});
+				for (const [id, original] of originals) {
+					for (const node of [...original.nodes]) {
+						if (node.type === "atrule" && node.name.toLowerCase() === "import") continue;
+						const next = transformed.get(`${id}:${key(node)}`);
+						if (next) node.replaceWith(next.clone());
+						else node.remove();
+					}
+					if (id === file) {
+						const firstRule = original.nodes.find((node) => node.type !== "comment" && !(node.type === "atrule" && (node.name === "import" || node.name === "charset" || node.name === "layer" && !node.nodes)));
+						for (const node of root.nodes.filter((node) => !node.source?.input.file)) if (firstRule) original.insertBefore(firstRule, node.clone());
+						else original.append(node.clone());
+					}
+					const css = original.toString();
+					sources.set(id, css);
+					const input = original.source?.input.css;
+					if (input !== void 0) {
+						projectedInputs.set(input, css);
+						const map = original.toResult({
+							from: id,
+							to: id,
+							map: {
+								inline: false,
+								annotation: false,
+								sourcesContent: true
+							}
+						}).map?.toJSON();
+						if (map) map.sources = map.sources.map((source, index) => {
+							const url = isAbsolute(source) ? pathToFileURL(source) : new URL(source, pathToFileURL(id));
+							const temporary = url.protocol === "file:" ? sourceFiles.get(normalizeFilePath(fileURLToPath(url))) : void 0;
+							if (!temporary) return source;
+							if (map.sourcesContent) map.sourcesContent[index] = "";
+							return `\0master-css:preprocessed:${temporary}`;
+						});
+						const diagnostic = {
+							source: authoredInputs.get(id) ?? input,
+							code: css,
+							map: map && JSON.stringify(map)
+						};
+						diagnostics.set(id, diagnostic);
+						inputDiagnostics.set(input, diagnostic);
+					}
+				}
+				const originalRoot = originals.get(file);
+				if (originalRoot) {
+					root.removeAll();
+					root.append(originalRoot.nodes.map((node) => node.clone()));
+				}
+			}
+		},
+		sources,
+		diagnostics,
+		sourceFiles,
+		additionalData: preparation.additionalData,
+		copyDuplicate(id, source) {
+			id = normalizeFilePath(id);
+			const projected = projectedInputs.get(source);
+			if (projected !== void 0 && !sources.has(id)) {
+				sources.set(id, projected);
+				const original = inputDiagnostics.get(source);
+				const raw = original?.map ? JSON.parse(original.map) : void 0;
+				if (raw?.sources.length === 1) {
+					raw.sources = [pathToFileURL(id).href];
+					raw.sourceRoot = "";
+				}
+				diagnostics.set(id, {
+					source,
+					code: projected,
+					map: raw?.sources.length === 1 ? JSON.stringify(raw) : void 0
+				});
+			}
+		}
+	};
+}
+export { createModuleSourceProjection, moduleSourceID, moduleSourceOwner };

package/dist/utils/path.d.ts

@@ -0,0 +1,5 @@
+/** Identify a module by its root-relative ID, so the identity survives moving the project. */
+declare function toRootRelativeModuleId(root: string | undefined, id: string): string;
+declare function normalizeFilePath(file: string): string;
+declare function includesFile(dependencies: string[], file: string): boolean;
+export { includesFile, normalizeFilePath, toRootRelativeModuleId };

package/dist/utils/path.js

@@ -0,0 +1,27 @@
+import { realpathSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+// src/utils/path.ts
+/** Identify a module by its root-relative ID, so the identity survives moving the project. */
+function toRootRelativeModuleId(root, id) {
+	const prefix = id.startsWith("\0") ? "\0" : "";
+	const path = id.slice(prefix.length);
+	if (!root || !isAbsolute(path)) return id;
+	return prefix + relative(root, path).replace(/\\/g, "/");
+}
+function normalizeFilePath(file) {
+	let ancestor = resolve(file);
+	const missing = [];
+	while (true) try {
+		return join(realpathSync.native(ancestor), ...missing).replace(/\\/g, "/");
+	} catch {
+		const parent = dirname(ancestor);
+		if (parent === ancestor) return resolve(file).replace(/\\/g, "/");
+		missing.unshift(basename(ancestor));
+		ancestor = parent;
+	}
+}
+function includesFile(dependencies, file) {
+	const normalizedFile = normalizeFilePath(file);
+	return dependencies.some((dependency) => normalizeFilePath(dependency) === normalizedFile);
+}
+export { includesFile, normalizeFilePath, toRootRelativeModuleId };

package/dist/utils/recovery-error.d.ts

@@ -0,0 +1,3 @@
+import { DevEnvironment } from "vite";
+declare function sendRecoveryError(environment: DevEnvironment, error: unknown, id: string): void;
+export { sendRecoveryError };

package/dist/utils/recovery-error.js

@@ -0,0 +1,17 @@
+// src/utils/recovery-error.ts
+function sendRecoveryError(environment, error, id) {
+	const failure = error && typeof error === "object" ? error : { message: String(error) };
+	environment.hot.send({
+		type: "error",
+		err: {
+			message: failure.message ?? String(error),
+			stack: failure.stack ?? "",
+			id: failure.id ?? id,
+			frame: failure.frame,
+			plugin: failure.plugin,
+			pluginCode: failure.pluginCode,
+			loc: failure.loc
+		}
+	});
+}
+export { sendRecoveryError };

package/dist/utils/register-style-source.d.ts

@@ -0,0 +1,4 @@
+import { MasterCSSStylesheetDeliveryOptions } from "@master/css-compiler/stylesheet";
+import { MasterCSSVitePluginContext } from "../core.js";
+declare function registerStylesheetSource(context: MasterCSSVitePluginContext, id: string, source: string, host?: Pick<MasterCSSStylesheetDeliveryOptions, 'resolveImport' | 'onDependency'>): Promise<import("~/packages/compiler/src").MasterCSSCompileResult>;
+export { registerStylesheetSource };

package/dist/utils/register-style-source.js

@@ -0,0 +1,23 @@
+import { getPreparedSassSourceMap, getSassSourceFile } from "./build-sass-source.js";
+import { getScanner } from "./scanner-context.js";
+import { getBuildStylesheetDelivery } from "./build-stylesheet-delivery.js";
+import { getDevStylesheetDelivery } from "./dev-stylesheet-delivery.js";
+import { createStylesheetCollection } from "@master/css-compiler/stylesheet";
+// src/utils/register-style-source.ts
+async function registerStylesheetSource(context, id, source, host) {
+	context.stylesheets ??= createStylesheetCollection();
+	const scanner = getScanner(context);
+	const delivery = getBuildStylesheetDelivery(context) ?? getDevStylesheetDelivery(context);
+	return context.stylesheets.register(scanner, id, source, {
+		baseManifest: scanner.css.manifest,
+		projectDir: context.config?.root,
+		pruneNativeCSS: context.pruneNativeCSS,
+		delivery: delivery ? {
+			...delivery,
+			...host,
+			baseFile: getSassSourceFile(id),
+			sourceMap: await getPreparedSassSourceMap(context, id)
+		} : void 0
+	});
+}
+export { registerStylesheetSource };

package/dist/utils/sass-diagnostics.d.ts

@@ -0,0 +1,4 @@
+import { MasterCSSVitePluginContext } from "../core.js";
+/** Keep compiler diagnostics intact while adapting preprocessing source locations. */
+declare function withSassDiagnostics<T>(context: MasterCSSVitePluginContext, operation: () => Promise<T>): Promise<T>;
+export { withSassDiagnostics };

package/dist/utils/sass-diagnostics.js

@@ -0,0 +1,109 @@
+import { normalizeFilePath } from "./path.js";
+import { getPreparedSassDiagnosticSource } from "./build-sass-source.js";
+import { SourceMap } from "node:module";
+import { isAbsolute } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { MasterCSSError } from "@master/css-schema";
+// src/utils/sass-diagnostics.ts
+const mappedErrors = /* @__PURE__ */ new WeakSet();
+async function mapDiagnostic(context, diagnostic) {
+	if (!diagnostic.source || !diagnostic.range) return diagnostic;
+	const cached = await getPreparedSassDiagnosticSource(context, diagnostic.source);
+	if (!cached) return diagnostic;
+	const language = cached.file.endsWith(".css") ? "CSS Modules" : "Sass";
+	const unavailable = {
+		...diagnostic,
+		source: cached.generatedID,
+		notes: [...diagnostic.notes ?? [], `Original ${language} location is unavailable; this range refers to preprocessed CSS.`]
+	};
+	const prepared = cached.prepared;
+	const raw = typeof prepared.map === "string" ? JSON.parse(prepared.map) : prepared.map;
+	if (!raw || !("version" in raw) || !("sources" in raw) || !Array.isArray(raw.sources) || !raw.mappings) return unavailable;
+	const sourcesContent = "sourcesContent" in raw ? raw.sourcesContent ?? [] : [];
+	const sourceRoot = "sourceRoot" in raw ? raw.sourceRoot ?? "" : "";
+	const map = new SourceMap({
+		version: 3,
+		file: cached.file,
+		sourceRoot,
+		sources: raw.sources.map((source) => source ?? ""),
+		sourcesContent: sourcesContent.map((source) => source ?? ""),
+		names: "names" in raw ? raw.names ?? [] : [],
+		mappings: raw.mappings
+	});
+	const { start, end } = diagnostic.range;
+	const origin = map.findEntry(start.line, start.character);
+	if (!("originalSource" in origin) || !origin.originalSource || origin.originalSource.includes("\0") || origin.generatedLine !== start.line) return unavailable;
+	const rootSource = sourceRoot ? sourceRoot.replace(/\/?$/, "/") : "./";
+	const root = isAbsolute(rootSource) ? pathToFileURL(rootSource) : new URL(rootSource, pathToFileURL(cached.file));
+	const url = isAbsolute(origin.originalSource) ? pathToFileURL(origin.originalSource) : new URL(origin.originalSource, root);
+	const source = url.protocol === "file:" ? fileURLToPath(url) : url.href;
+	if (source.includes("\0")) return unavailable;
+	const position = {
+		line: origin.originalLine,
+		character: origin.originalColumn
+	};
+	let original = sourcesContent[raw.sources.indexOf(origin.originalSource)];
+	if (url.protocol === "file:" && normalizeFilePath(source) === cached.file) {
+		if (original != null && original !== cached.source) return unavailable;
+		original = cached.source;
+	}
+	const generatedLine = prepared.code.split(/\r\n?|\n/)[start.line];
+	const originalLine = typeof original === "string" ? original.split(/\r\n?|\n/)[origin.originalLine] : void 0;
+	const offset = start.character - origin.generatedColumn;
+	const length = end.character - origin.generatedColumn;
+	if (start.line === end.line && offset >= 0 && length >= offset && generatedLine !== void 0 && originalLine !== void 0 && originalLine.slice(origin.originalColumn, origin.originalColumn + length) === generatedLine.slice(origin.generatedColumn, end.character)) return {
+		...diagnostic,
+		source,
+		range: {
+			start: {
+				line: position.line,
+				character: position.character + offset
+			},
+			end: {
+				line: position.line,
+				character: position.character + length
+			}
+		}
+	};
+	return {
+		...diagnostic,
+		source,
+		range: {
+			start: position,
+			end: position
+		},
+		notes: [...diagnostic.notes ?? [], "The source map identifies the originating segment; an exact original token range is unavailable."]
+	};
+}
+/** Keep compiler diagnostics intact while adapting preprocessing source locations. */
+async function withSassDiagnostics(context, operation) {
+	try {
+		return await operation();
+	} catch (error) {
+		if (!(error instanceof MasterCSSError) || mappedErrors.has(error)) throw error;
+		const diagnostics = await Promise.all(error.diagnostics.map(async (diagnostic) => {
+			try {
+				return await mapDiagnostic(context, diagnostic);
+			} catch {
+				return {
+					...diagnostic,
+					notes: [...diagnostic.notes ?? [], "Sass source mapping failed; the original compiler diagnostic is retained."]
+				};
+			}
+		}));
+		if (diagnostics.every((diagnostic, index) => diagnostic === error.diagnostics[index])) throw error;
+		const mapped = new MasterCSSError({
+			...error.toJSON(),
+			diagnostics
+		}, { cause: error });
+		mappedErrors.add(mapped);
+		const primary = diagnostics.find((diagnostic) => diagnostic.source && diagnostic.range);
+		if (primary?.range) Object.assign(mapped, { loc: {
+			file: primary.source,
+			line: primary.range.start.line + 1,
+			column: primary.range.start.character
+		} });
+		throw mapped;
+	}
+}
+export { withSassDiagnostics };

package/dist/utils/sass-proxy-access.d.ts

@@ -0,0 +1,4 @@
+import { ViteDevServer } from "vite";
+/** Apply the host file policy to the real owner before loading a virtual proxy. */
+declare function installSassProxyAccessCheck(server: ViteDevServer): void;
+export { installSassProxyAccessCheck };

package/dist/utils/sass-proxy-access.js

@@ -0,0 +1,28 @@
+import { getSassSourceFile } from "./build-sass-source.js";
+import { isFileLoadingAllowed, normalizePath } from "vite";
+// src/utils/sass-proxy-access.ts
+/** Apply the host file policy to the real owner before loading a virtual proxy. */
+function installSassProxyAccessCheck(server) {
+	server.middlewares.use((request, response, next) => {
+		const check = async () => {
+			if (!request.url) return next();
+			const url = new URL(request.url, "http://master-css.invalid");
+			let path = decodeURI(url.pathname);
+			const base = server.config.base;
+			if (base !== "/" && path.startsWith(base)) path = "/" + path.slice(base.length);
+			const id = (path.startsWith("/@id/") ? path.slice(5).replace("__x00__", "\0") : path) + url.search;
+			if (!getSassSourceFile(id)) return next();
+			const resolved = await server.environments.client.pluginContainer.resolveId(id);
+			const owner = resolved && getSassSourceFile(resolved.id);
+			if (owner && !isFileLoadingAllowed(server.config, normalizePath(owner))) {
+				response.statusCode = 403;
+				response.setHeader("Content-Type", "text/plain; charset=utf-8");
+				response.end("403 Restricted");
+				return;
+			}
+			next();
+		};
+		check().catch(next);
+	});
+}
+export { installSassProxyAccessCheck };

package/dist/utils/sass-source-markers.d.ts

@@ -0,0 +1,8 @@
+import { CSSOptions } from "vite";
+type AdditionalData = NonNullable<NonNullable<CSSOptions['preprocessorOptions']>['scss']>['additionalData'];
+/** Keep input identities visible through Sass and Vite's source-map chaining. */
+declare function createSassSourceMarkers(onSource?: (file: string, source: string) => void): {
+  markers: Set<string>;
+  additionalData(value: AdditionalData): AdditionalData;
+};
+export { createSassSourceMarkers };