praxis-kit 4.0.1 → 4.1.0

package/dist/lit/index.js

@@ -1,11 +1,16 @@
-// ../../adapters/lit/src/create-contract-component.ts
-import { LitElement, html } from "lit";
+// ../../lib/adapter-utils/src/runtime/define-component.ts
+function defineContractComponent(options) {
+  return (factory) => factory(options);
+}
 
-// ../../lib/primitive/src/tag/resolve-tag.ts
-function makeResolveTag(defaultTag) {
-  return function tag(as) {
-    return as ?? defaultTag;
-  };
+// ../../lib/primitive/src/guards/foundational/is-defined.ts
+function isUndefined(value) {
+  return value === void 0;
+}
+
+// ../../lib/primitive/src/guards/foundational/is-null.ts
+function isNull(value) {
+  return value === null;
 }
 
 // ../../lib/primitive/src/utils/is-object.ts
@@ -20,195 +25,6 @@ function isNumber(value) {
   return typeof value === "number";
 }
 
-// ../../lib/primitive/src/utils/assert-never.ts
-function assertNever(value) {
-  throw new Error(`Unexpected value: ${String(value)}`);
-}
-
-// ../../lib/primitive/src/utils/cn.ts
-import { clsx } from "clsx";
-function cn(...inputs) {
-  return clsx(...inputs);
-}
-
-// ../../lib/primitive/src/utils/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;
-}
-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);
-  }
-}
-var iterate = Object.freeze({
-  entries,
-  filter,
-  find,
-  findLast,
-  forEach,
-  forEachEntry,
-  forEachKey,
-  forEachSet,
-  forEachValue,
-  items,
-  keys,
-  map,
-  mapEntries,
-  mapValues,
-  nodeList,
-  reduce,
-  collect,
-  set,
-  some,
-  every,
-  values
-});
-
-// ../../lib/primitive/src/utils/merge-props.ts
-function mergeProps(defaultProps, props) {
-  return {
-    ...defaultProps ?? {},
-    ...props
-  };
-}
-
 // ../../lib/primitive/src/constants/aria/global-aria-attributes.ts
 var GLOBAL_ARIA_ATTRIBUTES = /* @__PURE__ */ new Set([
   "aria-atomic",
@@ -231,7 +47,7 @@ var GLOBAL_ARIA_ATTRIBUTES = /* @__PURE__ */ new Set([
 ]);
 
 // ../../lib/primitive/src/constants/aria/implicit-role-record.ts
-var IMPLICIT_ROLE_RECORD = {
+var IMPLICIT_ROLE_RECORD = Object.freeze({
   // Landmarks
   article: "article",
   aside: "complementary",
@@ -267,8 +83,8 @@ var IMPLICIT_ROLE_RECORD = {
   meter: "meter",
   output: "status",
   progress: "progressbar"
-};
-var INPUT_TYPE_ROLE_MAP = {
+});
+var INPUT_TYPE_ROLE_MAP = Object.freeze({
   checkbox: "checkbox",
   radio: "radio",
   range: "slider",
@@ -282,15 +98,17 @@ var INPUT_TYPE_ROLE_MAP = {
   submit: "button",
   reset: "button",
   image: "button"
-};
-var STRONG_ROLES = [
+});
+var STRONG_ROLES = Object.freeze([
   "main",
   "navigation",
   "complementary",
   "contentinfo",
   "banner"
-];
-var STANDALONE_ROLES = ["article"];
+]);
+var STANDALONE_ROLES = Object.freeze([
+  "article"
+]);
 var STRONG_ROLES_SET = new Set(STRONG_ROLES);
 var STANDALONE_ROLES_SET = new Set(STANDALONE_ROLES);
 
@@ -445,16 +263,6 @@ var ROLE_RESTRICTED_ATTRIBUTES = /* @__PURE__ */ new Map([
   ]
 ]);
 
-// ../../lib/primitive/src/guards/foundational/is-defined.ts
-function isUndefined(value) {
-  return value === void 0;
-}
-
-// ../../lib/primitive/src/guards/foundational/is-null.ts
-function isNull(value) {
-  return value === null;
-}
-
 // ../../lib/primitive/src/guards/aria/is-aria-attribute.ts
 function isGlobalAriaAttribute(attr) {
   return GLOBAL_ARIA_ATTRIBUTES.has(attr);
@@ -476,38 +284,259 @@ function isStandaloneTag(tag) {
   return STANDALONE_ROLES_SET.has(IMPLICIT_ROLE_RECORD[tag]);
 }
 function getInputImplicitRole(type) {
-  if (type == null || !(type in INPUT_TYPE_ROLE_MAP)) return void 0;
+  if (!isString(type) || !(type in INPUT_TYPE_ROLE_MAP)) return void 0;
   return INPUT_TYPE_ROLE_MAP[type];
 }
 function getConditionalImplicitRole(tag, ariaLabel, ariaLabelledBy) {
-  const isNamed = typeof ariaLabel === "string" || typeof ariaLabelledBy === "string";
+  const isNamed = isString(ariaLabel) || isString(ariaLabelledBy);
   if (!isNamed) return void 0;
   if (tag === "section") return "region";
   if (tag === "form") return "form";
   return void 0;
 }
 
-// ../../lib/adapter-utils/src/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;
+// ../../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 === "input") return getInputImplicitRole(props?.type);
+  if (tag === "img") return props?.alt === "" ? "none" : "img";
+  if (tag === "section" || tag === "form") {
+    return getConditionalImplicitRole(tag, props?.["aria-label"], props?.["aria-labelledby"]);
+  }
+  return void 0;
+}
+
+// ../../lib/primitive/src/tag/resolve-tag.ts
+function makeResolveTag(defaultTag) {
+  return function tag(as) {
+    return as ?? defaultTag;
+  };
+}
+
+// ../../lib/primitive/src/utils/assert-never.ts
+function assertNever(value) {
+  throw new Error(`Unexpected value: ${String(value)}`);
+}
+
+// ../../lib/primitive/src/utils/cn.ts
+import { clsx } from "clsx";
+function cn(...inputs) {
+  return clsx(...inputs);
+}
+
+// ../../lib/primitive/src/utils/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;
+}
+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);
+  }
+}
+var iterate = Object.freeze({
+  entries,
+  filter,
+  find,
+  findLast,
+  forEach,
+  forEachEntry,
+  forEachKey,
+  forEachSet,
+  forEachValue,
+  items,
+  keys,
+  map,
+  mapEntries,
+  mapValues,
+  nodeList,
+  reduce,
+  collect,
+  set,
+  some,
+  every,
+  values
+});
+
+// ../../lib/primitive/src/utils/merge-props.ts
+function mergeProps(defaultProps, props) {
+  return {
+    ...defaultProps ?? {},
+    ...props
+  };
 }
 
