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

package/dist/publication-lock.js

@@ -0,0 +1,103 @@
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { platform, userInfo } from "node:os";
+import { mkdir, readFile, readdir, rename, unlink, writeFile } from "node:fs/promises";
+import { setTimeout } from "node:timers/promises";
+// src/publication-lock.ts
+const NAME = /^(\d+)-[a-f0-9-]+\.json$/;
+function missing(error) {
+	return error?.code === "ENOENT";
+}
+async function remove(file) {
+	try {
+		await withSharingRetry(() => unlink(file));
+	} catch (error) {
+		if (!missing(error)) throw error;
+	}
+}
+async function withSharingRetry(operation, deadline = performance.now() + 1e3) {
+	while (true) try {
+		return await operation();
+	} catch (error) {
+		const code = error.code;
+		if (platform() !== "win32" || ![
+			"EPERM",
+			"EACCES",
+			"EBUSY"
+		].includes(code ?? "") || performance.now() >= deadline) throw error;
+		await setTimeout(10);
+	}
+}
+function alive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code !== "ESRCH";
+	}
+}
+async function tickets(directory) {
+	const entries = [];
+	for (const id of await readdir(directory)) {
+		const register = id.endsWith(".next") ? id.slice(0, -5) : id;
+		const match = NAME.exec(register);
+		if (!match) continue;
+		const file = join(directory, register);
+		if (!alive(Number(match[1]))) {
+			await remove(file);
+			await remove(file + ".next");
+			continue;
+		}
+		if (id !== register) continue;
+		let text;
+		try {
+			text = await readFile(file, "utf8");
+		} catch (error) {
+			if (missing(error)) continue;
+			throw error;
+		}
+		const value = JSON.parse(text);
+		if (typeof value.choosing !== "boolean" || typeof value.number !== "string" || !/^\d+$/.test(value.number)) throw new Error(`Invalid CLI publication lock register: ${file}`);
+		entries.push({
+			id,
+			choosing: value.choosing,
+			number: BigInt(value.number)
+		});
+	}
+	return entries;
+}
+/** Serialize ownership, publication and cleanup across cooperating local CLI processes. */
+async function withStylesheetPublicationLock(work, options = {}) {
+	const directory = options.directory ?? join(userInfo().homedir, ".cache", "mastercss", "cli-publication-lock-v1");
+	const deadline = performance.now() + (options.timeout ?? 3e4);
+	const id = `${process.pid}-${randomUUID()}.json`;
+	const file = join(directory, id);
+	await mkdir(directory, {
+		recursive: true,
+		mode: 448
+	});
+	const publish = async (value) => {
+		await writeFile(file + ".next", JSON.stringify(value), { mode: 384 });
+		await withSharingRetry(() => rename(file + ".next", file), Math.min(deadline, performance.now() + 1e3));
+	};
+	try {
+		await publish({
+			choosing: true,
+			number: "0"
+		});
+		const number = (await tickets(directory)).reduce((max, peer) => peer.number > max ? peer.number : max, 0n) + 1n;
+		await publish({
+			choosing: false,
+			number: String(number)
+		});
+		while (true) {
+			if (performance.now() >= deadline) throw new Error("Timed out waiting for another stylesheet publication.");
+			if (!(await tickets(directory)).some((peer) => peer.id !== id && (peer.choosing || peer.number < number || peer.number === number && peer.id < id))) return await work();
+			await setTimeout(10);
+		}
+	} finally {
+		await remove(file);
+		await remove(file + ".next");
+	}
+}
+export { withStylesheetPublicationLock };

package/dist/publication.js

