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

package/dist/protocol.js

@@ -0,0 +1,14 @@
+// src/protocol.ts
+const MASTER_CSS_BINDING_ABI_VERSION = 32;
+const MASTER_CSS_LANGUAGE_VERSION = 18;
+const MASTER_CSS_MANIFEST_VERSION = 6;
+const MASTER_CSS_PROGRAM_VERSION = 3;
+const MASTER_CSS_HYDRATION_MANIFEST_VERSION = 5;
+const MASTER_CSS_ENGINE_TRANSITION_VERSION = 5;
+const MASTER_CSS_VALIDATOR_BATCH_VERSION = 4;
+const MASTER_CSS_DIAGNOSTICS_REPORT_VERSION = 5;
+const MASTER_CSS_LINT_BATCH_VERSION = 4;
+const MASTER_CSS_LANGUAGE_BATCH_VERSION = 8;
+const MASTER_CSS_LEXER_BATCH_VERSION = 1;
+const MASTER_CSS_SOURCE_BATCH_VERSION = 2;
+export { MASTER_CSS_BINDING_ABI_VERSION, MASTER_CSS_DIAGNOSTICS_REPORT_VERSION, MASTER_CSS_ENGINE_TRANSITION_VERSION, MASTER_CSS_HYDRATION_MANIFEST_VERSION, MASTER_CSS_LANGUAGE_BATCH_VERSION, MASTER_CSS_LANGUAGE_VERSION, MASTER_CSS_LEXER_BATCH_VERSION, MASTER_CSS_LINT_BATCH_VERSION, MASTER_CSS_MANIFEST_VERSION, MASTER_CSS_PROGRAM_VERSION, MASTER_CSS_SOURCE_BATCH_VERSION, MASTER_CSS_VALIDATOR_BATCH_VERSION };

package/dist/tooling-binding-adapter.js

@@ -0,0 +1,23 @@
+import { callBinding } from "./normalize-error.js";
+// src/tooling-binding-adapter.ts
+function sourceText(args) {
+	for (const value of args) {
+		if (!value || typeof value !== "object") continue;
+		if ("content" in value && typeof value.content === "string") return value.content;
+		if ("text" in value && typeof value.text === "string") return value.text;
+	}
+}
+function protectToolingSession(session) {
+	const protectedSession = Object.create(Object.getPrototypeOf(session));
+	for (const property of Reflect.ownKeys(session)) {
+		const value = Reflect.get(session, property);
+		Object.defineProperty(protectedSession, property, {
+			configurable: false,
+			enumerable: Object.prototype.propertyIsEnumerable.call(session, property),
+			writable: false,
+			value: typeof value === "function" ? (...args) => callBinding("tooling", () => Reflect.apply(value, session, args), sourceText(args)) : value
+		});
+	}
+	return Object.freeze(protectedSession);
+}
+export { protectToolingSession };

package/dist/tooling-binding-browser.d.ts

@@ -0,0 +1,5 @@
+import { MASTER_CSS_LANGUAGE_BATCH_VERSION, MASTER_CSS_LANGUAGE_VERSION, MASTER_CSS_LEXER_BATCH_VERSION, MASTER_CSS_LINT_BATCH_VERSION, MASTER_CSS_SOURCE_BATCH_VERSION, MASTER_CSS_VALIDATOR_BATCH_VERSION, MasterCSSBrowserSupport, MasterCSSClassSuggestions, MasterCSSDesignSystemCollision, MasterCSSDesignSystemComponent, MasterCSSDesignSystemDiagnostic, MasterCSSDesignSystemReport, MasterCSSDesignSystemRequest, MasterCSSDesignSystemStylesheet, MasterCSSDesignTokenMetadata, MasterCSSDiagnostic, MasterCSSEngineSnapshot, MasterCSSEngineTransition, MasterCSSLanguageClassifications, MasterCSSLanguageInspection, MasterCSSLanguageTokenFamilies, MasterCSSLexerBatch, MasterCSSLexerBatchRequest, MasterCSSLexerCSSAnalysis, MasterCSSLexerClassListInput, MasterCSSLexerClassListItem, MasterCSSLintBatch, MasterCSSLintCanonicalClassGroupSuggestions, MasterCSSLintCanonicalClassSuggestions, MasterCSSLintRawValueCandidates, MasterCSSMatchStatus, MasterCSSNativeDeclarationCandidate, MasterCSSScannerSourceInput, MasterCSSScannerSourceOptions, MasterCSSScannerState, MasterCSSScannerUpdate, MasterCSSSourceBatch, MasterCSSSourceBatchRequest, MasterCSSSourceExtractorKind, MasterCSSSourceOccurrence, MasterCSSSourceRange, MasterCSSStylesheetAncestor, MasterCSSStylesheetTokenReference, MasterCSSSyntaxStatus, MasterCSSTokenFamily, MasterCSSValidatorBatch, MasterCSSValueStatus } from "./protocol.js";
+import { MasterCSSBindingLoadOptions, MasterCSSNativeBindingLoadOptions, MasterCSSWasmBindingLoadOptions } from "./binding-options.js";
+import { MasterCSSLanguageBindingSession, MasterCSSLexerBindingSession, MasterCSSLintBindingSession, MasterCSSScannerBindingSession, MasterCSSSourceBindingSession, MasterCSSToolingBinding, MasterCSSToolingBindingSession, MasterCSSValidatorBindingSession } from "./tooling-binding-contract.js";
+declare function createToolingBinding(options?: MasterCSSBindingLoadOptions): Promise<MasterCSSToolingBinding>;
+export { MASTER_CSS_LANGUAGE_BATCH_VERSION, MASTER_CSS_LANGUAGE_VERSION, MASTER_CSS_LEXER_BATCH_VERSION, MASTER_CSS_LINT_BATCH_VERSION, MASTER_CSS_SOURCE_BATCH_VERSION, MASTER_CSS_VALIDATOR_BATCH_VERSION, type MasterCSSBindingLoadOptions, type MasterCSSBrowserSupport, type MasterCSSClassSuggestions, type MasterCSSDesignSystemCollision, type MasterCSSDesignSystemComponent, type MasterCSSDesignSystemDiagnostic, type MasterCSSDesignSystemReport, type MasterCSSDesignSystemRequest, type MasterCSSDesignSystemStylesheet, type MasterCSSDesignTokenMetadata, type MasterCSSDiagnostic, type MasterCSSEngineSnapshot, type MasterCSSEngineTransition, type MasterCSSLanguageBindingSession, type MasterCSSLanguageClassifications, type MasterCSSLanguageInspection, type MasterCSSLanguageTokenFamilies, type MasterCSSLexerBatch, type MasterCSSLexerBatchRequest, type MasterCSSLexerBindingSession, type MasterCSSLexerCSSAnalysis, type MasterCSSLexerClassListInput, type MasterCSSLexerClassListItem, type MasterCSSLintBatch, type MasterCSSLintBindingSession, type MasterCSSLintCanonicalClassGroupSuggestions, type MasterCSSLintCanonicalClassSuggestions, type MasterCSSLintRawValueCandidates, type MasterCSSMatchStatus, type MasterCSSNativeBindingLoadOptions, type MasterCSSNativeDeclarationCandidate, type MasterCSSScannerBindingSession, type MasterCSSScannerSourceInput, type MasterCSSScannerSourceOptions, type MasterCSSScannerState, type MasterCSSScannerUpdate, type MasterCSSSourceBatch, type MasterCSSSourceBatchRequest, type MasterCSSSourceBindingSession, type MasterCSSSourceExtractorKind, type MasterCSSSourceOccurrence, type MasterCSSSourceRange, type MasterCSSStylesheetAncestor, type MasterCSSStylesheetTokenReference, type MasterCSSSyntaxStatus, type MasterCSSTokenFamily, type MasterCSSToolingBinding, type MasterCSSToolingBindingSession, type MasterCSSValidatorBatch, type MasterCSSValidatorBindingSession, type MasterCSSValueStatus, type MasterCSSWasmBindingLoadOptions, createToolingBinding };

