@master/css-mcp 2.0.0-rc.88 → 2.0.0

package/dist/compare.js

@@ -1,44 +1,42 @@
+import { loadWorkspaceManifest, manifestMetadata, requireWorkspaceManifest } from "./project.js";
+import { compactClassInspection, createMCPToolingSession } from "./tooling-session.js";
 import { createMCPTextDocument } from "./document.js";
-import { loadWorkspaceManifest } from "./project.js";
-import { createRequire } from "node:module";
-import CSSLanguageService from "@master/css-language-service";
-import { createCSSWithNativeDeclarations } from "@master/css-validator/native-declaration";
-import { parseHTML } from "@master/css-server";
-//#region src/compare.ts
-const CSS_COMPARE_VERSION = 1;
-const defaultManifest = createRequire(import.meta.url)("@master/css-preset/default-manifest.json");
+import { renderClassNamesSync } from "@master/css/node";
+import { compareProjectSnapshots } from "@master/css-compiler/diagnostics";
+// src/compare.ts
+const CSS_COMPARE_VERSION = 2;
 function unique(values) {
 	return [...new Set(values)];
 }
 function splitClassList(value) {
 	return unique((value ?? "").split(/\s+/).map((className) => className.trim()).filter(Boolean));
 }
-function extractContentClasses(content, filePath) {
+function extractContentClasses(content, filePath, session) {
 	if (content === void 0) return [];
-	const service = new CSSLanguageService();
 	const document = createMCPTextDocument(filePath, content);
-	return unique(service.getClassPositions(document).map((position) => position.token));
+	return unique(session.analyzeDocument({
+		source: content,
+		languageId: document.languageId
+	}).classPositions.map((position) => position.token));
 }
-function resolveClasses(options, side, filePath) {
+function resolveClasses(options, side, filePath, session) {
 	const classList = side === "before" ? options.beforeClassList : options.afterClassList;
 	const html = side === "before" ? options.beforeHtml : options.afterHtml;
 	const content = side === "before" ? options.beforeContent : options.afterContent;
 	if (classList !== void 0) return splitClassList(classList);
-	if (html !== void 0) return unique(parseHTML(html).classes);
-	return extractContentClasses(content, filePath);
+	if (html !== void 0) return unique(session.extractSource({ files: [{
+		source: filePath,
+		content: html,
+		kind: "html"
+	}] }).files[0]?.candidates ?? []);
+	return extractContentClasses(content, filePath, session);
 }
 function renderClasses(manifest, classes) {
-	const css = createCSSWithNativeDeclarations(manifest);
-	const invalid = [];
-	for (const className of classes) {
-		const rules = css.generate(className);
-		if (rules.length) for (const rule of rules) rule.layer.insert(rule);
-		else invalid.push(className);
-	}
+	const rendered = renderClassNamesSync(classes, { manifest });
 	return {
-		text: css.text,
-		bytes: css.text.length,
-		invalid
+		text: rendered.cssText,
+		bytes: Buffer.byteLength(rendered.cssText, "utf8"),
+		invalid: [...rendered.invalidClassNames]
 	};
 }
 function diffValues(before, after) {
@@ -64,68 +62,86 @@ function createTextDiff(before, after) {
 	].join("\n");
 }
 async function compareCSS(context, options) {
-	const manifest = await loadWorkspaceManifest(context);
+	if (options.beforeSnapshot || options.afterSnapshot) {
+		if (!options.beforeSnapshot || !options.afterSnapshot) throw new Error("Project comparison requires both beforeSnapshot and afterSnapshot.");
+		if (Object.entries(options).some(([key, value]) => key !== "beforeSnapshot" && key !== "afterSnapshot" && value !== void 0)) throw new Error("Project snapshots cannot be combined with class, content, filePath or context inputs.");
+		return {
+			version: 3,
+			mode: "project",
+			comparison: await compareProjectSnapshots({
+				before: options.beforeSnapshot,
+				after: options.afterSnapshot
+			})
+		};
+	}
+	const manifest = await loadWorkspaceManifest(context, options.context);
 	const filePath = context.resolveVirtualPath(options.filePath || "index.html");
-	const activeManifest = manifest.status === "loaded" ? manifest.manifest : defaultManifest;
-	const beforeClasses = resolveClasses(options, "before", filePath);
-	const afterClasses = resolveClasses(options, "after", filePath);
-	const before = renderClasses(activeManifest, beforeClasses);
-	const after = renderClasses(activeManifest, afterClasses);
-	const classDiff = diffValues(beforeClasses, afterClasses);
-	const ruleDiff = diffValues(splitRules(before.text), splitRules(after.text));
-	return {
-		version: CSS_COMPARE_VERSION,
-		root: context.root,
-		manifest: {
-			status: manifest.status,
-			entries: manifest.entries,
-			...manifest.status === "error" ? { error: manifest.error } : {}
-		},
-		inputs: {
-			filePath,
-			before: {
-				classes: beforeClasses.length,
-				invalid: before.invalid.length
+	const activeManifest = requireWorkspaceManifest(manifest);
+	const session = createMCPToolingSession(activeManifest, manifest.nativeClassNames);
+	try {
+		const beforeClasses = resolveClasses(options, "before", filePath, session);
+		const afterClasses = resolveClasses(options, "after", filePath, session);
+		const before = renderClasses(activeManifest, beforeClasses);
+		const after = renderClasses(activeManifest, afterClasses);
+		const inspections = {
+			before: beforeClasses.map((name) => compactClassInspection(session, name, true)),
+			after: afterClasses.map((name) => compactClassInspection(session, name, true))
+		};
+		const classDiff = diffValues(beforeClasses, afterClasses);
+		const ruleDiff = diffValues(splitRules(before.text), splitRules(after.text));
+		return {
+			version: CSS_COMPARE_VERSION,
+			root: context.root,
+			manifest: manifestMetadata(manifest),
+			inspections,
+			diagnostics: [...inspections.before, ...inspections.after].flatMap((inspection) => inspection.diagnostics ?? []),
+			inputs: {
+				filePath,
+				before: {
+					classes: beforeClasses.length,
+					invalid: before.invalid.length
+				},
+				after: {
+					classes: afterClasses.length,
+					invalid: after.invalid.length
+				}
 			},
-			after: {
-				classes: afterClasses.length,
-				invalid: after.invalid.length
-			}
-		},
-		classes: classDiff,
-		invalid: {
-			before: before.invalid,
-			after: after.invalid,
-			added: after.invalid.filter((className) => !before.invalid.includes(className)),
-			removed: before.invalid.filter((className) => !after.invalid.includes(className))
-		},
-		css: {
-			changed: before.text !== after.text,
-			before: {
-				bytes: before.bytes,
-				text: before.text
+			classes: classDiff,
+			invalid: {
+				before: before.invalid,
+				after: after.invalid,
+				added: after.invalid.filter((className) => !before.invalid.includes(className)),
+				removed: before.invalid.filter((className) => !after.invalid.includes(className))
 			},
-			after: {
-				bytes: after.bytes,
-				text: after.text
+			css: {
+				changed: before.text !== after.text,
+				before: {
+					bytes: before.bytes,
+					text: before.text
+				},
+				after: {
+					bytes: after.bytes,
+					text: after.text
+				},
+				bytesDelta: after.bytes - before.bytes,
+				diff: createTextDiff(before.text, after.text)
 			},
-			bytesDelta: after.bytes - before.bytes,
-			diff: createTextDiff(before.text, after.text)
-		},
-		rules: {
-			added: ruleDiff.added,
-			removed: ruleDiff.removed,
-			unchanged: ruleDiff.unchanged.length
-		},
-		summary: {
-			changed: before.text !== after.text,
-			addedClasses: classDiff.added.length,
-			removedClasses: classDiff.removed.length,
-			addedRules: ruleDiff.added.length,
-			removedRules: ruleDiff.removed.length,
-			bytesDelta: after.bytes - before.bytes
-		}
-	};
+			rules: {
+				added: ruleDiff.added,
+				removed: ruleDiff.removed,
+				unchanged: ruleDiff.unchanged.length
+			},
+			summary: {
+				changed: before.text !== after.text,
+				addedClasses: classDiff.added.length,
+				removedClasses: classDiff.removed.length,
+				addedRules: ruleDiff.added.length,
+				removedRules: ruleDiff.removed.length,
+				bytesDelta: after.bytes - before.bytes
+			}
+		};
+	} finally {
+		session.dispose?.();
+	}
 }
-//#endregion
 export { compareCSS };

package/dist/context.d.ts

@@ -1,4 +1,3 @@
-//#region src/context.d.ts
 interface MasterCSSMCPContextOptions {
   root?: string;
   roots?: string[];
@@ -19,12 +18,6 @@ interface StoredPreviewChange {
   afterText: string;
   diff: string;
 }
-interface StoredPreview {
-  confirmToken: string;
-  createdAt: number;
-  expiresAt: number;
-  changes: StoredPreviewChange[];
-}
 interface PreviewResult {
   confirmToken?: string;
   expiresAt?: number;
@@ -41,12 +34,13 @@ declare class MasterCSSMCPContext {
   readonly previewTTL: number;
   private readonly containmentRoots;
   private previews;
+  private applying;
   constructor(options?: MasterCSSMCPContextOptions);
   assertContained(filePath: string): string;
   resolveVirtualPath(filePath: string): string;
   resolveExistingFile(filePath: string): Promise<string>;
   resolveWritableFile(filePath: string): Promise<string>;
-  validateGlobPatterns(patterns: string[]): void;
+  validateGlobPatterns(patterns: readonly string[]): void;
   createPreview(changes: PreviewChange[], ttl?: number): Promise<PreviewResult>;
   applyPreview(confirmToken: string): Promise<{
     applied: boolean;
@@ -55,6 +49,7 @@ declare class MasterCSSMCPContext {
       afterHash: string;
     }[];
   }>;
+  private applyStoredPreview;
+  dispose(): void;
 }
-//#endregion
-export { MasterCSSMCPContextOptions, PreviewChange, PreviewResult, StoredPreview, StoredPreviewChange, MasterCSSMCPContext as default };
+export { MasterCSSMCPContextOptions, PreviewChange, PreviewResult, StoredPreviewChange, MasterCSSMCPContext as default };

package/dist/context.js

@@ -1,9 +1,10 @@
-import { mkdir, readFile, realpath, stat, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, relative, resolve } from "node:path";
-import { createHash, randomBytes } from "node:crypto";
+import { withPreviewWriteLock } from "./preview-write-lock.js";
 import { existsSync, realpathSync, statSync } from "node:fs";
-//#region src/context.ts
-const DEFAULT_PREVIEW_TTL = 300 * 1e3;
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { createHash, randomBytes } from "node:crypto";
+import { lstat, mkdir, readFile, realpath, stat, writeFile } from "node:fs/promises";
+// src/context.ts
+const DEFAULT_PREVIEW_TTL = 3e5;
 function sha256(text) {
 	return createHash("sha256").update(text).digest("hex");
 }
@@ -48,6 +49,7 @@ var MasterCSSMCPContext = class {
 	previewTTL;
 	containmentRoots;
 	previews = /* @__PURE__ */ new Map();
+	applying = /* @__PURE__ */ new Set();
 	constructor(options = {}) {
 		const configuredRoots = options.roots?.length ? options.roots : [options.root || process.cwd()];
 		const roots = [];
@@ -90,9 +92,10 @@ var MasterCSSMCPContext = class {
 			return realPath;
 		}
 		this.assertContained(resolved);
+		if ((await lstat(resolved).catch(() => void 0))?.isSymbolicLink()) throw new Error(`Path is a dangling symbolic link: ${resolved}`);
 		const parent = await realpath$1(dirname(resolved));
 		this.assertContained(parent);
-		return resolved;
+		return join(parent, basename(resolved));
 	}
 	validateGlobPatterns(patterns) {
 		for (const pattern of patterns) assertFilePattern(pattern);
@@ -109,8 +112,8 @@ var MasterCSSMCPContext = class {
 				beforeHash: beforeExists ? sha256(beforeText) : null,
 				afterHash: sha256(change.afterText),
 				beforeExists,
-				beforeBytes: beforeText.length,
-				afterBytes: change.afterText.length,
+				beforeBytes: Buffer.byteLength(beforeText, "utf8"),
+				afterBytes: Buffer.byteLength(change.afterText, "utf8"),
 				afterText: change.afterText,
 				diff: formatDiff(filePath, beforeText, change.afterText)
 			});
@@ -143,6 +146,19 @@ var MasterCSSMCPContext = class {
 	async applyPreview(confirmToken) {
 		const preview = this.previews.get(confirmToken);
 		if (!preview) throw new Error("Unknown or already applied preview token.");
+		if (this.applying.has(confirmToken)) throw new Error("Preview token is already being applied.");
+		this.applying.add(confirmToken);
+		try {
+			return await withPreviewWriteLock(async () => {
+				if (this.previews.get(confirmToken) !== preview) throw new Error("Unknown or already applied preview token.");
+				return await this.applyStoredPreview(preview);
+			});
+		} finally {
+			this.applying.delete(confirmToken);
+		}
+	}
+	async applyStoredPreview(preview) {
+		const { confirmToken } = preview;
 		if (preview.expiresAt < Date.now()) {
 			this.previews.delete(confirmToken);
 			throw new Error("Preview token has expired.");
@@ -158,7 +174,7 @@ var MasterCSSMCPContext = class {
 		}
 		for (const change of preview.changes) {
 			await mkdir(dirname(change.filePath), { recursive: true });
-			await writeFile(change.filePath, change.afterText);
+			await writeFile(change.filePath, change.afterText, { flag: change.beforeExists ? "w" : "wx" });
 		}
 		this.previews.delete(confirmToken);
 		return {
@@ -169,6 +185,9 @@ var MasterCSSMCPContext = class {
 			}))
 		};
 	}
+	dispose() {
+		this.previews.clear();
+	}
 };
 async function realpath$1(filePath) {
 	try {
@@ -185,5 +204,4 @@ async function readFileIfExists(filePath) {
 		throw error;
 	}
 }
-//#endregion
 export { MasterCSSMCPContext as default };

package/dist/design-system-schema.js

@@ -0,0 +1,97 @@
+import { range, strings } from "./semantic-schema.js";
+import * as z from "zod/v4";
+// src/design-system-schema.ts
+const tokenMetadata = z.object({
+	description: z.string().optional(),
+	deprecated: z.boolean().optional(),
+	replacement: z.string().optional()
+}).strict();
+const designSystemOptions = z.object({
+	version: z.literal(1),
+	metadata: z.record(z.string(), tokenMetadata).optional(),
+	rawValuePolicy: z.object({
+		allowRawValues: z.boolean().optional(),
+		allowProperties: strings.optional(),
+		requireProperties: strings.optional(),
+		allowedPatterns: strings.optional()
+	}).strict().optional()
+}).strict();
+const designSystemReport = z.object({
+	version: z.literal(1),
+	tokens: z.array(z.object({
+		name: z.string(),
+		metadata: tokenMetadata.optional()
+	})),
+	references: z.array(z.object({
+		source: z.string(),
+		token: z.string(),
+		registered: z.boolean(),
+		range,
+		property: z.string(),
+		declarationRange: range,
+		ancestry: z.array(z.object({
+			kind: z.enum(["selector", "at-rule"]),
+			name: z.string().optional(),
+			prelude: z.string(),
+			range
+		})),
+		hasFallback: z.boolean(),
+		inFallback: z.boolean(),
+		importers: strings
+	})),
+	collisions: z.array(z.object({
+		prefix: z.string(),
+		key: z.string(),
+		className: z.string(),
+		namespaces: strings,
+		properties: strings
+	})),
+	components: z.array(z.object({
+		className: z.string(),
+		attributes: z.array(z.object({
+			name: z.string(),
+			values: strings,
+			presence: z.boolean()
+		})),
+		sources: strings
+	})),
+	diagnostics: z.array(z.object({
+		code: z.string(),
+		severity: z.enum([
+			"error",
+			"warning",
+			"information"
+		]),
+		message: z.string(),
+		source: z.string().optional(),
+		range: range.optional(),
+		token: z.string().optional(),
+		data: z.record(z.string(), z.json()).optional()
+	})),
+	coverage: z.object({
+		scope: z.literal("provided-stylesheets"),
+		browser: z.literal("not-checked"),
+		notes: strings
+	}),
+	summary: z.object({
+		stylesheets: z.number(),
+		tokens: z.number(),
+		references: z.number(),
+		collisions: z.number(),
+		errors: z.number(),
+		warnings: z.number()
+	}),
+	project: z.object({
+		cwd: z.string(),
+		entries: strings,
+		files: strings,
+		routeStylesheets: strings,
+		excluded: strings,
+		edges: z.array(z.object({
+			from: z.string(),
+			specifier: z.string(),
+			resolved: z.string()
+		}))
+	})
+});
+export { designSystemOptions, designSystemReport };

package/dist/directives.js

@@ -1,158 +1,108 @@
+import { loadWorkspaceManifest, manifestFingerprint, manifestMetadata, requireWorkspaceManifest } from "./project.js";
 import { createMCPTextDocument } from "./document.js";
-import { getErrorMessage } from "./result.js";
 import { summarizeManifest } from "./manifest-summary.js";
-import { readFile } from "node:fs/promises";
 import { basename } from "node:path";
-import { collectCSSDirectiveRanges } from "@master/css-lexer";
-import { compileCSSManifest, compileCSSManifestFile } from "@master/css-compiler";
-//#region src/directives.ts
-const DIRECTIVE_INSPECTION_VERSION = 1;
+import { readFile } from "node:fs/promises";
+import { compileManifestFileSync, compileManifestSync, inspectCSSSync } from "@master/css-compiler/node";
+// src/directives.ts
+const DIRECTIVE_INSPECTION_VERSION = 2;
 function createDirectiveEntries(content, filePath) {
 	const document = createMCPTextDocument(filePath, content);
-	return collectCSSDirectiveRanges(content).map((directive) => ({
+	return inspectCSSSync(content).directives.map((directive) => ({
 		name: directive.name,
-		range: {
-			start: directive.start,
-			end: directive.end
-		},
+		range: directive.range,
 		loc: {
-			start: document.positionAt(directive.start),
-			end: document.positionAt(directive.end)
+			start: document.positionAt(directive.range.start),
+			end: document.positionAt(directive.range.end)
 		},
 		prelude: content.slice(directive.preludeRange.start, directive.preludeRange.end).trim(),
-		hasBlock: Boolean(directive.blockRange),
-		quotedStrings: directive.quotedStringRanges.length
+		hasBlock: directive.hasBlock,
+		quotedStrings: directive.quotedStrings
 	}));
 }
-function countObjectKeys(value) {
-	return value && typeof value === "object" ? Object.keys(value).length : 0;
-}
-function summarizeManifestInput(input) {
-	const manifestInput = input && typeof input === "object" ? input : {};
-	return {
-		keys: Object.keys(manifestInput),
-		counts: {
-			settings: countObjectKeys(manifestInput.settings),
-			variables: countObjectKeys(manifestInput.variables),
-			utilities: Array.isArray(manifestInput.utilities) ? manifestInput.utilities.length : countObjectKeys(manifestInput.utilities),
-			variants: Array.isArray(manifestInput.variants) ? manifestInput.variants.length : countObjectKeys(manifestInput.variants),
-			conditions: countObjectKeys(manifestInput.conditions),
-			selectors: countObjectKeys(manifestInput.selectors),
-			animations: countObjectKeys(manifestInput.animations)
-		}
-	};
-}
 function summarizeCompileResult(result) {
-	const styleDefinitions = result.directives.styleDefinitions ?? [];
+	const warnings = result.diagnostics.filter((diagnostic) => diagnostic.severity === "warning").map((diagnostic) => diagnostic.message);
 	return {
 		manifest: summarizeManifest(result.manifest),
 		directives: {
-			manifestInput: summarizeManifestInput(result.directives.manifestInput),
+			manifestInput: result.directiveSummary.manifestInput,
 			classNames: result.classNames,
 			nativeClassNames: result.nativeClassNames,
-			styleDefinitions: styleDefinitions.length,
-			extractionPolicy: result.extractionPolicy
+			styleDefinitions: result.directiveSummary.styleDefinitions,
+			extractionPolicy: result.directiveSummary.extractionPolicy
 		},
 		css: {
-			bytes: result.css.length,
-			nativeBytes: result.nativeCSS.length,
-			generatedBytes: result.generatedCSS.length
+			bytes: Buffer.byteLength(result.css, "utf8"),
+			nativeBytes: Buffer.byteLength(result.nativeCSS, "utf8"),
+			generatedBytes: Buffer.byteLength(result.generatedCSS, "utf8")
 		},
 		dependencies: result.dependencies,
-		warnings: result.warnings
+		warnings,
+		diagnostics: result.diagnostics
 	};
 }
 async function compileDirectives(context, options) {
+	const manifest = await loadWorkspaceManifest(context, options.context, options.entryPath ? [await context.resolveExistingFile(options.entryPath)] : void 0);
+	const baseManifest = requireWorkspaceManifest(manifest);
 	if (options.entryPath) {
 		const filePath = await context.resolveExistingFile(options.entryPath);
-		const [content, result] = await Promise.all([readFile(filePath, "utf8"), Promise.resolve(compileCSSManifestFile(filePath, {
+		const [content, result] = await Promise.all([readFile(filePath, "utf8"), Promise.resolve(compileManifestFileSync(filePath, {
 			root: context.root,
+			baseManifest,
 			preserveNativeCSS: options.preserveNativeCSS
 		}))]);
 		return {
 			filePath,
 			content,
-			result
+			result,
+			context: manifestMetadata(manifest)
 		};
 	}
 	if (options.content === void 0) throw new Error("Either entryPath or content is required.");
 	const filePath = context.resolveVirtualPath(options.filePath || "master.css");
-	const result = compileCSSManifest(options.content, {
-		root: context.root,
+	const result = compileManifestSync(options.content, {
+		baseManifest,
 		from: filePath,
 		preserveNativeCSS: options.preserveNativeCSS
 	});
 	return {
 		filePath,
 		content: options.content,
+		context: manifestMetadata(manifest),
 		result
 	};
 }
 async function inspectDirectives(context, options) {
-	try {
-		const compiled = await compileDirectives(context, options);
-		const inspection = summarizeCompileResult(compiled.result);
-		const directiveEntries = createDirectiveEntries(compiled.content, compiled.filePath);
-		return {
-			version: DIRECTIVE_INSPECTION_VERSION,
-			root: context.root,
+	const compiled = await compileDirectives(context, options);
+	const inspection = summarizeCompileResult(compiled.result);
+	const directiveEntries = createDirectiveEntries(compiled.content, compiled.filePath);
+	return {
+		version: DIRECTIVE_INSPECTION_VERSION,
+		root: context.root,
+		context: compiled.context,
+		status: inspection.warnings.length ? "warning" : "ok",
+		input: {
+			filePath: compiled.filePath,
+			name: basename(compiled.filePath),
+			mode: options.entryPath ? "entry" : "content"
+		},
+		directiveEntries,
+		...inspection,
+		manifest: {
+			...inspection.manifest,
+			fingerprint: manifestFingerprint(compiled.result.manifest),
+			languageVersion: compiled.result.manifest.languageVersion
+		},
+		diagnostics: inspection.diagnostics,
+		summary: {
 			status: inspection.warnings.length ? "warning" : "ok",
-			input: {
-				filePath: compiled.filePath,
-				name: basename(compiled.filePath),
-				mode: options.entryPath ? "entry" : "content"
-			},
-			directiveEntries,
-			...inspection,
-			diagnostics: inspection.warnings.map((warning) => ({
-				code: "compiler-warning",
-				severity: "warning",
-				message: warning,
-				source: "Master CSS",
-				sourceKind: "directive",
-				filePath: compiled.filePath
-			})),
-			summary: {
-				status: inspection.warnings.length ? "warning" : "ok",
-				directives: directiveEntries.length,
-				classNames: inspection.directives.classNames.length,
-				nativeClassNames: inspection.directives.nativeClassNames.length,
-				dependencies: inspection.dependencies.length,
-				warnings: inspection.warnings.length,
-				cssBytes: inspection.css.bytes
-			}
-		};
-	} catch (error) {
-		const filePath = options.entryPath || options.filePath || "master.css";
-		return {
-			version: DIRECTIVE_INSPECTION_VERSION,
-			root: context.root,
-			status: "error",
-			input: {
-				filePath,
-				mode: options.entryPath ? "entry" : "content"
-			},
-			directiveEntries: options.content ? createDirectiveEntries(options.content, context.resolveVirtualPath(options.filePath || "master.css")) : [],
-			diagnostics: [{
-				code: "directive-inspection-error",
-				severity: "error",
-				message: getErrorMessage(error),
-				source: "Master CSS",
-				sourceKind: "directive",
-				filePath
-			}],
-			summary: {
-				status: "error",
-				directives: 0,
-				classNames: 0,
-				nativeClassNames: 0,
-				dependencies: 0,
-				warnings: 0,
-				errors: 1,
-				cssBytes: 0
-			}
-		};
-	}
+			directives: directiveEntries.length,
+			classNames: inspection.directives.classNames.length,
+			nativeClassNames: inspection.directives.nativeClassNames.length,
+			dependencies: inspection.dependencies.length,
+			warnings: inspection.warnings.length,
+			cssBytes: inspection.css.bytes
+		}
+	};
 }
-//#endregion
 export { inspectDirectives };