@@ -0,0 +1,109 @@
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { platform } from "node:os";
+// src/publication.ts
+function renameStylesheetFile(from, to) {
+	const deadline = performance.now() + 1e3;
+	let waitBuffer;
+	while (true) try {
+		fs.renameSync(from, to);
+		return;
+	} catch (error) {
+		const code = error.code;
+		if (platform() !== "win32" || ![
+			"EPERM",
+			"EACCES",
+			"EBUSY"
+		].includes(code ?? "") || performance.now() >= deadline) throw error;
+		waitBuffer ??= new Int32Array(new SharedArrayBuffer(4));
+		Atomics.wait(waitBuffer, 0, 0, Math.min(10, Math.max(0, deadline - performance.now())));
+	}
+}
+function matchesAsset(file, bytes) {
+	const stat = fs.lstatSync(file, { throwIfNoEntry: false });
+	if (!stat) return false;
+	if (!stat.isFile() || !fs.readFileSync(file).equals(bytes)) throw new Error(`Refusing to overwrite stylesheet asset: ${file}`);
+	return true;
+}
+function prepareTemporaryFile(target, bytes, outputFiles, mode) {
+	const temporary = path.join(path.dirname(target), `.master-css-${randomUUID()}.tmp`);
+	let descriptor;
+	let created = false;
+	outputFiles.add(temporary);
+	try {
+		descriptor = fs.openSync(temporary, "wx", mode ?? 438);
+		created = true;
+		if (mode !== void 0) fs.fchmodSync(descriptor, mode);
+		fs.writeFileSync(descriptor, bytes);
+		fs.closeSync(descriptor);
+		descriptor = void 0;
+		return temporary;
+	} catch (error) {
+		if (descriptor !== void 0) {
+			fs.closeSync(descriptor);
+			descriptor = void 0;
+		}
+		if (created) fs.rmSync(temporary, { force: true });
+		outputFiles.delete(temporary);
+		throw error;
+	} finally {
+		if (descriptor !== void 0) fs.closeSync(descriptor);
+	}
+}
+function removeTemporaryFile(file, outputFiles) {
+	try {
+		fs.rmSync(file, { force: true });
+	} finally {
+		outputFiles.delete(file);
+	}
+}
+function replaceStylesheetFile(file, bytes, outputFiles, mode) {
+	const temporary = prepareTemporaryFile(file, bytes, outputFiles, mode);
+	try {
+		renameStylesheetFile(temporary, file);
+	} finally {
+		removeTemporaryFile(temporary, outputFiles);
+	}
+}
+function resolveEntryTarget(file) {
+	for (let depth = 0; depth < 40; depth++) {
+		if (!fs.lstatSync(file, { throwIfNoEntry: false })?.isSymbolicLink()) return file;
+		file = path.resolve(path.dirname(file), fs.readlinkSync(file));
+	}
+	throw new Error("Too many symbolic links in stylesheet output path");
+}
+/** Publish immutable sidecars completely before atomically replacing the entry. */
+function publishStylesheet(entry, css, assets, outputFiles, journal) {
+	fs.mkdirSync(path.dirname(entry), { recursive: true });
+	const target = resolveEntryTarget(entry);
+	const previous = fs.statSync(target, { throwIfNoEntry: false });
+	if (previous) {
+		if (!previous.isFile()) throw new Error(`Stylesheet output is not a file: ${target}`);
+		fs.accessSync(target, fs.constants.W_OK);
+	}
+	outputFiles.add(target);
+	for (const [file, bytes] of assets) {
+		outputFiles.add(file);
+		if (file === target || file === entry) throw new Error(`Stylesheet asset collides with output: ${file}`);
+		matchesAsset(file, bytes);
+	}
+	const prepared = /* @__PURE__ */ new Map();
+	let entryTemporary;
+	try {
+		for (const [file, bytes] of assets) if (!matchesAsset(file, bytes)) prepared.set(file, prepareTemporaryFile(file, bytes, outputFiles));
+		entryTemporary = prepareTemporaryFile(target, Buffer.from(css), outputFiles, previous ? previous.mode & 511 : void 0);
+		journal?.beforePublish(prepared, entryTemporary);
+		for (const [file, temporary] of prepared) try {
+			fs.linkSync(temporary, file);
+		} catch (error) {
+			if (error.code !== "EEXIST" || !matchesAsset(file, assets.get(file))) throw error;
+		}
+		renameStylesheetFile(entryTemporary, target);
+		journal?.afterPublish();
+	} finally {
+		for (const temporary of prepared.values()) removeTemporaryFile(temporary, outputFiles);
+		if (entryTemporary) removeTemporaryFile(entryTemporary, outputFiles);
+	}
+}
+export { publishStylesheet, replaceStylesheetFile, resolveEntryTarget };

package/dist/source-watch.js

