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

package/dist/binding-options.d.ts

@@ -0,0 +1,14 @@
+import { MasterCSSBinding } from "./protocol.js";
+interface MasterCSSNativeBindingLoadOptions {
+  readonly bindingPath?: string;
+}
+interface MasterCSSWasmBindingLoadOptions {
+  readonly module?: object;
+  readonly input?: RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+}
+interface MasterCSSBindingLoadOptions {
+  readonly binding?: MasterCSSBinding;
+  readonly native?: MasterCSSNativeBindingLoadOptions;
+  readonly wasm?: MasterCSSWasmBindingLoadOptions;
+}
+export { MasterCSSBindingLoadOptions, MasterCSSNativeBindingLoadOptions, MasterCSSWasmBindingLoadOptions };

package/dist/binding-options.js

@@ -0,0 +1,15 @@
+import { MasterCSSError } from "@master/css-schema";
+// src/binding-options.ts
+function hasMasterCSSNodeRuntime() {
+	return typeof globalThis.process?.versions?.node === "string";
+}
+function shouldLoadMasterCSSNativeBinding(binding) {
+	const hasNode = hasMasterCSSNodeRuntime();
+	if (binding === "native" && !hasNode) throw new MasterCSSError({
+		code: "NATIVE_UNAVAILABLE",
+		domain: "binding",
+		message: "Master CSS native bindings are unavailable outside Node.js."
+	});
+	return binding !== "wasm" && hasNode;
+}
+export { hasMasterCSSNodeRuntime, shouldLoadMasterCSSNativeBinding };

package/dist/binding.d.ts

@@ -0,0 +1,12 @@
+import { MasterCSSBindingFeature, MasterCSSBindingInfo, MasterCSSBindingSurface } from "./protocol.js";
+interface MasterCSSBindingRequirements {
+  surface: MasterCSSBindingSurface;
+  features?: readonly MasterCSSBindingFeature[];
+  packageVersion?: string;
+}
+declare class MasterCSSBindingContractError extends Error {
+  readonly code = "BINDING_MISMATCH";
+  constructor(message: string, options?: ErrorOptions);
+}
+declare function assertMasterCSSBindingInfo(value: unknown, requirements: MasterCSSBindingRequirements): MasterCSSBindingInfo;
+export { MasterCSSBindingContractError, MasterCSSBindingRequirements, assertMasterCSSBindingInfo };

package/dist/binding.js

@@ -0,0 +1,23 @@
+import "./protocol.js";
+// src/binding.ts
+var MasterCSSBindingContractError = class extends Error {
+	code = "BINDING_MISMATCH";
+	constructor(message, options) {
+		super(message, options);
+		this.name = "MasterCSSBindingContractError";
+	}
+};
+function parseBindingInfo(value) {
+	if (!value || typeof value !== "object") throw new MasterCSSBindingContractError("Master CSS binding metadata must be an object.");
+	return value;
+}
+function assertMasterCSSBindingInfo(value, requirements) {
+	const info = parseBindingInfo(value);
+	const versionsMatch = info.bindingAbiVersion === 32 && info.manifestVersion === 6 && info.programVersion === 3 && info.languageVersion === 18 && info.hydrationManifestVersion === 5 && info.engineTransitionVersion === 5 && info.validatorBatchVersion === 4 && info.diagnosticsReportVersion === 5 && info.lintBatchVersion === 4 && info.languageBatchVersion === 8 && info.lexerBatchVersion === 1 && info.sourceBatchVersion === 2;
+	const packageMatches = requirements.packageVersion === void 0 || info.packageVersion === requirements.packageVersion;
+	const features = Array.isArray(info.features) ? new Set(info.features) : /* @__PURE__ */ new Set();
+	const missingFeatures = (requirements.features || []).filter((feature) => !features.has(feature));
+	if (!versionsMatch || !packageMatches || info.surface !== requirements.surface || missingFeatures.length) throw new MasterCSSBindingContractError(`Master CSS ${requirements.surface} binding contract mismatch.` + (missingFeatures.length ? ` Missing features: ${missingFeatures.join(", ")}.` : ""));
+	return info;
+}
+export { MasterCSSBindingContractError, assertMasterCSSBindingInfo };

package/dist/browser.d.ts

@@ -0,0 +1,3 @@
+import { MASTER_CSS_BINDING_ABI_VERSION, MASTER_CSS_HYDRATION_MANIFEST_VERSION, MASTER_CSS_MANIFEST_VERSION, MasterCSSBinding, MasterCSSBindingFeature, MasterCSSBindingInfo, MasterCSSBindingSurface, MasterCSSEngineResolvedBinding, MasterCSSResolvedBinding } from "./protocol.js";
+import { MasterCSSBindingContractError, MasterCSSBindingRequirements, assertMasterCSSBindingInfo } from "./binding.js";
+export { MASTER_CSS_BINDING_ABI_VERSION, MASTER_CSS_HYDRATION_MANIFEST_VERSION, MASTER_CSS_MANIFEST_VERSION, type MasterCSSBinding, MasterCSSBindingContractError, type MasterCSSBindingFeature, type MasterCSSBindingInfo, type MasterCSSBindingRequirements, type MasterCSSBindingSurface, type MasterCSSEngineResolvedBinding, type MasterCSSResolvedBinding, assertMasterCSSBindingInfo };

package/dist/browser.js

@@ -0,0 +1,3 @@
+import { MASTER_CSS_BINDING_ABI_VERSION, MASTER_CSS_HYDRATION_MANIFEST_VERSION, MASTER_CSS_MANIFEST_VERSION } from "./protocol.js";
+import { MasterCSSBindingContractError, assertMasterCSSBindingInfo } from "./binding.js";
+export { MASTER_CSS_BINDING_ABI_VERSION, MASTER_CSS_HYDRATION_MANIFEST_VERSION, MASTER_CSS_MANIFEST_VERSION, MasterCSSBindingContractError, assertMasterCSSBindingInfo };

package/dist/compiler-binding-adapter.js

