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

package/dist/project/manifest.js

@@ -0,0 +1,49 @@
+import { findCSSManifestEntryFilesSync, isCSSManifestRequest } from "./entries.js";
+import { loadBindingProjectManifest } from "./binding-project.js";
+import { resolve } from "node:path";
+import { MASTER_CSS_DIAGNOSTIC_VERSION } from "@master/css-schema";
+// src/project/manifest.ts
+function throwIfAborted(signal) {
+	signal?.throwIfAborted();
+}
+function assertStylesheetEntries(entries) {
+	for (const entry of entries ?? []) if (!isCSSManifestRequest(entry)) throw new TypeError("Master CSS project entries must be CSS files.");
+}
+function warningDiagnostic(message) {
+	return Object.freeze({
+		version: MASTER_CSS_DIAGNOSTIC_VERSION,
+		code: "PROJECT_WARNING",
+		domain: "project",
+		severity: "warning",
+		message
+	});
+}
+function immutableProjectResult(result, onDiagnostic) {
+	const diagnostics = Object.freeze(result.warnings.map(warningDiagnostic));
+	for (const diagnostic of diagnostics) onDiagnostic?.(diagnostic);
+	return Object.freeze({
+		manifest: Object.freeze(result.manifest),
+		nativeClassNames: Object.freeze([...result.nativeClassNames]),
+		entries: Object.freeze([...result.entries]),
+		dependencies: Object.freeze([...result.dependencies]),
+		diagnostics,
+		...result.sourceGraph ? { sourceGraph: result.sourceGraph } : {}
+	});
+}
+async function discoverManifestEntries(options = {}) {
+	throwIfAborted(options.signal);
+	const entries = findCSSManifestEntryFilesSync(resolve(options.root ?? process.cwd()));
+	throwIfAborted(options.signal);
+	return Object.freeze(entries);
+}
+async function loadProjectManifest(options) {
+	throwIfAborted(options.signal);
+	assertStylesheetEntries(options.entries);
+	const result = loadBindingProjectManifest(resolve(options.root ?? process.cwd()), options.baseManifest, options.entries, options.onDependency, options.includeSourceGraph);
+	throwIfAborted(options.signal);
+	return immutableProjectResult(result, options.onDiagnostic);
+}
+async function compileProjectManifest(options) {
+	return loadProjectManifest(options);
+}
+export { compileProjectManifest, discoverManifestEntries, loadProjectManifest };

package/dist/project/options.d.ts

@@ -0,0 +1,43 @@
+import { MasterCSSDiagnostic } from "@master/css-schema";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+interface MasterCSSProjectDiscoveryOptions {
+  readonly root?: string;
+  readonly signal?: AbortSignal;
+}
+interface MasterCSSProjectLoadOptions extends MasterCSSProjectDiscoveryOptions {
+  readonly baseManifest: MasterCSSManifest;
+  readonly entries?: readonly string[];
+  readonly onDiagnostic?: (diagnostic: MasterCSSDiagnostic) => void;
+  /** Reports each project CSS file before reading it, including missing imports/references. */
+  readonly onDependency?: (file: string) => void;
+  /** Include authored source and import/reference edges for build-time inspection only. */
+  readonly includeSourceGraph?: boolean;
+}
+interface MasterCSSProjectSourceGraph {
+  readonly version: 1;
+  readonly files: readonly Readonly<{
+    source: string;
+    content: string;
+    /** Both authored and real paths are inside the project root, outside node_modules. */
+    projectOwned: boolean;
+  }>[];
+  /** Definition reachability, including @reference; these edges do not imply CSS delivery. */
+  readonly edges: readonly Readonly<{
+    from: string;
+    specifier: string;
+    resolved: string;
+  }>[];
+}
+interface MasterCSSProjectCompileOptions extends MasterCSSProjectLoadOptions {
+  readonly entries: readonly string[];
+}
+interface MasterCSSProjectResult {
+  /** Decoded native class registrations from the resolved CSS graph. */
+  readonly nativeClassNames: readonly string[];
+  readonly manifest: MasterCSSManifest;
+  readonly entries: readonly string[];
+  readonly dependencies: readonly string[];
+  readonly diagnostics: readonly MasterCSSDiagnostic[];
+  readonly sourceGraph?: MasterCSSProjectSourceGraph;
+}
+export { MasterCSSProjectCompileOptions, MasterCSSProjectDiscoveryOptions, MasterCSSProjectLoadOptions, MasterCSSProjectResult, MasterCSSProjectSourceGraph };