package/dist/tooling-binding-browser.js

@@ -0,0 +1,15 @@
+import { MASTER_CSS_LANGUAGE_BATCH_VERSION, MASTER_CSS_LANGUAGE_VERSION, MASTER_CSS_LEXER_BATCH_VERSION, MASTER_CSS_LINT_BATCH_VERSION, MASTER_CSS_SOURCE_BATCH_VERSION, MASTER_CSS_VALIDATOR_BATCH_VERSION } from "./protocol.js";
+import { callBindingAsync } from "./normalize-error.js";
+import { createWasmToolingBinding } from "./tooling-binding-wasm.js";
+import { MasterCSSError } from "@master/css-schema";
+import { createMasterCSSToolingWasmProvider } from "@master/css-binding-wasm-tooling";
+// src/tooling-binding-browser.ts
+function createToolingBinding(options = {}) {
+	if (options.binding === "native") throw new MasterCSSError({
+		code: "NATIVE_UNAVAILABLE",
+		domain: "binding",
+		message: "Master CSS native tooling bindings are unavailable in browsers."
+	});
+	return callBindingAsync("tooling", () => createWasmToolingBinding(options.wasm, createMasterCSSToolingWasmProvider));
+}
+export { MASTER_CSS_LANGUAGE_BATCH_VERSION, MASTER_CSS_LANGUAGE_VERSION, MASTER_CSS_LEXER_BATCH_VERSION, MASTER_CSS_LINT_BATCH_VERSION, MASTER_CSS_SOURCE_BATCH_VERSION, MASTER_CSS_VALIDATOR_BATCH_VERSION, createToolingBinding };

package/dist/tooling-binding-contract.d.ts

