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

package/dist/node-imports.js

@@ -0,0 +1,253 @@
+import { createRequire } from "node:module";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { dirname, extname, isAbsolute, relative, resolve } from "node:path";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+// src/node-imports.ts
+/** @internal Node filesystem and package inputs for the Rust import graph. */
+const require = createRequire(import.meta.url);
+const MASTER_CSS_PACKAGE_IDS = /* @__PURE__ */ new Set(["@master/css", "@master/css-preset"]);
+function normalizeStylesheetGraphID(id) {
+	return id.startsWith("\0") ? id : resolve(id);
+}
+function isExpandableImportSource(source, fromFile) {
+	if (source.startsWith("/") || /^[a-z][a-z\d+.-]*:/i.test(source)) return false;
+	if (extname(decodeURIComponent(new URL(source, "file:///").pathname)).toLowerCase() !== ".css") return false;
+	return source.startsWith("./") || source.startsWith("../") || existsSync(resolveRelativeCSSFile(source, fromFile));
+}
+function resolveRelativeCSSFile(source, fromFile) {
+	return fileURLToPath(new URL(source, pathToFileURL(fromFile)));
+}
+function readJSONFile(file) {
+	return JSON.parse(readFileSync(file, "utf-8"));
+}
+function findPackageRoot(entryFile, packageName) {
+	let directory = dirname(entryFile);
+	while (true) {
+		const packageJSONFile = resolve(directory, "package.json");
+		if (existsSync(packageJSONFile)) try {
+			const packageJSON = readJSONFile(packageJSONFile);
+			if (packageJSON.name === packageName) return {
+				directory,
+				packageJSON
+			};
+		} catch {}
+		const parentDirectory = dirname(directory);
+		if (parentDirectory === directory) return;
+		directory = parentDirectory;
+	}
+}
+/**
+* Package file identity survives checkout, installation and publication paths:
+* the nearest named package plus the package-relative path. Keyframe IDs hash
+* this owner into delivered CSS, so absolute paths remain only without a name.
+*/
+function stylesheetResourceOwner(file) {
+	if (!isAbsolute(file)) return file;
+	try {
+		file = realpathSync(file);
+	} catch {}
+	let directory = dirname(file);
+	while (true) {
+		const manifest = resolve(directory, "package.json");
+		if (existsSync(manifest)) try {
+			const { name } = readJSONFile(manifest);
+			if (typeof name === "string" && name) return `${name}/${relative(directory, file).replace(/\\/g, "/")}`;
+		} catch {}
+		const parent = dirname(directory);
+		if (parent === directory) return file;
+		directory = parent;
+	}
+}
+function resolvePackageDirectory(directory) {
+	try {
+		return realpathSync(directory);
+	} catch {
+		return directory;
+	}
+}
+function findNodeModulesPackageRoot(baseDirectory, packageName) {
+	let directory = resolve(baseDirectory);
+	const packagePath = packageName.split("/");
+	while (true) {
+		const packageJSONFile = resolve(directory, "node_modules", ...packagePath, "package.json");
+		if (existsSync(packageJSONFile)) try {
+			const packageJSON = readJSONFile(packageJSONFile);
+			if (packageJSON.name === packageName) return {
+				directory: resolvePackageDirectory(dirname(packageJSONFile)),
+				packageJSON
+			};
+		} catch {}
+		const parentDirectory = dirname(directory);
+		if (parentDirectory === directory) return;
+		directory = parentDirectory;
+	}
+}
+function resolvePackageRoot(packageName, fromFile, projectDir) {
+	const resolvedFromFile = resolve(projectDir || "", fromFile);
+	const searchDirectories = [
+		projectDir,
+		resolvedFromFile,
+		dirname(resolvedFromFile),
+		process.cwd()
+	].filter((directory) => typeof directory === "string");
+	for (const directory of new Set(searchDirectories)) {
+		const packageRoot = findNodeModulesPackageRoot(directory, packageName);
+		if (packageRoot) return packageRoot;
+	}
+	const resolver = createProjectRequire(fromFile, projectDir);
+	let packageEntryFile;
+	try {
+		packageEntryFile = resolver.resolve(packageName);
+	} catch {
+		packageEntryFile = require.resolve(
+			/* webpackIgnore: true */
+			packageName
+		);
+	}
+	return findPackageRoot(packageEntryFile, packageName);
+}
+function getPackageStyleEntry(packageJSON) {
+	if (typeof packageJSON.style === "string") return packageJSON.style;
+	if (!packageJSON.exports || typeof packageJSON.exports !== "object") return;
+	const rootExport = packageJSON.exports["."];
+	if (!rootExport || typeof rootExport !== "object") return;
+	const styleExport = rootExport.style;
+	return typeof styleExport === "string" ? styleExport : void 0;
+}
+function createProjectRequire(fromFile, projectDir) {
+	return createRequire(resolve(projectDir || dirname(fromFile), "package.json"));
+}
+function resolveMasterCSSPackageEntryFile(importSource, fromFile = process.cwd(), projectDir) {
+	if (!MASTER_CSS_PACKAGE_IDS.has(importSource)) return;
+	const packageRoot = resolvePackageRoot(importSource, fromFile, projectDir);
+	if (!packageRoot) return;
+	const styleEntry = getPackageStyleEntry(packageRoot.packageJSON);
+	if (!styleEntry) return;
+	const styleFile = resolve(packageRoot.directory, styleEntry);
+	if (!existsSync(styleFile)) throw new Error(`${importSource} CSS style entry was not found: ${styleFile}`);
+	return styleFile;
+}
+function resolveNodePackageCSS(importSource, fromFile) {
+	if (importSource.startsWith(".") || importSource.startsWith("/") || /^[a-z][a-z\d+.-]*:/i.test(importSource)) return;
+	try {
+		const file = createRequire(fromFile).resolve(importSource);
+		if (extname(file).toLowerCase() === ".css") return file;
+	} catch {}
+}
+/** A bare alias is not package ownership; verify the resolved file's package root. */
+function isResolvedPackageCSS(specifier, importer, file, projectDir) {
+	if (specifier.startsWith(".") || specifier.startsWith("/") || /^[a-z][a-z\d+.-]*:/i.test(specifier)) return false;
+	const packageName = specifier.split("/").slice(0, specifier.startsWith("@") ? 2 : 1).join("/");
+	try {
+		const root = resolvePackageRoot(packageName, importer, projectDir);
+		if (!root) return false;
+		const path = relative(resolvePackageDirectory(root.directory), resolvePackageDirectory(file));
+		return path !== ".." && !path.startsWith("../") && !path.startsWith("..\\") && !isAbsolute(path);
+	} catch {
+		return false;
+	}
+}
+function resolvePreparedImport(importSource, file, options) {
+	const packageFile = options.expandPackageImports !== false ? resolveMasterCSSPackageEntryFile(importSource, file, options.projectDir) : void 0;
+	const nodePackageFile = !packageFile && options.resolveNodePackageImports ? resolveNodePackageCSS(importSource, file) : void 0;
+	if (packageFile || nodePackageFile || isExpandableImportSource(importSource, file)) return {
+		file: packageFile || nodePackageFile || resolveRelativeCSSFile(importSource, file),
+		packageCSS: Boolean(nodePackageFile)
+	};
+}
+function prepareCSSImportGraphFile(file, graph, visited, options, sourceOverride, analyzeDependencies, packageCSS = false) {
+	const absoluteFile = resolve(file);
+	options.onDependency?.(absoluteFile);
+	if (packageCSS && !graph.packageFiles?.includes(absoluteFile)) (graph.packageFiles ??= []).push(absoluteFile);
+	if (sourceOverride === void 0 && !existsSync(absoluteFile)) throw new Error(`CSS file not found: ${absoluteFile}`);
+	if (visited.has(absoluteFile)) return;
+	visited.add(absoluteFile);
+	const source = sourceOverride ?? readFileSync(absoluteFile, "utf-8");
+	graph.files[absoluteFile] = source;
+	(graph.resourceOwners ??= {})[absoluteFile] = stylesheetResourceOwner(absoluteFile);
+	const analysis = analyzeDependencies(source);
+	for (const importStatement of analysis.imports) {
+		const importSource = importStatement.source;
+		const imported = resolvePreparedImport(importSource, absoluteFile, options);
+		if (imported) {
+			const importedFile = imported.file;
+			graph.edges.push({
+				from: absoluteFile,
+				specifier: importSource,
+				resolved: importedFile
+			});
+			prepareCSSImportGraphFile(importedFile, graph, visited, options, void 0, analyzeDependencies, packageCSS || imported.packageCSS);
+		}
+	}
+}
+function prepareCSSImportGraph(file, source, options, analyzeDependencies) {
+	const graph = {
+		entry: resolve(file),
+		files: {},
+		edges: []
+	};
+	prepareCSSImportGraphFile(graph.entry, graph, /* @__PURE__ */ new Set(), options, source, analyzeDependencies);
+	return graph;
+}
+/** Async build-host file resolution, sharing Node fallback and Rust dependency analysis. */
+async function prepareCSSImportGraphWithResolver(file, source, options, analyzeDependencies, resolveImport) {
+	const graph = {
+		entry: normalizeStylesheetGraphID(file),
+		files: {},
+		edges: []
+	};
+	if (options.sourceMap) graph.sourceMaps = { [graph.entry]: options.sourceMap };
+	if (options.baseFile) {
+		if (!isAbsolute(options.baseFile)) throw new TypeError("A stylesheet source baseFile must be an absolute filesystem path.");
+		graph.baseFiles = { [graph.entry]: options.baseFile };
+	}
+	const pending = [{
+		file: graph.entry,
+		source,
+		packageCSS: false
+	}];
+	const visited = /* @__PURE__ */ new Set();
+	while (pending.length) {
+		options.signal?.throwIfAborted();
+		const item = pending.pop();
+		options.onDependency?.(item.file);
+		if (item.packageCSS && !graph.packageFiles?.includes(item.file)) (graph.packageFiles ??= []).push(item.file);
+		if (visited.has(item.file)) continue;
+		visited.add(item.file);
+		const text = item.source ?? readFileSync(item.file, "utf8");
+		graph.files[item.file] = text;
+		(graph.resourceOwners ??= {})[item.file] = stylesheetResourceOwner(graph.baseFiles?.[item.file] ?? item.file);
+		const children = [];
+		for (const { source: specifier } of analyzeDependencies(text).imports) {
+			const resolved = await resolveImport(specifier, item.file);
+			options.signal?.throwIfAborted();
+			if (resolved === null) continue;
+			const supplied = typeof resolved === "object" ? resolved : void 0;
+			const id = supplied?.id ?? resolved;
+			if (typeof id === "string" && !isAbsolute(id) && !(supplied && id.startsWith("\0"))) throw new TypeError("A stylesheet import resolver must return an absolute filesystem path or a source with a virtual ID.");
+			if (supplied?.baseFile && !isAbsolute(supplied.baseFile)) throw new TypeError("A stylesheet source baseFile must be an absolute filesystem path.");
+			const importer = graph.baseFiles?.[item.file] ?? item.file;
+			const owner = supplied?.baseFile ?? id;
+			const imported = resolved === void 0 ? resolvePreparedImport(specifier, importer, options) : {
+				file: normalizeStylesheetGraphID(id),
+				packageCSS: isAbsolute(owner) && isResolvedPackageCSS(specifier, importer, owner, options.projectDir)
+			};
+			if (!imported) continue;
+			if (supplied?.baseFile) (graph.baseFiles ??= {})[imported.file] = supplied.baseFile;
+			if (supplied?.sourceMap) (graph.sourceMaps ??= {})[imported.file] = supplied.sourceMap;
+			graph.edges.push({
+				from: item.file,
+				specifier,
+				resolved: imported.file
+			});
+			children.push({
+				file: imported.file,
+				source: supplied?.source,
+				packageCSS: item.packageCSS || imported.packageCSS
+			});
+		}
+		pending.push(...children.reverse());
+	}
+	return graph;
+}
+export { isExpandableImportSource, normalizeStylesheetGraphID, prepareCSSImportGraph, prepareCSSImportGraphWithResolver, resolveMasterCSSPackageEntryFile, resolveNodePackageCSS, resolveRelativeCSSFile, stylesheetResourceOwner };