package/dist/project/options.js

@@ -0,0 +1 @@
+export {};

package/dist/pure-css-cache.d.ts

@@ -0,0 +1,11 @@
+/** Pure binding values only; filesystem discovery and observation stay outside. */
+declare class PureCSSCache {
+  private readonly budget;
+  private readonly capacity;
+  private readonly values;
+  private bytes;
+  constructor(budget?: number, capacity?: number);
+  run<T>(operation: string, input: unknown, compute: () => T): T;
+}
+declare const pureCSSCache: PureCSSCache;
+export { PureCSSCache, pureCSSCache };

package/dist/pure-css-cache.js

@@ -0,0 +1,39 @@
+import { createHash } from "node:crypto";
+// src/pure-css-cache.ts
+/** Pure binding values only; filesystem discovery and observation stay outside. */
+var PureCSSCache = class {
+	budget;
+	capacity;
+	values = /* @__PURE__ */ new Map();
+	bytes = 0;
+	constructor(budget = 4194304, capacity = 128) {
+		this.budget = budget;
+		this.capacity = capacity;
+	}
+	run(operation, input, compute) {
+		const key = operation + ":" + createHash("sha256").update(JSON.stringify(input)).digest("hex");
+		const cached = this.values.get(key);
+		if (cached) {
+			this.values.delete(key);
+			this.values.set(key, cached);
+			return structuredClone(cached.value);
+		}
+		const value = compute();
+		const bytes = JSON.stringify(value).length * 2;
+		if (bytes <= this.budget && this.capacity > 0) {
+			while (this.bytes + bytes > this.budget || this.values.size >= this.capacity) {
+				const oldest = this.values.keys().next().value;
+				this.bytes -= this.values.get(oldest).bytes;
+				this.values.delete(oldest);
+			}
+			this.values.set(key, {
+				value: structuredClone(value),
+				bytes
+			});
+			this.bytes += bytes;
+		}
+		return value;
+	}
+};
+const pureCSSCache = new PureCSSCache();
+export { PureCSSCache, pureCSSCache };

package/dist/session.d.ts

@@ -0,0 +1,19 @@
+import { MasterCSSBindingLoadOptions, MasterCSSCompilerBindingSession } from "@master/css-binding/compiler";
+import { CompileCSSOptions, CompileCSSResult } from "./contracts.js";
+interface BindingCompilerSession {
+  readonly binding: MasterCSSCompilerBindingSession['binding'];
+  compareProjectSnapshots: MasterCSSCompilerBindingSession['compareProjectSnapshots'];
+  inspectCSS: MasterCSSCompilerBindingSession['inspectCSS'];
+  compileCSS(source: string, options?: CompileCSSOptions): CompileCSSResult;
+  lowerCSSDirectives: MasterCSSCompilerBindingSession['lowerCSSDirectives'];
+  prepareCSSStylesheetBundle: MasterCSSCompilerBindingSession['prepareCSSStylesheetBundle'];
+  renderCSSStylesheetBundle: MasterCSSCompilerBindingSession['renderCSSStylesheetBundle'];
+  compileCSSStylesheetGraph(request: Parameters<MasterCSSCompilerBindingSession['compileCSSStylesheetGraph']>[0]): Omit<ReturnType<MasterCSSCompilerBindingSession['compileCSSStylesheetGraph']>, 'directives'> & {
+    directives: CompileCSSResult;
+  };
+  dispose(): void;
+}
+declare function createCompilerBindingSession(options?: MasterCSSBindingLoadOptions): Promise<BindingCompilerSession>;
+/** @internal */
+declare function bindCompilerBindingSessionInternal(session: MasterCSSCompilerBindingSession): BindingCompilerSession;
+export { BindingCompilerSession, bindCompilerBindingSessionInternal, createCompilerBindingSession };

package/dist/session.js

