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

package/dist/index.js

@@ -0,0 +1,1723 @@
+import { MASTER_CSS_DIAGNOSTIC_VERSION, MasterCSSError } from "@master/css-schema";
+import { MASTER_CSS_RUNTIME_STYLE_ID } from "@master/css-schema/runtime-style";
+import { MASTER_CSS_HYDRATION_MANIFEST_ATTR, MASTER_CSS_HYDRATION_MANIFEST_SCRIPT_ID } from "@master/css-schema/hydration-manifest";
+// src/class-tracker.ts
+function isElement(node) {
+	return node.nodeType === 1;
+}
+function updateClassDelta(deltaCounts, className, delta) {
+	const nextDelta = (deltaCounts.get(className) || 0) + delta;
+	if (nextDelta) deltaCounts.set(className, nextDelta);
+	else deltaCounts.delete(className);
+}
+function traverseElementSubtree(root, visited, callback) {
+	const stack = [root];
+	while (stack.length) {
+		const el = stack.pop();
+		if (visited.has(el)) continue;
+		visited.add(el);
+		callback(el);
+		for (let child = el.lastElementChild; child; child = child.previousElementSibling) stack.push(child);
+	}
+}
+var RuntimeClassTracker = class {
+	snapshots = /* @__PURE__ */ new WeakMap();
+	reset() {
+		this.snapshots = /* @__PURE__ */ new WeakMap();
+	}
+	collectConnected(root, classCounts) {
+		this.reset();
+		const connectedNames = /* @__PURE__ */ new Set();
+		for (const el of root.querySelectorAll("[class]")) {
+			const classNames = this.snapshotElement(el);
+			if (!classNames) continue;
+			for (const className of classNames) {
+				const count = classCounts.get(className) || 0;
+				if (!count) connectedNames.add(className);
+				classCounts.set(className, count + 1);
+			}
+		}
+		return connectedNames;
+	}
+	collectMutations(records, root) {
+		const deltaCounts = /* @__PURE__ */ new Map();
+		const nodeCounts = /* @__PURE__ */ new Map();
+		const attrRecords = /* @__PURE__ */ new Set();
+		const visited = /* @__PURE__ */ new WeakSet();
+		const belongsToRoot = (node) => node.getRootNode() === root;
+		const updateNodeCount = (el, delta) => {
+			const nextCount = (nodeCounts.get(el) || 0) + delta;
+			if (nextCount) nodeCounts.set(el, nextCount);
+			else nodeCounts.delete(el);
+		};
+		for (const record of records) if (record.type === "childList") {
+			for (const node of record.addedNodes) if (isElement(node) && belongsToRoot(node)) updateNodeCount(node, 1);
+			for (const node of record.removedNodes) if (isElement(node) && !belongsToRoot(node)) updateNodeCount(node, -1);
+		} else if (record.type === "attributes" && record.attributeName === "class") {
+			const target = record.target;
+			if (isElement(target)) attrRecords.add(target);
+		}
+		for (const [node, count] of nodeCounts) if (count > 0) traverseElementSubtree(node, visited, (el) => this.diffElement(el, deltaCounts));
+		else if (count < 0 && !belongsToRoot(node)) traverseElementSubtree(node, visited, (el) => this.removeElement(el, deltaCounts));
+		for (const el of attrRecords) {
+			if (visited.has(el)) continue;
+			if (belongsToRoot(el)) this.diffElement(el, deltaCounts);
+			else this.removeElement(el, deltaCounts);
+		}
+		return deltaCounts;
+	}
+	snapshotElement(el) {
+		const classList = el.classList;
+		if (!classList.length) {
+			this.snapshots.delete(el);
+			return;
+		}
+		const classNames = /* @__PURE__ */ new Set();
+		for (let i = 0; i < classList.length; i++) classNames.add(classList.item(i));
+		this.snapshots.set(el, classNames);
+		return classNames;
+	}
+	diffElement(el, deltaCounts) {
+		const previousClassNames = this.snapshots.get(el);
+		const classList = el.classList;
+		let nextClassNames;
+		for (let i = 0; i < classList.length; i++) {
+			const className = classList.item(i);
+			if (!previousClassNames?.has(className)) updateClassDelta(deltaCounts, className, 1);
+			(nextClassNames ??= /* @__PURE__ */ new Set()).add(className);
+		}
+		if (previousClassNames) {
+			for (const className of previousClassNames) if (!nextClassNames?.has(className)) updateClassDelta(deltaCounts, className, -1);
+		}
+		if (nextClassNames) this.snapshots.set(el, nextClassNames);
+		else this.snapshots.delete(el);
+	}
+	removeElement(el, deltaCounts) {
+		const previousClassNames = this.snapshots.get(el);
+		if (!previousClassNames) return;
+		for (const className of previousClassNames) updateClassDelta(deltaCounts, className, -1);
+		this.snapshots.delete(el);
+	}
+};
+// src/debuggers/log.ts
+const createLogger = (type) => {
+	return (message, ...args) => {
+		if (!type) return console.log(message, ...args);
+		if (console[type]) console[type](`%c[Master CSS]%c ${message}`, "color: gray;", "color: inherit;", ...args);
+	};
+};
+const loggers = {
+	info: createLogger("info"),
+	debug: createLogger("debug"),
+	warn: console.warn,
+	error: console.error,
+	trace: console.trace,
+	table: console.table,
+	group: console.group,
+	groupCollapsed: console.group,
+	groupEnd: console.groupEnd,
+	time: console.time,
+	timeEnd: console.timeEnd
+};
+const log = createLogger();
+Object.assign(log, loggers);
+// src/debuggers/class-count.ts
+function debugRuntimeMutation(records, classCounts, root, host, snapshot) {
+	const actualClassCounts = {};
+	let errored = false;
+	const resolveClass = (className) => {
+		if (Object.prototype.hasOwnProperty.call(actualClassCounts, className)) actualClassCounts[className]++;
+		else actualClassCounts[className] = 1;
+	};
+	(root.constructor.name === "HTMLDocument" ? host : root).querySelectorAll("[class]").forEach((element) => {
+		element.classList.forEach(resolveClass);
+	});
+	host.classList.forEach(resolveClass);
+	for (const className in actualClassCounts) {
+		const eachCount = snapshot.usageCounts[className];
+		const eachActualCount = actualClassCounts[className];
+		if (eachCount !== eachActualCount) {
+			log.error(`Class count mismatch for \`${className}\` (expected ${eachActualCount}) (received ${eachCount})`);
+			errored = true;
+		}
+	}
+	for (const [className, eachCount] of Object.entries(snapshot.usageCounts)) if (!Object.prototype.hasOwnProperty.call(actualClassCounts, className)) {
+		log.error(`Class count mismatch for \`${className}\` (expected 0) (received ${eachCount})`);
+		errored = true;
+	}
+	if (errored) {
+		log.debug("Records:", records);
+		log.debug("Serialized Records:", serializeMutations(records));
+		log.debug("Counts:", classCounts);
+	}
+}
+function serializeMutations(mutations) {
+	return mutations.map((m) => {
+		const target = m.target;
+		return {
+			type: m.type,
+			attributeName: m.attributeName,
+			oldValue: m.oldValue,
+			target: {
+				tagName: target.tagName,
+				id: target.id,
+				classList: Array.from(target.classList)
+			},
+			added: Array.from(m.addedNodes).filter((n) => n.nodeType === 1).map((el) => ({
+				tagName: el.tagName,
+				id: el.id,
+				classList: Array.from(el.classList)
+			})),
+			removed: Array.from(m.removedNodes).filter((n) => n.nodeType === 1).map((el) => ({
+				tagName: el.tagName,
+				id: el.id,
+				classList: Array.from(el.classList)
+			}))
+		};
+	});
+}
+// src/debuggers/lifecycle.ts
+function debugRuntimeCreated(cssRuntime) {
+	log.debug("created", cssRuntime);
+}
+function debugRuntimeHydrated(cssRuntime, result) {
+	log.debug("hydrated", cssRuntime, result);
+}
+function debugRuntimeObserved(cssRuntime) {
+	log.debug("observed", cssRuntime);
+	if (cssRuntime.snapshot().hydration.state === "progressive") {
+		log.info("Progressive rendering is adopted.");
+		log.debug("pre-rendered CSS", cssRuntime.snapshot().cssText);
+	} else log.info("Runtime rendering is adopted.");
+}
+function debugRuntimeRefreshed(cssRuntime, program) {
+	log.debug("refreshed", cssRuntime, program);
+}
+function debugRuntimeDisconnected(cssRuntime) {
+	log.debug("disconnected", cssRuntime);
+}
+function debugRuntimeDestroyed(cssRuntime) {
+	log.debug("destroyed", cssRuntime);
+}
+// src/generated-rule.ts
+var HydratedGeneratedRuleNode = class {
+	text;
+	native;
+	constructor(text) {
+		this.text = text;
+	}
+};
+var HydratedGeneratedRule = class {
+	ir;
+	layer;
+	native;
+	nativeNodeCount;
+	name;
+	key;
+	layerName;
+	type;
+	sortTier;
+	priority;
+	text;
+	valid = true;
+	fixedClass;
+	nodeCount;
+	nodes;
+	variableNames;
+	selectorText;
+	constructor(ir, layer) {
+		this.ir = ir;
+		this.layer = layer;
+		this.nodeCount = ir.nodes?.length || 1;
+		this.name = ir.className;
+		this.key = ir.key;
+		this.layerName = ir.layer;
+		this.type = ir.type;
+		this.sortTier = ir.sortTier;
+		this.priority = ir.priority;
+		this.text = ir.text;
+		this.selectorText = ir.selectorText;
+		if (ir.nodes?.length) this.nodes = ir.nodes.map((node) => new HydratedGeneratedRuleNode(node.text));
+		if (ir.variableNames?.length) this.variableNames = new Set(ir.variableNames);
+	}
+};
+// src/register-global.ts
+function registerGlobal(Runtime) {
+	if (!globalThis.MasterCSSRuntime) globalThis.MasterCSSRuntime = Runtime;
+}
+// src/keyframe-host.ts
+const isKeyframesRule = (rule) => rule.constructor.name === "CSSKeyframesRule" || rule.constructor.name === "WebKitCSSKeyframesRule";
+/**
+* Places the keyframes the engine emits in the runtime stylesheet, after its layers
+* and wrapped in the containers each definition was declared in.
+*/
+var KeyframeHost = class {
+	sheet;
+	definitions;
+	containers = /* @__PURE__ */ new Map();
+	order = /* @__PURE__ */ new Map();
+	constructor(sheet, definitions) {
+		this.sheet = sheet;
+		this.definitions = definitions;
+	}
+	reset() {
+		this.containers.clear();
+		this.order.clear();
+	}
+	definition(id) {
+		return this.definitions().find((definition) => definition.id === id);
+	}
+	insertionIndex(parent, order) {
+		const next = [...parent.cssRules].findIndex((rule) => (this.order.get(rule) ?? -1) > order);
+		return next < 0 ? parent.cssRules.length : next;
+	}
+	parent(definition, order) {
+		let parent = this.sheet();
+		if (!parent) return;
+		for (const container of definition.containers || []) {
+			let native = this.containers.get(container.id);
+			if (!native) {
+				const index = parent.insertRule(`${container.prelude}{}`, this.insertionIndex(parent, order));
+				native = parent.cssRules[index];
+				this.containers.set(container.id, native);
+				this.order.set(native, order);
+			}
+			parent = native;
+		}
+		return parent;
+	}
+	insert(id, text) {
+		const definition = this.definition(id);
+		if (!definition) return;
+		const order = this.definitions().indexOf(definition);
+		const parent = this.parent(definition, order);
+		if (!parent) return;
+		const index = parent.insertRule(text, this.insertionIndex(parent, order));
+		const native = parent.cssRules[index];
+		this.order.set(native, order);
+		return native;
+	}
+	contains(native) {
+		if (!native || native.parentStyleSheet !== this.sheet()) return false;
+		const parent = native.parentRule || native.parentStyleSheet;
+		return !!parent && [...parent.cssRules].includes(native);
+	}
+	remove(native) {
+		if (!native) return;
+		const parent = native.parentRule || native.parentStyleSheet;
+		if (!parent) return;
+		const index = [...parent.cssRules].indexOf(native);
+		if (index >= 0) parent.deleteRule(index);
+		this.order.delete(native);
+	}
+	/** Claims the pre-rendered rule of `id`, with its containers, from the runtime stylesheet. */
+	adopt(id, claimed) {
+		const definition = this.definition(id);
+		const sheet = this.sheet();
+		if (!definition || !sheet) return;
+		const candidates = [];
+		const walk = (parent) => {
+			for (const rule of parent.cssRules) if (isKeyframesRule(rule)) {
+				if (rule.name === definition.name && !claimed.has(rule)) candidates.push(rule);
+			} else if ("cssRules" in rule) walk(rule);
+		};
+		walk(sheet);
+		const native = candidates[0];
+		if (!native) return;
+		claimed.add(native);
+		const order = this.definitions().indexOf(definition);
+		this.order.set(native, order);
+		let parent = native.parentRule;
+		for (const container of [...definition.containers || []].reverse()) {
+			if (!parent || !("cssRules" in parent)) break;
+			this.containers.set(container.id, parent);
+			this.order.set(parent, order);
+			parent = parent.parentRule;
+		}
+		return native;
+	}
+};
+// src/layer.ts
+function getRuleNodeCount(rule) {
+	return rule.nativeNodeCount ?? ("nodeCount" in rule ? rule.nodeCount : 1);
+}
+var RuntimeLayer = class {
+	name;
+	insertRule;
+	deleteRule;
+	rules = [];
+	tokenCounts = /* @__PURE__ */ new Map();
+	byKey = /* @__PURE__ */ new Map();
+	offsets;
+	nodeCount = 0;
+	native = null;
+	constructor(name, insertRule, deleteRule) {
+		this.name = name;
+		this.insertRule = insertRule;
+		this.deleteRule = deleteRule;
+	}
+	get text() {
+		return this.rules.length ? `@layer ${this.name}{${this.rules.map(({ text }) => text).join("")}}` : "";
+	}
+	get(key) {
+		return this.byKey.get(key);
+	}
+	/** Single-node layers and tail operations need no prefix traversal. */
+	nativeIndex(index) {
+		return index === this.rules.length ? this.nodeCount : this.offsets?.[index] ?? index;
+	}
+	track(rule, index) {
+		const count = getRuleNodeCount(rule);
+		const nativeIndex = this.nativeIndex(index);
+		if (count !== 1) this.offsets ??= Array.from({ length: this.rules.length }, (_, index) => index);
+		if (this.offsets) {
+			this.offsets.splice(index, 0, nativeIndex);
+			for (let next = index + 1; next < this.offsets.length; next++) this.offsets[next] += count;
+		}
+		this.nodeCount += count;
+		this.rules.splice(index, 0, rule);
+		this.byKey.set(rule.key, rule);
+		return nativeIndex;
+	}
+	/** Track an already hydrated rule without mutating the stylesheet. */
+	adopt(rule) {
+		if (!this.byKey.has(rule.key)) this.track(rule, this.rules.length);
+	}
+	insert(rule, index = this.rules.length) {
+		if (this.byKey.has(rule.key)) return;
+		const boundedIndex = Math.max(0, Math.min(index, this.rules.length));
+		const nativeIndex = this.nativeIndex(boundedIndex);
+		this.insertRule(this, rule, nativeIndex);
+		this.track(rule, boundedIndex);
+		return boundedIndex;
+	}
+	delete(key, index) {
+		const rule = this.byKey.get(key);
+		if (!rule) return;
+		const foundIndex = index !== void 0 && this.rules[index] === rule ? index : this.rules.indexOf(rule);
+		const nativeIndex = this.nativeIndex(foundIndex);
+		const count = getRuleNodeCount(rule);
+		this.rules.splice(foundIndex, 1);
+		this.byKey.delete(key);
+		this.nodeCount -= count;
+		if (this.nodeCount === this.rules.length) this.offsets = void 0;
+		if (this.offsets) {
+			this.offsets.splice(foundIndex, 1);
+			for (let next = foundIndex; next < this.offsets.length; next++) this.offsets[next] -= count;
+		}
+		this.deleteRule(this, rule, nativeIndex);
+		return rule;
+	}
+	clearRules() {
+		this.rules.length = 0;
+		this.byKey.clear();
+		this.offsets = void 0;
+		this.nodeCount = 0;
+	}
+	reset() {
+		this.clearRules();
+		this.tokenCounts.clear();
+		this.native = null;
+	}
+};
+// src/theme-layer.ts
+var RuntimeThemeLayer = class extends RuntimeLayer {
+	resourceText = "";
+	get text() {
+		return this.resourceText ? `@layer theme{${this.resourceText}}` : "";
+	}
+	reset() {
+		super.reset();
+		this.resourceText = "";
+	}
+};
+// src/utility-layer.ts
+/**
+* CSSOM host state for one generated utility layer. Class matching, ordering,
+* resources, and lifecycle are owned by the Rust engine session.
+*/
+var RuntimeUtilityLayer = class extends RuntimeLayer {};
+// src/hydration.ts
+function isDocumentRoot(root) {
+	const rootConstructorName = root?.constructor.name;
+	return rootConstructorName === "HTMLDocument" || rootConstructorName === "Document";
+}
+function findElementById(root, id) {
+	return isDocumentRoot(root) ? root.getElementById(id) : root.querySelector(`#${id}`);
+}
+function getRootHost(root) {
+	return isDocumentRoot(root) ? root.documentElement : root.host;
+}
+/** Classes the server rendered, so the progressive stylesheet already holds their CSS, if any. */
+function getRenderedClassNames(hydrationManifest) {
+	return new Set(hydrationManifest?.classNames);
+}
+function validateHydrationManifest(hydrationManifest) {
+	const candidate = hydrationManifest;
+	return candidate?.version === 5 && candidate.languageVersion === 18 && Array.isArray(candidate.classNames) && candidate.classNames.every((className) => typeof className === "string") && Array.isArray(candidate.resourceOrder?.variables) && Array.isArray(candidate.resourceOrder?.keyframes) ? candidate : void 0;
+}
+function invalidHydrationManifest(message, cause) {
+	return new MasterCSSError({
+		code: "INVALID_HYDRATION_MANIFEST",
+		domain: "runtime",
+		message
+	}, { cause });
+}
+function parseHydrationManifest(source) {
+	try {
+		const hydrationManifest = validateHydrationManifest(JSON.parse(source));
+		if (hydrationManifest) return hydrationManifest;
+	} catch (cause) {
+		throw invalidHydrationManifest("Cannot parse the Master CSS hydration manifest.", cause);
+	}
+	throw invalidHydrationManifest("Unsupported Master CSS hydration manifest. Expected version 5 and languageVersion 18. Recompile with matching packages.");
+}
+function readInlineHydrationManifest(root) {
+	const source = findElementById(root, MASTER_CSS_HYDRATION_MANIFEST_SCRIPT_ID)?.textContent?.trim();
+	return source ? parseHydrationManifest(source) : void 0;
+}
+function readExternalHydrationManifestSource(root) {
+	return findElementById(root, MASTER_CSS_RUNTIME_STYLE_ID)?.getAttribute(MASTER_CSS_HYDRATION_MANIFEST_ATTR) || void 0;
+}
+function resolveExternalHydrationManifestURL(root, source) {
+	const ownerDocument = isDocumentRoot(root) ? root : root.ownerDocument;
+	return new URL(source, ownerDocument.baseURI).href;
+}
+async function importHydrationManifest(url) {
+	try {
+		const value = (await import(
+			/* @vite-ignore */
+			/* webpackIgnore: true */
+			url,
+			{ with: { type: "json" } }
+)).default;
+		const hydrationManifest = validateHydrationManifest(value);
+		if (hydrationManifest) return hydrationManifest;
+		throw invalidHydrationManifest(`Invalid Master CSS hydration manifest loaded from ${url}.`);
+	} catch (cause) {
+		if (cause instanceof MasterCSSError) throw cause;
+		throw invalidHydrationManifest(`Cannot load the Master CSS hydration manifest from ${url}.`, cause);
+	}
+}
+async function resolveHydrationManifest$1(root, explicit) {
+	if (explicit !== void 0) {
+		const hydrationManifest = validateHydrationManifest(explicit);
+		if (!hydrationManifest) throw invalidHydrationManifest("Unsupported Master CSS hydration manifest. Expected version 5 and languageVersion 18. Recompile with matching packages.");
+		return hydrationManifest;
+	}
+	const inline = readInlineHydrationManifest(root);
+	if (inline) return inline;
+	const source = readExternalHydrationManifestSource(root);
+	return source ? await importHydrationManifest(resolveExternalHydrationManifestURL(root, source)) : void 0;
+}
+// src/host.ts
+const LAYER_ORDER = [
+	"theme",
+	"base",
+	"defaults",
+	"components",
+	"utilities"
+];
+function isLayerBlockRule(rule) {
+	return rule.constructor.name === "CSSLayerBlockRule";
+}
+function getGeneratedRuleNodeTexts(rule) {
+	const nodes = "nodes" in rule ? rule.nodes : void 0;
+	return nodes?.length ? nodes.map(({ text }) => text) : [rule.text];
+}
+function cloneEmittedGlobals(emittedGlobals) {
+	return {
+		variables: { ...emittedGlobals?.variables || {} },
+		keyframes: { ...emittedGlobals?.keyframes || {} }
+	};
+}
+function addEmittedGlobals(target, source) {
+	for (const kind of ["variables", "keyframes"]) for (const [name, count] of Object.entries(source[kind] || {})) if (count) target[kind][name] = Math.min(4294967295, (target[kind][name] || 0) + count);
+}
+function missingEmittedGlobals(current, source) {
+	const missing = cloneEmittedGlobals();
+	let found = false;
+	for (const kind of ["variables", "keyframes"]) for (const [name, count] of Object.entries(source[kind] || {})) if (count && !current[kind][name]) {
+		missing[kind][name] = count;
+		found = true;
+	}
+	return found ? missing : void 0;
+}
+var RuntimeHost = class {
+	root;
+	hydrationManifest;
+	host;
+	container;
+	insertRuntimeLayerRule = (layer, rule, nativeIndex) => this.insertLayerRule(layer, rule, nativeIndex);
+	deleteRuntimeLayerRule = (layer, rule, nativeIndex) => this.deleteLayerRule(layer, rule, nativeIndex);
+	baseLayer = new RuntimeUtilityLayer("base", this.insertRuntimeLayerRule, this.deleteRuntimeLayerRule);
+	themeLayer = new RuntimeThemeLayer("theme", this.insertRuntimeLayerRule, this.deleteRuntimeLayerRule);
+	defaultsLayer = new RuntimeUtilityLayer("defaults", this.insertRuntimeLayerRule, this.deleteRuntimeLayerRule);
+	componentsLayer = new RuntimeUtilityLayer("components", this.insertRuntimeLayerRule, this.deleteRuntimeLayerRule);
+	utilitiesLayer = new RuntimeUtilityLayer("utilities", this.insertRuntimeLayerRule, this.deleteRuntimeLayerRule);
+	keyframeHost;
+	keyframes = new RuntimeLayer("keyframes", (_layer, rule) => {
+		rule.nativeNodeCount = 0;
+		try {
+			rule.native = this.keyframeHost.insert(rule.key, rule.text);
+			rule.nativeNodeCount = rule.native ? 1 : 0;
+		} catch (error) {
+			console.error(error, rule);
+		}
+	}, (_layer, rule) => this.keyframeHost.remove(rule.native));
+	classUtilities = /* @__PURE__ */ new Map();
+	ruleClasses = /* @__PURE__ */ new Map();
+	emittedGlobals;
+	/** Set when the engine starts; progressive pages defer both. */
+	keyframeDefinitions = [];
+	bindingEngine;
+	style = null;
+	progressive = false;
+	hydrationFailureReason;
+	get rules() {
+		return LAYER_ORDER.map((name) => this.getLayerByName(name)).filter((layer) => Boolean(layer?.text));
+	}
+	constructor(root, emittedGlobals, hydrationManifest) {
+		this.root = root;
+		this.hydrationManifest = hydrationManifest;
+		this.keyframeHost = new KeyframeHost(() => this.getStyleSheet(), () => this.keyframeDefinitions);
+		this.emittedGlobals = cloneEmittedGlobals(emittedGlobals);
+		this.host = isDocumentRoot(root) ? root.documentElement : root.host;
+		this.container = isDocumentRoot(root) ? root.head : root;
+		this.resetResourceCounts();
+	}
+	/** Rule and resource changes run only after the engine starts. */
+	get engine() {
+		if (!this.bindingEngine) throw new MasterCSSError({
+			code: "INTERNAL",
+			domain: "runtime",
+			message: "The Master CSS engine has not started."
+		});
+		return this.bindingEngine;
+	}
+	registerEmittedGlobals(emittedGlobals) {
+		if (!emittedGlobals) return;
+		const transition = this.bindingEngine?.registerEmittedGlobals(emittedGlobals);
+		addEmittedGlobals(this.emittedGlobals, emittedGlobals);
+		if (transition) this.applyTransition(transition);
+	}
+	/** Count resources another host emitted without changing rendered CSS; callers adopt a snapshot next. */
+	registerMissingEmittedGlobals(emittedGlobals) {
+		const missing = emittedGlobals && missingEmittedGlobals(this.emittedGlobals, emittedGlobals);
+		if (!missing) return false;
+		this.engine.registerEmittedGlobals(missing);
+		addEmittedGlobals(this.emittedGlobals, missing);
+		return true;
+	}
+	adoptEmittedGlobals(emittedGlobals) {
+		Object.assign(this.emittedGlobals, cloneEmittedGlobals(emittedGlobals));
+	}
+	replaceEmittedGlobals(emittedGlobals) {
+		const transition = this.engine.replaceEmittedGlobals(emittedGlobals);
+		Object.assign(this.emittedGlobals, cloneEmittedGlobals(emittedGlobals));
+		this.applyTransition(transition);
+	}
+	setHydrationManifest(hydrationManifest) {
+		this.hydrationManifest = hydrationManifest;
+		return this;
+	}
+	getOwnerDocument() {
+		return isDocumentRoot(this.root) ? this.root : this.root.ownerDocument;
+	}
+	createRuntimeStyle() {
+		this.style = this.getOwnerDocument().createElement("style");
+		this.style.id = MASTER_CSS_RUNTIME_STYLE_ID;
+		this.style.setAttribute("blocking", "render");
+		this.container.append(this.style);
+	}
+	getStyleSheet() {
+		return this.style?.sheet || void 0;
+	}
+	findTopLevelRuleIndex(rule) {
+		const sheet = this.getStyleSheet();
+		if (!sheet) return -1;
+		for (let index = 0; index < sheet.cssRules.length; index++) if (sheet.cssRules.item(index) === rule) return index;
+		return -1;
+	}
+	getLayerInsertIndex(name) {
+		const sheet = this.getStyleSheet();
+		if (!sheet) return 0;
+		const rank = LAYER_ORDER.indexOf(name);
+		for (let index = 0; index < sheet.cssRules.length; index++) {
+			const rule = sheet.cssRules.item(index);
+			if (rule.constructor.name === "CSSKeyframesRule") return index;
+			if (isLayerBlockRule(rule)) {
+				if (LAYER_ORDER.indexOf(rule.name) > rank) return index;
+			}
+		}
+		return sheet.cssRules.length;
+	}
+	ensureNativeLayer(layer) {
+		const sheet = this.getStyleSheet();
+		if (!sheet) return;
+		if (layer.native?.parentStyleSheet) return layer.native;
+		const insertedIndex = sheet.insertRule(`@layer ${layer.name}{}`, this.getLayerInsertIndex(layer.name));
+		layer.native = sheet.cssRules.item(insertedIndex);
+		return layer.native;
+	}
+	insertLayerRule(layer, rule, nativeIndex) {
+		rule.nativeNodeCount = 0;
+		const nativeLayer = this.ensureNativeLayer(layer);
+		if (!nativeLayer) return;
+		const nodes = "nodes" in rule ? rule.nodes : void 0;
+		for (const [nodeIndex, text] of getGeneratedRuleNodeTexts(rule).entries()) try {
+			const insertedIndex = nativeLayer.insertRule(text, nativeIndex + rule.nativeNodeCount);
+			rule.nativeNodeCount++;
+			const native = nativeLayer.cssRules.item(insertedIndex) || void 0;
+			if (nodes?.[nodeIndex]) nodes[nodeIndex].native = native;
+			else rule.native = native;
+		} catch (error) {
+			console.error(error, rule);
+		}
+	}
+	deleteLayerRule(layer, rule, nativeIndex) {
+		const nativeLayer = layer.native;
+		if (!nativeLayer) return;
+		for (let count = getRuleNodeCount(rule); count > 0; count--) if (nativeIndex < nativeLayer.cssRules.length) nativeLayer.deleteRule(nativeIndex);
+		if (!layer.rules.length) {
+			const sheet = this.getStyleSheet();
+			const topIndex = this.findTopLevelRuleIndex(nativeLayer);
+			if (sheet && topIndex !== -1) sheet.deleteRule(topIndex);
+			layer.native = null;
+		}
+	}
+	getLayerByName(name) {
+		switch (name) {
+			case "theme": return this.themeLayer;
+			case "base": return this.baseLayer;
+			case "defaults": return this.defaultsLayer;
+			case "components": return this.componentsLayer;
+			case "utilities": return this.utilitiesLayer;
+		}
+	}
+	getUtilityLayerByName(name) {
+		return this.getLayerByName(name);
+	}
+	getUtilityLayers() {
+		return [
+			this.baseLayer,
+			this.defaultsLayer,
+			this.componentsLayer,
+			this.utilitiesLayer
+		];
+	}
+	setThemeResource(text) {
+		const sheet = this.getStyleSheet();
+		if (sheet && this.themeLayer.native) {
+			const index = this.findTopLevelRuleIndex(this.themeLayer.native);
+			if (index !== -1) sheet.deleteRule(index);
+		}
+		this.themeLayer.native = null;
+		this.themeLayer.resourceText = text;
+		if (sheet && text) {
+			const index = sheet.insertRule(`@layer theme{${text}}`, this.getLayerInsertIndex("theme"));
+			this.themeLayer.native = sheet.cssRules.item(index);
+		}
+	}
+	clearKeyframeRules() {
+		for (const rule of this.keyframes.rules) this.keyframeHost.remove(rule.native);
+	}
+	/** Places keyframes rules the runtime stylesheet lost or could not take yet. */
+	reconcileKeyframeRules() {
+		if (!this.bindingEngine) return;
+		const claimed = /* @__PURE__ */ new Set();
+		for (const rule of this.keyframes.rules) if (this.keyframeHost.contains(rule.native)) claimed.add(rule.native);
+		for (const rule of this.keyframes.rules) {
+			if (rule.native && claimed.has(rule.native)) continue;
+			this.keyframeHost.remove(rule.native);
+			rule.native = this.keyframeHost.adopt(rule.key, claimed) || this.keyframeHost.insert(rule.key, rule.text);
+			if (rule.native) claimed.add(rule.native);
+			rule.nativeNodeCount = rule.native ? 1 : 0;
+		}
+	}
+	resetHostRuleState() {
+		this.clearClassReferences();
+		this.baseLayer.reset();
+		this.themeLayer.reset();
+		this.defaultsLayer.reset();
+		this.componentsLayer.reset();
+		this.utilitiesLayer.reset();
+		this.keyframes.reset();
+		this.keyframeHost.reset();
+		this.resetResourceCounts();
+	}
+	resetResourceCounts() {
+		this.themeLayer.tokenCounts.clear();
+		for (const [name, count] of Object.entries(this.emittedGlobals.variables)) if (count) this.themeLayer.tokenCounts.set(name, count);
+	}
+	syncResourceSnapshot(resources) {
+		this.themeLayer.resourceText = resources.themeText || "";
+		this.themeLayer.clearRules();
+		this.resetResourceCounts();
+		for (const { name, refCount } of resources.variables) {
+			const rule = {
+				key: name,
+				name,
+				text: ""
+			};
+			this.themeLayer.adopt(rule);
+			if (refCount) this.themeLayer.tokenCounts.set(name, (this.themeLayer.tokenCounts.get(name) || 0) + refCount);
+		}
+	}
+	clearClassReferences() {
+		this.classUtilities.clear();
+		this.ruleClasses.clear();
+	}
+	setClassRules(className, rules) {
+		const previous = this.classUtilities.get(className);
+		if (previous?.length === rules.length && previous.every((rule, index) => rule === rules[index])) return;
+		for (const rule of previous || []) {
+			const classes = this.ruleClasses.get(rule);
+			if (typeof classes === "string") {
+				if (classes === className) this.ruleClasses.delete(rule);
+			} else if (classes) {
+				classes.delete(className);
+				if (classes.size === 1) this.ruleClasses.set(rule, classes.values().next().value);
+				else if (!classes.size) this.ruleClasses.delete(rule);
+			}
+		}
+		if (!rules.length) {
+			this.classUtilities.delete(className);
+			return;
+		}
+		this.classUtilities.set(className, rules);
+		for (const rule of rules) {
+			const classes = this.ruleClasses.get(rule);
+			if (classes === void 0) this.ruleClasses.set(rule, className);
+			else if (typeof classes === "string") {
+				if (classes !== className) this.ruleClasses.set(rule, /* @__PURE__ */ new Set([classes, className]));
+			} else classes.add(className);
+		}
+	}
+	registerClassRule(rule) {
+		this.setClassRules(rule.name, [...this.classUtilities.get(rule.name) || [], rule]);
+	}
+	unregisterLayerRule(rule) {
+		if (!(rule instanceof HydratedGeneratedRule)) return;
+		const classes = this.ruleClasses.get(rule);
+		if (!classes) return;
+		this.ruleClasses.delete(rule);
+		for (const className of typeof classes === "string" ? [classes] : classes) this.setClassRules(className, (this.classUtilities.get(className) || []).filter((candidate) => candidate !== rule));
+	}
+	syncClassReferences(classes) {
+		for (const { className, references } of classes) {
+			const rules = references.map(({ layer, key }) => this.getUtilityLayerByName(layer).get(key)).filter((rule) => rule instanceof HydratedGeneratedRule);
+			this.setClassRules(className, rules);
+		}
+	}
+	applyTransition(transition, classNames = []) {
+		for (const mutation of transition.mutations) {
+			if (mutation.target === "theme") {
+				this.setThemeResource(mutation.op === "insert" ? mutation.text : "");
+				continue;
+			}
+			if (mutation.target === "keyframes") {
+				if (mutation.op === "insert") this.keyframes.insert({
+					key: mutation.key,
+					name: mutation.key,
+					text: mutation.text
+				}, mutation.index);
+				else this.keyframes.delete(mutation.key, mutation.index);
+				continue;
+			}
+			const layer = this.getUtilityLayerByName(mutation.target);
+			if (mutation.op === "insert") {
+				if (!mutation.rule) throw new MasterCSSError({
+					code: "INTERNAL",
+					domain: "runtime",
+					message: `Missing generated rule contract for ${mutation.key}.`
+				});
+				const rule = new HydratedGeneratedRule(mutation.rule, layer);
+				if (layer.insert(rule, mutation.index) !== void 0) this.registerClassRule(rule);
+			} else {
+				const rule = layer.delete(mutation.key, mutation.index);
+				if (rule) this.unregisterLayerRule(rule);
+			}
+		}
+		const state = this.engine.executionState(classNames);
+		this.syncResourceSnapshot(state.resources);
+		this.syncClassReferences(state.classes);
+	}
+	adoptSnapshot(snapshot, preserveStyle = false) {
+		if (!preserveStyle) this.clearKeyframeRules();
+		this.resetHostRuleState();
+		if (!this.style) return;
+		if (!preserveStyle) this.style.textContent = snapshot.text;
+		const sheet = this.getStyleSheet();
+		if (!sheet) return;
+		const nativeLayers = /* @__PURE__ */ new Map();
+		for (const rule of sheet.cssRules) if (isLayerBlockRule(rule)) nativeLayers.set(rule.name, rule);
+		this.themeLayer.native = nativeLayers.get("theme") || null;
+		this.themeLayer.resourceText = snapshot.resources.themeText || "";
+		const layerNativeIndexes = /* @__PURE__ */ new Map();
+		for (const ir of snapshot.rules) {
+			const layer = this.getUtilityLayerByName(ir.layer);
+			layer.native ||= nativeLayers.get(ir.layer) || null;
+			const rule = new HydratedGeneratedRule(ir, layer);
+			const nativeIndex = layerNativeIndexes.get(ir.layer) || 0;
+			const nodes = rule.nodes;
+			if (nodes?.length) for (let index = 0; index < nodes.length; index++) nodes[index].native = layer.native?.cssRules.item(nativeIndex + index) || void 0;
+			else rule.native = layer.native?.cssRules.item(nativeIndex) || void 0;
+			layerNativeIndexes.set(ir.layer, nativeIndex + (nodes?.length || 1));
+			layer.adopt(rule);
+			this.registerClassRule(rule);
+		}
+		const claimed = /* @__PURE__ */ new Set();
+		for (const resource of snapshot.resources.keyframes) {
+			const native = this.keyframeHost.adopt(resource.id, claimed);
+			if (native) this.keyframes.adopt({
+				key: resource.id,
+				name: resource.name,
+				text: resource.text,
+				native,
+				nativeNodeCount: 1
+			});
+			else this.keyframes.insert({
+				key: resource.id,
+				name: resource.name,
+				text: resource.text
+			});
+		}
+		this.syncResourceSnapshot(snapshot.resources);
+	}
+};
+// src/mutation.ts
+function countMutationDelta(deltaCounts, classCounts) {
+	const added = [];
+	const removed = [];
+	for (const [className, change] of deltaCounts) {
+		const current = classCounts.get(className) || 0;
+		const next = current + change;
+		if (next > 0) {
+			classCounts.set(className, next);
+			if (current === 0) added.push(className);
+		} else {
+			classCounts.delete(className);
+			removed.push(className);
+		}
+	}
+	return {
+		added,
+		removed
+	};
+}
+/** Counts class changes while the engine is deferred; returns newly connected classes. */
+function applyDeferredMutationDelta(deltaCounts, classCounts) {
+	return countMutationDelta(deltaCounts, classCounts).added;
+}
+function applyRuntimeMutationDelta(records, deltaCounts, context) {
+	const { added, removed: removedClassNames } = countMutationDelta(deltaCounts, context.classCounts);
+	const warmClassNames = added.filter((className) => context.isWarm(className));
+	const queuedClassNames = added.filter((className) => !context.isWarm(className));
+	if (warmClassNames.length) context.ensure(warmClassNames);
+	if (queuedClassNames.length) context.queueAdded(queuedClassNames);
+	if (removedClassNames.length) {
+		context.cancelAdded(removedClassNames);
+		context.queueRemoved(removedClassNames);
+	}
+	{
+		const [root, host, snapshot] = context.debug();
+		debugRuntimeMutation(records, deltaCounts, root, host, snapshot);
+	}
+}
+// src/retention-config.ts
+const RETAINED_CLASS_RULE_MIN_AGE_MS = 1e3;
+const RETAINED_CLASS_RULE_IDLE_TIMEOUT_MS = 5e3;
+// src/startup.ts
+const MASTER_CSS_RUNTIME_STARTUP_TIMEOUT_MS = 3e3;
+/** Races startup steps against one deadline; `subject` names what failed to start. */
+function createStartupTimeout(view, timeoutMs, subject) {
+	let handle;
+	const expired = new Promise((_, reject) => {
+		handle = view.setTimeout(() => reject(new MasterCSSError({
+			code: "RUNTIME_STARTUP_TIMEOUT",
+			domain: "runtime",
+			message: `Master CSS ${subject} did not start within ${timeoutMs}ms.`
+		})), timeoutMs);
+	});
+	return {
+		race: (step) => Promise.race([step, expired]),
+		clear: () => view.clearTimeout(handle)
+	};
+}
+function toStartupDiagnostic(error) {
+	if (error instanceof MasterCSSError && error.diagnostics[0]) return error.diagnostics[0];
+	return Object.freeze({
+		version: MASTER_CSS_DIAGNOSTIC_VERSION,
+		code: "INTERNAL",
+		domain: "runtime",
+		severity: "error",
+		message: error instanceof Error ? error.message : String(error)
+	});
+}
+// src/core.ts
+const MASTER_CSS_RUNTIME_STYLE_SELECTOR = `style#${MASTER_CSS_RUNTIME_STYLE_ID}`;
+function programBytes(program) {
+	return ArrayBuffer.isView(program) ? new Uint8Array(program.buffer, program.byteOffset, program.byteLength) : new Uint8Array(program);
+}
+async function resolveProgram$1(program) {
+	return programBytes(typeof program === "function" ? await program() : program);
+}
+/** `@master/css` stays out of the entry chunk, so deferred pages never download it. */
+async function loadEngine(program, emittedGlobals, binding) {
+	const { createEngine } = await import("@master/css");
+	const resolvedProgram = await program;
+	return {
+		engine: await createEngine({
+			program: resolvedProgram,
+			emittedGlobals,
+			binding
+		}),
+		program: resolvedProgram
+	};
+}
+function runtimeDisposedError() {
+	return new MasterCSSError({
+		code: "RUNTIME_DISPOSED",
+		domain: "runtime",
+		message: "The Master CSS runtime has been disposed."
+	});
+}
+var MasterCSSRuntime = class MasterCSSRuntime extends RuntimeHost {
+	static #instances = /* @__PURE__ */ new WeakMap();
+	static #starts = /* @__PURE__ */ new WeakMap();
+	classCounts = /* @__PURE__ */ new Map();
+	retainedClassNames = /* @__PURE__ */ new Set();
+	observer;
+	observing = false;
+	disposed = false;
+	globalFacade;
+	classTracker = new RuntimeClassTracker();
+	pendingAddedClassNames = /* @__PURE__ */ new Set();
+	pendingRemovedClassNames = /* @__PURE__ */ new Set();
+	retainedClassRules = /* @__PURE__ */ new Map();
+	pendingAdditionFrame;
+	pendingRemovalFrame;
+	pendingRemovalFlushFrame;
+	retainedCleanupIdleHandle;
+	retainedCleanupTimeoutHandle;
+	engineState;
+	engineStart;
+	programSource;
+	programRequest;
+	/** The program the engine executes; refresh() without one re-executes it. */
+	program;
+	/** Engine calls made while it loads, replayed in order once it is installed or fails. */
+	pendingEngineCalls = [];
+	renderedClassNames;
+	engineBinding;
+	startupTimeoutMs;
+	onDiagnostic;
+	constructor(root, options, hydrationManifest, loaded) {
+		super(root, options.emittedGlobals, hydrationManifest);
+		this.programSource = options.program;
+		this.renderedClassNames = getRenderedClassNames(hydrationManifest);
+		this.engineBinding = options.binding || "auto";
+		this.startupTimeoutMs = options.startupTimeoutMs ?? 3e3;
+		this.onDiagnostic = options.onDiagnostic;
+		if (loaded) {
+			this.bindingEngine = loaded.engine;
+			this.program = loaded.program;
+			this.keyframeDefinitions = loaded.engine.keyframeDefinitions();
+			this.engineState = "ready";
+		} else {
+			this.engineState = "deferred";
+			if (options.enginePrefetch === "idle") this.startEngineWhenIdle();
+		}
+	}
+	get binding() {
+		return this.bindingEngine?.binding;
+	}
+	static async start(options) {
+		const root = options.root || document;
+		const current = MasterCSSRuntime.#instances.get(root);
+		if (current) {
+			current.registerEmittedGlobals(options.emittedGlobals);
+			if (options.hydrationManifest !== void 0) current.setHydrationManifest(options.hydrationManifest);
+			current.retryEngine();
+			return current;
+		}
+		const pending = MasterCSSRuntime.#starts.get(root);
+		if (pending) {
+			if (options.emittedGlobals) pending.emittedGlobals.push(options.emittedGlobals);
+			if (options.hydrationManifest !== void 0) pending.hydrationManifest = options.hydrationManifest;
+			return await pending.promise;
+		}
+		let pendingStart;
+		const startup = MasterCSSRuntime.startNew(root, options).then((runtime) => {
+			try {
+				for (const emittedGlobals of pendingStart.emittedGlobals) runtime.registerEmittedGlobals(emittedGlobals);
+				if (pendingStart.hydrationManifest !== void 0) runtime.setHydrationManifest(pendingStart.hydrationManifest);
+				return runtime;
+			} catch (error) {
+				runtime.dispose();
+				throw error;
+			}
+		}).finally(() => MasterCSSRuntime.#starts.delete(root));
+		pendingStart = {
+			promise: startup,
+			emittedGlobals: []
+		};
+		MasterCSSRuntime.#starts.set(root, pendingStart);
+		return await startup;
+	}
+	static async startNew(root, options) {
+		const { binding = "auto", startupTimeoutMs = MASTER_CSS_RUNTIME_STARTUP_TIMEOUT_MS, onDiagnostic } = options;
+		const timeout = createStartupTimeout((isDocumentRoot(root) ? root : root.ownerDocument).defaultView || globalThis, startupTimeoutMs, "runtime");
+		let abandoned = false;
+		let ownedEngine;
+		let startupRuntime;
+		const startEngine = () => loadEngine(resolveProgram$1(options.program), options.emittedGlobals, binding).then((loaded) => {
+			if (abandoned) loaded.engine.dispose();
+			else ownedEngine = loaded.engine;
+			return loaded;
+		});
+		const enginePromise = options.engine !== "eager" && Boolean(findElementById(root, MASTER_CSS_RUNTIME_STYLE_ID)) ? void 0 : startEngine();
+		const hydrationPromise = resolveHydrationManifest$1(root, options.hydrationManifest);
+		try {
+			let loaded;
+			let hydrationManifest;
+			if (enginePromise) [loaded, hydrationManifest] = await timeout.race(Promise.all([enginePromise, hydrationPromise]));
+			else {
+				hydrationManifest = await timeout.race(hydrationPromise);
+				if (!hydrationManifest?.classNames.length) loaded = await timeout.race(startEngine());
+			}
+			timeout.clear();
+			startupRuntime = new MasterCSSRuntime(root, options, hydrationManifest, loaded);
+			return startupRuntime.register();
+		} catch (error) {
+			abandoned = true;
+			(startupRuntime || ownedEngine)?.dispose();
+			timeout.clear();
+			getRootHost(root).removeAttribute("hidden");
+			onDiagnostic?.(toStartupDiagnostic(error));
+			throw error;
+		}
+	}
+	/** Starts the engine of a deferred progressive page, resolving once it executes rules. */
+	ready() {
+		if (this.disposed) return Promise.reject(runtimeDisposedError());
+		return this.engineState === "ready" ? Promise.resolve(this) : this.startEngine();
+	}
+	startEngine() {
+		this.engineStart ??= this.loadDeferredEngine();
+		return this.engineStart;
+	}
+	async loadDeferredEngine() {
+		this.engineState = "loading";
+		const timeout = createStartupTimeout(this.getAnimationFrameWindow(), this.startupTimeoutMs, "engine");
+		const loading = loadEngine(this.loadProgram(), this.emittedGlobals, this.engineBinding);
+		try {
+			const { engine, program } = await timeout.race(loading);
+			if (this.disposed) throw runtimeDisposedError();
+			this.installEngine(engine, program);
+			return this;
+		} catch (error) {
+			if (!this.disposed) {
+				this.engineState = "failed";
+				this.programRequest = void 0;
+				this.host.removeAttribute("hidden");
+				this.onDiagnostic?.(toStartupDiagnostic(error));
+				this.replayPendingEngineCalls();
+			}
+			loading.then(({ engine }) => {
+				if (this.engineState === "ready" && this.bindingEngine === engine) return;
+				if (this.bindingEngine === engine) this.bindingEngine = void 0;
+				engine.dispose();
+			}, () => {});
+			throw error;
+		} finally {
+			timeout.clear();
+		}
+	}
+	loadProgram() {
+		this.programRequest ??= resolveProgram$1(this.programSource);
+		return this.programRequest;
+	}
+	installEngine(engine, program) {
+		this.bindingEngine = engine;
+		this.program = program;
+		this.keyframeDefinitions = engine.keyframeDefinitions();
+		this.engineState = "ready";
+		if (this.observing) {
+			this.adoptConnectedClasses(new Set(this.classCounts.keys()));
+			this.reconcileKeyframeRules();
+		}
+		this.replayPendingEngineCalls();
+	}
+	replayPendingEngineCalls() {
+		for (const call of this.pendingEngineCalls.splice(0)) call();
+	}
+	startEngineWhenIdle() {
+		const view = this.getCleanupWindow();
+		const start = () => this.requestEngine();
+		if (view.requestIdleCallback) view.requestIdleCallback(start);
+		else view.setTimeout(start, 0);
+	}
+	/** Starts a deferred engine for a class pre-rendered CSS lacks; a failed one waits for a retry. */
+	requestEngine() {
+		if (this.engineState === "deferred" && !this.disposed) this.startEngine().catch(() => {});
+	}
+	retryEngine() {
+		if (this.engineState !== "failed") return;
+		this.engineStart = void 0;
+		this.engineState = "deferred";
+		this.requestEngine();
+	}
+	requireEngine() {
+		if (this.engineState === "ready") return this.engine;
+		this.requestEngine();
+		throw new MasterCSSError({
+			code: "RUNTIME_ENGINE_NOT_READY",
+			domain: "runtime",
+			message: "The Master CSS engine has not started. Await runtime.ready() before changing class rules."
+		});
+	}
+	registerEmittedGlobals(emittedGlobals) {
+		if (emittedGlobals && this.engineState === "loading") this.pendingEngineCalls.push(() => super.registerEmittedGlobals(emittedGlobals));
+		else super.registerEmittedGlobals(emittedGlobals);
+	}
+	setHydrationManifest(hydrationManifest) {
+		this.renderedClassNames = getRenderedClassNames(hydrationManifest);
+		return super.setHydrationManifest(hydrationManifest);
+	}
+	register() {
+		const registered = MasterCSSRuntime.#instances.get(this.root) === this;
+		MasterCSSRuntime.#instances.set(this.root, this);
+		if (isDocumentRoot(this.root)) this.root.defaultView.globalThis.masterCSSRuntime = this.getGlobalFacade();
+		if (!registered && true) debugRuntimeCreated(this);
+		return this;
+	}
+	unregister() {
+		MasterCSSRuntime.#instances.delete(this.root);
+		if (isDocumentRoot(this.root) && this.root.defaultView.globalThis.masterCSSRuntime === this.globalFacade) this.root.defaultView.globalThis.masterCSSRuntime = void 0;
+		return this;
+	}
+	getGlobalFacade() {
+		if (this.globalFacade) return this.globalFacade;
+		let facade;
+		const getBinding = () => this.binding;
+		facade = Object.freeze({
+			get binding() {
+				return getBinding();
+			},
+			ready: async () => {
+				await this.ready();
+				return facade;
+			},
+			observe: () => {
+				this.observe();
+				return facade;
+			},
+			disconnect: () => {
+				this.disconnect();
+				return facade;
+			},
+			refresh: (program, emittedGlobals) => {
+				this.refresh(program, emittedGlobals);
+				return facade;
+			},
+			ensureClassRules: (classNames) => this.ensureClassRules(classNames),
+			deleteClassRules: (classNames) => this.deleteClassRules(classNames),
+			snapshot: () => this.snapshot(),
+			dispose: () => this.dispose(),
+			[Symbol.dispose]: () => this.dispose()
+		});
+		this.globalFacade = facade;
+		return facade;
+	}
+	warnHydrationFallback(reason) {
+		console.warn(`Master CSS progressive hydration requires a matching hydration manifest. ${reason} Rebuilding ${MASTER_CSS_RUNTIME_STYLE_SELECTOR} with the runtime.`);
+	}
+	useRuntimeStyle(connectedNames, reason) {
+		if (reason) this.warnHydrationFallback(reason);
+		this.style?.remove();
+		this.style = null;
+		this.progressive = false;
+		this.createRuntimeStyle();
+		this.adoptSnapshot(this.engine.snapshot());
+		this.ensureClassRules([...connectedNames]);
+	}
+	detectRuntimeStyle() {
+		const style = findElementById(this.root, MASTER_CSS_RUNTIME_STYLE_ID);
+		if (style?.constructor.name === "HTMLStyleElement") {
+			this.style = style;
+			this.progressive = true;
+		}
+	}
+	collectConnectedClasses() {
+		return this.classTracker.collectConnected(this.root, this.classCounts);
+	}
+	failHydration(reason, ensuredClassNames = []) {
+		this.hydrationFailureReason = reason;
+		if (ensuredClassNames.length) this.engine.deleteClassRules(ensuredClassNames);
+		this.resetHostRuleState();
+	}
+	matchesEngineSnapshotText(snapshot) {
+		const sheet = this.getStyleSheet();
+		if (!sheet) return false;
+		const expectedStyle = this.getOwnerDocument().createElement("style");
+		expectedStyle.media = "not all";
+		expectedStyle.textContent = snapshot.text;
+		this.container.append(expectedStyle);
+		try {
+			const expectedRules = expectedStyle.sheet?.cssRules;
+			if (!expectedRules) return false;
+			const checkedLayers = /* @__PURE__ */ new Set();
+			for (const layer of expectedRules) {
+				if (!isLayerBlockRule(layer) || layer.name === "theme" || checkedLayers.has(layer.name) || !snapshot.rules.some((rule) => rule.layer === layer.name)) continue;
+				checkedLayers.add(layer.name);
+				const nodeCount = snapshot.rules.filter((rule) => rule.layer === layer.name).reduce((count, rule) => count + (rule.nodes?.length || 1), 0);
+				if (layer.cssRules.length !== nodeCount) return false;
+			}
+			const actualRules = [...sheet.cssRules];
+			return actualRules.length === expectedRules.length && actualRules.every((rule, index) => rule.cssText === expectedRules[index].cssText);
+		} finally {
+			expectedStyle.remove();
+		}
+	}
+	hydrate(nativeLayerRules) {
+		this.hydrationFailureReason = void 0;
+		const manifest = this.hydrationManifest;
+		if (manifest?.version !== 5 || !Array.isArray(manifest.classNames)) return this.failHydration("Missing or invalid hydration manifest.");
+		if (!manifest.classNames.length) return this.failHydration(`Hydration manifest has no rendered classes for ${MASTER_CSS_RUNTIME_STYLE_SELECTOR}.`);
+		const classNames = [...manifest.classNames];
+		this.engine.ensureClassRules(classNames);
+		let snapshot = this.engine.snapshot();
+		if (this.registerMissingEmittedGlobals(manifest.emittedGlobals)) snapshot = this.engine.snapshot();
+		const resourceOrder = {
+			variables: snapshot.resources.variables.map((resource) => resource.name),
+			keyframes: snapshot.resources.keyframes.map((resource) => resource.id)
+		};
+		if (JSON.stringify(resourceOrder) !== JSON.stringify(manifest.resourceOrder)) return this.failHydration("Generated resources do not match the hydration manifest.", classNames);
+		if (!this.matchesEngineSnapshotText(snapshot)) return this.failHydration(`${MASTER_CSS_RUNTIME_STYLE_SELECTOR} does not match the Rust engine snapshot.`, classNames);
+		if (nativeLayerRules.length !== this.style?.sheet?.cssRules.length) return this.failHydration(`Cannot read ${MASTER_CSS_RUNTIME_STYLE_SELECTOR} CSS rules.`, classNames);
+		this.adoptSnapshot(snapshot, true);
+		const result = { allUtilities: this.getUtilityLayers().flatMap(({ rules }) => rules.filter((rule) => rule instanceof HydratedGeneratedRule)) };
+		debugRuntimeHydrated(this, result);
+		return result;
+	}
+	hydrateRuntimeStyle(connectedNames) {
+		const hydrateResult = this.style?.sheet && this.hydrate(this.style.sheet.cssRules);
+		if (!hydrateResult) {
+			this.useRuntimeStyle(connectedNames, this.hydrationFailureReason || `Cannot read ${MASTER_CSS_RUNTIME_STYLE_SELECTOR} CSS rules.`);
+			return;
+		}
+		const hydratedClassNames = new Set(hydrateResult.allUtilities.map(({ name }) => name));
+		const missing = [...connectedNames].filter((className) => !hydratedClassNames.has(className));
+		if (missing.length) this.ensureClassRules(missing);
+		this.queueRemovedClassNames(hydratedClassNames);
+	}
+	renderRuntimeStyle(connectedNames) {
+		this.createRuntimeStyle();
+		this.adoptSnapshot(this.engine.snapshot());
+		this.ensureClassRules([...connectedNames]);
+	}
+	adoptConnectedClasses(connectedNames) {
+		if (this.progressive) this.hydrateRuntimeStyle(connectedNames);
+		else this.renderRuntimeStyle(connectedNames);
+		if (!this.progressive) this.host.removeAttribute("hidden");
+	}
+	getAnimationFrameWindow() {
+		return this.getOwnerDocument().defaultView || globalThis;
+	}
+	cancelPendingRemovalFrames() {
+		const view = this.getAnimationFrameWindow();
+		if (this.pendingRemovalFrame !== void 0) view.cancelAnimationFrame(this.pendingRemovalFrame);
+		if (this.pendingRemovalFlushFrame !== void 0) view.cancelAnimationFrame(this.pendingRemovalFlushFrame);
+		this.pendingRemovalFrame = void 0;
+		this.pendingRemovalFlushFrame = void 0;
+	}
+	cancelPendingAdditionFrame() {
+		if (this.pendingAdditionFrame === void 0) return;
+		this.getAnimationFrameWindow().cancelAnimationFrame(this.pendingAdditionFrame);
+		this.pendingAdditionFrame = void 0;
+	}
+	clearPendingAddedClassNames() {
+		this.pendingAddedClassNames.clear();
+		this.cancelPendingAdditionFrame();
+	}
+	clearPendingRemovedClassNames() {
+		this.pendingRemovedClassNames.clear();
+		this.cancelPendingRemovalFrames();
+	}
+	getCleanupWindow() {
+		return this.getAnimationFrameWindow();
+	}
+	cancelRetainedClassRuleCleanup() {
+		const view = this.getCleanupWindow();
+		if (this.retainedCleanupIdleHandle !== void 0) {
+			view.cancelIdleCallback?.(this.retainedCleanupIdleHandle);
+			this.retainedCleanupIdleHandle = void 0;
+		}
+		if (this.retainedCleanupTimeoutHandle !== void 0) {
+			view.clearTimeout(this.retainedCleanupTimeoutHandle);
+			this.retainedCleanupTimeoutHandle = void 0;
+		}
+	}
+	clearRetainedClassRules() {
+		this.retainedClassNames.clear();
+		this.retainedClassRules.clear();
+		this.cancelRetainedClassRuleCleanup();
+	}
+	cancelPendingRemovedClassNames(classNames) {
+		for (const className of classNames) this.pendingRemovedClassNames.delete(className);
+		if (!this.pendingRemovedClassNames.size) this.cancelPendingRemovalFrames();
+	}
+	cancelPendingAddedClassNames(classNames) {
+		for (const className of classNames) this.pendingAddedClassNames.delete(className);
+		if (!this.pendingAddedClassNames.size) this.cancelPendingAdditionFrame();
+	}
+	cancelRetainedClassNames(classNames) {
+		for (const className of classNames) {
+			this.retainedClassNames.delete(className);
+			this.retainedClassRules.delete(className);
+		}
+		if (!this.retainedClassNames.size) this.cancelRetainedClassRuleCleanup();
+	}
+	schedulePendingRemovalFlush() {
+		if (!this.pendingRemovedClassNames.size || this.pendingRemovalFrame !== void 0 || this.pendingRemovalFlushFrame !== void 0) return;
+		const view = this.getAnimationFrameWindow();
+		this.pendingRemovalFrame = view.requestAnimationFrame(() => {
+			this.pendingRemovalFrame = void 0;
+			this.pendingRemovalFlushFrame = view.requestAnimationFrame(() => {
+				this.pendingRemovalFlushFrame = void 0;
+				this.flushPendingRemovedClassNames();
+			});
+		});
+	}
+	queueRemovedClassNames(classNames) {
+		for (const className of classNames) if (!this.classCounts.has(className)) this.pendingRemovedClassNames.add(className);
+		this.schedulePendingRemovalFlush();
+	}
+	schedulePendingAdditionFlush() {
+		if (!this.pendingAddedClassNames.size || this.pendingAdditionFrame !== void 0) return;
+		this.pendingAdditionFrame = this.getAnimationFrameWindow().requestAnimationFrame(() => {
+			this.pendingAdditionFrame = void 0;
+			this.flushPendingAddedClassNames();
+		});
+	}
+	queueAddedClassNames(classNames) {
+		for (const className of classNames) if (this.classCounts.has(className)) this.pendingAddedClassNames.add(className);
+		this.schedulePendingAdditionFlush();
+	}
+	estimateRetainedClassRule(className) {
+		const rules = this.classUtilities.get(className);
+		if (!rules?.length) return;
+		let rawBytes = 0;
+		let ruleCount = 0;
+		for (const rule of rules) {
+			const texts = getGeneratedRuleNodeTexts(rule);
+			rawBytes += texts.reduce((length, text) => length + text.length, 0);
+			ruleCount += texts.length;
+		}
+		return {
+			retainedAt: Date.now(),
+			rawBytes,
+			ruleCount
+		};
+	}
+	getRetainedClassRuleRawBytes() {
+		let rawBytes = 0;
+		for (const retainedRule of this.retainedClassRules.values()) rawBytes += retainedRule.rawBytes;
+		return rawBytes;
+	}
+	exceedsRetainedClassRuleHardLimits() {
+		return this.retainedClassNames.size > 512 || this.getRetainedClassRuleRawBytes() > 262144;
+	}
+	scheduleRetainedClassRuleCleanup() {
+		if (!this.retainedClassNames.size || this.retainedCleanupIdleHandle !== void 0 || this.retainedCleanupTimeoutHandle !== void 0) return;
+		const view = this.getCleanupWindow();
+		const timeout = this.exceedsRetainedClassRuleHardLimits() ? 0 : RETAINED_CLASS_RULE_IDLE_TIMEOUT_MS;
+		const cleanup = () => {
+			this.retainedCleanupIdleHandle = void 0;
+			this.retainedCleanupTimeoutHandle = void 0;
+			this.cleanupRetainedClassRules();
+		};
+		if (view.requestIdleCallback) this.retainedCleanupIdleHandle = view.requestIdleCallback(cleanup, { timeout });
+		else this.retainedCleanupTimeoutHandle = view.setTimeout(cleanup, timeout);
+	}
+	retainRemovedClassRules(classNames) {
+		const release = [];
+		for (const className of classNames) {
+			if (this.classCounts.has(className)) continue;
+			if (this.classUtilities.get(className)?.some(({ ir }) => ir.retainAllKeyframes || ir.keyframeNames?.length)) {
+				release.push(className);
+				continue;
+			}
+			const retainedRule = this.retainedClassRules.get(className) || this.estimateRetainedClassRule(className);
+			if (!retainedRule) continue;
+			this.retainedClassNames.add(className);
+			this.retainedClassRules.set(className, retainedRule);
+		}
+		if (release.length) this.deleteClassRules(release);
+		this.scheduleRetainedClassRuleCleanup();
+	}
+	getRetainedClassRuleCleanupCandidates(force = false) {
+		const now = Date.now();
+		const hardLimitExceeded = this.exceedsRetainedClassRuleHardLimits();
+		const entries = [];
+		for (const className of this.retainedClassNames) {
+			if (this.classCounts.has(className)) {
+				this.retainedClassNames.delete(className);
+				this.retainedClassRules.delete(className);
+				continue;
+			}
+			const retainedRule = this.retainedClassRules.get(className);
+			if (!retainedRule) continue;
+			const oldEnough = now - retainedRule.retainedAt >= RETAINED_CLASS_RULE_MIN_AGE_MS;
+			if (force || hardLimitExceeded || oldEnough && this.retainedClassNames.size > 128) entries.push([className, retainedRule]);
+		}
+		entries.sort(([, left], [, right]) => left.retainedAt - right.retainedAt);
+		const cleanupCount = hardLimitExceeded ? Math.max(64, this.retainedClassNames.size - 128) : 64;
+		return entries.slice(0, force ? entries.length : cleanupCount).map(([className]) => className);
+	}
+	removeRetainedClassRules(classNames) {
+		const removedClassNames = [];
+		for (const className of classNames) {
+			if (!this.retainedClassNames.has(className)) continue;
+			this.retainedClassNames.delete(className);
+			this.retainedClassRules.delete(className);
+			if (!this.classCounts.has(className)) removedClassNames.push(className);
+		}
+		if (removedClassNames.length) this.deleteClassRules(removedClassNames);
+		return removedClassNames.length;
+	}
+	cleanupRetainedClassRules(force = false) {
+		const removedCount = this.removeRetainedClassRules(this.getRetainedClassRuleCleanupCandidates(force));
+		if (this.retainedClassNames.size && (force || this.retainedClassNames.size > 128 || this.exceedsRetainedClassRuleHardLimits())) this.scheduleRetainedClassRuleCleanup();
+		return removedCount;
+	}
+	flushPendingRemovedClassNames() {
+		const classNames = [...this.pendingRemovedClassNames].filter((className) => !this.classCounts.has(className));
+		this.pendingRemovedClassNames.clear();
+		if (classNames.length) this.retainRemovedClassRules(classNames);
+	}
+	flushPendingAddedClassNames() {
+		const classNames = [...this.pendingAddedClassNames].filter((className) => this.classCounts.has(className));
+		this.pendingAddedClassNames.clear();
+		if (classNames.length) this.ensureClassRules(classNames);
+	}
+	handleMutationRecords(records) {
+		const deltaCounts = this.classTracker.collectMutations(records, this.root);
+		if (this.engineState !== "ready") {
+			if (applyDeferredMutationDelta(deltaCounts, this.classCounts).some((className) => !this.renderedClassNames.has(className))) this.requestEngine();
+			return;
+		}
+		applyRuntimeMutationDelta(records, deltaCounts, {
+			classCounts: this.classCounts,
+			isWarm: (className) => this.classUtilities.has(className) || this.retainedClassNames.has(className),
+			ensure: (classNames) => this.ensureClassRules(classNames),
+			queueAdded: (classNames) => this.queueAddedClassNames(classNames),
+			queueRemoved: (classNames) => this.queueRemovedClassNames(classNames),
+			cancelAdded: (classNames) => this.cancelPendingAddedClassNames(classNames),
+			debug: () => [
+				this.root,
+				this.host,
+				this.snapshot()
+			]
+		});
+	}
+	ensureClassRules(classNames) {
+		this.cancelPendingAddedClassNames(classNames);
+		this.cancelPendingRemovedClassNames(classNames);
+		const engine = this.requireEngine();
+		this.cancelRetainedClassNames(classNames);
+		const transition = engine.ensureClassRules(classNames);
+		this.applyTransition(transition, classNames);
+		return transition;
+	}
+	deleteClassRules(classNames) {
+		this.cancelPendingAddedClassNames(classNames);
+		this.cancelPendingRemovedClassNames(classNames);
+		const engine = this.requireEngine();
+		this.cancelRetainedClassNames(classNames);
+		const transition = engine.deleteClassRules(classNames);
+		this.applyTransition(transition, classNames);
+		return transition;
+	}
+	startMutationObserver() {
+		this.observer = new MutationObserver((records) => this.handleMutationRecords(records));
+		this.observer.observe(this.root, {
+			childList: true,
+			attributes: true,
+			attributeFilter: ["class"],
+			subtree: true
+		});
+	}
+	observe() {
+		if (this.observing) return this;
+		this.detectRuntimeStyle();
+		const connectedNames = this.collectConnectedClasses();
+		if (this.engineState === "ready") this.adoptConnectedClasses(connectedNames);
+		else if (!this.progressive || [...connectedNames].some((className) => !this.renderedClassNames.has(className))) this.requestEngine();
+		this.startMutationObserver();
+		this.observing = true;
+		debugRuntimeObserved(this);
+		return this;
+	}
+	disconnect() {
+		this.clearPendingAddedClassNames();
+		this.clearPendingRemovedClassNames();
+		this.clearRetainedClassRules();
+		if (!this.observing) return this;
+		this.observer?.disconnect();
+		this.observer = void 0;
+		this.observing = false;
+		const activeClassNames = [...this.classUtilities.keys()];
+		if (activeClassNames.length) this.bindingEngine?.deleteClassRules(activeClassNames);
+		this.classCounts.clear();
+		this.classTracker.reset();
+		this.clearKeyframeRules();
+		this.resetHostRuleState();
+		if (!this.progressive) {
+			this.style?.remove();
+			this.style = null;
+		}
+		debugRuntimeDisconnected(this);
+		return this;
+	}
+	refresh(program, emittedGlobals) {
+		if (this.engineState === "loading") {
+			this.pendingEngineCalls.push(() => this.refresh(program, emittedGlobals));
+			return this;
+		}
+		if (this.engineState !== "ready") {
+			if (program) {
+				this.programSource = program;
+				this.programRequest = void 0;
+			}
+			if (emittedGlobals) this.adoptEmittedGlobals(emittedGlobals);
+			this.retryEngine();
+			this.requestEngine();
+			return this;
+		}
+		const next = program ? programBytes(program) : this.program;
+		const releasedClassNames = [.../* @__PURE__ */ new Set([...this.pendingRemovedClassNames, ...this.retainedClassNames])].filter((className) => !this.classCounts.has(className));
+		if (releasedClassNames.length) this.deleteClassRules(releasedClassNames);
+		const transition = this.engine.refresh(next, emittedGlobals);
+		if (emittedGlobals) this.adoptEmittedGlobals(emittedGlobals);
+		this.clearPendingAddedClassNames();
+		this.clearPendingRemovedClassNames();
+		this.clearRetainedClassRules();
+		this.program = next;
+		this.keyframeDefinitions = this.engine.keyframeDefinitions();
+		this.clearClassReferences();
+		this.applyTransition(transition);
+		this.reconcileKeyframeRules();
+		this.ensureClassRules([...this.classCounts.keys()]);
+		debugRuntimeRefreshed(this, next);
+		return this;
+	}
+	/** Rules come from the engine; until it starts, classes report usage only. */
+	getClassRuleSnapshots() {
+		const ruleSnapshots = /* @__PURE__ */ new Map();
+		for (const [className, rules] of this.classUtilities) ruleSnapshots.set(className, rules.map((rule) => Object.freeze({
+			key: rule.key,
+			layer: rule.layer.name,
+			text: rule.text
+		})));
+		return ruleSnapshots;
+	}
+	snapshot() {
+		const usageCounts = Object.freeze(Object.fromEntries(this.classCounts));
+		const ruleSnapshots = this.getClassRuleSnapshots();
+		const classNames = /* @__PURE__ */ new Set([
+			...ruleSnapshots.keys(),
+			...this.classCounts.keys(),
+			...this.retainedClassNames
+		]);
+		const classRules = Object.create(null);
+		for (const className of [...classNames].sort()) classRules[className] = Object.freeze({
+			usageCount: this.classCounts.get(className) || 0,
+			retained: this.retainedClassNames.has(className),
+			rules: Object.freeze(ruleSnapshots.get(className) || [])
+		});
+		const layers = [...LAYER_ORDER.map((name) => {
+			const layer = this.getLayerByName(name);
+			return Object.freeze({
+				name,
+				cssText: layer.text,
+				ruleCount: layer.rules.length
+			});
+		})];
+		return Object.freeze({
+			binding: this.binding,
+			engine: this.engineState,
+			cssText: this.engineState === "ready" ? this.engine.snapshot().text : this.style?.textContent || "",
+			observing: this.observing,
+			classRules: Object.freeze(classRules),
+			usageCounts,
+			layers: Object.freeze(layers),
+			hydration: Object.freeze({
+				state: this.progressive ? "progressive" : this.style ? "runtime" : "none",
+				manifestLoaded: this.hydrationManifest !== void 0,
+				...this.hydrationFailureReason ? { failureReason: this.hydrationFailureReason } : {}
+			})
+		});
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disconnect();
+		this.bindingEngine?.dispose();
+		this.unregister();
+		this.disposed = true;
+		debugRuntimeDestroyed(this);
+	}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+};
+registerGlobal(MasterCSSRuntime);
+// src/css-runtime.ts
+function resolveProgram(host, program) {
+	return typeof program === "function" ? async () => await program(host) : program;
+}
+function resolveRoot(host, root) {
+	return typeof root === "function" ? root(host) : root || host.shadowRoot;
+}
+function resolveEmittedGlobals(host, emittedGlobals) {
+	return typeof emittedGlobals === "function" ? emittedGlobals(host) : emittedGlobals;
+}
+function resolveHydrationManifest(host, hydrationManifest) {
+	return typeof hydrationManifest === "function" ? hydrationManifest(host) : hydrationManifest;
+}
+function withMasterCSSRuntime(options) {
+	return function(target) {
+		const connectedCallback = target.prototype.connectedCallback;
+		const disconnectedCallback = target.prototype.disconnectedCallback;
+		return class extends target {
+			masterCSSRuntime;
+			connectedCallback() {
+				connectedCallback?.call(this);
+				const root = resolveRoot(this, options.root);
+				if (!root) throw new Error("withMasterCSSRuntime() requires a shadow root. Provide options.root or create a shadow root before connectedCallback() finishes.");
+				MasterCSSRuntime.start({
+					program: resolveProgram(this, options.program),
+					root,
+					emittedGlobals: resolveEmittedGlobals(this, options.emittedGlobals),
+					hydrationManifest: resolveHydrationManifest(this, options.hydrationManifest),
+					onDiagnostic: (diagnostic) => console.error(diagnostic)
+				}).then((runtime) => {
+					if (!this.isConnected) {
+						runtime.dispose();
+						return;
+					}
+					this.masterCSSRuntime = runtime;
+					runtime.observe();
+				}).catch(() => {});
+			}
+			disconnectedCallback() {
+				disconnectedCallback?.call(this);
+				this.masterCSSRuntime?.dispose();
+				this.masterCSSRuntime = void 0;
+			}
+		};
+	};
+}
+export { MasterCSSRuntime, withMasterCSSRuntime };