package/dist/node.d.ts

@@ -0,0 +1,21 @@
+import { MasterCSSCompileManifestOptions, MasterCSSCompileManifestOptions as MasterCSSCompileManifestOptions$1, MasterCSSCompileManifestResult, MasterCSSCompileManifestResult as MasterCSSCompileManifestResult$1, MasterCSSCompileOptions, MasterCSSCompileResult, MasterCSSCompileStylesheetsRequest, MasterCSSCompileStylesheetsResult, MasterCSSCompileStylesheetsResult as MasterCSSCompileStylesheetsResult$1, MasterCSSCompilerInspection, MasterCSSPrepareStylesheetBundleRequest, MasterCSSRenderStylesheetBundleRequest, MasterCSSStylesheetAsset, MasterCSSStylesheetBundle } from "./index.js";
+import { MasterCSSCompiler } from "./compiler.js";
+import { StylesheetDeliveryOptions, StylesheetResourceAsset } from "./stylesheet/delivery.js";
+import { MasterCSSStylesheetDependencies, MasterCSSStylesheetDependencyOptions, MasterCSSStylesheetHostOptions, MasterCSSStylesheetResolution, MasterCSSStylesheetResolutionOptions, collectStylesheetDependenciesSync, composeStylesheetHostSync, resolveStylesheetDependenciesSync, resolveStylesheetSync } from "./stylesheet/public.js";
+interface MasterCSSCompileManifestFileOptions extends MasterCSSCompileManifestOptions$1 {
+  readonly root?: string;
+}
+interface MasterCSSCompileManifestFileDeliveryOptions extends MasterCSSCompileManifestFileOptions {
+  readonly delivery: StylesheetDeliveryOptions;
+}
+interface MasterCSSCompileManifestFileResult extends MasterCSSCompileStylesheetsResult$1 {
+  /** Copy these files to their hrefs before publishing the entry stylesheet. */
+  readonly resources: readonly Readonly<StylesheetResourceAsset>[];
+}
+declare function createCompilerSync(): MasterCSSCompiler;
+declare function inspectCSSSync(source: string): import("./index.js").MasterCSSCompilerInspection;
+declare function compileCSSSync(source: string, options?: import('./index.js').MasterCSSCompileOptions): import("./index.js").MasterCSSCompileResult;
+declare function compileManifestSync(source: string, options: import('./index.js').MasterCSSCompileManifestOptions): MasterCSSCompileManifestResult$1;
+declare function compileManifestFileSync(file: string, options: MasterCSSCompileManifestFileDeliveryOptions): MasterCSSCompileManifestFileResult;
+declare function compileManifestFileSync(file: string, options: MasterCSSCompileManifestFileOptions): MasterCSSCompileManifestResult$1;
+export { MasterCSSCompileManifestFileDeliveryOptions, MasterCSSCompileManifestFileOptions, MasterCSSCompileManifestFileResult, type MasterCSSCompileManifestOptions, type MasterCSSCompileManifestResult, type MasterCSSCompileOptions, type MasterCSSCompileResult, type MasterCSSCompileStylesheetsRequest, type MasterCSSCompileStylesheetsResult, type MasterCSSCompilerInspection, type MasterCSSPrepareStylesheetBundleRequest, type MasterCSSRenderStylesheetBundleRequest, type MasterCSSStylesheetAsset, type MasterCSSStylesheetBundle, type MasterCSSStylesheetDependencies, type MasterCSSStylesheetDependencyOptions, type MasterCSSStylesheetHostOptions, type MasterCSSStylesheetResolution, type MasterCSSStylesheetResolutionOptions, collectStylesheetDependenciesSync, compileCSSSync, compileManifestFileSync, compileManifestSync, composeStylesheetHostSync, createCompilerSync, inspectCSSSync, resolveStylesheetDependenciesSync, resolveStylesheetSync };