@@ -0,0 +1,46 @@
+import { assertValidationOptions } from "./value-validation.js";
+import { createCompilerBindingSession as createCompilerBindingSession$1 } from "@master/css-binding/compiler";
+// src/session.ts
+function reviveCompileResult(result) {
+	result.extractionPolicy.blocklist = result.extractionPolicy.blocklist.map((entry) => {
+		if (entry && typeof entry === "object" && "source" in entry && typeof entry.source === "string") return new RegExp(entry.source, "flags" in entry && typeof entry.flags === "string" ? entry.flags : "");
+		return entry;
+	});
+	return result;
+}
+function bindCompilerSession(session) {
+	return {
+		binding: session.binding,
+		compareProjectSnapshots: (request) => session.compareProjectSnapshots(request),
+		inspectCSS: (source) => session.inspectCSS(source),
+		compileCSS(source, options = {}) {
+			assertValidationOptions(options);
+			return reviveCompileResult(session.compileCSSDirectives(source, {
+				from: options.from || "master.css",
+				preserveNativeCSS: options.preserveNativeCSS !== false,
+				pruneNativeCSS: options.pruneNativeCSS === true,
+				...options.preserveNativeSource === void 0 ? {} : { preserveNativeSource: options.preserveNativeSource },
+				...options.classes ? { classes: options.classes } : {}
+			}));
+		},
+		lowerCSSDirectives: (request, options, sourceText) => session.lowerCSSDirectives(request, options, sourceText),
+		prepareCSSStylesheetBundle: (request) => session.prepareCSSStylesheetBundle(request),
+		renderCSSStylesheetBundle: (request) => session.renderCSSStylesheetBundle(request),
+		compileCSSStylesheetGraph(request) {
+			const result = session.compileCSSStylesheetGraph(request);
+			return {
+				...result,
+				directives: reviveCompileResult(result.directives)
+			};
+		},
+		dispose: () => session.dispose()
+	};
+}
+async function createCompilerBindingSession(options = {}) {
+	return bindCompilerSession(await createCompilerBindingSession$1(options));
+}
+/** @internal */
+function bindCompilerBindingSessionInternal(session) {
+	return bindCompilerSession(session);
+}
+export { bindCompilerBindingSessionInternal, createCompilerBindingSession };

package/dist/stylesheet/browser.d.ts

@@ -0,0 +1,32 @@
+import { MasterCSSDiagnostic } from "@master/css-schema";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+import { MasterCSSCompileManifestResult } from "../index.js";
+import { MasterCSSEmittedGlobals } from "@master/css-schema/emitted-globals";
+interface MasterCSSBrowserStylesheetCompileOptions {
+  readonly baseManifest: MasterCSSManifest;
+  readonly classNames?: readonly string[];
+  readonly from?: string;
+  readonly preserveNativeCSS?: boolean;
+  readonly pruneNativeCSS?: boolean;
+  readonly validation?: 'report' | 'error';
+  /** Keep untouched native source for host transforms; incompatible with class pruning. */
+  readonly preserveNativeSource?: boolean;
+  /** Globals already present outside this render; emit only additional resources. */
+  readonly emittedGlobals?: MasterCSSEmittedGlobals;
+  readonly binding?: Readonly<{
+    input?: RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+  }>;
+  readonly signal?: AbortSignal;
+  readonly onDiagnostic?: (diagnostic: import('@master/css-schema').MasterCSSDiagnostic) => void;
+}
+interface MasterCSSBrowserStylesheetCompileResult {
+  readonly css: string;
+  readonly nativeCSS: string;
+  readonly generatedCSS: string;
+  readonly manifest: MasterCSSManifest;
+  readonly diagnostics: readonly MasterCSSDiagnostic[];
+  readonly emittedGlobals: Required<MasterCSSEmittedGlobals>;
+  readonly result: MasterCSSCompileManifestResult;
+}
+declare function compileBrowserStylesheet(source: string, options: MasterCSSBrowserStylesheetCompileOptions): Promise<MasterCSSBrowserStylesheetCompileResult>;
+export { MasterCSSBrowserStylesheetCompileOptions, MasterCSSBrowserStylesheetCompileResult, type MasterCSSCompileManifestResult, compileBrowserStylesheet };

package/dist/stylesheet/browser.js