@@ -0,0 +1,92 @@
+import { MasterCSSBindingInfo, MasterCSSClassSuggestions, MasterCSSDesignSystemReport, MasterCSSDesignSystemRequest, MasterCSSDiagnosticsReportInput, MasterCSSEngineTransition, MasterCSSInspectionReport, MasterCSSLanguageClassifications, MasterCSSLanguageColorCandidateInput, MasterCSSLanguageColorPresentation, MasterCSSLanguageColorTokens, MasterCSSLanguageCompletionIndex, MasterCSSLanguageDocument, MasterCSSLanguageDocumentRequest, MasterCSSLanguageFormatEdits, MasterCSSLanguageFormatRequest, MasterCSSLanguageInspection, MasterCSSLanguageNativeDeclarationCompletion, MasterCSSLanguageNativeDeclarationCompletionRequest, MasterCSSLanguageTokenFamilies, MasterCSSLexerBatch, MasterCSSLexerBatchRequest, MasterCSSLintBatch, MasterCSSLintCanonicalClassGroupSuggestions, MasterCSSLintCanonicalClassNameOptions, MasterCSSLintCanonicalClassSuggestions, MasterCSSLintClassList, MasterCSSLintClassListPolicyRequest, MasterCSSLintHostValidation, MasterCSSLintRawValueCandidates, MasterCSSNativeDeclarationCandidate, MasterCSSRegex, MasterCSSResolvedBinding, MasterCSSScannerSourceInput, MasterCSSScannerSourceOptions, MasterCSSScannerState, MasterCSSScannerUpdate, MasterCSSSourceBatch, MasterCSSSourceBatchRequest, MasterCSSValidatorBatch } from "./protocol.js";
+import { MasterCSSBindingLoadOptions, MasterCSSNativeBindingLoadOptions, MasterCSSWasmBindingLoadOptions } from "./binding-options.js";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+interface MasterCSSToolingBindingSession extends Disposable {
+  dispose(): void;
+}
+interface MasterCSSLexerBindingSession extends MasterCSSToolingBindingSession {
+  analyze(request: MasterCSSLexerBatchRequest): MasterCSSLexerBatch;
+}
+interface MasterCSSSourceBindingSession extends MasterCSSToolingBindingSession {
+  extract(request: MasterCSSSourceBatchRequest): MasterCSSSourceBatch;
+}
+interface MasterCSSValidatorBindingSession extends MasterCSSToolingBindingSession {
+  nativeDeclarationCandidates(classNames: readonly string[]): readonly MasterCSSNativeDeclarationCandidate[];
+  generateClassRules(classNames: readonly string[], nativeSupport?: readonly boolean[]): MasterCSSValidatorBatch;
+}
+interface MasterCSSLanguagePreparedDocument {
+  readonly id: number;
+  readonly nativeCandidates: readonly MasterCSSNativeDeclarationCandidate[];
+}
+interface MasterCSSLanguageBindingSession extends MasterCSSToolingBindingSession {
+  prepareDocument(request: MasterCSSLanguageDocumentRequest): MasterCSSLanguagePreparedDocument;
+  finishDocument(id: number, nativeSupport: readonly boolean[]): MasterCSSLanguageDocument;
+  cancelDocument(id: number): void;
+  analyzeDocument(request: MasterCSSLanguageDocumentRequest): MasterCSSLanguageDocument;
+  formatDirectives(request: MasterCSSLanguageFormatRequest): MasterCSSLanguageFormatEdits;
+  nativeDeclarationCompletion(request: MasterCSSLanguageNativeDeclarationCompletionRequest): MasterCSSLanguageNativeDeclarationCompletion | null;
+  nativeDeclarationCandidates(classNames: readonly string[]): readonly MasterCSSNativeDeclarationCandidate[];
+  classifyClassNames(classNames: readonly string[], nativeSupport?: readonly boolean[]): MasterCSSLanguageClassifications;
+  inspectClassName(className: string, nativeSupport?: readonly boolean[]): MasterCSSLanguageInspection;
+  tokenFamilies(): MasterCSSLanguageTokenFamilies;
+  completionIndex(): MasterCSSLanguageCompletionIndex;
+  colorPresentation(colorToken: string): MasterCSSLanguageColorPresentation;
+  colorTokens(candidates: readonly MasterCSSLanguageColorCandidateInput[]): MasterCSSLanguageColorTokens;
+}
+interface MasterCSSLintBindingSession extends MasterCSSToolingBindingSession {
+  suggestClasses(declarations: string): MasterCSSClassSuggestions;
+  inspectDesignSystem(request: MasterCSSDesignSystemRequest): MasterCSSDesignSystemReport;
+  nativeDeclarationCandidates(classNames: readonly string[]): readonly MasterCSSNativeDeclarationCandidate[];
+  resolveValidation(batch: MasterCSSValidatorBatch, ruleErrors: readonly (readonly (readonly string[])[])[]): MasterCSSLintHostValidation;
+  canonicalClassNames(classNames: readonly string[], nativeSupport: readonly boolean[] | undefined, options?: Partial<MasterCSSLintCanonicalClassNameOptions>): MasterCSSLintCanonicalClassSuggestions;
+  canonicalClassGroups(classNames: readonly string[], nativeSupport: readonly boolean[] | undefined, options?: Partial<MasterCSSLintCanonicalClassNameOptions>): MasterCSSLintCanonicalClassGroupSuggestions;
+  rawValueCandidates(classNames: readonly string[], nativeSupport: readonly boolean[] | undefined, invalidGeneratedClasses: readonly string[]): MasterCSSLintRawValueCandidates;
+  analyze(classNames: readonly string[], nativeSupport: readonly boolean[] | undefined, invalidGeneratedClasses: readonly string[]): MasterCSSLintBatch;
+  analyzeClassList(classList: string, classNames: readonly string[], nativeSupport: readonly boolean[] | undefined, invalidGeneratedClasses: readonly string[]): MasterCSSLintBatch;
+  analyzeClassListPolicy(request: MasterCSSLintClassListPolicyRequest): MasterCSSLintClassList;
+}
+interface MasterCSSScannerBindingSession extends MasterCSSToolingBindingSession {
+  scan(source: string, content: string): MasterCSSScannerUpdate;
+  extractCandidates(source: string, content: string, options?: MasterCSSScannerSourceOptions): readonly string[];
+  collectCandidates(candidates: readonly string[]): readonly string[];
+  filterCandidates(candidates: readonly string[], blocklist: readonly (string | MasterCSSRegex)[]): readonly string[];
+  scanCandidates(source: string, content: string, candidates: readonly string[], blocklist: readonly (string | MasterCSSRegex)[], options?: MasterCSSScannerSourceOptions): MasterCSSScannerUpdate;
+  removeSource(source: string, options?: MasterCSSScannerSourceOptions): MasterCSSScannerUpdate;
+  reconcileSources(owner: string, inputs: readonly MasterCSSScannerSourceInput[]): MasterCSSScannerUpdate;
+  removeOwner(owner: string): MasterCSSScannerUpdate;
+  ensureClassRules(classNames: readonly string[]): MasterCSSEngineTransition;
+  registerNativeClassNames(owner: string, classNames: readonly string[]): boolean;
+  reset(): void;
+  snapshot(): MasterCSSScannerState;
+}
+interface MasterCSSToolingBinding {
+  readonly info: MasterCSSBindingInfo;
+  readonly binding: MasterCSSResolvedBinding;
+  createLexerSession(): Promise<MasterCSSLexerBindingSession>;
+  createSourceSession(): Promise<MasterCSSSourceBindingSession>;
+  createValidatorSession(manifest: MasterCSSManifest): Promise<MasterCSSValidatorBindingSession>;
+  createLanguageSession(manifest: MasterCSSManifest): Promise<MasterCSSLanguageBindingSession>;
+  createLintSession(manifest: MasterCSSManifest): Promise<MasterCSSLintBindingSession>;
+  createScannerSession(manifest: MasterCSSManifest): Promise<MasterCSSScannerBindingSession>;
+  extractClassCandidates(content: string): readonly string[];
+  extractOxcClasses(source: string, content: string): readonly string[];
+  extractHTMLClasses(source: string, content: string): readonly string[];
+  extractAstroClasses(source: string, content: string): readonly string[];
+  createInspectionReport(input: MasterCSSDiagnosticsReportInput): Promise<MasterCSSInspectionReport>;
+}
+interface MasterCSSToolingBindingSync {
+  readonly info: MasterCSSBindingInfo;
+  readonly binding: 'native';
+  createLexerSession(): MasterCSSLexerBindingSession;
+  createSourceSession(): MasterCSSSourceBindingSession;
+  createValidatorSession(manifest: MasterCSSManifest): MasterCSSValidatorBindingSession;
+  createLanguageSession(manifest: MasterCSSManifest): MasterCSSLanguageBindingSession;
+  createLintSession(manifest: MasterCSSManifest): MasterCSSLintBindingSession;
+  createScannerSession(manifest: MasterCSSManifest): MasterCSSScannerBindingSession;
+  extractClassCandidates(content: string): readonly string[];
+  extractOxcClasses(source: string, content: string): readonly string[];
+  extractHTMLClasses(source: string, content: string): readonly string[];
+  extractAstroClasses(source: string, content: string): readonly string[];
+  createInspectionReport(input: MasterCSSDiagnosticsReportInput): MasterCSSInspectionReport;
+}
+export { type MasterCSSBindingLoadOptions, MasterCSSLanguageBindingSession, MasterCSSLanguagePreparedDocument, MasterCSSLexerBindingSession, MasterCSSLintBindingSession, type MasterCSSNativeBindingLoadOptions, MasterCSSScannerBindingSession, MasterCSSSourceBindingSession, MasterCSSToolingBinding, MasterCSSToolingBindingSession, MasterCSSToolingBindingSync, MasterCSSValidatorBindingSession, type MasterCSSWasmBindingLoadOptions };