@@ -0,0 +1,55 @@
+import { callBinding } from "./normalize-error.js";
+import { MasterCSSError } from "@master/css-schema";
+// src/compiler-binding-adapter.ts
+function unavailable(operation) {
+	throw new MasterCSSError({
+		code: "NATIVE_UNAVAILABLE",
+		domain: "compiler",
+		message: `${operation} requires the Master CSS native Node binding.`
+	});
+}
+function bindCompilerBindingSession(binding, operations) {
+	let disposed = false;
+	const invoke = (domain, operation, source) => {
+		if (disposed) throw new MasterCSSError({
+			code: "SESSION_DISPOSED",
+			domain: "compiler",
+			message: "The Master CSS compiler binding session has been disposed."
+		});
+		return callBinding(domain, operation, source);
+	};
+	const dispose = () => {
+		if (disposed) return;
+		disposed = true;
+		operations.dispose?.();
+	};
+	return Object.freeze({
+		binding,
+		findManifestEntries: (projectDir) => invoke("project", () => operations.findManifestEntries?.(projectDir) ?? unavailable("Project discovery")),
+		loadProjectManifest: (projectDir, baseManifest, entries) => invoke("project", () => operations.loadProjectManifest?.(projectDir, baseManifest, entries) ?? unavailable("Project manifest loading")),
+		loadPreparedProjectManifest: (projectDir, baseManifest, graphs) => invoke("project", () => operations.loadPreparedProjectManifest?.(projectDir, baseManifest, graphs) ?? unavailable("Prepared project manifest loading")),
+		compareProjectSnapshots: (request) => invoke("compiler", () => operations.compareProjectSnapshots(request)),
+		inspectCSS: (source) => invoke("compiler", () => operations.inspectCSS(source), source),
+		compileNativeCSS: (source, options) => invoke("compiler", () => operations.compileNativeCSS(source, options), source),
+		compileCSSDirectives: (source, options) => invoke("compiler", () => operations.compileCSSDirectives(source, options), source),
+		analyzeCSSDependencies: (source) => invoke("compiler", () => operations.analyzeCSSDependencies(source), source),
+		analyzeStandaloneDirectives: (source) => invoke("compiler", () => operations.analyzeStandaloneDirectives(source), source),
+		mergeCSSExtractionPolicies: (policies) => invoke("compiler", () => operations.mergeCSSExtractionPolicies(policies)),
+		filterCSSExtractionCandidates: (candidates, blocklist) => invoke("compiler", () => operations.filterCSSExtractionCandidates(candidates, blocklist)),
+		compileManifestInput: (input, options) => invoke("compiler", () => operations.compileManifestInput(input, options)),
+		lowerCSSDirectives: (request, options, sourceText) => invoke("compiler", () => operations.lowerCSSDirectives(request, options), sourceText),
+		normalizeManifest: (manifest) => invoke("compiler", () => operations.normalizeManifest(manifest)),
+		normalizeDefaultManifest: (manifest) => invoke("compiler", () => operations.normalizeDefaultManifest(manifest)),
+		compileDefaultPresetManifest: (request) => invoke("compiler", () => operations.compileDefaultPresetManifest(request)),
+		resolveCSSImportGraph: (request) => invoke("compiler", () => operations.resolveCSSImportGraph(request)),
+		resolveCSSStylesheetGraph: (request) => invoke("compiler", () => operations.resolveCSSStylesheetGraph(request), (filename) => request.files[filename]),
+		prepareCSSStylesheetBundle: (request) => invoke("compiler", () => operations.prepareCSSStylesheetBundle(request), (filename) => filename === request.from ? request.source : request.managed.stylesheets.find((asset) => asset.id === filename)?.css),
+		renderCSSStylesheetBundle: (request) => invoke("compiler", () => operations.renderCSSStylesheetBundle(request)),
+		compileCSSStylesheetGraph: (request) => invoke("compiler", () => operations.compileCSSStylesheetGraph(request), (filename) => Object.hasOwn(request.graph.files, filename) ? request.graph.files[filename] : void 0),
+		createInspectionReport: (input) => invoke("tooling", () => operations.createInspectionReport?.(input) ?? unavailable("Inspection reporting")),
+		renderClassNames: (manifest, classNames) => invoke("server", () => operations.renderClassNames?.(manifest, classNames) ?? unavailable("Native class rendering")),
+		dispose,
+		[Symbol.dispose]: dispose
+	});
+}
+export { bindCompilerBindingSession };

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

@@ -0,0 +1,6 @@
+import { MASTER_CSS_DIAGNOSTICS_REPORT_VERSION, MasterCSSCompileDefaultPresetRequest, MasterCSSCompileDefaultPresetResult, MasterCSSCompileManifestOptions, MasterCSSCompileManifestResult, MasterCSSCompileStylesheetGraphRequest, MasterCSSCompiledStylesheet, MasterCSSCompiledStylesheetGraph, MasterCSSCompilerInspection, MasterCSSDependencyAnalysis, MasterCSSDiagnosticsReportInput, MasterCSSDirectiveCompilation, MasterCSSDirectiveCompileOptions, MasterCSSDirectiveExtractionPolicy, MasterCSSDirectiveManifestInput, MasterCSSImportGraphRequest, MasterCSSInspectionReport, MasterCSSLowerDirectivesOptions, MasterCSSLowerDirectivesRequest, MasterCSSLowerDirectivesResult, MasterCSSPrepareStylesheetBundleRequest, MasterCSSProjectAssetChange, MasterCSSProjectComparison, MasterCSSProjectComparisonRequest, MasterCSSProjectEntryGraph, MasterCSSProjectManifest, MasterCSSProjectSnapshot, MasterCSSRenderStylesheetBundleRequest, MasterCSSResolvedImportGraph, MasterCSSStandaloneDirectiveAnalysis, MasterCSSStylesheetAsset, MasterCSSStylesheetBundle } from "./protocol.js";
+import { MasterCSSBindingLoadOptions, MasterCSSNativeBindingLoadOptions, MasterCSSWasmBindingLoadOptions } from "./binding-options.js";
+import { MasterCSSCompilerBindingSession, MasterCSSCompilerRenderBindingSession, MasterCSSCompilerRenderBindingSessionOptions } from "./compiler-binding-contract.js";
+declare function createCompilerBindingSession(options?: MasterCSSBindingLoadOptions): Promise<MasterCSSCompilerBindingSession>;
+declare function createCompilerRenderBindingSession(options: MasterCSSCompilerRenderBindingSessionOptions, loadOptions?: MasterCSSBindingLoadOptions): Promise<MasterCSSCompilerRenderBindingSession>;
+export { MASTER_CSS_DIAGNOSTICS_REPORT_VERSION, type MasterCSSBindingLoadOptions, type MasterCSSCompileDefaultPresetRequest, type MasterCSSCompileDefaultPresetResult, type MasterCSSCompileManifestOptions, type MasterCSSCompileManifestResult, type MasterCSSCompileStylesheetGraphRequest, type MasterCSSCompiledStylesheet, type MasterCSSCompiledStylesheetGraph, type MasterCSSCompilerBindingSession, type MasterCSSCompilerInspection, type MasterCSSCompilerRenderBindingSession, type MasterCSSCompilerRenderBindingSessionOptions, type MasterCSSDependencyAnalysis, type MasterCSSDiagnosticsReportInput, type MasterCSSDirectiveCompilation, type MasterCSSDirectiveCompileOptions, type MasterCSSDirectiveExtractionPolicy, type MasterCSSDirectiveManifestInput, type MasterCSSImportGraphRequest, type MasterCSSInspectionReport, type MasterCSSLowerDirectivesOptions, type MasterCSSLowerDirectivesRequest, type MasterCSSLowerDirectivesResult, type MasterCSSNativeBindingLoadOptions, type MasterCSSPrepareStylesheetBundleRequest, type MasterCSSProjectAssetChange, type MasterCSSProjectComparison, type MasterCSSProjectComparisonRequest, type MasterCSSProjectEntryGraph, type MasterCSSProjectManifest, type MasterCSSProjectSnapshot, type MasterCSSRenderStylesheetBundleRequest, type MasterCSSResolvedImportGraph, type MasterCSSStandaloneDirectiveAnalysis, type MasterCSSStylesheetAsset, type MasterCSSStylesheetBundle, type MasterCSSWasmBindingLoadOptions, createCompilerBindingSession, createCompilerRenderBindingSession };