-// ../../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 === "input") return getInputImplicitRole(props?.type);
-  if (tag === "img") return props?.alt === "" ? "none" : "img";
-  if (tag === "section" || tag === "form") {
-    return getConditionalImplicitRole(tag, props?.["aria-label"], props?.["aria-labelledby"]);
+// ../../lib/primitive/src/guards/children/component-id.ts
+var COMPONENT_DEFAULT_TAG = /* @__PURE__ */ Symbol.for("praxis.component-default-tag");
+
+// ../../lib/primitive/src/guards/children/is-tag.ts
+function getAsProp(child) {
+  if (!isObject(child) || !("props" in child)) return void 0;
+  const props = child.props;
+  if (!isObject(props)) return void 0;
+  const as = props.as;
+  return isString(as) && as !== "" ? as : void 0;
+}
+function getTag(child) {
+  if (!isObject(child) || !("type" in child)) return void 0;
+  const t = child.type;
+  if (isString(t)) return t;
+  if (typeof t === "function" || isObject(t)) {
+    const defaultTag = t[COMPONENT_DEFAULT_TAG];
+    if (!isString(defaultTag)) return void 0;
+    return getAsProp(child) ?? defaultTag;
   }
   return void 0;
 }
+function isTag(...args) {
+  if (isString(args[0])) {
+    const set3 = new Set(args);
+    return (child2) => {
+      const tag2 = getTag(child2);
+      return tag2 !== void 0 && set3.has(tag2);
+    };
+  }
+  const [child, ...tags] = args;
+  const set2 = new Set(tags);
+  const tag = getTag(child);
+  return tag !== void 0 && set2.has(tag);
+}
 
 // ../../lib/contract/src/strict/invariant-base.ts
 var InvariantBase = class {
@@ -531,159 +560,21 @@ var InvariantBase = class {
   }
 };
 
-// ../../lib/diagnostics/src/category.ts
-var DiagnosticCategory = /* @__PURE__ */ ((DiagnosticCategory2) => {
-  DiagnosticCategory2[DiagnosticCategory2["Contract"] = 0] = "Contract";
-  DiagnosticCategory2[DiagnosticCategory2["HTML"] = 1] = "HTML";
-  DiagnosticCategory2[DiagnosticCategory2["ARIA"] = 2] = "ARIA";
-  DiagnosticCategory2[DiagnosticCategory2["Composition"] = 3] = "Composition";
-  DiagnosticCategory2[DiagnosticCategory2["Rendering"] = 4] = "Rendering";
-  DiagnosticCategory2[DiagnosticCategory2["Accessibility"] = 5] = "Accessibility";
-  DiagnosticCategory2[DiagnosticCategory2["Performance"] = 6] = "Performance";
-  DiagnosticCategory2[DiagnosticCategory2["Internal"] = 7] = "Internal";
-  DiagnosticCategory2[DiagnosticCategory2["Deprecation"] = 8] = "Deprecation";
-  DiagnosticCategory2[DiagnosticCategory2["Lint"] = 9] = "Lint";
-  return DiagnosticCategory2;
-})(DiagnosticCategory || {});
-
-// ../../lib/diagnostics/src/error.ts
-var PraxisError = class extends Error {
-  diagnostic;
-  constructor(diagnostic) {
-    super(diagnostic.message);
-    this.name = "PraxisError";
-    this.diagnostic = diagnostic;
-  }
-};
-
-// ../../lib/diagnostics/src/severity.ts
-var Severity = /* @__PURE__ */ ((Severity2) => {
-  Severity2[Severity2["Debug"] = 0] = "Debug";
-  Severity2[Severity2["Info"] = 1] = "Info";
-  Severity2[Severity2["Warning"] = 2] = "Warning";
-  Severity2[Severity2["Error"] = 3] = "Error";
-  Severity2[Severity2["Fatal"] = 4] = "Fatal";
-  return Severity2;
-})(Severity || {});
-
-// ../../lib/diagnostics/src/policy.ts
-var DefaultPolicy = class {
-  reportThreshold;
-  throwThreshold;
-  constructor({
-    reportThreshold = 1 /* Info */,
-    throwThreshold = 4 /* Fatal */
-  } = {}) {
-    this.reportThreshold = reportThreshold;
-    this.throwThreshold = throwThreshold;
-  }
-  resolve(diagnostic) {
-    if (diagnostic.severity >= this.throwThreshold) return 2 /* Throw */;
-    if (diagnostic.severity >= this.reportThreshold) return 1 /* Report */;
-    return 0 /* Ignore */;
-  }
-};
-
-// ../../lib/diagnostics/src/diagnostics.ts
-var Diagnostics = class {
-  reporter;
-  policy;
-  // Pre-computed at construction time: true if Warning-level diagnostics are not ignored.
-  active;
-  constructor(reporter, policy = new DefaultPolicy()) {
-    this.reporter = reporter;
-    this.policy = policy;
-    this.active = policy.resolve({ severity: 2 /* Warning */ }) !== 0 /* Ignore */;
-  }
-  report(diagnostic) {
-    const enforcement = this.policy.resolve(diagnostic);
-    if (enforcement === 0 /* Ignore */) return diagnostic;
-    if (enforcement === 2 /* Throw */) throw new PraxisError(diagnostic);
-    this.reporter.report(diagnostic);
-    return diagnostic;
-  }
-  warn(input) {
-    return this.report({ ...input, severity: 2 /* Warning */ });
-  }
-  error(input) {
-    return this.report({ ...input, severity: 3 /* Error */ });
-  }
-  info(input) {
-    return this.report({ ...input, severity: 1 /* Info */ });
-  }
-};
-
-// ../../lib/diagnostics/src/formatter.ts
-function formatDiagnostic(diagnostic) {
-  const level = Severity[diagnostic.severity];
-  const category = DiagnosticCategory[diagnostic.category];
-  const prefix = category !== void 0 ? `[${category}] ` : "";
-  return `${level} ${diagnostic.code}: ${prefix}${diagnostic.message}`;
-}
-
-// ../../lib/diagnostics/src/console-reporter.ts
-var ConsoleReporter = class {
-  report(diagnostic) {
-    const message = formatDiagnostic(diagnostic);
-    switch (diagnostic.severity) {
-      case 0 /* Debug */:
-        console.debug(message);
-        break;
-      case 1 /* Info */:
-        console.info(message);
-        break;
-      case 2 /* Warning */:
-        console.warn(message);
-        break;
-      case 3 /* Error */:
-      case 4 /* Fatal */:
-        console.error(message);
-        break;
-    }
-  }
-};
-
-// ../../lib/diagnostics/src/null-reporter.ts
-var nullReporter = {
-  report() {
-  }
-};
-
-// ../../lib/diagnostics/src/presets.ts
-var ignoreAllPolicy = {
-  resolve(_) {
-    return 0 /* Ignore */;
-  }
-};
-var warnOnlyReporter = {
-  report(diagnostic) {
-    console.warn(formatDiagnostic(diagnostic));
-  }
-};
-var silentDiagnostics = new Diagnostics(nullReporter, ignoreAllPolicy);
-var warnDiagnostics = new Diagnostics(
-  warnOnlyReporter,
-  new DefaultPolicy({ reportThreshold: 2 /* Warning */, throwThreshold: 4 /* Fatal */ })
-);
-var throwDiagnostics = new Diagnostics(
-  new ConsoleReporter(),
-  new DefaultPolicy({ reportThreshold: 2 /* Warning */, throwThreshold: 3 /* Error */ })
-);
-
 // ../../lib/contract/src/diagnostics/aria.ts
+import { DiagnosticCategory, DiagnosticCode } from "../_shared/diagnostics.js";
 var AriaDiagnostics = {
   /** Generic bridge for violations produced by external AriaRule functions. */
   fromViolation(v) {
     return {
-      code: "ARIA2002" /* AriaViolation */,
-      category: 2 /* ARIA */,
+      code: DiagnosticCode.AriaViolation,
+      category: DiagnosticCategory.ARIA,
       message: v.message
     };
   },
   attributeInvalid(key, role) {
     return {
-      code: "ARIA2003" /* AriaAttributeInvalid */,
-      category: 2 /* ARIA */,
+      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: [
@@ -696,8 +587,8 @@ var AriaDiagnostics = {
   },
   missingLiveRegion(role, impliedLive) {
     return {
-      code: "ARIA2004" /* AriaMissingLiveRegion */,
-      category: 2 /* ARIA */,
+      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: [
@@ -711,8 +602,8 @@ var AriaDiagnostics = {
   },
   missingAtomic(role) {
     return {
-      code: "ARIA2005" /* AriaMissingAtomic */,
-      category: 2 /* ARIA */,
+      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."
     };
@@ -720,8 +611,8 @@ var AriaDiagnostics = {
   relevantInvalidTokens(invalid) {
     const quoted = invalid.map((t) => `"${t}"`).join(", ");
     return {
-      code: "ARIA2006" /* AriaRelevantInvalidToken */,
-      category: 2 /* ARIA */,
+      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: [
@@ -734,8 +625,8 @@ var AriaDiagnostics = {
   },
   relevantSuperseded() {
     return {
-      code: "ARIA2007" /* AriaRelevantSuperseded */,
-      category: 2 /* ARIA */,
+      code: DiagnosticCode.AriaRelevantSuperseded,
+      category: DiagnosticCategory.ARIA,
       message: 'aria-relevant includes "all" alongside other tokens. "all" supersedes additions, removals, and text \u2014 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: [
@@ -748,8 +639,8 @@ var AriaDiagnostics = {
   },
   missingAccessibleName(tag) {
     return {
-      code: "ARIA2009" /* AriaMissingAccessibleName */,
-      category: 2 /* ARIA */,
+      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: [
@@ -766,8 +657,8 @@ var AriaDiagnostics = {
   },
   attributeOnPresentational(attr, tag) {
     return {
-      code: "ARIA2010" /* AriaAttributeOnPresentational */,
-      category: 2 /* ARIA */,
+      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: [
@@ -780,8 +671,8 @@ var AriaDiagnostics = {
   },
   ariaHiddenOnFocusable(tag) {
     return {
-      code: "ARIA2011" /* AriaHiddenOnFocusable */,
-      category: 2 /* ARIA */,
+      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" \u2014 a focusable element assistive technology cannot describe.',
       suggestions: [
@@ -799,8 +690,8 @@ var AriaDiagnostics = {
   invalidAttributeValue(attr, value, expected) {
     const got = value === null ? "null" : value === void 0 ? "undefined" : typeof value === "string" ? `"${value}"` : String(value);
     return {
-      code: "ARIA2013" /* AriaInvalidAttributeValue */,
-      category: 2 /* ARIA */,
+      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: [
@@ -813,8 +704,8 @@ var AriaDiagnostics = {
   },
   redundantAriaLevel(tag, level) {
     return {
-      code: "ARIA2014" /* AriaRedundantLevelAttribute */,
-      category: 2 /* ARIA */,
+      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: [
@@ -827,8 +718,8 @@ var AriaDiagnostics = {
   },
   requiredProperty(attr, role) {
     return {
-      code: "ARIA2012" /* AriaRequiredProperty */,
-      category: 2 /* ARIA */,
+      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: [
@@ -841,8 +732,8 @@ var AriaDiagnostics = {
   },
   invalidRole(role, tag) {
     return {
-      code: "ARIA2008" /* AriaInvalidRole */,
-      category: 2 /* ARIA */,
+      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."
     };
@@ -850,11 +741,12 @@ var AriaDiagnostics = {
 };
 
 // ../../lib/contract/src/diagnostics/contract.ts
+import { DiagnosticCategory as DiagnosticCategory2, DiagnosticCode as DiagnosticCode2 } from "../_shared/diagnostics.js";
 var ContractDiagnostics = {
   unexpectedChild(typeName, index, context) {
     return {
-      code: "COMP1004" /* UnexpectedChild */,
-      category: 0 /* Contract */,
+      code: DiagnosticCode2.UnexpectedChild,
+      category: DiagnosticCategory2.Contract,
       component: context,
       message: `${context}: unexpected child "${typeName}" at index ${index}.`
     };
@@ -862,69 +754,69 @@ var ContractDiagnostics = {
   ambiguousChild(typeName, index, ruleNames, context) {
     const quoted = ruleNames.map((n) => `"${n}"`).join(" and ");
     return {
-      code: "COMP1005" /* AmbiguousChild */,
-      category: 0 /* Contract */,
+      code: DiagnosticCode2.AmbiguousChild,
+      category: DiagnosticCategory2.Contract,
       component: context,
       message: `${context}: child "${typeName}" at index ${index} matches multiple child rules: ${quoted}.`
     };
   },
   cardinalityMin(ruleName, min, context) {
     return {
-      code: "COMP1006" /* CardinalityMin */,
-      category: 0 /* Contract */,
+      code: DiagnosticCode2.CardinalityMin,
+      category: DiagnosticCategory2.Contract,
       component: context,
       message: `${context}: "${ruleName}" requires at least ${min}.`
     };
   },
   cardinalityMax(ruleName, max, context) {
     return {
-      code: "COMP1007" /* CardinalityMax */,
-      category: 0 /* Contract */,
+      code: DiagnosticCode2.CardinalityMax,
+      category: DiagnosticCategory2.Contract,
       component: context,
       message: `${context}: "${ruleName}" allows at most ${max}.`
     };
   },
   positionViolation(ruleName, position, index, context) {
     return {
-      code: "COMP1008" /* PositionViolation */,
-      category: 0 /* Contract */,
+      code: DiagnosticCode2.PositionViolation,
+      category: DiagnosticCategory2.Contract,
       component: context,
       message: `${context}: "${ruleName}" must be ${position}, got index ${index}`
     };
   },
   unknownVariantDim(component, label2, dim) {
     return {
-      code: "COMP1010" /* ContractUnknownVariantDim */,
-      category: 0 /* Contract */,
+      code: DiagnosticCode2.ContractUnknownVariantDim,
+      category: DiagnosticCategory2.Contract,
       message: `${component}: ${label2} references unknown variant "${dim}".`
     };
   },
   unknownVariantValue(component, label2, dim, value, valid) {
     return {
-      code: "COMP1011" /* ContractUnknownVariantValue */,
-      category: 0 /* Contract */,
+      code: DiagnosticCode2.ContractUnknownVariantValue,
+      category: DiagnosticCategory2.Contract,
       message: `${component}: ${label2} sets "${dim}" to unknown value "${value}" (valid: ${valid.join(", ")}).`
     };
   },
   unknownRecipeKey(component, key) {
     return {
-      code: "COMP1012" /* ContractUnknownRecipeKey */,
-      category: 0 /* Contract */,
+      code: DiagnosticCode2.ContractUnknownRecipeKey,
+      category: DiagnosticCategory2.Contract,
       message: `${component} Unknown recipeKey "${key}" \u2014 no preset with that name exists.`
     };
   },
   invalidVariantValue(component, key, value) {
     return {
-      code: "COMP1013" /* ContractInvalidVariantValue */,
-      category: 0 /* Contract */,
+      code: DiagnosticCode2.ContractInvalidVariantValue,
+      category: DiagnosticCategory2.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: "COMP1009" /* AllowedAsViolation */,
-      category: 0 /* Contract */,
+      code: DiagnosticCode2.AllowedAsViolation,
+      category: DiagnosticCategory2.Contract,
       component,
       message: `<${component}>: "as" prop received "${tag}" but only [${allowed}] are allowed.`
     };
@@ -932,46 +824,47 @@ var ContractDiagnostics = {
 };
 
 // ../../lib/contract/src/diagnostics/html.ts
+import { DiagnosticCategory as DiagnosticCategory3, DiagnosticCode as DiagnosticCode3 } from "../_shared/diagnostics.js";
 var HtmlDiagnostics = {
   emptyRole(tag) {
     return {
-      code: "HTML3002" /* HtmlEmptyRole */,
-      category: 1 /* HTML */,
+      code: DiagnosticCode3.HtmlEmptyRole,
+      category: DiagnosticCategory3.HTML,
       message: `<${tag}> has an explicit empty role="". Omit the attribute instead.`
     };
   },
   implicitRoleRedundant(tag, implicitRole) {
     return {
-      code: "HTML3003" /* HtmlImplicitRoleRedundant */,
-      category: 1 /* HTML */,
+      code: DiagnosticCode3.HtmlImplicitRoleRedundant,
+      category: DiagnosticCategory3.HTML,
       message: `<${tag}> already has implicit role="${implicitRole}". Avoid redundant role assignment.`
     };
   },
   implicitRoleOverride(tag, implicitRole, role) {
     return {
-      code: "HTML3004" /* HtmlImplicitRoleOverride */,
-      category: 1 /* HTML */,
+      code: DiagnosticCode3.HtmlImplicitRoleOverride,
+      category: DiagnosticCategory3.HTML,
       message: `<${tag}> should not override its implicit role="${implicitRole}" with role="${role}".`
     };
   },
   standaloneRegionOverride(tag, implicitRole) {
     return {
-      code: "HTML3005" /* HtmlStandaloneRegionOverride */,
-      category: 1 /* HTML */,
+      code: DiagnosticCode3.HtmlStandaloneRegionOverride,
+      category: DiagnosticCategory3.HTML,
       message: `<${tag}> is a self-contained element with implicit role="${implicitRole}". Assigning role="region" has been removed.`
     };
   },
   landmarkRoleOverride(tag, implicitRole, role) {
     return {
-      code: "HTML3006" /* HtmlLandmarkRoleOverride */,
-      category: 1 /* HTML */,
+      code: DiagnosticCode3.HtmlLandmarkRoleOverride,
+      category: DiagnosticCategory3.HTML,
       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: "HTML3007" /* HtmlInvalidChild */,
-      category: 1 /* HTML */,
+      code: DiagnosticCode3.HtmlInvalidChild,
+      category: DiagnosticCategory3.HTML,
       message: `<${child}> is not a valid direct child of <${parent}>. Allowed: ${allowed}.`
     };
   }
@@ -1654,7 +1547,7 @@ function getTypeName(value) {
     return primitive;
   }
   const name = value.constructor?.name;
-  return typeof name === "string" && name !== "Object" ? name : "object";
+  return isString(name) && name !== "Object" ? name : "object";
 }
 
 // ../../lib/contract/src/children/normalize-child-rule.ts
@@ -1905,6 +1798,9 @@ var readonlyProps = ({
   };
 };
 
+// ../core/src/html/evaluators.ts
+import { warnDiagnostics as warnDiagnostics2 } from "../_shared/diagnostics.js";
+
 // ../core/src/html/aria-rules.ts
 var LANDMARK_TAG_SET = /* @__PURE__ */ new Set(["article", "aside", "footer", "header", "main", "nav"]);
 var removeLandmarkRoleOverride = {
@@ -1947,6 +1843,167 @@ function landmarkNameAdvisory(ctx) {
 }
 var HTML_ARIA_RULES = [landmarkRoleRule, landmarkNameAdvisory];
 
+// ../core/src/html/contracts.ts
+import { warnDiagnostics } from "../_shared/diagnostics.js";
+function isOpenContent(...blockedTags) {
+  const set2 = new Set(blockedTags);
+  return (child) => isObject(child) && "type" in child && (!isString(child.type) || !set2.has(child.type));
+}
+var METADATA_TAGS = ["script", "template"];
+var metadataMatch = isTag(...METADATA_TAGS);
+function metadata(name = "metadata") {
+  return { name, match: metadataMatch };
+}
+function firstOptional(name, tag) {
+  return { name, match: isTag(tag), cardinality: { max: 1 }, position: "first" };
+}
+function contract(children) {
+  return { diagnostics: warnDiagnostics, children };
+}
+function ariaContract(aria) {
+  return { diagnostics: warnDiagnostics, aria };
+}
+function firstChildContract(name, tag) {
+  return contract([firstOptional(name, tag), { name: "content", match: isOpenContent(tag) }]);
+}
+var VOID_TAGS = [
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+];
+var TEXT_ONLY_TAGS = ["option", "script", "style", "textarea", "title"];
+var LANDMARK_TAGS = ["article", "aside", "footer", "header", "main", "nav"];
+var listContract = contract([{ name: "list-item", match: isTag("li", ...METADATA_TAGS) }]);
+var tableContract = contract([
+  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) }
+]);
+var tableBodyContract = contract([
+  { name: "table-row", match: isTag("tr", ...METADATA_TAGS) }
+]);
+var tableRowContract = contract([
+  { name: "table-cell", match: isTag("td", "th", ...METADATA_TAGS) }
+]);
+var colgroupContract = contract([{ name: "column", match: isTag("col", "template") }]);
+var dlContract = contract([
+  { name: "term", match: isTag("dt") },
+  { name: "description", match: isTag("dd") },
+  { name: "group", match: isTag("div") },
+  metadata()
+]);
+var selectContract = contract([
+  { name: "option", match: isTag("option", "optgroup", "hr", ...METADATA_TAGS) }
+]);
+var optgroupContract = contract([
+  { name: "option", match: isTag("option", ...METADATA_TAGS) }
+]);
+var datalistContract = contract([
+  { name: "option", match: isTag("option", ...METADATA_TAGS) }
+]);
+var pictureContract = contract([
+  { name: "source", match: isTag("source", ...METADATA_TAGS) },
+  { name: "image", match: isTag("img"), cardinality: { min: 1, max: 1 }, position: "last" }
+]);
+var figureContract = contract([
+  { name: "caption", match: isTag("figcaption"), cardinality: { max: 1 } },
+  { name: "content", match: isOpenContent("figcaption") }
+]);
+var detailsContract = firstChildContract("summary", "summary");
+var fieldsetContract = firstChildContract("legend", "legend");
+var mediaContract = contract([
+  { name: "source", match: isTag("source") },
+  { name: "track", match: isTag("track") },
+  metadata(),
+  { name: "content", match: isOpenContent("source", "track", ...METADATA_TAGS) }
+]);
+var headContract = contract([
+  {
+    name: "metadata",
+    match: isTag("base", "link", "meta", "noscript", "script", "style", "template", "title")
+  }
+]);
+var htmlContract = contract([
+  { name: "head", match: isTag("head"), cardinality: { min: 1, max: 1 }, position: "first" },
+  { name: "body", match: isTag("body"), cardinality: { min: 1, max: 1 } }
+]);
+var voidContract = contract([]);
+var textOnlyContract = contract([
+  {
+    name: "text",
+    match: (child) => isString(child) || isNumber(child)
+  }
+]);
+var landmarkContract = ariaContract([landmarkRoleRule, landmarkNameAdvisory]);
+var dialogContract = ariaContract([requireAccessibleName]);
+var menuContract = ariaContract([requireAccessibleName]);
+var menubarContract = ariaContract([requireAccessibleName]);
+var treeContract = ariaContract([requireAccessibleName]);
+var gridContract = ariaContract([requireAccessibleName]);
+var listboxContract = ariaContract([requireAccessibleName]);
+var tablistContract = ariaContract([requireAccessibleName]);
+var radiogroupContract = ariaContract([requireAccessibleName]);
+var CONTRACT_GROUPS = [
+  [VOID_TAGS, voidContract],
+  [TEXT_ONLY_TAGS, textOnlyContract],
+  [LANDMARK_TAGS, landmarkContract],
+  [["ul", "ol", "menu"], listContract],
+  [["audio", "video"], mediaContract],
+  [["thead", "tbody", "tfoot"], tableBodyContract]
+];
+function contractMap(groups) {
+  return Object.fromEntries(
+    groups.flatMap(([tags, enforcement]) => tags.map((tag) => [tag, enforcement]))
+  );
+}
+var htmlContracts = {
+  ...contractMap(CONTRACT_GROUPS),
+  table: tableContract,
+  tr: tableRowContract,
+  colgroup: colgroupContract,
+  dl: dlContract,
+  select: selectContract,
+  optgroup: optgroupContract,
+  datalist: datalistContract,
+  picture: pictureContract,
+  figure: figureContract,
+  details: detailsContract,
+  fieldset: fieldsetContract,
+  dialog: dialogContract,
+  head: headContract,
+  html: htmlContract
+};
+
+// ../core/src/html/evaluators.ts
+var htmlDiagnostics = warnDiagnostics2;
+function buildEvaluatorMap() {
+  const map2 = /* @__PURE__ */ new Map();
+  iterate.forEachEntry(htmlContracts, (tag, { children }) => {
+    if (children?.length) {
+      map2.set(tag, new ChildrenEvaluator(children, htmlDiagnostics, `<${tag}>`));
+    }
+  });
+  return map2;
+}
+var HTML_EVALUATORS = buildEvaluatorMap();
+function getHtmlChildrenEvaluator(tag) {
+  return typeof tag === "string" ? HTML_EVALUATORS.get(tag) : void 0;
+}
+
 // ../core/src/html/prop-normalizers.ts
 var HTML_FORM_NORMALIZERS = /* @__PURE__ */ new Map([
   ["button", [disabledProps]],
@@ -2134,7 +2191,21 @@ function createClassPipeline(resolved) {
   };
 }
 
+// ../../lib/pipeline-kit/src/factory/define-pipeline.ts
+function definePipeline(factory) {
+  const cache = /* @__PURE__ */ new WeakMap();
+  return (resolved) => {
+    let pipeline = cache.get(resolved);
+    if (!pipeline) {
+      pipeline = factory(resolved);
+      cache.set(resolved, pipeline);
+    }
+    return pipeline;
+  };
+}
+
 // ../core/src/options/resolve-factory-options.ts
+import { silentDiagnostics } from "../_shared/diagnostics.js";
 var EMPTY_VARIANT_KEYS = /* @__PURE__ */ new Set();
 function composeNormalizers(normalizers, fn) {
   if (!normalizers?.length) return fn;
@@ -2226,21 +2297,25 @@ function validateRenderProps(diagnostics, options, props, recipeKey) {
   }
 }
 
+// ../core/src/factory/plugin-invariants.ts
+import { throwDiagnostics } from "../_shared/diagnostics.js";
+
 // ../core/src/factory/plugin-diagnostics.ts
+import { DiagnosticCategory as DiagnosticCategory4, DiagnosticCode as DiagnosticCode4 } from "../_shared/diagnostics.js";
 var PluginDiagnostics = {
   invalidShape(received) {
     const got = received === null ? "null" : typeof received;
     return {
-      code: "PLUGIN7001" /* PluginInvalidShape */,
-      category: 7 /* Internal */,
+      code: DiagnosticCode4.PluginInvalidShape,
+      category: DiagnosticCategory4.Internal,
       message: `[praxis-kit] Plugin factory must return an object with a 'pipeline' function. Got: ${got}.`
     };
   },
   pipelineReturnType(received) {
     const got = received === null ? "null" : Array.isArray(received) ? "array" : typeof received;
     return {
-      code: "PLUGIN7002" /* PluginPipelineReturnType */,
-      category: 7 /* Internal */,
+      code: DiagnosticCode4.PluginPipelineReturnType,
+      category: DiagnosticCategory4.Internal,
       message: `[praxis-kit] Plugin pipeline must return a string. Got: ${got}.`
     };
   }
@@ -2264,89 +2339,82 @@ function guardPipeline(pipeline) {
   };
 }
 
-// ../core/src/factory/create-polymorphic.ts
-var NOOP_CLASS_PIPELINE = (_tag, _props, className) => Array.isArray(className) ? className.join(" ") : className ?? "";
-function resolveClassPipeline(options, resolved, diagnostics, capabilities) {
-  const factory = options.styling?.plugin;
-  if (!factory) {
-    const createClassPipeline2 = capabilities?.createClassPipeline;
-    const classPipeline2 = createClassPipeline2 ? createClassPipeline2(resolved) : NOOP_CLASS_PIPELINE;
-    return { pluginResult: void 0, classPipeline: classPipeline2 };
-  }
+// ../core/src/factory/create-polymorphic2.ts
+var createTagPipeline = (resolved) => makeResolveTag(resolved.defaultTag);
+var createPropsPipeline = (resolved) => (props) => mergeProps(resolved.defaultProps, props);
+var createHtmlPropNormalizersPipeline = () => getHtmlPropNormalizers;
+var createHtmlChildrenEvaluatorPipeline = () => getHtmlChildrenEvaluator;
+var createStylingClassPipeline = (resolved) => createClassPipeline(resolved);
+function resolveAriaRules(resolved) {
+  return [.../* @__PURE__ */ new Set([...HTML_ARIA_RULES, ...resolved.ariaRules ?? []])];
+}
+var createAriaPipeline = (resolved) => {
+  const rules = resolveAriaRules(resolved);
+  const engine = new AriaPolicyEngine(resolved.diagnostics, rules.length ? { rules } : void 0);
+  return (tag, props) => engine.validate(tag, props);
+};
+var memoizedTagPipeline = definePipeline(createTagPipeline);
+var memoizedPropsPipeline = definePipeline(createPropsPipeline);
+var memoizedHtmlPropNormalizersPipeline = definePipeline(createHtmlPropNormalizersPipeline);
+var memoizedHtmlChildrenEvaluatorPipeline = definePipeline(createHtmlChildrenEvaluatorPipeline);
+var memoizedClassPipeline = definePipeline(createStylingClassPipeline);
+var memoizedAriaPipeline = definePipeline(createAriaPipeline);
+function resolveAriaPassthrough(_tag, props) {
+  return { props };
+}
+function resolveClassPlugin(factory, resolved, diagnostics) {
+  if (!factory) return { pluginResult: void 0, classPipeline: memoizedClassPipeline(resolved) };
   const pluginResult = factory(resolved, diagnostics);
   assertPluginShape(pluginResult);
-  const classPipeline = guardPipeline(pluginResult.pipeline);
-  return { pluginResult, classPipeline };
+  return { pluginResult, classPipeline: guardPipeline(pluginResult.pipeline) };
 }
-function createRuntimeMethods(resolved, classPipeline, engine, renderDiagnostics) {
-  return {
-    resolveTag: makeResolveTag(resolved.defaultTag),
-    resolveProps(props) {
-      return mergeProps(resolved.defaultProps, props);
-    },
+function createPolymorphic2(options = {}) {
+  const baseResolved = resolveFactoryOptions(options);
+  const anyBaseResolved = baseResolved;
+  const resolved = Object.freeze({
+    ...baseResolved,
+    htmlPropNormalizersFn: memoizedHtmlPropNormalizersPipeline(anyBaseResolved),
+    htmlChildrenEvaluatorFn: memoizedHtmlChildrenEvaluatorPipeline(anyBaseResolved)
+  });
+  const anyResolved = resolved;
+  if (process.env.NODE_ENV !== "production") {
+    validateFactoryOptions(resolved, resolved.diagnostics);
+  }
+  const { pluginResult, classPipeline } = resolveClassPlugin(
+    options.styling?.plugin,
+    anyResolved,
+    resolved.diagnostics
+  );
+  const resolveTag2 = memoizedTagPipeline(anyResolved);
+  const resolveProps = memoizedPropsPipeline(anyResolved);
+  const resolveAriaFn = options.enforcement !== void 0 ? memoizedAriaPipeline(anyResolved) : resolveAriaPassthrough;
+  const methods = {
+    resolveTag: resolveTag2,
+    resolveProps,
     resolveClasses(tag, props, className, recipe) {
       if (process.env.NODE_ENV !== "production") {
-        validateRenderProps(renderDiagnostics, resolved, props, recipe);
+        validateRenderProps(resolved.diagnostics, resolved, props, recipe);
       }
       return classPipeline(tag, props, className, recipe);
     },
     resolveAria(tag, props) {
-      if (!engine) return { props };
-      const result = engine.validate(tag, props);
-      return { props: result.props };
+      return resolveAriaFn(tag, props);
     }
   };
-}
-function createRuntimeObject(methods, resolved, pluginResult) {
-  return pluginResult ? { ...methods, options: resolved, hasStyling: true, classPlugin: pluginResult } : { ...methods, options: resolved };
-}
-function createPolymorphic(options = {}, capabilities) {
-  const baseResolved = resolveFactoryOptions(options);
-  const resolved = capabilities?.htmlPropNormalizersFn !== void 0 ? Object.freeze({
-    ...baseResolved,
-    htmlPropNormalizersFn: capabilities.htmlPropNormalizersFn
-  }) : baseResolved;
-  if (process.env.NODE_ENV !== "production") {
-    validateFactoryOptions(resolved, resolved.diagnostics);
-  }
-  const { pluginResult, classPipeline } = resolveClassPipeline(
-    options,
-    resolved,
-    resolved.diagnostics,
-    capabilities
-  );
-  const allAriaRules = [
-    .../* @__PURE__ */ new Set([...capabilities?.htmlAriaRules ?? [], ...resolved.ariaRules ?? []])
-  ];
-  const engine = options.enforcement !== void 0 && capabilities?.AriaEngine ? new capabilities.AriaEngine(
-    resolved.diagnostics,
-    allAriaRules.length ? { rules: allAriaRules } : void 0
-  ) : null;
-  const methods = createRuntimeMethods(resolved, classPipeline, engine, resolved.diagnostics);
-  return createRuntimeObject(
-    methods,
-    resolved,
-    pluginResult
-  );
-}
-
-// ../core/src/factory/create-polymorphic-full.ts
-var FULL_CAPABILITIES = {
-  createClassPipeline,
-  AriaEngine: AriaPolicyEngine,
-  htmlAriaRules: HTML_ARIA_RULES,
-  htmlPropNormalizersFn: getHtmlPropNormalizers
-};
-function createPolymorphic2(options = {}) {
-  return createPolymorphic(options, FULL_CAPABILITIES);
+  const runtimeObject = pluginResult ? { ...methods, options: resolved, hasStyling: true, classPlugin: pluginResult } : { ...methods, options: resolved };
+  return runtimeObject;
 }
 
-// ../../lib/adapter-utils/src/define-component.ts
-function defineContractComponent(options) {
-  return (factory) => factory(options);
+// ../core/src/resolver/resolver.ts
+import { silentDiagnostics as silentDiagnostics2 } from "../_shared/diagnostics.js";
+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));
 }
 
-// ../../lib/adapter-utils/src/build-core-runtime.ts
+// ../../lib/adapter-utils/src/runtime/build-core-runtime.ts
 var EMPTY_SET = /* @__PURE__ */ new Set();
 function buildCoreRuntime(normalized) {
   const runtime = createPolymorphic2(normalized);
@@ -2354,57 +2422,41 @@ function buildCoreRuntime(normalized) {
   return { runtime, ownedKeys };
 }
 
-// ../../lib/adapter-utils/src/build-engines.ts
+// ../../lib/adapter-utils/src/runtime/build-engines.ts
 function buildEngines(diagnostics, childRules, context) {
   return childRules?.length ? { childrenEvaluator: new ChildrenEvaluator(childRules, diagnostics, context) } : {};
 }
 
-// ../../lib/adapter-utils/src/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);
-}
-
-// ../../lib/adapter-utils/src/resolve-adapter-common-options.ts
-function resolveAdapterCommonOptions(options, defaultName = "PolymorphicComponent", defaultDiagnostics = throwDiagnostics) {
+// ../../lib/adapter-utils/src/runtime/resolve-adapter-common-options.ts
+import { throwDiagnostics as throwDiagnostics2, silentDiagnostics as silentDiagnostics3 } from "../_shared/diagnostics.js";
+function resolveAdapterCommonOptions(options, defaultName = "PolymorphicComponent", defaultDiagnostics = throwDiagnostics2) {
   return {
     name: options.name ?? defaultName,
     diagnostics: options.enforcement?.diagnostics ?? defaultDiagnostics
   };
 }
 
-// ../../adapters/lit/src/build-runtime.ts
-function normalizeOptions(options) {
-  return {
-    ...options,
-    ...resolveAdapterCommonOptions(options, "PolymorphicElement", silentDiagnostics)
-  };
-}
-function buildRuntime(options) {
-  const { filterProps: customFilter, enforcement } = options;
-  const normalized = normalizeOptions(options);
-  const { runtime, ownedKeys } = buildCoreRuntime(normalized);
-  const { childrenEvaluator } = buildEngines(
-    normalized.diagnostics,
-    enforcement?.children,
-    normalized.name
-  );
-  const filterProps = composeFilter(ownedKeys, customFilter);
-  return {
-    runtime,
-    filterProps,
-    ...childrenEvaluator !== void 0 && { childrenEvaluator }
-  };
+// ../../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;
 }
 
-// ../../adapters/lit/src/render-to-string.ts
-var ssrRegistry = /* @__PURE__ */ new WeakMap();
-function registerForSsr(cls, bundle) {
-  ssrRegistry.set(cls, { bundle });
+// ../../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);
 }
+
+// ../../lib/adapter-utils/src/render/render-to-string.ts
 function escapeAttr(value) {
   return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
 }
@@ -2418,51 +2470,51 @@ function buildAttrString(attributes) {
       parts.push(`${key}="${escapeAttr(String(value))}"`);
     }
   });
-  return parts.length > 0 ? " " + parts.join(" ") : "";
+  return parts.length > 0 ? ` ${parts.join(" ")}` : "";
 }
-function renderToString(component, props = {}, innerHTML = "") {
-  const entry = ssrRegistry.get(component);
-  if (!entry) {
-    const name = component.name ?? "AnonymousComponent";
-    throw new Error(
-      `[renderToString] ${name} was not registered for SSR. Ensure it was created with createContractComponent from @praxis-kit/lit.`
-    );
-  }
-  const { bundle } = entry;
+function renderBundleToString(bundle, props = {}, innerHTML = "") {
+  const {
+    filterProps,
+    runtime: { options, resolveAria, resolveClasses, resolveProps, resolveTag: resolveTag2 }
+  } = bundle;
   const { as, className, recipe, class: classAttr, ...rest } = props;
-  const tag = bundle.runtime.resolveTag(as);
-  const mergedProps = bundle.runtime.resolveProps(rest);
-  const resolvedClass = bundle.runtime.resolveClasses(
+  const tag = resolveTag2(as);
+  if (options.allowedAs !== void 0) {
+    enforceAllowedAs(tag, options.allowedAs, options.diagnostics, options.displayName);
+  }
+  const mergedProps = resolveProps(rest);
+  const normalizedProps = typeof options.normalizeFn === "function" ? options.normalizeFn(mergedProps) : mergedProps;
+  const htmlNormalizers = options.htmlPropNormalizersFn?.(tag);
+  const finalProps = { ...normalizedProps };
+  if (htmlNormalizers) {
+    for (const normalize of htmlNormalizers) {
+      Object.assign(finalProps, normalize(finalProps));
+    }
+  }
+  const resolvedClass = resolveClasses(
     tag,
-    mergedProps,
+    finalProps,
     // Accept both React-style className and HTML-native class
     className ?? classAttr,
     recipe
   );
-  const ariaResult = bundle.runtime.resolveAria(tag, mergedProps);
-  const filtered = applyFilter(
-    ariaResult.props,
-    bundle.filterProps,
-    bundle.runtime.options.variantKeys
-  );
+  const ariaResult = resolveAria(tag, finalProps);
+  const filtered = applyFilter(ariaResult.props, filterProps, options.variantKeys);
   const attrs = { ...filtered, class: resolvedClass || void 0 };
   const attrStr = buildAttrString(attrs);
   return `<${tag}${attrStr}>${innerHTML}</${tag}>`;
 }
 
-// ../../adapters/lit/src/create-contract-component.ts
-function isObject2(value) {
-  return typeof value === "object" && value !== null;
-}
+// ../../lib/adapter-utils/src/render/host-state.ts
 function isLooseBundle(arg) {
-  if (!isObject2(arg)) return false;
+  if (!isObject(arg)) return false;
   const { runtime, filterProps, childrenEvaluator } = arg;
-  if (!isObject2(runtime)) return false;
-  if (!isObject2(runtime["options"])) return false;
+  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 && (!isObject2(childrenEvaluator) || typeof childrenEvaluator["evaluate"] !== "function"))
+  if (childrenEvaluator !== void 0 && (!isObject(childrenEvaluator) || typeof childrenEvaluator["evaluate"] !== "function"))
     return false;
   return true;
 }
@@ -2474,41 +2526,46 @@ function toLooseBundle(bundle) {
 }
 function resolveHostState(bundle, props) {
   const { as, className, recipe, ...rest } = props;
-  const tag = bundle.runtime.resolveTag(as);
-  const mergedProps = bundle.runtime.resolveProps(rest);
-  const baseProps = bundle.runtime.options.normalizeFn ? bundle.runtime.options.normalizeFn(mergedProps) : mergedProps;
-  const htmlNormalizers = bundle.runtime.options.htmlPropNormalizersFn?.(tag);
-  const normalizedProps = htmlNormalizers?.length ? htmlNormalizers.reduce((acc, fn) => ({ ...acc, ...fn(acc) }), baseProps) : baseProps;
-  const resolvedClass = bundle.runtime.resolveClasses(
+  const { options, resolveAria, resolveClasses, resolveProps, resolveTag: resolveTag2 } = bundle.runtime;
+  const tag = resolveTag2(as);
+  if (options.allowedAs !== void 0) {
+    enforceAllowedAs(tag, options.allowedAs, options.diagnostics, options.displayName);
+  }
+  const mergedProps = resolveProps(rest);
+  const normalizedProps = typeof options.normalizeFn === "function" ? options.normalizeFn(mergedProps) : mergedProps;
+  const htmlNormalizers = options.htmlPropNormalizersFn?.(tag);
+  const finalProps = { ...normalizedProps };
+  if (htmlNormalizers) {
+    for (const normalize of htmlNormalizers) {
+      Object.assign(finalProps, normalize(finalProps));
+    }
+  }
+  const resolvedClass = resolveClasses(
     tag,
-    normalizedProps,
+    finalProps,
     className,
     recipe
   );
-  const ariaResult = bundle.runtime.resolveAria(tag, normalizedProps);
-  const attributes = applyFilter(
-    ariaResult.props,
-    bundle.filterProps,
-    bundle.runtime.options.variantKeys
-  );
+  const ariaResult = resolveAria(tag, finalProps);
+  const attributes = applyFilter(ariaResult.props, bundle.filterProps, options.variantKeys);
   return { className: resolvedClass, attributes };
 }
-function applyHostState(host, state, prevPipelineAttrs, incomingProps) {
+function diffAndApplyAttributes(host, state, prevPipelineAttrs, incomingProps) {
+  const hasOwn2 = Object.hasOwn;
+  const attrs = state.attributes;
   host.className = state.className;
-  iterate.forEachSet(prevPipelineAttrs, (key) => {
-    if (!Object.hasOwn(state.attributes, key)) {
-      host.removeAttribute(key);
-    }
-  });
+  for (const key of prevPipelineAttrs) {
+    if (!hasOwn2(attrs, key)) host.removeAttribute(key);
+  }
   prevPipelineAttrs.clear();
-  iterate.forEachKey(incomingProps, (key) => {
-    if (!Object.hasOwn(incomingProps, key)) return;
-    if (!key.startsWith("aria-") && key !== "role") return;
-    if (!Object.hasOwn(state.attributes, key)) host.removeAttribute(key);
-  });
-  iterate.forEachKey(state.attributes, (key) => {
-    if (!Object.hasOwn(state.attributes, key)) return;
-    const value = state.attributes[key];
+  for (const key in incomingProps) {
+    if (!hasOwn2(incomingProps, key)) continue;
+    if (!key.startsWith("aria-") && key !== "role") continue;
+    if (!hasOwn2(attrs, key)) host.removeAttribute(key);
+  }
+  for (const key in attrs) {
+    if (!hasOwn2(attrs, key)) continue;
+    const value = attrs[key];
     if (value === void 0 || value === null || value === false) {
       host.removeAttribute(key);
     } else if (value === true) {
@@ -2518,8 +2575,54 @@ function applyHostState(host, state, prevPipelineAttrs, incomingProps) {
       host.setAttribute(key, String(value));
       prevPipelineAttrs.add(key);
     }
-  });
+  }
+}
+
+// ../../adapters/lit/src/create-contract-component.ts
+import { LitElement, html } from "lit";
+
+// ../../adapters/lit/src/build-runtime.ts
+import { silentDiagnostics as silentDiagnostics4 } from "../_shared/diagnostics.js";
+function normalizeOptions(options) {
+  return {
+    ...options,
+    ...resolveAdapterCommonOptions(options, "PolymorphicElement", silentDiagnostics4)
+  };
+}
+function buildRuntime(options) {
+  const { filterProps: customFilter, enforcement } = options;
+  const normalized = normalizeOptions(options);
+  const { runtime, ownedKeys } = buildCoreRuntime(normalized);
+  const { childrenEvaluator } = buildEngines(
+    normalized.diagnostics,
+    enforcement?.children,
+    normalized.name
+  );
+  const filterProps = composeFilter(ownedKeys, customFilter);
+  return {
+    runtime,
+    filterProps,
+    ...childrenEvaluator !== void 0 && { childrenEvaluator }
+  };
+}
+
+// ../../adapters/lit/src/render-to-string.ts
+var ssrRegistry = /* @__PURE__ */ new WeakMap();
+function registerForSsr(cls, bundle) {
+  ssrRegistry.set(cls, { bundle });
+}
+function renderToString(component, props = {}, innerHTML = "") {
+  const entry = ssrRegistry.get(component);
+  if (!entry) {
+    const name = component.name ?? "AnonymousComponent";
+    throw new Error(
+      `[renderToString] ${name} was not registered for SSR. Ensure it was created with createContractComponent from @praxis-kit/lit.`
+    );
+  }
+  return renderBundleToString(entry.bundle, props, innerHTML);
 }
+
+// ../../adapters/lit/src/create-contract-component.ts
 function createContractComponent(options) {
   const bundle = buildRuntime(options);
   const looseBundle = toLooseBundle(bundle);
@@ -2587,7 +2690,8 @@ function createContractComponent(options) {
       const self = this._self;
       const props = {};
       iterate.forEach(iterate.items(this.attributes), (attr) => {
-        if (attr.name !== "class") props[attr.name] = attr.value;
+        if (attr.name === "class") return;
+        props[attr.name] = attr.name === "disabled" ? true : attr.value;
       });
       props["as"] = self.as;
       props["recipe"] = self.recipe;
@@ -2596,12 +2700,15 @@ function createContractComponent(options) {
         const val = self[key];
         if (val != null) props[key] = val;
       });
-      applyHostState(this, resolveHostState(looseBundle, props), this._pipelineAttrs, props);
+      diffAndApplyAttributes(this, resolveHostState(looseBundle, props), this._pipelineAttrs, props);
     }
     render() {
+      const children = Array.from(this.childNodes);
       if (bundle.childrenEvaluator) {
-        bundle.childrenEvaluator.evaluate(Array.from(this.childNodes));
+        bundle.childrenEvaluator.evaluate(children);
       }
+      const tag = bundle.runtime.resolveTag(this._self.as);
+      bundle.runtime.options.htmlChildrenEvaluatorFn?.(tag)?.evaluate(children);
       return html`<slot></slot>`;
     }
   }