package/dist/tooling-binding-native.js

@@ -0,0 +1,46 @@
+import { callBinding } from "./normalize-error.js";
+import { protectToolingSession } from "./tooling-binding-adapter.js";
+import { loadNativeToolingBinding } from "./tooling.js";
+// src/tooling-binding-native.ts
+function createNativeToolingBinding(options, required) {
+	const native = loadNativeToolingBinding({
+		...options,
+		required
+	});
+	if (!native) return;
+	const bound = {
+		binding: "native",
+		info: native.info,
+		createLexerSession: () => protectToolingSession(native.createLexerSession()),
+		createSourceSession: () => protectToolingSession(native.createSourceSession()),
+		createValidatorSession: (manifest) => protectToolingSession(native.createValidatorSession(manifest)),
+		createLanguageSession: (manifest) => protectToolingSession(native.createLanguageSession(manifest)),
+		createLintSession: (manifest) => protectToolingSession(native.createLintSession(manifest)),
+		createScannerSession: (manifest) => protectToolingSession(native.createScannerSession(manifest)),
+		extractClassCandidates: (content) => callBinding("tooling", () => native.extractClassCandidates(content), content),
+		extractOxcClasses: (source, content) => callBinding("tooling", () => native.extractOxcClasses(source, content), content),
+		extractHTMLClasses: (source, content) => callBinding("tooling", () => native.extractHTMLClasses(source, content), content),
+		extractAstroClasses: (source, content) => callBinding("tooling", () => native.extractAstroClasses(source, content), content),
+		createInspectionReport: (input) => callBinding("tooling", () => native.createInspectionReport(input))
+	};
+	return Object.freeze(bound);
+}
+function asAsyncToolingBinding(binding) {
+	const bound = {
+		binding: binding.binding,
+		info: binding.info,
+		createLexerSession: async () => binding.createLexerSession(),
+		createSourceSession: async () => binding.createSourceSession(),
+		createValidatorSession: async (manifest) => binding.createValidatorSession(manifest),
+		createLanguageSession: async (manifest) => binding.createLanguageSession(manifest),
+		createLintSession: async (manifest) => binding.createLintSession(manifest),
+		createScannerSession: async (manifest) => binding.createScannerSession(manifest),
+		extractClassCandidates: (content) => binding.extractClassCandidates(content),
+		extractOxcClasses: (source, content) => binding.extractOxcClasses(source, content),
+		extractHTMLClasses: (source, content) => binding.extractHTMLClasses(source, content),
+		extractAstroClasses: (source, content) => binding.extractAstroClasses(source, content),
+		createInspectionReport: async (input) => binding.createInspectionReport(input)
+	};
+	return Object.freeze(bound);
+}
+export { asAsyncToolingBinding, createNativeToolingBinding };

package/dist/tooling-binding-node.d.ts

@@ -0,0 +1,4 @@
+import { MasterCSSNativeBindingLoadOptions } from "./binding-options.js";
+import { MasterCSSLanguageBindingSession, MasterCSSLexerBindingSession, MasterCSSLintBindingSession, MasterCSSScannerBindingSession, MasterCSSSourceBindingSession, MasterCSSToolingBindingSession, MasterCSSToolingBindingSync, MasterCSSValidatorBindingSession } from "./tooling-binding-contract.js";
+declare function createToolingBindingSync(options?: MasterCSSNativeBindingLoadOptions): MasterCSSToolingBindingSync;
+export { type MasterCSSLanguageBindingSession, type MasterCSSLexerBindingSession, type MasterCSSLintBindingSession, type MasterCSSNativeBindingLoadOptions, type MasterCSSScannerBindingSession, type MasterCSSSourceBindingSession, type MasterCSSToolingBindingSession, type MasterCSSToolingBindingSync, type MasterCSSValidatorBindingSession, createToolingBindingSync };

package/dist/tooling-binding-node.js

@@ -0,0 +1,11 @@
+import { normalizeBindingError } from "./normalize-error.js";
+import { createNativeToolingBinding } from "./tooling-binding-native.js";
+// src/tooling-binding-node.ts
+function createToolingBindingSync(options = {}) {
+	try {
+		return createNativeToolingBinding(options, true);
+	} catch (cause) {
+		throw normalizeBindingError(cause, "tooling");
+	}
+}
+export { createToolingBindingSync };

package/dist/tooling-binding-wasm.js

