@master/css-cli 2.0.0-rc.88 → 2.0.1

package/dist/generate.js

@@ -0,0 +1,388 @@
+import { createDependencyRebuild } from "./dependency-rebuild.js";
+import { publishOwnedStylesheet, stylesheetStatePath } from "./asset-ownership.js";
+import { createSourceWatchPlan } from "./source-watch.js";
+import { DEFAULT_SCAN_OUTPUT } from "./constants.js";
+import { withStylesheetPublicationLock } from "./publication-lock.js";
+import fs from "node:fs";
+import path from "node:path";
+import defaultManifestJSON from "@master/css-preset/default-manifest.json" with { type: "json" };
+import { createHash } from "node:crypto";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { once } from "node:events";
+// src/generate.ts
+const DEFAULT_SOURCE_PATTERNS = ["**/*.{html,htm,js,mjs,jsx,cjs,ts,tsx,mts,cts,svelte,astro,vue,md,mdx,pug,php}"];
+let scannerModulePromise;
+let stylesheetModulePromise;
+let projectModulePromise;
+let fastGlobModulePromise;
+let chokidarModulePromise;
+let bytesPromise;
+const defaultManifest = defaultManifestJSON;
+async function registerManagedCSSEntries(scanner, stylesheets, delivery) {
+	const [_stylesheet, { discoverManifestEntries }] = await Promise.all([loadStylesheetModule(), loadProjectModule()]);
+	stylesheets.clear();
+	for (const entry of await discoverManifestEntries({ root: scanner.cwd })) {
+		delivery?.onDependency?.(entry);
+		await stylesheets.register(scanner, entry, fs.readFileSync(entry, "utf8"), {
+			baseManifest: defaultManifest,
+			projectDir: scanner.cwd,
+			delivery
+		});
+	}
+	scanner.resetDependencies = [...stylesheets.snapshot().dependencies];
+}
+function normalizeSourcePatterns(specifiedSourcePaths) {
+	return specifiedSourcePaths?.length ? specifiedSourcePaths : DEFAULT_SOURCE_PATTERNS;
+}
+function normalizeGlobPatterns(patterns) {
+	return patterns.map((pattern) => pattern.replace(/\\/g, "/"));
+}
+function filesystemSourceIdentity(cwd, source) {
+	return path.relative(cwd, path.resolve(cwd, source)).split(path.sep).join("/");
+}
+function resolveSourcePaths(scanner, fg, sourcePatterns, ignore = [], explicit = false) {
+	const sources = fg.sync(normalizeGlobPatterns(sourcePatterns), {
+		cwd: scanner.cwd,
+		ignore: normalizeGlobPatterns(ignore)
+	}).filter((source) => source && scanner.isSourceAllowed(source, { explicit }));
+	return [...new Set(sources.map((source) => filesystemSourceIdentity(scanner.cwd, source)))];
+}
+async function scanSourceFile(scanner, source) {
+	const filepath = path.resolve(scanner.cwd, source);
+	await scanner.scan(source, fs.readFileSync(filepath, "utf8"));
+}
+async function scanSourceFiles(scanner, sourcePaths) {
+	await scanner.reconcileSources("project", sourcePaths.map((source) => ({
+		source,
+		content: fs.readFileSync(path.resolve(scanner.cwd, source), "utf8")
+	})));
+}
+async function prepareScanner(scanner, stylesheets, sourcePaths, delivery) {
+	await registerManagedCSSEntries(scanner, stylesheets, delivery);
+	await scanSourceFiles(scanner, sourcePaths);
+}
+async function reportExport(scanner, css, filename = DEFAULT_SCAN_OUTPUT) {
+	const filepath = path.resolve(scanner.cwd, filename);
+	if (scanner.options.verbose) {
+		const bytes = await loadBytes();
+		process.stderr.write(`${filename} exported ${bytes(css.length)}\n`);
+	}
+	scanner.emit("export", filename, filepath);
+}
+function formatWatchedPath(cwd, file) {
+	return path.isAbsolute(file) ? path.relative(cwd, file) : file;
+}
+function createDependencyWatchPlan(dependencies) {
+	const contains = (parent, file) => {
+		const relative = path.relative(parent, file);
+		return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
+	};
+	const directories = [...dependencies].filter((file) => fs.statSync(file, { throwIfNoEntry: false })?.isDirectory());
+	const matches = (file) => dependencies.has(path.resolve(file)) || directories.some((directory) => contains(directory, file));
+	const roots = [...new Set([...dependencies].map((file) => {
+		let directory = path.dirname(file);
+		while (!fs.statSync(directory, { throwIfNoEntry: false })?.isDirectory()) {
+			const parent = path.dirname(directory);
+			if (parent === directory) break;
+			directory = parent;
+		}
+		return directory;
+	}))];
+	return {
+		roots: roots.filter((root) => !roots.some((other) => root !== other && contains(other, root))),
+		matches,
+		ignored(file, stats) {
+			if (stats?.isDirectory()) return !matches(file) && ![...dependencies].some((target) => contains(file, target));
+			return stats?.isFile() ? !matches(file) : false;
+		}
+	};
+}
+async function waitForWatcherReady(watcher) {
+	await once(watcher, "ready");
+	await new Promise((resolve) => setTimeout(resolve, 0));
+}
+async function runGenerate(specifiedSourcePaths = [], options = {}) {
+	const pipelineModules = Promise.all([loadStylesheetModule(), loadProjectModule()]);
+	const [MasterCSSScanner, fg] = await Promise.all([loadCSSScanner(), loadFastGlob()]);
+	const { watch, output, verbose, cwd } = options;
+	const scanner = new MasterCSSScanner({
+		manifest: defaultManifest,
+		binding: options.binding,
+		verbose: verbose ? +verbose : void 0
+	}, cwd);
+	const { createStylesheetCollection } = await loadStylesheetModule();
+	const stylesheets = createStylesheetCollection();
+	const sourcePatterns = normalizeSourcePatterns(specifiedSourcePaths);
+	const outputPath = path.resolve(scanner.cwd, output || "master.css");
+	const outputFiles = /* @__PURE__ */ new Set([outputPath, stylesheetStatePath(outputPath)]);
+	const attemptedDependencies = /* @__PURE__ */ new Set();
+	const missingDependencies = /* @__PURE__ */ new Set();
+	const hash = (value) => createHash("sha256").update(value).digest("hex").slice(0, 20);
+	const assetPrefix = `master-${hash(path.relative(scanner.cwd, outputPath))}`;
+	let revision = "";
+	let reportedOutput = false;
+	let resourceBytes;
+	const readResource = (file) => {
+		const bytes = resourceBytes?.get(file) ?? fs.readFileSync(file);
+		resourceBytes?.set(file, bytes);
+		return bytes;
+	};
+	const delivery = options.export ? {
+		entryURL: `./${encodeURIComponent(path.basename(outputPath))}`,
+		onDependency: watch ? (file) => {
+			const absolute = path.resolve(file);
+			attemptedDependencies.add(absolute);
+			if (!fs.existsSync(absolute)) missingDependencies.add(absolute);
+		} : void 0,
+		stylesheetURL: (file, variant) => `./${assetPrefix}-${revision}${hash(path.relative(scanner.cwd, file) + (variant?.slice(file.length) ?? ""))}.css`,
+		resourceURL: (file) => `./${assetPrefix}-${hash(readResource(file))}${encodeURIComponent(path.extname(file))}`,
+		relativeResourceURLs: true,
+		inlineImports: true
+	} : void 0;
+	const writeOutput = async () => {
+		const compose = () => stylesheets.compose({
+			scanner,
+			baseManifest: defaultManifest,
+			projectDir: scanner.cwd,
+			pruneNativeCSS: options.pruneNativeCSS,
+			validation: options.strict ? "error" : "report",
+			onDiagnostic: (diagnostic) => {
+				if (diagnostic.severity === "error") process.stderr.write(`${diagnostic.code}: ${diagnostic.message}\n`);
+			},
+			delivery
+		});
+		revision = "";
+		resourceBytes = options.export ? /* @__PURE__ */ new Map() : void 0;
+		try {
+			let composition = await compose();
+			if (options.export) {
+				revision = `${hash(JSON.stringify({
+					css: composition.css,
+					stylesheets: composition.stylesheets?.map(({ href, css }) => ({
+						href,
+						css
+					}))
+				}))}-`;
+				composition = await compose();
+				const assets = /* @__PURE__ */ new Map();
+				const addAsset = (href, bytes) => {
+					const target = fileURLToPath(new URL(href, pathToFileURL(outputPath)));
+					if (assets.has(target) && !assets.get(target).equals(bytes)) throw new Error(`Conflicting stylesheet assets: ${target}`);
+					assets.set(target, bytes);
+				};
+				for (const asset of composition.stylesheets || []) addAsset(asset.href, Buffer.from(asset.css));
+				for (const asset of composition.resources || []) addAsset(asset.href, readResource(asset.file));
+				const published = await withStylesheetPublicationLock(() => publishOwnedStylesheet(outputPath, composition.css, assets, outputFiles));
+				scanner.resetDependencies = [.../* @__PURE__ */ new Set([...scanner.resetDependencies, ...composition.dependencies || []])];
+				if (!watch || published || !reportedOutput) {
+					await reportExport(scanner, composition.css, output);
+					reportedOutput = true;
+				}
+			} else process.stdout.write(`${composition.css}\n`);
+		} finally {
+			revision = "";
+			resourceBytes = void 0;
+		}
+	};
+	await scanner.init();
+	const scanPaths = () => resolveSourcePaths(scanner, fg, sourcePatterns, specifiedSourcePaths.length ? [] : scanner.options.exclude, specifiedSourcePaths.length > 0).filter((file) => !options.export || !outputFiles.has(path.resolve(scanner.cwd, file)));
+	if (watch) {
+		const chokidar = await loadChokidar();
+		const watchers = [];
+		let pipelineReady = false;
+		let stopped = false;
+		let writing = Promise.resolve();
+		let planWatcher;
+		let sourceWatcher;
+		let sourceRefreshQueued = false;
+		let sourceRefreshRequested = false;
+		let watchedDependencies = /* @__PURE__ */ new Set();
+		const closeWatcher = async (watcher) => {
+			const index = watchers.indexOf(watcher);
+			if (index >= 0) watchers.splice(index, 1);
+			await watcher.close();
+		};
+		const closeWatchers = async () => {
+			await Promise.all(watchers.splice(0).map((watcher) => watcher.close()));
+		};
+		const shutdown = async () => {
+			stopped = true;
+			await writing;
+			await closeWatchers();
+			await scanner.dispose();
+			stylesheets.dispose();
+		};
+		const syncDependencies = async (dependencies) => {
+			if (stopped) return;
+			const next = new Set([...dependencies].map((file) => path.resolve(scanner.cwd, file)));
+			if (next.size === watchedDependencies.size && [...next].every((file) => watchedDependencies.has(file))) return;
+			const previous = planWatcher;
+			if (next.size) {
+				const plan = createDependencyWatchPlan(next);
+				planWatcher = chokidar.watch(plan.roots, {
+					ignoreInitial: true,
+					ignored: (file, stats) => options.export && outputFiles.has(path.resolve(scanner.cwd, file)) || plan.ignored(file, stats)
+				});
+				for (const event of [
+					"add",
+					"change",
+					"unlink"
+				]) planWatcher.on(event, (file) => {
+					if (!plan.matches(file) || options.export && outputFiles.has(path.resolve(scanner.cwd, file))) return;
+					if (scanner.options.verbose) process.stderr.write(`\n[change] ${formatWatchedPath(scanner.cwd, file)}\n`);
+					enqueue(() => rebuildDependency(file));
+				});
+				watchers.push(planWatcher);
+				await waitForWatcherReady(planWatcher);
+			} else planWatcher = void 0;
+			if (previous) {
+				watchers.splice(watchers.indexOf(previous), 1);
+				await previous.close();
+			}
+			watchedDependencies = next;
+		};
+		const rebuild = async (initial = false) => {
+			pipelineReady = false;
+			attemptedDependencies.clear();
+			missingDependencies.clear();
+			await prepareScanner(scanner, stylesheets, scanPaths(), delivery);
+			await writeOutput();
+			await syncDependencies([
+				...scanner.resetDependencies,
+				...scanner.sourcePolicyDependencies,
+				...attemptedDependencies
+			]);
+			pipelineReady = true;
+			missingDependencies.clear();
+			process.stderr.write(initial ? "\nStart watching source changes\n" : "\nRestart watching source changes\n");
+			if (!initial) scanner.emit("resetDependencyChange");
+		};
+		const enqueue = (operation) => {
+			writing = writing.then(async () => {
+				if (!stopped) await operation();
+			}).catch(async (error) => {
+				pipelineReady = false;
+				const missing = error?.path;
+				if (missing) attemptedDependencies.add(path.resolve(scanner.cwd, missing));
+				await syncDependencies([
+					...watchedDependencies,
+					...scanner.resetDependencies,
+					...attemptedDependencies
+				]);
+				process.stderr.write(`Cannot rebuild CSS: ${error}\n`);
+				if (!stopped && [...missingDependencies].some((file) => fs.existsSync(file))) enqueue(() => rebuild());
+			});
+			return writing;
+		};
+		const rebuildDependency = createDependencyRebuild(() => rebuild(), () => pipelineReady);
+		const sourcePlan = createSourceWatchPlan(fg, scanner.cwd, sourcePatterns, specifiedSourcePaths.length ? [] : scanner.options.exclude);
+		const startSourceWatcher = async (reconcile = false) => {
+			if (stopped) return;
+			if (!sourcePlan.roots.length) return;
+			const previous = sourceWatcher;
+			const next = chokidar.watch(sourcePlan.roots, {
+				cwd: scanner.cwd,
+				ignoreInitial: true,
+				ignored: (file, stats) => options.export && outputFiles.has(path.resolve(scanner.cwd, file)) || sourcePlan.ignored(file, stats)
+			});
+			const scanChangedSource = (file) => {
+				if (!sourcePlan.matches(file)) return;
+				const source = filesystemSourceIdentity(scanner.cwd, file);
+				enqueue(async () => {
+					if (!pipelineReady) return rebuild();
+					if (scanner.isSourceAllowed(source, { explicit: specifiedSourcePaths.length > 0 })) await scanSourceFile(scanner, source);
+					else scanner.removeSource(source);
+					await writeOutput();
+				});
+			};
+			next.on("add", scanChangedSource);
+			next.on("change", scanChangedSource);
+			next.on("unlink", (file) => {
+				if (!sourcePlan.matches(file)) return;
+				const source = filesystemSourceIdentity(scanner.cwd, file);
+				enqueue(async () => {
+					scanner.removeSource(source);
+					await writeOutput();
+				});
+			});
+			next.on("addDir", () => {
+				if (stopped || !sourceWatcher) return;
+				sourceRefreshRequested = true;
+				if (sourceRefreshQueued) return;
+				sourceRefreshQueued = true;
+				enqueue(async () => {
+					try {
+						while (sourceRefreshRequested && !stopped) {
+							sourceRefreshRequested = false;
+							await startSourceWatcher(true);
+						}
+					} finally {
+						sourceRefreshQueued = false;
+					}
+				});
+			});
+			watchers.push(next);
+			try {
+				await waitForWatcherReady(next);
+				if (stopped) return;
+				sourceWatcher = next;
+				if (reconcile) {
+					if (!pipelineReady) await rebuild();
+					else {
+						await scanSourceFiles(scanner, scanPaths());
+						await writeOutput();
+					}
+				}
+			} finally {
+				if (sourceWatcher !== next) await closeWatcher(next);
+				else if (previous) await closeWatcher(previous);
+			}
+		};
+		process.once("SIGTERM", () => {
+			shutdown().finally(() => process.exit(0));
+		});
+		process.once("SIGINT", () => {
+			shutdown().finally(() => process.exit(0));
+		});
+		try {
+			await pipelineModules;
+			await startSourceWatcher();
+			await enqueue(() => rebuild(true));
+		} catch (error) {
+			await shutdown();
+			throw error;
+		}
+	} else try {
+		await pipelineModules;
+		await prepareScanner(scanner, stylesheets, scanPaths(), delivery);
+		await writeOutput();
+	} finally {
+		await scanner.dispose();
+		stylesheets.dispose();
+	}
+}
+function loadCSSScanner() {
+	scannerModulePromise ||= import("@master/css-tooling/scanner/node").then((mod) => mod.MasterCSSScanner);
+	return scannerModulePromise;
+}
+function loadStylesheetModule() {
+	stylesheetModulePromise ||= import("@master/css-compiler/stylesheet");
+	return stylesheetModulePromise;
+}
+function loadProjectModule() {
+	projectModulePromise ||= import("@master/css-compiler/project");
+	return projectModulePromise;
+}
+function loadFastGlob() {
+	fastGlobModulePromise ||= import("fast-glob").then((mod) => mod.default || mod);
+	return fastGlobModulePromise;
+}
+function loadChokidar() {
+	chokidarModulePromise ||= import("chokidar").then((mod) => mod.default);
+	return chokidarModulePromise;
+}
+function loadBytes() {
+	bytesPromise ||= import("bytes").then((mod) => mod.default || mod);
+	return bytesPromise;
+}
+export { runGenerate as default };