@@ -0,0 +1,71 @@
+import { assertValidationOptions, validateCompiledCSS } from "../value-validation.js";
+import { renderCompiledManifestCSSWithSession } from "./render-core.js";
+import { createCompiler } from "../index.js";
+import { createCompilerRenderBindingSession } from "@master/css-binding/compiler";
+// src/stylesheet/browser.ts
+async function compileBrowserStylesheet(source, options) {
+	assertValidationOptions(options);
+	const { baseManifest, classNames, from, preserveNativeCSS, preserveNativeSource, emittedGlobals, binding, signal, onDiagnostic } = options;
+	signal?.throwIfAborted();
+	const compiler = await createCompiler({
+		binding: "wasm",
+		...binding ? { wasm: binding } : {}
+	});
+	let result;
+	try {
+		result = compiler.compileManifest(source, {
+			baseManifest,
+			pruneNativeCSS: options.pruneNativeCSS,
+			classes: classNames,
+			validation: options.validation,
+			...from ? { from } : {},
+			...preserveNativeCSS === void 0 ? {} : { preserveNativeCSS },
+			...preserveNativeSource === void 0 ? {} : { preserveNativeSource },
+			...onDiagnostic ? { onDiagnostic } : {}
+		});
+	} finally {
+		compiler.dispose();
+	}
+	signal?.throwIfAborted();
+	const bindingSession = await createCompilerRenderBindingSession({
+		manifest: result.manifest,
+		emittedGlobals
+	}, {
+		binding: "wasm",
+		wasm: binding
+	});
+	const renderSession = {
+		ensureClasses: (classNames) => bindingSession.ensureClasses(classNames),
+		ensureStylesheetResources: (nativeCSS) => bindingSession.ensureStylesheetResources(nativeCSS),
+		emittedGlobals: () => bindingSession.emittedGlobals(),
+		snapshot: () => bindingSession.snapshot(),
+		dispose: () => bindingSession.dispose()
+	};
+	let renderedCSS;
+	try {
+		renderedCSS = renderCompiledManifestCSSWithSession({
+			manifest: result.manifest,
+			nativeCSS: result.css || "",
+			classNames
+		}, renderSession);
+	} finally {
+		renderSession.dispose();
+	}
+	signal?.throwIfAborted();
+	return Object.freeze({
+		css: renderedCSS.css,
+		nativeCSS: renderedCSS.nativeCSS,
+		generatedCSS: renderedCSS.generatedCSS,
+		manifest: result.manifest,
+		diagnostics: Object.freeze([...result.diagnostics, ...validateCompiledCSS([{
+			css: renderedCSS.generatedCSS,
+			source: from
+		}], options)]),
+		emittedGlobals: Object.freeze({
+			variables: Object.freeze({ ...renderedCSS.emittedGlobals.variables }),
+			keyframes: Object.freeze({ ...renderedCSS.emittedGlobals.keyframes })
+		}),
+		result
+	});
+}
+export { compileBrowserStylesheet };

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

@@ -0,0 +1,11 @@
+import { CSSOutputMapping } from "@master/css-schema/css-directives";
+import { CompileCSSManifestResult, CompileCSSResult } from "../node-compiler.js";
+import { CompileStylesheetOptions } from "./types.js";
+/** Preserve input origins while joining parsed and lowered compiler output. */
+declare function compilePreparedStylesheet(filename: string, css: string, options: CompileStylesheetOptions, resolveImports: boolean): {
+  compileOptions: Omit<CompileStylesheetOptions, 'projectDir' | 'loadSass' | 'baseManifest' | 'sourceMap' | 'baseFile' | 'onDependency' | 'references' | 'referenceFiles'>;
+  finalizedResult: CompileCSSManifestResult;
+  result: CompileCSSResult;
+  outputMap: (code: string, resources?: CSSOutputMapping[]) => string;
+};
+export { compilePreparedStylesheet };

package/dist/stylesheet/compiled-source.js