package/dist/node.js

@@ -0,0 +1,47 @@
+import { stylesheetValidationSource } from "./stylesheet/output-map.js";
+import { assertValidationOptions, validateCompiledCSS } from "./value-validation.js";
+import { bindCompilerSessionInternal, toMasterCSSCompileManifestResultInternal } from "./compiler.js";
+import { compileCSSManifestFile } from "./node-compiler.js";
+import { compileDeliveredFile } from "./stylesheet/delivery.js";
+import { bindCompilerBindingSessionInternal } from "./session.js";
+import { collectStylesheetDependenciesSync, composeStylesheetHostSync, resolveStylesheetDependenciesSync, resolveStylesheetSync } from "./stylesheet/public.js";
+import { createCompilerBindingSessionSync } from "@master/css-binding/compiler/node";
+// src/node.ts
+function createCompilerSync() {
+	return bindCompilerSessionInternal(bindCompilerBindingSessionInternal(createCompilerBindingSessionSync()));
+}
+function inspectCSSSync(source) {
+	using compiler = createCompilerSync();
+	return compiler.inspectCSS(source);
+}
+function compileCSSSync(source, options = {}) {
+	using compiler = createCompilerSync();
+	return compiler.compileCSS(source, options);
+}
+function compileManifestSync(source, options) {
+	using compiler = createCompilerSync();
+	return compiler.compileManifest(source, options);
+}
+function compileManifestFileSync(file, options) {
+	assertValidationOptions(options);
+	if ("delivery" in options) {
+		const result = compileDeliveredFile(file, {
+			...options,
+			projectDir: options.root,
+			preserveNativeCSS: options.preserveNativeCSS ?? true
+		});
+		return Object.freeze({
+			...toMasterCSSCompileManifestResultInternal({
+				...result.directives,
+				manifest: result.manifest,
+				directives: result.directives
+			}, options.onDiagnostic, options.validation),
+			diagnostics: validateCompiledCSS(result.stylesheets.map((asset) => stylesheetValidationSource(asset.css, asset.id, void 0, asset.outputMappings)), options),
+			entry: result.entry,
+			stylesheets: Object.freeze(result.stylesheets.map((asset) => Object.freeze({ ...asset }))),
+			resources: Object.freeze(result.resources.map((asset) => Object.freeze({ ...asset })))
+		});
+	}
+	return toMasterCSSCompileManifestResultInternal(compileCSSManifestFile(file, options), options.onDiagnostic, options.validation);
+}
+export { collectStylesheetDependenciesSync, compileCSSSync, compileManifestFileSync, compileManifestSync, composeStylesheetHostSync, createCompilerSync, inspectCSSSync, resolveStylesheetDependenciesSync, resolveStylesheetSync };