package/dist/compiler-binding-browser.js

@@ -0,0 +1,24 @@
+import { MASTER_CSS_DIAGNOSTICS_REPORT_VERSION } from "./protocol.js";
+import { callBindingAsync } from "./normalize-error.js";
+import { createCompilerWasmBindingSession, createCompilerWasmRenderBindingSession } from "./compiler-binding-wasm.js";
+import { MasterCSSError } from "@master/css-schema";
+import { serializeMasterCSSManifest } from "@master/css-schema/manifest";
+import { createMasterCSSCompilerWasmProvider } from "@master/css-binding-wasm-compiler";
+// src/compiler-binding-browser.ts
+function createCompilerBindingSession(options = {}) {
+	if (options.binding === "native") throw new MasterCSSError({
+		code: "NATIVE_UNAVAILABLE",
+		domain: "binding",
+		message: "Master CSS native compiler bindings are unavailable in browsers."
+	});
+	return callBindingAsync("compiler", () => createCompilerWasmBindingSession(options.wasm, createMasterCSSCompilerWasmProvider));
+}
+function createCompilerRenderBindingSession(options, loadOptions = {}) {
+	if (loadOptions.binding === "native") throw new MasterCSSError({
+		code: "NATIVE_UNAVAILABLE",
+		domain: "binding",
+		message: "Master CSS native compiler bindings are unavailable in browsers."
+	});
+	return callBindingAsync("compiler", () => createCompilerWasmRenderBindingSession(serializeMasterCSSManifest(options.manifest), options.emittedGlobals === void 0 ? void 0 : JSON.stringify(options.emittedGlobals), loadOptions.wasm, createMasterCSSCompilerWasmProvider));
+}
+export { MASTER_CSS_DIAGNOSTICS_REPORT_VERSION, createCompilerBindingSession, createCompilerRenderBindingSession };

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

@@ -0,0 +1,45 @@
+import { MasterCSSCompileDefaultPresetRequest, MasterCSSCompileDefaultPresetResult, MasterCSSCompileManifestOptions, MasterCSSCompileManifestResult, MasterCSSCompileStylesheetGraphRequest, MasterCSSCompiledStylesheetGraph, MasterCSSCompilerInspection, MasterCSSDependencyAnalysis, MasterCSSDiagnosticsReportInput, MasterCSSDirectiveCompilation, MasterCSSDirectiveCompileOptions, MasterCSSDirectiveExtractionPolicy, MasterCSSDirectiveManifestInput, MasterCSSImportGraphRequest, MasterCSSInspectionReport, MasterCSSLowerDirectivesOptions, MasterCSSLowerDirectivesRequest, MasterCSSLowerDirectivesResult, MasterCSSNativeDeclarationCandidate, MasterCSSPrepareStylesheetBundleRequest, MasterCSSProjectComparison, MasterCSSProjectComparisonRequest, MasterCSSProjectEntryGraph, MasterCSSProjectManifest, MasterCSSRegex, MasterCSSRenderStylesheetBundleRequest, MasterCSSResolvedBinding, MasterCSSResolvedImportGraph, MasterCSSServerRender, MasterCSSStandaloneDirectiveAnalysis, MasterCSSStylesheetAsset, MasterCSSStylesheetBundle } from "./protocol.js";
+import { MasterCSSBindingLoadOptions, MasterCSSNativeBindingLoadOptions, MasterCSSWasmBindingLoadOptions } from "./binding-options.js";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+import { MasterCSSEmittedGlobals } from "@master/css-schema/emitted-globals";
+interface MasterCSSCompilerBindingSession extends Disposable {
+  readonly binding: MasterCSSResolvedBinding;
+  findManifestEntries(projectDir: string): readonly string[];
+  loadProjectManifest(projectDir: string, baseManifest: MasterCSSManifest, entries?: readonly string[]): MasterCSSProjectManifest;
+  loadPreparedProjectManifest(projectDir: string, baseManifest: MasterCSSManifest, graphs: readonly MasterCSSProjectEntryGraph[]): MasterCSSProjectManifest;
+  compareProjectSnapshots(request: MasterCSSProjectComparisonRequest): MasterCSSProjectComparison;
+  inspectCSS(source: string): MasterCSSCompilerInspection;
+  compileNativeCSS(source: string, options?: MasterCSSDirectiveCompileOptions): MasterCSSDirectiveCompilation;
+  compileCSSDirectives(source: string, options?: MasterCSSDirectiveCompileOptions): MasterCSSDirectiveCompilation;
+  analyzeCSSDependencies(source: string): MasterCSSDependencyAnalysis;
+  analyzeStandaloneDirectives(source: string): MasterCSSStandaloneDirectiveAnalysis;
+  mergeCSSExtractionPolicies(policies: readonly Partial<MasterCSSDirectiveExtractionPolicy>[]): MasterCSSDirectiveExtractionPolicy;
+  filterCSSExtractionCandidates(candidates: readonly string[], blocklist: readonly (string | MasterCSSRegex)[]): readonly string[];
+  compileManifestInput(input: MasterCSSDirectiveManifestInput, options?: MasterCSSCompileManifestOptions): MasterCSSCompileManifestResult;
+  lowerCSSDirectives(request: MasterCSSLowerDirectivesRequest, options?: MasterCSSLowerDirectivesOptions, sourceText?: string): MasterCSSLowerDirectivesResult;
+  normalizeManifest(manifest: MasterCSSManifest): MasterCSSManifest;
+  normalizeDefaultManifest(manifest: MasterCSSManifest): MasterCSSManifest;
+  compileDefaultPresetManifest(request: MasterCSSCompileDefaultPresetRequest): MasterCSSCompileDefaultPresetResult;
+  resolveCSSImportGraph(request: MasterCSSImportGraphRequest): MasterCSSResolvedImportGraph;
+  resolveCSSStylesheetGraph(request: MasterCSSImportGraphRequest): MasterCSSStylesheetBundle['graph'];
+  prepareCSSStylesheetBundle(request: MasterCSSPrepareStylesheetBundleRequest): MasterCSSStylesheetBundle;
+  renderCSSStylesheetBundle(request: MasterCSSRenderStylesheetBundleRequest): readonly MasterCSSStylesheetAsset[];
+  compileCSSStylesheetGraph(request: MasterCSSCompileStylesheetGraphRequest): MasterCSSCompiledStylesheetGraph;
+  createInspectionReport(input: MasterCSSDiagnosticsReportInput): MasterCSSInspectionReport;
+  renderClassNames(manifest: MasterCSSManifest, classNames: readonly string[]): MasterCSSServerRender;
+  dispose(): void;
+}
+interface MasterCSSCompilerRenderBindingSessionOptions {
+  readonly manifest: MasterCSSManifest;
+  readonly emittedGlobals?: MasterCSSEmittedGlobals;
+}
+interface MasterCSSCompilerRenderBindingSession extends Disposable {
+  readonly binding: MasterCSSResolvedBinding;
+  nativeDeclarationCandidates(classNames: readonly string[]): readonly MasterCSSNativeDeclarationCandidate[];
+  ensureClasses(classNames: readonly string[]): void;
+  ensureStylesheetResources(nativeCSS: string): void;
+  emittedGlobals(): MasterCSSEmittedGlobals;
+  snapshot(): MasterCSSServerRender;
+  dispose(): void;
+}
+export { type MasterCSSBindingLoadOptions, MasterCSSCompilerBindingSession, MasterCSSCompilerRenderBindingSession, MasterCSSCompilerRenderBindingSessionOptions, type MasterCSSNativeBindingLoadOptions, type MasterCSSWasmBindingLoadOptions };

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

