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

package/dist/stylesheet/public.js

@@ -0,0 +1,346 @@
+import { stylesheetValidationSource } from "./output-map.js";
+import { assertValidationOptions, validateCompiledCSS } from "../value-validation.js";
+import { toMasterCSSCompileResultInternal } from "../compiler.js";
+import { normalizeStylesheetGraphID, prepareCSSImportGraph, prepareCSSImportGraphWithResolver } from "../node-imports.js";
+import { analyzeCSSDependencies, inspectCSS } from "../node-compiler.js";
+import { hasLocalStyleDirectives } from "./directives.js";
+import { StylesheetCompositionCache } from "./composition-cache.js";
+import { mapStylesheetError } from "./source-context.js";
+import { cleanStyleRequest, collectStylesheetDependencies as collectStylesheetDependencies$1, compileRenderedStylesheet as compileRenderedStylesheet$1, compileStylesheet as compileStylesheet$1, createExtractedCSSResult, createStyleEntryEmittedGlobals, createStylesheetHostSource, isMasterCSSPackageStyleFile, isStylesheetRequest, prepareStylesheetSource, registerStylesheetSource, removeMasterStyleDirectives, resolveMasterStyleSource, transformLocalStylesheet } from "./index.js";
+import { MasterCSSError } from "@master/css-schema";
+// src/stylesheet/public.ts
+function abortableOptions(options) {
+	options.signal?.throwIfAborted();
+	const { signal: _signal, ...compileOptions } = options;
+	return compileOptions;
+}
+function freezeEmittedGlobals(emittedGlobals) {
+	return Object.freeze({
+		variables: Object.freeze({ ...emittedGlobals.variables }),
+		keyframes: Object.freeze({ ...emittedGlobals.keyframes })
+	});
+}
+function resolveStylesheetSync(id, source, options = {}) {
+	options.signal?.throwIfAborted();
+	if (!isStylesheetRequest(id)) return;
+	const normalizedId = cleanStyleRequest(id);
+	try {
+		return createStylesheetResolution(normalizedId, source, options, options.preserveImports ? resolveUnflattenedStylesheet(normalizedId, source, options.projectDir) : resolveMasterStyleSource(id, source, options.projectDir));
+	} catch (error) {
+		throw mapStylesheetError(error, normalizedId, options, source);
+	}
+}
+function createStylesheetResolution(normalizedId, source, options, resolved) {
+	const packageStyle = !normalizedId.startsWith("\0") && isMasterCSSPackageStyleFile(normalizedId, options.projectDir);
+	const entry = resolved && !resolved.local;
+	const local = resolved?.local || !resolved && hasLocalStyleDirectives(source, normalizedId);
+	const kind = packageStyle ? entry ? "master-package-entry" : "master-package" : entry ? "entry" : local ? "local" : "plain";
+	const outputSource = packageStyle ? removeMasterStyleDirectives(source).code : source;
+	const compilationSource = resolved?.source ?? outputSource;
+	const dependencies = resolved?.dependencies ?? (kind === "plain" ? [normalizedId] : collectStylesheetDependencies$1(normalizedId, source, options.projectDir));
+	return Object.freeze({
+		id: normalizedId,
+		kind,
+		source,
+		compilationSource,
+		outputSource,
+		dependencies: Object.freeze([...new Set(dependencies)])
+	});
+}
+function resolveUnflattenedStylesheet(id, source, projectDir) {
+	let graph;
+	try {
+		graph = prepareCSSImportGraph(id, source, {
+			projectDir,
+			expandPackageImports: false
+		}, analyzeCSSDependencies);
+	} catch (error) {
+		if (!inspectCSS(source).hasMasterEntry) return;
+		throw error;
+	}
+	return classifyPreparedStylesheet(graph, source);
+}
+function classifyPreparedStylesheet(graph, source) {
+	const files = Object.entries(graph.files);
+	const entry = files.some(([, text]) => inspectCSS(text).hasMasterEntry);
+	if (!entry && !files.some(([file, text]) => hasLocalStyleDirectives(text, file))) return;
+	return {
+		source,
+		dependencies: Object.keys(graph.files),
+		local: !entry
+	};
+}
+async function resolveStylesheet(id, source, options = {}) {
+	if (!options.resolveImport && !options.baseFile) return resolveStylesheetSync(id, source, options);
+	options.signal?.throwIfAborted();
+	if (!options.preserveImports) throw new TypeError("Custom import resolution requires preserveImports.");
+	if (!isStylesheetRequest(id)) return;
+	const normalizedId = cleanStyleRequest(id);
+	const graph = await prepareCSSImportGraphWithResolver(normalizedId, source, {
+		projectDir: options.projectDir,
+		expandPackageImports: false,
+		onDependency: options.onDependency,
+		signal: options.signal,
+		baseFile: options.baseFile
+	}, analyzeCSSDependencies, options.resolveImport ?? (() => void 0));
+	options.signal?.throwIfAborted();
+	return createStylesheetResolution(normalizedId, source, options, classifyPreparedStylesheet(graph, source));
+}
+/** Resolve the complete delivery graph, including package CSS, without lowering or flattening.
+* Unlike classification-only dependency collection, resolution failures propagate.
+*/
+function resolveStylesheetDependenciesSync(id, source, options = {}) {
+	options.signal?.throwIfAborted();
+	const filename = cleanStyleRequest(id);
+	let hasReferences = false;
+	const graph = prepareCSSImportGraph(filename, source, { projectDir: options.projectDir }, (text) => {
+		const analysis = analyzeCSSDependencies(text);
+		hasReferences ||= analysis.sourceWithoutReferences !== text;
+		return analysis;
+	});
+	options.signal?.throwIfAborted();
+	return Object.freeze({
+		hasReferences,
+		dependencies: Object.freeze(Object.keys(graph.files)),
+		edges: Object.freeze(graph.edges.map((edge) => Object.freeze({ ...edge })))
+	});
+}
+function collectStylesheetDependenciesSync(id, source, options = {}) {
+	options.signal?.throwIfAborted();
+	return Object.freeze(collectStylesheetDependencies$1(id, source, options.projectDir));
+}
+function collectStylesheetDependencies(id, source, options = {}) {
+	return Promise.resolve(collectStylesheetDependenciesSync(id, source, options));
+}
+function composeStylesheetHostSync(source, options = {}) {
+	options.signal?.throwIfAborted();
+	return createStylesheetHostSource(source, options);
+}
+function composeStylesheetHost(source, options = {}) {
+	return Promise.resolve(composeStylesheetHostSync(source, options));
+}
+async function compileStylesheet(id, source, options) {
+	assertValidationOptions(options);
+	const compileOptions = abortableOptions(options);
+	const result = await compileStylesheet$1(id, source, {
+		...compileOptions,
+		loadSass: compileOptions.loadSass
+	});
+	options.signal?.throwIfAborted();
+	return toMasterCSSCompileResultInternal(result, options.onDiagnostic, options.validation, stylesheetValidationSource(result.css, id, result.sourceMap));
+}
+async function compileRenderedStylesheet(id, source, options) {
+	assertValidationOptions(options);
+	const compileOptions = abortableOptions(options);
+	const result = await compileRenderedStylesheet$1(id, source, {
+		...compileOptions,
+		loadSass: compileOptions.loadSass
+	});
+	options.signal?.throwIfAborted();
+	const compilation = toMasterCSSCompileResultInternal(result, options.onDiagnostic, options.validation, stylesheetValidationSource(result.css, id, result.sourceMap));
+	return Object.freeze({
+		...compilation,
+		diagnostics: Object.freeze([...compilation.diagnostics, ...validateCompiledCSS((result.stylesheets ?? []).map((asset) => stylesheetValidationSource(asset.css, asset.id, asset.sourceMap)), options)]),
+		...result.stylesheets ? {
+			entry: result.entry,
+			stylesheets: Object.freeze(result.stylesheets.map(({ id, href, css, sourceMap }) => Object.freeze({
+				id,
+				href,
+				css,
+				sourceMap
+			}))),
+			resources: Object.freeze((result.resources ?? []).map((asset) => Object.freeze({ ...asset })))
+		} : {},
+		manifest: Object.freeze(result.manifest),
+		emittedGlobals: freezeEmittedGlobals(result.emittedGlobals)
+	});
+}
+async function collectStylesheetEmittedGlobals(entries, options) {
+	assertValidationOptions(options);
+	const compileOptions = abortableOptions(options);
+	const result = await createStyleEntryEmittedGlobals([...entries], {
+		...compileOptions,
+		loadSass: compileOptions.loadSass
+	});
+	options.signal?.throwIfAborted();
+	return Object.freeze({
+		emittedGlobals: freezeEmittedGlobals(result.emittedGlobals),
+		dependencies: Object.freeze([...result.dependencies])
+	});
+}
+async function transformStylesheet(id, source, options) {
+	assertValidationOptions(options);
+	const compileOptions = abortableOptions(options);
+	const result = await transformLocalStylesheet(id, source, {
+		...compileOptions,
+		loadSass: compileOptions.loadSass
+	});
+	options.signal?.throwIfAborted();
+	return Object.freeze({
+		code: result.code,
+		diagnostics: validateCompiledCSS([
+			stylesheetValidationSource(result.code, id, result.result?.sourceMap),
+			...result.globalStylesheet ? [stylesheetValidationSource(result.globalStylesheet.css, id, result.globalStylesheet.sourceMap)] : [],
+			...(result.stylesheets ?? []).map((asset) => stylesheetValidationSource(asset.css, asset.id, asset.sourceMap))
+		], options),
+		...result.globalStylesheet ? { globalStylesheet: Object.freeze({ ...result.globalStylesheet }) } : {},
+		...result.result?.sourceMap ? { sourceMap: result.result.sourceMap } : {},
+		dependencies: Object.freeze([...result.dependencies]),
+		transformed: result.transformed,
+		...result.stylesheets ? { stylesheets: Object.freeze(result.stylesheets.map((asset) => Object.freeze({ ...asset }))) } : {},
+		...result.resources ? { resources: Object.freeze(result.resources.map((asset) => Object.freeze({ ...asset }))) } : {},
+		...result.result ? { compilation: toMasterCSSCompileResultInternal(result.result, options.onDiagnostic, options.validation) } : {}
+	});
+}
+let bindStylesheetCollection;
+var MasterCSSStylesheetCollection = class MasterCSSStylesheetCollection {
+	#sources = /* @__PURE__ */ new Map();
+	#compositionCache = new StylesheetCompositionCache();
+	#disposed = false;
+	#scanners = /* @__PURE__ */ new Map();
+	#sourceIDs = /* @__PURE__ */ new Map();
+	constructor() {}
+	get size() {
+		this.assertActive();
+		return this.#sources.size;
+	}
+	async register(scanner, id, source, options) {
+		this.assertActive();
+		assertValidationOptions(options);
+		let compileOptions = abortableOptions(options);
+		const resolveImport = compileOptions.delivery?.resolveImport;
+		if (resolveImport) compileOptions = {
+			...compileOptions,
+			delivery: {
+				...compileOptions.delivery,
+				resolveImport: async (specifier, importer) => {
+					this.assertActive();
+					options.signal?.throwIfAborted();
+					const result = await resolveImport(specifier, importer);
+					this.assertActive();
+					options.signal?.throwIfAborted();
+					return result;
+				}
+			}
+		};
+		const previousSources = new Map(this.#sources);
+		const stagedSources = new Map(previousSources);
+		const nativeRegistrations = [];
+		const stagedScanner = Object.create(scanner);
+		stagedScanner.registerNativeClasses = (owner, names) => {
+			nativeRegistrations.push([owner, names]);
+			return false;
+		};
+		const result = await registerStylesheetSource(stagedScanner, stagedSources, id, source, {
+			...compileOptions,
+			loadSass: compileOptions.loadSass
+		});
+		options.signal?.throwIfAborted();
+		const compilation = toMasterCSSCompileResultInternal(result, options.onDiagnostic, options.validation, stylesheetValidationSource(result.css, id, result.sourceMap));
+		this.assertActive();
+		this.#compositionCache.clear();
+		for (const [key, staged] of stagedSources) {
+			if (previousSources.get(key) === staged) continue;
+			this.#sources.set(key, staged);
+			this.#scanners.set(key, scanner);
+			this.#sourceIDs.set(id, key);
+		}
+		for (const [owner, names] of nativeRegistrations) scanner.registerNativeClasses(owner, names);
+		return compilation;
+	}
+	delete(id) {
+		this.assertActive();
+		this.#compositionCache.clear();
+		const key = this.#sourceIDs.get(id) ?? normalizeStylesheetGraphID(cleanStyleRequest(id));
+		this.#sourceIDs.delete(id);
+		this.#scanners.get(key)?.removeOwner(key);
+		this.#scanners.delete(key);
+		return this.#sources.delete(key);
+	}
+	clear() {
+		this.assertActive();
+		this.#compositionCache.clear();
+		for (const [id, scanner] of this.#scanners) if (scanner.initialized) scanner.removeOwner(id);
+		this.#scanners.clear();
+		this.#sourceIDs.clear();
+		this.#sources.clear();
+	}
+	async compose(options) {
+		this.assertActive();
+		const { sourceIds, ...compileOptions } = abortableOptions(options);
+		const selected = sourceIds && new Set(sourceIds.map(cleanStyleRequest));
+		const sources = selected ? new Map([...this.#sources].filter(([id]) => selected.has(id))) : this.#sources;
+		let result = this.#compositionCache.get(options, sources);
+		const cached = Boolean(result);
+		const captured = result ? void 0 : this.#compositionCache.capture(options, sources);
+		if (!result) {
+			result = await createExtractedCSSResult({
+				...compileOptions,
+				scanner: options.scanner,
+				stylesheetSources: sources,
+				loadSass: compileOptions.loadSass
+			});
+			options.signal?.throwIfAborted();
+			this.assertActive();
+		}
+		options.signal?.throwIfAborted();
+		const diagnostics = validateCompiledCSS([{ css: result.css }, ...(result.stylesheets ?? []).map((asset) => stylesheetValidationSource(asset.css, asset.id, asset.sourceMap))], options);
+		options.signal?.throwIfAborted();
+		this.assertActive();
+		if (!cached && !diagnostics.some((diagnostic) => diagnostic.severity === "error")) this.#compositionCache.set(options, sources, result, captured);
+		return Object.freeze({
+			css: result.css,
+			diagnostics,
+			...result.stylesheets ? { stylesheets: Object.freeze(result.stylesheets.map((asset) => Object.freeze({ ...asset }))) } : {},
+			...result.resources ? { resources: Object.freeze(result.resources.map((asset) => Object.freeze({ ...asset }))) } : {},
+			...result.dependencies ? { dependencies: Object.freeze([...result.dependencies]) } : {},
+			emittedGlobals: freezeEmittedGlobals(result.emittedGlobals)
+		});
+	}
+	snapshot() {
+		this.assertActive();
+		const sources = Object.freeze([...this.#sources.entries()].map(([id, source]) => freezeSourceSnapshot(id, source)));
+		return Object.freeze({
+			size: sources.length,
+			sourceIds: Object.freeze(sources.map(({ id }) => id)),
+			dependencies: Object.freeze([...new Set(sources.flatMap(({ dependencies }) => dependencies))]),
+			sources
+		});
+	}
+	dispose() {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		this.#compositionCache.clear();
+		for (const [id, scanner] of this.#scanners) if (scanner.initialized) scanner.removeOwner(id);
+		this.#scanners.clear();
+		this.#sourceIDs.clear();
+		this.#sources.clear();
+	}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+	assertActive() {
+		if (this.#disposed) throw new MasterCSSError({
+			code: "SESSION_DISPOSED",
+			domain: "compiler",
+			message: "The Master CSS stylesheet collection has been disposed."
+		});
+	}
+	static {
+		bindStylesheetCollection = () => new MasterCSSStylesheetCollection();
+	}
+};
+function freezeSourceSnapshot(id, source) {
+	return Object.freeze({
+		id,
+		source: source.source,
+		dependencies: Object.freeze([...source.dependencies]),
+		sourceDependencies: Object.freeze([...source.sourceDependencies]),
+		isMasterCSS: source.masterCSS,
+		prunesNativeCSS: source.pruneNativeCSS
+	});
+}
+function createStylesheetCollection() {
+	return bindStylesheetCollection();
+}
+export { MasterCSSStylesheetCollection, collectStylesheetDependencies, collectStylesheetDependenciesSync, collectStylesheetEmittedGlobals, compileRenderedStylesheet, compileStylesheet, composeStylesheetHost, composeStylesheetHostSync, createStylesheetCollection, prepareStylesheetSource as prepareStylesheet, resolveStylesheet, resolveStylesheetDependenciesSync, resolveStylesheetSync, transformStylesheet };

package/dist/stylesheet/reference-files.d.ts

@@ -0,0 +1,6 @@
+import { CSSDirectiveReference } from "@master/css-schema/css-directives";
+/** File paths are host inputs, not CSS URLs. Preserve reserved filename characters. */
+declare function referenceFileInputs(files?: readonly string[]): (CSSDirectiveReference & {
+  resolvedFile: string;
+})[];
+export { referenceFileInputs };

package/dist/stylesheet/reference-files.js

@@ -0,0 +1,13 @@
+import { isAbsolute } from "node:path";
+// src/stylesheet/reference-files.ts
+/** File paths are host inputs, not CSS URLs. Preserve reserved filename characters. */
+function referenceFileInputs(files = []) {
+	return files.map((file) => {
+		if (!isAbsolute(file)) throw new TypeError("referenceFiles must contain absolute filesystem paths.");
+		return {
+			source: file,
+			resolvedFile: file
+		};
+	});
+}
+export { referenceFileInputs };

package/dist/stylesheet/reference-origins.d.ts

@@ -0,0 +1,4 @@
+import { CSSDirectiveReference } from "@master/css-schema/css-directives";
+/** Adapt Rust reference offsets through a host map; CSS parsing stays in Rust. */
+declare function resolveReferenceOrigins(source: string, references: readonly CSSDirectiveReference[], owner: string, serializedMap?: string): readonly CSSDirectiveReference[];
+export { resolveReferenceOrigins };

package/dist/stylesheet/reference-origins.js

@@ -0,0 +1,28 @@
+import { sourceMapBase, sourceMapURL } from "./source-map-url.js";
+import { SourceMap } from "node:module";
+import { fileURLToPath } from "node:url";
+import { isAbsolute } from "node:path";
+// src/stylesheet/reference-origins.ts
+/** Adapt Rust reference offsets through a host map; CSS parsing stays in Rust. */
+function resolveReferenceOrigins(source, references, owner, serializedMap) {
+	if (!serializedMap || !references.length) return references;
+	if (!isAbsolute(owner)) throw new TypeError("A stylesheet source map requires an absolute filesystem baseFile.");
+	const raw = JSON.parse(serializedMap);
+	const map = new SourceMap(raw);
+	const base = sourceMapBase(owner, raw.sourceRoot);
+	return references.map((reference) => {
+		const start = "start" in reference ? reference.start : void 0;
+		if (typeof start !== "number" || !Number.isInteger(start) || start < 0 || start >= source.length) throw new TypeError("A mapped CSS reference requires its compiler-provided source offset.");
+		const prefix = source.slice(0, start).split(/\r\n?|\n/);
+		const line = prefix.length - 1, column = prefix[line].length;
+		const origin = map.findEntry(line, column);
+		if (!("originalSource" in origin) || !origin.originalSource || origin.originalSource.includes("\0") || origin.generatedLine !== line) throw new TypeError(`Original source unavailable for mapped CSS reference: ${reference.source}`);
+		const url = sourceMapURL(origin.originalSource, base);
+		if (url.protocol !== "file:") throw new TypeError(`CSS reference source must identify a filesystem file: ${url.href}`);
+		return {
+			...reference,
+			file: fileURLToPath(url)
+		};
+	});
+}
+export { resolveReferenceOrigins };

package/dist/stylesheet/render-core.d.ts

@@ -0,0 +1,35 @@
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+import { CSSOutputMapping } from "@master/css-schema/css-directives";
+import { MasterCSSEmittedGlobals } from "@master/css-schema/emitted-globals";
+import { MasterCSSHydrationManifest } from "@master/css-schema/hydration-manifest";
+import { MasterCSSEngineSnapshot } from "@master/css";
+interface MasterCSSRenderBindingResult {
+  readonly outputMappings: CSSOutputMapping[];
+  readonly classes: string[];
+  readonly snapshot: MasterCSSEngineSnapshot;
+  readonly hydrationManifest: MasterCSSHydrationManifest;
+}
+interface RenderCompiledManifestCSSOptions {
+  manifest: MasterCSSManifest;
+  classNames?: Iterable<string>;
+  nativeCSS?: string | string[];
+  includeGeneratedCSS?: boolean;
+  emittedGlobals?: MasterCSSEmittedGlobals;
+}
+interface RenderCompiledManifestCSSResult {
+  css: string;
+  nativeCSS: string;
+  generatedCSS: string;
+  outputMappings: CSSOutputMapping[];
+  emittedGlobals: Required<MasterCSSEmittedGlobals>;
+}
+interface StylesheetRenderSession {
+  ensureClasses(classNames: string[]): void;
+  ensureStylesheetResources(nativeCSS: string): void;
+  emittedGlobals(): Required<MasterCSSEmittedGlobals>;
+  snapshot(): MasterCSSRenderBindingResult;
+  dispose(): void;
+}
+declare function normalizeNativeCSS(nativeCSS: string | string[] | undefined): string[];
+declare function renderCompiledManifestCSSWithSession(options: RenderCompiledManifestCSSOptions, session: StylesheetRenderSession): RenderCompiledManifestCSSResult;
+export { RenderCompiledManifestCSSOptions, RenderCompiledManifestCSSResult, StylesheetRenderSession, normalizeNativeCSS, renderCompiledManifestCSSWithSession };

package/dist/stylesheet/render-core.js

@@ -0,0 +1,28 @@
+// src/stylesheet/render-core.ts
+function normalizeNativeCSS(nativeCSS) {
+	return (Array.isArray(nativeCSS) ? nativeCSS : [nativeCSS]).filter((source) => typeof source === "string").map((source) => source.replace(/\r\n?/g, "\n"));
+}
+function renderCompiledManifestCSSWithSession(options, session) {
+	const nativeCSS = normalizeNativeCSS(options.nativeCSS);
+	const nativeCSSText = nativeCSS.filter(Boolean).join("\n\n");
+	if (options.includeGeneratedCSS !== false) {
+		const classNames = [...options.classNames || []];
+		session.ensureClasses(classNames);
+	}
+	for (const css of nativeCSS) session.ensureStylesheetResources(css);
+	const rendered = session.snapshot();
+	const generatedCSS = rendered.snapshot.text;
+	const offset = nativeCSSText ? nativeCSSText.length + 2 : 0;
+	return {
+		css: [nativeCSSText, generatedCSS].filter(Boolean).join("\n\n"),
+		nativeCSS: nativeCSSText,
+		generatedCSS,
+		outputMappings: rendered.outputMappings.map((mapping) => ({
+			...mapping,
+			generatedStart: mapping.generatedStart + offset,
+			generatedEnd: mapping.generatedEnd === void 0 ? void 0 : mapping.generatedEnd + offset
+		})),
+		emittedGlobals: session.emittedGlobals()
+	};
+}
+export { normalizeNativeCSS, renderCompiledManifestCSSWithSession };

package/dist/stylesheet/render-delivery.d.ts

@@ -0,0 +1,4 @@
+import { CompileRenderedStylesheetOptions, CompileRenderedStylesheetResult } from "./types.js";
+/** Render generated globals once while keeping native stylesheet boundaries. */
+declare function compileRenderedDelivery(id: string, source: string, options: CompileRenderedStylesheetOptions): Promise<CompileRenderedStylesheetResult>;
+export { compileRenderedDelivery };

package/dist/stylesheet/render-delivery.js

@@ -0,0 +1,61 @@
+import { renderCompiledManifestCSS } from "./render.js";
+import { compileDeliveredSource } from "./delivery.js";
+import { mapStylesheetError } from "./source-context.js";
+// src/stylesheet/render-delivery.ts
+/** Render generated globals once while keeping native stylesheet boundaries. */
+async function compileRenderedDelivery(id, source, options) {
+	try {
+		const result = await compileDeliveredSource(id, source, {
+			...options,
+			transformNativeStylesheets: true
+		}, options.classes);
+		const entry = result.stylesheets.find((asset) => asset.id === result.entry);
+		const generated = renderCompiledManifestCSS({
+			manifest: result.resolutionManifest,
+			nativeCSS: result.stylesheets.map((asset) => asset.css),
+			classNames: options.classes,
+			emittedGlobals: options.emittedGlobals
+		});
+		const nativeCSS = entry.css;
+		const css = [nativeCSS, generated.generatedCSS].filter(Boolean).join("\n\n");
+		const shift = (nativeCSS ? nativeCSS.length + 2 : 0) - (generated.nativeCSS ? generated.nativeCSS.length + 2 : 0);
+		const resourceMappings = generated.outputMappings.map((mapping) => ({
+			...mapping,
+			generatedStart: mapping.generatedStart + shift,
+			generatedEnd: mapping.generatedEnd === void 0 ? void 0 : mapping.generatedEnd + shift
+		}));
+		const sourceMap = result.outputMap(css, [...entry.outputMappings, ...resourceMappings]);
+		const renderedCSS = {
+			...generated,
+			css,
+			nativeCSS,
+			outputMappings: resourceMappings
+		};
+		return {
+			...result.directives,
+			entry: result.entry,
+			stylesheets: result.stylesheets.map((asset) => asset.id === entry.id ? {
+				...asset,
+				css,
+				sourceMap
+			} : {
+				...asset,
+				sourceMap: result.outputMap(asset.css, asset.outputMappings, asset.id)
+			}),
+			resources: result.resources,
+			sourceMap,
+			css,
+			nativeCSS,
+			generatedCSS: generated.generatedCSS,
+			emittedGlobals: generated.emittedGlobals,
+			manifest: result.manifest,
+			renderedCSS
+		};
+	} catch (error) {
+		throw mapStylesheetError(error, id, {
+			baseFile: options.delivery?.baseFile ?? options.baseFile,
+			sourceMap: options.delivery?.sourceMap ?? options.sourceMap
+		}, source);
+	}
+}
+export { compileRenderedDelivery };

package/dist/stylesheet/render.d.ts

@@ -0,0 +1,5 @@
+import { RenderCompiledManifestCSSOptions, RenderCompiledManifestCSSOptions as RenderCompiledManifestCSSOptions$1, RenderCompiledManifestCSSResult, RenderCompiledManifestCSSResult as RenderCompiledManifestCSSResult$1 } from "./render-core.js";
+/** Compare canonical Rust reference counts; referenced theme variables and keyframes are managed. */
+declare function hasStylesheetResourceReferences(manifest: RenderCompiledManifestCSSOptions$1['manifest'], source: string): boolean;
+declare function renderCompiledManifestCSS(options: RenderCompiledManifestCSSOptions$1): RenderCompiledManifestCSSResult$1;
+export { type RenderCompiledManifestCSSOptions, type RenderCompiledManifestCSSResult, hasStylesheetResourceReferences, renderCompiledManifestCSS };

package/dist/stylesheet/render.js

@@ -0,0 +1,31 @@
+import { renderCompiledManifestCSSWithSession } from "./render-core.js";
+import { createRenderBindingSessionSync } from "@master/css-binding/engine/node";
+// src/stylesheet/render.ts
+/** Compare canonical Rust reference counts; referenced theme variables and keyframes are managed. */
+function hasStylesheetResourceReferences(manifest, source) {
+	const session = createRenderBindingSessionSync({ manifest });
+	try {
+		const before = session.snapshot().snapshot.resources;
+		session.ensureStylesheetResources(source);
+		const after = session.snapshot().snapshot.resources;
+		return after.variables.some((value) => value.refCount > (before.variables.find((item) => item.name === value.name)?.refCount ?? 0)) || after.keyframes.some((value) => value.refCount > (before.keyframes.find((item) => item.id === value.id)?.refCount ?? 0));
+	} finally {
+		session.dispose();
+	}
+}
+function renderCompiledManifestCSS(options) {
+	const nativeSession = createRenderBindingSessionSync(options);
+	const session = {
+		ensureClasses: (classNames) => nativeSession.ensureClassRules(classNames),
+		ensureStylesheetResources: (nativeCSS) => nativeSession.ensureStylesheetResources(nativeCSS),
+		emittedGlobals: () => nativeSession.emittedGlobals(),
+		snapshot: () => nativeSession.snapshot(),
+		dispose: () => nativeSession.dispose()
+	};
+	try {
+		return renderCompiledManifestCSSWithSession(options, session);
+	} finally {
+		session.dispose();
+	}
+}
+export { hasStylesheetResourceReferences, renderCompiledManifestCSS };

package/dist/stylesheet/source-context.d.ts

@@ -0,0 +1,8 @@
+interface StylesheetSourceContext {
+  readonly baseFile?: string;
+  readonly sourceMap?: string;
+  readonly onDependency?: (file: string) => void;
+}
+/** Translate host-prepared locations; parsing and diagnostic policy stay in Rust. */
+declare function mapStylesheetError(error: unknown, file: string, options: StylesheetSourceContext, preparedSource?: string): unknown;
+export { StylesheetSourceContext, mapStylesheetError };

package/dist/stylesheet/source-context.js

@@ -0,0 +1,71 @@
+import { sourceMapBase, sourceMapURL } from "./source-map-url.js";
+import { SourceMap } from "node:module";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { MasterCSSError } from "@master/css-schema";
+// src/stylesheet/source-context.ts
+const mappedErrors = /* @__PURE__ */ new WeakSet();
+/** Translate host-prepared locations; parsing and diagnostic policy stay in Rust. */
+function mapStylesheetError(error, file, options, preparedSource) {
+	if (!(error instanceof MasterCSSError) || mappedErrors.has(error) || !options.sourceMap) return error;
+	try {
+		const payload = JSON.parse(options.sourceMap);
+		const map = new SourceMap(payload);
+		const base = sourceMapBase(options.baseFile ?? file, payload.sourceRoot);
+		const mapped = new MasterCSSError({
+			...error.payload,
+			diagnostics: error.diagnostics.map((diagnostic) => {
+				if (diagnostic.source !== file || !diagnostic.range) return diagnostic;
+				const { start, end } = diagnostic.range;
+				const point = map.findEntry(start.line, start.character);
+				if (!("originalSource" in point) || !point.originalSource || point.generatedLine !== start.line) return {
+					...diagnostic,
+					source: pathToFileURL(file).href + "?master-css-preprocessed",
+					notes: [...diagnostic.notes ?? [], "Original source location is unavailable; this range refers to preprocessed CSS."]
+				};
+				const url = sourceMapURL(point.originalSource, base);
+				const source = url.protocol === "file:" && !url.search && !url.hash ? fileURLToPath(url) : url.href;
+				const position = {
+					line: point.originalLine,
+					character: point.originalColumn
+				};
+				const generatedLine = preparedSource?.split(/\r\n?|\n/)[start.line];
+				const originalLine = payload.sourcesContent?.[payload.sources.indexOf(point.originalSource)]?.split(/\r\n?|\n/)[point.originalLine];
+				const offset = start.character - point.generatedColumn, length = end.character - point.generatedColumn;
+				if (start.line === end.line && offset >= 0 && length >= offset && generatedLine !== void 0 && originalLine !== void 0 && originalLine.slice(point.originalColumn, point.originalColumn + length) === generatedLine.slice(point.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."]
+				};
+			})
+		}, { cause: error });
+		mappedErrors.add(mapped);
+		return mapped;
+	} catch {
+		return new MasterCSSError({
+			...error.payload,
+			diagnostics: error.diagnostics.map((diagnostic) => ({
+				...diagnostic,
+				notes: [...diagnostic.notes ?? [], "Source mapping failed; the original compiler diagnostic is retained."]
+			}))
+		}, { cause: error });
+	}
+}
+export { mapStylesheetError };

package/dist/stylesheet/source-map-url.d.ts

@@ -0,0 +1,4 @@
+/** Host maps may contain native filesystem paths as well as URL references. */
+declare function sourceMapURL(source: string, base: URL): URL;
+declare function sourceMapBase(owner: string, sourceRoot?: string): URL;
+export { sourceMapBase, sourceMapURL };