praxis-kit 0.1.0

package/dist/web/index.js

@@ -0,0 +1,4868 @@
+import { clsx } from "clsx";
+import { DiagnosticCategory, DiagnosticCode, resolveDiagnostics, silentDiagnostics, throwDiagnostics, throwDiagnostics as throwDiagnostics$1, warnDiagnostics } from "../_shared/diagnostics.js";
+import { cva } from "class-variance-authority";
+//#region ../../lib/adapter-utils/src/invariant.ts
+function panic(message) {
+	throw new Error(message);
+}
+function invariant(condition, message) {
+	if (!condition) panic(message);
+}
+//#endregion
+//#region ../../lib/adapter-utils/src/runtime/define-component.ts
+function defineContractComponent(options) {
+	return (factory) => factory(options);
+}
+//#endregion
+//#region ../../lib/adapter-utils/src/runtime/assemble-compound-component.ts
+/**
+* Assembles a compound component by attaching sub-components to a
+* generated root component, producing APIs such as `Card.Header`,
+* `Card.Content`, and `Card.Footer`.
+*
+* Mutates and returns `root` in place, following the convention used by
+* other component post-processing helpers.
+*/
+function assembleCompoundComponent(root, subComponents) {
+	if (!subComponents) return root;
+	return Object.assign(root, subComponents);
+}
+//#endregion
+//#region ../../lib/primitive/src/tag/resolve-tag.ts
+function makeResolveTag(defaultTag) {
+	return function tag(as) {
+		return as ?? defaultTag;
+	};
+}
+//#endregion
+//#region ../../lib/primitive/src/rule/rule-brand.ts
+const RULE_BRAND = Symbol("praxis-kit/dynamic-rule");
+//#endregion
+//#region ../../lib/primitive/src/rule/dynamic.ts
+function dynamic(resolve) {
+	return {
+		[RULE_BRAND]: true,
+		resolve
+	};
+}
+//#endregion
+//#region ../../lib/foundation/src/iterate.ts
+function find(iterable, callback) {
+	for (const value of iterable) {
+		const result = callback(value);
+		if (result != null) return result;
+	}
+	return null;
+}
+function some(iterable, predicate) {
+	for (const value of iterable) if (predicate(value)) return true;
+	return false;
+}
+function every(iterable, predicate) {
+	let index = 0;
+	for (const value of iterable) if (!predicate(value, index++)) return false;
+	return true;
+}
+function* filter(iterable, predicate) {
+	let index = 0;
+	for (const value of iterable) if (predicate(value, index++)) yield value;
+}
+function* map(iterable, callback) {
+	let index = 0;
+	for (const value of iterable) yield callback(value, index++);
+}
+function forEach(iterable, callback) {
+	let index = 0;
+	for (const value of iterable) callback(value, index++);
+}
+function reduce(iterable, initial, callback) {
+	let accumulator = initial;
+	let index = 0;
+	for (const value of iterable) accumulator = callback(accumulator, value, index++);
+	return accumulator;
+}
+/**
+* Transforms an iterable into a Record.
+*
+* The callback returns a `[key, value]` tuple for each element. Returning
+* `null` aborts the collection and causes `collect()` to return `null`.
+*/
+function collect(iterable, callback) {
+	const result = {};
+	let index = 0;
+	for (const value of iterable) {
+		const entry = callback(value, index++);
+		if (entry === null) return null;
+		result[entry[0]] = entry[1];
+	}
+	return result;
+}
+function findLast(value, callback) {
+	for (let index = value.length - 1; index >= 0; index--) {
+		const result = callback(value[index], index);
+		if (result != null) return result;
+	}
+	return null;
+}
+function* items(collection) {
+	for (let i = 0; i < collection.length; i++) {
+		const item = collection.item(i);
+		if (item !== null) yield item;
+	}
+}
+function nodeList(list) {
+	return { *[Symbol.iterator]() {
+		for (let i = 0; i < list.length; i++) {
+			const node = list.item(i);
+			if (node !== null) yield node;
+		}
+	} };
+}
+function mapEntries(m) {
+	return m.entries();
+}
+function set(s) {
+	return s.values();
+}
+function hasOwn(object, key) {
+	return Object.hasOwn(object, key);
+}
+function* entries(object) {
+	for (const key in object) {
+		if (!hasOwn(object, key)) continue;
+		yield [key, object[key]];
+	}
+}
+function* keys(object) {
+	for (const [key] of entries(object)) yield key;
+}
+function* values(object) {
+	for (const [, value] of entries(object)) yield value;
+}
+function mapValues(object, callback) {
+	const result = {};
+	for (const [key, value] of entries(object)) result[key] = callback(value, key);
+	return result;
+}
+function forEachEntry(object, callback) {
+	for (const [key, value] of entries(object)) callback(key, value);
+}
+function forEachKey(object, callback) {
+	for (const key of keys(object)) callback(key);
+}
+function forEachValue(object, callback) {
+	for (const value of values(object)) callback(value);
+}
+function forEachSet(s, callback) {
+	for (const value of s) callback(value);
+}
+const iterate = Object.freeze({
+	entries,
+	filter,
+	find,
+	findLast,
+	forEach,
+	forEachEntry,
+	forEachKey,
+	forEachSet,
+	forEachValue,
+	items,
+	keys,
+	map,
+	mapEntries,
+	mapValues,
+	nodeList,
+	reduce,
+	collect,
+	set,
+	some,
+	every,
+	values
+});
+//#endregion
+//#region ../../lib/foundation/src/assert-never.ts
+function assertNever(value) {
+	throw new Error(`Unexpected value: ${String(value)}`);
+}
+//#endregion
+//#region ../../lib/foundation/src/cn.ts
+function cn(...inputs) {
+	return clsx(...inputs);
+}
+//#endregion
+//#region ../../lib/foundation/src/lru-cache.ts
+/**
+* A bounded cache that evicts the least recently used entry once `maxSize` is
+* exceeded. Backed by a single `Map`, relying on its insertion-order iteration:
+* `get()` promotes a hit to most-recently-used by deleting and re-inserting the
+* key (moving it to the tail), and `set()` evicts the head (oldest) key when
+* over capacity.
+*
+* Consolidates a pattern that was hand-rolled independently in three places
+* (`StaticClassResolver`, `VariantClassResolver`, `AriaPolicyEngine#planCache`)
+* before this existed.
+*/
+var LRUCache = class {
+	#maxSize;
+	#store = /* @__PURE__ */ new Map();
+	constructor(maxSize) {
+		if (!Number.isInteger(maxSize) || maxSize < 1) throw new RangeError("LRUCache maxSize must be a positive integer.");
+		this.#maxSize = maxSize;
+	}
+	get(key) {
+		if (!this.#store.has(key)) return void 0;
+		const value = this.#store.get(key);
+		this.#store.delete(key);
+		this.#store.set(key, value);
+		return value;
+	}
+	set(key, value) {
+		this.#store.delete(key);
+		this.#store.set(key, value);
+		if (this.#store.size > this.#maxSize) {
+			const lru = this.#store.keys().next().value;
+			if (lru !== void 0) this.#store.delete(lru);
+		}
+	}
+	has(key) {
+		return this.#store.has(key);
+	}
+	delete(key) {
+		return this.#store.delete(key);
+	}
+	get size() {
+		return this.#store.size;
+	}
+	clear() {
+		this.#store.clear();
+	}
+};
+//#endregion
+//#region ../../lib/foundation/src/type-guards.ts
+function isString(value) {
+	return typeof value === "string";
+}
+function isNumber(value) {
+	return typeof value === "number";
+}
+function isFunction(value) {
+	return typeof value === "function";
+}
+function isObject(value, excludeArrays = false) {
+	if (value === null || typeof value !== "object") return false;
+	return excludeArrays ? !Array.isArray(value) : true;
+}
+function isDefined(value) {
+	return value !== void 0;
+}
+function isUndefined(value) {
+	return value === void 0;
+}
+function isNull(value) {
+	return value === null;
+}
+function isNonNull(value) {
+	return value != null;
+}
+function isNullish(value) {
+	return isNull(value) || isUndefined(value);
+}
+//#endregion
+//#region ../../lib/primitive/src/rule/is-dynamic-rule.ts
+function isDynamicRule(rule) {
+	return isObject(rule, true) && Reflect.get(rule, RULE_BRAND) === true;
+}
+//#endregion
+//#region ../../lib/primitive/src/rule/resolve-rule.ts
+function resolveRule(rule, context) {
+	return isDynamicRule(rule) ? rule.resolve(context) : rule;
+}
+//#endregion
+//#region ../../lib/primitive/src/utils/merge-props.ts
+function mergeProps(defaultProps, props) {
+	return {
+		...defaultProps ?? {},
+		...props
+	};
+}
+//#endregion
+//#region ../../lib/primitive/src/constants/aria/global-aria-attributes.ts
+const GLOBAL_ARIA_ATTRIBUTES = /* @__PURE__ */ new Set([
+	"aria-atomic",
+	"aria-busy",
+	"aria-controls",
+	"aria-current",
+	"aria-describedby",
+	"aria-description",
+	"aria-details",
+	"aria-disabled",
+	"aria-errormessage",
+	"aria-flowto",
+	"aria-hidden",
+	"aria-keyshortcuts",
+	"aria-label",
+	"aria-labelledby",
+	"aria-live",
+	"aria-owns",
+	"aria-relevant",
+	"aria-roledescription"
+]);
+//#endregion
+//#region ../../lib/primitive/src/constants/aria/implicit-role-record.ts
+/**
+* A **deliberately partial** static tag→role model — not "the ARIA validator".
+*
+* HTML implicit roles fall into four kinds; this file only covers the first:
+*
+* 1. **static** — role depends on the tag alone (`nav → navigation`,
+*    `article → article`). Only these belong in `IMPLICIT_ROLE_RECORD`.
+* 2. **attribute-dependent** — role depends on an attribute value
+*    (`a`/`area` is `link` *with* `href`, `generic` without — see
+*    `getAnchorImplicitRole`; `input` per `type`, see `INPUT_TYPE_ROLE_MAP` +
+*    `getInputImplicitRole`; `img` per `alt`; `select` is `combobox` or
+*    `listbox` per `multiple`/`size`, see `getSelectImplicitRole`).
+* 3. **context-dependent** — role depends on ancestry
+*    (`section`/`form` become landmarks only when they have an accessible name;
+*    `header`/`footer` are `banner`/`contentinfo` only at the top level — see
+*    `getConditionalImplicitRole`).
+* 4. **state-/naming-dependent** — role depends on runtime state or naming.
+*
+* Entries here that are *actually* attribute-dependent (`td`, `th`) are the "no
+* attributes / defaults" case; callers that know the attributes must prefer the
+* conditional helpers. Do not add an entry whose real role needs more than the
+* tag — `a`/`area` and `select` are deliberately absent for that reason (a bare
+* `<a>` is `generic`, not `link`; a bare `<select>` is `combobox`, not
+* `listbox`, per ARIA-in-HTML).
+*/
+const IMPLICIT_ROLE_RECORD = Object.freeze({
+	article: "article",
+	aside: "complementary",
+	footer: "contentinfo",
+	header: "banner",
+	main: "main",
+	nav: "navigation",
+	button: "button",
+	textarea: "textbox",
+	h1: "heading",
+	h2: "heading",
+	h3: "heading",
+	h4: "heading",
+	h5: "heading",
+	h6: "heading",
+	ul: "list",
+	ol: "list",
+	li: "listitem",
+	table: "table",
+	tr: "row",
+	td: "cell",
+	th: "columnheader",
+	dialog: "dialog",
+	fieldset: "group",
+	figure: "figure",
+	meter: "meter",
+	output: "status",
+	progress: "progressbar"
+});
+const INPUT_TYPE_ROLE_MAP = Object.freeze({
+	checkbox: "checkbox",
+	radio: "radio",
+	range: "slider",
+	number: "spinbutton",
+	search: "searchbox",
+	text: "textbox",
+	email: "textbox",
+	tel: "textbox",
+	url: "textbox",
+	button: "button",
+	submit: "button",
+	reset: "button",
+	image: "button"
+});
+/**
+* Roles whose implicit assignment this library treats as **not overridable** by
+* an explicit `role` attribute (a warning, not a hard block).
+*
+* DELIBERATE POLICY, wider than ARIA-in-HTML (audited 2026-09, see
+* docs/accessibility/html-aria-audit.md D1). ARIA-in-HTML *permits* specific role overrides
+* on landmark elements (e.g. `<nav role="tablist">`); Praxis flags them anyway
+* via `landmarkRoleRule`, because overriding a landmark's role silently drops it
+* from the screen-reader landmark menu, and the APG's own menu/tab/tree patterns
+* never put those roles on a landmark element. The allowed-role tables in
+* `role-restrictions.ts` remain spec-accurate; this set only drives the softer
+* landmark-override advisory. `<header>`/`<footer>` are `banner`/`contentinfo`
+* only at the top level (see `getConditionalImplicitRole`).
+*/
+const STRONG_ROLES = Object.freeze([
+	"main",
+	"navigation",
+	"complementary",
+	"contentinfo",
+	"banner"
+]);
+const STANDALONE_ROLES = Object.freeze(["article"]);
+const STRONG_ROLES_SET = new Set(STRONG_ROLES);
+const STANDALONE_ROLES_SET = new Set(STANDALONE_ROLES);
+//#endregion
+//#region ../../lib/primitive/src/constants/aria/role-restricted-attributes.ts
+const ROLE_RESTRICTED_ATTRIBUTES = /* @__PURE__ */ new Map([
+	["aria-activedescendant", /* @__PURE__ */ new Set([
+		"application",
+		"combobox",
+		"grid",
+		"group",
+		"listbox",
+		"menu",
+		"menubar",
+		"radiogroup",
+		"row",
+		"searchbox",
+		"spinbutton",
+		"tablist",
+		"textbox",
+		"toolbar",
+		"tree",
+		"treegrid"
+	])],
+	["aria-autocomplete", /* @__PURE__ */ new Set([
+		"combobox",
+		"searchbox",
+		"textbox"
+	])],
+	["aria-checked", /* @__PURE__ */ new Set([
+		"checkbox",
+		"menuitemcheckbox",
+		"menuitemradio",
+		"option",
+		"radio",
+		"switch",
+		"treeitem"
+	])],
+	["aria-colcount", /* @__PURE__ */ new Set([
+		"grid",
+		"table",
+		"treegrid"
+	])],
+	["aria-colindex", /* @__PURE__ */ new Set([
+		"cell",
+		"columnheader",
+		"gridcell",
+		"row",
+		"rowheader"
+	])],
+	["aria-colspan", /* @__PURE__ */ new Set([
+		"cell",
+		"columnheader",
+		"gridcell",
+		"rowheader"
+	])],
+	["aria-expanded", /* @__PURE__ */ new Set([
+		"application",
+		"button",
+		"checkbox",
+		"columnheader",
+		"combobox",
+		"gridcell",
+		"link",
+		"listbox",
+		"menuitem",
+		"menuitemcheckbox",
+		"menuitemradio",
+		"row",
+		"rowheader",
+		"switch",
+		"tab",
+		"treeitem"
+	])],
+	["aria-haspopup", /* @__PURE__ */ new Set([
+		"application",
+		"button",
+		"columnheader",
+		"combobox",
+		"gridcell",
+		"link",
+		"menuitem",
+		"menuitemcheckbox",
+		"menuitemradio",
+		"rowheader",
+		"searchbox",
+		"slider",
+		"tab",
+		"textbox",
+		"treeitem"
+	])],
+	["aria-invalid", /* @__PURE__ */ new Set([
+		"application",
+		"checkbox",
+		"columnheader",
+		"combobox",
+		"gridcell",
+		"listbox",
+		"menuitemcheckbox",
+		"menuitemradio",
+		"radiogroup",
+		"rowheader",
+		"searchbox",
+		"slider",
+		"spinbutton",
+		"switch",
+		"textbox",
+		"tree",
+		"treegrid"
+	])],
+	["aria-level", /* @__PURE__ */ new Set([
+		"heading",
+		"listitem",
+		"row",
+		"tablist",
+		"treeitem"
+	])],
+	["aria-modal", /* @__PURE__ */ new Set(["alertdialog", "dialog"])],
+	["aria-multiline", /* @__PURE__ */ new Set(["searchbox", "textbox"])],
+	["aria-multiselectable", /* @__PURE__ */ new Set([
+		"grid",
+		"listbox",
+		"tablist",
+		"tree",
+		"treegrid"
+	])],
+	["aria-orientation", /* @__PURE__ */ new Set([
+		"listbox",
+		"menu",
+		"menubar",
+		"radiogroup",
+		"scrollbar",
+		"separator",
+		"slider",
+		"tablist",
+		"toolbar",
+		"tree",
+		"treegrid"
+	])],
+	["aria-placeholder", /* @__PURE__ */ new Set(["searchbox", "textbox"])],
+	["aria-posinset", /* @__PURE__ */ new Set([
+		"article",
+		"listitem",
+		"menuitem",
+		"menuitemcheckbox",
+		"menuitemradio",
+		"option",
+		"radio",
+		"row",
+		"tab",
+		"treeitem"
+	])],
+	["aria-pressed", /* @__PURE__ */ new Set(["button"])],
+	["aria-readonly", /* @__PURE__ */ new Set([
+		"checkbox",
+		"columnheader",
+		"combobox",
+		"grid",
+		"gridcell",
+		"listbox",
+		"menuitemcheckbox",
+		"menuitemradio",
+		"radiogroup",
+		"rowheader",
+		"searchbox",
+		"slider",
+		"spinbutton",
+		"switch",
+		"textbox",
+		"treegrid"
+	])],
+	["aria-required", /* @__PURE__ */ new Set([
+		"checkbox",
+		"columnheader",
+		"combobox",
+		"gridcell",
+		"listbox",
+		"menuitemcheckbox",
+		"menuitemradio",
+		"radiogroup",
+		"rowheader",
+		"searchbox",
+		"spinbutton",
+		"switch",
+		"textbox",
+		"tree",
+		"treegrid"
+	])],
+	["aria-rowcount", /* @__PURE__ */ new Set([
+		"grid",
+		"table",
+		"treegrid"
+	])],
+	["aria-rowindex", /* @__PURE__ */ new Set([
+		"cell",
+		"columnheader",
+		"gridcell",
+		"row",
+		"rowheader"
+	])],
+	["aria-rowspan", /* @__PURE__ */ new Set([
+		"cell",
+		"columnheader",
+		"gridcell",
+		"rowheader"
+	])],
+	["aria-selected", /* @__PURE__ */ new Set([
+		"columnheader",
+		"gridcell",
+		"option",
+		"row",
+		"rowheader",
+		"tab",
+		"treeitem"
+	])],
+	["aria-setsize", /* @__PURE__ */ new Set([
+		"article",
+		"listitem",
+		"menuitem",
+		"menuitemcheckbox",
+		"menuitemradio",
+		"option",
+		"radio",
+		"row",
+		"tab",
+		"treeitem"
+	])],
+	["aria-sort", /* @__PURE__ */ new Set(["columnheader", "rowheader"])],
+	["aria-valuemax", /* @__PURE__ */ new Set([
+		"meter",
+		"progressbar",
+		"scrollbar",
+		"separator",
+		"slider",
+		"spinbutton"
+	])],
+	["aria-valuemin", /* @__PURE__ */ new Set([
+		"meter",
+		"progressbar",
+		"scrollbar",
+		"separator",
+		"slider",
+		"spinbutton"
+	])],
+	["aria-valuenow", /* @__PURE__ */ new Set([
+		"meter",
+		"progressbar",
+		"scrollbar",
+		"separator",
+		"slider",
+		"spinbutton"
+	])],
+	["aria-valuetext", /* @__PURE__ */ new Set([
+		"meter",
+		"progressbar",
+		"scrollbar",
+		"separator",
+		"slider",
+		"spinbutton"
+	])]
+]);
+//#endregion
+//#region ../../lib/primitive/src/constants/html/void-tags.ts
+/**
+* HTML void elements.
+*
+* Void elements cannot have child nodes and therefore all share the same
+* empty content model — a WHATWG-stable fact, not a praxis-kit opinion.
+* Single source of truth shared by the contract engine's built-in void-tag
+* children contract (`@praxis-kit/core`'s `VOID_TAGS` re-export) and the
+* Tailwind pipeline's flex/grid-on-void-tag warning, so the two can't drift.
+*/
+const VOID_TAGS = [
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+];
+//#endregion
+//#region ../../lib/primitive/src/guards/aria/is-aria-attribute.ts
+function isGlobalAriaAttribute(attr) {
+	return GLOBAL_ARIA_ATTRIBUTES.has(attr);
+}
+function isAriaAttributeValidForRole(attr, role) {
+	const allowedRoles = ROLE_RESTRICTED_ATTRIBUTES.get(attr);
+	if (isUndefined(allowedRoles)) return true;
+	if (isUndefined(role)) return false;
+	return allowedRoles.has(role);
+}
+//#endregion
+//#region ../../lib/primitive/src/guards/aria/is-aria-role.ts
+function lookupImplicitRole(tag) {
+	return IMPLICIT_ROLE_RECORD[tag];
+}
+/**
+* Returns whether the element has a strong implicit ARIA role.
+*
+* Strong implicit roles cannot be overridden with an explicit `role`
+* attribute unless the HTML specification explicitly permits it.
+*/
+function isStrongImplicitRole(tag) {
+	const role = lookupImplicitRole(tag);
+	return !isNullish(role) && STRONG_ROLES_SET.has(role);
+}
+/**
+* Returns whether the element's implicit ARIA role is considered
+* standalone for accessibility validation purposes.
+*/
+function hasStandaloneRole(tag) {
+	const role = lookupImplicitRole(tag);
+	return !isNullish(role) && STANDALONE_ROLES_SET.has(role);
+}
+/**
+* Input types for which the presence of a `list` attribute changes the implicit
+* ARIA role from `textbox` to `combobox`, per the ARIA-in-HTML specification.
+* `packages/core`'s `inputElementSpec` keeps its own copy of this set (it must
+* not import the guard module) — the two are pinned to the spec by tests on both
+* sides and must stay in sync.
+*/
+const LIST_ELIGIBLE_INPUT_TYPES = /* @__PURE__ */ new Set([
+	"text",
+	"search",
+	"tel",
+	"url",
+	"email"
+]);
+/**
+* Returns the implicit ARIA role for an `<input>` element.
+*
+* An omitted `type` attribute defaults to `text` (HTML), so a bare `<input>`
+* resolves to `textbox` — `<input role="textbox">` is then caught as redundant.
+*
+* For text-like input types associated with a `<datalist>` via the
+* `list` attribute, the implicit role becomes `combobox` instead of
+* `textbox`, per the ARIA-in-HTML specification.
+*
+* Returns `undefined` for input types that do not expose an implicit
+* ARIA role (for example `color`, `date`, or `hidden`).
+*/
+function getInputImplicitRole(type, list) {
+	const resolvedType = isNullish(type) ? "text" : type;
+	if (!isString(resolvedType)) return void 0;
+	const role = INPUT_TYPE_ROLE_MAP[resolvedType];
+	if (!role) return void 0;
+	if (!isNullish(list) && LIST_ELIGIBLE_INPUT_TYPES.has(resolvedType)) return "combobox";
+	return role;
+}
+function isBooleanAttrOn(value) {
+	if (value === false || value === void 0 || value === null) return false;
+	if (typeof value === "string") return value.toLowerCase() !== "false";
+	return true;
+}
+/**
+* Returns the implicit ARIA role for a `<select>` element.
+*
+* Per HTML-AAM / ARIA-in-HTML a `<select>` is a **`combobox`** in its default
+* drop-down form, and a **`listbox`** only when it is a list box — i.e. it has a
+* `multiple` attribute, or a `size` attribute whose value is greater than 1.
+*
+* Kept as a helper (not an `IMPLICIT_ROLE_RECORD` entry) because the role needs
+* more than the tag name — the same reason `<input>` is handled by
+* `getInputImplicitRole`.
+*/
+function getSelectImplicitRole(multiple, size) {
+	if (isBooleanAttrOn(multiple)) return "listbox";
+	const sizeNum = typeof size === "number" ? size : typeof size === "string" ? Number(size) : NaN;
+	if (Number.isFinite(sizeNum) && sizeNum > 1) return "listbox";
+	return "combobox";
+}
+/**
+* Returns the implicit ARIA role for an `<a>` or `<area>` element.
+*
+* Per ARIA-in-HTML, an `<a>`/`<area>` **with an `href`** is a `link`; **without
+* an `href`** it is `generic` (it has no interactive semantics — it is just a
+* styled span). Kept as a helper (not an `IMPLICIT_ROLE_RECORD` entry) because
+* the role needs the `href` attribute, not just the tag: a bare `<a>` is *not* a
+* `link`, so `<a role="button">` on it is not a redundant override.
+*
+* A `href=""` (empty string) still counts — it is a valid same-page link.
+*/
+function getAnchorImplicitRole(href) {
+	return isNullish(href) ? "generic" : "link";
+}
+/**
+* Returns the conditional implicit landmark role for `<section>` and
+* `<form>` elements.
+*
+* Per HTML-AAM, these elements expose their landmark roles only when
+* they have an accessible name provided by `aria-label` or
+* `aria-labelledby`.
+*/
+function getConditionalImplicitRole(tag, ariaLabel, ariaLabelledBy) {
+	if (!(isString(ariaLabel) && ariaLabel.trim().length > 0 || isString(ariaLabelledBy) && ariaLabelledBy.trim().length > 0)) return void 0;
+	if (tag === "section") return "region";
+	if (tag === "form") return "form";
+}
+//#endregion
+//#region ../../lib/primitive/src/guards/children/component-id.ts
+/**
+* Well-known Symbol stamped onto every component created by praxis-kit factories.
+* Stores the factory's defaultTag — the tag that renders when no `as` prop is given.
+* HOC wrappers must propagate it: `Wrapped[COMPONENT_DEFAULT_TAG] = Original[COMPONENT_DEFAULT_TAG]`.
+*/
+const COMPONENT_DEFAULT_TAG = Symbol.for("praxis.component-default-tag");
+//#endregion
+//#region ../../lib/primitive/src/guards/children/is-tag.ts
+function getAsProp(child) {
+	if (!isObject(child) || !("props" in child)) return void 0;
+	const { props } = child;
+	if (!isObject(props)) return void 0;
+	const as = Reflect.get(props, "as");
+	return isString(as) && as !== "" ? as : void 0;
+}
+/**
+* Resolves the effective HTML tag for a vnode:
+*   - native element: returns its type string directly
+*   - praxis-kit component: resolves `as ?? defaultTag`, mirroring render-time logic
+*   - anything else: returns undefined
+*/
+function getTag(child) {
+	if (!isObject(child) || !("type" in child)) return void 0;
+	const { type: t } = child;
+	if (isString(t)) return t;
+	if (typeof t === "function" || isObject(t)) {
+		const defaultTag = Reflect.get(t, COMPONENT_DEFAULT_TAG);
+		if (!isString(defaultTag)) return void 0;
+		return getAsProp(child) ?? defaultTag;
+	}
+}
+function isTag(...args) {
+	if (isString(args[0])) {
+		const set = new Set(args);
+		return (child) => {
+			const tag = getTag(child);
+			return tag !== void 0 && set.has(tag);
+		};
+	}
+	const [child, ...tags] = args;
+	const set = new Set(tags);
+	const tag = getTag(child);
+	return tag !== void 0 && set.has(tag);
+}
+//#endregion
+//#region ../../lib/adapter-utils/src/runtime/is-factory-options-like.ts
+/**
+* Loosely validates one recognized `FactoryOptions` field's runtime shape.
+* "Loosely" because the field's declared type is itself parameterized by a
+* generic (Props, Variants, TPlugin, ...) that's erased at runtime — these
+* checks confirm the field is the right *kind* of value (object, function,
+* string), not that it satisfies its exact generic instantiation, which no
+* runtime check can ever do.
+*
+* Covers every field `FactoryOptions` itself declares — identical across
+* every adapter, since they all extend the same core type. Adapter-specific
+* additions (React's `slotComponent`/`artifact`, every adapter's own
+* `filterProps`, etc.) are passed in by the caller as extra entries.
+*/
+const FACTORY_OPTIONS_FIELD_VALIDATORS = {
+	tag: (v) => v === void 0 || isString(v),
+	name: (v) => v === void 0 || isString(v),
+	defaults: (v) => v === void 0 || isObject(v),
+	normalize: (v) => v === void 0 || isFunction(v),
+	styling: (v) => v === void 0 || isObject(v),
+	enforcement: (v) => v === void 0 || isObject(v),
+	diagnostics: (v) => v === void 0 || isObject(v),
+	subComponents: (v) => v === void 0 || isObject(v),
+	onElement: (v) => v === void 0 || isFunction(v)
+};
+/**
+* Type guard narrowing the generic `FactoryOptions` shape down to an
+* adapter-specific factory options type `T` — the type each adapter's
+* `buildRuntime` is declared against.
+*
+* Walks every own enumerable property on `options` and checks it against
+* `FACTORY_OPTIONS_FIELD_VALIDATORS` plus `extraFieldValidators` (the
+* adapter's own additions on top of `FactoryOptions`): an unrecognized key,
+* or a recognized key holding a value of the wrong kind, fails the guard.
+* This is a genuine structural check, not a relabeled assertion — though it
+* necessarily stops at each field's runtime *kind*, since the field's actual
+* generic instantiation is erased at runtime and no guard can validate it.
+* That part remains the caller's responsibility, same as with any other
+* generic function in TypeScript.
+*/
+function isFactoryOptionsLike(options, extraFieldValidators) {
+	if (!isObject(options)) return false;
+	const validators = {
+		...FACTORY_OPTIONS_FIELD_VALIDATORS,
+		...extraFieldValidators
+	};
+	for (const [key, value] of Object.entries(options)) {
+		const validate = validators[key];
+		if (!validate || !validate(value)) return false;
+	}
+	return true;
+}
+//#endregion
+//#region ../../lib/contract/src/aria/aria-role-policy.ts
+function getImplicitRole(tag, props) {
+	if (tag in IMPLICIT_ROLE_RECORD) return IMPLICIT_ROLE_RECORD[tag];
+	if (tag === "a" || tag === "area") return getAnchorImplicitRole(props?.href);
+	if (tag === "input") return getInputImplicitRole(props?.type, props?.list);
+	if (tag === "select") return getSelectImplicitRole(props?.multiple, props?.size);
+	if (tag === "img") return props?.alt === "" ? "none" : "img";
+	if (tag === "section" || tag === "form") return getConditionalImplicitRole(tag, props?.["aria-label"], props?.["aria-labelledby"]);
+}
+//#endregion
+//#region ../../lib/contract/src/diagnostics/anchor-accessibility.ts
+function createDiagnostic(input) {
+	return {
+		category: DiagnosticCategory.Accessibility,
+		...input
+	};
+}
+const AnchorAccessibilityDiagnostics = {
+	roleButtonWithHref() {
+		return createDiagnostic({
+			code: DiagnosticCode.A11yAnchorRoleButtonWithHref,
+			severity: "warning",
+			message: "role=\"button\" on an <a> with an href overrides its navigation semantics for assistive technology; use a real <button> element, or remove href, if this element should not navigate.",
+			rationale: "Assistive technology announces role=\"button\" as a button, not a link — but the element still follows the link when activated by mouse or keyboard, which is confusing and inconsistent with how a button is expected to behave.",
+			suggestions: [{
+				title: "Use a real <button>",
+				description: "If this element should not navigate, render a <button> instead of an <a>."
+			}, {
+				title: "Remove role=\"button\"",
+				description: "If this element should navigate, keep the default link role."
+			}]
+		});
+	},
+	ariaDisabledInert() {
+		return createDiagnostic({
+			code: DiagnosticCode.A11yAnchorAriaDisabledInert,
+			severity: "warning",
+			message: "aria-disabled does not prevent an <a> from being focused, clicked, or navigated via keyboard; remove href, or prevent navigation yourself, if this link should be inert.",
+			rationale: "Unlike a native form control, an <a> has no disabled state the browser enforces — aria-disabled only changes what assistive technology announces, not what actually happens when the link is activated by mouse or keyboard.",
+			suggestions: [{
+				title: "Remove href",
+				description: "If this element is temporarily unavailable, remove href until it can be activated."
+			}, {
+				title: "Prevent navigation when disabled",
+				description: "Prevent the click and keyboard activation when the link is disabled so it behaves consistently for all users."
+			}]
+		});
+	}
+};
+//#endregion
+//#region ../../lib/contract/src/diagnostics/aria.ts
+const AriaDiagnostics = {
+	/** Generic bridge for violations produced by external AriaRule functions. */
+	fromViolation(v) {
+		return {
+			code: DiagnosticCode.AriaViolation,
+			category: DiagnosticCategory.ARIA,
+			message: v.message
+		};
+	},
+	attributeInvalid(key, role) {
+		return {
+			code: DiagnosticCode.AriaAttributeInvalid,
+			category: DiagnosticCategory.ARIA,
+			message: `"${key}" is not valid on role="${role}". It will be removed.`,
+			rationale: "Invalid ARIA attributes are ignored by assistive technology and may trigger accessibility-tree warnings in browser devtools.",
+			suggestions: [{
+				title: "Remove the attribute",
+				description: `"${key}" is not in the allowed attribute set for role="${role}".`
+			}]
+		};
+	},
+	missingLiveRegion(role, impliedLive) {
+		return {
+			code: DiagnosticCode.AriaMissingLiveRegion,
+			category: DiagnosticCategory.ARIA,
+			message: `role="${role}" implies aria-live="${impliedLive}" but it is missing. It has been injected.`,
+			rationale: "Live-region roles announce dynamic content changes to screen readers. Without aria-live the politeness level is unspecified and announcements may be silent.",
+			suggestions: [{
+				title: `Add aria-live="${impliedLive}"`,
+				description: `role="${role}" conventionally implies aria-live="${impliedLive}".`,
+				fix: `aria-live="${impliedLive}"`
+			}]
+		};
+	},
+	missingAtomic(role) {
+		return {
+			code: DiagnosticCode.AriaMissingAtomic,
+			category: DiagnosticCategory.ARIA,
+			message: `role="${role}" is a live region. Consider setting aria-atomic="true" if the full region should be announced as a unit, or aria-atomic="false" if only changed nodes should be read.`,
+			rationale: "aria-atomic controls whether assistive technology announces the entire live region or only the changed nodes. Omitting it leaves the behaviour browser-defined."
+		};
+	},
+	relevantInvalidTokens(invalid) {
+		const quoted = invalid.map((t) => `"${t}"`).join(", ");
+		return {
+			code: DiagnosticCode.AriaRelevantInvalidToken,
+			category: DiagnosticCategory.ARIA,
+			message: `aria-relevant contains invalid token(s): ${quoted}. Valid tokens are: additions, removals, text, all.`,
+			rationale: "aria-relevant accepts a space-separated list of change types. Unrecognised tokens are silently ignored by assistive technology, making the attribute ineffective.",
+			suggestions: [{
+				title: "Use only valid tokens",
+				description: "Valid values are: additions, removals, text, all (or a space-separated combination)."
+			}]
+		};
+	},
+	relevantSuperseded() {
+		return {
+			code: DiagnosticCode.AriaRelevantSuperseded,
+			category: DiagnosticCategory.ARIA,
+			message: "aria-relevant includes \"all\" alongside other tokens. \"all\" supersedes additions, removals, and text — use aria-relevant=\"all\" alone.",
+			rationale: "\"all\" is equivalent to \"additions removals text\". Combining it with other tokens is redundant and may confuse readers of the markup.",
+			suggestions: [{
+				title: "Use aria-relevant=\"all\"",
+				fix: "aria-relevant=\"all\""
+			}]
+		};
+	},
+	missingAccessibleName(tag) {
+		return {
+			code: DiagnosticCode.AriaMissingAccessibleName,
+			category: DiagnosticCategory.ARIA,
+			message: `<${tag}> has no accessible name. Add aria-label or aria-labelledby.`,
+			rationale: "Elements with a landmark or interactive role must have an accessible name so that assistive technology can identify them when presenting the page outline.",
+			suggestions: [{
+				title: "Add aria-label",
+				description: `Add aria-label="…" directly to the <${tag}> element.`
+			}, {
+				title: "Add aria-labelledby",
+				description: "Point aria-labelledby at the id of an existing heading or label element."
+			}]
+		};
+	},
+	nameProhibited(attr, role) {
+		return {
+			code: DiagnosticCode.AriaNameProhibited,
+			category: DiagnosticCategory.ARIA,
+			message: `"${attr}" is prohibited on role="${role}" — this role does not support a name from the author. It will be removed.`,
+			rationale: "WAI-ARIA 1.2 lists a set of roles (generic, presentation/none, and the inline text-level roles) as Name Prohibited: aria-label / aria-labelledby on them are a conformance error and are ignored by assistive technology.",
+			suggestions: [{
+				title: "Remove the attribute",
+				description: `role="${role}" cannot be named. If the element needs an accessible name, give it a role that supports one (or use visible text / a wrapping labelled element).`
+			}]
+		};
+	},
+	attributeOnPresentational(attr, tag) {
+		return {
+			code: DiagnosticCode.AriaAttributeOnPresentational,
+			category: DiagnosticCategory.ARIA,
+			message: `"${attr}" is not allowed on a presentational <${tag}>. Presentational elements are invisible to assistive technology.`,
+			rationale: "role=\"none\" and role=\"presentation\" (including <img alt=\"\">) remove an element from the accessibility tree. ARIA attributes on such elements are ignored by assistive technology.",
+			suggestions: [{
+				title: "Remove the attribute",
+				description: `"${attr}" has no effect when the element has role="none" or role="presentation".`
+			}]
+		};
+	},
+	ariaHiddenOnFocusable(tag) {
+		return {
+			code: DiagnosticCode.AriaHiddenOnFocusable,
+			category: DiagnosticCategory.ARIA,
+			message: `aria-hidden="true" must not be used on focusable <${tag}> elements. Screen reader users who navigate by keyboard will encounter the element but receive no information about it.`,
+			rationale: "aria-hidden removes an element from the accessibility tree while leaving it keyboard-reachable. This creates a \"ghost\" — a focusable element assistive technology cannot describe.",
+			suggestions: [{
+				title: "Remove aria-hidden",
+				description: "If the element should be hidden from all users, use the HTML hidden attribute or CSS display:none instead."
+			}, {
+				title: "Make the element non-focusable",
+				description: "If the element is intentionally decorative, add tabindex=\"-1\" and disable it so it is not reachable by keyboard."
+			}]
+		};
+	},
+	invalidAttributeValue(attr, value, expected) {
+		const got = value === null ? "null" : value === void 0 ? "undefined" : typeof value === "string" ? `"${value}"` : String(value);
+		return {
+			code: DiagnosticCode.AriaInvalidAttributeValue,
+			category: DiagnosticCategory.ARIA,
+			message: `"${attr}" has an invalid value (${got}). Expected: ${expected}.`,
+			rationale: "ARIA attributes with invalid values are silently ignored by assistive technology, making the markup semantically inert.",
+			suggestions: [{
+				title: `Use a valid value for ${attr}`,
+				description: `Valid values are: ${expected}.`
+			}]
+		};
+	},
+	redundantAriaLevel(tag, level) {
+		return {
+			code: DiagnosticCode.AriaRedundantLevelAttribute,
+			category: DiagnosticCategory.ARIA,
+			message: `aria-level="${level}" is redundant on <${tag}>: the element already has an implicit heading level of ${level}. Remove the attribute.`,
+			rationale: "Restating the implicit aria-level adds noise without semantic value. Use aria-level only to override the native heading level (e.g. aria-level=\"3\" on <h2>).",
+			suggestions: [{
+				title: "Remove aria-level",
+				description: `<${tag}> already implies aria-level="${level}".`
+			}]
+		};
+	},
+	requiredProperty(attr, role) {
+		return {
+			code: DiagnosticCode.AriaRequiredProperty,
+			category: DiagnosticCategory.ARIA,
+			message: `"${attr}" is required for role="${role}" but is missing.`,
+			rationale: `WAI-ARIA 1.2 specifies required states and properties for certain roles. Without "${attr}", assistive technology cannot correctly communicate the element's state to users.`,
+			suggestions: [{
+				title: `Add ${attr}`,
+				description: `role="${role}" requires "${attr}" to be present.`
+			}]
+		};
+	},
+	invalidRole(role, tag) {
+		return {
+			code: DiagnosticCode.AriaInvalidRole,
+			category: DiagnosticCategory.ARIA,
+			message: `Invalid role "${role ?? ""}" on <${tag}>.`,
+			rationale: "An unrecognised or misapplied ARIA role is ignored by assistive technology and may degrade the accessibility of the element."
+		};
+	}
+};
+//#endregion
+//#region ../../lib/contract/src/diagnostics/contract.ts
+const ContractDiagnostics = {
+	unexpectedChild(typeName, index, context) {
+		return {
+			code: DiagnosticCode.UnexpectedChild,
+			category: DiagnosticCategory.Contract,
+			component: context,
+			message: `${context}: unexpected child "${typeName}" at index ${index}.`
+		};
+	},
+	ambiguousChild(typeName, index, ruleNames, context) {
+		const quoted = ruleNames.map((n) => `"${n}"`).join(" and ");
+		return {
+			code: DiagnosticCode.AmbiguousChild,
+			category: DiagnosticCategory.Contract,
+			component: context,
+			message: `${context}: child "${typeName}" at index ${index} matches multiple child rules: ${quoted}.`
+		};
+	},
+	cardinalityMin(ruleName, min, context) {
+		return {
+			code: DiagnosticCode.CardinalityMin,
+			category: DiagnosticCategory.Contract,
+			component: context,
+			message: `${context}: "${ruleName}" requires at least ${min}.`
+		};
+	},
+	cardinalityMax(ruleName, max, context) {
+		return {
+			code: DiagnosticCode.CardinalityMax,
+			category: DiagnosticCategory.Contract,
+			component: context,
+			message: `${context}: "${ruleName}" allows at most ${max}.`
+		};
+	},
+	positionViolation(ruleName, position, index, context) {
+		return {
+			code: DiagnosticCode.PositionViolation,
+			category: DiagnosticCategory.Contract,
+			component: context,
+			message: `${context}: "${ruleName}" must be ${position}, got index ${index}`
+		};
+	},
+	unknownVariantDim(component, label, dim) {
+		return {
+			code: DiagnosticCode.ContractUnknownVariantDim,
+			category: DiagnosticCategory.Contract,
+			message: `${component}: ${label} references unknown variant "${dim}".`
+		};
+	},
+	unknownVariantValue(component, label, dim, value, valid) {
+		return {
+			code: DiagnosticCode.ContractUnknownVariantValue,
+			category: DiagnosticCategory.Contract,
+			message: `${component}: ${label} sets "${dim}" to unknown value "${value}" (valid: ${valid.join(", ")}).`
+		};
+	},
+	unknownRecipeKey(component, key) {
+		return {
+			code: DiagnosticCode.ContractUnknownRecipeKey,
+			category: DiagnosticCategory.Contract,
+			message: `${component}: unknown recipeKey "${key}" — no preset with that name exists.`
+		};
+	},
+	invalidVariantValue(component, key, value) {
+		return {
+			code: DiagnosticCode.ContractInvalidVariantValue,
+			category: DiagnosticCategory.Contract,
+			message: `${component}: variant "${key}=${value}" is not a defined value for the "${key}" dimension.`
+		};
+	},
+	allowedAsViolation(tag, allowedAs, component) {
+		const allowed = allowedAs.map((t) => `"${String(t)}"`).join(", ");
+		return {
+			code: DiagnosticCode.AllowedAsViolation,
+			category: DiagnosticCategory.Contract,
+			component,
+			message: `<${component}>: "as" prop received "${tag}" but only [${allowed}] are allowed.`
+		};
+	}
+};
+//#endregion
+//#region ../../lib/contract/src/diagnostics/html.ts
+const ATTRIBUTE_IGNORED_CODES = {
+	checked: DiagnosticCode.HtmlInputCheckedIgnoredForType,
+	multiple: DiagnosticCode.HtmlInputMultipleIgnoredForType,
+	maxLength: DiagnosticCode.HtmlInputMaxLengthIgnoredForType,
+	minLength: DiagnosticCode.HtmlInputMinLengthIgnoredForType,
+	pattern: DiagnosticCode.HtmlInputPatternIgnoredForType,
+	min: DiagnosticCode.HtmlInputMinIgnoredForType,
+	max: DiagnosticCode.HtmlInputMaxIgnoredForType,
+	step: DiagnosticCode.HtmlInputStepIgnoredForType,
+	accept: DiagnosticCode.HtmlInputAcceptIgnoredForType,
+	capture: DiagnosticCode.HtmlInputCaptureIgnoredForType,
+	size: DiagnosticCode.HtmlInputSizeIgnoredForType,
+	alt: DiagnosticCode.HtmlInputAltIgnoredForType,
+	height: DiagnosticCode.HtmlInputHeightIgnoredForType,
+	width: DiagnosticCode.HtmlInputWidthIgnoredForType
+};
+const HtmlDiagnostics = {
+	emptyRole(tag) {
+		return {
+			code: DiagnosticCode.HtmlEmptyRole,
+			category: DiagnosticCategory.HTML,
+			severity: "warning",
+			message: `<${tag}> has an explicit empty role="". Omit the attribute instead.`
+		};
+	},
+	implicitRoleRedundant(tag, implicitRole) {
+		return {
+			code: DiagnosticCode.HtmlImplicitRoleRedundant,
+			category: DiagnosticCategory.HTML,
+			severity: "warning",
+			message: `<${tag}> already has implicit role="${implicitRole}". Avoid redundant role assignment.`
+		};
+	},
+	implicitRoleOverride(tag, implicitRole, role) {
+		return {
+			code: DiagnosticCode.HtmlImplicitRoleOverride,
+			category: DiagnosticCategory.HTML,
+			severity: "error",
+			message: `<${tag}> should not override its implicit role="${implicitRole}" with role="${role}".`
+		};
+	},
+	standaloneRegionOverride(tag, implicitRole) {
+		return {
+			code: DiagnosticCode.HtmlStandaloneRegionOverride,
+			category: DiagnosticCategory.HTML,
+			severity: "error",
+			message: `<${tag}> is a self-contained element with implicit role="${implicitRole}". Assigning role="region" has been removed.`
+		};
+	},
+	landmarkRoleOverride(tag, implicitRole, role) {
+		return {
+			code: DiagnosticCode.HtmlLandmarkRoleOverride,
+			category: DiagnosticCategory.HTML,
+			severity: "error",
+			message: `<${tag}> has a fixed landmark role="${implicitRole}". role="${role}" overrides it and confuses assistive technology. The override has been removed.`
+		};
+	},
+	invalidChild(child, parent, allowed) {
+		return {
+			code: DiagnosticCode.HtmlInvalidChild,
+			category: DiagnosticCategory.HTML,
+			severity: "error",
+			message: `<${child}> is not a valid direct child of <${parent}>. Allowed: ${allowed}.`
+		};
+	},
+	roleNotPermitted(tag, role, allowedRoles) {
+		const allowed = allowedRoles.length > 0 ? allowedRoles.map((r) => `"${r}"`).join(", ") : "none — no explicit role is permitted on this element";
+		return {
+			code: DiagnosticCode.HtmlRoleNotPermitted,
+			category: DiagnosticCategory.HTML,
+			severity: "error",
+			message: `role="${role}" is not permitted on <${tag}>. Allowed alternate role(s): ${allowed}.`,
+			rationale: "The WAI-ARIA \"ARIA in HTML\" specification restricts which explicit roles a native element may take. A role outside that set is ignored or produces undefined behavior in assistive technology."
+		};
+	},
+	input: {
+		unsupportedType(type) {
+			return {
+				code: DiagnosticCode.HtmlInputUnsupportedType,
+				category: DiagnosticCategory.HTML,
+				severity: "warning",
+				message: `type="${type}" is not a value defined by the HTML specification. Browsers silently fall back to type="text".`,
+				rationale: "An unrecognized input type is not invalid markup — the spec requires the \"text\" fallback — but it usually means a typo, since the input keeps working while silently losing the intended type-specific behavior (validation, virtual keyboard, picker UI).",
+				suggestions: [{
+					title: "Check for a typo in the type value",
+					description: `"${type}" does not match any HTML5 input type.`
+				}]
+			};
+		},
+		attributeIgnoredForType(attribute, type, allowedTypes) {
+			const allowed = allowedTypes.map((t) => `"${t}"`).join(", ");
+			return {
+				code: ATTRIBUTE_IGNORED_CODES[attribute],
+				category: DiagnosticCategory.HTML,
+				severity: "warning",
+				message: `"${attribute}" is ignored on <input type="${type}">.`,
+				rationale: `"${attribute}" only has an effect when type is one of: ${allowed}. Browsers silently ignore it on other input types.`,
+				suggestions: [{
+					title: `Remove "${attribute}"`,
+					description: `"${attribute}" only affects <input> when type is one of: ${allowed}.`
+				}]
+			};
+		}
+	},
+	anchor: { dangerousHref(href) {
+		return {
+			code: DiagnosticCode.HtmlAnchorDangerousHref,
+			category: DiagnosticCategory.HTML,
+			severity: "warning",
+			message: `href="${href}" uses a scheme that executes attacker-controlled content when navigated to. It has been removed.`,
+			rationale: "\"javascript:\", \"data:\", and \"vbscript:\" URLs are a common XSS vector when href comes from untrusted input — none of the three are needed for legitimate navigation."
+		};
+	} }
+};
+//#endregion
+//#region ../../lib/contract/src/diagnostics/input-accessibility.ts
+function accessibilityFact(input) {
+	return {
+		category: DiagnosticCategory.Accessibility,
+		...input
+	};
+}
+const InputAccessibilityDiagnostics = {
+	missingAccessibleName() {
+		return accessibilityFact({
+			code: DiagnosticCode.A11yInputMissingAccessibleName,
+			severity: "warning",
+			message: "This input has no accessible name. Add an associated <label>, aria-label, or aria-labelledby.",
+			rationale: "Assistive technology announces a form field by its accessible name; without one, users of screen readers cannot tell what the field is for.",
+			suggestions: [{
+				title: "Add aria-label",
+				description: "Set aria-label=\"…\" directly on the input."
+			}, {
+				title: "Add an associated <label>",
+				description: "Wrap the input in a <label>, or point a <label for=\"…\"> at its id."
+			}]
+		});
+	},
+	placeholderIsNotLabel() {
+		return accessibilityFact({
+			code: DiagnosticCode.A11yInputPlaceholderNotLabel,
+			severity: "warning",
+			message: "Placeholder text does not provide an accessible name. Add an associated <label>, aria-label, or aria-labelledby.",
+			rationale: "Placeholder text disappears as users interact with the field and is not treated as the control's accessible name by many assistive technologies.",
+			suggestions: [{
+				title: "Add aria-label",
+				description: "Set aria-label=\"…\" directly on the input."
+			}, {
+				title: "Add an associated <label>",
+				description: "Wrap the input in a <label>, or point a <label for=\"…\"> at its id."
+			}]
+		});
+	},
+	passwordMissingAutocomplete() {
+		return accessibilityFact({
+			code: DiagnosticCode.A11yInputPasswordAutocomplete,
+			severity: "warning",
+			message: "Password inputs should specify an autoComplete value.",
+			rationale: "Without an explicit autocomplete hint, password managers and browsers cannot reliably tell a sign-in field apart from a password-creation field.",
+			suggestions: [{
+				title: "Set autoComplete=\"current-password\"",
+				description: "Use this for sign-in forms."
+			}, {
+				title: "Set autoComplete=\"new-password\"",
+				description: "Use this for sign-up / change-password forms."
+			}]
+		});
+	},
+	requiredReadOnlyConflict() {
+		return accessibilityFact({
+			code: DiagnosticCode.A11yInputRequiredReadOnlyConflict,
+			severity: "warning",
+			message: "\"required\" has no effect while this field is readOnly — the two attributes together usually signal an unintended state.",
+			rationale: "The combination is valid HTML, but a readOnly control cannot be edited, so its \"required\" constraint can never be satisfied or violated through user interaction. Consider using disabled instead of readOnly, or only applying required when the field is editable."
+		});
+	}
+};
+//#endregion
+//#region ../../lib/contract/src/strict/invariant-base.ts
+var InvariantBase = class {
+	diagnostics;
+	constructor(diagnostics) {
+		this.diagnostics = diagnostics;
+	}
+	get warnActive() {
+		return this.diagnostics.warnActive;
+	}
+	violate(input) {
+		this.diagnostics.error(input);
+	}
+	warn(input) {
+		this.diagnostics.warn(input);
+	}
+	invariant(condition, input) {
+		if (!condition) this.violate(input);
+	}
+};
+//#endregion
+//#region ../../lib/contract/src/aria/spec/roles/required-properties.ts
+const REQUIRED_ARIA_PROPERTIES = {
+	combobox: ["aria-expanded"],
+	option: ["aria-selected"],
+	slider: ["aria-valuenow"],
+	scrollbar: ["aria-controls", "aria-valuenow"],
+	spinbutton: ["aria-valuenow"]
+};
+//#endregion
+//#region ../../lib/contract/src/aria/spec/roles/name-required.ts
+const NAME_REQUIRED_ROLES = /* @__PURE__ */ new Set(["img"]);
+//#endregion
+//#region ../../lib/contract/src/aria/spec/roles/name-prohibited.ts
+const NAME_PROHIBITED_ROLES = /* @__PURE__ */ new Set([
+	"caption",
+	"code",
+	"deletion",
+	"emphasis",
+	"generic",
+	"insertion",
+	"none",
+	"paragraph",
+	"presentation",
+	"strong",
+	"subscript",
+	"superscript"
+]);
+const NAME_PROHIBITED_ATTRIBUTES = ["aria-label", "aria-labelledby"];
+//#endregion
+//#region ../../lib/contract/src/aria/spec/validators/required-properties-validator.ts
+const NO_VIOLATIONS$1 = [{ valid: true }];
+function requiredAttributeByRole(roles, attribute) {
+	return Object.fromEntries([...roles].map((role) => [role, [attribute]]));
+}
+/**
+* Reports missing attributes required by an element's effective ARIA role.
+*
+* Shared by validators that differ only in their role-to-attribute mapping and diagnostic
+* generation.
+*/
+function checkRequiredAttributes(requirement, { props, effectiveRole }) {
+	if (!effectiveRole) return NO_VIOLATIONS$1;
+	const requiredAttributes = requirement.attributesByRole[effectiveRole];
+	if (!requiredAttributes) return NO_VIOLATIONS$1;
+	const results = [];
+	for (const attribute of requiredAttributes) {
+		if (attribute in props) continue;
+		results.push({
+			valid: false,
+			fixable: false,
+			severity: "warning",
+			attribute,
+			diagnostic: requirement.diagnosticFor(attribute, effectiveRole)
+		});
+	}
+	return results;
+}
+//#endregion
+//#region ../../lib/contract/src/aria/spec/roles/live-region.ts
+const LIVE_REGION_ROLES = /* @__PURE__ */ new Map([
+	["alert", "assertive"],
+	["status", "polite"],
+	["log", "polite"],
+	["timer", "off"]
+]);
+const ATOMIC_REQUIREMENTS = requiredAttributeByRole(LIVE_REGION_ROLES.keys(), "aria-atomic");
+//#endregion
+//#region ../../lib/contract/src/aria/spec/attributes/aria-value-types.ts
+const ARIA_VALUE_TYPES = /* @__PURE__ */ new Map([
+	["aria-atomic", { kind: "boolean" }],
+	["aria-busy", { kind: "boolean" }],
+	["aria-disabled", { kind: "boolean" }],
+	["aria-expanded", { kind: "boolean" }],
+	["aria-hidden", { kind: "boolean" }],
+	["aria-modal", { kind: "boolean" }],
+	["aria-multiline", { kind: "boolean" }],
+	["aria-multiselectable", { kind: "boolean" }],
+	["aria-readonly", { kind: "boolean" }],
+	["aria-required", { kind: "boolean" }],
+	["aria-selected", { kind: "boolean" }],
+	["aria-checked", { kind: "tristate" }],
+	["aria-pressed", { kind: "tristate" }],
+	["aria-valuenow", { kind: "number" }],
+	["aria-valuemin", { kind: "number" }],
+	["aria-valuemax", { kind: "number" }],
+	["aria-level", {
+		kind: "integer",
+		min: 1
+	}],
+	["aria-posinset", {
+		kind: "integer",
+		min: 1
+	}],
+	["aria-setsize", {
+		kind: "integer",
+		min: -1
+	}],
+	["aria-rowcount", {
+		kind: "integer",
+		min: -1
+	}],
+	["aria-colcount", {
+		kind: "integer",
+		min: -1
+	}],
+	["aria-rowindex", {
+		kind: "integer",
+		min: 1
+	}],
+	["aria-colindex", {
+		kind: "integer",
+		min: 1
+	}],
+	["aria-rowspan", {
+		kind: "integer",
+		min: 0
+	}],
+	["aria-colspan", {
+		kind: "integer",
+		min: 0
+	}],
+	["aria-autocomplete", {
+		kind: "enum",
+		values: /* @__PURE__ */ new Set([
+			"inline",
+			"list",
+			"both",
+			"none"
+		])
+	}],
+	["aria-current", {
+		kind: "enum",
+		values: /* @__PURE__ */ new Set([
+			"page",
+			"step",
+			"location",
+			"date",
+			"time",
+			"true",
+			"false"
+		])
+	}],
+	["aria-haspopup", {
+		kind: "enum",
+		values: /* @__PURE__ */ new Set([
+			"false",
+			"true",
+			"menu",
+			"listbox",
+			"tree",
+			"grid",
+			"dialog"
+		])
+	}],
+	["aria-invalid", {
+		kind: "enum",
+		values: /* @__PURE__ */ new Set([
+			"grammar",
+			"false",
+			"spelling",
+			"true"
+		])
+	}],
+	["aria-live", {
+		kind: "enum",
+		values: /* @__PURE__ */ new Set([
+			"assertive",
+			"off",
+			"polite"
+		])
+	}],
+	["aria-orientation", {
+		kind: "enum",
+		values: /* @__PURE__ */ new Set([
+			"horizontal",
+			"vertical",
+			"undefined"
+		])
+	}],
+	["aria-sort", {
+		kind: "enum",
+		values: /* @__PURE__ */ new Set([
+			"ascending",
+			"descending",
+			"none",
+			"other"
+		])
+	}]
+]);
+//#endregion
+//#region ../../lib/contract/src/aria/spec/attributes/aria-relevant-tokens.ts
+const VALID_RELEVANT_TOKENS = /* @__PURE__ */ new Set([
+	"additions",
+	"removals",
+	"text",
+	"all"
+]);
+//#endregion
+//#region ../../lib/contract/src/aria/spec/elements/heading-implicit-levels.ts
+const HEADING_IMPLICIT_LEVELS = /* @__PURE__ */ new Map([
+	["h1", 1],
+	["h2", 2],
+	["h3", 3],
+	["h4", 4],
+	["h5", 5],
+	["h6", 6]
+]);
+//#endregion
+//#region ../../lib/contract/src/aria/spec/elements/focusable.ts
+function parseTabIndex(raw) {
+	if (typeof raw === "number") return Number.isInteger(raw) ? raw : void 0;
+	if (typeof raw !== "string") return void 0;
+	const trimmed = raw.trim();
+	if (trimmed === "") return void 0;
+	const n = Number(trimmed);
+	return Number.isInteger(n) ? n : void 0;
+}
+function isDisabled(props) {
+	const d = props["disabled"];
+	return d !== void 0 && d !== false && d !== null;
+}
+function isContentEditable(props) {
+	const c = props["contenteditable"] ?? props["contentEditable"];
+	return c === "" || c === true || c === "true" || c === "plaintext-only";
+}
+function hasHref(props) {
+	return props["href"] !== void 0 && props["href"] !== null;
+}
+/**
+* Whether an element is reachable in the sequential keyboard tab order — a native control its
+* own attributes leave tabbable, `tabindex >= 0`, or `contenteditable`.
+*
+* This is **tabbability, not raw focusability**: `tabindex="-1"` is deliberately treated as *not*
+* qualifying, even though such an element can still receive programmatic focus. The one consumer
+* (`#checkAriaHiddenOnFocusable`) cares about content a keyboard user can land on, and `../pk`'s
+* behavior — `aria-hidden` on `<h2 tabindex="-1">` is not flagged — depends on this. If the
+* contract system ever needs to separate focusability from tabbability, split this into
+* `isPotentiallyFocusable` / `isPotentiallyTabbable`; until then one predicate with this policy
+* is enough.
+*
+* Absent `tabindex`, `contenteditable` makes anything tabbable; otherwise the answer is per
+* native tag, gated on that tag's own attributes.
+*/
+function isPotentiallyFocusable(tag, props) {
+	const tabindex = parseTabIndex(props["tabindex"] ?? props["tabIndex"]);
+	if (tabindex !== void 0) return tabindex >= 0;
+	if (isContentEditable(props)) return true;
+	switch (tag) {
+		case "a":
+		case "area": return hasHref(props);
+		case "input": return props["type"] !== "hidden" && !isDisabled(props);
+		case "button":
+		case "select":
+		case "textarea": return !isDisabled(props);
+		default: return false;
+	}
+}
+//#endregion
+//#region ../../lib/contract/src/aria/aria-policy-engine.ts
+const NO_VIOLATIONS = [{ valid: true }];
+const NO_VARIANT_KEYS = /* @__PURE__ */ new Set();
+function isIntrinsicTag(tag) {
+	return isString(tag);
+}
+function omitProp(obj, key) {
+	const { [key]: _, ...rest } = obj;
+	return rest;
+}
+function strictNumeric(value) {
+	if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	if (trimmed === "") return void 0;
+	const n = Number(trimmed);
+	return Number.isFinite(n) ? n : void 0;
+}
+var AriaPolicyEngine = class AriaPolicyEngine extends InvariantBase {
+	#extraRules;
+	#variantKeys;
+	#planCache = new LRUCache(100);
+	static #removeAttributeFixCache = /* @__PURE__ */ new Map();
+	constructor(diagnostics, options) {
+		super(diagnostics);
+		this.#extraRules = options?.rules ?? [];
+		this.#variantKeys = options?.variantKeys ?? NO_VARIANT_KEYS;
+	}
+	static #normalizeEmptyRole(tag, props) {
+		if (props.role !== "") return { normalized: false };
+		const d = HtmlDiagnostics.emptyRole(tag);
+		return {
+			normalized: true,
+			result: {
+				props: omitProp(props, "role"),
+				violations: [{
+					message: d.message,
+					diagnostic: d,
+					tag,
+					role: "",
+					attribute: void 0,
+					severity: d.severity,
+					phase: "evaluate"
+				}]
+			}
+		};
+	}
+	static #deriveContext(tag, props, variantKeys = NO_VARIANT_KEYS) {
+		if (!isIntrinsicTag(tag)) return {
+			proceed: false,
+			result: {
+				props,
+				violations: []
+			}
+		};
+		const implicitRole = getImplicitRole(tag, props);
+		const hasRole = isNonNull(implicitRole) || isString(props.role) && props.role.length > 0;
+		const normalized = AriaPolicyEngine.#normalizeEmptyRole(tag, props);
+		const workingProps = normalized.normalized ? normalized.result.props : props;
+		const preExistingViolations = normalized.normalized ? normalized.result.violations : [];
+		const effectiveRole = workingProps.role ?? implicitRole;
+		return {
+			proceed: true,
+			tag,
+			implicitRole,
+			effectiveRole,
+			hasRole,
+			props: workingProps,
+			preExistingViolations,
+			context: {
+				tag,
+				props: workingProps,
+				implicitRole,
+				effectiveRole,
+				variantKeys
+			}
+		};
+	}
+	static #runRules(rules, context) {
+		const violations = [];
+		const fixes = [];
+		iterate.forEach(rules, (rule) => {
+			if (isNonNull(rule.tags) && !rule.tags.includes(context.tag)) return;
+			iterate.forEach(rule(context), (result) => {
+				if (result.valid) return;
+				const { tag, props: { role } } = context;
+				const { message, attribute, severity } = result;
+				const resolvedMessage = message ?? result.diagnostic?.message;
+				const fallbackDiag = isNonNull(resolvedMessage) ? void 0 : AriaDiagnostics.invalidRole(role, tag);
+				violations.push({
+					message: resolvedMessage ?? fallbackDiag.message,
+					tag,
+					role,
+					attribute,
+					severity,
+					phase: "evaluate",
+					...isNonNull(result.diagnostic) && { diagnostic: result.diagnostic },
+					...isNonNull(fallbackDiag) && { diagnostic: fallbackDiag }
+				});
+				if (result.fixable) fixes.push(result.fix);
+			});
+		});
+		return {
+			violations,
+			fixes
+		};
+	}
+	static #getRules(context) {
+		if (AriaPolicyEngine.#hasRole(context.props) || isNonNull(context.effectiveRole) && LIVE_REGION_ROLES.has(context.effectiveRole)) return AriaPolicyEngine.#pipeline;
+		return AriaPolicyEngine.#implicitOnlyRules;
+	}
+	static evaluate(tag, props) {
+		const derived = AriaPolicyEngine.#deriveContext(tag, props);
+		if (!derived.proceed) return derived.result;
+		if (!derived.hasRole) return {
+			props: derived.props,
+			violations: [...derived.preExistingViolations]
+		};
+		const { tag: narrowedTag, implicitRole, context, props: workingProps, preExistingViolations } = derived;
+		const { violations, fixes } = AriaPolicyEngine.#runRules(AriaPolicyEngine.#getRules(context), context);
+		return {
+			props: AriaPolicyEngine.#applyFixes(narrowedTag, implicitRole, workingProps, fixes),
+			violations: [...preExistingViolations, ...violations]
+		};
+	}
+	static #evaluateWithRules(tag, props, extraRules, extraProps, variantKeys = NO_VARIANT_KEYS) {
+		const derived = AriaPolicyEngine.#deriveContext(tag, props, variantKeys);
+		if (!derived.proceed) return derived.result;
+		const { tag: narrowedTag, implicitRole, context, props: workingProps, preExistingViolations } = derived;
+		const builtinRules = derived.hasRole ? AriaPolicyEngine.#getRules(context) : [];
+		const builtin = AriaPolicyEngine.#runRules(builtinRules, context);
+		const extraContext = extraProps === void 0 ? context : {
+			...context,
+			props: extraProps
+		};
+		const extra = AriaPolicyEngine.#runRules(extraRules, extraContext);
+		const violations = [...builtin.violations, ...extra.violations];
+		const fixes = [...builtin.fixes, ...extra.fixes];
+		return {
+			props: AriaPolicyEngine.#applyFixes(narrowedTag, implicitRole, workingProps, fixes, variantKeys),
+			violations: [...preExistingViolations, ...violations]
+		};
+	}
+	report(violations) {
+		iterate.forEach(violations, (v) => {
+			const d = v.diagnostic ?? AriaDiagnostics.fromViolation(v);
+			if (v.severity === "error") this.violate(d);
+			else this.warn(d);
+		});
+	}
+	static #createPlanKey(tag, props) {
+		if (!isIntrinsicTag(tag)) return null;
+		const parts = [tag];
+		if (typeof props.role === "string") parts.push(`role:${props.role}`);
+		if (tag === "input" && typeof props.type === "string") parts.push(`type:${props.type}`);
+		if (tag === "img") parts.push(`alt:${props.alt === "" ? "empty" : "present"}`);
+		const ariaEntries = [];
+		iterate.forEachEntry(props, (k, v) => {
+			if (!k.startsWith("aria-")) return;
+			if (!isString(v) && !isNumber(v) && typeof v !== "boolean") return;
+			ariaEntries.push(`${k}:${String(v)}`);
+		});
+		if (ariaEntries.length > 0) parts.push(...ariaEntries.sort());
+		return parts.join("|");
+	}
+	static #extraRulesKeySuffix(extraRules, props) {
+		const parts = [];
+		for (const rule of extraRules) {
+			const readsProps = rule.readsProps;
+			if (!isNonNull(readsProps)) return null;
+			for (const propKey of readsProps) {
+				const v = props[propKey];
+				if (v !== void 0 && !isString(v) && !isNumber(v) && typeof v !== "boolean") return null;
+				parts.push(`x:${propKey}:${String(v)}`);
+			}
+		}
+		return parts.sort().join("|");
+	}
+	static #computePlan(inputProps, resultProps) {
+		const removals = /* @__PURE__ */ new Set();
+		const updates = {};
+		iterate.forEachKey(inputProps, (key) => {
+			if (!(key in resultProps)) removals.add(key);
+		});
+		iterate.forEachEntry(resultProps, (key, resultVal) => {
+			if (inputProps[key] !== resultVal) updates[key] = resultVal;
+		});
+		return {
+			removals,
+			updates
+		};
+	}
+	static #applyPlan(props, removals, updates) {
+		const hasRemovals = removals.size > 0;
+		const hasUpdates = Object.keys(updates).length > 0;
+		if (!hasRemovals && !hasUpdates) return props;
+		const next = {};
+		iterate.forEachEntry(props, (k, v) => {
+			if (!removals.has(k)) next[k] = v;
+		});
+		Object.assign(next, updates);
+		return next;
+	}
+	validate(tag, props, extraProps) {
+		const ruleProps = extraProps ?? props;
+		const baseKey = AriaPolicyEngine.#createPlanKey(tag, props);
+		let key = baseKey;
+		if (this.#extraRules.length > 0) {
+			const suffix = AriaPolicyEngine.#extraRulesKeySuffix(this.#extraRules, ruleProps);
+			key = isNonNull(baseKey) && isNonNull(suffix) ? `${baseKey}|${suffix}` : null;
+		}
+		if (!isNull(key)) {
+			const cached = this.#planCache.get(key);
+			if (cached !== void 0) {
+				if (cached.violations.length > 0) this.report(cached.violations);
+				return {
+					props: AriaPolicyEngine.#applyPlan(props, cached.removals, cached.updates),
+					violations: cached.violations
+				};
+			}
+		}
+		const result = this.#extraRules.length ? AriaPolicyEngine.#evaluateWithRules(tag, props, this.#extraRules, extraProps, this.#variantKeys) : AriaPolicyEngine.evaluate(tag, props);
+		if (result.violations.length > 0) this.report(result.violations);
+		if (!isNull(key)) {
+			const { removals, updates } = AriaPolicyEngine.#computePlan(props, result.props);
+			const plan = {
+				removals,
+				updates,
+				violations: result.violations
+			};
+			this.#planCache.set(key, plan);
+		}
+		return result;
+	}
+	static #hasRole(props) {
+		return isString(props.role) && props.role.length > 0;
+	}
+	static #applyFixes(tag, implicitRole, props, fixes, variantKeys = NO_VARIANT_KEYS) {
+		if (fixes.length === 0) return props;
+		const sorted = [...fixes].sort((a, b) => (a.priority ?? Infinity) - (b.priority ?? Infinity));
+		let next = props;
+		iterate.forEach(sorted, ({ apply }) => {
+			const fixResult = apply({
+				tag,
+				implicitRole,
+				effectiveRole: next.role ?? implicitRole,
+				props: next,
+				variantKeys
+			});
+			if (fixResult.applied) next = fixResult.next;
+		});
+		return next;
+	}
+	static #removeRole = {
+		kind: "removeRole",
+		apply: ({ props }) => {
+			if (!("role" in props)) return {
+				applied: false,
+				next: props
+			};
+			return {
+				applied: true,
+				next: omitProp(props, "role"),
+				previous: props
+			};
+		}
+	};
+	static #makeRemoveAttributeFix(attr) {
+		const cached = AriaPolicyEngine.#removeAttributeFixCache.get(attr);
+		if (cached) return cached;
+		const fix = {
+			kind: "removeAttribute",
+			attribute: attr,
+			apply: ({ props }) => {
+				if (!(attr in props)) return {
+					applied: false,
+					next: props
+				};
+				return {
+					applied: true,
+					next: omitProp(props, attr),
+					previous: props
+				};
+			}
+		};
+		AriaPolicyEngine.#removeAttributeFixCache.set(attr, fix);
+		return fix;
+	}
+	static #pipeline = [
+		AriaPolicyEngine.#checkInvalidRoleOverride,
+		AriaPolicyEngine.#checkRedundantRole,
+		AriaPolicyEngine.#checkStandaloneRegion,
+		AriaPolicyEngine.#checkAriaAttributeValues,
+		AriaPolicyEngine.#checkInvalidAriaAttributes,
+		AriaPolicyEngine.#checkNameProhibitedRoles,
+		AriaPolicyEngine.#checkRequiredAriaProperties,
+		AriaPolicyEngine.#checkNameRequiredRoles,
+		AriaPolicyEngine.#checkRedundantAriaLevel,
+		AriaPolicyEngine.#checkMissingLiveRegion,
+		AriaPolicyEngine.#checkMissingAtomic,
+		AriaPolicyEngine.#checkInvalidAriaRelevant,
+		AriaPolicyEngine.#checkAriaHiddenOnFocusable,
+		AriaPolicyEngine.#checkPresentationalAriaAttributes
+	];
+	static #implicitOnlyRules = [
+		AriaPolicyEngine.#checkAriaAttributeValues,
+		AriaPolicyEngine.#checkInvalidAriaAttributes,
+		AriaPolicyEngine.#checkNameProhibitedRoles,
+		AriaPolicyEngine.#checkNameRequiredRoles,
+		AriaPolicyEngine.#checkRedundantAriaLevel,
+		AriaPolicyEngine.#checkAriaHiddenOnFocusable,
+		AriaPolicyEngine.#checkPresentationalAriaAttributes
+	];
+	static #checkInvalidRoleOverride({ tag, props, implicitRole }) {
+		const role = props.role;
+		if (!implicitRole || !role || role === implicitRole) return NO_VIOLATIONS;
+		if (isStrongImplicitRole(tag) && role === "region") {
+			const diagnostic = HtmlDiagnostics.implicitRoleOverride(tag, implicitRole, role);
+			return [{
+				valid: false,
+				fixable: true,
+				severity: diagnostic.severity,
+				fix: AriaPolicyEngine.#removeRole,
+				diagnostic
+			}];
+		}
+		return NO_VIOLATIONS;
+	}
+	static #checkRedundantRole({ tag, props, implicitRole }) {
+		const role = props.role;
+		if (!implicitRole || !role || role !== implicitRole) return NO_VIOLATIONS;
+		const diagnostic = HtmlDiagnostics.implicitRoleRedundant(tag, implicitRole);
+		return [{
+			valid: false,
+			fixable: true,
+			severity: diagnostic.severity,
+			fix: AriaPolicyEngine.#removeRole,
+			diagnostic
+		}];
+	}
+	static #checkStandaloneRegion({ tag, props, implicitRole }) {
+		if (props.role !== "region") return NO_VIOLATIONS;
+		if (!hasStandaloneRole(tag)) return NO_VIOLATIONS;
+		const diagnostic = HtmlDiagnostics.standaloneRegionOverride(tag, implicitRole ?? tag);
+		return [{
+			valid: false,
+			fixable: true,
+			severity: diagnostic.severity,
+			fix: AriaPolicyEngine.#removeRole,
+			diagnostic
+		}];
+	}
+	static #checkInvalidAriaAttributes({ tag, props, effectiveRole }) {
+		if (effectiveRole === "none" || effectiveRole === "presentation") return NO_VIOLATIONS;
+		const results = [];
+		iterate.forEachEntry(props, (key) => {
+			if (!key.startsWith("aria-")) return;
+			if (isGlobalAriaAttribute(key)) return;
+			if (isAriaAttributeValidForRole(key, effectiveRole)) return;
+			results.push({
+				valid: false,
+				severity: "warning",
+				fixable: true,
+				attribute: key,
+				diagnostic: AriaDiagnostics.attributeInvalid(key, effectiveRole ?? tag),
+				fix: AriaPolicyEngine.#makeRemoveAttributeFix(key)
+			});
+		});
+		return results;
+	}
+	static #isValidAriaValue(value, type) {
+		switch (type.kind) {
+			case "boolean": return value === "true" || value === "false" || value === true || value === false;
+			case "tristate": return value === "true" || value === "false" || value === "mixed" || value === true || value === false;
+			case "number": return strictNumeric(value) !== void 0;
+			case "integer": {
+				const n = strictNumeric(value);
+				if (n === void 0 || !Number.isInteger(n)) return false;
+				if (type.min !== void 0 && n < type.min) return false;
+				if (type.max !== void 0 && n > type.max) return false;
+				return true;
+			}
+			case "enum": return typeof value === "string" && type.values.has(value);
+		}
+	}
+	static #describeExpected(type) {
+		switch (type.kind) {
+			case "boolean": return "\"true\" or \"false\"";
+			case "tristate": return "\"true\", \"false\", or \"mixed\"";
+			case "number": return "a finite number";
+			case "integer": {
+				const parts = ["an integer"];
+				if (type.min !== void 0 && type.max !== void 0) parts.push(`between ${type.min} and ${type.max}`);
+				else if (type.min !== void 0) parts.push(`≥ ${type.min}`);
+				else if (type.max !== void 0) parts.push(`≤ ${type.max}`);
+				return parts.join(" ");
+			}
+			case "enum": return [...type.values].map((v) => `"${v}"`).join(", ");
+		}
+	}
+	static #checkAriaAttributeValues({ props, effectiveRole }) {
+		if (effectiveRole === "none" || effectiveRole === "presentation") return NO_VIOLATIONS;
+		const results = [];
+		iterate.forEachEntry(props, (key, value) => {
+			if (!key.startsWith("aria-")) return;
+			const type = ARIA_VALUE_TYPES.get(key);
+			if (!isNonNull(type)) return;
+			if (AriaPolicyEngine.#isValidAriaValue(value, type)) return;
+			results.push({
+				valid: false,
+				fixable: true,
+				severity: "warning",
+				attribute: key,
+				diagnostic: AriaDiagnostics.invalidAttributeValue(key, value, AriaPolicyEngine.#describeExpected(type)),
+				fix: AriaPolicyEngine.#makeRemoveAttributeFix(key)
+			});
+		});
+		return results;
+	}
+	static #checkRedundantAriaLevel({ tag, props, effectiveRole }) {
+		if (effectiveRole === "none" || effectiveRole === "presentation") return NO_VIOLATIONS;
+		const implicitLevel = HEADING_IMPLICIT_LEVELS.get(tag);
+		if (!isNonNull(implicitLevel)) return NO_VIOLATIONS;
+		const raw = props["aria-level"];
+		if (!isNonNull(raw)) return NO_VIOLATIONS;
+		const n = strictNumeric(raw);
+		if (n === void 0 || n !== implicitLevel) return NO_VIOLATIONS;
+		return [{
+			valid: false,
+			fixable: true,
+			severity: "warning",
+			attribute: "aria-level",
+			diagnostic: AriaDiagnostics.redundantAriaLevel(tag, implicitLevel),
+			fix: AriaPolicyEngine.#makeRemoveAttributeFix("aria-level")
+		}];
+	}
+	static #checkNameProhibitedRoles({ props, effectiveRole }) {
+		if (!effectiveRole || effectiveRole === "none" || effectiveRole === "presentation" || !NAME_PROHIBITED_ROLES.has(effectiveRole)) return NO_VIOLATIONS;
+		const results = [];
+		for (const key of NAME_PROHIBITED_ATTRIBUTES) {
+			if (!(key in props)) continue;
+			results.push({
+				valid: false,
+				fixable: true,
+				severity: "warning",
+				attribute: key,
+				diagnostic: AriaDiagnostics.nameProhibited(key, effectiveRole),
+				fix: AriaPolicyEngine.#makeRemoveAttributeFix(key)
+			});
+		}
+		return results;
+	}
+	static #checkNameRequiredRoles({ tag, props, effectiveRole }) {
+		if (!effectiveRole || !NAME_REQUIRED_ROLES.has(effectiveRole)) return NO_VIOLATIONS;
+		if ("aria-label" in props || "aria-labelledby" in props) return NO_VIOLATIONS;
+		if (tag === "img" && typeof props.alt === "string" && props.alt.length > 0) return NO_VIOLATIONS;
+		return [{
+			valid: false,
+			fixable: false,
+			severity: "warning",
+			diagnostic: AriaDiagnostics.missingAccessibleName(tag)
+		}];
+	}
+	static #requiredAriaPropertiesRule = {
+		attributesByRole: REQUIRED_ARIA_PROPERTIES,
+		diagnosticFor: (attribute, role) => AriaDiagnostics.requiredProperty(attribute, role)
+	};
+	static #checkRequiredAriaProperties(context) {
+		if (!isNonNull(context.props.role)) return NO_VIOLATIONS;
+		return checkRequiredAttributes(AriaPolicyEngine.#requiredAriaPropertiesRule, context);
+	}
+	static #checkAriaHiddenOnFocusable({ tag, props }) {
+		if (props["aria-hidden"] !== "true" && props["aria-hidden"] !== true) return NO_VIOLATIONS;
+		if (!isPotentiallyFocusable(tag, props)) return NO_VIOLATIONS;
+		return [{
+			valid: false,
+			fixable: false,
+			severity: "error",
+			attribute: "aria-hidden",
+			diagnostic: AriaDiagnostics.ariaHiddenOnFocusable(tag)
+		}];
+	}
+	static #checkPresentationalAriaAttributes({ tag, props, effectiveRole }) {
+		if (effectiveRole !== "none" && effectiveRole !== "presentation") return NO_VIOLATIONS;
+		const results = [];
+		iterate.forEachEntry(props, (key) => {
+			if (!key.startsWith("aria-")) return;
+			if (key === "aria-hidden") return;
+			results.push({
+				valid: false,
+				fixable: true,
+				severity: "warning",
+				attribute: key,
+				diagnostic: AriaDiagnostics.attributeOnPresentational(key, tag),
+				fix: AriaPolicyEngine.#makeRemoveAttributeFix(key)
+			});
+		});
+		return results;
+	}
+	static #checkMissingLiveRegion({ effectiveRole, props }) {
+		if (!effectiveRole) return NO_VIOLATIONS;
+		const impliedLive = LIVE_REGION_ROLES.get(effectiveRole);
+		if (!impliedLive) return NO_VIOLATIONS;
+		if ("aria-live" in props) return NO_VIOLATIONS;
+		return [{
+			valid: false,
+			fixable: true,
+			severity: "warning",
+			fix: {
+				kind: "injectLive",
+				attribute: "aria-live",
+				apply: (ctx) => ({
+					applied: true,
+					next: {
+						...ctx.props,
+						"aria-live": impliedLive
+					},
+					previous: ctx.props
+				})
+			},
+			diagnostic: AriaDiagnostics.missingLiveRegion(effectiveRole, impliedLive)
+		}];
+	}
+	static #missingAtomicRule = {
+		attributesByRole: ATOMIC_REQUIREMENTS,
+		diagnosticFor: (_attribute, role) => AriaDiagnostics.missingAtomic(role)
+	};
+	static #checkMissingAtomic(context) {
+		return checkRequiredAttributes(AriaPolicyEngine.#missingAtomicRule, context);
+	}
+	static #normalizeRelevantAllFix = {
+		kind: "normalizeRelevantAll",
+		apply: ({ props: p }) => ({
+			applied: true,
+			next: {
+				...p,
+				"aria-relevant": "all"
+			},
+			previous: p
+		})
+	};
+	static #checkInvalidAriaRelevant({ props }) {
+		const relevant = props["aria-relevant"];
+		if (relevant === void 0) return NO_VIOLATIONS;
+		if (typeof relevant !== "string") return NO_VIOLATIONS;
+		const tokens = relevant.trim().split(/\s+/);
+		const invalid = tokens.filter((t) => !VALID_RELEVANT_TOKENS.has(t));
+		if (invalid.length > 0) return [{
+			valid: false,
+			fixable: true,
+			severity: "warning",
+			attribute: "aria-relevant",
+			diagnostic: AriaDiagnostics.relevantInvalidTokens(invalid),
+			fix: AriaPolicyEngine.#makeRemoveAttributeFix("aria-relevant")
+		}];
+		if (tokens.includes("all") && tokens.length > 1) return [{
+			valid: false,
+			fixable: true,
+			severity: "warning",
+			attribute: "aria-relevant",
+			diagnostic: AriaDiagnostics.relevantSuperseded(),
+			fix: AriaPolicyEngine.#normalizeRelevantAllFix
+		}];
+		return NO_VIOLATIONS;
+	}
+};
+//#endregion
+//#region ../../lib/contract/src/aria/factories.ts
+/**
+* Builds a correctly-literal-typed `fixable: false` `AriaResult`. Exists so a rule author can
+* extract shared branch logic (severity/attribute/message computed once, reused across multiple
+* `return`s) without TypeScript silently widening `valid: false`/`fixable: false` to `boolean`
+* the moment those values leave an object-literal-in-return-position — the widening only happens
+* on plain object literals; a function's declared return type narrows unconditionally.
+*/
+function invalidWithoutFix(input) {
+	return {
+		valid: false,
+		fixable: false,
+		severity: input.severity,
+		...isDefined(input.attribute) && { attribute: input.attribute },
+		...isDefined(input.message) && { message: input.message },
+		...isDefined(input.diagnostic) && { diagnostic: input.diagnostic }
+	};
+}
+/** Same as {@link invalidWithoutFix}, for the `fixable: true` branch — requires a `fix`. */
+function invalidWithFix(input) {
+	return {
+		valid: false,
+		fixable: true,
+		severity: input.severity,
+		...isDefined(input.attribute) && { attribute: input.attribute },
+		...isDefined(input.message) && { message: input.message },
+		...isDefined(input.diagnostic) && { diagnostic: input.diagnostic },
+		fix: input.fix
+	};
+}
+function removeProp(props, key) {
+	const next = { ...props };
+	delete next[key];
+	return next;
+}
+/**
+* Builds an `AriaFix` that strips a single attribute — the shape `dangerousHrefRule`-style
+* "strip this attribute when it's dangerous/redundant" rules need. A no-op (`applied: false`) when
+* the attribute isn't present, so applying the fix twice (or applying it when nothing triggered it)
+* is always safe. Frozen — a fix is a value object; nothing should mutate `kind`/`attribute`/`apply`
+* after construction.
+*/
+function removeAttributeFix(attribute) {
+	return Object.freeze({
+		kind: "removeAttribute",
+		attribute,
+		apply: ({ props }) => {
+			if (!(attribute in props)) return {
+				applied: false,
+				next: props
+			};
+			return {
+				applied: true,
+				next: removeProp(props, attribute),
+				previous: props
+			};
+		}
+	});
+}
+function defineRuleMetadata(rule, metadata) {
+	const descriptors = {};
+	for (const key of Object.keys(metadata)) descriptors[key] = {
+		value: metadata[key],
+		enumerable: false
+	};
+	Object.defineProperties(rule, descriptors);
+	return rule;
+}
+/**
+* Convenience factory for the single most common `enforcement.aria`/`enforcement.rules` shape:
+* "strip this attribute when some condition on the element's own props holds" — covers
+* security-style guards (a dangerous URL scheme on `href`) and redundant-attribute rules alike,
+* without hand-writing the rule function, the `AriaFix`, and the `invalidWithFix` call each time.
+* A rule with no fix (a warn-only advisory) still needs the raw `AriaRule` shape directly — this
+* factory is deliberately scoped to the strip-on-match case, not a general rule builder.
+*/
+function createRemoveAttributeRule(attribute, options) {
+	const { when, severity = "warning", message, diagnostic, readsProps, tags } = options;
+	const fix = removeAttributeFix(attribute);
+	const rule = (context) => {
+		if (!when(context)) return [];
+		return [invalidWithFix({
+			severity,
+			attribute,
+			...isDefined(message) && { message },
+			...isDefined(diagnostic) && { diagnostic: diagnostic(context) },
+			fix
+		})];
+	};
+	return defineRuleMetadata(rule, {
+		...isDefined(readsProps) && { readsProps },
+		...isDefined(tags) && { tags }
+	});
+}
+//#endregion
+//#region ../../lib/contract/src/children/get-type-name.ts
+function getTypeName(value) {
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	const primitive = typeof value;
+	if (primitive !== "object") return primitive;
+	const name = value.constructor?.name;
+	return isString(name) && name !== "Object" ? name : "object";
+}
+//#endregion
+//#region ../../lib/contract/src/children/normalize-child-rule.ts
+function normalizeCardinality(input, impliesSingleton) {
+	const min = input?.min ?? 0;
+	const max = input?.max ?? (impliesSingleton ? 1 : Infinity);
+	if (min === 0 && max === Infinity) return { kind: "unbounded" };
+	if (min > max) throw new RangeError(`normalizeChildRule: min (${min}) cannot exceed max (${max})`);
+	return {
+		kind: "bounded",
+		min,
+		max
+	};
+}
+function normalizeChildRule(rule) {
+	const position = rule.position ?? "any";
+	const impliesSingleton = position === "first" || position === "last";
+	const cardinality = normalizeCardinality(rule.cardinality, impliesSingleton);
+	if (impliesSingleton && (cardinality.kind === "unbounded" || cardinality.max > 1)) throw new RangeError(`normalizeChildRule: rule "${rule.name}" sets position="${position}" with an unbounded or >1 max — position="first"|"last" implies max=1.`);
+	return {
+		...rule,
+		position,
+		cardinality
+	};
+}
+//#endregion
+//#region ../../lib/contract/src/children/rules-matcher.ts
+/** Reads child.type without assuming a framework — works for React elements and Vue vnodes. */
+function getChildType(child) {
+	if (!isObject(child) || !("type" in child)) return void 0;
+	return child.type;
+}
+/**
+* Separates rules into an O(1) type-dispatch index and a linear-scan remainder.
+*
+* Rules without a type field go straight to untypedIndices.
+* Rules whose type is shared with another rule are removed from the index and
+* demoted to untypedIndices — the linear path handles ambiguous multi-matches
+* correctly, the index cannot.
+*
+* INVARIANT: a rule with a unique `type` matches on `child.type === rule.type` alone — its
+* `match` predicate is **not** called on the fast path. A rule whose `match` needs to narrow
+* further than its `type` (e.g. also on `child.props`) must therefore either omit `type` (linear
+* path) or share it with another rule (demoted). See `ChildRuleInput`.
+*/
+function buildPartialIndex(rules) {
+	const typeIndex = /* @__PURE__ */ new Map();
+	const duplicateTypes = /* @__PURE__ */ new Set();
+	const untypedIndices = [];
+	iterate.forEach(rules, (rule, ri) => {
+		const t = rule.type;
+		if (t === void 0) untypedIndices.push(ri);
+		else if (typeIndex.has(t)) duplicateTypes.add(t);
+		else typeIndex.set(t, ri);
+	});
+	if (duplicateTypes.size > 0) {
+		iterate.forEachSet(duplicateTypes, (t) => {
+			typeIndex.delete(t);
+		});
+		iterate.forEach(rules, (rule, ri) => {
+			if (duplicateTypes.has(rule.type)) untypedIndices.push(ri);
+		});
+	}
+	return {
+		typeIndex,
+		untypedIndices
+	};
+}
+var RuleMatcher = class {
+	#rules;
+	#typeIndex;
+	#untypedIndices;
+	constructor(rules) {
+		this.#rules = rules;
+		const { typeIndex, untypedIndices } = buildPartialIndex(rules);
+		this.#typeIndex = typeIndex;
+		this.#untypedIndices = untypedIndices;
+	}
+	match(children) {
+		const forward = /* @__PURE__ */ new Map();
+		const reverse = /* @__PURE__ */ new Map();
+		const unexpectedIndices = /* @__PURE__ */ new Set();
+		const ambiguousIndices = /* @__PURE__ */ new Set();
+		iterate.forEach(this.#rules, (_, ri) => {
+			reverse.set(ri, /* @__PURE__ */ new Set());
+		});
+		iterate.forEach(children, (child, ci) => {
+			const t = getChildType(child);
+			if (t !== void 0) {
+				const ri = this.#typeIndex.get(t);
+				if (ri !== void 0) {
+					let childEntry = forward.get(ci);
+					if (!childEntry) {
+						childEntry = /* @__PURE__ */ new Set();
+						forward.set(ci, childEntry);
+					}
+					childEntry.add(ri);
+					reverse.get(ri).add(ci);
+				}
+			}
+			iterate.forEach(this.#untypedIndices, (ri) => {
+				if (!this.#rules[ri].match(child)) return;
+				let childEntry = forward.get(ci);
+				if (!childEntry) {
+					childEntry = /* @__PURE__ */ new Set();
+					forward.set(ci, childEntry);
+				}
+				childEntry.add(ri);
+				reverse.get(ri).add(ci);
+			});
+			const entry = forward.get(ci);
+			if (!entry) unexpectedIndices.add(ci);
+			else if (entry.size > 1) ambiguousIndices.add(ci);
+		});
+		return {
+			matrix: { childToRules: {
+				forward,
+				reverse
+			} },
+			unexpectedIndices,
+			ambiguousIndices
+		};
+	}
+};
+//#endregion
+//#region ../../lib/contract/src/children/rule-validator.ts
+var RuleValidator = class RuleValidator extends InvariantBase {
+	#context;
+	constructor(context, diagnostics) {
+		super(diagnostics);
+		this.#context = context;
+	}
+	validate(rules, matrix, childCount) {
+		const firstIndex = 0;
+		const lastIndex = childCount - 1;
+		iterate.forEach(rules, (rule, ri) => {
+			const matches = matrix.childToRules.reverse.get(ri);
+			const matchCount = matches.size;
+			this.#validateCardinality(rule, matchCount);
+			if (matchCount === 0) return;
+			this.#validatePositions(rule, matches, firstIndex, lastIndex);
+		});
+	}
+	#validateCardinality(rule, matchCount) {
+		const { cardinality, name } = rule;
+		if (cardinality.kind !== "bounded") return;
+		const { min, max } = cardinality;
+		if (matchCount < min) {
+			this.violate(ContractDiagnostics.cardinalityMin(name, min, this.#context));
+			return;
+		}
+		if (matchCount > max) this.violate(ContractDiagnostics.cardinalityMax(name, max, this.#context));
+	}
+	#validatePositions(rule, matches, firstIndex, lastIndex) {
+		const { name, position } = rule;
+		iterate.forEachSet(matches, (index) => {
+			if (RuleValidator.#isValidPosition(index, position, firstIndex, lastIndex)) return;
+			this.violate(ContractDiagnostics.positionViolation(name, position, index, this.#context));
+		});
+	}
+	static #isValidPosition(matchIndex, position, firstIndex, lastIndex) {
+		switch (position) {
+			case "first": return matchIndex === firstIndex;
+			case "last": return matchIndex === lastIndex;
+			case "any": return true;
+			default: return assertNever(position);
+		}
+	}
+};
+//#endregion
+//#region ../../lib/contract/src/children/children-evaluator.ts
+const isTextLike = (child) => isString(child) || isNumber(child);
+var ChildrenEvaluator = class extends InvariantBase {
+	#context;
+	/** Rules with a static cardinality — normalized once, reused on every evaluate() call. */
+	#staticRules;
+	/** Rules whose cardinality is `dynamic(...)` — re-resolved against a ChildRuleContext per call. */
+	#dynamicRuleInputs;
+	#matcher;
+	#ruleValidator;
+	#exclusiveChildren;
+	#allowText;
+	constructor(rules, diagnostics, context = "Component", options = {}) {
+		super(diagnostics);
+		this.#context = context;
+		this.#exclusiveChildren = options.exclusiveChildren ?? false;
+		this.#allowText = options.allowText ?? true;
+		const staticRuleInputs = [];
+		const dynamicRuleInputs = [];
+		iterate.forEach(rules, (rule) => {
+			if (isDynamicRule(rule.cardinality)) dynamicRuleInputs.push(rule);
+			else staticRuleInputs.push(rule);
+		});
+		this.#dynamicRuleInputs = dynamicRuleInputs;
+		this.#staticRules = staticRuleInputs.map((r) => normalizeChildRule(r));
+		this.#ruleValidator = new RuleValidator(context, diagnostics);
+		this.#matcher = this.#dynamicRuleInputs.length === 0 ? new RuleMatcher(this.#staticRules) : void 0;
+	}
+	/**
+	* @param context Required when any rule has a `dynamic(...)` cardinality —
+	*   supplies the resolved tag/props those rules are evaluated against.
+	*/
+	evaluate(children, context) {
+		if (!this.warnActive) return;
+		const { rules, matcher } = this.#resolveRules(context);
+		const { matrix, unexpectedIndices: rawUnexpectedIndices, ambiguousIndices } = matcher.match(children);
+		this.#ruleValidator.validate(rules, matrix, children.length);
+		const unexpectedIndices = new Set([...rawUnexpectedIndices].filter((ci) => isTextLike(children[ci]) ? this.#allowText === false : this.#exclusiveChildren));
+		if (unexpectedIndices.size === 0 && ambiguousIndices.size === 0) return;
+		const violating = [...unexpectedIndices, ...ambiguousIndices].sort((a, b) => a - b);
+		iterate.forEach(violating, (ci) => {
+			const typeName = getTypeName(children[ci]);
+			if (unexpectedIndices.has(ci)) this.violate(ContractDiagnostics.unexpectedChild(typeName, ci, this.#context));
+			else {
+				const names = [...matrix.childToRules.forward.get(ci)].map((ri) => rules[ri]?.name ?? `#${ri}`);
+				this.violate(ContractDiagnostics.ambiguousChild(typeName, ci, names, this.#context));
+			}
+		});
+	}
+	#resolveRules(context) {
+		if (this.#dynamicRuleInputs.length === 0) return {
+			rules: this.#staticRules,
+			matcher: this.#matcher
+		};
+		if (context === void 0) throw new RangeError(`ChildrenEvaluator [${this.#context}]: rule(s) have a dynamic(...) cardinality — evaluate() requires a context argument to resolve them.`);
+		const resolvedDynamicRules = this.#dynamicRuleInputs.map((r) => {
+			const cardinality = resolveRule(r.cardinality, context);
+			return normalizeChildRule({
+				...r,
+				cardinality
+			});
+		});
+		const rules = [...this.#staticRules, ...resolvedDynamicRules];
+		return {
+			rules,
+			matcher: new RuleMatcher(rules)
+		};
+	}
+};
+//#endregion
+//#region ../../lib/contract/src/props/make-state-normalizer.ts
+/**
+* Builds one of the eight built-in state-prop normalizers. A truthy state injects the `aria-*` /
+* `data-*` pair; the false state is handled per `falseState`; an explicitly supplied `aria-*` /
+* `data-*` value is never overwritten (the normalizer only fills when the key is `undefined`).
+*/
+function makeStateNormalizer({ state, aria, data, falseState = "omit" }) {
+	return (props) => {
+		const value = props[state];
+		if (falseState === "synthesize" ? isNullish(value) : !value) return {};
+		const out = {};
+		if (isUndefined(props[aria])) out[aria] = value ? "true" : "false";
+		if (value && isUndefined(props[data])) out[data] = "";
+		return out;
+	};
+}
+makeStateNormalizer({
+	state: "active",
+	aria: "aria-current",
+	data: "data-active"
+});
+const disabledProps = makeStateNormalizer({
+	state: "disabled",
+	aria: "aria-disabled",
+	data: "data-disabled"
+});
+makeStateNormalizer({
+	state: "expanded",
+	aria: "aria-expanded",
+	data: "data-expanded",
+	falseState: "synthesize"
+});
+const invalidProps = makeStateNormalizer({
+	state: "invalid",
+	aria: "aria-invalid",
+	data: "data-invalid"
+});
+makeStateNormalizer({
+	state: "loading",
+	aria: "aria-busy",
+	data: "data-loading"
+});
+makeStateNormalizer({
+	state: "pressed",
+	aria: "aria-pressed",
+	data: "data-pressed",
+	falseState: "synthesize"
+});
+const readonlyProps = makeStateNormalizer({
+	state: "readOnly",
+	aria: "aria-readonly",
+	data: "data-readonly"
+});
+makeStateNormalizer({
+	state: "selected",
+	aria: "aria-selected",
+	data: "data-selected",
+	falseState: "synthesize"
+});
+//#endregion
+//#region ../core/src/html/contracts/categories.ts
+/**
+* HTML content-model tag groups shared across multiple contracts.
+*
+* Shared here means referenced by more than one contract, or by the top-level
+* tag → contract map in `index.ts`. Contract-specific tag lists that only one
+* module needs (e.g. `pContract`'s block-level blocklist) stay local to that module.
+*/
+/**
+* HTML elements classified as metadata content.
+*
+* Metadata content (`<script>` and `<template>`) is permitted in almost every
+* HTML content model and is therefore accepted by many contracts.
+*/
+const METADATA_TAGS = ["script", "template"];
+/**
+* Elements whose content model is character data only.
+*
+* Includes raw text elements (`<script>`, `<style>`), escapable raw text
+* elements (`<textarea>`, `<title>`), and `<option>`.
+*/
+const TEXT_ONLY_TAGS = [
+	"option",
+	"script",
+	"style",
+	"textarea",
+	"title"
+];
+/**
+* HTML elements with implicit landmark roles.
+*
+* `<section>` and `<form>` are intentionally excluded because their landmark
+* semantics depend on having an accessible name.
+*/
+const LANDMARK_TAGS = [
+	"article",
+	"aside",
+	"footer",
+	"header",
+	"main",
+	"nav"
+];
+/**
+* Interactive content as defined by the HTML Living Standard.
+*
+* Used to enforce restrictions such as "must not contain interactive content"
+* for elements like `<button>` and `<a>`.
+*
+* Only direct children are checked; descendant traversal is outside the scope
+* of the contract engine.
+*/
+const INTERACTIVE_CONTENT_TAGS = [
+	"a",
+	"button",
+	"input",
+	"select",
+	"textarea",
+	"label"
+];
+/**
+* HTML labelable form controls.
+*
+* Used by `<label>` to validate implicit and explicit control associations.
+* `input[type="hidden"]` is excluded separately because labelability depends
+* on element attributes rather than tag name alone.
+*/
+const LABELABLE_TAGS = [
+	"button",
+	"input",
+	"meter",
+	"output",
+	"progress",
+	"select",
+	"textarea"
+];
+/**
+* Interactive elements that are never labelable.
+*
+* Used by `labelContract` to enforce the HTML rule that a `<label>` may contain
+* no interactive content other than its labeled control.
+*
+* Conditionally interactive elements (for example, `audio[controls]`) are
+* excluded because their interactivity depends on attributes rather than tag
+* name alone.
+*/
+const OTHER_INTERACTIVE_TAGS = [
+	"a",
+	"details",
+	"embed",
+	"iframe"
+];
+/**
+* Elements that implicitly terminate a `<p>` element.
+*
+* This contract intentionally uses a blocklist rather than attempting to model
+* the full phrasing-content category. Missing an obscure block-level element is
+* preferable to rejecting valid inline content because the allowlist is
+* incomplete.
+*/
+const P_BLOCKED_TAGS = [
+	"address",
+	"article",
+	"aside",
+	"blockquote",
+	"details",
+	"dialog",
+	"div",
+	"dl",
+	"fieldset",
+	"figure",
+	"footer",
+	"form",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"header",
+	"hr",
+	"main",
+	"nav",
+	"ol",
+	"p",
+	"pre",
+	"section",
+	"table",
+	"ul"
+];
+//#endregion
+//#region ../core/src/html/anchor-rules.ts
+const DANGEROUS_URL_SCHEMES = [
+	"javascript:",
+	"data:",
+	"vbscript:"
+];
+function normalizeForSchemeCheck(href) {
+	return href.replace(/[\x00-\x20]/g, "").toLowerCase();
+}
+function isDangerousUrl(href) {
+	if (!isString(href)) return false;
+	const normalized = normalizeForSchemeCheck(href);
+	return DANGEROUS_URL_SCHEMES.some((scheme) => normalized.startsWith(scheme));
+}
+const ANCHOR_RULES = [
+	createRemoveAttributeRule("href", {
+		when: ({ props }) => isDangerousUrl(props.href),
+		severity: "warning",
+		diagnostic: ({ props }) => HtmlDiagnostics.anchor.dangerousHref(props.href),
+		readsProps: ["href"],
+		tags: ["a"]
+	}),
+	Object.assign(({ props }) => {
+		if (props.role !== "button" || !isString(props.href) || props.href.length === 0) return [];
+		const diagnostic = AnchorAccessibilityDiagnostics.roleButtonWithHref();
+		return [invalidWithoutFix({
+			severity: diagnostic.severity,
+			attribute: "role",
+			diagnostic
+		})];
+	}, {
+		readsProps: ["role", "href"],
+		tags: ["a"]
+	}),
+	Object.assign(({ props }) => {
+		const ariaDisabled = props["aria-disabled"];
+		const isDisabled = ariaDisabled === true || ariaDisabled === "true";
+		const hasHref = isString(props.href) && props.href.length > 0;
+		if (!isDisabled || !hasHref) return [];
+		const diagnostic = AnchorAccessibilityDiagnostics.ariaDisabledInert();
+		return [invalidWithoutFix({
+			severity: diagnostic.severity,
+			attribute: "aria-disabled",
+			diagnostic
+		})];
+	}, {
+		readsProps: ["aria-disabled", "href"],
+		tags: ["a"]
+	})
+];
+//#endregion
+//#region ../core/src/html/spec/vocabulary/input.ts
+const TEXT_INPUT_TYPES = [
+	"text",
+	"search",
+	"url",
+	"tel",
+	"email",
+	"password"
+];
+const NUMERIC_INPUT_TYPES = [
+	"number",
+	"range",
+	"date",
+	"month",
+	"week",
+	"time",
+	"datetime-local"
+];
+const HTML_INPUT_TYPES = /* @__PURE__ */ new Set([
+	...TEXT_INPUT_TYPES,
+	...NUMERIC_INPUT_TYPES,
+	"checkbox",
+	"radio",
+	"file",
+	"color",
+	"hidden",
+	"button",
+	"submit",
+	"reset",
+	"image"
+]);
+//#endregion
+//#region ../core/src/html/spec/attributes/input.ts
+const INPUT_ATTRIBUTE_TYPE_POLICIES = [
+	{
+		attribute: "checked",
+		allowedTypes: ["checkbox", "radio"]
+	},
+	{
+		attribute: "multiple",
+		allowedTypes: ["email", "file"]
+	},
+	{
+		attribute: "maxLength",
+		allowedTypes: TEXT_INPUT_TYPES
+	},
+	{
+		attribute: "minLength",
+		allowedTypes: TEXT_INPUT_TYPES
+	},
+	{
+		attribute: "pattern",
+		allowedTypes: TEXT_INPUT_TYPES
+	},
+	{
+		attribute: "min",
+		allowedTypes: NUMERIC_INPUT_TYPES
+	},
+	{
+		attribute: "max",
+		allowedTypes: NUMERIC_INPUT_TYPES
+	},
+	{
+		attribute: "step",
+		allowedTypes: NUMERIC_INPUT_TYPES
+	},
+	{
+		attribute: "accept",
+		allowedTypes: ["file"]
+	},
+	{
+		attribute: "capture",
+		allowedTypes: ["file"]
+	},
+	{
+		attribute: "size",
+		allowedTypes: TEXT_INPUT_TYPES
+	},
+	{
+		attribute: "alt",
+		allowedTypes: ["image"]
+	},
+	{
+		attribute: "height",
+		allowedTypes: ["image"]
+	},
+	{
+		attribute: "width",
+		allowedTypes: ["image"]
+	}
+];
+//#endregion
+//#region ../core/src/html/spec/constraints/input.ts
+const REQUIRED_READONLY_CONFLICT = {
+	props: ["required", "readOnly"],
+	diagnostic: () => InputAccessibilityDiagnostics.requiredReadOnlyConflict()
+};
+const INPUT_MUTUALLY_EXCLUSIVE_POLICIES = [REQUIRED_READONLY_CONFLICT];
+//#endregion
+//#region ../core/src/html/spec/validators/attribute-type-validator.ts
+const DEFAULT_INPUT_TYPE = "text";
+function createInputAttributeTypeRule({ attribute, allowedTypes }) {
+	const rule = ({ tag, props, variantKeys }) => {
+		if (tag !== "input" || !(attribute in props)) return [];
+		if (variantKeys?.has(attribute)) return [];
+		const type = typeof props.type === "string" ? props.type : DEFAULT_INPUT_TYPE;
+		if (allowedTypes.includes(type)) return [];
+		const diagnostic = HtmlDiagnostics.input.attributeIgnoredForType(attribute, type, allowedTypes);
+		return [{
+			valid: false,
+			fixable: true,
+			severity: diagnostic.severity,
+			fix: removeAttributeFix(attribute),
+			diagnostic
+		}];
+	};
+	return Object.assign(rule, {
+		readsProps: ["type", attribute],
+		tags: ["input"]
+	});
+}
+//#endregion
+//#region ../core/src/html/spec/validators/mutually-exclusive-validator.ts
+function isBooleanAttrSet(value) {
+	return value !== void 0 && value !== null && value !== false;
+}
+function createMutuallyExclusiveRule({ props: conflictingProps, diagnostic: createDiagnostic }) {
+	const [first, second] = conflictingProps;
+	const rule = ({ tag, props }) => {
+		if (tag !== "input" || !isBooleanAttrSet(props[first]) || !isBooleanAttrSet(props[second])) return [];
+		const diagnostic = createDiagnostic();
+		return [{
+			valid: false,
+			fixable: false,
+			severity: diagnostic.severity,
+			diagnostic
+		}];
+	};
+	return Object.assign(rule, {
+		readsProps: conflictingProps,
+		tags: ["input"]
+	});
+}
+//#endregion
+//#region ../core/src/html/input-rules.ts
+const policyByAttribute = Object.fromEntries(INPUT_ATTRIBUTE_TYPE_POLICIES.map((policy) => [policy.attribute, policy]));
+function policyFor(attribute) {
+	return policyByAttribute[attribute];
+}
+const supportedInputTypeRule = Object.assign(({ tag, props }) => {
+	if (tag !== "input" || typeof props.type !== "string") return [];
+	const type = props.type;
+	if (HTML_INPUT_TYPES.has(type)) return [];
+	const diagnostic = HtmlDiagnostics.input.unsupportedType(type);
+	return [{
+		valid: false,
+		fixable: false,
+		severity: diagnostic.severity,
+		diagnostic
+	}];
+}, {
+	readsProps: ["type"],
+	tags: ["input"]
+});
+const checkedRequiresCheckableTypeRule = createInputAttributeTypeRule(policyFor("checked"));
+const multipleRequiresSupportedTypeRule = createInputAttributeTypeRule(policyFor("multiple"));
+const maxLengthRequiresTextTypeRule = createInputAttributeTypeRule(policyFor("maxLength"));
+const minLengthRequiresTextTypeRule = createInputAttributeTypeRule(policyFor("minLength"));
+const patternRequiresTextTypeRule = createInputAttributeTypeRule(policyFor("pattern"));
+const minRequiresNumericTypeRule = createInputAttributeTypeRule(policyFor("min"));
+const maxRequiresNumericTypeRule = createInputAttributeTypeRule(policyFor("max"));
+const stepRequiresNumericTypeRule = createInputAttributeTypeRule(policyFor("step"));
+const acceptRequiresFileTypeRule = createInputAttributeTypeRule(policyFor("accept"));
+const captureRequiresFileTypeRule = createInputAttributeTypeRule(policyFor("capture"));
+const sizeRequiresTextTypeRule = createInputAttributeTypeRule(policyFor("size"));
+const altRequiresImageTypeRule = createInputAttributeTypeRule(policyFor("alt"));
+const heightRequiresImageTypeRule = createInputAttributeTypeRule(policyFor("height"));
+const widthRequiresImageTypeRule = createInputAttributeTypeRule(policyFor("width"));
+const inputAccessibleNameRule = Object.assign(({ tag, props }) => {
+	if (tag !== "input" || props.type === "hidden") return [];
+	if ("aria-label" in props || "aria-labelledby" in props) return [];
+	const diagnostic = typeof props.placeholder === "string" && props.placeholder.length > 0 ? InputAccessibilityDiagnostics.placeholderIsNotLabel() : InputAccessibilityDiagnostics.missingAccessibleName();
+	return [{
+		valid: false,
+		fixable: false,
+		severity: diagnostic.severity,
+		diagnostic
+	}];
+}, {
+	readsProps: [
+		"type",
+		"aria-label",
+		"aria-labelledby",
+		"placeholder"
+	],
+	tags: ["input"]
+});
+const PASSWORD_AUTOCOMPLETE_VALUES = ["current-password", "new-password"];
+const INPUT_RULES = [
+	supportedInputTypeRule,
+	checkedRequiresCheckableTypeRule,
+	multipleRequiresSupportedTypeRule,
+	maxLengthRequiresTextTypeRule,
+	minLengthRequiresTextTypeRule,
+	patternRequiresTextTypeRule,
+	minRequiresNumericTypeRule,
+	maxRequiresNumericTypeRule,
+	stepRequiresNumericTypeRule,
+	acceptRequiresFileTypeRule,
+	captureRequiresFileTypeRule,
+	sizeRequiresTextTypeRule,
+	altRequiresImageTypeRule,
+	heightRequiresImageTypeRule,
+	widthRequiresImageTypeRule,
+	inputAccessibleNameRule,
+	Object.assign(({ tag, props }) => {
+		if (tag !== "input" || props.type !== "password") return [];
+		const autoComplete = props.autoComplete;
+		const tokens = typeof autoComplete === "string" ? autoComplete.split(" ") : [];
+		if (PASSWORD_AUTOCOMPLETE_VALUES.some((value) => tokens.includes(value))) return [];
+		const diagnostic = InputAccessibilityDiagnostics.passwordMissingAutocomplete();
+		return [{
+			valid: false,
+			fixable: false,
+			severity: diagnostic.severity,
+			diagnostic
+		}];
+	}, {
+		readsProps: ["type", "autoComplete"],
+		tags: ["input"]
+	}),
+	createMutuallyExclusiveRule(REQUIRED_READONLY_CONFLICT)
+];
+//#endregion
+//#region ../core/src/html/spec/types.ts
+function resolveAllowedRoles(spec, props) {
+	const policy = spec.allowedRoles;
+	if (!policy) return void 0;
+	switch (policy.kind) {
+		case "fixed": return policy.roles;
+		case "byProp": {
+			const raw = props[policy.prop];
+			const value = typeof raw === "string" && raw in policy.map ? raw : policy.fallback;
+			return policy.map[value];
+		}
+		case "dynamic": return policy.resolve({ props });
+	}
+}
+//#endregion
+//#region ../core/src/html/spec/roles/input.ts
+const ALLOWED_INPUT_ROLES = {
+	checkbox: [
+		"menuitemcheckbox",
+		"option",
+		"switch",
+		"button"
+	],
+	radio: ["menuitemradio"],
+	range: [],
+	number: [],
+	search: [],
+	text: [
+		"combobox",
+		"searchbox",
+		"spinbutton"
+	],
+	email: [],
+	tel: [],
+	url: [],
+	button: [
+		"checkbox",
+		"combobox",
+		"gridcell",
+		"link",
+		"menuitem",
+		"menuitemcheckbox",
+		"menuitemradio",
+		"option",
+		"radio",
+		"separator",
+		"slider",
+		"switch",
+		"tab",
+		"treeitem"
+	],
+	submit: [
+		"checkbox",
+		"combobox",
+		"gridcell",
+		"link",
+		"menuitem",
+		"menuitemcheckbox",
+		"menuitemradio",
+		"option",
+		"radio",
+		"separator",
+		"slider",
+		"switch",
+		"tab",
+		"treeitem"
+	],
+	reset: [
+		"checkbox",
+		"combobox",
+		"gridcell",
+		"link",
+		"menuitem",
+		"menuitemcheckbox",
+		"menuitemradio",
+		"option",
+		"radio",
+		"separator",
+		"slider",
+		"switch",
+		"tab",
+		"treeitem"
+	],
+	image: [
+		"checkbox",
+		"gridcell",
+		"link",
+		"menuitem",
+		"menuitemcheckbox",
+		"menuitemradio",
+		"option",
+		"radio",
+		"separator",
+		"slider",
+		"switch",
+		"tab",
+		"treeitem"
+	],
+	hidden: []
+};
+//#endregion
+//#region ../core/src/html/spec/elements/input.ts
+const LIST_ELIGIBLE_TYPES = /* @__PURE__ */ new Set([
+	"text",
+	"search",
+	"tel",
+	"url",
+	"email"
+]);
+function rolesForType(type) {
+	return ALLOWED_INPUT_ROLES[type in ALLOWED_INPUT_ROLES ? type : "text"];
+}
+const inputElementSpec = {
+	tag: "input",
+	allowedRoles: {
+		kind: "dynamic",
+		resolve: ({ props }) => {
+			const type = isString(props.type) ? props.type : "text";
+			if (isNonNull(props.list) && LIST_ELIGIBLE_TYPES.has(type)) return [];
+			return rolesForType(type);
+		}
+	},
+	attributes: INPUT_ATTRIBUTE_TYPE_POLICIES,
+	mutuallyExclusive: INPUT_MUTUALLY_EXCLUSIVE_POLICIES
+};
+//#endregion
+//#region ../core/src/html/spec/roles/img.ts
+const IMG_DECORATIVE_ROLES = ["none", "presentation"];
+const IMG_NAMED_ROLES = [
+	"button",
+	"checkbox",
+	"link",
+	"math",
+	"menuitem",
+	"menuitemcheckbox",
+	"menuitemradio",
+	"meter",
+	"option",
+	"progressbar",
+	"radio",
+	"scrollbar",
+	"separator",
+	"slider",
+	"switch",
+	"tab",
+	"treeitem"
+];
+//#endregion
+//#region ../core/src/html/spec/elements/img.ts
+const imgElementSpec = {
+	tag: "img",
+	allowedRoles: {
+		kind: "dynamic",
+		resolve: ({ props }) => {
+			if (isNullish(props.alt)) return IMG_DECORATIVE_ROLES;
+			return props.alt === "" ? [] : IMG_NAMED_ROLES;
+		}
+	}
+};
+//#endregion
+//#region ../core/src/html/spec/roles/select.ts
+const ALLOWED_SELECT_ROLES = ["menu"];
+//#endregion
+//#region ../core/src/html/spec/elements/select.ts
+function isListBoxSelect(props) {
+	const { multiple, size } = props;
+	if (isNonNull(multiple) && multiple !== false && (!isString(multiple) || multiple.toLowerCase() !== "false")) return true;
+	const parsed = isNumber(size) ? size : isString(size) ? Number(size) : NaN;
+	return Number.isFinite(parsed) && parsed > 1;
+}
+const selectElementSpec = {
+	tag: "select",
+	allowedRoles: {
+		kind: "dynamic",
+		resolve: ({ props }) => isListBoxSelect(props) ? [] : ALLOWED_SELECT_ROLES
+	}
+};
+//#endregion
+//#region ../core/src/html/spec/elements/table.ts
+const tableElementSpec = {
+	tag: "table",
+	allowedRoles: {
+		kind: "fixed",
+		roles: ["grid", "treegrid"]
+	}
+};
+//#endregion
+//#region ../core/src/html/role-restrictions.ts
+const ALLOWED_ROLES = {
+	article: [
+		"application",
+		"document",
+		"feed",
+		"main",
+		"none",
+		"presentation",
+		"region"
+	],
+	aside: [
+		"feed",
+		"none",
+		"note",
+		"presentation",
+		"region",
+		"search"
+	],
+	footer: [
+		"group",
+		"none",
+		"presentation"
+	],
+	header: [
+		"group",
+		"none",
+		"presentation"
+	],
+	main: [],
+	nav: [
+		"menu",
+		"menubar",
+		"none",
+		"presentation",
+		"tablist"
+	],
+	a: [
+		"button",
+		"checkbox",
+		"menuitem",
+		"menuitemcheckbox",
+		"menuitemradio",
+		"option",
+		"radio",
+		"switch",
+		"tab",
+		"treeitem"
+	],
+	button: [
+		"checkbox",
+		"combobox",
+		"gridcell",
+		"link",
+		"menuitem",
+		"menuitemcheckbox",
+		"menuitemradio",
+		"option",
+		"radio",
+		"separator",
+		"slider",
+		"switch",
+		"tab",
+		"treeitem"
+	],
+	h1: [
+		"tab",
+		"presentation",
+		"none"
+	],
+	h2: [
+		"tab",
+		"presentation",
+		"none"
+	],
+	h3: [
+		"tab",
+		"presentation",
+		"none"
+	],
+	h4: [
+		"tab",
+		"presentation",
+		"none"
+	],
+	h5: [
+		"tab",
+		"presentation",
+		"none"
+	],
+	h6: [
+		"tab",
+		"presentation",
+		"none"
+	],
+	ul: [
+		"group",
+		"listbox",
+		"menu",
+		"menubar",
+		"none",
+		"presentation",
+		"radiogroup",
+		"tablist",
+		"toolbar",
+		"tree"
+	],
+	ol: [
+		"group",
+		"listbox",
+		"menu",
+		"menubar",
+		"none",
+		"presentation",
+		"radiogroup",
+		"tablist",
+		"toolbar",
+		"tree"
+	],
+	li: [
+		"menuitem",
+		"menuitemcheckbox",
+		"menuitemradio",
+		"option",
+		"none",
+		"presentation",
+		"radio",
+		"separator",
+		"tab",
+		"treeitem"
+	],
+	dialog: ["alertdialog"],
+	fieldset: [
+		"none",
+		"presentation",
+		"radiogroup"
+	],
+	label: []
+};
+const ELEMENT_SPECS = {
+	input: inputElementSpec,
+	img: imgElementSpec,
+	select: selectElementSpec,
+	table: tableElementSpec
+};
+function getAllowedRoles(tag, props) {
+	const spec = ELEMENT_SPECS[tag];
+	if (spec) return resolveAllowedRoles(spec, props);
+	return ALLOWED_ROLES[tag];
+}
+const removeRoleFix = {
+	kind: "removeRole",
+	apply: ({ props }) => {
+		if (!("role" in props)) return {
+			applied: false,
+			next: props
+		};
+		const { role: _role, ...rest } = props;
+		return {
+			applied: true,
+			next: rest,
+			previous: props
+		};
+	}
+};
+const roleNotPermittedRule = Object.assign(({ tag, props, implicitRole }) => {
+	const role = props.role;
+	if (typeof role !== "string" || role.length === 0 || role === implicitRole) return [];
+	const allowed = getAllowedRoles(tag, props);
+	if (allowed === void 0 || allowed.includes(role)) return [];
+	const diagnostic = HtmlDiagnostics.roleNotPermitted(tag, role, allowed);
+	return [{
+		valid: false,
+		fixable: true,
+		severity: diagnostic.severity,
+		fix: removeRoleFix,
+		diagnostic
+	}];
+}, { readsProps: [
+	"role",
+	"type",
+	"alt",
+	"list",
+	"multiple",
+	"size"
+] });
+//#endregion
+//#region ../core/src/html/aria-rules.ts
+function defineAriaRule(tags, rule) {
+	return Object.assign(rule, { tags });
+}
+const LANDMARK_TAG_SET = new Set(LANDMARK_TAGS);
+const removeLandmarkRoleOverride = {
+	kind: "removeRole",
+	apply: ({ props }) => {
+		if (!("role" in props)) return {
+			applied: false,
+			next: props
+		};
+		const { role: _r, ...rest } = props;
+		return {
+			applied: true,
+			next: rest,
+			previous: props
+		};
+	}
+};
+const landmarkRoleRule = defineAriaRule(LANDMARK_TAGS, ({ tag, props, implicitRole }) => {
+	if (!LANDMARK_TAG_SET.has(tag) || !implicitRole) return [];
+	const { role } = props;
+	if (!role || role === implicitRole) return [];
+	const diagnostic = HtmlDiagnostics.landmarkRoleOverride(tag, implicitRole, role);
+	return [{
+		valid: false,
+		fixable: true,
+		severity: diagnostic.severity,
+		fix: removeLandmarkRoleOverride,
+		diagnostic
+	}];
+});
+function requireAccessibleName({ tag, props }) {
+	if ("aria-label" in props || "aria-labelledby" in props) return [];
+	return [{
+		valid: false,
+		fixable: false,
+		severity: "warning",
+		diagnostic: AriaDiagnostics.missingAccessibleName(tag)
+	}];
+}
+const NAMED_LANDMARK_TAGS = ["nav", "aside"];
+const NAMED_LANDMARK_TAG_SET = new Set(NAMED_LANDMARK_TAGS);
+const landmarkAccessibleNameRule = defineAriaRule(NAMED_LANDMARK_TAGS, (ctx) => {
+	if (!ctx.implicitRole || !NAMED_LANDMARK_TAG_SET.has(ctx.tag)) return [];
+	return requireAccessibleName(ctx);
+});
+const HTML_ARIA_RULES = [
+	landmarkRoleRule,
+	landmarkAccessibleNameRule,
+	roleNotPermittedRule,
+	...INPUT_RULES,
+	...ANCHOR_RULES
+];
+//#endregion
+//#region ../core/src/html/contracts/helpers.ts
+/** Narrows an unknown value to the minimal vnode shape used by contract helpers. */
+function isVNodeLike(child) {
+	return isObject(child) && "type" in child;
+}
+/**
+* Creates a matcher that accepts any element except the supplied HTML tags.
+*
+* Tag resolution is semantic-aware, so Praxis components are matched by their
+* resolved HTML tag rather than their component type.
+*/
+function isOpenContent(...blockedTags) {
+	const set = new Set(blockedTags);
+	return (child) => {
+		if (!isVNodeLike(child)) return false;
+		const tag = getTag(child);
+		return tag === void 0 || !set.has(tag);
+	};
+}
+const metadataMatch = isTag(...METADATA_TAGS);
+/** Creates a child rule matching HTML metadata content (`<script>` and `<template>`). */
+function metadata(name = "metadata") {
+	return {
+		name,
+		match: metadataMatch
+	};
+}
+/**
+* Creates an optional singleton child rule (`max: 1`).
+*
+* Used as the building block for positional variants such as `firstOptional()`.
+*/
+function optional(name, tag) {
+	return {
+		name,
+		match: isTag(tag),
+		cardinality: { max: 1 }
+	};
+}
+function firstOptional(name, tag) {
+	return {
+		...optional(name, tag),
+		position: "first"
+	};
+}
+/**
+* Creates an enforcement contract with the default diagnostics configuration.
+*/
+function contract(children, options) {
+	return {
+		diagnostics: warnDiagnostics,
+		children,
+		...options
+	};
+}
+/**
+* Creates a closed content model.
+*
+* Only the supplied child rules are permitted; all other children are rejected.
+*/
+function closedContract(children) {
+	return contract(children, { exclusiveChildren: true });
+}
+/** Creates an ARIA-only enforcement contract. */
+function ariaContract(aria) {
+	return {
+		diagnostics: warnDiagnostics,
+		aria
+	};
+}
+/**
+* Creates a contract with an optional leading child followed by open content.
+*
+* Used by elements such as `<details>` and `<fieldset>` whose first child has
+* special semantics.
+*/
+function firstChildContract(name, tag) {
+	return contract([firstOptional(name, tag), {
+		name: "content",
+		match: isOpenContent(tag)
+	}]);
+}
+/**
+* Returns a property from a vnode-like child, if present.
+*/
+function getChildProp(child, key) {
+	if (!isVNodeLike(child)) return void 0;
+	const { props } = child;
+	if (!isObject(props)) return void 0;
+	return Reflect.get(props, key);
+}
+//#endregion
+//#region ../core/src/html/contracts/aria/landmarks.ts
+/**
+* Elements with an unconditional landmark role (`<article>`, `<aside>`, `<footer>`,
+* `<header>`, `<main>`, `<nav>`).
+*
+* - `role="<implicit>"` → warning: redundant, removed (built-in engine behaviour).
+* - `role="<anything else>"` → error: overrides the fixed landmark, removed.
+* - `<nav>` and `<aside>` without an accessible name → warning (commonly multiplied).
+*/
+const landmarkContract = ariaContract([landmarkRoleRule, landmarkAccessibleNameRule]);
+//#endregion
+//#region ../core/src/html/contracts/aria/widgets.ts
+/**
+* `<dialog>` — must have an accessible name (aria-label or aria-labelledby).
+* APG: https://www.w3.org/WAI/ARIA/apg/patterns/dialog-modal/
+* Without a name, assistive technology cannot identify the dialog in the page outline
+* or when focus moves into it.
+*/
+const dialogContract = ariaContract([requireAccessibleName]);
+//#endregion
+//#region ../core/src/html/contracts/html/document.ts
+/**
+* `<head>` — metadata content only.
+*/
+const headContract = closedContract([{
+	name: "metadata",
+	match: isTag("base", "link", "meta", "noscript", "script", "style", "template", "title")
+}]);
+/**
+* `<html>` — one `<head>` and one `<body>`.
+*/
+const htmlContract = closedContract([{
+	name: "head",
+	match: isTag("head"),
+	cardinality: {
+		min: 1,
+		max: 1
+	},
+	position: "first"
+}, {
+	name: "body",
+	match: isTag("body"),
+	cardinality: {
+		min: 1,
+		max: 1
+	}
+}]);
+/**
+* Void elements — the HTML spec forbids any children, including text.
+*/
+const voidContract = contract([], {
+	exclusiveChildren: true,
+	allowText: false
+});
+/**
+* Raw text (`<script>`, `<style>`), escapable raw text (`<textarea>`, `<title>`), and
+* `<option>` — only text nodes (strings or numbers) are permitted as children. No
+* explicit rule is needed: `exclusiveChildren` rejects every element (nothing matches
+* the empty rule list) while `allowText` stays at its default `true`.
+*/
+const textOnlyContract = contract([], { exclusiveChildren: true });
+//#endregion
+//#region ../core/src/html/contracts/html/forms.ts
+/**
+* `<select>` — direct children must be `<option>`, `<optgroup>`, `<hr>`, `<script>`,
+* or `<template>`.
+*/
+const selectContract = closedContract([{
+	name: "option",
+	match: isTag("option", "optgroup", "hr", ...METADATA_TAGS)
+}]);
+/**
+* `<optgroup>` — direct children must be `<option>`, `<script>`, or `<template>`.
+*/
+const optgroupContract = closedContract([{
+	name: "option",
+	match: isTag("option", ...METADATA_TAGS)
+}]);
+/**
+* `<datalist>` — direct children must be `<option>`, `<script>`, or `<template>`.
+*/
+const datalistContract = closedContract([{
+	name: "option",
+	match: isTag("option", ...METADATA_TAGS)
+}]);
+/**
+* `<button>` — must not directly contain interactive content (`<a>`, another `<button>`,
+* `<input>`, `<select>`, `<textarea>`, or `<label>`) per the HTML5 spec.
+*/
+const buttonContract = closedContract([{
+	name: "content",
+	match: isOpenContent(...INTERACTIVE_CONTENT_TAGS)
+}]);
+/**
+* `<a>` — same interactive-content restriction as `<button>`: must not directly contain
+* `<a>`, `<button>`, `<input>`, `<select>`, `<textarea>`, or `<label>`.
+*/
+const anchorContract = closedContract([{
+	name: "content",
+	match: isOpenContent(...INTERACTIVE_CONTENT_TAGS)
+}]);
+const labelableTagMatch = isTag(...LABELABLE_TAGS);
+function isLabelableControl(child) {
+	if (!labelableTagMatch(child)) return false;
+	if (getTag(child) !== "input") return true;
+	const type = getChildProp(child, "type");
+	return !isString(type) || type !== "hidden";
+}
+function hasAccessibleNameProp(props) {
+	return "aria-label" in props || "aria-labelledby" in props;
+}
+function isNonEmptyTextChild(child) {
+	if (isNumber(child)) return true;
+	return isString(child) && child.trim().length > 0;
+}
+/**
+* `<label>` — at most one labelable form control descendant (`<button>`, `<input>`
+* excluding `type="hidden"`, `<meter>`, `<output>`, `<progress>`, `<select>`, `<textarea>`);
+* a nested `<label>` is rejected outright, as is any other interactive content (`<a>`,
+* `<details>`, `<embed>`, `<iframe>`) that isn't the labeled control; any other phrasing
+* content is permitted. Requires an accessible name: either `aria-label`/`aria-labelledby`,
+* or visible (non-whitespace) text among its direct children.
+*
+* The text check only looks at direct children (matching every other rule in this
+* contract, and the engine's own model — it doesn't walk into a descendant control to
+* find, say, an `<option>`'s text), so a label whose only content is a nested element
+* with its own accessible name (e.g. `<label><input type="image" alt="Submit" /></label>`)
+* still reports as missing a name. That's a known, narrower check than the full HTML AAM
+* accessible-name computation, not a bug.
+*/
+const labelContract = contract([
+	{
+		name: "control",
+		match: isLabelableControl,
+		cardinality: { max: 1 }
+	},
+	{
+		name: "nested-label",
+		match: isTag("label"),
+		cardinality: { max: 0 }
+	},
+	{
+		name: "other-interactive-content",
+		match: isTag(...OTHER_INTERACTIVE_TAGS),
+		cardinality: { max: 0 }
+	},
+	{
+		name: "accessible-name",
+		match: isNonEmptyTextChild,
+		cardinality: dynamic((ctx) => hasAccessibleNameProp(ctx.props) ? { min: 0 } : { min: 1 })
+	}
+]);
+//#endregion
+//#region ../core/src/html/contracts/html/grouping.ts
+/**
+* `<details>` — permits an optional leading `<summary>` followed by flow content.
+*/
+const detailsContract = firstChildContract("summary", "summary");
+/**
+* `<fieldset>` — permits an optional leading `<legend>` followed by flow content.
+*/
+const fieldsetContract = firstChildContract("legend", "legend");
+//#endregion
+//#region ../core/src/html/contracts/html/lists.ts
+/**
+* `<ul>`, `<ol>`, `<menu>` — direct children must be `<li>`, `<script>`, or `<template>`.
+*/
+const listContract = closedContract([{
+	name: "list-item",
+	match: isTag("li", ...METADATA_TAGS)
+}]);
+/**
+* `<dl>` — direct children must be `<dt>`, `<dd>`, `<div>` (as group wrapper),
+* `<script>`, or `<template>`.
+*/
+const dlContract = closedContract([
+	{
+		name: "term",
+		match: isTag("dt")
+	},
+	{
+		name: "description",
+		match: isTag("dd")
+	},
+	{
+		name: "group",
+		match: isTag("div")
+	},
+	metadata()
+]);
+//#endregion
+//#region ../core/src/html/contracts/html/media.ts
+/**
+* `<picture>` — permits zero or more `<source>` elements followed by a single
+* `<img>` fallback.
+*
+* `<img>` must be the final child.
+*/
+const pictureContract = closedContract([{
+	name: "source",
+	match: isTag("source", ...METADATA_TAGS)
+}, {
+	name: "image",
+	match: isTag("img"),
+	cardinality: {
+		min: 1,
+		max: 1
+	},
+	position: "last"
+}]);
+/**
+* `<figure>` — permits at most one `<figcaption>` and arbitrary flow content.
+*
+* The `<figcaption>` may appear as either the first or last child.
+*/
+const figureContract = contract([{
+	name: "caption",
+	match: isTag("figcaption"),
+	cardinality: { max: 1 }
+}, {
+	name: "content",
+	match: isOpenContent("figcaption")
+}]);
+/**
+* `<object>` — permits `<param>` elements followed by transparent fallback
+* content.
+*
+* Relative ordering is not currently validated.
+*/
+const objectContract = contract([{
+	name: "param",
+	match: isTag("param")
+}, {
+	name: "content",
+	match: isOpenContent("param")
+}]);
+/**
+* `<audio>` and `<video>` — permit media source definitions, timed text tracks,
+* metadata, and fallback content.
+*/
+const mediaContract = contract([
+	{
+		name: "source",
+		match: isTag("source")
+	},
+	{
+		name: "track",
+		match: isTag("track")
+	},
+	metadata(),
+	{
+		name: "content",
+		match: isOpenContent("source", "track", ...METADATA_TAGS)
+	}
+]);
+//#endregion
+//#region ../core/src/html/contracts/html/tables.ts
+/**
+* `<table>` — permits the HTML table sectioning elements as direct children.
+*
+* `<caption>` is optional and must be first. `<thead>` and `<tfoot>` may each
+* appear at most once.
+*
+* Relative ordering of the remaining sections is not currently validated.
+*/
+const tableContract = closedContract([
+	firstOptional("caption", "caption"),
+	{
+		name: "colgroup",
+		match: isTag("colgroup")
+	},
+	{
+		name: "thead",
+		match: isTag("thead"),
+		cardinality: { max: 1 }
+	},
+	{
+		name: "tbody",
+		match: isTag("tbody")
+	},
+	{
+		name: "tfoot",
+		match: isTag("tfoot"),
+		cardinality: { max: 1 }
+	},
+	{
+		name: "table-row",
+		match: isTag("tr", ...METADATA_TAGS)
+	}
+]);
+/**
+* `<thead>`, `<tbody>`, and `<tfoot>` — permit table rows as direct children.
+*/
+const tableBodyContract = closedContract([{
+	name: "table-row",
+	match: isTag("tr", ...METADATA_TAGS)
+}]);
+/**
+* `<tr>` — permits table cells as direct children.
+*/
+const tableRowContract = closedContract([{
+	name: "table-cell",
+	match: isTag("td", "th", ...METADATA_TAGS)
+}]);
+/**
+* `<colgroup>` — permits column definitions as direct children.
+*/
+const colgroupContract = closedContract([{
+	name: "column",
+	match: isTag("col", "template")
+}]);
+//#endregion
+//#region ../core/src/html/contracts/html/text.ts
+/**
+* `<p>` — permits phrasing content only.
+*
+* Implemented as a pragmatic blocklist of elements that terminate a paragraph.
+*/
+const pContract = closedContract([{
+	name: "content",
+	match: isOpenContent(...P_BLOCKED_TAGS)
+}]);
+//#endregion
+//#region ../core/src/html/contracts/build-map.ts
+/**
+* Builds a lookup table from grouped keys.
+*
+* Each key in a group is associated with the group's shared value. Used to
+* expand compact declarations into a flat lookup record.
+*/
+function buildMap(groups) {
+	return Object.fromEntries(groups.flatMap(([keys, value]) => keys.map((key) => [key, value])));
+}
+/**
+* Built-in HTML element contracts keyed by tag name.
+*
+* Pass a contract directly to `createContractComponent`:
+*
+* ```ts
+* const List = createContractComponent({
+*   tag: 'ul',
+*   enforcement: htmlContracts.ul,
+* })
+* ```
+*
+* Contracts default to `strict: 'warn'`. Override individual options by
+* spreading the contract into a new enforcement object.
+*/
+const htmlContracts = {
+	...buildMap([
+		[VOID_TAGS, voidContract],
+		[TEXT_ONLY_TAGS, textOnlyContract],
+		[LANDMARK_TAGS, landmarkContract],
+		[[
+			"ul",
+			"ol",
+			"menu"
+		], listContract],
+		[["audio", "video"], mediaContract],
+		[[
+			"thead",
+			"tbody",
+			"tfoot"
+		], tableBodyContract]
+	]),
+	table: tableContract,
+	tr: tableRowContract,
+	colgroup: colgroupContract,
+	dl: dlContract,
+	select: selectContract,
+	optgroup: optgroupContract,
+	datalist: datalistContract,
+	picture: pictureContract,
+	figure: figureContract,
+	details: detailsContract,
+	fieldset: fieldsetContract,
+	dialog: dialogContract,
+	object: objectContract,
+	button: buttonContract,
+	a: anchorContract,
+	label: labelContract,
+	p: pContract,
+	head: headContract,
+	html: htmlContract
+};
+//#endregion
+//#region ../core/src/html/evaluators.ts
+const htmlDiagnostics = warnDiagnostics;
+function buildEvaluatorMap() {
+	const map = /* @__PURE__ */ new Map();
+	iterate.forEachEntry(htmlContracts, (tag, { children, exclusiveChildren, allowText }) => {
+		if (children?.length || exclusiveChildren || allowText === false) map.set(tag, new ChildrenEvaluator(children ?? [], htmlDiagnostics, `<${tag}>`, {
+			exclusiveChildren,
+			allowText
+		}));
+	});
+	return map;
+}
+const HTML_EVALUATORS = buildEvaluatorMap();
+function getHtmlChildrenEvaluator(tag) {
+	return typeof tag === "string" ? HTML_EVALUATORS.get(tag) : void 0;
+}
+//#endregion
+//#region ../core/src/html/prop-normalizers.ts
+const HTML_FORM_NORMALIZERS = /* @__PURE__ */ new Map([
+	["button", [disabledProps]],
+	["input", [
+		disabledProps,
+		readonlyProps,
+		invalidProps
+	]],
+	["select", [disabledProps]],
+	["textarea", [disabledProps, readonlyProps]],
+	["fieldset", [disabledProps]],
+	["optgroup", [disabledProps]]
+]);
+function getHtmlPropNormalizers(tag) {
+	return typeof tag === "string" ? HTML_FORM_NORMALIZERS.get(tag) : void 0;
+}
+//#endregion
+//#region ../../lib/styling/src/cva.ts
+function cva$1(base, config) {
+	const fn = cva(base, config);
+	return (props) => cn(fn(props));
+}
+//#endregion
+//#region ../../lib/styling/src/static-class-resolver.ts
+var StaticClassResolver = class {
+	#baseClass;
+	#cache = new LRUCache(200);
+	#resolveTag;
+	constructor(baseClass, tagMap) {
+		this.#baseClass = Array.isArray(baseClass) ? baseClass.join(" ") : baseClass;
+		this.#resolveTag = tagMap ? (tag) => {
+			const extra = tagMap[tag];
+			if (!extra) return this.#baseClass;
+			const extraStr = Array.isArray(extra) ? extra.join(" ") : extra;
+			return `${this.#baseClass} ${extraStr}`;
+		} : () => this.#baseClass;
+	}
+	resolve(tag, skipTagMap = false) {
+		if (typeof tag !== "string" || skipTagMap) return this.#baseClass;
+		const cached = this.#cache.get(tag);
+		if (cached !== void 0) return cached;
+		const result = this.#resolveTag(tag);
+		this.#cache.set(tag, result);
+		return result;
+	}
+};
+//#endregion
+//#region ../../lib/styling/src/variant-class-resolver.ts
+/**
+* Runtime CVA class resolution with LRU + precomputed-map caching.
+*
+* Distinct from `variant-pass/` — `createVariantPass` is a composable pipeline stage for
+* build-time / plugin use (a `VariantConfig` → classes function), while this is the memoized
+* runtime resolver `createClassPipeline` calls per render.
+*
+* The precomputed map (`compileVariantLookup`, injected by the vite plugin) covers the
+* **no-recipe** combinations only — its keys are variant props alone, whereas this resolver's
+* cache keys are `recipe | variant props`, so a recipe-active call never hits a precomputed
+* entry and falls through to `#compute`. Recipe resolution stays fully runtime by design.
+*/
+var VariantClassResolver = class VariantClassResolver {
+	#cvaFn;
+	#recipeMap;
+	#variantKeys;
+	#precomputedClasses;
+	#cache = new LRUCache(1e3);
+	constructor(cvaFn, recipeMap, variantKeys, precomputedClasses) {
+		this.#cvaFn = cvaFn ?? null;
+		this.#recipeMap = Object.freeze(recipeMap ?? {});
+		this.#variantKeys = variantKeys ?? null;
+		this.#precomputedClasses = precomputedClasses ?? null;
+	}
+	resolve({ props, recipe }) {
+		const normalizedKey = recipe ?? "__none__";
+		const cacheKey = this.#createCacheKey(props, normalizedKey);
+		if (this.#precomputedClasses !== null) {
+			const precomputed = this.#precomputedClasses[cacheKey];
+			if (precomputed !== void 0) return precomputed;
+		}
+		const cached = this.#cache.get(cacheKey);
+		if (cached !== void 0) return cached;
+		const result = this.#compute(props, recipe);
+		this.#cache.set(cacheKey, result);
+		return result;
+	}
+	#compute(props, recipe) {
+		if (!this.#cvaFn) return "";
+		if (recipe === void 0) return this.#cvaFn(props);
+		const preset = this.#recipeMap[recipe];
+		if (!preset) return this.#cvaFn(props);
+		return this.#cvaFn({
+			...preset,
+			...props
+		});
+	}
+	#createCacheKey(props, recipe) {
+		if (this.#variantKeys !== null) {
+			let key = recipe;
+			iterate.forEachSet(this.#variantKeys, (k) => {
+				if (k in props) key += `|${k}:${VariantClassResolver.#serializeValue(props[k])}`;
+			});
+			return key;
+		}
+		let key = recipe;
+		iterate.forEach(Object.keys(props).sort(), (k) => {
+			key += `|${k}:${VariantClassResolver.#serializeValue(props[k])}`;
+		});
+		return key;
+	}
+	static #serializeValue(value) {
+		if (value === void 0) return "u";
+		if (value === null) return "n";
+		if (typeof value === "boolean") return `b:${value}`;
+		if (typeof value === "string") return `s:${value}`;
+		return `x:${String(value)}`;
+	}
+};
+//#endregion
+//#region ../../lib/styling/src/create-class-pipeline.ts
+function createClassPipeline(resolved) {
+	const baseClass = resolved.baseClassName ?? "";
+	const cvaFn = resolved.variants ? cva$1("", {
+		variants: resolved.variants,
+		defaultVariants: resolved.defaultVariants,
+		compoundVariants: resolved.compoundVariants
+	}) : null;
+	const variantKeys = resolved.variants ? new Set(Object.keys(resolved.variants)) : void 0;
+	const staticResolver = new StaticClassResolver(baseClass, resolved.tagMap);
+	const variantResolver = new VariantClassResolver(cvaFn, resolved.recipeMap, variantKeys, resolved.precomputedClasses);
+	return function resolveClasses(tag, props, className, recipe) {
+		const staticClasses = staticResolver.resolve(tag, recipe !== void 0);
+		const variantClasses = variantResolver.resolve({
+			props,
+			recipe
+		});
+		if (!className) return (staticClasses && variantClasses ? `${staticClasses} ${variantClasses}` : staticClasses || variantClasses) || void 0;
+		return cn(staticClasses, variantClasses, className);
+	};
+}
+//#endregion
+//#region ../core/src/options/resolve-factory-options.ts
+const EMPTY_VARIANT_KEYS = /* @__PURE__ */ new Set();
+function toNormalizeFn(normalize) {
+	if (!Array.isArray(normalize)) return normalize;
+	const fns = normalize;
+	if (fns.length === 0) return void 0;
+	if (fns.length === 1) return fns[0];
+	return ((props) => {
+		let acc = props;
+		for (const fn of fns) acc = fn(acc);
+		return acc;
+	});
+}
+function composeNormalizers(normalizers, fn) {
+	if (!normalizers?.length) return fn;
+	return ((props) => {
+		const patched = { ...props };
+		for (const normalizer of normalizers) Object.assign(patched, normalizer(patched));
+		const resolved = patched;
+		return fn ? fn(resolved) : resolved;
+	});
+}
+function whenDefined(key, value) {
+	return value === void 0 ? {} : { [key]: value };
+}
+function mergeAriaRules(aria, rules) {
+	if (!aria?.length) return rules;
+	if (!rules?.length) return aria;
+	return [...aria, ...rules];
+}
+function resolveFactoryOptions(options = {}) {
+	const { styling, enforcement } = options;
+	const composedNormalizeFn = composeNormalizers(enforcement?.props, toNormalizeFn(options.normalize));
+	const variantKeys = styling?.variants === void 0 ? EMPTY_VARIANT_KEYS : new Set(Object.keys(styling.variants));
+	return Object.freeze({
+		defaultTag: options.tag ?? "div",
+		diagnostics: resolveDiagnostics(enforcement?.diagnostics, options.diagnostics ?? silentDiagnostics),
+		variantKeys,
+		...whenDefined("displayName", options.name),
+		...whenDefined("defaultProps", options.defaults),
+		...whenDefined("baseClassName", styling?.base),
+		...whenDefined("tagMap", styling?.tags),
+		...whenDefined("recipeMap", styling?.presets),
+		...whenDefined("variants", styling?.variants),
+		...whenDefined("defaultVariants", styling?.defaults),
+		...whenDefined("compoundVariants", styling?.compounds),
+		...whenDefined("normalizeFn", composedNormalizeFn),
+		...whenDefined("ariaRules", mergeAriaRules(enforcement?.aria, enforcement?.rules)),
+		...whenDefined("childRules", enforcement?.children),
+		...whenDefined("exclusiveChildren", enforcement?.exclusiveChildren),
+		...whenDefined("allowText", enforcement?.allowText),
+		...whenDefined("allowedAs", enforcement?.allowedAs),
+		...whenDefined("precomputedClasses", styling?.precomputedClasses)
+	});
+}
+//#endregion
+//#region ../core/src/options/validate-factory-options.ts
+/**
+* Construction-time validation of the variant surface.
+*
+* A `presets` selection or `defaults` entry that references a variant key — or a
+* value of a key — not declared in `variants` resolves to no class at runtime,
+* silently. TypeScript catches this in typed usage, but untyped JS consumers and
+* `as`-cast escapes bypass it. This mirrors the type contract at runtime: warn
+* (`strict: 'warn'`) or throw (`strict: 'throw'`/`true`); a no-op when `false`.
+*
+* Runs once per factory (not per render). Render-time checks — unknown
+* `recipe`, undefined variant value at the call site — are a separate
+* follow-up (they require `strict` threaded into the class resolver).
+*/
+function validateFactoryOptions(resolved, diagnostics) {
+	if (!diagnostics.warnActive) return;
+	const name = resolved.displayName ?? "Component";
+	const { variants } = resolved;
+	const checkSelection = (label, selection) => {
+		iterate.forEachEntry(selection, (dim, value) => {
+			if (value === void 0 || value === null) return;
+			if (!variants || !Object.hasOwn(variants, dim)) {
+				diagnostics.error(ContractDiagnostics.unknownVariantDim(name, label, dim));
+				return;
+			}
+			const states = variants[dim];
+			const stateKey = String(value);
+			if (!Object.hasOwn(states, stateKey)) diagnostics.error(ContractDiagnostics.unknownVariantValue(name, label, dim, stateKey, Object.keys(states)));
+		});
+	};
+	const { recipeMap } = resolved;
+	if (recipeMap) iterate.forEachEntry(recipeMap, (recipeKey, selection) => {
+		checkSelection(`preset "${recipeKey}"`, selection);
+	});
+	if (resolved.defaultVariants) checkSelection("defaults", resolved.defaultVariants);
+}
+//#endregion
+//#region ../core/src/options/validate-render-props.ts
+function label(name) {
+	return name ? `[${name}]` : "[createContractComponent]";
+}
+function validateRenderProps(diagnostics, options, props, recipeKey) {
+	const { recipeMap, variants, displayName } = options;
+	const tag = label(displayName);
+	if (recipeKey !== void 0 && (!recipeMap || !Object.hasOwn(recipeMap, recipeKey))) diagnostics.error(ContractDiagnostics.unknownRecipeKey(tag, recipeKey));
+	if (variants) iterate.forEachKey(variants, (key) => {
+		if (!Object.hasOwn(props, key)) return;
+		const value = props[key];
+		if (value === void 0 || value === null) return;
+		const dim = variants[key];
+		if (dim && !Object.hasOwn(dim, String(value))) diagnostics.error(ContractDiagnostics.invalidVariantValue(tag, key, String(value)));
+	});
+}
+//#endregion
+//#region ../../lib/pipeline-kit/src/factory/define-pipeline.ts
+/** Wraps a PipelineFactory, memoizing the built Pipeline by the resolved config's object
+*  identity. Resolved options are already frozen per-component throughout this codebase
+*  (e.g. resolveFactoryOptions's `Object.freeze(...)`), so a WeakMap keyed on that same frozen
+*  reference is a safe, free cache — calling a factory twice with the same resolved reference
+*  doesn't redundantly rebuild internal resolvers. Modeled on the defineConfig-style helper
+*  convention (Vite/Vitest) for clean generic inference at the call site.
+*
+*  Note: the return type is intentionally the plain `PipelineFactory`, not wrapped in
+*  type-fest's `Simplify` — Simplify flattens object/intersection types for cleaner hover
+*  tooltips, but applying it to a callable type breaks the contextual typing TypeScript needs
+*  to infer the returned function's own parameter type. */
+function definePipeline(factory) {
+	const cache = /* @__PURE__ */ new WeakMap();
+	return (resolved) => {
+		const cached = cache.get(resolved);
+		if (cached !== void 0) return cached;
+		const pipeline = factory(resolved);
+		cache.set(resolved, pipeline);
+		return pipeline;
+	};
+}
+//#endregion
+//#region ../core/src/factory/pipelines/generic.ts
+const createTagPipeline = (resolved) => makeResolveTag(resolved.defaultTag);
+const createPropsPipeline = (resolved) => (props) => mergeProps(resolved.defaultProps, props);
+const createHtmlPropNormalizersPipeline = () => getHtmlPropNormalizers;
+const createHtmlChildrenEvaluatorPipeline = () => getHtmlChildrenEvaluator;
+const createStylingClassPipeline = (resolved) => createClassPipeline(resolved);
+const memoizedTagPipeline = definePipeline(createTagPipeline);
+const memoizedPropsPipeline = definePipeline(createPropsPipeline);
+const memoizedHtmlPropNormalizersPipeline = definePipeline(createHtmlPropNormalizersPipeline);
+const memoizedHtmlChildrenEvaluatorPipeline = definePipeline(createHtmlChildrenEvaluatorPipeline);
+const memoizedClassPipeline = definePipeline(createStylingClassPipeline);
+//#endregion
+//#region ../core/src/factory/pipelines/aria.ts
+function resolveAriaRules(resolved) {
+	return [.../* @__PURE__ */ new Set([...HTML_ARIA_RULES, ...resolved.ariaRules ?? []])];
+}
+const createAriaPipeline = (resolved) => {
+	const rules = resolveAriaRules(resolved);
+	const engine = new AriaPolicyEngine(resolved.diagnostics, {
+		...rules.length > 0 && { rules },
+		variantKeys: resolved.variantKeys
+	});
+	return (tag, props, extraProps) => engine.validate(tag, props, extraProps);
+};
+const memoizedAriaPipeline = definePipeline(createAriaPipeline);
+function resolveAriaPassthrough(_tag, props, _extraProps) {
+	return { props };
+}
+//#endregion
+//#region ../core/src/factory/plugin-diagnostics.ts
+const PluginDiagnostics = {
+	invalidShape(received) {
+		const got = isNull(received) ? "null" : typeof received;
+		return {
+			code: DiagnosticCode.PluginInvalidShape,
+			category: DiagnosticCategory.Internal,
+			message: `[praxis-kit] Plugin factory must return an object with a 'pipeline' function. Got: ${got}.`
+		};
+	},
+	pipelineReturnType(received) {
+		const got = isNull(received) ? "null" : Array.isArray(received) ? "array" : typeof received;
+		return {
+			code: DiagnosticCode.PluginPipelineReturnType,
+			category: DiagnosticCategory.Internal,
+			message: `[praxis-kit] Plugin pipeline must return a string. Got: ${got}.`
+		};
+	}
+};
+//#endregion
+//#region ../core/src/factory/plugin-invariants.ts
+function assertPluginShape(result) {
+	if (isNull(result) || !isObject(result)) throwDiagnostics.error(PluginDiagnostics.invalidShape(result));
+	if (!isFunction(result.pipeline)) throwDiagnostics.error(PluginDiagnostics.invalidShape(result));
+}
+function guardPipeline(pipeline) {
+	if (process.env.NODE_ENV === "production") return pipeline;
+	return function guardedPipeline(tag, props, className, recipe) {
+		const result = pipeline(tag, props, className, recipe);
+		if (!isString(result)) throwDiagnostics.error(PluginDiagnostics.pipelineReturnType(result));
+		return result;
+	};
+}
+//#endregion
+//#region ../core/src/factory/pipelines/styling.ts
+function resolveClassPlugin(factory, resolved, diagnostics) {
+	if (!factory) return {
+		pluginResult: void 0,
+		classPipeline: memoizedClassPipeline(resolved)
+	};
+	const pluginResult = factory(resolved, diagnostics);
+	assertPluginShape(pluginResult);
+	return {
+		pluginResult,
+		classPipeline: guardPipeline(pluginResult.pipeline)
+	};
+}
+//#endregion
+//#region ../core/src/factory/create-polymorphic.ts
+function eraseResolvedShape(resolved) {
+	return resolved;
+}
+function createPolymorphic(options = {}) {
+	const baseResolved = resolveFactoryOptions(options);
+	const anyBaseResolved = eraseResolvedShape(baseResolved);
+	const resolved = Object.freeze({
+		...baseResolved,
+		htmlPropNormalizersFn: memoizedHtmlPropNormalizersPipeline(anyBaseResolved),
+		htmlChildrenEvaluatorFn: memoizedHtmlChildrenEvaluatorPipeline(anyBaseResolved)
+	});
+	const anyResolved = eraseResolvedShape(resolved);
+	if (process.env.NODE_ENV !== "production") validateFactoryOptions(resolved, resolved.diagnostics);
+	const { pluginResult, classPipeline } = resolveClassPlugin(options.styling?.plugin, anyResolved, resolved.diagnostics);
+	const resolveTag = memoizedTagPipeline(anyResolved);
+	const resolveProps = memoizedPropsPipeline(anyResolved);
+	const resolveAriaFn = options.enforcement !== void 0 ? memoizedAriaPipeline(anyResolved) : resolveAriaPassthrough;
+	const methods = {
+		resolveTag,
+		resolveProps,
+		resolveClasses(tag, props, className, recipe) {
+			if (process.env.NODE_ENV !== "production") validateRenderProps(resolved.diagnostics, resolved, props, recipe);
+			return classPipeline(tag, props, className, recipe) || void 0;
+		},
+		resolveAria(tag, props, extraProps) {
+			return resolveAriaFn(tag, props, extraProps);
+		}
+	};
+	return pluginResult ? {
+		...methods,
+		options: resolved,
+		hasStyling: true,
+		classPlugin: pluginResult
+	} : {
+		...methods,
+		options: resolved
+	};
+}
+//#endregion
+//#region ../core/src/resolver/resolver.ts
+function enforceAllowedAs(tag, allowedAs, diagnostics, displayName) {
+	if (allowedAs.includes(tag)) return;
+	if (!diagnostics) return;
+	const component = displayName ?? String(tag);
+	diagnostics.error(ContractDiagnostics.allowedAsViolation(String(tag), allowedAs, component));
+}
+//#endregion
+//#region ../../lib/adapter-utils/src/runtime/build-core-runtime.ts
+const EMPTY_SET = /* @__PURE__ */ new Set();
+function buildCoreRuntime(normalized) {
+	const runtime = createPolymorphic(normalized);
+	return {
+		runtime,
+		ownedKeys: "classPlugin" in runtime ? runtime.classPlugin.ownedKeys ?? EMPTY_SET : EMPTY_SET
+	};
+}
+//#endregion
+//#region ../../lib/adapter-utils/src/runtime/build-engines.ts
+function buildEngines(diagnostics, childRules, context, childrenOptions) {
+	const { exclusiveChildren, allowText } = childrenOptions ?? {};
+	return childRules?.length || exclusiveChildren || allowText === false ? { childrenEvaluator: new ChildrenEvaluator(childRules ?? [], diagnostics, context, {
+		exclusiveChildren,
+		allowText
+	}) } : {};
+}
+//#endregion
+//#region ../../lib/adapter-utils/src/runtime/resolve-adapter-common-options.ts
+/**
+* Resolves the two fields that every adapter's `normalizeOptions` must provide:
+* `name` (required string) and `diagnostics` (required Diagnostics instance).
+*
+* Called by each adapter's `normalizeOptions` and spread into the result:
+*
+* ```ts
+* function normalizeOptions(options): NormalizedOptions {
+*   return { ...options, ...resolveAdapterCommonOptions(options) } as NormalizedOptions
+* }
+* ```
+*
+* The defaults (`'PolymorphicComponent'` and `throwDiagnostics`) match the convention used
+* by React, Vue, Preact, Solid, and Svelte. Adapters with different defaults
+* (e.g. Lit, Web: `silentDiagnostics`) pass an override argument.
+*/
+function resolveAdapterCommonOptions(options, defaultName = "PolymorphicComponent", defaultDiagnostics = throwDiagnostics$1) {
+	return {
+		name: options.name ?? defaultName,
+		diagnostics: resolveDiagnostics(options.enforcement?.diagnostics, defaultDiagnostics)
+	};
+}
+//#endregion
+//#region ../../lib/adapter-utils/src/props/apply-filter.ts
+function applyFilter(props, filterProps, variantKeys) {
+	const out = {};
+	iterate.forEachEntry(props, (k) => {
+		if (!Object.hasOwn(props, k)) return;
+		if (filterProps(k, variantKeys)) return;
+		out[k] = props[k];
+	});
+	return out;
+}
+//#endregion
+//#region ../../lib/adapter-utils/src/props/resolve-normalized-props.ts
+/**
+* The single canonical prop-normalization step for every render path — the five
+* VDOM adapters (React, Preact, Vue, Solid, Svelte) and the host-state path
+* shared by Lit, Web, and SSR.
+*
+* Ordering is fixed and load-bearing:
+*
+* ```text
+* mergedProps  →  HTML built-in normalizers  →  normalizeFn
+* ```
+*
+* `normalizeFn` is the primitive's composed `enforcement.props` normalizers plus
+* the caller's `normalize` option (folded together by `composeNormalizers`).
+* Running it last means a caller's `normalize` always observes — and can
+* override — an HTML built-in's output for the same key. This must be identical
+* across adapters: the same component with the same props has to normalize the
+* same way whether it renders through React or through SSR.
+*
+* `mergedProps` must already be the result of `runtime.resolveProps(rest)`. The
+* input object is never mutated; a copy is taken only when an HTML normalizer
+* actually runs — most tags have none (`htmlPropNormalizersFn` returns
+* `undefined` for every non-form element).
+*/
+function resolveNormalizedProps(options, tag, mergedProps) {
+	const htmlNormalizers = options.htmlPropNormalizersFn?.(tag);
+	let base = mergedProps;
+	if (htmlNormalizers?.length) {
+		base = { ...mergedProps };
+		for (const normalize of htmlNormalizers) Object.assign(base, normalize(base));
+	}
+	return typeof options.normalizeFn === "function" ? options.normalizeFn(base) : base;
+}
+//#endregion
+//#region ../../lib/adapter-utils/src/props/compose-filter.ts
+function composeFilter(ownedKeys, filterProps) {
+	const defaultFilter = (key, variantKeys) => variantKeys.has(key) || ownedKeys.has(key);
+	if (!filterProps) return defaultFilter;
+	return (key, variantKeys) => defaultFilter(key, variantKeys) || filterProps(key, variantKeys);
+}
+//#endregion
+//#region ../../lib/adapter-utils/src/render/render-to-string.ts
+const SAFE_TAG_NAME = /^[a-zA-Z][a-zA-Z0-9-]*$/;
+function assertSerializableTag(tag) {
+	if (!SAFE_TAG_NAME.test(tag)) throw new Error(`[renderBundleToString] refusing to serialize invalid tag name "${tag}" — an SSR tag must match /^[a-zA-Z][a-zA-Z0-9-]*\$/ (a valid HTML or custom-element tag name). It is written directly into the returned markup with no further escaping possible, so an invalid value can only be rejected, never sanitized.`);
+}
+function escapeAttr(value) {
+	return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+}
+function buildAttrString(attributes) {
+	const parts = [];
+	iterate.forEachEntry(attributes, (key, value) => {
+		if (value === false || value === null || value === void 0) return;
+		if (value === true) parts.push(key);
+		else parts.push(`${key}="${escapeAttr(String(value))}"`);
+	});
+	return parts.length > 0 ? ` ${parts.join(" ")}` : "";
+}
+/**
+* Renders a praxis-kit non-VDOM component (Lit, Web) to an HTML string without
+* requiring a DOM. Tag polymorphism works correctly in SSR — `options.tag` and the
+* `as` prop are resolved directly to the HTML element tag.
+*
+* `innerHTML` is assumed to be trusted, already-escaped HTML and is inserted
+* verbatim — it is not escaped here. Callers are responsible for escaping any
+* untrusted content before passing it.
+*
+* The resolved tag, by contrast, is validated unconditionally (`assertSerializableTag`, above) —
+* it has no legal escaping once interpolated into `<${tag}...>`, so unlike `innerHTML` this is not
+* a "caller's responsibility" boundary: an `as` prop that resolves to anything other than a
+* syntactically valid tag name throws here rather than reaching the returned string.
+*/
+function renderBundleToString(bundle, props = {}, innerHTML = "") {
+	const { filterProps, runtime: { options, resolveAria, resolveClasses, resolveProps, resolveTag } } = bundle;
+	const { as, className, recipe, class: classAttr, ...rest } = props;
+	const tag = resolveTag(as);
+	assertSerializableTag(tag);
+	if (options.allowedAs !== void 0) enforceAllowedAs(tag, options.allowedAs, options.diagnostics, options.displayName);
+	const finalProps = resolveNormalizedProps(options, tag, resolveProps(rest));
+	const resolvedClass = resolveClasses(tag, finalProps, className ?? classAttr, recipe);
+	return `<${tag}${buildAttrString({
+		...applyFilter(resolveAria(tag, finalProps).props, filterProps, options.variantKeys),
+		class: resolvedClass || void 0
+	})}>${innerHTML}</${tag}>`;
+}
+//#endregion
+//#region ../../lib/adapter-utils/src/render/host-state.ts
+/**
+* Runtime shape guard for the value returned by an adapter's buildRuntime() —
+* shared between Lit and Web, whose bundle shape (and validation needs) are
+* identical. childrenEvaluator is optional and adapter-owned; not part of
+* SsrBundle's declared type since resolveHostState below never reads it, but
+* still checked here since a malformed one indicates a real construction bug.
+*/
+function isLooseBundle(arg) {
+	if (!isObject(arg)) return false;
+	const { runtime, filterProps, childrenEvaluator } = arg;
+	if (!isObject(runtime)) return false;
+	if (!isObject(runtime["options"])) return false;
+	if (typeof runtime["resolveTag"] !== "function" || typeof runtime["resolveProps"] !== "function" || typeof runtime["resolveClasses"] !== "function" || typeof runtime["resolveAria"] !== "function") return false;
+	if (typeof filterProps !== "function") return false;
+	if (childrenEvaluator !== void 0 && (!isObject(childrenEvaluator) || typeof childrenEvaluator["evaluate"] !== "function")) return false;
+	return true;
+}
+function toLooseBundle(bundle) {
+	if (!isLooseBundle(bundle)) throw new Error("[createContractComponent] buildRuntime returned an unexpected shape.");
+	return bundle;
+}
+/**
+* Pure and side-effect-free (no enforceAllowedAs diagnostic): resolves the tag
+* and normalized props for the current attributes, nothing more.
+*
+* Exported separately from resolveHostState so a caller that only needs
+* tag/normalizedProps — e.g. Lit's render(), which runs before _applyPraxis()'s
+* full resolveHostState() call in the same update cycle and has nothing to
+* reuse yet — doesn't have to trigger resolveClasses/resolveAria/applyFilter,
+* and critically doesn't double-fire enforceAllowedAs's warning.
+*/
+function resolveTagAndNormalizedProps(bundle, props) {
+	const { as, className: _className, recipe: _recipe, ...rest } = props;
+	const { options, resolveProps, resolveTag } = bundle.runtime;
+	const tag = resolveTag(as);
+	return {
+		tag,
+		normalizedProps: resolveNormalizedProps(options, tag, resolveProps(rest))
+	};
+}
+/**
+* Pure: resolves the class string and filtered attribute map from current props.
+* Shared between Lit and Web — same pipeline, only the surrounding element
+* lifecycle (how `props` gets built, when this gets called) differs per adapter.
+*
+* Separating resolution from DOM mutation keeps this testable without a real
+* DOM and keeps diffAndApplyAttributes a simple write-only function.
+*/
+function resolveHostState(bundle, props) {
+	const { className, recipe } = props;
+	const { options, resolveAria, resolveClasses } = bundle.runtime;
+	const { tag, normalizedProps: finalProps } = resolveTagAndNormalizedProps(bundle, props);
+	if (options.allowedAs !== void 0) enforceAllowedAs(tag, options.allowedAs, options.diagnostics, options.displayName);
+	return {
+		className: resolveClasses(tag, finalProps, className, recipe),
+		attributes: applyFilter(resolveAria(tag, finalProps).props, bundle.filterProps, options.variantKeys),
+		tag,
+		normalizedProps: finalProps
+	};
+}
+/**
+* Applies resolved state to a host element. Shared between Lit and Web — both
+* hosts are HTMLElement subclasses and the diffing algorithm is identical.
+*
+* `prevPipelineAttrs` tracks which attribute keys the pipeline set on the
+* previous run. Any key present there but absent from the new state is
+* explicitly removed, preventing stale pipeline-managed attributes from
+* accumulating across runs.
+*
+* Variant key attributes are intentionally never removed here — removing them
+* would re-trigger each adapter's own attribute-change callback (Lit's
+* requestUpdate, the native attributeChangedCallback), creating a feedback loop.
+*/
+function diffAndApplyAttributes(host, state, prevPipelineAttrs, incomingProps) {
+	const hasOwn = Object.hasOwn;
+	const attrs = state.attributes;
+	if (state.className) host.className = state.className;
+	else host.removeAttribute("class");
+	for (const key of prevPipelineAttrs) if (!hasOwn(attrs, key)) host.removeAttribute(key);
+	prevPipelineAttrs.clear();
+	for (const key in incomingProps) {
+		if (!hasOwn(incomingProps, key)) continue;
+		if (!key.startsWith("aria-") && key !== "role") continue;
+		if (!hasOwn(attrs, key)) host.removeAttribute(key);
+	}
+	for (const key in attrs) {
+		if (!hasOwn(attrs, key)) continue;
+		const value = attrs[key];
+		if (value === void 0 || value === null || value === false) host.removeAttribute(key);
+		else if (value === true) {
+			host.setAttribute(key, "");
+			prevPipelineAttrs.add(key);
+		} else {
+			host.setAttribute(key, String(value));
+			prevPipelineAttrs.add(key);
+		}
+	}
+}
+//#endregion
+//#region ../../adapters/web/src/build-runtime.ts
+function buildRuntime(options) {
+	const normalized = {
+		...options,
+		...resolveAdapterCommonOptions(options, "PolymorphicElement", silentDiagnostics)
+	};
+	const { filterProps: customFilter, enforcement } = normalized;
+	const { runtime, ownedKeys } = buildCoreRuntime(normalized);
+	const { childrenEvaluator } = buildEngines(normalized.diagnostics, enforcement?.children, normalized.name, {
+		exclusiveChildren: enforcement?.exclusiveChildren,
+		allowText: enforcement?.allowText
+	});
+	return {
+		runtime,
+		filterProps: composeFilter(ownedKeys, customFilter),
+		diagnostics: normalized.diagnostics,
+		...childrenEvaluator !== void 0 && { childrenEvaluator }
+	};
+}
+//#endregion
+//#region ../../adapters/web/src/is-web-contract-component.ts
+/**
+* Type guard narrowing a generated class down to the public
+* `WebContractComponent<TVariants, TPluginProps>` interface the adapter
+* exposes.
+*
+* Like Lit's contract type, this describes an actual constructable class
+* (`new (): ...`) plus a required `diagnostics` static property — both real
+* runtime facts to check, beyond the generic-erasure boundary every guard
+* in this codebase hits.
+*
+* In SSR (Node) environments `HTMLElement` itself is undefined — the class
+* still gets created (as a stub, see `BaseElement` in
+* create-contract-component.ts) so `registerForSsr` can register it, but
+* there's no `HTMLElement` to check `instanceof` against there, so that part
+* of the check is skipped when `HTMLElement` doesn't exist.
+*
+* `WebContractComponent`'s third parameter, `G` (the phantom `__generics`
+* marker `GenericsOf`/`ContractProps` read back — `./types/contract-props`), is
+* left at its default here: it carries no runtime signal for this guard to
+* check, and `createContractComponent` supplies the real `G` itself when it
+* casts this function's narrowed result to its public return type.
+*/
+function isWebContractComponent(value) {
+	if (!isFunction(value)) return false;
+	if (typeof HTMLElement !== "undefined" && !(value.prototype instanceof HTMLElement)) return false;
+	if (!("diagnostics" in value)) return false;
+	return isObject(value.diagnostics);
+}
+//#endregion
+//#region ../../adapters/web/src/render-to-string.ts
+const ssrRegistry = /* @__PURE__ */ new WeakMap();
+/** Called by createContractComponent to enable renderContractToString for a class. */
+function registerForSsr(cls, bundle) {
+	ssrRegistry.set(cls, { bundle });
+}
+/**
+* Serializes a praxis-kit web component's **resolved contract** to an HTML string, without
+* requiring a DOM — not Custom Element SSR, and not a hydration mechanism.
+*
+* This distinction matters and is easy to get wrong: the output element is `options.tag`
+* (`<button>…</button>`, say), never the registered custom-element tag (`<praxis-button>`) —
+* `createContractComponent`'s own doc comment covers why the two are different concepts ("the
+* element Praxis models" vs. "the element actually in the DOM"). `customElements.define()` happens
+* externally, after `createContractComponent()` returns, and this function has no way to know what
+* name (if any) a caller eventually registers the class under, so there is no tag it could emit
+* that's guaranteed to match. Even if it could, the browser's Custom Element upgrade mechanism only
+* upgrades an exact tag-name match — a server-sent `<button>` can never become the live
+* `<praxis-button>` no matter what the client bundle does, so this was never a viable
+* SSR-then-upgrade path regardless of naming.
+*
+* Use this for what it actually is: previewing/testing the resolved styling + ARIA + attribute
+* pipeline as plain HTML (static generation, snapshot tests, non-interactive contexts) — not for
+* server-rendering markup you intend the live custom element to take over.
+*
+* `innerHTML` is treated as a pre-sanitized HTML string and inserted verbatim.
+* Callers are responsible for escaping any untrusted content before passing it.
+*/
+function renderContractToString(component, props = {}, innerHTML = "") {
+	const entry = ssrRegistry.get(component);
+	if (!entry) {
+		const name = component.name ?? "AnonymousComponent";
+		throw new Error(`[renderContractToString] ${name} was not registered for SSR. Ensure it was created with createContractComponent from praxis-kit/web.`);
+	}
+	const { as: _as, ...rest } = props;
+	return renderBundleToString(entry.bundle, rest, innerHTML);
+}
+//#endregion
+//#region ../../adapters/web/src/to-web-factory-options.ts
+/** Web-specific addition on top of `FactoryOptions`. */
+const WEB_FIELD_VALIDATORS = { filterProps: (v) => v === void 0 || isFunction(v) };
+/**
+* Type guard narrowing the generic `FactoryOptions` shape down to
+* `WebFactoryOptions` — the type `buildRuntime` is declared against. See
+* `isFactoryOptionsLike` for what this does and doesn't validate.
+*/
+function isWebFactoryOptions(options) {
+	return isFactoryOptionsLike(options, WEB_FIELD_VALIDATORS);
+}
+//#endregion
+//#region ../../adapters/web/src/create-contract-component.ts
+/**
+* Creates a plain `HTMLElement` subclass with praxis-kit contracts applied.
+*
+* No framework dependency. Register with `customElements.define()`:
+*
+* ```ts
+* const Button = createContractComponent({
+*   tag: 'button',
+*   name: 'Button',
+*   styling: {
+*     base: 'btn',
+*     variants: { intent: { primary: 'btn--primary', ghost: 'btn--ghost' } },
+*     defaults: { intent: 'primary' },
+*   },
+*   enforcement: { diagnostics: warnDiagnostics },
+* })
+*
+* customElements.define('praxis-button', Button)
+* ```
+*
+* The pipeline runs synchronously on `connectedCallback` and on every
+* `attributeChangedCallback` for praxis-owned attributes (variant keys,
+* `variant-key`, `praxis-class`).
+*
+* For non-reactive attributes (`aria-*`, `role`, `data-*`) — or a praxis-owned
+* property set directly rather than via `setAttribute` (property assignment
+* alone never fires `attributeChangedCallback`) — call `element.update()` after
+* to trigger an explicit pipeline re-run.
+*
+* **This adapter is a Custom Element host carrying a Praxis semantic contract — not a
+* reimplementation of native HTML element behavior.** `options.tag` (`'button'` above) names the
+* _intrinsic model_ Praxis resolves ARIA roles, content-model rules, and built-in prop
+* normalizers (`disabledProps`, etc.) against — it is not, and was never meant to be, the tag
+* actually written to the DOM. The DOM tag is whatever name a caller later passes to
+* `customElements.define(name, Button)`, entirely separate from `options.tag` and not knowable by
+* this function at all (registration happens externally, after this returns, possibly under
+* multiple names or never). So for the example above:
+*
+* ```text
+* Praxis intrinsic model:  button   (options.tag — drives ARIA/content-model/normalizers)
+* DOM host:                praxis-button   (customElements.define()'s name — the actual element)
+* ```
+*
+* A concrete consequence worth internalizing: `<praxis-button disabled>` gets `aria-disabled` from
+* the `disabledProps` normalizer (correctly, since `disabled`'s HTML-boolean-attribute semantics
+* are honored in `_buildProps()` below), but the browser does **not** make the custom element
+* keyboard-inert, form-participating, or otherwise behave like a real `HTMLButtonElement` — that
+* gap isn't a bug, it's the direct consequence of `class X extends HTMLElement`, and no ARIA
+* attribute on any element, custom or not, ever supplies real interactive behavior. The contract
+* layer (styling, variants, ARIA policy, child enforcement, attribute management, lifecycle hooks,
+* diagnostics) and the host's actual interactive behavior are — and have to stay — conceptually
+* separate; a caller who needs real button/link/input behavior supplies it themselves (`onElement`
+* is the wiring point), the same way any `role="button"` `<div>` would require it. (Customized
+* built-ins — `class X extends HTMLButtonElement` + `{ extends: 'button' }` — were considered and
+* rejected for solving this: a real platform mechanism, but a different consumer-facing API
+* (`<button is="…">` instead of `<praxis-button>`) with its own platform constraints, not worth the
+* complexity it would add here.)
+*
+* **No `as` prop.** Like the Lit adapter (this one's closest sibling — both are fixed-identity
+* custom elements, sharing `resolveHostState`/`renderBundleToString` from the shared adapter runtime),
+* a custom element's DOM tag is fixed at `customElements.define()` time — once the model/host
+* distinction above is explicit, this becomes easy: there is no tag for `as` to switch. An earlier
+* design accepted `as` as a semantic-only override (never changing the rendered element, but
+* changing which ARIA/content-model rules applied, as if it really were a different tag). That was
+* worse than not having it: it could produce `role="link"`-shaped output with none of an anchor's
+* actual keyboard/click/middle-click behavior — a real accessibility footgun regardless of the
+* option's name — and it made `renderContractToString`'s output disagree with itself across calls
+* to the same component, which can only ever produce `<praxis-button>…</praxis-button>` on the live
+* client regardless of what tag `as` named. `as` is filtered out unconditionally in `_buildProps()`
+* below (including as a raw, undeclared HTML attribute, not just a declared property) so
+* `resolveHostState`/`renderBundleToString` — shared, unmodified, cross-adapter code — always
+* resolve to `options.tag` here, on both the client and SSR paths. Need different semantics for one
+* instance? Register a second component with a different `tag`, or set `role` directly — both
+* already work today, unaffected by this.
+*/
+function createContractComponent(options) {
+	invariant(isWebFactoryOptions(options), "options is not a valid WebFactoryOptions object");
+	const bundle = buildRuntime(options);
+	const looseBundle = toLooseBundle(bundle);
+	const variantKeys = options.styling?.variants ? Object.keys(options.styling.variants) : [];
+	const pluginKeys = "classPlugin" in bundle.runtime ? [...bundle.runtime.classPlugin.ownedKeys ?? []] : [];
+	const observedAttrNames = [
+		"variant-key",
+		"praxis-class",
+		...variantKeys,
+		...pluginKeys
+	];
+	const BaseElement = typeof HTMLElement !== "undefined" ? HTMLElement : class {};
+	class PolymorphicWebElement extends BaseElement {
+		_pipelineAttrs = /* @__PURE__ */ new Set();
+		static get observedAttributes() {
+			return observedAttrNames;
+		}
+		_onElementCleanup;
+		connectedCallback() {
+			this._applyPraxis();
+			if (options.onElement) this._onElementCleanup = options.onElement(this, () => this._buildProps()) ?? void 0;
+		}
+		disconnectedCallback() {
+			this._onElementCleanup?.();
+			this._onElementCleanup = void 0;
+		}
+		attributeChangedCallback(_name, _old, _next) {
+			if (this.isConnected) this._applyPraxis();
+		}
+		/** Re-runs the pipeline. Call after setting non-reactive attributes (aria-*, role, data-*)
+		*  or a praxis-owned property directly (see this module's own doc comment). */
+		update() {
+			this._applyPraxis();
+		}
+		get _self() {
+			return this;
+		}
+		_buildProps() {
+			const self = this._self;
+			const observedSet = new Set(this.constructor.observedAttributes ?? []);
+			const props = {};
+			for (const attr of Array.from(this.attributes)) {
+				if (attr.name === "class" || attr.name === "as" || observedSet.has(attr.name)) continue;
+				props[attr.name] = attr.name === "disabled" ? true : attr.value;
+			}
+			props["recipe"] = self.recipe ?? this.getAttribute("variant-key") ?? void 0;
+			props["className"] = self.praxisClass ?? this.getAttribute("praxis-class") ?? void 0;
+			for (const key of variantKeys) {
+				const val = self[key] ?? this.getAttribute(key);
+				if (val != null) props[key] = val;
+			}
+			return props;
+		}
+		_applyPraxis() {
+			const { childrenEvaluator, runtime: { options } } = bundle;
+			const props = this._buildProps();
+			const hostState = resolveHostState(looseBundle, props);
+			const children = Array.from(this.childNodes);
+			if (childrenEvaluator) childrenEvaluator.evaluate(children, {
+				tag: hostState.tag,
+				props: hostState.normalizedProps
+			});
+			options.htmlChildrenEvaluatorFn?.(hostState.tag)?.evaluate(children, {
+				tag: hostState.tag,
+				props: hostState.normalizedProps
+			});
+			diffAndApplyAttributes(this, hostState, this._pipelineAttrs, props);
+		}
+	}
+	if (options.name) Object.defineProperty(PolymorphicWebElement, "name", { value: options.name });
+	Object.defineProperty(PolymorphicWebElement, "diagnostics", { value: bundle.diagnostics });
+	const contractClass = PolymorphicWebElement;
+	invariant(isWebContractComponent(contractClass), "Generated class failed to satisfy the WebContractComponent shape");
+	registerForSsr(contractClass, looseBundle);
+	return assembleCompoundComponent(contractClass, options.subComponents);
+}
+//#endregion
+export { createContractComponent, defineContractComponent, renderContractToString };