package/dist/inspect.js

@@ -1,6 +1,10 @@
 import path from "node:path";
-import { createMasterCSSInspectionReport } from "@master/css-diagnostics";
-//#region src/inspect.ts
+import defaultManifestJSON from "@master/css-preset/default-manifest.json" with { type: "json" };
+import { captureMasterCSSProject, compareProjectSnapshots, createMasterCSSDesignSystemReport, createMasterCSSInspectionReport } from "@master/css-compiler/diagnostics";
+import fg from "fast-glob";
+import { readFile } from "node:fs/promises";
+// src/inspect.ts
+const defaultManifest = defaultManifestJSON;
 function parseMaxWarnings(value) {
 	if (value === void 0) return Number.POSITIVE_INFINITY;
 	const maxWarnings = Number(value);
@@ -17,22 +21,62 @@ function formatStylish(report) {
 	return `${lines.join("\n")}\n`;
 }
 function outputReport(report, format) {
-	if (format === "stylish") process.stdout.write(formatStylish(report));
-	else console.log(JSON.stringify(report, null, 2));
+	if (format === "stylish") process.stderr.write(formatStylish(report));
+	else process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
 }
 async function runInspect(specifiedSourcePaths = [], options = {}) {
 	const cwd = path.resolve(options.cwd || process.cwd());
 	const format = options.format || "json";
 	const exitCode = options.exitCode || "diagnostics";
-	const report = await createMasterCSSInspectionReport({
+	if (options.designSystemOptions && !options.designSystem) throw new Error("--design-system-options requires --design-system.");
+	if (options.designSystem) {
+		if (options.snapshot || options.compare || options.classes || options.includeCss) throw new Error("--design-system inspects the managed CSS graph; do not combine it with --classes, --include-css, --snapshot or --compare.");
+		const routeStylesheets = specifiedSourcePaths.length ? (await fg([...specifiedSourcePaths], {
+			cwd,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"]
+		})).sort() : [];
+		if (specifiedSourcePaths.length && !routeStylesheets.length) throw new Error(`No route stylesheet matched: ${specifiedSourcePaths.join(", ")}`);
+		const nonCSS = routeStylesheets.filter((file) => path.extname(file) !== ".css");
+		if (nonCSS.length) throw new Error(`--design-system source paths must be stylesheets: ${nonCSS.map((file) => path.relative(cwd, file)).join(", ")}`);
+		const designSystem = options.designSystemOptions ? JSON.parse(await readFile(path.resolve(cwd, options.designSystemOptions), "utf8")) : void 0;
+		if (options.designSystemOptions && (!designSystem || typeof designSystem !== "object" || Array.isArray(designSystem))) throw new TypeError("Design-system options must be a versioned JSON object.");
+		const report = await createMasterCSSDesignSystemReport({
+			manifest: defaultManifest,
+			cwd,
+			designSystem,
+			routeStylesheets
+		});
+		if (format === "stylish") {
+			const lines = [`Inspected ${report.summary.stylesheets} stylesheets (${report.project.routeStylesheets.length} route), ${report.summary.references} token references.`];
+			for (const item of report.diagnostics) lines.push(`${item.severity.toUpperCase()} ${item.code}${item.source ? ` ${item.source}` : ""}: ${item.message}`);
+			lines.push("Coverage: supplied project CSS; browser behavior not checked.");
+			process.stderr.write(`${lines.join("\n")}\n`);
+		} else process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+		if (exitCode !== "never" && (report.summary.errors || report.summary.warnings > parseMaxWarnings(options.maxWarnings))) process.exitCode = 1;
+		return report;
+	}
+	const inspectionOptions = {
+		manifest: defaultManifest,
 		cwd,
 		patterns: specifiedSourcePaths.length ? specifiedSourcePaths : void 0,
 		classes: options.classes,
 		includeCss: Boolean(options.includeCss)
-	});
+	};
+	if (options.snapshot || options.compare) {
+		if (options.snapshot && options.compare) throw new Error("Choose either --snapshot or --compare.");
+		const { snapshot } = await captureMasterCSSProject(inspectionOptions);
+		const result = options.compare ? await compareProjectSnapshots({
+			before: JSON.parse(await readFile(path.resolve(cwd, options.compare), "utf8")),
+			after: snapshot
+		}) : snapshot;
+		process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+		return result;
+	}
+	const report = await createMasterCSSInspectionReport(inspectionOptions);
 	outputReport(report, format);
 	if (exitCode !== "never" && (report.summary.errors || report.summary.warnings > parseMaxWarnings(options.maxWarnings))) process.exitCode = 1;
 	return report;
 }
-//#endregion
 export { runInspect as default };

package/dist/lint.js

@@ -1,12 +1,15 @@
 import fs from "node:fs";
 import path from "node:path";
-import { createCSSWithNativeDeclarations } from "@master/css-validator";
-import { fixMasterCSSContent, lintMasterCSSContent, resolveMasterCSSLintRules, summarizeMasterCSSLintFiles } from "@master/css-lint";
-import { loadProjectManifest } from "@master/css-project/manifest";
+import { loadProjectManifest } from "@master/css-compiler/project";
+import { createToolingSessionSync } from "@master/css-tooling/node";
+import defaultManifestJSON from "@master/css-preset/default-manifest.json" with { type: "json" };
 import fg from "fast-glob";
-//#region src/lint.ts
-const REPORT_VERSION = 1;
-const DEFAULT_SOURCE_PATTERNS = ["**/*.{html,htm,js,jsx,cjs,ts,tsx,mts,cts,svelte,astro,vue,md,mdx,pug,php,css,scss,less}"];
+import { fixMasterCSSContent, lintMasterCSSContent, resolveMasterCSSLintRules, summarizeMasterCSSLintFiles } from "@master/css-tooling/lint";
+import { SourcePolicy } from "@master/css-tooling/scanner/node";
+// src/lint.ts
+const REPORT_VERSION = 5;
+const defaultManifest = defaultManifestJSON;
+const DEFAULT_SOURCE_PATTERNS = ["**/*.{html,htm,js,mjs,jsx,cjs,ts,tsx,mts,cts,svelte,astro,vue,md,mdx,pug,php,css,scss,less}"];
 const DEFAULT_IGNORE_PATTERNS = ["**/node_modules/**", "node_modules"];
 function normalizeSourcePatterns(specifiedSourcePaths) {
 	return specifiedSourcePaths?.length ? specifiedSourcePaths : DEFAULT_SOURCE_PATTERNS;
@@ -59,17 +62,27 @@ function createManifestFileResult(cwd, diagnostics) {
 		diagnostics
 	};
 }
-function createReport(cwd, manifest, files) {
+function createReport(cwd, manifest, files, checkedFiles) {
+	const { files: _files, ...summary } = summarizeMasterCSSLintFiles(files);
 	return {
 		version: REPORT_VERSION,
 		cwd,
 		manifest,
 		files,
-		summary: summarizeMasterCSSLintFiles(files)
+		coverage: {
+			status: manifest.status === "error" ? "not-run" : checkedFiles.length ? "complete" : "no-inputs",
+			checkedFiles,
+			description: manifest.status === "error" ? "Source lint did not run because manifest loading failed. Manifest diagnostics are not checked source files." : checkedFiles.length ? "Source lint ran on every path in checkedFiles with the enabled rules. The files array lists only diagnostic results; an empty files array means those inputs produced no diagnostics. manifest.entries lists stylesheet entries used to load the manifest, not linted source inputs. Browser behavior is not checked." : "No source inputs matched, so source lint did not run. Zero diagnostics does not verify any source file or browser behavior."
+		},
+		summary: {
+			...summary,
+			checkedFiles: checkedFiles.length,
+			filesWithDiagnostics: files.filter((file) => file.sourceKind !== "manifest" && file.diagnostics.length).length
+		}
 	};
 }
 function formatStylish(report) {
-	const lines = [];
+	const lines = [report.coverage.status === "not-run" ? "Source lint checks did not run because the manifest could not be loaded." : report.coverage.status === "no-inputs" ? "No source inputs matched; no source lint checks ran." : `Checked ${report.summary.checkedFiles} source inputs; ${report.summary.filesWithDiagnostics} with diagnostics.`];
 	for (const result of report.files) {
 		if (!result.diagnostics.length) continue;
 		lines.push(result.filePath);
@@ -80,8 +93,8 @@ function formatStylish(report) {
 function outputReport(report, format) {
 	if (format === "stylish") {
 		const output = formatStylish(report);
-		if (output) process.stdout.write(output);
-	} else console.log(JSON.stringify(report, null, 2));
+		if (output) process.stderr.write(output);
+	} else process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
 }
 function resolveSourceInputs(cwd, specifiedSourcePaths, options) {
 	if (options.stdin) return [{
@@ -89,7 +102,10 @@ function resolveSourceInputs(cwd, specifiedSourcePaths, options) {
 		content: fs.readFileSync(0, "utf8"),
 		stdin: true
 	}];
-	return resolveSourcePaths(cwd, normalizeSourcePatterns(specifiedSourcePaths), specifiedSourcePaths.length ? [] : DEFAULT_IGNORE_PATTERNS).map((source) => {
+	const sourcePatterns = normalizeSourcePatterns(specifiedSourcePaths);
+	const explicit = specifiedSourcePaths.length > 0;
+	const policy = new SourcePolicy(cwd);
+	return resolveSourcePaths(cwd, sourcePatterns, explicit ? [] : DEFAULT_IGNORE_PATTERNS).filter((source) => policy.accepts(source, explicit)).map((source) => {
 		const filePath = path.resolve(cwd, source);
 		return {
 			filePath,
@@ -97,23 +113,22 @@ function resolveSourceInputs(cwd, specifiedSourcePaths, options) {
 		};
 	});
 }
-function lintInputs(inputs, css, rules) {
+function lintInputs(inputs, rules, lintSession) {
 	return inputs.map((input) => lintMasterCSSContent({
 		content: input.content,
 		filePath: input.filePath,
-		css,
-		rules
+		rules,
+		lintSession
 	})).filter((result) => result.diagnostics.length);
 }
-function applyFileFixes(inputs, css, rules, includeDirectiveFixes) {
+function applyFileFixes(inputs, rules, lintSession) {
 	for (const input of inputs) {
 		if (input.stdin) continue;
 		const fixed = fixMasterCSSContent({
 			content: input.content,
 			filePath: input.filePath,
-			css,
 			rules,
-			includeDirectiveFixes
+			lintSession
 		});
 		if (fixed !== input.content) {
 			fs.writeFileSync(input.filePath, fixed);
@@ -127,34 +142,41 @@ async function runLint(specifiedSourcePaths = [], options = {}) {
 	const exitCode = options.exitCode || "diagnostics";
 	const rules = resolveMasterCSSLintRules(options.rules);
 	const inputs = resolveSourceInputs(cwd, specifiedSourcePaths, options);
-	let manifest;
-	let files;
+	let manifestResult;
 	try {
-		const manifestResult = await loadProjectManifest(cwd);
-		const css = createCSSWithNativeDeclarations(manifestResult.manifest);
-		manifest = {
-			status: "loaded",
-			entries: manifestResult.entries,
-			diagnostics: []
-		};
-		files = lintInputs(inputs, css, rules);
-		if (options.fix && !options.fixDryRun) {
-			applyFileFixes(inputs, css, rules, Boolean(options.fixDirectives));
-			files = lintInputs(inputs, css, rules);
-		}
+		manifestResult = await loadProjectManifest({
+			root: cwd,
+			baseManifest: defaultManifest
+		});
 	} catch (error) {
 		const diagnostic = createManifestDiagnostic(cwd, error);
-		manifest = {
+		const report = createReport(cwd, {
 			status: "error",
 			entries: [],
 			diagnostics: [diagnostic]
-		};
-		files = [createManifestFileResult(cwd, [diagnostic])];
+		}, [createManifestFileResult(cwd, [diagnostic])], []);
+		outputReport(report, format);
+		if (exitCode !== "never") process.exitCode = 1;
+		return report;
+	}
+	const lintSession = createToolingSessionSync({ manifest: manifestResult.manifest });
+	let files;
+	try {
+		files = lintInputs(inputs, rules, lintSession);
+		if (options.fix && !options.fixDryRun) {
+			applyFileFixes(inputs, rules, lintSession);
+			files = lintInputs(inputs, rules, lintSession);
+		}
+	} finally {
+		lintSession.dispose();
 	}
-	const report = createReport(cwd, manifest, files);
+	const report = createReport(cwd, {
+		status: "loaded",
+		entries: [...manifestResult.entries],
+		diagnostics: []
+	}, files, inputs.map((input) => input.filePath));
 	outputReport(report, format);
 	if (exitCode !== "never" && (report.summary.errors || report.summary.warnings > parseMaxWarnings(options.maxWarnings))) process.exitCode = 1;
 	return report;
 }
-//#endregion
 export { runLint as default };