@@ -0,0 +1,127 @@
+import { assertMasterCSSBindingInfo } from "./binding.js";
+import { callBinding, callBindingAsync } from "./normalize-error.js";
+import { protectToolingSession } from "./tooling-binding-adapter.js";
+import { serializeMasterCSSManifest } from "@master/css-schema/manifest";
+// src/tooling-binding-wasm.ts
+async function loadDefaultWasmProvider(options) {
+	const { createMasterCSSToolingWasmProvider } = await import("@master/css-binding-wasm-tooling");
+	return await createMasterCSSToolingWasmProvider(options);
+}
+function withLifecycle(session) {
+	let disposed = false;
+	const dispose = () => {
+		if (disposed) return;
+		disposed = true;
+		session.dispose();
+	};
+	return {
+		dispose,
+		[Symbol.dispose]: dispose
+	};
+}
+async function createWasmToolingBinding(options, providerFactory = loadDefaultWasmProvider) {
+	const wasm = await providerFactory(options);
+	assertMasterCSSBindingInfo(wasm.info, {
+		surface: "tooling",
+		features: [
+			"diagnostics",
+			"language",
+			"lint",
+			"scanner",
+			"source",
+			"validator"
+		]
+	});
+	const bound = {
+		binding: "wasm",
+		info: wasm.info,
+		async createLexerSession() {
+			const session = await callBindingAsync("tooling", () => wasm.createLexerSession());
+			const bound = {
+				...withLifecycle(session),
+				analyze: (request) => session.analyze(request)
+			};
+			return protectToolingSession(Object.freeze(bound));
+		},
+		async createSourceSession() {
+			const session = await callBindingAsync("tooling", () => wasm.createSourceSession());
+			const bound = {
+				...withLifecycle(session),
+				extract: (request) => session.extract(request)
+			};
+			return protectToolingSession(Object.freeze(bound));
+		},
+		async createValidatorSession(manifest) {
+			const session = await callBindingAsync("tooling", () => wasm.createValidatorSession(serializeMasterCSSManifest(manifest)));
+			const bound = {
+				...withLifecycle(session),
+				nativeDeclarationCandidates: (classNames) => session.nativeDeclarationCandidates([...classNames]),
+				generateClassRules: (classNames, nativeSupport) => session.generateClasses([...classNames], nativeSupport ? [...nativeSupport] : void 0)
+			};
+			return protectToolingSession(Object.freeze(bound));
+		},
+		async createLanguageSession(manifest) {
+			const session = await callBindingAsync("tooling", () => wasm.createLanguageSession(serializeMasterCSSManifest(manifest)));
+			const bound = {
+				...withLifecycle(session),
+				prepareDocument: (request) => session.prepareDocument(request),
+				finishDocument: (id, support) => session.finishDocument(id, [...support]),
+				cancelDocument: (id) => session.cancelDocument(id),
+				analyzeDocument: (request) => session.analyzeDocument(request),
+				formatDirectives: (request) => session.formatDirectives(request),
+				nativeDeclarationCompletion: (request) => session.nativeDeclarationCompletion(request),
+				nativeDeclarationCandidates: (classNames) => session.nativeDeclarationCandidates([...classNames]),
+				classifyClassNames: (classNames, nativeSupport) => session.classifyClassNames([...classNames], nativeSupport ? [...nativeSupport] : void 0),
+				inspectClassName: (className, nativeSupport) => session.inspectClassName(className, nativeSupport ? [...nativeSupport] : void 0),
+				tokenFamilies: () => session.tokenFamilies(),
+				completionIndex: () => session.completionIndex(),
+				colorPresentation: (colorToken) => session.colorPresentation(colorToken),
+				colorTokens: (candidates) => session.colorTokens(candidates)
+			};
+			return protectToolingSession(Object.freeze(bound));
+		},
+		async createLintSession(manifest) {
+			const session = await callBindingAsync("tooling", () => wasm.createLintSession(serializeMasterCSSManifest(manifest)));
+			const bound = {
+				...withLifecycle(session),
+				inspectDesignSystem: (request) => session.inspectDesignSystem(request),
+				suggestClasses: (declarations) => session.suggestClasses(declarations),
+				nativeDeclarationCandidates: (classNames) => session.nativeDeclarationCandidates([...classNames]),
+				resolveValidation: (batch, ruleErrors) => session.resolveValidation(batch, ruleErrors),
+				canonicalClassNames: (classNames, nativeSupport, lintOptions) => session.canonicalClassNames([...classNames], nativeSupport ? [...nativeSupport] : void 0, lintOptions),
+				canonicalClassGroups: (classNames, nativeSupport, lintOptions) => session.canonicalClassGroups([...classNames], nativeSupport ? [...nativeSupport] : void 0, lintOptions),
+				rawValueCandidates: (classNames, nativeSupport, invalidGeneratedClasses) => session.rawValueCandidates([...classNames], nativeSupport ? [...nativeSupport] : void 0, [...invalidGeneratedClasses]),
+				analyze: (classNames, nativeSupport, invalidGeneratedClasses) => session.analyze([...classNames], nativeSupport ? [...nativeSupport] : void 0, [...invalidGeneratedClasses]),
+				analyzeClassList: (classList, classNames, nativeSupport, invalidGeneratedClasses) => session.analyzeClassList(classList, [...classNames], nativeSupport ? [...nativeSupport] : void 0, [...invalidGeneratedClasses]),
+				analyzeClassListPolicy: (request) => session.analyzeClassListPolicy(typeof request === "string" ? request : JSON.stringify(request))
+			};
+			return protectToolingSession(Object.freeze(bound));
+		},
+		async createScannerSession(manifest) {
+			const session = await callBindingAsync("tooling", () => wasm.createScannerSession(serializeMasterCSSManifest(manifest)));
+			const bound = {
+				...withLifecycle(session),
+				scan: (source, content) => session.scan(source, content),
+				extractCandidates: (source, content, options = {}) => session.extractCandidates(source, content, options),
+				collectCandidates: (candidates) => session.collectCandidates([...candidates]),
+				filterCandidates: (candidates, blocklist) => session.filterCandidates([...candidates], blocklist),
+				scanCandidates: (source, content, candidates, blocklist, options = {}) => session.scanCandidates(source, content, [...candidates], blocklist, options),
+				removeSource: (source, options = {}) => session.removeSource(source, options),
+				reconcileSources: (owner, inputs) => session.reconcileSources(owner, inputs),
+				removeOwner: (owner) => session.removeOwner(owner),
+				ensureClassRules: (classNames) => session.ensureClasses([...classNames]),
+				registerNativeClassNames: (owner, classNames) => session.registerNativeClasses(owner, [...classNames]),
+				reset: () => session.reset(),
+				snapshot: () => session.state()
+			};
+			return protectToolingSession(Object.freeze(bound));
+		},
+		extractClassCandidates: (content) => callBinding("tooling", () => wasm.extractClassCandidates(content), content),
+		extractOxcClasses: (source, content) => callBinding("tooling", () => wasm.extractOxcClasses(source, content), content),
+		extractHTMLClasses: (source, content) => callBinding("tooling", () => wasm.extractHTMLClasses(source, content), content),
+		extractAstroClasses: (source, content) => callBinding("tooling", () => wasm.extractAstroClasses(source, content), content),
+		createInspectionReport: (input) => callBindingAsync("tooling", () => wasm.createInspectionReport(input))
+	};
+	return Object.freeze(bound);
+}
+export { createWasmToolingBinding };

