praxis-kit 4.0.1 → 4.1.0

package/dist/solid/index.js

@@ -23,205 +23,47 @@ function isNull(value) {
   return value === null;
 }
 
-// ../../lib/adapter-utils/src/apply-display-name.ts
-function applyDisplayName(component, name) {
-  Object.assign(component, { displayName: name ?? "PolymorphicComponent" });
-}
-
-// ../../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);
+// ../../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 forEachValue(object, callback) {
-  for (const value of values(object)) {
-    callback(value);
+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);
 }
-function forEachSet(s, callback) {
-  for (const value of s) {
-    callback(value);
-  }
+
+// ../../lib/adapter-utils/src/runtime/apply-display-name.ts
+function applyDisplayName(component, name) {
+  Object.assign(component, { displayName: name ?? "PolymorphicComponent" });
 }
-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/adapter-utils/src/runtime/define-component.ts
+function defineContractComponent(options) {
+  return (factory) => factory(options);
 }
 
 // ../../lib/primitive/src/constants/aria/global-aria-attributes.ts
@@ -246,7 +88,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",
@@ -282,8 +124,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",
@@ -297,20 +139,22 @@ 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);
 
 // ../../lib/primitive/src/constants/aria/known-aria-roles.ts
-var KNOWN_ARIA_ROLES = [
+var KNOWN_ARIA_ROLES = Object.freeze([
   "alert",
   "alertdialog",
   "application",
@@ -392,7 +236,7 @@ var KNOWN_ARIA_ROLES = [
   "tree",
   "treegrid",
   "treeitem"
-];
+]);
 var KNOWN_ARIA_ROLES_SET = new Set(KNOWN_ARIA_ROLES);
 
 // ../../lib/primitive/src/constants/aria/role-restricted-attributes.ts
@@ -550,59 +394,244 @@ var ROLE_RESTRICTED_ATTRIBUTES = /* @__PURE__ */ new Map([
 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);
+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);
+}
+
+// ../../lib/primitive/src/guards/aria/is-aria-role.ts
+function isStrongImplicitRole(tag) {
+  if (!(tag in IMPLICIT_ROLE_RECORD)) return false;
+  return STRONG_ROLES_SET.has(IMPLICIT_ROLE_RECORD[tag]);
+}
+function isStandaloneTag(tag) {
+  if (!(tag in IMPLICIT_ROLE_RECORD)) return false;
+  return STANDALONE_ROLES_SET.has(IMPLICIT_ROLE_RECORD[tag]);
+}
+function getInputImplicitRole(type) {
+  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 = isString(ariaLabel) || isString(ariaLabelledBy);
+  if (!isNamed) return void 0;
+  if (tag === "section") return "region";
+  if (tag === "form") return "form";
+  return void 0;
+}
+
+// ../../lib/primitive/src/guards/aria/is-known-aria-role.ts
+function isKnownAriaRole(value) {
+  return isString(value) && KNOWN_ARIA_ROLES_SET.has(value);
+}
+
+// ../../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;
+        }
+      }
+    }
+  };
 }
