praxis-kit 5.0.0 → 6.0.0

package/dist/tailwind/index.js

@@ -358,6 +358,14 @@ function createClassPipeline(resolved) {
   };
 }
 
+// ../../lib/pipeline-kit/src/core/compose-pipelines.ts
+function composePipelines(first, second) {
+  return (...args) => second(first(...args));
+}
+
+// ../../lib/tailwind/src/create-tailwind-pipeline.ts
+import { ConsoleReporter, DefaultPolicy, Diagnostics, Severity } from "../_shared/diagnostics.js";
+
 // ../../lib/tailwind/src/class-builder.ts
 var ClassBuilder = class {
   build(tokens) {
@@ -371,6 +379,7 @@ var ClassBuilder = class {
         }
         case "utility":
         case "gap":
+        case "shared":
         case "conditional": {
           normal.push(token.raw);
           break;
@@ -444,6 +453,16 @@ var CONDITIONALS = {
   "[&.flex": "flex",
   "[&.grid": "grid"
 };
+var SHARED_PREFIXES = [
+  /^order/,
+  /^justify-(?!items-|self-)/,
+  /^content-/,
+  /^items-/,
+  /^self-/,
+  /^place-content-/,
+  /^place-items-/,
+  /^place-self-/
+];
 var ClassClassifier = class _ClassClassifier {
   static #getBaseUtility(token) {
     let depth = 0;
@@ -476,23 +495,16 @@ var ClassClassifier = class _ClassClassifier {
       }
     );
     if (conditional !== null) return conditional;
-    return base === "gap" || base.startsWith("gap-") ? {
-      kind: "gap",
-      raw: token
-    } : {
-      kind: "utility",
-      base,
-      raw: token
-    };
+    if (base === "gap" || base.startsWith("gap-")) {
+      return { kind: "gap", raw: token };
+    }
+    if (SHARED_PREFIXES.some((rule) => rule.test(base))) {
+      return { kind: "shared", raw: token };
+    }
+    return { kind: "utility", base, raw: token };
   }
 };
 
-// ../../lib/tailwind/src/dependency-rules.ts
-var defaultDependencyRules = {
-  flex: [/^flex-/, /^grow/, /^shrink/, /^basis-/],
-  grid: [/^grid-/, /^col-/, /^row-/, /^auto-cols-/, /^auto-rows-/]
-};
-
 // ../../lib/tailwind/src/dependency-evaluator.ts
 var DependencyEvaluator = class {
   constructor(rules) {
@@ -513,7 +525,8 @@ var DependencyEvaluator = class {
           (layout) => this.rules[layout].some((rule) => rule.test(token.base)) ? state.family === layout : null
         ) ?? true;
       }
-      case "gap": {
+      case "gap":
+      case "shared": {
         return state.family !== "none";
       }
       default:
@@ -522,26 +535,22 @@ var DependencyEvaluator = class {
   }
 };
 
-// ../../lib/tailwind/src/layout-state.ts
-var LayoutState = class {
-  #mode;
-  #family;
-  constructor(mode) {
-    this.#mode = mode;
-    this.#family = mode === "none" ? "none" : LAYOUT_FAMILY_MAP[mode];
-    Object.freeze(this);
-  }
-  get mode() {
-    return this.#mode;
-  }
-  get family() {
-    return this.#family;
-  }
+// ../../lib/tailwind/src/dependency-rules.ts
+var defaultDependencyRules = {
+  flex: [/^flex-/, /^grow/, /^shrink/, /^basis-/],
+  grid: [
+    /^grid-/,
+    /^col-/,
+    /^row-/,
+    /^auto-cols-/,
+    /^auto-rows-/,
+    // justify-items/-self are no-ops on flex containers per the CSS box
+    // alignment spec (flex items ignore them), so treat as grid-only.
+    /^justify-items-/,
+    /^justify-self-/
+  ]
 };
 
-// ../../lib/tailwind/src/create-tailwind-pipeline.ts
-import { ConsoleReporter, Diagnostics, DefaultPolicy, Severity } from "../_shared/diagnostics.js";
-
 // ../../lib/tailwind/src/diagnostics.ts
 import { DiagnosticCategory, DiagnosticCode } from "../_shared/diagnostics.js";
 var TailwindDiagnostics = {
@@ -568,6 +577,23 @@ var TailwindDiagnostics = {
   }
 };
 
+// ../../lib/tailwind/src/layout-state.ts
+var LayoutState = class {
+  #mode;
+  #family;
+  constructor(mode) {
+    this.#mode = mode;
+    this.#family = mode === "none" ? "none" : LAYOUT_FAMILY_MAP[mode];
+    Object.freeze(this);
+  }
+  get mode() {
+    return this.#mode;
+  }
+  get family() {
+    return this.#family;
+  }
+};
+
 // ../../lib/tailwind/src/create-tailwind-pipeline.ts
 var DEV = process.env.NODE_ENV !== "production";
 var devDiagnostics = new Diagnostics(
@@ -648,23 +674,36 @@ function warnDeadVariants(diagnostics, options, compoundDims, props, recipe, sta
   });
 }
 function createTailwindPipeline(options, diagnostics) {
-  const pipeline = createClassPipeline(options);
+  const innerPipeline = createClassPipeline(options);
   const compoundDims = compoundDimensions(getCompoundVariants(options));
+  const resolveLayoutContext = (tag, props, className, recipe) => {
+    const mode = resolveLayout(devDiagnostics, props);
+    const resolvedClasses = innerPipeline(tag, props, className, recipe);
+    const tokens = classifyTokens(resolvedClasses);
+    const state = new LayoutState(mode);
+    const filtered = tokens.filter((token) => evaluator.evaluate(token, state));
+    return { mode, state, filtered, tokens, props, recipe };
+  };
+  const buildClassString = (ctx) => {
+    const built = builder.build(ctx.filtered);
+    if (ctx.mode === "none") return built;
+    return ctx.filtered.some((t) => t.kind === "layout" && t.value === ctx.mode) ? built : cn(ctx.mode, built);
+  };
+  const emitDiagnosticsFromContext = (ctx) => {
+    if (!DEV) return;
+    warnReservedLayoutLiterals(diagnostics, ctx.tokens);
+    warnDeadVariants(diagnostics, options, compoundDims, ctx.props, ctx.recipe, ctx.state);
+  };
+  const combined = (ctx) => {
+    const built = buildClassString(ctx);
+    emitDiagnosticsFromContext(ctx);
+    return built;
+  };
+  const mainPipeline = composePipelines(resolveLayoutContext, combined);
   return {
     ownedKeys: LAYOUT_OWNED_KEYS,
     pipeline(tag, props, className, recipe) {
-      const mode = resolveLayout(devDiagnostics, props);
-      const raw = pipeline(tag, props, className, recipe);
-      const tokens = classifyTokens(raw);
-      const state = new LayoutState(mode);
-      if (DEV) {
-        warnReservedLayoutLiterals(diagnostics, tokens);
-        warnDeadVariants(diagnostics, options, compoundDims, props, recipe, state);
-      }
-      const filtered = tokens.filter((token) => evaluator.evaluate(token, state));
-      const built = builder.build(filtered);
-      if (mode === "none") return built;
-      return filtered.some((t) => t.kind === "layout" && t.value === mode) ? built : cn(mode, built);
+      return mainPipeline(tag, props, className, recipe);
     }
   };
 }

package/dist/vue/index.d.ts

@@ -31,6 +31,26 @@ type MinMax = {
 };
 type CardinalityInput = Partial<MinMax>;
 
+/**
+ * Resolved per-instance state available to a dynamic (`dynamic(...)`) child
+ * rule field — the same tag/props every adapter already computes before
+ * evaluating children, exposed so a rule can vary by them (e.g. cardinality
+ * that depends on the resolved `as` tag).
+ */
+type ChildRuleContext = {
+    readonly tag: unknown;
+    readonly props: Readonly<AnyRecord>;
+};
+
+declare const RULE_BRAND: unique symbol;
+
+type DynamicRule<T, C = unknown> = {
+    readonly [RULE_BRAND]: true;
+    resolve(context: C): T;
+};
+
+type Rule<T, C = unknown> = T | DynamicRule<T, C>;
+
 type ChildRuleMatch<T, U extends T = T> = (child: T) => child is U;
 
 type ChildRulePosition = 'first' | 'last' | 'any';
@@ -38,7 +58,13 @@ type ChildRulePosition = 'first' | 'last' | 'any';
 type ChildRuleInput<T = unknown, U extends T = T> = {
     name: string;
     match: ChildRuleMatch<T, U>;
-    cardinality?: CardinalityInput;
+    /**
+     * Either a static cardinality, or `dynamic((ctx) => ...)` to derive it from
+     * the resolved tag/props (e.g. a different max depending on `as`). `match`
+     * stays static-only — it's already a function, so a dynamic wrapper would
+     * be indistinguishable from the predicate itself without one.
+     */
+    cardinality?: Rule<CardinalityInput, ChildRuleContext>;
     position?: ChildRulePosition;
     /**
      * Optional component-type reference for O(1) dispatch index.

package/dist/vue/index.js

@@ -456,6 +456,19 @@ function makeResolveTag(defaultTag) {
   };
 }
 
+// ../../lib/primitive/src/rule/rule-brand.ts
+var RULE_BRAND = /* @__PURE__ */ Symbol("praxis-kit/dynamic-rule");
+
+// ../../lib/primitive/src/rule/is-dynamic-rule.ts
+function isDynamicRule(rule) {
+  return isObject(rule, true) && rule[RULE_BRAND] === true;
+}
+
+// ../../lib/primitive/src/rule/resolve-rule.ts
+function resolveRule(rule, context) {
+  return isDynamicRule(rule) ? rule.resolve(context) : rule;
+}
+
 // ../../lib/primitive/src/utils/assert-never.ts
 function assertNever(value) {
   throw new Error(`Unexpected value: ${String(value)}`);
@@ -1868,10 +1881,22 @@ var RuleValidator = class _RuleValidator extends InvariantBase {
 
 // ../../lib/contract/src/children/children-evaluator.ts
 var isTextLike = (child) => isString(child) || isNumber(child);
+function checkPositionCardinalityInvariant(rules, context) {
+  iterate.forEach(rules, (rule) => {
+    const { name, position, cardinality } = rule;
+    if ((position === "first" || position === "last") && (cardinality.kind === "unbounded" || cardinality.max > 1)) {
+      throw new RangeError(
+        `ChildrenEvaluator [${context}]: rule "${name}" sets position="${position}" with an unbound or >1 max. position="first|last" implies max=1.`
+      );
+    }
+  });
+}
 var ChildrenEvaluator = class extends InvariantBase {
   #context;
-  #rules;
-  #ruleNames;
+  /** Rules with a static cardinality — normalized once, reused on every evaluate() call. */
+  #staticRules;
+  /** Rules whose cardinality is `dynamic(...)` — re-resolved against a ChildRuleContext per call. */
+  #dynamicRuleInputs;
   #matcher;
   #ruleValidator;
   #exclusiveChildren;
@@ -1879,29 +1904,39 @@ var ChildrenEvaluator = class extends InvariantBase {
   constructor(rules, diagnostics, context = "Component", options = {}) {
     super(diagnostics);
     this.#context = context;
-    this.#rules = rules.map((r) => normalizeChildRule(r));
-    this.#ruleNames = this.#rules.map((r) => r.name);
     this.#exclusiveChildren = options.exclusiveChildren ?? false;
     this.#allowText = options.allowText ?? true;
-    iterate.forEach(this.#rules, (rule) => {
-      const { name, position, cardinality } = rule;
-      if ((position === "first" || position === "last") && (cardinality.kind === "unbounded" || cardinality.max > 1)) {
-        throw new RangeError(
-          `ChildrenEvaluator [${context}]: rule "${name}" sets position="${position}" with an unbound or >1 max. position="first|last" implies max=1.`
-        );
-      }
+    const staticRuleInputs = [];
+    const dynamicRuleInputs = [];
+    iterate.forEach(rules, (rule) => {
+      if (isDynamicRule(rule.cardinality)) dynamicRuleInputs.push(rule);
+      else staticRuleInputs.push(rule);
     });
-    this.#matcher = new RuleMatcher(this.#rules);
+    this.#dynamicRuleInputs = dynamicRuleInputs;
+    this.#staticRules = staticRuleInputs.map(
+      (r) => normalizeChildRule(r)
+    );
     this.#ruleValidator = new RuleValidator(context, diagnostics);
+    if (this.#dynamicRuleInputs.length === 0) {
+      checkPositionCardinalityInvariant(this.#staticRules, context);
+      this.#matcher = new RuleMatcher(this.#staticRules);
+    } else {
+      this.#matcher = void 0;
+    }
   }
-  evaluate(children) {
+  /**
+   * @param context Required when any rule has a `dynamic(...)` cardinality —
+   *   supplies the resolved tag/props those rules are evaluated against.
+   */
+  evaluate(children, context) {
     if (!this.active) return;
+    const { rules, matcher } = this.#resolveRules(context);
     const {
       matrix,
       unexpectedIndices: rawUnexpectedIndices,
       ambiguousIndices
-    } = this.#matcher.match(children);
-    this.#ruleValidator.validate(this.#rules, matrix, children.length);
+    } = matcher.match(children);
+    this.#ruleValidator.validate(rules, matrix, children.length);
     const unexpectedIndices = new Set(
       [...rawUnexpectedIndices].filter(
         (ci) => isTextLike(children[ci]) ? this.#allowText === false : this.#exclusiveChildren
@@ -1915,11 +1950,28 @@ var ChildrenEvaluator = class extends InvariantBase {
         this.violate(ContractDiagnostics.unexpectedChild(typeName, ci, this.#context));
       } else {
         const matches = matrix.childToRules.forward.get(ci);
-        const names = [...matches].map((ri) => this.#ruleNames[ri] ?? `#${ri}`);
+        const names = [...matches].map((ri) => rules[ri]?.name ?? `#${ri}`);
         this.violate(ContractDiagnostics.ambiguousChild(typeName, ci, names, this.#context));
       }
     });
   }
+  #resolveRules(context) {
+    if (this.#dynamicRuleInputs.length === 0) {
+      return { rules: this.#staticRules, matcher: this.#matcher };
+    }
+    if (context === void 0) {
+      throw new RangeError(
+        `ChildrenEvaluator [${this.#context}]: rule(s) have a dynamic(...) cardinality \u2014 evaluate() requires a context argument to resolve them.`
+      );
+    }
+    const resolvedDynamicRules = this.#dynamicRuleInputs.map((r) => {
+      const cardinality = resolveRule(r.cardinality, context);
+      return normalizeChildRule({ ...r, cardinality });
+    });
+    checkPositionCardinalityInvariant(resolvedDynamicRules, this.#context);
+    const rules = [...this.#staticRules, ...resolvedDynamicRules];
+    return { rules, matcher: new RuleMatcher(rules) };
+  }
 };
 
 // ../../lib/contract/src/props/get-disabled-props.ts
@@ -2785,6 +2837,7 @@ function prepareRenderState(runtime, attrs, filterProps) {
       ...asChild !== void 0 && { asChild }
     },
     props: filteredProps,
+    normalizedProps,
     className
   };
 }
@@ -2831,7 +2884,7 @@ function render({
 }) {
   const { vnodes: children, discarded } = normalizeChildren(slots);
   if (process.env.NODE_ENV !== "production") {
-    childrenEvaluator?.evaluate(children);
+    childrenEvaluator?.evaluate(children, { tag: state.tag, props: state.normalizedProps });
     runtime.options.htmlChildrenEvaluatorFn?.(state.tag)?.evaluate(children);
   }
   const slotResult = tryRenderAsChild(state, children, discarded, slotValidator);

package/dist/web/index.d.ts

@@ -29,6 +29,26 @@ type MinMax = {
 };
 type CardinalityInput = Partial<MinMax>;
 
+/**
+ * Resolved per-instance state available to a dynamic (`dynamic(...)`) child
+ * rule field — the same tag/props every adapter already computes before
+ * evaluating children, exposed so a rule can vary by them (e.g. cardinality
+ * that depends on the resolved `as` tag).
+ */
+type ChildRuleContext = {
+    readonly tag: unknown;
+    readonly props: Readonly<AnyRecord>;
+};
+
+declare const RULE_BRAND: unique symbol;
+
+type DynamicRule<T, C = unknown> = {
+    readonly [RULE_BRAND]: true;
+    resolve(context: C): T;
+};
+
+type Rule<T, C = unknown> = T | DynamicRule<T, C>;
+
 type ChildRuleMatch<T, U extends T = T> = (child: T) => child is U;
 
 type ChildRulePosition = 'first' | 'last' | 'any';
@@ -36,7 +56,13 @@ type ChildRulePosition = 'first' | 'last' | 'any';
 type ChildRuleInput<T = unknown, U extends T = T> = {
     name: string;
     match: ChildRuleMatch<T, U>;
-    cardinality?: CardinalityInput;
+    /**
+     * Either a static cardinality, or `dynamic((ctx) => ...)` to derive it from
+     * the resolved tag/props (e.g. a different max depending on `as`). `match`
+     * stays static-only — it's already a function, so a dynamic wrapper would
+     * be indistinguishable from the predicate itself without one.
+     */
+    cardinality?: Rule<CardinalityInput, ChildRuleContext>;
     position?: ChildRulePosition;
     /**
      * Optional component-type reference for O(1) dispatch index.

package/dist/web/index.js

@@ -313,6 +313,19 @@ function makeResolveTag(defaultTag) {
   };
 }
 
+// ../../lib/primitive/src/rule/rule-brand.ts
+var RULE_BRAND = /* @__PURE__ */ Symbol("praxis-kit/dynamic-rule");
+
+// ../../lib/primitive/src/rule/is-dynamic-rule.ts
+function isDynamicRule(rule) {
+  return isObject(rule, true) && rule[RULE_BRAND] === true;
+}
+
+// ../../lib/primitive/src/rule/resolve-rule.ts
+function resolveRule(rule, context) {
+  return isDynamicRule(rule) ? rule.resolve(context) : rule;
+}
+
 // ../../lib/primitive/src/utils/assert-never.ts
 function assertNever(value) {
   throw new Error(`Unexpected value: ${String(value)}`);
@@ -1715,10 +1728,22 @@ var RuleValidator = class _RuleValidator extends InvariantBase {
 
 // ../../lib/contract/src/children/children-evaluator.ts
 var isTextLike = (child) => isString(child) || isNumber(child);
+function checkPositionCardinalityInvariant(rules, context) {
+  iterate.forEach(rules, (rule) => {
+    const { name, position, cardinality } = rule;
+    if ((position === "first" || position === "last") && (cardinality.kind === "unbounded" || cardinality.max > 1)) {
+      throw new RangeError(
+        `ChildrenEvaluator [${context}]: rule "${name}" sets position="${position}" with an unbound or >1 max. position="first|last" implies max=1.`
+      );
+    }
+  });
+}
 var ChildrenEvaluator = class extends InvariantBase {
   #context;
-  #rules;
-  #ruleNames;
+  /** Rules with a static cardinality — normalized once, reused on every evaluate() call. */
+  #staticRules;
+  /** Rules whose cardinality is `dynamic(...)` — re-resolved against a ChildRuleContext per call. */
+  #dynamicRuleInputs;
   #matcher;
   #ruleValidator;
   #exclusiveChildren;
@@ -1726,29 +1751,39 @@ var ChildrenEvaluator = class extends InvariantBase {
   constructor(rules, diagnostics, context = "Component", options = {}) {
     super(diagnostics);
     this.#context = context;
-    this.#rules = rules.map((r) => normalizeChildRule(r));
-    this.#ruleNames = this.#rules.map((r) => r.name);
     this.#exclusiveChildren = options.exclusiveChildren ?? false;
     this.#allowText = options.allowText ?? true;
-    iterate.forEach(this.#rules, (rule) => {
-      const { name, position, cardinality } = rule;
-      if ((position === "first" || position === "last") && (cardinality.kind === "unbounded" || cardinality.max > 1)) {
-        throw new RangeError(
-          `ChildrenEvaluator [${context}]: rule "${name}" sets position="${position}" with an unbound or >1 max. position="first|last" implies max=1.`
-        );
-      }
+    const staticRuleInputs = [];
+    const dynamicRuleInputs = [];
+    iterate.forEach(rules, (rule) => {
+      if (isDynamicRule(rule.cardinality)) dynamicRuleInputs.push(rule);
+      else staticRuleInputs.push(rule);
     });
-    this.#matcher = new RuleMatcher(this.#rules);
+    this.#dynamicRuleInputs = dynamicRuleInputs;
+    this.#staticRules = staticRuleInputs.map(
+      (r) => normalizeChildRule(r)
+    );
     this.#ruleValidator = new RuleValidator(context, diagnostics);
+    if (this.#dynamicRuleInputs.length === 0) {
+      checkPositionCardinalityInvariant(this.#staticRules, context);
+      this.#matcher = new RuleMatcher(this.#staticRules);
+    } else {
+      this.#matcher = void 0;
+    }
   }
-  evaluate(children) {
+  /**
+   * @param context Required when any rule has a `dynamic(...)` cardinality —
+   *   supplies the resolved tag/props those rules are evaluated against.
+   */
+  evaluate(children, context) {
     if (!this.active) return;
+    const { rules, matcher } = this.#resolveRules(context);
     const {
       matrix,
       unexpectedIndices: rawUnexpectedIndices,
       ambiguousIndices
-    } = this.#matcher.match(children);
-    this.#ruleValidator.validate(this.#rules, matrix, children.length);
+    } = matcher.match(children);
+    this.#ruleValidator.validate(rules, matrix, children.length);
     const unexpectedIndices = new Set(
       [...rawUnexpectedIndices].filter(
         (ci) => isTextLike(children[ci]) ? this.#allowText === false : this.#exclusiveChildren
@@ -1762,11 +1797,28 @@ var ChildrenEvaluator = class extends InvariantBase {
         this.violate(ContractDiagnostics.unexpectedChild(typeName, ci, this.#context));
       } else {
         const matches = matrix.childToRules.forward.get(ci);
-        const names = [...matches].map((ri) => this.#ruleNames[ri] ?? `#${ri}`);
+        const names = [...matches].map((ri) => rules[ri]?.name ?? `#${ri}`);
         this.violate(ContractDiagnostics.ambiguousChild(typeName, ci, names, this.#context));
       }
     });
   }
+  #resolveRules(context) {
+    if (this.#dynamicRuleInputs.length === 0) {
+      return { rules: this.#staticRules, matcher: this.#matcher };
+    }
+    if (context === void 0) {
+      throw new RangeError(
+        `ChildrenEvaluator [${this.#context}]: rule(s) have a dynamic(...) cardinality \u2014 evaluate() requires a context argument to resolve them.`
+      );
+    }
+    const resolvedDynamicRules = this.#dynamicRuleInputs.map((r) => {
+      const cardinality = resolveRule(r.cardinality, context);
+      return normalizeChildRule({ ...r, cardinality });
+    });
+    checkPositionCardinalityInvariant(resolvedDynamicRules, this.#context);
+    const rules = [...this.#staticRules, ...resolvedDynamicRules];
+    return { rules, matcher: new RuleMatcher(rules) };
+  }
 };
 
 // ../../lib/contract/src/props/get-disabled-props.ts
@@ -2558,13 +2610,10 @@ function toLooseBundle(bundle) {
   }
   return bundle;
 }
-function resolveHostState(bundle, props) {
-  const { as, className, recipe, ...rest } = props;
-  const { options, resolveAria, resolveClasses, resolveProps, resolveTag: resolveTag2 } = bundle.runtime;
+function resolveTagAndNormalizedProps(bundle, props) {
+  const { as, className: _className, recipe: _recipe, ...rest } = props;
+  const { options, 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);
@@ -2574,6 +2623,15 @@ function resolveHostState(bundle, props) {
       Object.assign(finalProps, normalize(finalProps));
     }
   }
+  return { tag, normalizedProps: finalProps };
+}
+function resolveHostState(bundle, props) {
+  const { className, recipe } = props;
+  const { options, resolveAria, resolveClasses } = bundle.runtime;
+  const { tag, normalizedProps: finalProps } = resolveTagAndNormalizedProps(bundle, props);
+  if (options.allowedAs !== void 0) {
+    enforceAllowedAs(tag, options.allowedAs, options.diagnostics, options.displayName);
+  }
   const resolvedClass = resolveClasses(
     tag,
     finalProps,
@@ -2582,7 +2640,7 @@ function resolveHostState(bundle, props) {
   );
   const ariaResult = resolveAria(tag, finalProps);
   const attributes = applyFilter(ariaResult.props, bundle.filterProps, options.variantKeys);
-  return { className: resolvedClass, attributes };
+  return { className: resolvedClass, attributes, tag, normalizedProps: finalProps };
 }
 function diffAndApplyAttributes(host, state, prevPipelineAttrs, incomingProps) {
   const hasOwn2 = Object.hasOwn;
@@ -2689,14 +2747,8 @@ function createContractComponent(options) {
       const self = this._self;
       const {
         childrenEvaluator,
-        runtime: { options: options2, resolveTag: resolveTag2 }
+        runtime: { options: options2 }
       } = bundle;
-      const tag = resolveTag2(self.as);
-      const children = Array.from(this.childNodes);
-      if (childrenEvaluator) {
-        childrenEvaluator.evaluate(children);
-      }
-      options2.htmlChildrenEvaluatorFn?.(tag)?.evaluate(children);
       const observedSet = new Set(
         this.constructor.observedAttributes ?? []
       );
@@ -2712,7 +2764,16 @@ function createContractComponent(options) {
         const val = self[key] ?? this.getAttribute(key);
         if (val != null) props[key] = val;
       }
-      diffAndApplyAttributes(this, resolveHostState(looseBundle, props), this._pipelineAttrs, props);
+      const hostState = resolveHostState(looseBundle, props);
+      const children = Array.from(this.childNodes);
+      if (childrenEvaluator) {
+        childrenEvaluator.evaluate(children, {
+          tag: hostState.tag,
+          props: hostState.normalizedProps
+        });
+      }
+      options2.htmlChildrenEvaluatorFn?.(hostState.tag)?.evaluate(children);
+      diffAndApplyAttributes(this, hostState, this._pipelineAttrs, props);
     }
   }
   if (options.name) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praxis-kit",
-  "version": "5.0.0",
+  "version": "6.0.0",
   "type": "module",
   "exports": {
     "./react": {
@@ -184,10 +184,10 @@
     "vue": "^3.5.38",
     "@praxis-kit/core": "0.0.0",
     "@praxis-kit/adapter-utils": "0.0.0",
-    "@praxis-kit/pipeline": "0.0.0",
-    "@praxis-kit/primitive": "0.0.0",
     "@praxis-kit/diagnostics": "0.0.0",
-    "@praxis-kit/vite-plugin": "0.0.0"
+    "@praxis-kit/pipeline": "0.0.0",
+    "@praxis-kit/vite-plugin": "0.0.0",
+    "@praxis-kit/primitive": "0.0.0"
   },
   "publishConfig": {
     "access": "public"