@@ -0,0 +1,5 @@
+import { MASTER_CSS_DIAGNOSTICS_REPORT_VERSION, MasterCSSCompileDefaultPresetRequest, MasterCSSCompileDefaultPresetResult, MasterCSSCompileManifestOptions, MasterCSSCompileManifestResult, MasterCSSCompilerInspection, MasterCSSDependencyAnalysis, MasterCSSDiagnosticsReportInput, MasterCSSDirectiveCompilation, MasterCSSDirectiveCompileOptions, MasterCSSDirectiveExtractionPolicy, MasterCSSDirectiveManifestInput, MasterCSSImportGraphRequest, MasterCSSInspectionReport, MasterCSSLowerDirectivesOptions, MasterCSSLowerDirectivesRequest, MasterCSSLowerDirectivesResult, MasterCSSProjectAssetChange, MasterCSSProjectComparison, MasterCSSProjectComparisonRequest, MasterCSSProjectEntryGraph, MasterCSSProjectManifest, MasterCSSProjectSnapshot, MasterCSSResolvedImportGraph, MasterCSSStandaloneDirectiveAnalysis } from "./protocol.js";
+import { MasterCSSNativeBindingLoadOptions } from "./binding-options.js";
+import { MasterCSSCompilerBindingSession } from "./compiler-binding-contract.js";
+declare function createCompilerBindingSessionSync(options?: MasterCSSNativeBindingLoadOptions): MasterCSSCompilerBindingSession;
+export { MASTER_CSS_DIAGNOSTICS_REPORT_VERSION, type MasterCSSCompileDefaultPresetRequest, type MasterCSSCompileDefaultPresetResult, type MasterCSSCompileManifestOptions, type MasterCSSCompileManifestResult, type MasterCSSCompilerBindingSession, type MasterCSSCompilerInspection, type MasterCSSDependencyAnalysis, type MasterCSSDiagnosticsReportInput, type MasterCSSDirectiveCompilation, type MasterCSSDirectiveCompileOptions, type MasterCSSDirectiveExtractionPolicy, type MasterCSSDirectiveManifestInput, type MasterCSSImportGraphRequest, type MasterCSSInspectionReport, type MasterCSSLowerDirectivesOptions, type MasterCSSLowerDirectivesRequest, type MasterCSSLowerDirectivesResult, type MasterCSSNativeBindingLoadOptions, type MasterCSSProjectAssetChange, type MasterCSSProjectComparison, type MasterCSSProjectComparisonRequest, type MasterCSSProjectEntryGraph, type MasterCSSProjectManifest, type MasterCSSProjectSnapshot, type MasterCSSResolvedImportGraph, type MasterCSSStandaloneDirectiveAnalysis, createCompilerBindingSessionSync };

package/dist/compiler-binding-node.js

@@ -0,0 +1,20 @@
+import { MASTER_CSS_DIAGNOSTICS_REPORT_VERSION } from "./protocol.js";
+import { normalizeBindingError } from "./normalize-error.js";
+import { bindCompilerBindingSession } from "./compiler-binding-adapter.js";
+import { loadNativeCompilerBinding } from "./compiler.js";
+// src/compiler-binding-node.ts
+function createCompilerBindingSessionSync(options = {}) {
+	try {
+		const native = loadNativeCompilerBinding({
+			...options,
+			required: true
+		});
+		return bindCompilerBindingSession("native", {
+			...native,
+			dispose: () => void 0
+		});
+	} catch (cause) {
+		throw normalizeBindingError(cause, "compiler");
+	}
+}
+export { MASTER_CSS_DIAGNOSTICS_REPORT_VERSION, createCompilerBindingSessionSync };