package/dist/tooling-binding.d.ts

@@ -0,0 +1,5 @@
+import { MASTER_CSS_LANGUAGE_BATCH_VERSION, MASTER_CSS_LANGUAGE_VERSION, MASTER_CSS_LEXER_BATCH_VERSION, MASTER_CSS_LINT_BATCH_VERSION, MASTER_CSS_SOURCE_BATCH_VERSION, MASTER_CSS_VALIDATOR_BATCH_VERSION, MasterCSSBrowserSupport, MasterCSSClassSuggestions, MasterCSSDesignSystemCollision, MasterCSSDesignSystemComponent, MasterCSSDesignSystemDiagnostic, MasterCSSDesignSystemReport, MasterCSSDesignSystemRequest, MasterCSSDesignSystemStylesheet, MasterCSSDesignTokenMetadata, MasterCSSDiagnostic, MasterCSSEngineSnapshot, MasterCSSEngineTransition, MasterCSSLanguageClassifications, MasterCSSLanguageInspection, MasterCSSLanguageTokenFamilies, MasterCSSLexerBatch, MasterCSSLexerBatchRequest, MasterCSSLexerCSSAnalysis, MasterCSSLexerClassListInput, MasterCSSLexerClassListItem, MasterCSSLintBatch, MasterCSSLintCanonicalClassGroupSuggestions, MasterCSSLintCanonicalClassSuggestions, MasterCSSLintRawValueCandidates, MasterCSSMatchStatus, MasterCSSNativeDeclarationCandidate, MasterCSSScannerSourceInput, MasterCSSScannerSourceOptions, MasterCSSScannerState, MasterCSSScannerUpdate, MasterCSSSourceBatch, MasterCSSSourceBatchRequest, MasterCSSSourceExtractorKind, MasterCSSSourceOccurrence, MasterCSSSourceRange, MasterCSSStylesheetAncestor, MasterCSSStylesheetTokenReference, MasterCSSSyntaxStatus, MasterCSSTokenFamily, MasterCSSValidatorBatch, MasterCSSValueStatus } from "./protocol.js";
+import { MasterCSSBindingLoadOptions, MasterCSSNativeBindingLoadOptions, MasterCSSWasmBindingLoadOptions } from "./binding-options.js";
+import { MasterCSSLanguageBindingSession, MasterCSSLexerBindingSession, MasterCSSLintBindingSession, MasterCSSScannerBindingSession, MasterCSSSourceBindingSession, MasterCSSToolingBinding, MasterCSSToolingBindingSession, MasterCSSValidatorBindingSession } from "./tooling-binding-contract.js";
+declare function createToolingBinding(options?: MasterCSSBindingLoadOptions): Promise<MasterCSSToolingBinding>;
+export { MASTER_CSS_LANGUAGE_BATCH_VERSION, MASTER_CSS_LANGUAGE_VERSION, MASTER_CSS_LEXER_BATCH_VERSION, MASTER_CSS_LINT_BATCH_VERSION, MASTER_CSS_SOURCE_BATCH_VERSION, MASTER_CSS_VALIDATOR_BATCH_VERSION, type MasterCSSBindingLoadOptions, type MasterCSSBrowserSupport, type MasterCSSClassSuggestions, type MasterCSSDesignSystemCollision, type MasterCSSDesignSystemComponent, type MasterCSSDesignSystemDiagnostic, type MasterCSSDesignSystemReport, type MasterCSSDesignSystemRequest, type MasterCSSDesignSystemStylesheet, type MasterCSSDesignTokenMetadata, type MasterCSSDiagnostic, type MasterCSSEngineSnapshot, type MasterCSSEngineTransition, type MasterCSSLanguageBindingSession, type MasterCSSLanguageClassifications, type MasterCSSLanguageInspection, type MasterCSSLanguageTokenFamilies, type MasterCSSLexerBatch, type MasterCSSLexerBatchRequest, type MasterCSSLexerBindingSession, type MasterCSSLexerCSSAnalysis, type MasterCSSLexerClassListInput, type MasterCSSLexerClassListItem, type MasterCSSLintBatch, type MasterCSSLintBindingSession, type MasterCSSLintCanonicalClassGroupSuggestions, type MasterCSSLintCanonicalClassSuggestions, type MasterCSSLintRawValueCandidates, type MasterCSSMatchStatus, type MasterCSSNativeBindingLoadOptions, type MasterCSSNativeDeclarationCandidate, type MasterCSSScannerBindingSession, type MasterCSSScannerSourceInput, type MasterCSSScannerSourceOptions, type MasterCSSScannerState, type MasterCSSScannerUpdate, type MasterCSSSourceBatch, type MasterCSSSourceBatchRequest, type MasterCSSSourceBindingSession, type MasterCSSSourceExtractorKind, type MasterCSSSourceOccurrence, type MasterCSSSourceRange, type MasterCSSStylesheetAncestor, type MasterCSSStylesheetTokenReference, type MasterCSSSyntaxStatus, type MasterCSSTokenFamily, type MasterCSSToolingBinding, type MasterCSSToolingBindingSession, type MasterCSSValidatorBatch, type MasterCSSValidatorBindingSession, type MasterCSSValueStatus, type MasterCSSWasmBindingLoadOptions, createToolingBinding };

package/dist/tooling-binding.js

@@ -0,0 +1,21 @@
+import { MASTER_CSS_LANGUAGE_BATCH_VERSION, MASTER_CSS_LANGUAGE_VERSION, MASTER_CSS_LEXER_BATCH_VERSION, MASTER_CSS_LINT_BATCH_VERSION, MASTER_CSS_SOURCE_BATCH_VERSION, MASTER_CSS_VALIDATOR_BATCH_VERSION } from "./protocol.js";
+import { normalizeBindingError } from "./normalize-error.js";
+import { shouldLoadMasterCSSNativeBinding } from "./binding-options.js";
+import { createWasmToolingBinding } from "./tooling-binding-wasm.js";
+// src/tooling-binding.ts
+async function loadNativeToolingFactory() {
+	return await (import.meta.url.endsWith(".ts") ? import("./tooling-binding-native.js") : import("./tooling-binding-native.js"));
+}
+async function createToolingBinding(options = {}) {
+	try {
+		if (shouldLoadMasterCSSNativeBinding(options.binding)) {
+			const { asAsyncToolingBinding, createNativeToolingBinding } = await loadNativeToolingFactory();
+			const native = createNativeToolingBinding(options.native ?? {}, options.binding === "native");
+			if (native) return asAsyncToolingBinding(native);
+		}
+		return await createWasmToolingBinding(options.wasm);
+	} catch (cause) {
+		throw normalizeBindingError(cause, "tooling");
+	}
+}
+export { MASTER_CSS_LANGUAGE_BATCH_VERSION, MASTER_CSS_LANGUAGE_VERSION, MASTER_CSS_LEXER_BATCH_VERSION, MASTER_CSS_LINT_BATCH_VERSION, MASTER_CSS_SOURCE_BATCH_VERSION, MASTER_CSS_VALIDATOR_BATCH_VERSION, createToolingBinding };