package/dist/notices.d.ts

@@ -0,0 +1,5 @@
+import { MasterCSSDiagnostic } from "@master/css-schema";
+import { CSSDirectiveNotice } from "@master/css-schema/css-directives";
+/** Adapt Rust source locations to the public, zero-based diagnostic envelope. */
+declare function noticeDiagnostics(notices: readonly CSSDirectiveNotice[] | undefined, onDiagnostic?: (diagnostic: MasterCSSDiagnostic) => void): MasterCSSDiagnostic[];
+export { noticeDiagnostics };

package/dist/notices.js

@@ -0,0 +1,29 @@
+import { MASTER_CSS_DIAGNOSTIC_VERSION } from "@master/css-schema";
+// src/notices.ts
+/** Adapt Rust source locations to the public, zero-based diagnostic envelope. */
+function noticeDiagnostics(notices, onDiagnostic) {
+	return (notices || []).map(({ code, message, source }) => {
+		const diagnostic = Object.freeze({
+			version: MASTER_CSS_DIAGNOSTIC_VERSION,
+			code,
+			message,
+			domain: "compiler",
+			phase: "compiler",
+			severity: "information",
+			...source?.file ? { source: source.file } : {},
+			...source?.loc ? { range: {
+				start: {
+					line: source.loc.start.line - 1,
+					character: source.loc.start.column - 1
+				},
+				end: {
+					line: source.loc.end.line - 1,
+					character: source.loc.end.column - 1
+				}
+			} } : {}
+		});
+		onDiagnostic?.(diagnostic);
+		return diagnostic;
+	});
+}
+export { noticeDiagnostics };