@@ -0,0 +1,41 @@
+import fs from "node:fs";
+import path from "node:path";
+// src/source-watch.ts
+const normalize = (value) => value.replace(/\\/g, "/");
+function createSourceWatchPlan(fg, cwd, patterns, ignore = []) {
+	const tasks = fg.generateTasks(patterns.map(normalize), {
+		cwd,
+		ignore: ignore.map(normalize)
+	});
+	const bases = tasks.map((task) => path.resolve(cwd, task.base));
+	const match = (file, pattern) => {
+		const absolute = normalize(path.resolve(cwd, file));
+		const candidate = /[/\\]$/.test(file) && !absolute.endsWith("/") ? absolute + "/" : absolute;
+		return path.matchesGlob(candidate, normalize(path.resolve(cwd, pattern)));
+	};
+	const excluded = (file) => tasks.length > 0 && tasks.every((task) => task.negative.some((pattern) => match(file, pattern)));
+	const matches = (file) => tasks.some((task) => task.positive.some((pattern) => match(file, pattern)) && !task.negative.some((pattern) => match(file, pattern)));
+	const contains = (parent, child) => {
+		const relative = path.relative(parent, child);
+		return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
+	};
+	const roots = [...new Set(bases.map((base) => {
+		while (!fs.existsSync(base) || !fs.statSync(base).isDirectory()) {
+			const parent = path.dirname(base);
+			if (parent === base) break;
+			base = parent;
+		}
+		return base;
+	}))];
+	return {
+		roots: roots.filter((root) => !roots.some((other) => other !== root && contains(other, root))),
+		matches,
+		ignored(file, stats) {
+			const absolute = path.resolve(cwd, file);
+			if (excluded(absolute) || stats?.isDirectory() && excluded(absolute + path.sep)) return true;
+			if (stats?.isDirectory()) return !bases.some((base) => contains(base, absolute) || contains(absolute, base));
+			return stats?.isFile() ? !matches(absolute) : false;
+		}
+	};
+}
+export { createSourceWatchPlan };

package/dist/suggest.js