@@ -0,0 +1,96 @@
+import { stylesheetInputMap, stylesheetOutputMap, stylesheetOutputMappings } from "./output-map.js";
+import { prepareCSSImportGraph } from "../node-imports.js";
+import { analyzeCSSDependencies, compileCSS, compileCSSManifestGraph, createManifestFromCSSResult } from "../node-compiler.js";
+import { resolveReferenceOrigins } from "./reference-origins.js";
+import { referenceFileInputs } from "./reference-files.js";
+import { mapStylesheetError } from "./source-context.js";
+import { resolve } from "node:path";
+import { MasterCSSError } from "@master/css-schema";
+// src/stylesheet/compiled-source.ts
+/** Preserve input origins while joining parsed and lowered compiler output. */
+function compilePreparedStylesheet(filename, css, options, resolveImports) {
+	const { projectDir, loadSass: _loadSass, baseManifest, sourceMap, baseFile, onDependency, referenceFiles, references: suppliedReferences, ...compileOptions } = options;
+	const hostReferences = referenceFileInputs(referenceFiles);
+	onDependency?.(baseFile ?? filename);
+	let compilationFile = filename;
+	const compilationSource = css;
+	let errorContext;
+	try {
+		if (resolveImports) {
+			const root = resolve(projectDir ?? "", filename);
+			compilationFile = root;
+			const graph = prepareCSSImportGraph(root, css, {
+				projectDir,
+				onDependency
+			}, analyzeCSSDependencies);
+			const context = {
+				file: root,
+				source: css,
+				compilationFile: root,
+				sourceMap,
+				graph: { sources: graph.files }
+			};
+			errorContext = context;
+			const finalizedResult = compileCSSManifestGraph(graph, {
+				...compileOptions,
+				baseManifest,
+				from: root,
+				root: projectDir,
+				onDependency,
+				referenceStack: [root],
+				resolveReferenceResources: Boolean(referenceFiles?.length),
+				mapReferences: (file, text, references) => file === root ? [...hostReferences, ...suppliedReferences ?? resolveReferenceOrigins(text, references, baseFile ?? root, sourceMap)] : references
+			});
+			if (finalizedResult.stylesheets.length > 1) throw new MasterCSSError({
+				code: "CSS_IMPORT_ERROR",
+				domain: "compiler",
+				message: "This stylesheet retains import or resource boundaries and requires stylesheet asset delivery."
+			});
+			const outputMap = (code, resources = []) => stylesheetOutputMap(code, [...finalizedResult.outputMappings, ...resources], context, finalizedResult.css.length);
+			return {
+				compileOptions,
+				finalizedResult,
+				result: finalizedResult.directives,
+				outputMap
+			};
+		}
+		const context = {
+			file: baseFile ?? filename,
+			source: css,
+			compilationFile,
+			sourceMap
+		};
+		errorContext = context;
+		const result = compileCSS(compilationSource, {
+			...compileOptions,
+			from: compilationFile
+		});
+		if (suppliedReferences) result.references = suppliedReferences;
+		else if (sourceMap && result.references) result.references = [...resolveReferenceOrigins(css, result.references, baseFile ?? filename, sourceMap)];
+		if (hostReferences.length) result.references = [...hostReferences, ...result.references ?? []];
+		const finalizedResult = createManifestFromCSSResult(result, {
+			...compileOptions,
+			onDependency,
+			baseManifest,
+			root: projectDir,
+			from: filename,
+			sourceText: compilationSource,
+			resolveReferenceResources: Boolean(referenceFiles?.length)
+		});
+		const mappings = finalizedResult.outputMappings ?? stylesheetOutputMappings(result.nativeCSS, result.nativeMappings, finalizedResult.generatedMappings);
+		const outputMap = (code, resources = []) => stylesheetOutputMap(code, [...mappings, ...resources], context, finalizedResult.css.length);
+		return {
+			compileOptions,
+			finalizedResult,
+			result,
+			outputMap
+		};
+	} catch (error) {
+		const inputMap = errorContext?.graph?.sourceMappings ? stylesheetInputMap(compilationSource, errorContext) : sourceMap;
+		throw mapStylesheetError(error, compilationFile, {
+			...options,
+			sourceMap: inputMap
+		}, compilationSource);
+	}
+}
+export { compilePreparedStylesheet };

package/dist/stylesheet/composition-cache.d.ts

@@ -0,0 +1,18 @@
+import { MasterCSSStylesheetCompositionOptions } from "./public.js";
+import { CreateExtractedCSSResult, StylesheetSources } from "./types.js";
+/** One result, scoped to its collection. Class-sensitive compositions always run. */
+declare class StylesheetCompositionCache {
+  generation: number;
+  private entry?;
+  private readonly functions;
+  private nextFunction;
+  clear(): void;
+  private fingerprint;
+  get(options: MasterCSSStylesheetCompositionOptions, sources: StylesheetSources): CreateExtractedCSSResult | undefined;
+  capture(options: MasterCSSStylesheetCompositionOptions, sources: StylesheetSources): {
+    generation: number;
+    versions: Map<string, string>;
+  } | undefined;
+  set(options: MasterCSSStylesheetCompositionOptions, sources: StylesheetSources, result: CreateExtractedCSSResult, captured: ReturnType<StylesheetCompositionCache['capture']>): void;
+}
+export { StylesheetCompositionCache };