package/dist/prepared-graph-cache.d.ts

@@ -0,0 +1,5 @@
+import { MasterCSSCompilerBindingSession } from "@master/css-binding/compiler";
+type CompileGraph = MasterCSSCompilerBindingSession['compileCSSStylesheetGraph'];
+/** Cache only the pure binding request, after resolving and observing all inputs. */
+declare function compilePreparedGraph(binding: Pick<MasterCSSCompilerBindingSession, 'compileCSSStylesheetGraph'>, request: Parameters<CompileGraph>[0]): ReturnType<CompileGraph>;
+export { compilePreparedGraph };

package/dist/prepared-graph-cache.js

@@ -0,0 +1,31 @@
+import { createHash } from "node:crypto";
+// src/prepared-graph-cache.ts
+const results = /* @__PURE__ */ new Map();
+const budget = 16777216;
+let bytes = 0;
+/** Cache only the pure binding request, after resolving and observing all inputs. */
+function compilePreparedGraph(binding, request) {
+	const key = createHash("sha256").update(JSON.stringify(request)).digest("hex");
+	const cached = results.get(key);
+	if (cached) {
+		results.delete(key);
+		results.set(key, cached);
+		return structuredClone(cached.result);
+	}
+	const result = binding.compileCSSStylesheetGraph(request);
+	const size = JSON.stringify(result).length * 2;
+	if (size <= budget) {
+		while (bytes + size > budget || results.size >= 64) {
+			const oldest = results.keys().next().value;
+			bytes -= results.get(oldest).bytes;
+			results.delete(oldest);
+		}
+		results.set(key, {
+			result: structuredClone(result),
+			bytes: size
+		});
+		bytes += size;
+	}
+	return result;
+}
+export { compilePreparedGraph };