package/dist/compiler-binding-wasm.js

@@ -0,0 +1,58 @@
+import { assertMasterCSSBindingInfo } from "./binding.js";
+import { bindCompilerBindingSession } from "./compiler-binding-adapter.js";
+// src/compiler-binding-wasm.ts
+async function loadDefaultWasmProvider(options) {
+	const { createMasterCSSCompilerWasmProvider } = await import("@master/css-binding-wasm-compiler");
+	return await createMasterCSSCompilerWasmProvider(options);
+}
+async function provider(options, factory = loadDefaultWasmProvider) {
+	const wasm = await factory(options);
+	assertMasterCSSBindingInfo(wasm.info, {
+		surface: "compiler",
+		features: ["compiler", "render"]
+	});
+	return wasm;
+}
+async function createCompilerWasmBindingSession(options, providerFactory) {
+	const session = await (await provider(options, providerFactory)).createSession();
+	return bindCompilerBindingSession("wasm", {
+		compareProjectSnapshots: (request) => session.compareProjectSnapshots(request),
+		inspectCSS: (source) => session.inspectCSS(source),
+		compileNativeCSS: (source, compileOptions) => session.compileNativeCSS(source, compileOptions),
+		compileCSSDirectives: (source, compileOptions) => session.compileCSSDirectives(source, compileOptions),
+		analyzeCSSDependencies: (source) => session.analyzeCSSDependencies(source),
+		analyzeStandaloneDirectives: (source) => session.analyzeStandaloneDirectives(source),
+		mergeCSSExtractionPolicies: (policies) => session.mergeCSSExtractionPolicies(policies),
+		filterCSSExtractionCandidates: (candidates, blocklist) => session.filterCSSExtractionCandidates([...candidates], blocklist),
+		compileManifestInput: (input, compileOptions) => session.compileManifestInput(input, compileOptions),
+		lowerCSSDirectives: (request, compileOptions) => session.lowerCSSDirectives(request, compileOptions),
+		normalizeManifest: (manifest) => session.normalizeManifestForJSON(manifest),
+		normalizeDefaultManifest: (manifest) => session.normalizeDefaultManifestForJSON(manifest),
+		compileDefaultPresetManifest: (request) => session.compileDefaultPresetManifest(request),
+		resolveCSSImportGraph: (request) => session.resolveCSSImportGraph(request),
+		resolveCSSStylesheetGraph: (request) => session.resolveCSSStylesheetGraph(request),
+		prepareCSSStylesheetBundle: (request) => session.prepareCSSStylesheetBundle(request),
+		renderCSSStylesheetBundle: (request) => session.renderCSSStylesheetBundle(request),
+		compileCSSStylesheetGraph: (request) => session.compileCSSStylesheetGraph(request)
+	});
+}
+async function createCompilerWasmRenderBindingSession(manifestJSON, emittedGlobalsJSON, options, providerFactory) {
+	const session = await (await provider(options, providerFactory)).createRenderSession(manifestJSON, emittedGlobalsJSON);
+	let disposed = false;
+	const dispose = () => {
+		if (disposed) return;
+		disposed = true;
+		session.dispose();
+	};
+	return Object.freeze({
+		binding: "wasm",
+		nativeDeclarationCandidates: (classNames) => session.nativeDeclarationCandidates([...classNames]),
+		ensureClasses: (classNames) => session.ensureClasses([...classNames]),
+		ensureStylesheetResources: (nativeCSS) => session.ensureStylesheetResources(nativeCSS),
+		emittedGlobals: () => session.emittedGlobals(),
+		snapshot: () => session.snapshot(),
+		dispose,
+		[Symbol.dispose]: dispose
+	});
+}
+export { createCompilerWasmBindingSession, createCompilerWasmRenderBindingSession };

package/dist/compiler-binding.d.ts

@@ -0,0 +1,6 @@
+import { MASTER_CSS_DIAGNOSTICS_REPORT_VERSION, MasterCSSCompileDefaultPresetRequest, MasterCSSCompileDefaultPresetResult, MasterCSSCompileManifestOptions, MasterCSSCompileManifestResult, MasterCSSCompileStylesheetGraphRequest, MasterCSSCompiledStylesheet, MasterCSSCompiledStylesheetGraph, MasterCSSCompilerInspection, MasterCSSDependencyAnalysis, MasterCSSDiagnosticsReportInput, MasterCSSDirectiveCompilation, MasterCSSDirectiveCompileOptions, MasterCSSDirectiveExtractionPolicy, MasterCSSDirectiveManifestInput, MasterCSSImportGraphRequest, MasterCSSInspectionReport, MasterCSSLowerDirectivesOptions, MasterCSSLowerDirectivesRequest, MasterCSSLowerDirectivesResult, MasterCSSPrepareStylesheetBundleRequest, MasterCSSProjectAssetChange, MasterCSSProjectComparison, MasterCSSProjectComparisonRequest, MasterCSSProjectEntryGraph, MasterCSSProjectManifest, MasterCSSProjectSnapshot, MasterCSSRenderStylesheetBundleRequest, MasterCSSResolvedImportGraph, MasterCSSStandaloneDirectiveAnalysis, MasterCSSStylesheetAsset, MasterCSSStylesheetBundle } from "./protocol.js";
+import { MasterCSSBindingLoadOptions, MasterCSSNativeBindingLoadOptions, MasterCSSWasmBindingLoadOptions } from "./binding-options.js";
+import { MasterCSSCompilerBindingSession, MasterCSSCompilerRenderBindingSession, MasterCSSCompilerRenderBindingSessionOptions } from "./compiler-binding-contract.js";
+declare function createCompilerBindingSession(options?: MasterCSSBindingLoadOptions): Promise<MasterCSSCompilerBindingSession>;
+declare function createCompilerRenderBindingSession(options: MasterCSSCompilerRenderBindingSessionOptions, loadOptions?: MasterCSSBindingLoadOptions): Promise<MasterCSSCompilerRenderBindingSession>;
+export { MASTER_CSS_DIAGNOSTICS_REPORT_VERSION, type MasterCSSBindingLoadOptions, type MasterCSSCompileDefaultPresetRequest, type MasterCSSCompileDefaultPresetResult, type MasterCSSCompileManifestOptions, type MasterCSSCompileManifestResult, type MasterCSSCompileStylesheetGraphRequest, type MasterCSSCompiledStylesheet, type MasterCSSCompiledStylesheetGraph, type MasterCSSCompilerBindingSession, type MasterCSSCompilerInspection, type MasterCSSCompilerRenderBindingSession, type MasterCSSCompilerRenderBindingSessionOptions, type MasterCSSDependencyAnalysis, type MasterCSSDiagnosticsReportInput, type MasterCSSDirectiveCompilation, type MasterCSSDirectiveCompileOptions, type MasterCSSDirectiveExtractionPolicy, type MasterCSSDirectiveManifestInput, type MasterCSSImportGraphRequest, type MasterCSSInspectionReport, type MasterCSSLowerDirectivesOptions, type MasterCSSLowerDirectivesRequest, type MasterCSSLowerDirectivesResult, type MasterCSSNativeBindingLoadOptions, type MasterCSSPrepareStylesheetBundleRequest, type MasterCSSProjectAssetChange, type MasterCSSProjectComparison, type MasterCSSProjectComparisonRequest, type MasterCSSProjectEntryGraph, type MasterCSSProjectManifest, type MasterCSSProjectSnapshot, type MasterCSSRenderStylesheetBundleRequest, type MasterCSSResolvedImportGraph, type MasterCSSStandaloneDirectiveAnalysis, type MasterCSSStylesheetAsset, type MasterCSSStylesheetBundle, type MasterCSSWasmBindingLoadOptions, createCompilerBindingSession, createCompilerRenderBindingSession };