package/dist/tooling.js

@@ -0,0 +1,144 @@
+import "./protocol.js";
+import { NativeBindingError } from "./errors.js";
+import { loadNativeBinding } from "./native-loader.js";
+import { MasterCSSError } from "@master/css-schema";
+import { serializeMasterCSSManifest } from "@master/css-schema/manifest";
+// src/tooling.ts
+function parse(value) {
+	return JSON.parse(value);
+}
+function request(value) {
+	return typeof value === "string" ? value : JSON.stringify(value);
+}
+function disposable(session) {
+	let disposed = false;
+	return () => {
+		if (disposed) return;
+		disposed = true;
+		session.dispose();
+	};
+}
+function bindingError(cause) {
+	if (cause instanceof MasterCSSError) return cause;
+	const code = cause instanceof NativeBindingError ? cause.code : "NATIVE_LOAD_FAILED";
+	return new MasterCSSError({
+		code,
+		domain: "binding",
+		message: cause instanceof Error ? cause.message : String(cause)
+	}, { cause });
+}
+function loadNativeToolingBinding(moduleOptions = {}) {
+	try {
+		const loaded = loadNativeBinding(moduleOptions);
+		if (!loaded) return;
+		const nativeBinding = loaded.binding;
+		const toolingBinding = {
+			info: loaded.info,
+			createLexerSession() {
+				const session = new nativeBinding.LexerSession();
+				const dispose = disposable(session);
+				return {
+					analyze: (input) => parse(session.analyze(request(input))),
+					dispose,
+					[Symbol.dispose]: dispose
+				};
+			},
+			createSourceSession() {
+				const session = new nativeBinding.SourceSession();
+				const dispose = disposable(session);
+				return {
+					extract: (input) => parse(session.extract(request(input))),
+					dispose,
+					[Symbol.dispose]: dispose
+				};
+			},
+			createValidatorSession(manifest) {
+				const session = new nativeBinding.ValidatorSession(serializeMasterCSSManifest(manifest));
+				const dispose = disposable(session);
+				return {
+					nativeDeclarationCandidates: (classNames) => parse(session.nativeDeclarationCandidates([...classNames])),
+					generateClassRules: (classNames, nativeSupport) => parse(session.generateClasses([...classNames], nativeSupport ? [...nativeSupport] : void 0)),
+					dispose,
+					[Symbol.dispose]: dispose
+				};
+			},
+			createLanguageSession(manifest) {
+				const session = new nativeBinding.LanguageSession(serializeMasterCSSManifest(manifest));
+				const dispose = disposable(session);
+				return {
+					prepareDocument: (input) => parse(session.prepareDocument(request(input))),
+					finishDocument: (id, support) => {
+						try {
+							return parse(session.finishDocument(id, [...support]));
+						} finally {
+							session.cancelDocument(id);
+						}
+					},
+					cancelDocument: (id) => session.cancelDocument(id),
+					analyzeDocument: (input) => parse(session.analyzeDocument(request(input))),
+					formatDirectives: (input) => parse(session.formatDirectives(request(input))),
+					nativeDeclarationCompletion: (input) => parse(session.nativeDeclarationCompletion(request(input))),
+					nativeDeclarationCandidates: (classNames) => parse(session.nativeDeclarationCandidates([...classNames])),
+					classifyClassNames: (classNames, nativeSupport) => parse(session.classifyClassNames([...classNames], nativeSupport ? [...nativeSupport] : void 0)),
+					inspectClassName: (className, nativeSupport) => parse(session.inspectClassName(className, nativeSupport ? [...nativeSupport] : void 0)),
+					tokenFamilies: () => parse(session.tokenFamilies()),
+					completionIndex: () => parse(session.completionIndex()),
+					colorPresentation: (colorToken) => parse(session.colorPresentation(colorToken)),
+					colorTokens: (candidates) => parse(session.colorTokens(request(candidates))),
+					dispose,
+					[Symbol.dispose]: dispose
+				};
+			},
+			createLintSession(manifest) {
+				const session = new nativeBinding.LintSession(serializeMasterCSSManifest(manifest));
+				const dispose = disposable(session);
+				return {
+					suggestClasses: (declarations) => {
+						if (typeof session.suggestClasses !== "function") throw new Error("The native binding does not support suggestClasses. Rebuild or update the Master CSS binding to match the tooling package.");
+						return parse(session.suggestClasses(declarations));
+					},
+					inspectDesignSystem: (input) => parse(session.inspectDesignSystem(request(input))),
+					nativeDeclarationCandidates: (classNames) => parse(session.nativeDeclarationCandidates([...classNames])),
+					resolveValidation: (batch, ruleErrors) => parse(session.resolveValidation(request(batch), request(ruleErrors))),
+					canonicalClassNames: (classNames, nativeSupport, options) => parse(session.canonicalClassNames([...classNames], nativeSupport ? [...nativeSupport] : void 0, options === void 0 ? void 0 : request(options))),
+					canonicalClassGroups: (classNames, nativeSupport, options) => parse(session.canonicalClassGroups([...classNames], nativeSupport ? [...nativeSupport] : void 0, options === void 0 ? void 0 : request(options))),
+					rawValueCandidates: (classNames, nativeSupport, invalidGeneratedClasses) => parse(session.rawValueCandidates([...classNames], nativeSupport ? [...nativeSupport] : void 0, [...invalidGeneratedClasses])),
+					analyze: (classNames, nativeSupport, invalidGeneratedClasses) => parse(session.analyze([...classNames], nativeSupport ? [...nativeSupport] : void 0, [...invalidGeneratedClasses])),
+					analyzeClassList: (classList, classNames, nativeSupport, invalidGeneratedClasses) => parse(session.analyzeClassList(classList, [...classNames], nativeSupport ? [...nativeSupport] : void 0, [...invalidGeneratedClasses])),
+					analyzeClassListPolicy: (input) => parse(session.analyzeClassListPolicy(request(input))),
+					dispose,
+					[Symbol.dispose]: dispose
+				};
+			},
+			createScannerSession(manifest) {
+				const session = new nativeBinding.ScannerSession(serializeMasterCSSManifest(manifest));
+				const dispose = disposable(session);
+				return {
+					scan: (source, content) => parse(session.scan(source, content)),
+					extractCandidates: (source, content, options = {}) => session.extractCandidates(source, content, request(options)),
+					collectCandidates: (candidates) => session.collectCandidates([...candidates]),
+					filterCandidates: (candidates, blocklist) => session.filterCandidates([...candidates], request(blocklist)),
+					scanCandidates: (source, content, candidates, blocklist, options = {}) => parse(session.scanCandidates(source, content, [...candidates], request(blocklist), request(options))),
+					removeSource: (source, options = {}) => parse(session.removeSource(source, request(options))),
+					reconcileSources: (owner, inputs) => parse(session.reconcileSources(owner, request(inputs))),
+					removeOwner: (owner) => parse(session.removeOwner(owner)),
+					ensureClassRules: (classNames) => parse(session.ensureClasses([...classNames])),
+					registerNativeClassNames: (owner, classNames) => session.registerNativeClasses(owner, [...classNames]),
+					reset: () => session.reset(),
+					snapshot: () => parse(session.state()),
+					dispose,
+					[Symbol.dispose]: dispose
+				};
+			},
+			extractClassCandidates: (content) => nativeBinding.extractClassCandidates(content),
+			extractOxcClasses: (source, content) => nativeBinding.extractOxcClasses(source, content),
+			extractHTMLClasses: (source, content) => nativeBinding.extractHtmlClasses(source, content),
+			extractAstroClasses: (source, content) => nativeBinding.extractAstroClasses(source, content),
+			createInspectionReport: (input) => parse(nativeBinding.createInspectionReportJson(request(input)))
+		};
+		return Object.freeze(toolingBinding);
+	} catch (cause) {
+		throw bindingError(cause);
+	}
+}
+export { loadNativeToolingBinding };