package/dist/project/binding-project.d.ts

@@ -0,0 +1,29 @@
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+import { CSSDirectiveExtractionPolicy } from "@master/css-schema/css-directives";
+import { MasterCSSProjectSourceGraph } from "./options.js";
+interface BindingProjectSourceEntryPlan {
+  entry: string;
+  include: string[];
+  exclude: string[];
+  files: string[];
+}
+interface BindingProjectManifestResult {
+  sourceGraph?: MasterCSSProjectSourceGraph;
+  entries: string[];
+  manifest: MasterCSSManifest;
+  dependencies: string[];
+  extractionPolicy: CSSDirectiveExtractionPolicy;
+  classNames: string[];
+  nativeClassNames: string[];
+  nativeCSS: string;
+  css: string;
+  generatedCSS: string;
+  warnings: string[];
+  sourcePlan: {
+    version: 1;
+    entries: BindingProjectSourceEntryPlan[];
+    files: string[];
+  };
+}
+declare function loadBindingProjectManifest(projectDir: string, baseManifest: MasterCSSManifest, entries?: readonly string[], onDependency?: (file: string) => void, includeSourceGraph?: boolean): BindingProjectManifestResult;
+export { loadBindingProjectManifest };

package/dist/project/binding-project.js

@@ -0,0 +1,100 @@
+import { prepareCSSImportGraph } from "../node-imports.js";
+import { analyzeCSSDependencies, compileCSS, resolveCSSReferenceFile, stripWindowsExtendedPathPrefix } from "../node-compiler.js";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { realpathSync } from "node:fs";
+import { createCompilerBindingSessionSync } from "@master/css-binding/compiler/node";
+// src/project/binding-project.ts
+function prepareManifestGraph(entry, projectDir, onDependency) {
+	const graph = prepareCSSImportGraph(entry, void 0, {
+		projectDir,
+		onDependency
+	}, analyzeCSSDependencies);
+	const pending = Object.keys(graph.files);
+	const visited = /* @__PURE__ */ new Set();
+	while (pending.length) {
+		const file = pending.shift();
+		if (visited.has(file)) continue;
+		visited.add(file);
+		for (const reference of compileCSS(graph.files[file], { from: file }).references || []) {
+			const target = resolveCSSReferenceFile(reference, { root: projectDir });
+			const referenced = prepareCSSImportGraph(target, void 0, {
+				projectDir,
+				onDependency
+			}, analyzeCSSDependencies);
+			graph.edges.push({
+				from: file,
+				specifier: reference.source,
+				resolved: referenced.entry
+			}, ...referenced.edges);
+			Object.assign(graph.files, referenced.files);
+			Object.assign(graph.resourceOwners ??= {}, referenced.resourceOwners);
+			pending.push(...Object.keys(referenced.files).filter((id) => !visited.has(id)));
+		}
+	}
+	return graph;
+}
+function isProjectPath(root, file) {
+	const local = relative(root, file);
+	return local !== ".." && !local.startsWith(`..${sep}`) && !isAbsolute(local) && !local.split(sep).includes("node_modules");
+}
+function loadBindingProjectManifest(projectDir, baseManifest, entries, onDependency, includeSourceGraph = false) {
+	const compiler = createCompilerBindingSessionSync();
+	const root = resolve(projectDir);
+	let realRoot = root;
+	try {
+		realRoot = resolve(stripWindowsExtendedPathPrefix(realpathSync.native(root)));
+	} catch {}
+	const preservePath = (file) => {
+		const absoluteFile = resolve(stripWindowsExtendedPathPrefix(file));
+		return realRoot !== root && (absoluteFile === realRoot || absoluteFile.startsWith(`${realRoot}${sep}`)) ? join(root, relative(realRoot, absoluteFile)) : absoluteFile;
+	};
+	const resolvedEntries = (entries ?? compiler.findManifestEntries(projectDir)).map(preservePath);
+	const observed = /* @__PURE__ */ new Set();
+	const dependency = onDependency ? (file) => {
+		const path = preservePath(file);
+		if (observed.has(path)) return;
+		observed.add(path);
+		onDependency(path);
+	} : void 0;
+	const graphs = resolvedEntries.map((entry) => ({
+		entry,
+		source: "",
+		dependencies: [],
+		manifestGraph: prepareManifestGraph(entry, projectDir, dependency)
+	}));
+	const result = compiler.loadPreparedProjectManifest(projectDir, baseManifest, graphs);
+	if (includeSourceGraph) {
+		const files = /* @__PURE__ */ new Map();
+		const edges = /* @__PURE__ */ new Map();
+		for (const { manifestGraph } of graphs) {
+			for (const [source, content] of Object.entries(manifestGraph.files)) files.set(preservePath(source), content);
+			for (const edge of manifestGraph.edges) {
+				const value = {
+					from: preservePath(edge.from),
+					specifier: edge.specifier,
+					resolved: preservePath(edge.resolved)
+				};
+				edges.set(JSON.stringify(value), value);
+			}
+		}
+		result.sourceGraph = Object.freeze({
+			version: 1,
+			files: Object.freeze([...files].map(([source, content]) => Object.freeze({
+				source,
+				content,
+				projectOwned: isProjectPath(root, source) && isProjectPath(realRoot, stripWindowsExtendedPathPrefix(realpathSync.native(source)))
+			}))),
+			edges: Object.freeze([...edges.values()].map((edge) => Object.freeze(edge)))
+		});
+	}
+	result.entries = result.entries.map(preservePath);
+	result.dependencies = result.dependencies.map(preservePath);
+	result.sourcePlan.files = result.sourcePlan.files.map(preservePath);
+	result.sourcePlan.entries = result.sourcePlan.entries.map((entry) => ({
+		...entry,
+		entry: preservePath(entry.entry),
+		files: entry.files.map(preservePath)
+	}));
+	return result;
+}
+export { loadBindingProjectManifest };