package/dist/compiler-binding.js

@@ -0,0 +1,42 @@
+import { MASTER_CSS_DIAGNOSTICS_REPORT_VERSION } from "./protocol.js";
+import { normalizeBindingError } from "./normalize-error.js";
+import { shouldLoadMasterCSSNativeBinding } from "./binding-options.js";
+import { bindCompilerBindingSession } from "./compiler-binding-adapter.js";
+import { createCompilerWasmBindingSession, createCompilerWasmRenderBindingSession } from "./compiler-binding-wasm.js";
+import { MasterCSSError } from "@master/css-schema";
+import { serializeMasterCSSManifest } from "@master/css-schema/manifest";
+// src/compiler-binding.ts
+async function loadNativeCompilerFactory() {
+	return await (import.meta.url.endsWith(".ts") ? import("./compiler.js") : import("./compiler.js"));
+}
+async function createCompilerBindingSession(options = {}) {
+	try {
+		if (shouldLoadMasterCSSNativeBinding(options.binding)) {
+			const { loadNativeCompilerBinding } = await loadNativeCompilerFactory();
+			const native = loadNativeCompilerBinding({
+				...options.native,
+				required: options.binding === "native"
+			});
+			if (native) return bindCompilerBindingSession("native", {
+				...native,
+				dispose: () => void 0
+			});
+		}
+		return await createCompilerWasmBindingSession(options.wasm);
+	} catch (cause) {
+		throw normalizeBindingError(cause, "compiler");
+	}
+}
+async function createCompilerRenderBindingSession(options, loadOptions = {}) {
+	try {
+		if (loadOptions.binding === "native") throw new MasterCSSError({
+			code: "NATIVE_UNAVAILABLE",
+			domain: "binding",
+			message: "The Master CSS compiler render session is only available through Wasm."
+		});
+		return await createCompilerWasmRenderBindingSession(serializeMasterCSSManifest(options.manifest), options.emittedGlobals === void 0 ? void 0 : JSON.stringify(options.emittedGlobals), loadOptions.wasm);
+	} catch (cause) {
+		throw normalizeBindingError(cause, "compiler");
+	}
+}
+export { MASTER_CSS_DIAGNOSTICS_REPORT_VERSION, createCompilerBindingSession, createCompilerRenderBindingSession };

package/dist/compiler.js

@@ -0,0 +1,52 @@
+import { MASTER_CSS_DIAGNOSTICS_REPORT_VERSION } from "./protocol.js";
+import { NativeBindingError } from "./errors.js";
+import { loadNativeBinding } from "./native-loader.js";
+import { MasterCSSError } from "@master/css-schema";
+// src/compiler.ts
+function parse(value) {
+	return JSON.parse(value);
+}
+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 loadNativeCompilerBinding(moduleOptions = {}) {
+	try {
+		const loaded = loadNativeBinding(moduleOptions);
+		if (!loaded) return;
+		const nativeBinding = loaded.binding;
+		return Object.freeze({
+			findManifestEntries: (projectDir) => nativeBinding.findCssManifestEntries(projectDir),
+			loadProjectManifest: (projectDir, baseManifest, entries) => parse(nativeBinding.loadProjectManifestJson(projectDir, JSON.stringify(baseManifest), entries ? [...entries] : void 0)),
+			loadPreparedProjectManifest: (projectDir, baseManifest, graphs) => parse(nativeBinding.loadProjectManifestPreparedJson(projectDir, JSON.stringify(baseManifest), JSON.stringify(graphs))),
+			compareProjectSnapshots: (request) => parse(nativeBinding.compareProjectSnapshotsJson(JSON.stringify(request))),
+			inspectCSS: (source) => parse(nativeBinding.inspectCssJson(source)),
+			compileNativeCSS: (source, options) => parse(nativeBinding.compileNativeCssJson(source, options === void 0 ? void 0 : JSON.stringify(options))),
+			compileCSSDirectives: (source, options) => parse(nativeBinding.compileCssDirectivesJson(source, options === void 0 ? void 0 : JSON.stringify(options))),
+			analyzeCSSDependencies: (source) => parse(nativeBinding.analyzeCssDependenciesJson(source)),
+			analyzeStandaloneDirectives: (source) => parse(nativeBinding.analyzeStandaloneDirectivesJson(source)),
+			mergeCSSExtractionPolicies: (policies) => parse(nativeBinding.mergeCssExtractionPoliciesJson(JSON.stringify(policies))),
+			filterCSSExtractionCandidates: (candidates, blocklist) => nativeBinding.filterCssExtractionCandidates([...candidates], JSON.stringify(blocklist)),
+			compileManifestInput: (input, options) => parse(nativeBinding.compileManifestInputJson(JSON.stringify(input), options === void 0 ? void 0 : JSON.stringify(options))),
+			lowerCSSDirectives: (request, options) => parse(nativeBinding.lowerCssDirectivesJson(JSON.stringify(request), options === void 0 ? void 0 : JSON.stringify(options))),
+			normalizeManifest: (manifest) => parse(nativeBinding.normalizeManifestJson(JSON.stringify(manifest))),
+			normalizeDefaultManifest: (manifest) => parse(nativeBinding.normalizeDefaultManifestJson(JSON.stringify(manifest))),
+			compileDefaultPresetManifest: (request) => parse(nativeBinding.compileDefaultPresetManifestJson(JSON.stringify(request))),
+			resolveCSSStylesheetGraph: (request) => parse(nativeBinding.resolveCssStylesheetGraphJson(JSON.stringify(request))),
+			resolveCSSImportGraph: (request) => parse(nativeBinding.resolveCssImportGraphJson(JSON.stringify(request))),
+			prepareCSSStylesheetBundle: (request) => parse(nativeBinding.prepareCssStylesheetBundleJson(JSON.stringify(request))),
+			renderCSSStylesheetBundle: (request) => parse(nativeBinding.renderCssStylesheetBundleJson(JSON.stringify(request))),
+			compileCSSStylesheetGraph: (request) => parse(nativeBinding.compileCssStylesheetGraphJson(JSON.stringify(request))),
+			createInspectionReport: (input) => parse(nativeBinding.createInspectionReportJson(JSON.stringify(input))),
+			renderClassNames: (manifest, classNames) => parse(nativeBinding.renderClassesJson(JSON.stringify(manifest), [...classNames]))
+		});
+	} catch (cause) {
+		throw bindingError(cause);
+	}
+}
+export { MASTER_CSS_DIAGNOSTICS_REPORT_VERSION, loadNativeCompilerBinding };

