praxis-kit 4.0.3 → 4.1.1

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);
@@ -465,49 +273,270 @@ function isAriaAttributeValidForRole(attr, role) {
   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]);
+
+// ../../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/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 isStandaloneTag(tag) {
-  if (!(tag in IMPLICIT_ROLE_RECORD)) return false;
-  return STANDALONE_ROLES_SET.has(IMPLICIT_ROLE_RECORD[tag]);
+function forEachKey(object, callback) {
+  for (const key of keys(object)) {
+    callback(key);
+  }
 }
-function getInputImplicitRole(type) {
-  if (type == null || !(type in INPUT_TYPE_ROLE_MAP)) return void 0;
-  return INPUT_TYPE_ROLE_MAP[type];
+function forEachValue(object, callback) {
+  for (const value of values(object)) {
+    callback(value);
+  }
 }
-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 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/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/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 {
@@ -1518,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
@@ -1769,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 = {
@@ -1811,6 +1843,171 @@ 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) => {
+    if (!isObject(child) || !("type" in child)) return false;
+    const tag = getTag(child);
+    return tag === void 0 || !set2.has(tag);
+  };
+}
+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]],
@@ -1998,6 +2195,19 @@ 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();
@@ -2133,89 +2343,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);
@@ -2223,22 +2426,13 @@ 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
-import { throwDiagnostics as throwDiagnostics2, silentDiagnostics as silentDiagnostics2 } from "../_shared/diagnostics.js";
+// ../../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,
@@ -2246,36 +2440,27 @@ function resolveAdapterCommonOptions(options, defaultName = "PolymorphicComponen
   };
 }
 
-// ../../adapters/lit/src/build-runtime.ts
-import { silentDiagnostics as silentDiagnostics3 } from "../_shared/diagnostics.js";
-function normalizeOptions(options) {
-  return {
-    ...options,
-    ...resolveAdapterCommonOptions(options, "PolymorphicElement", silentDiagnostics3)
-  };
-}
-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;");
 }
@@ -2289,51 +2474,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;
 }
@@ -2345,41 +2530,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) {
@@ -2389,8 +2579,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);
@@ -2458,7 +2694,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;
@@ -2467,12 +2704,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>`;
     }
   }