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

package/dist/lint/source.js

@@ -0,0 +1,261 @@
+// src/lint/source.ts
+const MAX_FIX_PASSES = 10;
+const masterCSSLintRuleIds = Object.freeze([
+	"sort-classes",
+	"no-invalid-classes",
+	"no-conflicting-classes",
+	"prefer-canonical-classes",
+	"no-unapproved-raw-values",
+	"prefer-component-classes"
+]);
+const defaultMasterCSSLintRules = Object.freeze({
+	"sort-classes": true,
+	"no-invalid-classes": true,
+	"no-conflicting-classes": true,
+	"prefer-canonical-classes": true,
+	"no-unapproved-raw-values": false,
+	"prefer-component-classes": false
+});
+const languageByExtension = {
+	".astro": "astro",
+	".css": "css",
+	".htm": "html",
+	".html": "html",
+	".js": "javascript",
+	".mjs": "javascript",
+	".cjs": "javascript",
+	".jsx": "javascriptreact",
+	".less": "less",
+	".md": "markdown",
+	".mdx": "mdx",
+	".mts": "typescript",
+	".cts": "typescript",
+	".php": "html",
+	".pug": "html",
+	".scss": "scss",
+	".svelte": "svelte",
+	".ts": "typescript",
+	".tsx": "typescriptreact",
+	".vue": "vue"
+};
+const stylesheetLanguageIds = /* @__PURE__ */ new Set([
+	"css",
+	"scss",
+	"less"
+]);
+function resolveMasterCSSLintRules(option) {
+	if (!option) return { ...defaultMasterCSSLintRules };
+	const resolved = Object.fromEntries(masterCSSLintRuleIds.map((ruleId) => [ruleId, false]));
+	for (const rule of option.split(",").map((item) => item.trim()).filter(Boolean)) {
+		if (rule === "recommended") {
+			Object.assign(resolved, defaultMasterCSSLintRules);
+			continue;
+		}
+		if (rule === "all") {
+			for (const ruleId of masterCSSLintRuleIds) resolved[ruleId] = true;
+			continue;
+		}
+		if (!masterCSSLintRuleIds.includes(rule)) throw new Error(`Unknown Master CSS lint rule "${rule}".`);
+		resolved[rule] = true;
+	}
+	return resolved;
+}
+function resolveRules(rules) {
+	return {
+		...defaultMasterCSSLintRules,
+		...rules
+	};
+}
+function getLanguageId(filePath) {
+	const separator = Math.max(filePath.lastIndexOf("/"), filePath.lastIndexOf("\\"));
+	const dot = filePath.lastIndexOf(".");
+	const extension = dot > separator ? filePath.slice(dot).toLowerCase() : "";
+	return languageByExtension[extension] || "html";
+}
+function getFileSourceKind(languageId) {
+	return stylesheetLanguageIds.has(languageId) ? "stylesheet" : "source";
+}
+function detectClassListUnescape(content, range) {
+	const quote = content[range.start - 1];
+	return quote === "\"" || quote === "'" || quote === "`" ? quote : false;
+}
+function inferClassSourceKind(content, range) {
+	const prefix = content.slice(Math.max(0, range.start - 80), range.start);
+	return /(?:^|[\s{<])(?:class|className|class:list|:class|v-bind:class|\[class\]|\[className\]|\[ngClass\])\s*=\s*(?:"|'|`|\{[^]*$)/.test(prefix) ? "class-attribute" : "class-expression";
+}
+function collectClassListContexts(content, filePath, lintSession, analysis = lintSession.analyzeLintDocument(content, getLanguageId(filePath))) {
+	const positions = analysis.classPositions;
+	const contexts = /* @__PURE__ */ new Map();
+	for (const position of positions) {
+		const contextRange = position.contextRange;
+		const key = `${contextRange.start}:${contextRange.end}`;
+		const existing = contexts.get(key);
+		if (existing) {
+			existing.classNames.push(position.token);
+			existing.transformed ||= position.raw !== position.token;
+			continue;
+		}
+		contexts.set(key, {
+			range: contextRange,
+			text: content.slice(contextRange.start, contextRange.end),
+			sourceKind: inferClassSourceKind(content, contextRange),
+			unescape: detectClassListUnescape(content, contextRange),
+			classNames: [position.token],
+			transformed: position.raw !== position.token
+		});
+	}
+	return [...contexts.values()].map((context) => {
+		const tokens = lintSession.tokenizeClassList(context.text, context.unescape).map((item) => item.token);
+		context.transformed ||= tokens.length !== context.classNames.length || tokens.some((token, index) => token !== context.classNames[index]);
+		return context;
+	}).sort((a, b) => a.range.start - b.range.start || a.range.end - b.range.end);
+}
+function offsetToLocation(content, offset) {
+	let line = 1;
+	let lineStart = 0;
+	for (let index = 0; index < offset; index++) if (content[index] === "\n") {
+		line++;
+		lineStart = index + 1;
+	}
+	return {
+		line,
+		column: offset - lineStart + 1
+	};
+}
+function toLocationRange(content, range) {
+	return {
+		start: offsetToLocation(content, range.start),
+		end: offsetToLocation(content, range.end)
+	};
+}
+function createContextLintDiagnostics(context, rules, options) {
+	return Object.values(rules).some(Boolean) ? options.lintSession.analyzeLintClassList(context.text, context.classNames, {
+		disallowUnknownClass: options.ruleOptions?.["no-invalid-classes"]?.disallowUnknownClass,
+		rawValuePolicy: rules["no-unapproved-raw-values"] ? options.ruleOptions?.["no-unapproved-raw-values"] || {} : void 0,
+		canonicalOptions: rules["prefer-canonical-classes"] ? options.ruleOptions?.["prefer-canonical-classes"] || {} : void 0,
+		remoteStylingPolicy: rules["prefer-component-classes"] ? { max: options.ruleOptions?.["prefer-component-classes"]?.max } : void 0
+	}).diagnostics.filter(({ ruleId }) => rules[ruleId]).map((diagnostic) => ({
+		...diagnostic,
+		severity: options.severities?.[diagnostic.ruleId] || (diagnostic.ruleId === "no-invalid-classes" ? "error" : "warning"),
+		fix: diagnostic.fix
+	})) : [];
+}
+function toSourceFix(context, fix) {
+	if (context.transformed) return;
+	return {
+		kind: "class-list",
+		safety: "safe",
+		range: {
+			start: context.range.start + fix.range.start,
+			end: context.range.start + fix.range.end
+		},
+		text: fix.text,
+		description: "Replace the class list text.",
+		requiresFormatting: false
+	};
+}
+function toSourceDiagnostic(content, context, diagnostic) {
+	const range = context.transformed ? context.range : {
+		start: context.range.start + diagnostic.range.start,
+		end: context.range.start + diagnostic.range.end
+	};
+	const fix = diagnostic.fix && toSourceFix(context, diagnostic.fix);
+	return {
+		ruleId: diagnostic.ruleId,
+		code: diagnostic.code,
+		severity: diagnostic.severity,
+		message: diagnostic.message,
+		range,
+		loc: toLocationRange(content, range),
+		source: "Master CSS",
+		sourceKind: context.sourceKind,
+		...diagnostic.data ? { data: diagnostic.data } : {},
+		...fix ? { fixes: [fix] } : {}
+	};
+}
+function lintMasterCSSContent(options) {
+	const diagnostics = [];
+	const rules = resolveRules(options.rules);
+	const document = options.lintSession.analyzeLintDocument(options.content, getLanguageId(options.filePath));
+	for (const diagnostic of document.diagnostics ?? []) {
+		if (diagnostic.severity === "info") continue;
+		const range = diagnostic.range ?? {
+			start: 0,
+			end: 0
+		};
+		diagnostics.push({
+			code: diagnostic.code,
+			severity: diagnostic.severity,
+			message: diagnostic.message,
+			range,
+			loc: toLocationRange(options.content, range),
+			source: "Master CSS",
+			sourceKind: "class-expression"
+		});
+	}
+	for (const context of collectClassListContexts(options.content, options.filePath, options.lintSession, document)) diagnostics.push(...createContextLintDiagnostics(context, rules, options).map((diagnostic) => toSourceDiagnostic(options.content, context, diagnostic)));
+	const languageId = getLanguageId(options.filePath);
+	return {
+		filePath: options.filePath,
+		languageId,
+		sourceKind: getFileSourceKind(languageId),
+		diagnostics
+	};
+}
+function applyReplacement(content, range, text) {
+	return content.slice(0, range.start) + text + content.slice(range.end);
+}
+function applyFixes(content, fixes) {
+	let fixed = content;
+	for (const fix of fixes) fixed = applyReplacement(fixed, fix.range, fix.text);
+	return fixed;
+}
+function fixClassListText(context, rules, options) {
+	if (context.transformed) return context.text;
+	let fixed = context.text;
+	for (let pass = 0; pass < MAX_FIX_PASSES; pass++) {
+		const fix = createContextLintDiagnostics({
+			...context,
+			range: {
+				start: 0,
+				end: fixed.length
+			},
+			text: fixed,
+			classNames: options.lintSession.tokenizeClassList(fixed, context.unescape).map(({ token }) => token)
+		}, rules, options).map((diagnostic) => diagnostic.fix).find((fix) => Boolean(fix));
+		if (!fix) return fixed;
+		const next = applyReplacement(fixed, fix.range, fix.text);
+		if (next === fixed) return fixed;
+		fixed = next;
+	}
+	return fixed;
+}
+function fixSafeClassLists(content, filePath, rules, options) {
+	return applyFixes(content, collectClassListContexts(content, filePath, options.lintSession).map((context) => ({
+		range: context.range,
+		text: fixClassListText(context, rules, options)
+	})).filter((replacement) => content.slice(replacement.range.start, replacement.range.end) !== replacement.text).sort((a, b) => b.range.start - a.range.start || b.range.end - a.range.end).map((replacement) => ({
+		kind: "class-list",
+		safety: "safe",
+		range: replacement.range,
+		text: replacement.text,
+		description: "Replace the class list text.",
+		requiresFormatting: false
+	})));
+}
+function fixMasterCSSContent(options) {
+	return fixSafeClassLists(options.content, options.filePath, resolveRules(options.rules), options);
+}
+function summarizeMasterCSSLintFiles(files) {
+	const diagnostics = files.flatMap((file) => file.diagnostics);
+	const fixes = diagnostics.flatMap((diagnostic) => diagnostic.fixes ?? []);
+	return {
+		files: files.length,
+		diagnostics: diagnostics.length,
+		errors: diagnostics.filter((diagnostic) => diagnostic.severity === "error").length,
+		warnings: diagnostics.filter((diagnostic) => diagnostic.severity === "warning").length,
+		fixable: diagnostics.filter((diagnostic) => diagnostic.fixes?.length).length,
+		safeFixes: fixes.filter((fix) => fix.safety === "safe").length
+	};
+}
+export { defaultMasterCSSLintRules, fixMasterCSSContent, lintMasterCSSContent, masterCSSLintRuleIds, resolveMasterCSSLintRules, summarizeMasterCSSLintFiles };

package/dist/math-types.d.ts

@@ -0,0 +1,11 @@
+import { CssNode } from "@eslint/css-tree";
+declare const mathFunctions: Set<string>;
+/** Substitute only proven result types into a disposable grammar AST. Never
+ * evaluate values, ranges, variable substitutions, or mutate emitted CSS.
+ * A nested calc may have a compound intermediate type which its parent cancels.
+ */
+declare function validateMathTypes(ast: CssNode, matches: (value: CssNode) => boolean): {
+  ast: CssNode;
+  status?: 'valid' | 'invalid' | 'unknown';
+};
+export { mathFunctions, validateMathTypes };

package/dist/math-types.js

@@ -0,0 +1,236 @@
+import { clone, lexer, walk } from "@eslint/css-tree";
+// src/math-types.ts
+const unknown = { kind: "unknown" };
+const invalid = { kind: "invalid" };
+const number = () => ({
+	kind: "known",
+	powers: {}
+});
+const dimension = (name) => ({
+	kind: "known",
+	powers: { [name]: 1 }
+});
+const examples = {
+	length: "px",
+	angle: "deg",
+	time: "s",
+	frequency: "hz",
+	resolution: "dppx",
+	flex: "fr"
+};
+const units = new Map(Object.entries(lexer.units).filter(([type]) => type in examples).flatMap(([type, names]) => names.map((unit) => [unit.toLowerCase(), type])));
+const mathFunctions = /* @__PURE__ */ new Set([
+	"calc",
+	"min",
+	"max",
+	"clamp",
+	"mod",
+	"rem",
+	"sin",
+	"cos",
+	"tan",
+	"asin",
+	"acos",
+	"atan",
+	"atan2",
+	"pow",
+	"sqrt",
+	"hypot",
+	"exp",
+	"abs",
+	"sign",
+	"log",
+	"round"
+]);
+function same(a, b) {
+	return Object.keys({
+		...a.powers,
+		...b.powers
+	}).every((key) => a.powers[key] === b.powers[key]);
+}
+function combine(a, b, operator, hint) {
+	if (a.kind === "invalid" || b.kind === "invalid") return invalid;
+	if (a.kind === "unknown" || b.kind === "unknown") return unknown;
+	if (operator === "+" || operator === "-") {
+		if (same(a, b)) return a;
+		if (hint === void 0 && (a.powers.percentage || b.powers.percentage)) return unknown;
+		return invalid;
+	}
+	const powers = { ...a.powers };
+	for (const [dimension, exponent] of Object.entries(b.powers)) {
+		const key = dimension;
+		powers[key] = (powers[key] ?? 0) + exponent * (operator === "/" ? -1 : 1);
+		if (powers[key] === 0) delete powers[key];
+	}
+	return {
+		kind: "known",
+		powers
+	};
+}
+function expression(nodes, hint) {
+	let offset = 0;
+	const atom = () => {
+		const node = nodes[offset++];
+		if (!node) return invalid;
+		switch (node.type) {
+			case "Number": return number();
+			case "Dimension": return units.has(node.unit.toLowerCase()) ? dimension(units.get(node.unit.toLowerCase())) : unknown;
+			case "Percentage": return dimension(hint ?? "percentage");
+			case "Identifier": return [
+				"e",
+				"pi",
+				"infinity",
+				"-infinity",
+				"nan"
+			].includes(node.name.toLowerCase()) ? number() : unknown;
+			case "Parentheses": return expression([...node.children], hint);
+			case "Function": return inferFunction(node, hint);
+			default: return unknown;
+		}
+	};
+	const operator = () => {
+		const node = nodes[offset];
+		return node?.type === "Operator" ? node.value.trim() : "";
+	};
+	const product = () => {
+		let result = atom();
+		while (["*", "/"].includes(operator())) {
+			const op = operator();
+			offset++;
+			result = combine(result, atom(), op, hint);
+		}
+		return result;
+	};
+	let result = product();
+	let knownSum = result.kind === "known" ? result : void 0;
+	while (["+", "-"].includes(operator())) {
+		const op = operator();
+		offset++;
+		const right = product();
+		if (right.kind === "known") {
+			const sum = knownSum ? combine(knownSum, right, op, hint) : right;
+			if (sum.kind === "invalid") return invalid;
+			knownSum = sum.kind === "known" ? sum : void 0;
+		}
+		result = combine(result, right, op, hint);
+	}
+	return offset === nodes.length ? result : unknown;
+}
+function primitive(value) {
+	const entries = Object.entries(value.powers);
+	return !entries.length ? "number" : entries.length === 1 && entries[0][1] === 1 ? entries[0][0] : void 0;
+}
+function inferFunction(node, hint) {
+	const name = node.name.toLowerCase();
+	if (!mathFunctions.has(name)) return unknown;
+	const args = [[]];
+	for (const child of node.children) if (child.type === "Operator" && child.value.trim() === ",") args.push([]);
+	else args.at(-1).push(child);
+	if (name === "round" && args[0]?.length === 1 && args[0][0].type === "Identifier" && [
+		"nearest",
+		"up",
+		"down",
+		"to-zero"
+	].includes(args[0][0].name)) args.shift();
+	const values = args.map((nodes, index) => name === "clamp" && index !== 1 && nodes.length === 1 && nodes[0].type === "Identifier" && nodes[0].name === "none" ? void 0 : expression(nodes, hint)).filter((value) => value !== void 0);
+	if (values.some((value) => value.kind === "invalid")) return invalid;
+	const known = values.filter((value) => value.kind === "known");
+	const uncertain = known.length !== values.length;
+	const accepts = (types) => known.every((value) => {
+		const type = primitive(value);
+		return type !== void 0 && types.includes(type);
+	});
+	let result;
+	switch (name) {
+		case "calc": return values[0] ?? invalid;
+		case "sin":
+		case "cos":
+		case "tan":
+			result = accepts(["number", "angle"]) ? number() : invalid;
+			break;
+		case "asin":
+		case "acos":
+		case "atan":
+			result = accepts(["number"]) ? dimension("angle") : invalid;
+			break;
+		case "pow":
+		case "sqrt":
+		case "exp":
+		case "log":
+			result = accepts(["number"]) ? number() : invalid;
+			break;
+		case "sign":
+			result = known.every((value) => primitive(value) !== void 0) ? number() : invalid;
+			break;
+		case "abs":
+			result = values[0] ?? invalid;
+			break;
+		default:
+			result = known.reduce((result, value) => combine(result, value, "+", hint), known[0] ?? unknown);
+			if (name === "round" && values.length === 1 && !accepts(["number"])) result = invalid;
+			if (name === "atan2" && result.kind === "known") result = dimension("angle");
+	}
+	return result.kind === "invalid" ? invalid : uncertain ? unknown : result;
+}
+function representative(type) {
+	if (type === "number") return {
+		type: "Number",
+		value: "1"
+	};
+	if (type === "percentage") return {
+		type: "Percentage",
+		value: "1"
+	};
+	return {
+		type: "Dimension",
+		value: "1",
+		unit: examples[type]
+	};
+}
+/** Substitute only proven result types into a disposable grammar AST. Never
+* evaluate values, ranges, variable substitutions, or mutate emitted CSS.
+* A nested calc may have a compound intermediate type which its parent cancels.
+*/
+function validateMathTypes(ast, matches) {
+	const normalized = clone(ast);
+	let status = "valid";
+	let found = false;
+	walk(normalized, (node, item, list) => {
+		if (node.type !== "Function" || !mathFunctions.has(node.name.toLowerCase()) || !item || !list) return;
+		found = true;
+		const original = item.data;
+		const accepts = (type) => {
+			item.data = representative(type);
+			const result = matches(normalized);
+			item.data = original;
+			return result;
+		};
+		let hint = null;
+		let hasPercentage = false;
+		walk(node, (child) => {
+			if (child.type === "Percentage") hasPercentage = true;
+		});
+		if (hasPercentage) {
+			const bases = Object.keys(examples).filter((type) => accepts(type));
+			hint = accepts("percentage") && bases.length === 1 ? bases[0] : bases.length ? null : void 0;
+		}
+		const inferred = inferFunction(node, hint);
+		if (inferred.kind === "invalid") status = "invalid";
+		else if (inferred.kind === "unknown") {
+			if (status !== "invalid") status = "unknown";
+		} else {
+			const type = primitive(inferred);
+			if (!type) {
+				if (hasPercentage && hint === void 0) {
+					if (status !== "invalid") status = "unknown";
+				} else status = "invalid";
+			} else item.data = representative(type);
+		}
+		return walk.skip;
+	});
+	return {
+		ast: normalized,
+		status: found ? status : void 0
+	};
+}
+export { mathFunctions, validateMathTypes };

package/dist/math-validation.d.ts

@@ -0,0 +1,7 @@
+import { FunctionNode } from "@eslint/css-tree";
+/** Check operator structure and arity, without inferring the result's dimension.
+ * CSS Values 4 allows dimensional division. Normalize operands for grammar-only
+ * checks rather than applying the lexer's numeric-divisor restriction.
+ */
+declare function mathFunctionStatus(node: FunctionNode): 'valid' | 'invalid' | 'unknown' | undefined;
+export { mathFunctionStatus };

package/dist/math-validation.js

@@ -0,0 +1,74 @@
+import { mathFunctions } from "./math-types.js";
+import { List, clone, generate, lexer, walk } from "@eslint/css-tree";
+// src/math-validation.ts
+/** Check operator structure and arity, without inferring the result's dimension.
+* CSS Values 4 allows dimensional division. Normalize operands for grammar-only
+* checks rather than applying the lexer's numeric-divisor restriction.
+*/
+function mathFunctionStatus(node) {
+	const name = node.name.toLowerCase();
+	if (!mathFunctions.has(name)) return;
+	const normalized = clone(node);
+	let uncertain = false;
+	walk(normalized, (child, item, list) => {
+		if (child === normalized) return;
+		if (child.type === "Function") {
+			if (!mathFunctions.has(child.name.toLowerCase())) uncertain = true;
+			if (item && list) list.replace(item, list.createItem({
+				type: "Number",
+				value: "1"
+			}));
+			return walk.skip;
+		}
+		if ((child.type === "Dimension" || child.type === "Percentage") && item && list) list.replace(item, list.createItem({
+			type: "Number",
+			value: "1"
+		}));
+	});
+	if (uncertain) {
+		const arguments_ = [[]];
+		for (const child of node.children) if (child.type === "Operator" && child.value.trim() === ",") arguments_.push([]);
+		else arguments_.at(-1).push(child);
+		for (const argument of arguments_) {
+			const last = argument.at(-1);
+			if (last?.type === "Operator" && [
+				"+",
+				"-",
+				"*",
+				"/"
+			].includes(last.value.trim())) return "invalid";
+			let dependent = false;
+			const children = new List().fromArray(argument);
+			walk({
+				type: "Value",
+				children
+			}, (child) => {
+				if (child.type === "Function") dependent = true;
+			});
+			if (!dependent && mathFunctionStatus({
+				type: "Function",
+				name: "calc",
+				children
+			}) === "invalid") return "invalid";
+		}
+		return "unknown";
+	}
+	if (name === "log" || name === "round") {
+		const parts = [[]];
+		for (const child of normalized.children) if (child.type === "Operator" && child.value.trim() === ",") parts.push([]);
+		else parts.at(-1).push(child);
+		if (name === "round" && parts[0]?.length === 1 && parts[0][0].type === "Identifier" && [
+			"nearest",
+			"up",
+			"down",
+			"to-zero"
+		].includes(parts[0][0].name)) parts.shift();
+		if (parts.length < 1 || parts.length > 2) return "invalid";
+		return parts.some((children) => lexer.matchType("calc-sum", generate({
+			type: "Value",
+			children: new List().fromArray(children)
+		})).error) ? "invalid" : "valid";
+	}
+	return lexer.matchType(`${name}()`, generate(normalized)).error ? "invalid" : "valid";
+}
+export { mathFunctionStatus };

package/dist/node.d.ts

@@ -0,0 +1,12 @@
+import { CSS_VALUE_CHECK, cssValueStatus, validateRuleDeclarations } from "./value-validation.js";
+import { CSS_SYNTAX_CHECK, cssSyntaxStatus } from "./syntax-validation.js";
+import { MasterCSSToolingSession } from "./tooling-session.js";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+declare function createToolingSessionSync(options: {
+  readonly manifest: MasterCSSManifest;
+  /** Classes the project defines in native CSS; they report no diagnostics while they generate no rules. */
+  readonly nativeClassNames?: readonly string[];
+}): MasterCSSToolingSession;
+/** Versions from the artifact that actually executes project semantics. */
+declare function getToolingBindingInfo(): import("@master/css-binding").MasterCSSBindingInfo;
+export { CSS_SYNTAX_CHECK, CSS_VALUE_CHECK, type MasterCSSToolingSession, createToolingSessionSync, cssSyntaxStatus, cssValueStatus, getToolingBindingInfo, validateRuleDeclarations };

package/dist/node.js

@@ -0,0 +1,32 @@
+import { bindLexerSession } from "./lexer/session.js";
+import { CSS_SYNTAX_CHECK, cssSyntaxStatus } from "./syntax-validation.js";
+import { CSS_VALUE_CHECK, cssValueStatus, validateRuleDeclarations } from "./value-validation.js";
+import { bindLanguageSession } from "./language/session.js";
+import { bindLintSession } from "./lint/binding-session.js";
+import { bindSourceExtractor } from "./source/session.js";
+import { bindValidatorSession } from "./validator/binding-session.js";
+import { bindToolingSessionInternal } from "./tooling-session.js";
+import { createToolingBindingSync } from "@master/css-binding/tooling/node";
+// src/node.ts
+function createToolingSessionSync(options) {
+	const tooling = createToolingBindingSync();
+	const lexer = tooling.createLexerSession();
+	const source = tooling.createSourceSession();
+	const validator = tooling.createValidatorSession(options.manifest);
+	const language = tooling.createLanguageSession(options.manifest);
+	const lint = tooling.createLintSession(options.manifest);
+	const lintValidator = tooling.createValidatorSession(options.manifest);
+	const lintLanguage = tooling.createLanguageSession(options.manifest);
+	return bindToolingSessionInternal({
+		lexer: bindLexerSession("native", lexer),
+		source: bindSourceExtractor("native", source),
+		validator: bindValidatorSession("native", validator, options.nativeClassNames),
+		lint: bindLintSession(lint, lintValidator, lintLanguage),
+		language: bindLanguageSession("native", language, options.nativeClassNames)
+	});
+}
+/** Versions from the artifact that actually executes project semantics. */
+function getToolingBindingInfo() {
+	return createToolingBindingSync().info;
+}
+export { CSS_SYNTAX_CHECK, CSS_VALUE_CHECK, createToolingSessionSync, cssSyntaxStatus, cssValueStatus, getToolingBindingInfo, validateRuleDeclarations };

package/dist/scanner/binding-session.d.ts

@@ -0,0 +1,29 @@
+import { MasterCSSBindingLoadOptions, MasterCSSScannerSourceInput, MasterCSSScannerSourceOptions, MasterCSSScannerState, MasterCSSScannerUpdate } from "@master/css-binding/tooling";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+type BindingScannerUpdate = MasterCSSScannerUpdate;
+type BindingScannerState = MasterCSSScannerState;
+type ScannerSourceOptions = MasterCSSScannerSourceOptions;
+type ScannerSourceInput = MasterCSSScannerSourceInput;
+type BindingScannerBlocklist = string | Readonly<{
+  source: string;
+  flags: string;
+}>;
+interface BindingScannerSession {
+  readonly binding: 'native' | 'wasm';
+  extractCandidates(source: string, content: string, options?: ScannerSourceOptions): string[];
+  collectCandidates(candidates: string[]): string[];
+  filterCandidates(candidates: string[], blocklist: BindingScannerBlocklist[]): string[];
+  scanCandidates(source: string, content: string, candidates: string[], blocklist: BindingScannerBlocklist[], options?: ScannerSourceOptions): BindingScannerUpdate;
+  removeSource(source: string, options?: ScannerSourceOptions): BindingScannerUpdate;
+  reconcileSources(owner: string, inputs: readonly ScannerSourceInput[]): BindingScannerUpdate;
+  removeOwner(owner: string): BindingScannerUpdate;
+  ensureClasses(classNames: string[]): void;
+  registerNativeClasses(owner: string, classNames: string[]): boolean;
+  reset(): void;
+  state(): BindingScannerState;
+  dispose(): void;
+}
+declare function serializeScannerBlocklist(blocklist?: Iterable<string | RegExp>): BindingScannerBlocklist[];
+declare function createNativeScannerSession(manifest: MasterCSSManifest): BindingScannerSession;
+declare function createScannerSession(manifest: MasterCSSManifest, options?: MasterCSSBindingLoadOptions): Promise<BindingScannerSession>;
+export { BindingScannerBlocklist, BindingScannerSession, BindingScannerState, BindingScannerUpdate, ScannerSourceInput, ScannerSourceOptions, createNativeScannerSession, createScannerSession, serializeScannerBlocklist };