package/dist/engine-binding-adapter.js

@@ -0,0 +1,61 @@
+import { callBinding } from "./normalize-error.js";
+import { MasterCSSError } from "@master/css-schema";
+// src/engine-binding-adapter.ts
+function assertActive(disposed, domain) {
+	if (!disposed) return;
+	throw new MasterCSSError({
+		code: "SESSION_DISPOSED",
+		domain,
+		message: `The Master CSS ${domain} binding session has been disposed.`
+	});
+}
+function bindEngineBindingSession(binding, session) {
+	let disposed = false;
+	const invoke = (operation) => {
+		assertActive(disposed, "engine");
+		return callBinding("engine", operation);
+	};
+	const dispose = () => {
+		if (disposed) return;
+		disposed = true;
+		session.dispose();
+	};
+	return Object.freeze({
+		binding,
+		ensureClassRules: (classNames) => invoke(() => session.ensureClassRules(classNames)),
+		deleteClassRules: (classNames) => invoke(() => session.deleteClassRules(classNames)),
+		registerEmittedGlobals: (emittedGlobals) => invoke(() => session.registerEmittedGlobals(emittedGlobals)),
+		replaceEmittedGlobals: (emittedGlobals) => invoke(() => session.replaceEmittedGlobals(emittedGlobals)),
+		refresh: (source, emittedGlobals) => invoke(() => session.refresh(source, emittedGlobals)),
+		keyframeDefinitions: () => invoke(() => session.keyframeDefinitions()),
+		executionState: (classNames) => invoke(() => session.executionState(classNames)),
+		inspect: (className) => invoke(() => session.inspect(className)),
+		snapshot: () => invoke(() => session.snapshot()),
+		dispose,
+		[Symbol.dispose]: dispose
+	});
+}
+function bindRenderBindingSession(binding, session) {
+	let disposed = false;
+	const invoke = (operation) => {
+		assertActive(disposed, "server");
+		return callBinding("server", operation);
+	};
+	const dispose = () => {
+		if (disposed) return;
+		disposed = true;
+		session.dispose();
+	};
+	return Object.freeze({
+		binding,
+		nativeDeclarationCandidates: (classNames) => invoke(() => session.nativeDeclarationCandidates(classNames)),
+		ensureClassRules: (classNames) => invoke(() => session.ensureClassRules(classNames)),
+		ensureStylesheetResources: (nativeCSS) => invoke(() => session.ensureStylesheetResources(nativeCSS)),
+		emittedGlobals: () => invoke(() => session.emittedGlobals()),
+		snapshot: () => invoke(() => session.snapshot()),
+		snapshotForClassNames: (classNames) => invoke(() => session.snapshotForClassNames(classNames)),
+		dispose,
+		[Symbol.dispose]: dispose
+	});
+}
+export { bindEngineBindingSession, bindRenderBindingSession };

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

@@ -0,0 +1,8 @@
+import { MasterCSSBindingLoadOptions, MasterCSSNativeBindingLoadOptions, MasterCSSWasmBindingLoadOptions } from "./binding-options.js";
+import { MasterCSSEngineSource } from "./engine-contract.js";
+import { MasterCSSEngineBindingSession, MasterCSSEngineBindingSessionOptions, MasterCSSRenderBindingSession, MasterCSSRenderBindingSessionOptions } from "./engine-binding.js";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+declare function createEngineBindingSession(options: MasterCSSEngineBindingSessionOptions, loadOptions?: MasterCSSBindingLoadOptions): Promise<MasterCSSEngineBindingSession>;
+declare function createRenderBindingSession(_options: MasterCSSRenderBindingSessionOptions, _loadOptions?: MasterCSSBindingLoadOptions): Promise<MasterCSSRenderBindingSession>;
+declare function compileRuntimeProgram(_manifest: MasterCSSManifest, _loadOptions?: MasterCSSBindingLoadOptions): Promise<Uint8Array>;
+export { type MasterCSSBindingLoadOptions, type MasterCSSEngineBindingSession, type MasterCSSEngineBindingSessionOptions, type MasterCSSEngineSource, type MasterCSSNativeBindingLoadOptions, type MasterCSSRenderBindingSession, type MasterCSSRenderBindingSessionOptions, type MasterCSSWasmBindingLoadOptions, compileRuntimeProgram, createEngineBindingSession, createRenderBindingSession };

package/dist/engine-binding-browser.js