package/dist/stylesheet/composition-cache.js

@@ -0,0 +1,79 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+// src/stylesheet/composition-cache.ts
+function fileVersion(file) {
+	try {
+		return createHash("sha256").update(readFileSync(file)).digest("hex");
+	} catch {
+		return "missing";
+	}
+}
+/** One result, scoped to its collection. Class-sensitive compositions always run. */
+var StylesheetCompositionCache = class {
+	generation = 0;
+	entry;
+	functions = /* @__PURE__ */ new WeakMap();
+	nextFunction = 0;
+	clear() {
+		this.generation++;
+		this.entry = void 0;
+	}
+	fingerprint(options, sources, dependencies, version = fileVersion) {
+		if (options.includeGeneratedCSS !== false || options.pruneNativeCSS || options.onDiagnostic || options.loadSass || options.delivery?.resolveImport) return;
+		const hash = createHash("sha256");
+		hash.update(JSON.stringify(options.projectDir ?? options.scanner.cwd));
+		for (const [id, source] of sources) {
+			if (!source.graph || !source.classIndependent) return;
+			hash.update(JSON.stringify([id, source]));
+		}
+		const { scanner: _scanner, signal: _signal, onDependency: _dependency, onDiagnostic: _diagnostic, ...input } = options;
+		hash.update(JSON.stringify(input, (_key, value) => {
+			if (typeof value !== "function") return value;
+			let id = this.functions.get(value);
+			if (id === void 0) {
+				id = ++this.nextFunction;
+				this.functions.set(value, id);
+			}
+			return id;
+		}));
+		for (const file of new Set([...sources.values()].flatMap((source) => source.dependencies).concat([...dependencies]))) {
+			const content = version(file);
+			if (content === void 0) return;
+			hash.update(JSON.stringify([file, content]));
+		}
+		return hash.digest("hex");
+	}
+	get(options, sources) {
+		if (!this.entry || this.fingerprint(options, sources, this.entry.dependencies) !== this.entry.key) return;
+		const result = structuredClone(this.entry.result);
+		for (const dependency of this.entry.dependencies) {
+			options.onDependency?.(dependency);
+			if (options.delivery?.onDependency !== options.onDependency) options.delivery?.onDependency?.(dependency);
+		}
+		return result;
+	}
+	capture(options, sources) {
+		const versions = /* @__PURE__ */ new Map();
+		const dependencies = [...this.entry?.dependencies ?? [], ...options.referenceFiles ?? []];
+		return this.fingerprint(options, sources, dependencies, (file) => {
+			const version = fileVersion(file);
+			versions.set(file, version);
+			return version;
+		}) ? {
+			generation: this.generation,
+			versions
+		} : void 0;
+	}
+	set(options, sources, result, captured) {
+		if (!captured || captured.generation !== this.generation) return;
+		const dependencies = [...new Set([...sources.values()].flatMap((source) => source.dependencies).concat([...result.dependencies ?? []]))];
+		const key = this.fingerprint(options, sources, dependencies);
+		const before = this.fingerprint(options, sources, dependencies, (file) => captured.versions.get(file));
+		this.entry = key && key === before && JSON.stringify(result).length * 2 <= 4194304 ? {
+			key,
+			dependencies,
+			result: structuredClone(result)
+		} : void 0;
+	}
+};
+export { StylesheetCompositionCache };

package/dist/stylesheet/delivery.d.ts