@@ -0,0 +1,70 @@
+import fs from "node:fs";
+import path from "node:path";
+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" };
+// src/suggest.ts
+async function runSuggest(declarations, options = {}) {
+	const report = {
+		version: 1,
+		cwd: path.resolve(options.cwd || process.cwd()),
+		manifest: {
+			status: "not-loaded",
+			entries: []
+		},
+		result: null,
+		validation: [],
+		diagnostics: []
+	};
+	let failureCode = "SUGGEST_INPUT_ERROR";
+	try {
+		if (options.stdin ? declarations !== void 0 : declarations === void 0) throw new Error("Provide either a declaration argument or --stdin, but not both.");
+		const input = options.stdin ? fs.readFileSync(0, "utf8") : declarations;
+		if (!input.trim()) throw new Error("The declaration block must not be empty.");
+		if (!fs.statSync(report.cwd).isDirectory()) throw new Error("The project root must be a directory.");
+		failureCode = "PROJECT_MANIFEST_LOAD_ERROR";
+		const project = await loadProjectManifest({
+			root: report.cwd,
+			baseManifest: defaultManifestJSON
+		});
+		report.manifest = {
+			status: "loaded",
+			entries: project.entries
+		};
+		report.diagnostics.push(...project.diagnostics);
+		failureCode = "SUGGEST_EXECUTION_ERROR";
+		using session = createToolingSessionSync({ manifest: project.manifest });
+		report.result = session.suggestClasses(input);
+		for (const className of report.result.classes) {
+			const inspection = session.inspectClassName(className);
+			const { matchStatus, cssSyntaxStatus, cssValueStatus, browserSupport } = inspection;
+			report.validation.push({
+				className,
+				matchStatus,
+				cssSyntaxStatus,
+				cssValueStatus,
+				browserSupport
+			});
+			report.diagnostics.push(...(inspection.diagnostics || []).map((diagnostic) => ({
+				...diagnostic,
+				className
+			})));
+		}
+	} catch (error) {
+		if (failureCode === "PROJECT_MANIFEST_LOAD_ERROR") report.manifest.status = "error";
+		report.result = null;
+		report.validation = [];
+		report.diagnostics.push({
+			code: failureCode,
+			severity: "error",
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+	for (const diagnostic of report.diagnostics) if (diagnostic.severity === "error") {
+		process.stderr.write(`${diagnostic.code}: ${diagnostic.message}\n`);
+		process.exitCode = 1;
+	}
+	process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+	return report;
+}
+export { runSuggest as default };

package/package.json

@@ -1,60 +1,56 @@
 {
-  "name": "@master/css-cli",
-  "type": "module",
-  "license": "MIT",
-  "description": "Master CSS CLI",
-  "author": "Aoyue Design LLC.",
-  "funding": "https://rc.css.master.co/sponsor",
-  "homepage": "https://css.master.co",
-  "bugs": {
-    "url": "https://github.com/master-co/css/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/master-co/css.git",
-    "directory": "packages/cli"
-  },
-  "keywords": [
-    "cli",
-    "css",
-    "mastercss"
-  ],
-  "files": [
-    "dist"
-  ],
-  "publishConfig": {
-    "access": "public",
-    "provenance": true
-  },
-  "dependencies": {
-    "bytes": "^3.1.2",
-    "chokidar": "^5.0.0",
-    "commander": "^14.0.3",
-    "consola": "^3.4.2",
-    "fast-glob": "^3.3.3",
-    "@master/css": "^2.0.0-rc.88",
-    "@master/css-diagnostics": "^2.0.0-rc.88",
-    "@master/css-language": "^2.0.0-rc.88",
-    "@master/css-lexer": "^2.0.0-rc.88",
-    "@master/css-lint": "^2.0.0-rc.88",
-    "@master/css-project": "^2.0.0-rc.88",
-    "@master/css-scanner": "^2.0.0-rc.88",
-    "@master/css-stylesheet": "^2.0.0-rc.88",
-    "@master/css-validator": "^2.0.0-rc.88"
-  },
-  "devDependencies": {
-    "@types/bytes": "^3.1.5",
-    "upath": "^2.0.1"
-  },
-  "version": "2.0.0-rc.88",
-  "scripts": {
-    "build": "tsdown --config ../../shared/tsdown-package.config.ts",
-    "dev": "tsdown --config ../../shared/tsdown-package.config.ts --watch",
-    "lint": "eslint",
-    "type-check": "tsc -b tsconfig.typecheck.json",
-    "test": "vitest"
-  },
-  "bin": {
-    "css-cli": "./dist/bin/index.js"
-  }
-}
+    "name": "@master/css-cli",
+    "scripts": {
+        "build": "bun --bun tsdown --config ../../shared/tsdown-package.config.ts",
+        "dev": "bun --bun tsdown --config ../../shared/tsdown-package.config.ts --watch",
+        "lint": "bun --bun eslint",
+        "type-check": "bun --bun tsc -b tsconfig.typecheck.json",
+        "test": "node ../../node_modules/vitest/vitest.mjs run"
+    },
+    "type": "module",
+    "engines": {
+        "node": "^24"
+    },
+    "license": "MIT",
+    "description": "Master CSS CLI",
+    "author": "Aoyue Design LLC.",
+    "homepage": "https://css.master.co",
+    "bugs": {
+        "url": "https://github.com/master-co/css/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/master-co/css.git",
+        "directory": "packages/cli"
+    },
+    "keywords": [
+        "cli",
+        "css",
+        "mastercss"
+    ],
+    "bin": {
+        "master-css": "./dist/bin/index.js"
+    },
+    "exports": {},
+    "sideEffects": false,
+    "files": [
+        "dist"
+    ],
+    "publishConfig": {
+        "access": "public",
+        "provenance": true
+    },
+    "dependencies": {
+        "@master/css": "2.0.0",
+        "@master/css-compiler": "2.0.0",
+        "@master/css-preset": "2.0.0",
+        "@master/css-schema": "2.0.0",
+        "@master/css-tooling": "2.0.0",
+        "bytes": "^3.1.2",
+        "chokidar": "^5.0.0",
+        "commander": "^15.0.0",
+        "fast-glob": "^3.3.3"
+    },
+    "version": "2.0.0",
+    "gitHead": "6bf9adc4432b67e62613caea59d3b554711b4d54"
+}

package/LICENSE

@@ -1,21 +0,0 @@
-The MIT License
-
-Copyright (c) Aoyue Design LLC.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

package/dist/scan.js

@@ -1,199 +0,0 @@
-import { DEFAULT_SCAN_OUTPUT } from "./constants.js";
-import fs from "node:fs";
-import path from "node:path";
-//#region src/scan.ts
-const DEFAULT_SOURCE_PATTERNS = ["**/*.{html,htm,js,jsx,cjs,ts,tsx,mts,cts,svelte,astro,vue,md,mdx,pug,php}"];
-let scannerModulePromise;
-let stylesheetModulePromise;
-let projectEntriesModulePromise;
-let fastGlobModulePromise;
-let chokidarModulePromise;
-let loggerPromise;
-let bytesPromise;
-async function registerManagedCSSEntries(scanner, styleCSSSources) {
-	const [{ registerStyleCSSSource }, { findCSSManifestEntryFiles }] = await Promise.all([loadStylesheetModule(), loadProjectEntriesModule()]);
-	styleCSSSources.clear();
-	for (const entry of await findCSSManifestEntryFiles(scanner.cwd)) await registerStyleCSSSource(scanner, styleCSSSources, entry, fs.readFileSync(entry, "utf8"), { projectDir: scanner.cwd });
-	scanner.resetDependencies = [...new Set(Array.from(styleCSSSources.values()).flatMap((source) => source.dependencies))];
-}
-function normalizeSourcePatterns(specifiedSourcePaths) {
-	return specifiedSourcePaths?.length ? specifiedSourcePaths : DEFAULT_SOURCE_PATTERNS;
-}
-function normalizeGlobPatterns(patterns) {
-	return patterns.map((pattern) => pattern.replace(/\\/g, "/"));
-}
-function resolveSourcePaths(scanner, fg, sourcePatterns, ignore = []) {
-	return fg.sync(normalizeGlobPatterns(sourcePatterns), {
-		cwd: scanner.cwd,
-		ignore: normalizeGlobPatterns(ignore)
-	}).filter(Boolean);
-}
-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 Promise.all(sourcePaths.map((source) => scanSourceFile(scanner, source)));
-}
-async function prepareScanner(scanner, styleCSSSources, sourcePaths) {
-	await registerManagedCSSEntries(scanner, styleCSSSources);
-	await scanSourceFiles(scanner, sourcePaths);
-}
-async function exportCSS(scanner, css, filename = DEFAULT_SCAN_OUTPUT) {
-	const filepath = path.resolve(scanner.cwd, filename);
-	const dir = path.dirname(filepath);
-	if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-	fs.writeFileSync(filepath, css);
-	if (scanner.options.verbose) {
-		const [logger, bytes] = await Promise.all([loadLogger(), loadBytes()]);
-		logger.success(`${filename} exported ${bytes(css.length)}`);
-	}
-	scanner.emit("export", filename, filepath);
-}
-function formatWatchedPath(cwd, file) {
-	return path.isAbsolute(file) ? path.relative(cwd, file) : file;
-}
-async function waitForWatcherReady(watcher) {
-	await new Promise((resolve) => watcher.once("ready", resolve));
-	await new Promise((resolve) => setTimeout(resolve, 0));
-}
-async function runScan(specifiedSourcePaths = [], options = {}) {
-	const pipelineModules = Promise.all([loadStylesheetModule(), loadProjectEntriesModule()]);
-	const [CSSScanner, fg] = await Promise.all([loadCSSScanner(), loadFastGlob()]);
-	const { watch, output, verbose, cwd } = options;
-	const scanner = new CSSScanner({}, cwd);
-	const styleCSSSources = /* @__PURE__ */ new Map();
-	const sourcePatterns = normalizeSourcePatterns(specifiedSourcePaths);
-	const writeOutput = async () => {
-		const { createExtractedCSS } = await loadStylesheetModule();
-		const css = await createExtractedCSS({
-			scanner,
-			styleCSSSources,
-			projectDir: scanner.cwd
-		});
-		if (options.export) await exportCSS(scanner, css, output);
-		else console.log(css);
-	};
-	scanner.on("init", (options) => {
-		if (!specifiedSourcePaths.length) {
-			if (!options.exclude?.includes("**/node_modules/**")) options.exclude?.push("**/node_modules/**");
-			if (!options.exclude?.includes("node_modules")) options.exclude?.push("node_modules");
-		}
-		options.verbose = verbose ? +verbose : options.verbose;
-	});
-	await scanner.init();
-	const scanPaths = () => resolveSourcePaths(scanner, fg, sourcePatterns, specifiedSourcePaths.length ? [] : scanner.options.exclude);
-	if (watch) {
-		const chokidar = await loadChokidar();
-		const watchers = [];
-		let restarting = false;
-		let writing = Promise.resolve();
-		const queueWrite = () => {
-			writing = writing.then(writeOutput);
-			return writing;
-		};
-		const closeWatchers = async () => {
-			await Promise.all(watchers.splice(0).map((watcher) => watcher.close()));
-		};
-		const startWatchers = async () => {
-			const sourcePaths = scanPaths();
-			if (sourcePaths.length) {
-				const sourceWatcher = chokidar.watch(sourcePaths, {
-					cwd: scanner.cwd,
-					ignoreInitial: true
-				});
-				sourceWatcher.on("add", (source) => {
-					scanSourceFile(scanner, source).then(queueWrite);
-				});
-				sourceWatcher.on("change", (source) => {
-					scanSourceFile(scanner, source).then(queueWrite);
-				});
-				watchers.push(sourceWatcher);
-				await waitForWatcherReady(sourceWatcher);
-			}
-			if (scanner.resetDependencies.length) {
-				const planWatcher = chokidar.watch(scanner.resetDependencies, { ignoreInitial: true });
-				const handlePlanChange = async (resetDependency) => {
-					if (restarting) return;
-					restarting = true;
-					try {
-						if (scanner.options.verbose) {
-							const logger = await loadLogger();
-							logger.log("");
-							logger.info(`[change] ${formatWatchedPath(scanner.cwd, resetDependency)}`);
-						}
-						await closeWatchers();
-						await scanner.reset(scanner.customOptions, { emit: false });
-						await prepareScanner(scanner, styleCSSSources, scanPaths());
-						await queueWrite();
-						await startWatchers();
-						const logger = await loadLogger();
-						logger.log("");
-						logger.info("Restart watching source changes");
-						scanner.emit("resetDependencyChange");
-					} finally {
-						restarting = false;
-					}
-				};
-				planWatcher.on("add", (resetDependency) => {
-					handlePlanChange(resetDependency);
-				});
-				planWatcher.on("change", (resetDependency) => {
-					handlePlanChange(resetDependency);
-				});
-				planWatcher.on("unlink", (resetDependency) => {
-					handlePlanChange(resetDependency);
-				});
-				watchers.push(planWatcher);
-				await waitForWatcherReady(planWatcher);
-			}
-		};
-		process.once("SIGTERM", () => {
-			closeWatchers().finally(() => process.exit(0));
-		});
-		process.once("SIGINT", () => {
-			closeWatchers().finally(() => process.exit(0));
-		});
-		await pipelineModules;
-		await prepareScanner(scanner, styleCSSSources, scanPaths());
-		await queueWrite();
-		await startWatchers();
-		const logger = await loadLogger();
-		logger.log("");
-		logger.info("Start watching source changes");
-	} else {
-		await pipelineModules;
-		await prepareScanner(scanner, styleCSSSources, scanPaths());
-		await writeOutput();
-	}
-}
-function loadCSSScanner() {
-	scannerModulePromise ||= import("@master/css-scanner").then((mod) => mod.default);
-	return scannerModulePromise;
-}
-function loadStylesheetModule() {
-	stylesheetModulePromise ||= import("@master/css-stylesheet");
-	return stylesheetModulePromise;
-}
-function loadProjectEntriesModule() {
-	projectEntriesModulePromise ||= import("@master/css-project/entries");
-	return projectEntriesModulePromise;
-}
-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 loadLogger() {
-	loggerPromise ||= import("consola").then(({ createConsola }) => createConsola({ level: 3 }));
-	return loggerPromise;
-}
-function loadBytes() {
-	bytesPromise ||= import("bytes").then((mod) => mod.default || mod);
-	return bytesPromise;
-}
-//#endregion
-export { runScan as default };