@@ -0,0 +1,35 @@
+import { callBindingAsync } from "./normalize-error.js";
+import { createJavaScriptEngineBindingSession, programRequired } from "./engine-binding-js.js";
+import { MasterCSSError } from "@master/css-schema";
+// src/engine-binding-browser.ts
+function assertBrowserBinding(options) {
+	if (options.binding === "native") throw new MasterCSSError({
+		code: "NATIVE_UNAVAILABLE",
+		domain: "binding",
+		message: "Master CSS native bindings are unavailable in browsers."
+	});
+	if (options.binding === "wasm") throw new MasterCSSError({
+		code: "WASM_UNAVAILABLE",
+		domain: "binding",
+		message: "Master CSS Wasm engines are unavailable in browsers, which execute programs with the JavaScript engine."
+	});
+}
+function createEngineBindingSession(options, loadOptions = {}) {
+	return callBindingAsync("engine", async () => {
+		assertBrowserBinding(loadOptions);
+		return createJavaScriptEngineBindingSession(options);
+	});
+}
+function createRenderBindingSession(_options, _loadOptions = {}) {
+	return callBindingAsync("server", async () => {
+		throw new MasterCSSError({
+			code: "FEATURE_UNAVAILABLE",
+			domain: "server",
+			message: "Master CSS rendering is unavailable in browsers; use @master/css/node."
+		});
+	});
+}
+function compileRuntimeProgram(_manifest, _loadOptions = {}) {
+	return callBindingAsync("engine", async () => programRequired());
+}
+export { compileRuntimeProgram, createEngineBindingSession, createRenderBindingSession };

package/dist/engine-binding-js.js

@@ -0,0 +1,81 @@
+import { bindEngineBindingSession } from "./engine-binding-adapter.js";
+import { EngineError, createEngineSession } from "./engine-js/src/session.js";
+import { MASTER_CSS_DIAGNOSTIC_VERSION, MasterCSSError } from "@master/css-schema";
+// src/engine-binding-js.ts
+/** The JavaScript engine executes compiled programs; compiling a manifest is a Node build step. */
+function programRequired() {
+	throw new MasterCSSError({
+		code: "INVALID_INPUT",
+		domain: "binding",
+		message: "Master CSS engines in browsers execute compiled runtime programs, not manifests. Compile the manifest with compileRuntimeProgram() from @master/css/node and pass { program }."
+	});
+}
+function program(source) {
+	return ArrayBuffer.isView(source) ? source : programRequired();
+}
+function invalidEmittedGlobals(message) {
+	throw new MasterCSSError({
+		code: "INVALID_INPUT",
+		domain: "binding",
+		message: `Invalid Master CSS emitted globals: ${message}`
+	});
+}
+const EMITTED_GLOBALS_FIELDS = /* @__PURE__ */ new Set(["variables", "keyframes"]);
+/** Accepts what the engine's emitted globals schema accepts, as the Wasm engine binding does. */
+function emittedGlobals(globals) {
+	if (globals === void 0) return;
+	for (const field of Object.keys(globals)) if (!EMITTED_GLOBALS_FIELDS.has(field)) invalidEmittedGlobals(`unknown field ${field}.`);
+	for (const field of ["variables", "keyframes"]) for (const [name, count] of Object.entries(globals[field] ?? {})) if (!Number.isInteger(count) || count < 0 || count > 4294967295) invalidEmittedGlobals(`${field}.${name} must be a count.`);
+	return globals;
+}
+/** Engine errors carry their diagnostic, as the Wasm engine reports them. */
+function engineError(cause) {
+	if (!(cause instanceof EngineError)) return cause;
+	const diagnostic = {
+		version: MASTER_CSS_DIAGNOSTIC_VERSION,
+		code: cause.code,
+		domain: "engine",
+		severity: "error",
+		message: cause.message
+	};
+	return new MasterCSSError({
+		code: cause.code,
+		domain: "engine",
+		message: cause.message,
+		diagnostics: [diagnostic]
+	}, { cause });
+}
+function call(operation) {
+	try {
+		return operation();
+	} catch (cause) {
+		throw engineError(cause);
+	}
+}
+function bindSession(session) {
+	const dispose = () => session.dispose();
+	return bindEngineBindingSession("js", {
+		ensureClassRules: (classNames) => call(() => session.ensureClassRules(classNames)),
+		deleteClassRules: (classNames) => call(() => session.deleteClassRules(classNames)),
+		registerEmittedGlobals: (globals) => call(() => session.registerEmittedGlobals(emittedGlobals(globals))),
+		replaceEmittedGlobals: (globals) => call(() => session.replaceEmittedGlobals(emittedGlobals(globals))),
+		refresh: (source, globals) => call(() => session.refresh(program(source), emittedGlobals(globals))),
+		keyframeDefinitions: () => call(() => session.keyframeDefinitions()),
+		executionState: (classNames) => call(() => session.executionState(classNames)),
+		inspect: () => {
+			throw new MasterCSSError({
+				code: "FEATURE_UNAVAILABLE",
+				domain: "engine",
+				message: "Master CSS class inspection is unavailable in the JavaScript engine; use @master/css/node."
+			});
+		},
+		snapshot: () => call(() => session.snapshot()),
+		dispose,
+		[Symbol.dispose]: dispose
+	});
+}
+function createJavaScriptEngineBindingSession(options) {
+	const source = program(options.program ?? options.manifest);
+	return bindSession(call(() => createEngineSession(source, emittedGlobals(options.emittedGlobals))));
+}
+export { createJavaScriptEngineBindingSession, programRequired };

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

@@ -0,0 +1,9 @@
+import { MasterCSSNativeBindingLoadOptions } from "./binding-options.js";
+import { MasterCSSEngineSource } from "./engine-contract.js";
+import { MasterCSSEngineBindingSession, MasterCSSEngineBindingSessionOptions, MasterCSSRenderBindingSession, MasterCSSRenderBindingSessionOptions } from "./engine-binding.js";
+import { MasterCSSManifest } from "@master/css-schema/manifest";
+declare function createEngineBindingSessionSync(options: MasterCSSEngineBindingSessionOptions, loadOptions?: MasterCSSNativeBindingLoadOptions): MasterCSSEngineBindingSession;
+declare function createRenderBindingSessionSync(options: MasterCSSRenderBindingSessionOptions, loadOptions?: MasterCSSNativeBindingLoadOptions): MasterCSSRenderBindingSession;
+/** Compiles a manifest into the runtime program that browsers execute. */
+declare function compileRuntimeProgramSync(manifest: MasterCSSManifest, loadOptions?: MasterCSSNativeBindingLoadOptions): Uint8Array;
+export { type MasterCSSEngineBindingSession, type MasterCSSEngineBindingSessionOptions, type MasterCSSEngineSource, type MasterCSSNativeBindingLoadOptions, type MasterCSSRenderBindingSession, type MasterCSSRenderBindingSessionOptions, compileRuntimeProgramSync, createEngineBindingSessionSync, createRenderBindingSessionSync };