@@ -0,0 +1,103 @@
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+import { CompileCSSResult } from "../contracts.js";
+import { CSSOutputMapping } from "@master/css-schema/css-directives";
+import { CSSImportFileResolver } from "../node-imports.js";
+import { CompileStylesheetOptions, CreateExtractedCSSResult, ScannerState, StylesheetSource, StylesheetSources, TransformLocalStylesheetOptions } from "./types.js";
+interface StylesheetDeliveryOptions {
+  /** Filesystem owner of a supplied virtual entry source. */
+  readonly baseFile?: string;
+  /** Serialized source map v3 for original reference origins in the supplied entry. */
+  readonly sourceMap?: string;
+  /** Final URL of the emitted entry stylesheet. */
+  readonly entryURL: string;
+  /** Reports attempted filesystem dependencies, including files that are missing. */
+  readonly onDependency?: (file: string) => void;
+  readonly stylesheetURL: (file: string, variant?: string) => string;
+  readonly resourceURL: (file: string) => string;
+  /** Standalone sibling assets only; the resulting manifest is not for inline CSS. */
+  readonly relativeResourceURLs?: boolean;
+  /** Resolve CSS package exports with the Node host and preserve their native rules. */
+  readonly resolveNodePackageImports?: boolean;
+  /** Async registration only: resolve imports with a build host before Node fallback. */
+  readonly resolveImport?: CSSImportFileResolver;
+}
+interface StylesheetResourceAsset {
+  readonly file: string;
+  readonly href: string;
+}
+/** Compile native resource usage without flattening imports or reading host-owned assets. */
+declare function compileStylesheetMetadata(file: string, source: string, options: CompileStylesheetOptions): {
+  manifest: MasterCSSManifest;
+  resolutionManifest: MasterCSSManifest;
+  directives: CompileCSSResult;
+  resources: StylesheetResourceAsset[];
+  stylesheets: {
+    id: string;
+    href: string;
+    css: string;
+    nativeCSS: string;
+    generatedCSS: string;
+    outputMappings: CSSOutputMapping[];
+  }[];
+} | undefined;
+/** Compile one file and its dependencies for a host that publishes every asset. */
+declare function compileDeliveredFile(file: string, options: CompileStylesheetOptions): {
+  manifest: MasterCSSManifest;
+  resolutionManifest: MasterCSSManifest;
+  directives: CompileCSSResult;
+  resources: StylesheetResourceAsset[];
+  stylesheets: {
+    id: string;
+    href: string;
+    css: string;
+    nativeCSS: string;
+    generatedCSS: string;
+    outputMappings: CSSOutputMapping[];
+  }[];
+  entry: string;
+};
+/** Compile supplied local CSS and its imports without flattening their boundaries. */
+declare function compileDeliveredSource(id: string, source: string, options: TransformLocalStylesheetOptions, nativeClasses?: readonly string[]): Promise<{
+  manifest: MasterCSSManifest;
+  resolutionManifest: MasterCSSManifest;
+  directives: CompileCSSResult;
+  resources: StylesheetResourceAsset[];
+  stylesheets: {
+    id: string;
+    href: string;
+    css: string;
+    nativeCSS: string;
+    generatedCSS: string;
+    outputMappings: CSSOutputMapping[];
+    sourceMap: string;
+  }[];
+  entry: string;
+  outputMap: (css: string, mappings: CSSOutputMapping[], file?: string) => string;
+} | undefined>;
+declare function registerDeliveredStylesheet(scanner: ScannerState, sources: StylesheetSources, id: string, source: string, options: CompileStylesheetOptions, inlineImports?: boolean): Promise<{
+  notices?: import("@master/css-schema/css-directives").CSSDirectiveNotice[];
+  definitionSources?: import("@master/css-schema/css-directives").CSSDefinitionSource[];
+  nativeOutput?: import("@master/css-schema/css-directives").CSSNativeOutput;
+  outputMappings?: CSSOutputMapping[];
+  sourceMap?: string;
+  nativeMappings?: CSSOutputMapping[];
+  generatedMappings?: CSSOutputMapping[];
+  manifestInput: import("@master/css-schema/css-directives").CSSDirectiveManifestInput;
+  extractionPolicy: import("@master/css-schema/css-directives").CSSDirectiveExtractionPolicy;
+  classNames: string[];
+  nativeClassNames: string[];
+  nativeCSS: string;
+  css: string;
+  generatedCSS: string;
+  warnings: string[];
+  references?: import("@master/css-schema/css-directives").CSSDirectiveReference[];
+  styleDefinitions?: import("@master/css-schema/css-directives").CSSDirectiveStyleDefinition[];
+  dependencies: string[];
+}>;
+declare function composeDeliveredStylesheets(sources: StylesheetSources, options: CompileStylesheetOptions & {
+  manifest?: MasterCSSManifest;
+  includeGeneratedCSS?: boolean;
+  includeNativeCSS?: boolean;
+  includeMasterBaseCSS?: boolean;
+}, classes: readonly string[], styleClasses: (source: StylesheetSource) => readonly string[], inlineImports?: boolean): Required<CreateExtractedCSSResult>;
+export { StylesheetDeliveryOptions, StylesheetResourceAsset, compileDeliveredFile, compileDeliveredSource, compileStylesheetMetadata, composeDeliveredStylesheets, registerDeliveredStylesheet };