-
-// ../../lib/primitive/src/guards/aria/is-aria-role.ts
-function isStrongImplicitRole(tag) {
-  if (!(tag in IMPLICIT_ROLE_RECORD)) return false;
-  return STRONG_ROLES_SET.has(IMPLICIT_ROLE_RECORD[tag]);
+function mapEntries(m) {
+  return m.entries();
 }
-function isStandaloneTag(tag) {
-  if (!(tag in IMPLICIT_ROLE_RECORD)) return false;
-  return STANDALONE_ROLES_SET.has(IMPLICIT_ROLE_RECORD[tag]);
+function set(s) {
+  return s.values();
 }
-function getInputImplicitRole(type) {
-  if (type == null || !(type in INPUT_TYPE_ROLE_MAP)) return void 0;
-  return INPUT_TYPE_ROLE_MAP[type];
+function hasOwn(object, key) {
+  return Object.hasOwn(object, key);
 }
-function getConditionalImplicitRole(tag, ariaLabel, ariaLabelledBy) {
-  const isNamed = typeof ariaLabel === "string" || typeof ariaLabelledBy === "string";
-  if (!isNamed) return void 0;
-  if (tag === "section") return "region";
-  if (tag === "form") return "form";
-  return void 0;
+function* entries(object) {
+  for (const key in object) {
+    if (!hasOwn(object, key)) continue;
+    yield [key, object[key]];
+  }
 }
-
-// ../../lib/primitive/src/guards/aria/is-known-aria-role.ts
-function isKnownAriaRole(value) {
-  return isString(value) && KNOWN_ARIA_ROLES_SET.has(value);
+function* keys(object) {
+  for (const [key] of entries(object)) {
+    yield key;
+  }
 }
-
-// ../../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;
+function* values(object) {
+  for (const [, value] of entries(object)) {
+    yield value;
+  }
 }
-
-// ../../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"]);
+function mapValues(object, callback) {
+  const result = {};
+  for (const [key, value] of entries(object)) {
+    result[key] = callback(value, key);
   }
-  return void 0;
+  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/strict/invariant-base.ts
@@ -627,159 +656,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: [
@@ -792,8 +683,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: [
@@ -807,8 +698,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."
     };
@@ -816,8 +707,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: [
@@ -830,8 +721,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: [
@@ -844,8 +735,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: [
@@ -862,8 +753,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: [
@@ -876,8 +767,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: [
@@ -895,8 +786,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: [
@@ -909,8 +800,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: [
@@ -923,8 +814,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: [
@@ -937,8 +828,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."
     };
@@ -946,11 +837,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}.`
     };
@@ -958,69 +850,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.`
     };
@@ -1028,73 +920,75 @@ 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}.`
     };
   }
 };
 
 // ../../lib/contract/src/diagnostics/slot.ts
+import { DiagnosticCategory as DiagnosticCategory4, DiagnosticCode as DiagnosticCode4 } from "../_shared/diagnostics.js";
 var SlotDiagnostics = {
   exclusive(name) {
     return {
-      code: "SLOT1001" /* SlotExclusive */,
-      category: 0 /* Contract */,
+      code: DiagnosticCode4.SlotExclusive,
+      category: DiagnosticCategory4.Contract,
       component: name,
       message: `${name}: "as" and "asChild" are mutually exclusive`
     };
   },
   singleChildRequired(name, elementTerm) {
     return {
-      code: "SLOT1002" /* SlotSingleChild */,
-      category: 0 /* Contract */,
+      code: DiagnosticCode4.SlotSingleChild,
+      category: DiagnosticCategory4.Contract,
       component: name,
       message: `${name}: asChild requires a ${elementTerm} child`
     };
   },
   singleChildExceeded(name, elementTerm, count) {
     return {
-      code: "SLOT1002" /* SlotSingleChild */,
-      category: 0 /* Contract */,
+      code: DiagnosticCode4.SlotSingleChild,
+      category: DiagnosticCategory4.Contract,
       component: name,
       message: `${name}: asChild requires exactly one ${elementTerm} child, got ${count}`
     };
@@ -1102,16 +996,16 @@ var SlotDiagnostics = {
   discardedChildren(name, elementTerm, count) {
     const suffix = count === 1 ? "" : "ren";
     return {
-      code: "SLOT1003" /* SlotDiscardedChildren */,
-      category: 0 /* Contract */,
+      code: DiagnosticCode4.SlotDiscardedChildren,
+      category: DiagnosticCategory4.Contract,
       component: name,
       message: `${name}: asChild discarded ${count} non-element child${suffix} \u2014 only ${elementTerm}s are valid asChild children.`
     };
   },
   renderFnRequired(name, received) {
     return {
-      code: "SLOT1004" /* SlotRenderFn */,
-      category: 0 /* Contract */,
+      code: DiagnosticCode4.SlotRenderFn,
+      category: DiagnosticCategory4.Contract,
       component: name,
       message: `${name}: asChild requires a render function as children, got ${received}`
     };
@@ -1795,7 +1689,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
@@ -2046,6 +1940,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 = {
@@ -2088,6 +1985,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]],
@@ -2275,7 +2333,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;
@@ -2367,21 +2439,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 DiagnosticCategory5, DiagnosticCode as DiagnosticCode5 } from "../_shared/diagnostics.js";
 var PluginDiagnostics = {
   invalidShape(received) {
     const got = received === null ? "null" : typeof received;
     return {
-      code: "PLUGIN7001" /* PluginInvalidShape */,
-      category: 7 /* Internal */,
+      code: DiagnosticCode5.PluginInvalidShape,
+      category: DiagnosticCategory5.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: DiagnosticCode5.PluginPipelineReturnType,
+      category: DiagnosticCategory5.Internal,
       message: `[praxis-kit] Plugin pipeline must return a string. Got: ${got}.`
     };
   }
@@ -2405,89 +2481,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 resolveTag3 = memoizedTagPipeline(anyResolved);
+  const resolveProps = memoizedPropsPipeline(anyResolved);
+  const resolveAriaFn = options.enforcement !== void 0 ? memoizedAriaPipeline(anyResolved) : resolveAriaPassthrough;
+  const methods = {
+    resolveTag: resolveTag3,
+    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);
@@ -2495,12 +2564,32 @@ 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
+// ../../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
+  };
+}
+
+// ../../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;
+}
+
+// ../../lib/adapter-utils/src/props/compose-filter.ts
 function composeFilter(ownedKeys, filterProps) {
   const defaultFilter = (key, variantKeys) => variantKeys.has(key) || ownedKeys.has(key);
   if (!filterProps) {
@@ -2509,14 +2598,6 @@ function composeFilter(ownedKeys, filterProps) {
   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) {
-  return {
-    name: options.name ?? defaultName,
-    diagnostics: options.enforcement?.diagnostics ?? defaultDiagnostics
-  };
-}
-
 // ../../adapters/solid/src/slot/slot-validator.ts
 var SlotValidator = class extends InvariantBase {
   #name;
@@ -2593,7 +2674,7 @@ function resolveTag2(runtime, as) {
   return runtime.resolveTag(as);
 }
 function resolveDomProps(tag, elementProps, runtime) {
-  return typeof tag === "string" ? runtime.resolveAria(tag, elementProps).props : elementProps;
+  return isString(tag) ? runtime.resolveAria(tag, elementProps).props : elementProps;
 }
 function tryRenderAsChild(known, filteredProps, resolvedClass, slotValidator) {
   if (!known.asChild) return null;
@@ -2634,9 +2715,20 @@ function render({
   const filteredProps = createMemo(
     () => applyFilter(normalizedProps(), filterProps, runtime.options.variantKeys)
   );
+  const { allowedAs } = runtime.options;
+  if (allowedAs !== void 0) {
+    createEffect(
+      () => enforceAllowedAs(tag(), allowedAs, runtime.options.diagnostics, runtime.options.displayName)
+    );
+  }
   if (process.env.NODE_ENV !== "production" && childrenEvaluator) {
     createEffect(() => childrenEvaluator.evaluate(toChildArray(known.children)));
   }
+  if (process.env.NODE_ENV !== "production") {
+    createEffect(
+      () => runtime.options.htmlChildrenEvaluatorFn?.(tag())?.evaluate(toChildArray(known.children))
+    );
+  }
   const slotResult = tryRenderAsChild(known, filteredProps, resolvedClass, slotValidator);
   if (slotResult !== null) return slotResult;
   const domProps = createMemo(() => {