package/dist/project/entries.d.ts

@@ -0,0 +1,7 @@
+import { resolveMasterCSSPackageEntryFile } from "../node-compiler.js";
+declare function cleanCSSManifestRequest(id: string): string;
+declare function isCSSManifestRequest(id: string): boolean;
+declare function hasMasterCSSManifestEntrypoint(source: string): boolean;
+declare function findCSSManifestEntryFiles(projectDir?: string): Promise<string[]>;
+declare function findCSSManifestEntryFilesSync(projectDir?: string): string[];
+export { cleanCSSManifestRequest, findCSSManifestEntryFiles, findCSSManifestEntryFilesSync, hasMasterCSSManifestEntrypoint, isCSSManifestRequest, resolveMasterCSSPackageEntryFile };

package/dist/project/entries.js

@@ -0,0 +1,30 @@
+import { resolveMasterCSSPackageEntryFile } from "../node-imports.js";
+import { inspectCSS, stripRequestSuffix, stripWindowsExtendedPathPrefix } from "../node-compiler.js";
+import { extname, join, relative, resolve, sep } from "node:path";
+import { realpathSync } from "node:fs";
+import { createCompilerBindingSessionSync } from "@master/css-binding/compiler/node";
+// src/project/entries.ts
+function cleanCSSManifestRequest(id) {
+	return stripRequestSuffix(id);
+}
+function isCSSManifestRequest(id) {
+	return extname(cleanCSSManifestRequest(id)) === ".css";
+}
+function hasMasterCSSManifestEntrypoint(source) {
+	return inspectCSS(source).hasMasterEntry;
+}
+async function findCSSManifestEntryFiles(projectDir = process.cwd()) {
+	return findCSSManifestEntryFilesSync(projectDir);
+}
+function findCSSManifestEntryFilesSync(projectDir = process.cwd()) {
+	const root = resolve(projectDir);
+	let realRoot = root;
+	try {
+		realRoot = resolve(stripWindowsExtendedPathPrefix(realpathSync.native(root)));
+	} catch {}
+	return createCompilerBindingSessionSync().findManifestEntries(root).map((entry) => {
+		const absoluteEntry = resolve(stripWindowsExtendedPathPrefix(entry));
+		return realRoot !== root && (absoluteEntry === realRoot || absoluteEntry.startsWith(`${realRoot}${sep}`)) ? join(root, relative(realRoot, absoluteEntry)) : absoluteEntry;
+	});
+}
+export { cleanCSSManifestRequest, findCSSManifestEntryFiles, findCSSManifestEntryFilesSync, hasMasterCSSManifestEntrypoint, isCSSManifestRequest, resolveMasterCSSPackageEntryFile };

