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

package/dist/compiler.js

@@ -0,0 +1,248 @@
+import { validateCompiledCSS } from "./value-validation.js";
+import { noticeDiagnostics } from "./notices.js";
+import { MASTER_CSS_DIAGNOSTIC_VERSION, MasterCSSError } from "@master/css-schema";
+// src/compiler.ts
+function warningDiagnostic(message) {
+	return Object.freeze({
+		version: MASTER_CSS_DIAGNOSTIC_VERSION,
+		code: "COMPILER_WARNING",
+		domain: "compiler",
+		phase: "compiler",
+		severity: "warning",
+		message
+	});
+}
+function diagnosticsFor(warnings, onDiagnostic) {
+	const diagnostics = Object.freeze(warnings.map(warningDiagnostic));
+	for (const diagnostic of diagnostics) onDiagnostic?.(diagnostic);
+	return diagnostics;
+}
+function countRecordValue(value) {
+	if (Array.isArray(value)) return value.length;
+	return value && typeof value === "object" ? Object.keys(value).length : 0;
+}
+function freezeExtractionPolicy(policy) {
+	return Object.freeze({
+		include: Object.freeze([...policy.include]),
+		exclude: Object.freeze([...policy.exclude]),
+		safelist: Object.freeze([...policy.safelist]),
+		safelistKeyframes: Object.freeze([...policy.safelistKeyframes]),
+		blocklist: Object.freeze([...policy.blocklist]),
+		preserveNative: policy.preserveNative,
+		pruneNative: policy.pruneNative
+	});
+}
+function directiveSummary(result) {
+	const manifestInput = result.manifestInput;
+	const keys = Object.freeze(Object.keys(manifestInput));
+	return Object.freeze({
+		manifestInput: Object.freeze({
+			keys,
+			counts: Object.freeze(Object.fromEntries([
+				"theme",
+				"customMedia",
+				"mixins",
+				"keyframes"
+			].map((key) => [key, countRecordValue(manifestInput[key])])))
+		}),
+		styleDefinitions: (result.styleDefinitions?.length ?? 0) + [...result.manifestInput.mixins ?? [], ...result.manifestInput.utilities ?? []].reduce((count, definition) => count + (definition.body?.length ?? 0), 0),
+		extractionPolicy: freezeExtractionPolicy(result.extractionPolicy)
+	});
+}
+/** @internal */
+function toMasterCSSCompileResultInternal(result, onDiagnostic, validation, origin) {
+	return Object.freeze({
+		css: result.css,
+		...result.sourceMap ? { sourceMap: result.sourceMap } : {},
+		nativeCSS: result.nativeCSS,
+		generatedCSS: result.generatedCSS,
+		dependencies: Object.freeze([...result.dependencies]),
+		classNames: Object.freeze([...result.classNames]),
+		nativeClassNames: Object.freeze([...result.nativeClassNames]),
+		diagnostics: Object.freeze([
+			...diagnosticsFor(result.warnings, onDiagnostic),
+			...noticeDiagnostics(result.notices, onDiagnostic),
+			...validateCompiledCSS([{
+				css: result.css,
+				mappings: result.outputMappings ?? result.nativeMappings,
+				...origin
+			}], {
+				onDiagnostic,
+				validation
+			})
+		]),
+		directiveSummary: directiveSummary(result)
+	});
+}
+/** @internal */
+function toMasterCSSCompileManifestResultInternal(result, onDiagnostic, validation) {
+	return Object.freeze({
+		css: result.css,
+		nativeCSS: result.nativeCSS,
+		generatedCSS: result.generatedCSS,
+		dependencies: Object.freeze([...result.dependencies]),
+		classNames: Object.freeze([...result.classNames]),
+		nativeClassNames: Object.freeze([...result.nativeClassNames]),
+		diagnostics: Object.freeze([
+			...diagnosticsFor(result.warnings, onDiagnostic),
+			...noticeDiagnostics(result.notices, onDiagnostic),
+			...validateCompiledCSS([{
+				css: result.css,
+				mappings: result.outputMappings,
+				sources: result.sourceTexts
+			}], {
+				onDiagnostic,
+				validation
+			})
+		]),
+		directiveSummary: directiveSummary(result.directives),
+		manifest: Object.freeze(result.manifest),
+		directives: toMasterCSSCompileResultInternal(result.directives)
+	});
+}
+let bindCompilerSession;
+var MasterCSSCompiler = class MasterCSSCompiler {
+	#session;
+	#disposed = false;
+	constructor() {}
+	get binding() {
+		return this.#session.binding;
+	}
+	inspectCSS(source) {
+		this.assertActive();
+		const inspection = this.#session.inspectCSS(source);
+		return Object.freeze({
+			...inspection,
+			directives: Object.freeze(inspection.directives.map((directive) => Object.freeze({
+				...directive,
+				range: Object.freeze({ ...directive.range }),
+				preludeRange: Object.freeze({ ...directive.preludeRange })
+			})))
+		});
+	}
+	compileCSS(source, options = {}) {
+		this.assertActive();
+		return toMasterCSSCompileResultInternal(this.#session.compileCSS(source, options), options.onDiagnostic, options.validation, {
+			source: options.from ?? "<stylesheet>",
+			sources: { [options.from ?? "<stylesheet>"]: source }
+		});
+	}
+	compileManifest(source, options) {
+		this.assertActive();
+		const rawDirectives = this.#session.compileCSS(source, options);
+		const origin = {
+			source: options.from ?? "<stylesheet>",
+			sources: { [options.from ?? "<stylesheet>"]: source }
+		};
+		const directives = toMasterCSSCompileResultInternal(rawDirectives, void 0, void 0, origin);
+		if (rawDirectives.references?.length) throw new MasterCSSError({
+			code: "UNRESOLVED_REFERENCE",
+			domain: "compiler",
+			message: "Universal manifest compilation cannot resolve @reference directives."
+		});
+		const lowered = this.#session.lowerCSSDirectives({
+			manifestInput: rawDirectives.manifestInput,
+			definitionSources: rawDirectives.definitionSources || [],
+			nativeOutput: rawDirectives.nativeOutput,
+			styleDefinitions: rawDirectives.styleDefinitions || [],
+			warnings: rawDirectives.warnings
+		}, { baseManifest: options.baseManifest }, source);
+		const generatedCSS = lowered.generatedCSS || "";
+		const css = lowered.css ?? [rawDirectives.nativeCSS, generatedCSS].filter(Boolean).join("\n");
+		const diagnostics = Object.freeze([
+			...diagnosticsFor(lowered.warnings, options.onDiagnostic),
+			...noticeDiagnostics(lowered.notices, options.onDiagnostic),
+			...validateCompiledCSS([{
+				css,
+				mappings: lowered.outputMappings ?? rawDirectives.nativeMappings,
+				...origin
+			}], options)
+		]);
+		return Object.freeze({
+			css,
+			nativeCSS: rawDirectives.nativeCSS,
+			generatedCSS,
+			classNames: Object.freeze([...rawDirectives.classNames]),
+			nativeClassNames: Object.freeze([...rawDirectives.nativeClassNames]),
+			diagnostics,
+			directiveSummary: directiveSummary(rawDirectives),
+			dependencies: Object.freeze([]),
+			manifest: Object.freeze(lowered.manifest),
+			directives
+		});
+	}
+	dispose() {
+		if (this.#disposed) return;
+		this.#session.dispose();
+		this.#disposed = true;
+	}
+	prepareStylesheetBundle(request) {
+		this.assertActive();
+		const result = this.#session.prepareCSSStylesheetBundle(request);
+		return Object.freeze({
+			...result,
+			graph: Object.freeze({
+				...result.graph,
+				references: Object.freeze(result.graph.references.map((reference) => Object.freeze({ ...reference }))),
+				stylesheets: Object.freeze(result.graph.stylesheets.map((stylesheet) => Object.freeze({
+					...stylesheet,
+					imports: Object.freeze(stylesheet.imports.map((edge) => Object.freeze({ ...edge })))
+				})))
+			}),
+			sources: Object.freeze(result.sources.map((source) => Object.freeze({
+				...source,
+				range: Object.freeze({ ...source.range }),
+				resources: Object.freeze(source.resources.map((resource) => Object.freeze({ ...resource }))),
+				imports: Object.freeze(source.imports.map((resource) => Object.freeze({ ...resource })))
+			})))
+		});
+	}
+	renderStylesheetBundle(request) {
+		this.assertActive();
+		return Object.freeze(this.#session.renderCSSStylesheetBundle(request).map((asset) => Object.freeze({ ...asset })));
+	}
+	compareProjectSnapshots(request) {
+		this.assertActive();
+		return Object.freeze(this.#session.compareProjectSnapshots(request));
+	}
+	compileStylesheets(request, options = {}) {
+		this.assertActive();
+		const result = this.#session.compileCSSStylesheetGraph(request);
+		const directives = toMasterCSSCompileResultInternal(result.directives);
+		return Object.freeze({
+			...directives,
+			diagnostics: Object.freeze([...directives.diagnostics, ...validateCompiledCSS(result.stylesheets.map((asset) => ({
+				css: asset.css,
+				source: asset.id,
+				mappings: asset.outputMappings,
+				sources: request.graph.files
+			})), options)]),
+			entry: result.entry,
+			stylesheets: Object.freeze(result.stylesheets.map((stylesheet) => Object.freeze({ ...stylesheet }))),
+			manifest: Object.freeze(result.manifest),
+			directives
+		});
+	}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+	assertActive() {
+		if (this.#disposed) throw new MasterCSSError({
+			code: "SESSION_DISPOSED",
+			domain: "compiler",
+			message: "The Master CSS compiler has been disposed."
+		});
+	}
+	static {
+		bindCompilerSession = (session) => {
+			const compiler = new MasterCSSCompiler();
+			compiler.#session = session;
+			return compiler;
+		};
+	}
+};
+/** @internal */
+function bindCompilerSessionInternal(session) {
+	return bindCompilerSession(session);
+}
+export { MasterCSSCompiler, bindCompilerSessionInternal, toMasterCSSCompileManifestResultInternal, toMasterCSSCompileResultInternal };

package/dist/contracts.d.ts

@@ -0,0 +1,31 @@
+import { MasterCSSDiagnostic } from "@master/css-schema";
+import { CSSDirectiveExtractionPolicy, CSSDirectiveReference, CSSDirectiveResult } from "@master/css-schema/css-directives";
+interface CompileCSSOptions {
+  readonly classes?: readonly string[];
+  readonly from?: string;
+  readonly preserveNativeCSS?: boolean;
+  /** Opt in to pruning native rules in project-owned files. */
+  readonly pruneNativeCSS?: boolean;
+  /** Keep untouched native source for host transforms; incompatible with class pruning. */
+  readonly preserveNativeSource?: boolean;
+  /** Report CSS value errors by default; error rejects the complete output. */
+  readonly validation?: 'report' | 'error';
+  readonly onDiagnostic?: (diagnostic: MasterCSSDiagnostic) => void;
+}
+interface CompileCSSFileOptions extends CompileCSSOptions {
+  root?: string;
+}
+type CompileCSSResult = CSSDirectiveResult;
+interface ResolvedCSSImportGraph {
+  sourceMappings?: import('@master/css-schema/css-directives').CSSOutputMapping[];
+  source: string;
+  dependencies: string[];
+  references?: CSSDirectiveReference[];
+}
+type CSSReferenceStatement = CSSDirectiveReference & {
+  start: number;
+  end: number;
+  statement: string;
+};
+declare function emptyExtractionPolicy(): CSSDirectiveExtractionPolicy;
+export { CSSReferenceStatement, CompileCSSFileOptions, CompileCSSOptions, CompileCSSResult, ResolvedCSSImportGraph, emptyExtractionPolicy };

package/dist/contracts.js

@@ -0,0 +1,13 @@
+// src/contracts.ts
+function emptyExtractionPolicy() {
+	return {
+		include: [],
+		exclude: [],
+		safelist: [],
+		safelistKeyframes: [],
+		blocklist: [],
+		preserveNative: false,
+		pruneNative: false
+	};
+}
+export { emptyExtractionPolicy };

package/dist/diagnostics/contracts.d.ts

@@ -0,0 +1,119 @@
+import { MasterCSSClassValidation } from "@master/css-tooling/validator";
+import { MasterCSSDiagnostic } from "@master/css-binding/tooling";
+type MasterCSSInspectionDiagnosticSeverity = 'error' | 'warning' | 'info';
+type MasterCSSInspectionDiagnosticCode = 'invalid-scanner-class' | 'missing-css' | 'stylesheet-error' | 'stylesheet-warning' | 'scanner-error' | MasterCSSDiagnostic['code'];
+type MasterCSSInspectionDiagnosticSourceKind = 'scanner' | 'stylesheet' | 'missing-css';
+type MasterCSSMissingCSSStatus = 'present' | 'missing';
+type MasterCSSMissingCSSReason = 'generated' | 'native-css' | 'safelist' | 'invalid' | 'blocklisted' | 'not-detected';
+interface MasterCSSMissingCSSResult {
+  readonly className: string;
+  readonly status: MasterCSSMissingCSSStatus;
+  readonly reason: MasterCSSMissingCSSReason;
+}
+interface MasterCSSInspectionDiagnostic {
+  readonly code: MasterCSSInspectionDiagnosticCode;
+  readonly phase: MasterCSSDiagnostic['phase'];
+  readonly range?: MasterCSSDiagnostic['range'];
+  readonly notes?: readonly string[];
+  readonly severity: MasterCSSInspectionDiagnosticSeverity;
+  readonly message: string;
+  readonly source: 'Master CSS';
+  readonly sourceKind: MasterCSSInspectionDiagnosticSourceKind;
+  readonly filePath?: string;
+  readonly data?: Readonly<{
+    cwd: string;
+  } | {
+    className: string;
+  } | MasterCSSMissingCSSResult>;
+}
+interface MasterCSSDiscoveredClasses {
+  readonly latent: readonly string[];
+  readonly valid: readonly string[];
+  readonly invalid: readonly string[];
+  readonly usedNative: readonly string[];
+}
+interface MasterCSSSourceInspection {
+  readonly filePath: string;
+  readonly source: string;
+  readonly scanned: boolean;
+  readonly changed: boolean;
+  readonly discovered: MasterCSSDiscoveredClasses;
+}
+interface MasterCSSStylesheetInspection {
+  readonly filePath: string;
+  readonly masterCSS: boolean;
+  readonly pruneNativeCSS: boolean;
+  readonly dependencies: readonly string[];
+  readonly sourceDependencies: readonly string[];
+  readonly warnings: readonly string[];
+  readonly errors: readonly string[];
+}
+interface MasterCSSStylesheetError {
+  readonly filePath: string;
+  readonly message: string;
+}
+interface MasterCSSInspectionReport {
+  /** Optional authored CSS analysis from the same resolved project. */
+  readonly designSystem?: import('./design-system.js').MasterCSSProjectDesignSystemReport;
+  readonly version: 5;
+  readonly cwd: string;
+  readonly inputs: Readonly<{
+    patterns: readonly string[];
+    files: readonly string[];
+    classes: readonly string[];
+  }>;
+  readonly scanner: Readonly<{
+    counts: Readonly<{
+      latent: number;
+      valid: number;
+      invalid: number;
+      native: number;
+      usedNative: number;
+      safelist: number;
+      blocklist: number;
+    }>;
+    classes: Readonly<{
+      latent: readonly string[];
+      valid: readonly string[];
+      invalid: readonly string[];
+      native: readonly string[];
+      usedNative: readonly string[];
+      safelist: readonly string[];
+      blocklist: readonly string[];
+    }>;
+    resetDependencies: readonly string[];
+  }>;
+  readonly stylesheets: Readonly<{
+    entries: readonly MasterCSSStylesheetInspection[];
+    dependencies: readonly string[];
+    warnings: readonly string[];
+    errors: readonly MasterCSSStylesheetError[];
+  }>;
+  readonly css: Readonly<{
+    bytes: number;
+    included: boolean;
+    text?: string;
+    emittedGlobals: Readonly<{
+      variables: number;
+      keyframes: number;
+    }>;
+  }>;
+  readonly missingCSS: Readonly<{
+    checked: readonly string[];
+    present: readonly MasterCSSMissingCSSResult[];
+    missing: readonly MasterCSSMissingCSSResult[];
+  }>;
+  readonly files: readonly MasterCSSSourceInspection[];
+  readonly inspections: readonly MasterCSSClassValidation[];
+  readonly diagnostics: readonly MasterCSSInspectionDiagnostic[];
+  readonly summary: Readonly<{
+    files: number;
+    stylesheets: number;
+    diagnostics: number;
+    errors: number;
+    warnings: number;
+    missingCSS: number;
+    invalidClasses: number;
+  }>;
+}
+export { MasterCSSDiscoveredClasses, MasterCSSInspectionDiagnostic, MasterCSSInspectionDiagnosticCode, MasterCSSInspectionDiagnosticSeverity, MasterCSSInspectionDiagnosticSourceKind, MasterCSSInspectionReport, MasterCSSMissingCSSReason, MasterCSSMissingCSSResult, MasterCSSMissingCSSStatus, MasterCSSSourceInspection, MasterCSSStylesheetError, MasterCSSStylesheetInspection };

package/dist/diagnostics/contracts.js

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

package/dist/diagnostics/design-system.d.ts

@@ -0,0 +1,31 @@
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+import { MasterCSSDesignSystemOptions, MasterCSSDesignSystemOptions as MasterCSSDesignSystemOptions$1, MasterCSSDesignSystemReport, MasterCSSDesignSystemReport as MasterCSSDesignSystemReport$1 } from "@master/css-tooling/lint";
+import { MasterCSSProjectResult, MasterCSSProjectSourceGraph } from "../project/options.js";
+interface CreateMasterCSSDesignSystemReportOptions {
+  readonly manifest: MasterCSSManifest;
+  readonly cwd?: string;
+  readonly entries?: readonly string[];
+  readonly designSystem?: MasterCSSDesignSystemOptions$1;
+  /**
+   * Route and component stylesheets imported from JavaScript rather than reached from a CSS entry.
+   * They resolve against the same project manifest and report no importers.
+   */
+  readonly routeStylesheets?: readonly string[];
+  readonly resolveExistingFile?: (file: string) => string | Promise<string>;
+  readonly onDependency?: (file: string) => void;
+}
+interface MasterCSSProjectDesignSystemReport extends MasterCSSDesignSystemReport$1 {
+  readonly project: {
+    readonly cwd: string;
+    readonly entries: readonly string[];
+    readonly files: readonly string[];
+    readonly routeStylesheets: readonly string[];
+    readonly excluded: readonly string[];
+    readonly edges: MasterCSSProjectSourceGraph['edges'];
+  };
+}
+/** Inspect only project-owned CSS reached from managed entries, preserving authored offsets. */
+declare function createMasterCSSDesignSystemReport(options: CreateMasterCSSDesignSystemReportOptions): Promise<MasterCSSProjectDesignSystemReport>;
+/** Shared orchestration for standalone and combined project inspection. */
+declare function inspectResolvedProjectDesignSystem(project: MasterCSSProjectResult, cwd: string, options: Pick<CreateMasterCSSDesignSystemReportOptions, 'designSystem' | 'routeStylesheets' | 'resolveExistingFile'>): Promise<MasterCSSProjectDesignSystemReport>;
+export { CreateMasterCSSDesignSystemReportOptions, type MasterCSSDesignSystemOptions, type MasterCSSDesignSystemReport, MasterCSSProjectDesignSystemReport, createMasterCSSDesignSystemReport, inspectResolvedProjectDesignSystem };

package/dist/diagnostics/design-system.js

@@ -0,0 +1,75 @@
+import { loadProjectManifest } from "../project/manifest.js";
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { createToolingSession } from "@master/css-tooling";
+// src/diagnostics/design-system.ts
+/** Inspect only project-owned CSS reached from managed entries, preserving authored offsets. */
+async function createMasterCSSDesignSystemReport(options) {
+	const cwd = path.resolve(options.cwd ?? process.cwd());
+	return inspectResolvedProjectDesignSystem(await loadProjectManifest({
+		root: cwd,
+		entries: options.entries,
+		baseManifest: options.manifest,
+		includeSourceGraph: true,
+		onDependency: options.onDependency
+	}), cwd, options);
+}
+/** Shared orchestration for standalone and combined project inspection. */
+async function inspectResolvedProjectDesignSystem(project, cwd, options) {
+	if (!project.entries.length) throw new Error("No project CSS entry was found. Add a stylesheet importing @master/css.");
+	const graph = project.sourceGraph;
+	if (!graph) throw new Error("The project loader did not return its authored source graph.");
+	const importers = /* @__PURE__ */ new Map();
+	for (const { from, resolved } of graph.edges) {
+		const sources = importers.get(resolved) ?? /* @__PURE__ */ new Set();
+		sources.add(from);
+		importers.set(resolved, sources);
+	}
+	const stylesheets = [];
+	const excluded = [];
+	for (const file of graph.files) {
+		if (!file.projectOwned) {
+			excluded.push(file.source);
+			continue;
+		}
+		await options.resolveExistingFile?.(file.source);
+		stylesheets.push({
+			source: file.source,
+			content: file.content,
+			importers: [...importers.get(file.source) ?? []]
+		});
+	}
+	const managed = new Set(stylesheets.map((file) => file.source));
+	const routeStylesheets = [];
+	for (const file of options.routeStylesheets ?? []) {
+		const source = path.resolve(cwd, file);
+		if (managed.has(source)) continue;
+		managed.add(source);
+		routeStylesheets.push(source);
+		await options.resolveExistingFile?.(source);
+		stylesheets.push({
+			source,
+			content: await readFile(source, "utf8"),
+			importers: []
+		});
+	}
+	using tooling = await createToolingSession({
+		manifest: project.manifest,
+		nativeClassNames: project.nativeClassNames
+	});
+	return {
+		...tooling.inspectDesignSystem({
+			...options.designSystem ?? { version: 1 },
+			stylesheets
+		}),
+		project: {
+			cwd,
+			entries: project.entries,
+			files: stylesheets.map((file) => file.source),
+			routeStylesheets,
+			excluded,
+			edges: graph.edges
+		}
+	};
+}
+export { createMasterCSSDesignSystemReport, inspectResolvedProjectDesignSystem };

package/dist/diagnostics/index.d.ts

@@ -0,0 +1,28 @@
+import { MasterCSSProjectSnapshot as MasterCSSProjectSnapshot$1 } from "@master/css-binding/compiler";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+import { MasterCSSProjectComparison, MasterCSSProjectComparisonRequest, MasterCSSProjectSnapshot } from "../index.js";
+import { MasterCSSDiscoveredClasses, MasterCSSInspectionDiagnostic, MasterCSSInspectionDiagnosticCode, MasterCSSInspectionDiagnosticSeverity, MasterCSSInspectionDiagnosticSourceKind, MasterCSSInspectionReport, MasterCSSInspectionReport as MasterCSSInspectionReport$1, MasterCSSMissingCSSReason, MasterCSSMissingCSSResult, MasterCSSMissingCSSStatus, MasterCSSSourceInspection, MasterCSSStylesheetError, MasterCSSStylesheetInspection } from "./contracts.js";
+import { CreateMasterCSSDesignSystemReportOptions, MasterCSSDesignSystemOptions, MasterCSSDesignSystemOptions as MasterCSSDesignSystemOptions$1, MasterCSSDesignSystemReport, MasterCSSProjectDesignSystemReport, createMasterCSSDesignSystemReport } from "./design-system.js";
+import { compareProjectSnapshots } from "./project-comparison.js";
+declare const MASTER_CSS_INSPECTION_REPORT_VERSION: 5;
+interface CreateMasterCSSInspectionReportOptions {
+  manifest: MasterCSSManifest;
+  cwd?: string;
+  patterns?: readonly string[];
+  classes?: readonly string[] | string;
+  includeCss?: boolean;
+  /** Inspect authored CSS using the same project manifest as the class scan. */
+  designSystem?: MasterCSSDesignSystemOptions$1;
+  /** Route and component stylesheets the design-system inspection adds to the managed CSS graph. */
+  routeStylesheets?: readonly string[];
+  ignore?: readonly string[];
+  resolveExistingFile?: (filePath: string) => string | Promise<string>;
+  validatePatterns?: (patterns: readonly string[]) => void;
+}
+declare function createMasterCSSInspectionReport(options: CreateMasterCSSInspectionReportOptions): Promise<MasterCSSInspectionReport$1>;
+/** Capture known project consumers and resolved CSS assets in one inspection session. */
+declare function captureMasterCSSProject(options: CreateMasterCSSInspectionReportOptions): Promise<{
+  report: MasterCSSInspectionReport$1;
+  snapshot: MasterCSSProjectSnapshot$1;
+}>;
+export { type CreateMasterCSSDesignSystemReportOptions, CreateMasterCSSInspectionReportOptions, MASTER_CSS_INSPECTION_REPORT_VERSION, type MasterCSSDesignSystemOptions, type MasterCSSDesignSystemReport, type MasterCSSDiscoveredClasses, type MasterCSSInspectionDiagnostic, type MasterCSSInspectionDiagnosticCode, type MasterCSSInspectionDiagnosticSeverity, type MasterCSSInspectionDiagnosticSourceKind, type MasterCSSInspectionReport, type MasterCSSMissingCSSReason, type MasterCSSMissingCSSResult, type MasterCSSMissingCSSStatus, type MasterCSSProjectComparison, type MasterCSSProjectComparisonRequest, type MasterCSSProjectDesignSystemReport, type MasterCSSProjectSnapshot, type MasterCSSSourceInspection, type MasterCSSStylesheetError, type MasterCSSStylesheetInspection, captureMasterCSSProject, compareProjectSnapshots, createMasterCSSDesignSystemReport, createMasterCSSInspectionReport };