package/dist/version.js

@@ -0,0 +1,3 @@
+// src/version.ts
+const MASTER_CSS_PACKAGE_VERSION = "0.0.0";
+export { MASTER_CSS_PACKAGE_VERSION };

package/package.json

@@ -0,0 +1,78 @@
+{
+    "name": "@master/css-binding",
+    "type": "module",
+    "engines": {
+        "node": "^24"
+    },
+    "license": "MIT",
+    "description": "Internal Master CSS native and Wasm binding loader.",
+    "sideEffects": false,
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "browser": "./dist/browser.js",
+            "import": "./dist/index.js",
+            "default": "./dist/index.js"
+        },
+        "./engine": {
+            "types": "./dist/engine-binding.d.ts",
+            "browser": "./dist/engine-binding-browser.js",
+            "import": "./dist/engine-binding.js",
+            "default": "./dist/engine-binding.js"
+        },
+        "./engine/node": {
+            "types": "./dist/engine-binding-node.d.ts",
+            "import": "./dist/engine-binding-node.js",
+            "default": "./dist/engine-binding-node.js"
+        },
+        "./compiler": {
+            "types": "./dist/compiler-binding.d.ts",
+            "browser": "./dist/compiler-binding-browser.js",
+            "import": "./dist/compiler-binding.js",
+            "default": "./dist/compiler-binding.js"
+        },
+        "./compiler/node": {
+            "types": "./dist/compiler-binding-node.d.ts",
+            "import": "./dist/compiler-binding-node.js",
+            "default": "./dist/compiler-binding-node.js"
+        },
+        "./tooling": {
+            "types": "./dist/tooling-binding.d.ts",
+            "browser": "./dist/tooling-binding-browser.js",
+            "import": "./dist/tooling-binding.js",
+            "default": "./dist/tooling-binding.js"
+        },
+        "./tooling/node": {
+            "types": "./dist/tooling-binding-node.d.ts",
+            "import": "./dist/tooling-binding-node.js",
+            "default": "./dist/tooling-binding-node.js"
+        }
+    },
+    "files": [
+        "dist",
+        "artifacts"
+    ],
+    "publishConfig": {
+        "access": "public",
+        "provenance": true
+    },
+    "optionalDependencies": {
+        "@master/css-binding-darwin-arm64": "0.0.0-site.1793659883.g69c9aebcf628",
+        "@master/css-binding-darwin-x64": "0.0.0-site.1793659883.g69c9aebcf628",
+        "@master/css-binding-linux-arm64-gnu": "0.0.0-site.1793659883.g69c9aebcf628",
+        "@master/css-binding-linux-arm64-musl": "0.0.0-site.1793659883.g69c9aebcf628",
+        "@master/css-binding-linux-x64-gnu": "0.0.0-site.1793659883.g69c9aebcf628",
+        "@master/css-binding-linux-x64-musl": "0.0.0-site.1793659883.g69c9aebcf628",
+        "@master/css-binding-win32-arm64-msvc": "0.0.0-site.1793659883.g69c9aebcf628",
+        "@master/css-binding-win32-x64-msvc": "0.0.0-site.1793659883.g69c9aebcf628"
+    },
+    "dependencies": {
+        "@master/css-schema": "0.0.0-site.1793659883.g69c9aebcf628",
+        "@master/css-binding-wasm-compiler": "0.0.0-site.1793659883.g69c9aebcf628",
+        "@master/css-binding-wasm-engine": "0.0.0-site.1793659883.g69c9aebcf628",
+        "@master/css-binding-wasm-tooling": "0.0.0-site.1793659883.g69c9aebcf628"
+    },
+    "version": "0.0.0-site.1793659883.g69c9aebcf628",
+    "gitHead": "69c9aebcf628eb529001b9fa1b3536306f1b139e"
+}