package/dist/project/manifest-sync.d.ts

@@ -0,0 +1,5 @@
+import { MasterCSSProjectCompileOptions, MasterCSSProjectCompileOptions as MasterCSSProjectCompileOptions$1, MasterCSSProjectDiscoveryOptions, MasterCSSProjectDiscoveryOptions as MasterCSSProjectDiscoveryOptions$1, MasterCSSProjectLoadOptions, MasterCSSProjectLoadOptions as MasterCSSProjectLoadOptions$1, MasterCSSProjectResult, MasterCSSProjectResult as MasterCSSProjectResult$1, MasterCSSProjectSourceGraph } from "./options.js";
+declare function discoverManifestEntriesSync(options?: Omit<MasterCSSProjectDiscoveryOptions$1, 'signal'>): readonly string[];
+declare function loadProjectManifestSync(options: Omit<MasterCSSProjectLoadOptions$1, 'signal'>): MasterCSSProjectResult$1;
+declare function compileProjectManifestSync(options: Omit<MasterCSSProjectCompileOptions$1, 'signal'>): MasterCSSProjectResult$1;
+export { type MasterCSSProjectCompileOptions, type MasterCSSProjectDiscoveryOptions, type MasterCSSProjectLoadOptions, type MasterCSSProjectResult, type MasterCSSProjectSourceGraph, compileProjectManifestSync, discoverManifestEntriesSync, loadProjectManifestSync };

package/dist/project/manifest-sync.js

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

package/dist/project/manifest.d.ts

@@ -0,0 +1,5 @@
+import { MasterCSSProjectCompileOptions, MasterCSSProjectCompileOptions as MasterCSSProjectCompileOptions$1, MasterCSSProjectDiscoveryOptions, MasterCSSProjectDiscoveryOptions as MasterCSSProjectDiscoveryOptions$1, MasterCSSProjectLoadOptions, MasterCSSProjectLoadOptions as MasterCSSProjectLoadOptions$1, MasterCSSProjectResult, MasterCSSProjectResult as MasterCSSProjectResult$1, MasterCSSProjectSourceGraph } from "./options.js";
+declare function discoverManifestEntries(options?: MasterCSSProjectDiscoveryOptions$1): Promise<readonly string[]>;
+declare function loadProjectManifest(options: MasterCSSProjectLoadOptions$1): Promise<MasterCSSProjectResult$1>;
+declare function compileProjectManifest(options: MasterCSSProjectCompileOptions$1): Promise<MasterCSSProjectResult$1>;
+export { type MasterCSSProjectCompileOptions, type MasterCSSProjectDiscoveryOptions, type MasterCSSProjectLoadOptions, type MasterCSSProjectResult, type MasterCSSProjectSourceGraph, compileProjectManifest, discoverManifestEntries, loadProjectManifest };