praxis-kit 6.6.1 → 7.3.0

package/dist/_shared/diagnostics.d.ts

@@ -92,6 +92,7 @@ declare enum DiagnosticCode {
     TailwindMultipleDisplayProps = "CSS6001",
     TailwindReservedLayoutLiteral = "CSS6002",
     TailwindDeadVariantClass = "CSS6003",
+    TailwindLayoutOnVoidTag = "CSS6004",
     PluginInvalidShape = "PLUGIN7001",
     PluginPipelineReturnType = "PLUGIN7002",
     InternalError = "INTERNAL9000"

package/dist/_shared/diagnostics.js

@@ -93,6 +93,7 @@ var DiagnosticCode = /* @__PURE__ */ ((DiagnosticCode2) => {
   DiagnosticCode2["TailwindMultipleDisplayProps"] = "CSS6001";
   DiagnosticCode2["TailwindReservedLayoutLiteral"] = "CSS6002";
   DiagnosticCode2["TailwindDeadVariantClass"] = "CSS6003";
+  DiagnosticCode2["TailwindLayoutOnVoidTag"] = "CSS6004";
   DiagnosticCode2["PluginInvalidShape"] = "PLUGIN7001";
   DiagnosticCode2["PluginPipelineReturnType"] = "PLUGIN7002";
   DiagnosticCode2["InternalError"] = "INTERNAL9000";

package/dist/{chunk-6JILZ6GQ.js → chunk-EIKPSL26.js}

@@ -3,6 +3,12 @@ function defineContractComponent(options) {
   return (factory) => factory(options);
 }
 
+// ../../lib/adapter-utils/src/runtime/assemble-compound-component.ts
+function assembleCompoundComponent(root, subComponents) {
+  if (!subComponents) return root;
+  return Object.assign(root, subComponents);
+}
+
 // ../../lib/primitive/src/tag/resolve-tag.ts
 function makeResolveTag(defaultTag) {
   return function tag(as) {
@@ -16,6 +22,11 @@ var EVENT_HANDLER_RE = /^on[A-Z]/;
 // ../../lib/primitive/src/rule/rule-brand.ts
 var RULE_BRAND = /* @__PURE__ */ Symbol("praxis-kit/dynamic-rule");
 
+// ../../lib/primitive/src/rule/dynamic.ts
+function dynamic(resolve) {
+  return { [RULE_BRAND]: true, resolve };
+}
+
 // ../../lib/primitive/src/guards/foundational/is-defined.ts
 function isUndefined(value) {
   return value === void 0;
@@ -29,7 +40,7 @@ function isNonNull(value) {
   return value != null;
 }
 function isNullish(value) {
-  return isNull(value) || value === void 0;
+  return isNull(value) || isUndefined(value);
 }
 
 // ../../lib/primitive/src/utils/type-guards.ts
@@ -54,7 +65,7 @@ function isPlainObject(value) {
 
 // ../../lib/primitive/src/rule/is-dynamic-rule.ts
 function isDynamicRule(rule) {
-  return isObject(rule, true) && rule[RULE_BRAND] === true;
+  return isObject(rule, true) && Reflect.get(rule, RULE_BRAND) === true;
 }
 
 // ../../lib/primitive/src/rule/resolve-rule.ts
@@ -643,6 +654,24 @@ var ROLE_RESTRICTED_ATTRIBUTES = /* @__PURE__ */ new Map([
   ]
 ]);
 
+// ../../lib/primitive/src/constants/html/void-tags.ts
+var VOID_TAGS = [
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+];
+
 // ../../lib/primitive/src/constants/primitive/slot-name.ts
 var SLOT_NAME = "Slot";
 
@@ -699,17 +728,17 @@ var COMPONENT_DEFAULT_TAG = /* @__PURE__ */ Symbol.for("praxis.component-default
 // ../../lib/primitive/src/guards/children/is-tag.ts
 function getAsProp(child) {
   if (!isObject(child) || !("props" in child)) return void 0;
-  const props = child.props;
+  const { props } = child;
   if (!isObject(props)) return void 0;
-  const as = props.as;
+  const as = Reflect.get(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;
+  const { type: t } = child;
   if (isString(t)) return t;
   if (typeof t === "function" || isObject(t)) {
-    const defaultTag = t[COMPONENT_DEFAULT_TAG];
+    const defaultTag = Reflect.get(t, COMPONENT_DEFAULT_TAG);
     if (!isString(defaultTag)) return void 0;
     return getAsProp(child) ?? defaultTag;
   }
@@ -729,6 +758,36 @@ function isTag(...args) {
   return tag !== void 0 && set2.has(tag);
 }
 
+// ../../lib/adapter-utils/src/runtime/finalize-component.ts
+function finalizeComponent(component, defaultTag, subComponents) {
+  if (typeof defaultTag === "string") {
+    Object.assign(component, { [COMPONENT_DEFAULT_TAG]: defaultTag });
+  }
+  return assembleCompoundComponent(component, subComponents);
+}
+
+// ../../lib/adapter-utils/src/runtime/is-factory-options-like.ts
+var FACTORY_OPTIONS_FIELD_VALIDATORS = {
+  tag: (v) => v === void 0 || isString(v),
+  name: (v) => v === void 0 || isString(v),
+  defaults: (v) => v === void 0 || isObject(v),
+  normalize: (v) => v === void 0 || isFunction(v),
+  styling: (v) => v === void 0 || isObject(v),
+  enforcement: (v) => v === void 0 || isObject(v),
+  diagnostics: (v) => v === void 0 || isObject(v),
+  subComponents: (v) => v === void 0 || isObject(v),
+  onElement: (v) => v === void 0 || isFunction(v)
+};
+function isFactoryOptionsLike(options, extraFieldValidators) {
+  if (!isObject(options)) return false;
+  const validators = { ...FACTORY_OPTIONS_FIELD_VALIDATORS, ...extraFieldValidators };
+  for (const [key, value] of Object.entries(options)) {
+    const validate = validators[key];
+    if (!validate || !validate(value)) return false;
+  }
+  return true;
+}
+
 // ../../lib/contract/src/aria/aria-role-policy.ts
 function getImplicitRole(tag, props) {
   if (tag in IMPLICIT_ROLE_RECORD) return IMPLICIT_ROLE_RECORD[tag];
@@ -1627,7 +1686,8 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
     const cached = _AriaPolicyEngine.#removeAttributeFixCache.get(attr);
     if (cached) return cached;
     const fix = {
-      kind: `removeAttribute:${attr}`,
+      kind: "removeAttribute",
+      attribute: attr,
       apply: ({ props }) => {
         if (!(attr in props)) return { applied: false, next: props };
         return { applied: true, next: omitProp(props, attr), previous: props };
@@ -1898,7 +1958,8 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
     if (!impliedLive) return NO_VIOLATIONS2;
     if ("aria-live" in props) return NO_VIOLATIONS2;
     const injectLive = {
-      kind: `injectLive:${effectiveRole}`,
+      kind: "injectLive",
+      attribute: "aria-live",
       apply: (ctx) => ({
         applied: true,
         next: { ...ctx.props, "aria-live": impliedLive },
@@ -1967,6 +2028,23 @@ var AriaPolicyEngine = class _AriaPolicyEngine extends InvariantBase {
   }
 };
 
+// ../../lib/contract/src/aria/factories.ts
+function removeProp(props, key) {
+  const next = { ...props };
+  delete next[key];
+  return next;
+}
+function removeAttributeFix(attribute) {
+  return Object.freeze({
+    kind: "removeAttribute",
+    attribute,
+    apply: ({ props }) => {
+      if (!(attribute in props)) return { applied: false, next: props };
+      return { applied: true, next: removeProp(props, attribute), previous: props };
+    }
+  });
+}
+
 // ../../lib/contract/src/children/get-type-name.ts
 function getTypeName(value) {
   if (value === null) return "null";
@@ -2285,22 +2363,6 @@ import { warnDiagnostics as warnDiagnostics2 } from "./_shared/diagnostics.js";
 
 // ../core/src/html/contracts/categories.ts
 var METADATA_TAGS = ["script", "template"];
-var VOID_TAGS = [
-  "area",
-  "base",
-  "br",
-  "col",
-  "embed",
-  "hr",
-  "img",
-  "input",
-  "link",
-  "meta",
-  "param",
-  "source",
-  "track",
-  "wbr"
-];
 var TEXT_ONLY_TAGS = [
   "option",
   "script",
@@ -2424,20 +2486,6 @@ var INPUT_MUTUALLY_EXCLUSIVE_POLICIES = [
 
 // ../core/src/html/spec/validators/attribute-type-validator.ts
 var DEFAULT_INPUT_TYPE = "text";
-function omit(props, key) {
-  const next = { ...props };
-  delete next[key];
-  return next;
-}
-function removeAttributeFix(attribute) {
-  return {
-    kind: `removeAttribute:${attribute}`,
-    apply: ({ props }) => {
-      if (!(attribute in props)) return { applied: false, next: props };
-      return { applied: true, next: omit(props, attribute), previous: props };
-    }
-  };
-}
 function createInputAttributeTypeRule({
   attribute,
   allowedTypes
@@ -2890,7 +2938,7 @@ function getChildProp(child, key) {
   if (!isVNodeLike(child)) return void 0;
   const { props } = child;
   if (!isObject(props)) return void 0;
-  return props[key];
+  return Reflect.get(props, key);
 }
 
 // ../core/src/html/contracts/aria/landmarks.ts
@@ -2943,6 +2991,13 @@ function isLabelableControl(child) {
   const type = getChildProp(child, "type");
   return !isString(type) || type !== "hidden";
 }
+function hasAccessibleNameProp(props) {
+  return "aria-label" in props || "aria-labelledby" in props;
+}
+function isNonEmptyTextChild(child) {
+  if (isNumber(child)) return true;
+  return isString(child) && child.trim().length > 0;
+}
 var labelContract = contract([
   { name: "control", match: isLabelableControl, cardinality: { max: 1 } },
   { name: "nested-label", match: isTag("label"), cardinality: { max: 0 } },
@@ -2950,6 +3005,13 @@ var labelContract = contract([
     name: "other-interactive-content",
     match: isTag(...OTHER_INTERACTIVE_TAGS),
     cardinality: { max: 0 }
+  },
+  {
+    name: "accessible-name",
+    match: isNonEmptyTextChild,
+    cardinality: dynamic(
+      (ctx) => hasAccessibleNameProp(ctx.props) ? { min: 0 } : { min: 1 }
+    )
   }
 ]);
 
@@ -3699,6 +3761,23 @@ function applySlot(children, slotProps, ref, cloneSlotChild) {
   return cloneSlotChild({ child: children, slotProps, ref });
 }
 
+// ../../adapters/react/src/shared/to-react-factory-options.ts
+var REACT_FIELD_VALIDATORS = {
+  slotComponent: (v) => v === void 0 || isFunction(v) || isObject(v),
+  filterProps: (v) => v === void 0 || isFunction(v),
+  artifact: (v) => v === void 0 || isObject(v)
+};
+function isReactFactoryOptions(options) {
+  return isFactoryOptionsLike(options, REACT_FIELD_VALIDATORS);
+}
+
+// ../../adapters/react/src/shared/is-polymorphic-component.ts
+function isPolymorphicComponent(value) {
+  if (!isFunction(value)) return false;
+  if (!("displayName" in value)) return true;
+  return value.displayName === void 0 || isString(value.displayName);
+}
+
 // ../../adapters/react/src/shared/apply-display-name.ts
 function applyDisplayName(component, name) {
   const displayName = name ?? "PolymorphicComponent";
@@ -3824,7 +3903,10 @@ function render({
       tag: state.tag,
       props: state.normalizedProps
     });
-    runtime.options.htmlChildrenEvaluatorFn?.(state.tag)?.evaluate(getNormalizedChildren());
+    runtime.options.htmlChildrenEvaluatorFn?.(state.tag)?.evaluate(getNormalizedChildren(), {
+      tag: state.tag,
+      props: state.normalizedProps
+    });
   }
   if (typeof props.render === "function") {
     return props.render({ ...state.props, className: state.className, ref });
@@ -3872,10 +3954,14 @@ function buildRuntime(options, defaultSlotComponent, normalizeChildren) {
 }
 
 export {
+  invariant,
   defineContractComponent,
   isString,
   SLOT_NAME,
   COMPONENT_DEFAULT_TAG,
+  finalizeComponent,
+  isReactFactoryOptions,
+  isPolymorphicComponent,
   mergeRefs,
   applyDisplayName,
   Slottable,

package/dist/codemod/index.js

@@ -211608,12 +211608,12 @@ var require_commonjs = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/brace-expansion@5.0.7/node_modules/brace-expansion/dist/commonjs/index.js
+// ../../node_modules/.pnpm/brace-expansion@5.0.9/node_modules/brace-expansion/dist/commonjs/index.js
 var require_commonjs2 = __commonJS({
-  "../../node_modules/.pnpm/brace-expansion@5.0.7/node_modules/brace-expansion/dist/commonjs/index.js"(exports) {
+  "../../node_modules/.pnpm/brace-expansion@5.0.9/node_modules/brace-expansion/dist/commonjs/index.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.EXPANSION_MAX = void 0;
+    exports.EXPANSION_MAX_LENGTH = exports.EXPANSION_MAX = void 0;
     exports.expand = expand;
     var balanced_match_1 = require_commonjs();
     var escSlash = "\0SLASH" + Math.random() + "\0";
@@ -211632,6 +211632,7 @@ var require_commonjs2 = __commonJS({
     var commaPattern = /\\,/g;
     var periodPattern = /\\\./g;
     exports.EXPANSION_MAX = 1e5;
+    exports.EXPANSION_MAX_LENGTH = 4e6;
     function numeric(str) {
       return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
     }
@@ -211666,11 +211667,11 @@ var require_commonjs2 = __commonJS({
       if (!str) {
         return [];
       }
-      const { max = exports.EXPANSION_MAX } = options;
+      const { max = exports.EXPANSION_MAX, maxLength = exports.EXPANSION_MAX_LENGTH } = options;
       if (str.slice(0, 2) === "{}") {
         str = "\\{\\}" + str.slice(2);
       }
-      return expand_(escapeBraces(str), max, true).map(unescapeBraces);
+      return expand_(escapeBraces(str), max, maxLength, true).map(unescapeBraces);
     }
     function embrace(str) {
       return "{" + str + "}";
@@ -211684,20 +211685,87 @@ var require_commonjs2 = __commonJS({
     function gte(i, y) {
       return i >= y;
     }
-    function expand_(str, max, isTop) {
-      const expansions = [];
+    function combine(acc, pre, values, max, maxLength, dropEmpties) {
+      const out = [];
+      let length = 0;
+      for (let a = 0; a < acc.length; a++) {
+        for (let v = 0; v < values.length; v++) {
+          if (out.length >= max)
+            return out;
+          const expansion = acc[a] + pre + values[v];
+          if (dropEmpties && !expansion)
+            continue;
+          if (length + expansion.length > maxLength)
+            return out;
+          out.push(expansion);
+          length += expansion.length;
+        }
+      }
+      return out;
+    }
+    function expandSequence(body, isAlphaSequence, max, maxLength) {
+      const n = body.split(/\.\./);
+      const N = [];
+      if (n[0] === void 0 || n[1] === void 0) {
+        return N;
+      }
+      const x = numeric(n[0]);
+      const y = numeric(n[1]);
+      const width = Math.max(n[0].length, n[1].length);
+      let incr = n.length === 3 && n[2] !== void 0 ? Math.max(Math.abs(numeric(n[2])), 1) : 1;
+      let test = lte;
+      const reverse = y < x;
+      if (reverse) {
+        incr *= -1;
+        test = gte;
+      }
+      const pad = n.some(isPadded);
+      let length = 0;
+      for (let i = x; test(i, y) && N.length < max; i += incr) {
+        let c;
+        if (isAlphaSequence) {
+          c = String.fromCharCode(i);
+          if (c === "\\") {
+            c = "";
+          }
+        } else {
+          c = String(i);
+          if (pad) {
+            const need = width - c.length;
+            if (need > 0) {
+              const z = new Array(need + 1).join("0");
+              if (i < 0) {
+                c = "-" + z + c.slice(1);
+              } else {
+                c = z + c;
+              }
+            }
+          }
+        }
+        if (length + c.length > maxLength)
+          break;
+        N.push(c);
+        length += c.length;
+      }
+      return N;
+    }
+    function expand_(str, max, maxLength, isTop) {
+      let acc = [""];
+      let dropEmpties = false;
+      let firstGroup = true;
       for (; ; ) {
         const m = (0, balanced_match_1.balanced)("{", "}", str);
-        if (!m)
-          return [str];
+        if (!m) {
+          return combine(acc, str, [""], max, maxLength, dropEmpties);
+        }
         const pre = m.pre;
-        if (/\$$/.test(m.pre)) {
-          const post2 = m.post.length ? expand_(m.post, max, false) : [""];
-          for (let k = 0; k < post2.length && k < max; k++) {
-            const expansion = pre + "{" + m.body + "}" + post2[k];
-            expansions.push(expansion);
-          }
-          return expansions;
+        if (/\$$/.test(pre)) {
+          acc = combine(acc, pre + "{" + m.body + "}", [""], max, maxLength, dropEmpties && !m.post.length);
+          firstGroup = false;
+          if (!m.post.length)
+            break;
+          str = m.post;
+          continue;
         }
         const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
         const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
@@ -211709,74 +211777,55 @@ var require_commonjs2 = __commonJS({
             isTop = true;
             continue;
           }
-          return [str];
+          return combine(acc, pre + "{" + m.body + "}" + m.post, [""], max, maxLength, dropEmpties);
         }
-        const post = m.post.length ? expand_(m.post, max, false) : [""];
-        let n;
+        if (firstGroup) {
+          dropEmpties = isTop && !isSequence;
+          firstGroup = false;
+        }
+        let values;
         if (isSequence) {
-          n = m.body.split(/\.\./);
+          values = expandSequence(m.body, isAlphaSequence, max, maxLength);
         } else {
-          n = parseCommaParts(m.body);
+          let n = parseCommaParts(m.body);
           if (n.length === 1 && n[0] !== void 0) {
-            n = expand_(n[0], max, false).map(embrace);
+            n = expand_(n[0], max, maxLength, false).map(embrace);
             if (n.length === 1) {
-              return post.map((p) => m.pre + n[0] + p);
-            }
-          }
-        }
-        let N;
-        if (isSequence && n[0] !== void 0 && n[1] !== void 0) {
-          const x = numeric(n[0]);
-          const y = numeric(n[1]);
-          const width = Math.max(n[0].length, n[1].length);
-          let incr = n.length === 3 && n[2] !== void 0 ? Math.max(Math.abs(numeric(n[2])), 1) : 1;
-          let test = lte;
-          const reverse = y < x;
-          if (reverse) {
-            incr *= -1;
-            test = gte;
-          }
-          const pad = n.some(isPadded);
-          N = [];
-          for (let i = x; test(i, y) && N.length < max; i += incr) {
-            let c;
-            if (isAlphaSequence) {
-              c = String.fromCharCode(i);
-              if (c === "\\") {
-                c = "";
-              }
-            } else {
-              c = String(i);
-              if (pad) {
-                const need = width - c.length;
-                if (need > 0) {
-                  const z = new Array(need + 1).join("0");
-                  if (i < 0) {
-                    c = "-" + z + c.slice(1);
-                  } else {
-                    c = z + c;
-                  }
-                }
-              }
+              acc = combine(acc, pre + n[0], [""], max, maxLength, dropEmpties && !m.post.length);
+              if (!m.post.length)
+                break;
+              str = m.post;
+              continue;
             }
-            N.push(c);
           }
-        } else {
-          N = [];
-          for (let j = 0; j < n.length; j++) {
-            N.push.apply(N, expand_(n[j], max, false));
+          let dropsEmpties = dropEmpties && !m.post.length && !pre;
+          for (let d = 0; dropsEmpties && d < acc.length; d++) {
+            if (acc[d]) {
+              dropsEmpties = false;
+            }
           }
-        }
-        for (let j = 0; j < N.length; j++) {
-          for (let k = 0; k < post.length && expansions.length < max; k++) {
-            const expansion = pre + N[j] + post[k];
-            if (!isTop || isSequence || expansion) {
-              expansions.push(expansion);
+          values = [];
+          let valuesLength = 0;
+          outer: for (let j = 0; j < n.length; j++) {
+            const expanded = expand_(n[j], max, maxLength, false);
+            for (let k = 0; k < expanded.length; k++) {
+              const v = expanded[k];
+              if (dropsEmpties && !v)
+                continue;
+              if (values.length >= max || valuesLength + v.length > maxLength) {
+                break outer;
+              }
+              values.push(v);
+              valuesLength += v.length;
             }
           }
         }
-        return expansions;
+        acc = combine(acc, pre, values, max, maxLength, dropEmpties && !m.post.length);
+        if (!m.post.length)
+          break;
+        str = m.post;
       }
+      return acc;
     }
   }
 });

package/dist/contract/index.d.ts

@@ -4,6 +4,8 @@ import { RequireAtLeastOne, Simplify, ReadonlyDeep } from 'type-fest';
 type StringMap<T = unknown> = Record<string, T>;
 type AnyRecord = StringMap<unknown>;
 type EmptyRecord = Record<never, never>;
+/** A compound component's named sub-components, e.g. `{ Header, Content, Footer }`. */
+type SubComponentMap = Readonly<AnyRecord>;
 
 type IntrinsicTag = keyof HTMLElementTagNameMap;
 
@@ -177,8 +179,8 @@ type AriaContext = {
     readonly props: ReadonlyDeep<IntrinsicProps>;
 };
 
-type RemoveAttributeFixKind = `removeAttribute:${string}`;
-type InjectLiveFixKind = `injectLive:${string}`;
+type RemoveAttributeFixKind = 'removeAttribute';
+type InjectLiveFixKind = 'injectLive';
 type FixKind = 'removeRole' | 'setRole' | 'normalizeRelevantAll' | RemoveAttributeFixKind | InjectLiveFixKind;
 
 type AriaFixResult = {
@@ -191,6 +193,9 @@ type AriaFixResult = {
 };
 type AriaFix = {
     readonly kind: FixKind;
+    /** The attribute a `'removeAttribute'`/`'injectLive'` fix targets — always set for those
+     *  kinds, absent for kinds with no single-attribute target (`'removeRole'`, etc.). */
+    readonly attribute?: string;
     readonly priority?: number;
     readonly source?: string;
     readonly apply: (context: AriaContext) => AriaFixResult;
@@ -285,8 +290,82 @@ type FactoryOptions<TDefault extends ElementType = ElementType, Props extends An
      * be set directly by component authors — use `enforcement.diagnostics` to override per component.
      */
     readonly diagnostics?: Diagnostics$1;
+    /**
+     * Sub-components to attach to the generated root component, producing a
+     * compound component API (for example, `Card.Header`, `Card.Content`,
+     * and `Card.Footer`). Purely additive — has no effect on
+     * `enforcement.children`; author child rules explicitly if the component
+     * needs to validate its children.
+     */
+    readonly subComponents?: SubComponentMap;
+    /**
+     * Called once per instance, when the real underlying DOM element first
+     * exists, in every adapter — via that adapter's own native mount
+     * lifecycle, never through the props/attribute pipeline. Use this for
+     * wiring that needs the actual element (native imperative methods like
+     * `dialogEl.showModal()`, native events like `close`/`cancel` that have
+     * no prop-based equivalent), not for anything expressible as a plain
+     * prop.
+     *
+     * `getProps` returns the instance's *current* resolved props at call
+     * time — read it from inside a listener registered once at mount, rather
+     * than re-subscribing on every prop change.
+     *
+     * Return a cleanup function to run when the instance unmounts.
+     */
+    readonly onElement?: (element: Element, getProps: () => Readonly<Props>) => void | (() => void);
 };
 
+/** Shared input shape for `invalidWithFix`/`invalidWithoutFix`. */
+type InvalidResultInput = {
+    readonly severity: Severity;
+    readonly attribute?: string;
+    readonly message?: string;
+    readonly diagnostic?: DiagnosticInput;
+};
+
+/** Options for `createRemoveAttributeRule`. */
+type RemoveAttributeRuleOptions = {
+    /** Returns true when `attribute` should be stripped for the given render. */
+    readonly when: (context: AriaContext) => boolean;
+    readonly severity?: Severity;
+    readonly message?: string;
+    /** Receives the same context `when` did, so the diagnostic can reference the offending value. */
+    readonly diagnostic?: (context: AriaContext) => DiagnosticInput;
+    readonly readsProps?: readonly string[];
+    readonly tags?: readonly string[];
+};
+
+/**
+ * Builds a correctly-literal-typed `fixable: false` `AriaResult`. Exists so a rule author can
+ * extract shared branch logic (severity/attribute/message computed once, reused across multiple
+ * `return`s) without TypeScript silently widening `valid: false`/`fixable: false` to `boolean`
+ * the moment those values leave an object-literal-in-return-position — the widening only happens
+ * on plain object literals; a function's declared return type narrows unconditionally.
+ */
+declare function invalidWithoutFix(input: InvalidResultInput): AriaInvalidWithoutFix;
+/** Same as {@link invalidWithoutFix}, for the `fixable: true` branch — requires a `fix`. */
+declare function invalidWithFix(input: InvalidResultInput & {
+    readonly fix: AriaFix;
+}): AriaInvalidWithFix;
+/**
+ * Builds an `AriaFix` that strips a single attribute — the shape `dangerousHrefRule`-style
+ * "strip this attribute when it's dangerous/redundant" rules need. A no-op (`applied: false`) when
+ * the attribute isn't present, so applying the fix twice (or applying it when nothing triggered it)
+ * is always safe. Frozen — a fix is a value object; nothing should mutate `kind`/`attribute`/`apply`
+ * after construction.
+ */
+declare function removeAttributeFix(attribute: string): AriaFix;
+/**
+ * Convenience factory for the single most common `enforcement.aria`/`enforcement.rules` shape:
+ * "strip this attribute when some condition on the element's own props holds" — covers
+ * security-style guards (a dangerous URL scheme on `href`) and redundant-attribute rules alike,
+ * without hand-writing the rule function, the `AriaFix`, and the `invalidWithFix` call each time.
+ * A rule with no fix (a warn-only advisory) still needs the raw `AriaRule` shape directly — this
+ * factory is deliberately scoped to the strip-on-match case, not a general rule builder.
+ */
+declare function createRemoveAttributeRule(attribute: string, options: RemoveAttributeRuleOptions): AriaRule;
+
 declare const activeProps: PropNormalizer;
 
 declare const disabledProps: PropNormalizer;
@@ -316,4 +395,4 @@ declare function mergeContracts(...contracts: readonly EnforcementOptions[]): En
 
 type Diagnostics = Diagnostics$1;
 
-export { type AnyFactoryOptions, type AriaContext, type AriaFix, type AriaFixResult, type AriaPhase, type AriaResult, type AriaRule, type Diagnostics, type FixKind, type IntrinsicProps, type AriaInvalidResult as InvalidResult, type AriaInvalidWithFix as InvalidWithFix, type AriaInvalidWithoutFix as InvalidWithoutFix, type NormalizeFn, type PropNormalizer, type RemoveAttributeFixKind, type Severity, type ValidResult, activeContract, activeProps, disabledContract, disabledProps, expandedContract, expandedProps, invalidContract, invalidProps, loadingContract, loadingProps, mergeContracts, pressedContract, pressedProps, readonlyContract, readonlyProps, selectedContract, selectedProps };
+export { type AnyFactoryOptions, type AriaContext, type AriaFix, type AriaFixResult, type AriaPhase, type AriaResult, type AriaRule, type Diagnostics, type FixKind, type IntrinsicProps, type AriaInvalidResult as InvalidResult, type AriaInvalidWithFix as InvalidWithFix, type AriaInvalidWithoutFix as InvalidWithoutFix, type NormalizeFn, type PropNormalizer, type RemoveAttributeFixKind, type Severity, type ValidResult, activeContract, activeProps, createRemoveAttributeRule, disabledContract, disabledProps, expandedContract, expandedProps, invalidContract, invalidProps, invalidWithFix, invalidWithoutFix, loadingContract, loadingProps, mergeContracts, pressedContract, pressedProps, readonlyContract, readonlyProps, removeAttributeFix, selectedContract, selectedProps };