@wireweave/ux-rules 1.0.0 → 1.2.0-beta.0

package/dist/index.cjs

@@ -20,17 +20,302 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  ASYNC_ACTION_WORDS: () => ASYNC_ACTION_WORDS,
+  CLOSE_WORDS: () => CLOSE_WORDS,
+  CONTAINER_TYPES: () => CONTAINER_TYPES,
+  DESTRUCTIVE_WORDS: () => DESTRUCTIVE_WORDS,
+  ERROR_WORDS: () => ERROR_WORDS,
+  FORM_INPUT_TYPES: () => FORM_INPUT_TYPES,
+  GENERIC_LINK_TEXTS: () => GENERIC_LINK_TEXTS,
+  HOME_WORDS: () => HOME_WORDS,
+  INPUT_TYPE_SUGGESTIONS: () => INPUT_TYPE_SUGGESTIONS,
+  MAX_BUTTONS: () => MAX_BUTTONS,
+  MAX_BUTTON_TEXT_LENGTH: () => MAX_BUTTON_TEXT_LENGTH,
+  MAX_FORM_FIELDS: () => MAX_FORM_FIELDS,
+  MAX_LIST_ITEMS: () => MAX_LIST_ITEMS,
+  MAX_NAV_ITEMS: () => MAX_NAV_ITEMS,
+  MAX_NESTING_DEPTH: () => MAX_NESTING_DEPTH,
+  MAX_PAGE_ELEMENTS: () => MAX_PAGE_ELEMENTS,
+  MAX_TABLE_COLUMNS: () => MAX_TABLE_COLUMNS,
+  MAX_TABS: () => MAX_TABS,
+  MAX_TITLE_LENGTH: () => MAX_TITLE_LENGTH,
+  MAX_TOAST_DURATION: () => MAX_TOAST_DURATION,
+  MAX_TOOLTIP_LENGTH: () => MAX_TOOLTIP_LENGTH,
+  MIN_TOAST_DURATION: () => MIN_TOAST_DURATION,
+  MIN_TOUCH_TARGET: () => MIN_TOUCH_TARGET,
+  PLACEHOLDER_PATTERNS: () => PLACEHOLDER_PATTERNS,
+  RECOMMENDED_TOUCH_TARGET: () => RECOMMENDED_TOUCH_TARGET,
+  SIZE_MAP: () => SIZE_MAP,
+  SUBMIT_WORDS: () => SUBMIT_WORDS,
+  SUCCESS_WORDS: () => SUCCESS_WORDS,
+  TEXT_CONTENT_TYPES: () => TEXT_CONTENT_TYPES,
+  WARNING_WORDS: () => WARNING_WORDS,
   allRules: () => allRules,
+  containsAnyWord: () => containsAnyWord,
+  countInChildren: () => countInChildren,
+  filterChildren: () => filterChildren,
+  findInChildren: () => findInChildren,
   formatUXResult: () => formatUXResult,
+  getButtonStyle: () => getButtonStyle,
+  getChildren: () => getChildren,
+  getNodeItems: () => getNodeItems,
+  getNodeLocation: () => getNodeLocation,
+  getNodeText: () => getNodeText,
+  getNodeTextLower: () => getNodeTextLower,
   getRulesForCategories: () => getRulesForCategories,
+  getSizeValue: () => getSizeValue,
   getUXIssues: () => getUXIssues,
   getUXScore: () => getUXScore,
+  hasChildMatching: () => hasChildMatching,
+  hasChildren: () => hasChildren,
+  isAnyNode: () => isAnyNode,
+  isNodeType: () => isNodeType,
   isUXValid: () => isUXValid,
+  matchesAnyWord: () => matchesAnyWord,
   rulesByCategory: () => rulesByCategory,
+  toAnyNodeArray: () => toAnyNodeArray,
   validateUX: () => validateUX
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/constants.ts
+var MAX_NAV_ITEMS = 7;
+var MAX_TABS = 5;
+var MAX_NESTING_DEPTH = 6;
+var MAX_BUTTONS = 5;
+var MAX_FORM_FIELDS = 10;
+var MAX_PAGE_ELEMENTS = 50;
+var MAX_BUTTON_TEXT_LENGTH = 25;
+var MAX_TITLE_LENGTH = 60;
+var MAX_TOOLTIP_LENGTH = 100;
+var MAX_LIST_ITEMS = 20;
+var MAX_TABLE_COLUMNS = 8;
+var MIN_TOUCH_TARGET = 44;
+var RECOMMENDED_TOUCH_TARGET = 48;
+var SIZE_MAP = {
+  xs: 24,
+  sm: 32,
+  md: 40,
+  lg: 48,
+  xl: 56
+};
+var MIN_TOAST_DURATION = 2e3;
+var MAX_TOAST_DURATION = 1e4;
+var GENERIC_LINK_TEXTS = [
+  "click here",
+  "here",
+  "read more",
+  "more",
+  "link"
+];
+var ASYNC_ACTION_WORDS = [
+  "submit",
+  "save",
+  "send",
+  "upload",
+  "download",
+  "export",
+  "import",
+  "sync",
+  "load"
+];
+var DESTRUCTIVE_WORDS = [
+  "delete",
+  "remove",
+  "destroy",
+  "clear",
+  "reset",
+  "revoke",
+  "terminate"
+];
+var SUBMIT_WORDS = [
+  "submit",
+  "save",
+  "send",
+  "create",
+  "add",
+  "update",
+  "confirm",
+  "ok",
+  "done"
+];
+var ERROR_WORDS = [
+  "error",
+  "fail",
+  "invalid",
+  "wrong",
+  "denied"
+];
+var SUCCESS_WORDS = [
+  "success",
+  "saved",
+  "created",
+  "updated",
+  "complete"
+];
+var WARNING_WORDS = [
+  "warning",
+  "caution",
+  "attention",
+  "note"
+];
+var HOME_WORDS = [
+  "home",
+  "dashboard",
+  "main",
+  "start"
+];
+var CLOSE_WORDS = [
+  "close",
+  "cancel",
+  "dismiss",
+  "x"
+];
+var PLACEHOLDER_PATTERNS = [
+  "lorem ipsum",
+  "dolor sit amet",
+  "placeholder",
+  "sample text",
+  "text here",
+  "enter text",
+  "todo",
+  "tbd",
+  "xxx"
+];
+var INPUT_TYPE_SUGGESTIONS = [
+  { keywords: ["email", "e-mail"], type: "email" },
+  { keywords: ["phone", "tel", "mobile", "cell"], type: "tel" },
+  { keywords: ["url", "website", "link"], type: "url" },
+  { keywords: ["password", "pwd"], type: "password" },
+  { keywords: ["search", "find", "query"], type: "search" },
+  { keywords: ["date", "birthday", "dob"], type: "date" },
+  { keywords: ["number", "quantity", "amount", "count", "age"], type: "number" }
+];
+var FORM_INPUT_TYPES = [
+  "Input",
+  "Textarea",
+  "Select",
+  "Checkbox",
+  "Radio"
+];
+var CONTAINER_TYPES = [
+  "Card",
+  "Section",
+  "Modal",
+  "Drawer",
+  "Main"
+];
+var TEXT_CONTENT_TYPES = [
+  "Text",
+  "Title",
+  "Label"
+];
+
+// src/utils.ts
+function getNodeText(node) {
+  if ("content" in node && node.content) return String(node.content);
+  if ("text" in node && node.text) return String(node.text);
+  if ("label" in node && node.label) return String(node.label);
+  return "";
+}
+function getNodeTextLower(node) {
+  return getNodeText(node).toLowerCase();
+}
+function hasChildren(node) {
+  return "children" in node && Array.isArray(node.children);
+}
+function getChildren(node) {
+  if (hasChildren(node)) {
+    return node.children;
+  }
+  return [];
+}
+function findInChildren(node, predicate) {
+  const children = getChildren(node);
+  for (const child of children) {
+    if (predicate(child)) {
+      return child;
+    }
+    const found = findInChildren(child, predicate);
+    if (found) {
+      return found;
+    }
+  }
+  return null;
+}
+function hasChildMatching(node, predicate) {
+  return findInChildren(node, predicate) !== null;
+}
+function countInChildren(node, predicate) {
+  const children = getChildren(node);
+  let count = 0;
+  for (const child of children) {
+    if (predicate(child)) {
+      count++;
+    }
+    count += countInChildren(child, predicate);
+  }
+  return count;
+}
+function filterChildren(node, predicate) {
+  const children = getChildren(node);
+  const result = [];
+  for (const child of children) {
+    if (predicate(child)) {
+      result.push(child);
+    }
+    result.push(...filterChildren(child, predicate));
+  }
+  return result;
+}
+function getSizeValue(node) {
+  if (!("size" in node)) return null;
+  const size = node.size;
+  if (typeof size === "number") return size;
+  if (typeof size === "string" && size in SIZE_MAP) return SIZE_MAP[size];
+  return null;
+}
+function containsAnyWord(text, words) {
+  const lowerText = text.toLowerCase();
+  return words.some((word) => lowerText.includes(word));
+}
+function matchesAnyWord(text, words) {
+  const lowerText = text.toLowerCase().trim();
+  return words.includes(lowerText);
+}
+function getNodeLocation(node) {
+  if ("loc" in node && node.loc && "start" in node.loc) {
+    return {
+      line: node.loc.start.line,
+      column: node.loc.start.column
+    };
+  }
+  return void 0;
+}
+function isNodeType(node, type) {
+  if (Array.isArray(type)) {
+    return type.includes(node.type);
+  }
+  return node.type === type;
+}
+function getButtonStyle(node) {
+  if ("primary" in node && node.primary) return "primary";
+  if ("secondary" in node && node.secondary) return "secondary";
+  if ("outline" in node && node.outline) return "outline";
+  if ("ghost" in node && node.ghost) return "ghost";
+  if ("danger" in node && node.danger) return "danger";
+  return "default";
+}
+function isAnyNode(value) {
+  return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
+}
+function toAnyNodeArray(values) {
+  return values.filter(isAnyNode);
+}
+function getNodeItems(node) {
+  return "items" in node && Array.isArray(node.items) ? node.items : [];
+}
+
 // src/rules/accessibility.ts
 var inputRequiresLabel = {
   id: "a11y-input-label",
@@ -52,7 +337,7 @@ var inputRequiresLabel = {
         suggestion: hasPlaceholder ? "Add a label attribute. Placeholder alone is not sufficient for accessibility" : "Add a label attribute to describe this field",
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -77,7 +362,7 @@ var imageRequiresAlt = {
         suggestion: "Add an alt attribute describing the image content",
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -92,7 +377,7 @@ var iconButtonRequiresLabel = {
   appliesTo: ["Button"],
   check: (node, context) => {
     const hasIcon = "icon" in node && node.icon;
-    const hasContent = "content" in node && node.content && String(node.content).trim();
+    const hasContent = getNodeText(node).trim();
     if (hasIcon && !hasContent) {
       return {
         ruleId: "a11y-icon-button-label",
@@ -103,7 +388,7 @@ var iconButtonRequiresLabel = {
         suggestion: "Add text content or aria-label to describe the button action",
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -117,9 +402,8 @@ var linkRequiresDescriptiveText = {
   description: "Links should have descriptive text that indicates where they lead",
   appliesTo: ["Link"],
   check: (node, context) => {
-    const content = "content" in node ? String(node.content || "").toLowerCase() : "";
-    const genericTexts = ["click here", "here", "read more", "more", "link"];
-    if (genericTexts.includes(content.trim())) {
+    const content = getNodeText(node).toLowerCase();
+    if (GENERIC_LINK_TEXTS.includes(content.trim())) {
       return {
         ruleId: "a11y-link-text",
         category: "accessibility",
@@ -129,7 +413,7 @@ var linkRequiresDescriptiveText = {
         suggestion: `Replace "${content}" with descriptive text that indicates the link destination`,
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -161,7 +445,7 @@ var headingHierarchy = {
         suggestion: `Use h${prevHeadingLevel + 1} instead of h${level}, or add intermediate headings`,
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -184,30 +468,16 @@ var formRequiresSubmit = {
   description: "Forms with input fields should have a clear submit action",
   appliesTo: ["Card", "Section", "Modal", "Main"],
   check: (node, context) => {
-    if (!("children" in node) || !Array.isArray(node.children)) {
+    if (!hasChildren(node)) {
       return null;
     }
-    let hasInputs = false;
-    let hasSubmitButton = false;
-    function walkChildren(children) {
-      for (const child of children) {
-        if (["Input", "Textarea", "Select", "Checkbox", "Radio"].includes(child.type)) {
-          hasInputs = true;
-        }
-        if (child.type === "Button") {
-          const isPrimary = "primary" in child && child.primary;
-          const content = "content" in child ? String(child.content || "").toLowerCase() : "";
-          const submitWords = ["submit", "save", "send", "create", "add", "update", "confirm", "ok", "done"];
-          if (isPrimary || submitWords.some((w) => content.includes(w))) {
-            hasSubmitButton = true;
-          }
-        }
-        if ("children" in child && Array.isArray(child.children)) {
-          walkChildren(child.children);
-        }
-      }
-    }
-    walkChildren(node.children);
+    const hasInputs = hasChildMatching(node, (child) => FORM_INPUT_TYPES.includes(child.type));
+    const hasSubmitButton = hasChildMatching(node, (child) => {
+      if (child.type !== "Button") return false;
+      const isPrimary = "primary" in child && child.primary;
+      const content = getNodeText(child).toLowerCase();
+      return isPrimary || SUBMIT_WORDS.some((w) => content.includes(w));
+    });
     if (hasInputs && !hasSubmitButton) {
       return {
         ruleId: "form-submit-button",
@@ -218,7 +488,7 @@ var formRequiresSubmit = {
         suggestion: 'Add a primary button with a clear action label (e.g., "Submit", "Save")',
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -244,7 +514,7 @@ var requiredFieldIndicator = {
         suggestion: 'Add an asterisk (*) to the label or include "required" in the label text',
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -285,7 +555,7 @@ var passwordConfirmation = {
         suggestion: 'Add a "Confirm Password" field to prevent typos',
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -303,16 +573,7 @@ var appropriateInputType = {
     const label = "label" in node ? String(node.label || "").toLowerCase() : "";
     const placeholder = "placeholder" in node ? String(node.placeholder || "").toLowerCase() : "";
     const combined = label + " " + placeholder;
-    const suggestions = [
-      { keywords: ["email", "e-mail"], type: "email" },
-      { keywords: ["phone", "tel", "mobile", "cell"], type: "tel" },
-      { keywords: ["url", "website", "link"], type: "url" },
-      { keywords: ["password", "pwd"], type: "password" },
-      { keywords: ["search", "find", "query"], type: "search" },
-      { keywords: ["date", "birthday", "dob"], type: "date" },
-      { keywords: ["number", "quantity", "amount", "count", "age"], type: "number" }
-    ];
-    for (const suggestion of suggestions) {
+    for (const suggestion of INPUT_TYPE_SUGGESTIONS) {
       if (suggestion.keywords.some((k) => combined.includes(k)) && inputType !== suggestion.type) {
         return {
           ruleId: "form-input-type",
@@ -323,7 +584,7 @@ var appropriateInputType = {
           suggestion: `Change inputType to "${suggestion.type}"`,
           path: context.path,
           nodeType: node.type,
-          location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+          location: getNodeLocation(node)
         };
       }
     }
@@ -338,21 +599,6 @@ var formRules = [
 ];
 
 // src/rules/touch-target.ts
-var MIN_TOUCH_TARGET = 44;
-var SIZE_MAP = {
-  xs: 24,
-  sm: 32,
-  md: 40,
-  lg: 48,
-  xl: 56
-};
-function getSizeValue(node) {
-  if (!("size" in node)) return null;
-  const size = node.size;
-  if (typeof size === "number") return size;
-  if (typeof size === "string" && size in SIZE_MAP) return SIZE_MAP[size];
-  return null;
-}
 var buttonTouchTarget = {
   id: "touch-button-size",
   category: "touch-target",
@@ -372,7 +618,7 @@ var buttonTouchTarget = {
         suggestion: `Use size="md" or larger for better touch accessibility`,
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -401,7 +647,7 @@ var iconButtonTouchTarget = {
         suggestion: "Add padding (p=2 or more) or use a larger size",
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -426,7 +672,7 @@ var checkboxRadioTouchTarget = {
         suggestion: "Add a label to increase the touch target area",
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -455,7 +701,7 @@ var linkSpacing = {
             suggestion: "Add gap=2 or more to the parent row for better touch separation",
             path: context.path,
             nodeType: node.type,
-            location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+            location: getNodeLocation(node)
           };
         }
       }
@@ -482,7 +728,7 @@ var avatarTouchTarget = {
         suggestion: 'Use size="md" or larger for clickable avatars',
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -497,18 +743,6 @@ var touchTargetRules = [
 ];
 
 // src/rules/consistency.ts
-var buttonStyleTracker = /* @__PURE__ */ new Map();
-function resetConsistencyTrackers() {
-  buttonStyleTracker.clear();
-}
-function getButtonStyle(node) {
-  if ("primary" in node && node.primary) return "primary";
-  if ("secondary" in node && node.secondary) return "secondary";
-  if ("outline" in node && node.outline) return "outline";
-  if ("ghost" in node && node.ghost) return "ghost";
-  if ("danger" in node && node.danger) return "danger";
-  return "default";
-}
 var consistentButtonStyles = {
   id: "consistency-button-styles",
   category: "consistency",
@@ -517,10 +751,10 @@ var consistentButtonStyles = {
   description: "Action buttons in the same context should use consistent styling",
   appliesTo: ["Row", "Col", "Card", "Modal"],
   check: (node, context) => {
-    if (!("children" in node) || !Array.isArray(node.children)) {
+    if (!hasChildren(node)) {
       return null;
     }
-    const buttons = node.children.filter((c) => c.type === "Button");
+    const buttons = getChildren(node).filter((c) => c.type === "Button");
     if (buttons.length < 2) return null;
     const styles = buttons.map((b) => getButtonStyle(b));
     const uniqueStyles = [...new Set(styles)];
@@ -536,7 +770,7 @@ var consistentButtonStyles = {
         suggestion: "Use primary for main action, outline/ghost for secondary actions",
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -564,7 +798,7 @@ var consistentSpacing = {
         suggestion: "Use the same gap value for sibling containers",
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -604,7 +838,7 @@ var consistentCardStyling = {
         suggestion: "Apply the same visual treatment to sibling cards",
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -618,12 +852,9 @@ var consistentAlertVariants = {
   description: "Alerts should use appropriate variants for their purpose",
   appliesTo: ["Alert"],
   check: (node, context) => {
-    const content = "content" in node ? String(node.content || "").toLowerCase() : "";
+    const content = getNodeText(node).toLowerCase();
     const variant = "variant" in node ? String(node.variant || "") : "";
-    const errorWords = ["error", "fail", "invalid", "wrong", "denied"];
-    const successWords = ["success", "saved", "created", "updated", "complete"];
-    const warningWords = ["warning", "caution", "attention", "note"];
-    if (errorWords.some((w) => content.includes(w)) && variant !== "danger") {
+    if (ERROR_WORDS.some((w) => content.includes(w)) && variant !== "danger") {
       return {
         ruleId: "consistency-alert-variants",
         category: "consistency",
@@ -633,10 +864,10 @@ var consistentAlertVariants = {
         suggestion: "Add variant=danger to this error alert",
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
-    if (successWords.some((w) => content.includes(w)) && variant !== "success") {
+    if (SUCCESS_WORDS.some((w) => content.includes(w)) && variant !== "success") {
       return {
         ruleId: "consistency-alert-variants",
         category: "consistency",
@@ -646,10 +877,10 @@ var consistentAlertVariants = {
         suggestion: "Add variant=success to this success alert",
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
-    if (warningWords.some((w) => content.includes(w)) && variant !== "warning") {
+    if (WARNING_WORDS.some((w) => content.includes(w)) && variant !== "warning") {
       return {
         ruleId: "consistency-alert-variants",
         category: "consistency",
@@ -659,7 +890,7 @@ var consistentAlertVariants = {
         suggestion: "Add variant=warning to this warning alert",
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -691,7 +922,7 @@ var noEmptyContainers = {
         suggestion: "Add content to this container or use a placeholder to indicate intended content",
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -705,22 +936,13 @@ var clearCTA = {
   description: "Pages should have a clear primary action for users",
   appliesTo: ["Page"],
   check: (node, context) => {
-    if (!("children" in node) || !Array.isArray(node.children)) {
+    if (!hasChildren(node)) {
       return null;
     }
-    let hasPrimaryButton = false;
-    function findPrimaryButton(children) {
-      for (const child of children) {
-        if (child.type === "Button" && "primary" in child && child.primary) {
-          hasPrimaryButton = true;
-          return;
-        }
-        if ("children" in child && Array.isArray(child.children)) {
-          findPrimaryButton(child.children);
-        }
-      }
-    }
-    findPrimaryButton(node.children);
+    const hasPrimaryButton = hasChildMatching(
+      node,
+      (child) => child.type === "Button" && "primary" in child && !!child.primary
+    );
     if (!hasPrimaryButton) {
       return {
         ruleId: "usability-clear-cta",
@@ -731,7 +953,7 @@ var clearCTA = {
         suggestion: "Add a primary button for the main action on this page",
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -745,11 +967,10 @@ var loadingStates = {
   description: "Actions that may take time should have loading indicators",
   appliesTo: ["Button"],
   check: (node, context) => {
-    const content = "content" in node ? String(node.content || "").toLowerCase() : "";
+    const content = getNodeText(node).toLowerCase();
     const hasLoading = "loading" in node;
     const isPrimary = "primary" in node && node.primary;
-    const asyncActions = ["submit", "save", "send", "upload", "download", "export", "import", "sync", "load"];
-    if (isPrimary && asyncActions.some((a) => content.includes(a)) && !hasLoading) {
+    if (isPrimary && ASYNC_ACTION_WORDS.some((a) => content.includes(a)) && !hasLoading) {
       return {
         ruleId: "usability-loading-states",
         category: "usability",
@@ -759,7 +980,7 @@ var loadingStates = {
         suggestion: "Consider adding a loading variant for this button when action is in progress",
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -773,10 +994,9 @@ var destructiveActionConfirmation = {
   description: "Destructive actions should have clear warning styling",
   appliesTo: ["Button"],
   check: (node, context) => {
-    const content = "content" in node ? String(node.content || "").toLowerCase() : "";
+    const content = getNodeText(node).toLowerCase();
     const isDanger = "danger" in node && node.danger;
-    const destructiveWords = ["delete", "remove", "destroy", "clear", "reset", "revoke", "terminate"];
-    if (destructiveWords.some((w) => content.includes(w)) && !isDanger) {
+    if (DESTRUCTIVE_WORDS.some((w) => content.includes(w)) && !isDanger) {
       return {
         ruleId: "usability-destructive-confirm",
         category: "usability",
@@ -786,7 +1006,7 @@ var destructiveActionConfirmation = {
         suggestion: "Add the danger attribute to this button",
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -800,33 +1020,21 @@ var modalCloseButton = {
   description: "Users should be able to close modals easily",
   appliesTo: ["Modal"],
   check: (node, context) => {
-    if (!("children" in node) || !Array.isArray(node.children)) {
+    if (!hasChildren(node)) {
       return null;
     }
-    let hasCloseButton = false;
-    function findCloseButton(children) {
-      for (const child of children) {
-        if (child.type === "Button") {
-          const content = "content" in child ? String(child.content || "").toLowerCase() : "";
-          const icon = "icon" in child ? String(child.icon || "").toLowerCase() : "";
-          if (["close", "cancel", "dismiss", "x"].some((w) => content.includes(w) || icon.includes(w))) {
-            hasCloseButton = true;
-            return;
-          }
-        }
-        if (child.type === "Icon") {
-          const name = "name" in child ? String(child.name || "").toLowerCase() : "";
-          if (name === "x" || name === "close") {
-            hasCloseButton = true;
-            return;
-          }
-        }
-        if ("children" in child && Array.isArray(child.children)) {
-          findCloseButton(child.children);
-        }
+    const hasCloseButton = hasChildMatching(node, (child) => {
+      if (child.type === "Button") {
+        const content = getNodeText(child).toLowerCase();
+        const icon = "icon" in child ? String(child.icon || "").toLowerCase() : "";
+        return CLOSE_WORDS.some((w) => content.includes(w) || icon.includes(w));
       }
-    }
-    findCloseButton(node.children);
+      if (child.type === "Icon") {
+        const name = "name" in child ? String(child.name || "").toLowerCase() : "";
+        return name === "x" || name === "close";
+      }
+      return false;
+    });
     if (!hasCloseButton) {
       return {
         ruleId: "usability-modal-close",
@@ -837,7 +1045,7 @@ var modalCloseButton = {
         suggestion: 'Add a close button (icon "x") or a "Cancel" button',
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -851,18 +1059,126 @@ var maxNestingDepth = {
   description: "Deeply nested layouts can be confusing and hard to maintain",
   appliesTo: ["Row", "Col", "Card", "Section"],
   check: (node, context) => {
-    const MAX_DEPTH = 6;
-    if (context.depth > MAX_DEPTH) {
+    if (context.depth > MAX_NESTING_DEPTH) {
       return {
         ruleId: "usability-nesting-depth",
         category: "usability",
         severity: "warning",
-        message: `Component is nested ${context.depth} levels deep (max recommended: ${MAX_DEPTH})`,
+        message: `Component is nested ${context.depth} levels deep (max recommended: ${MAX_NESTING_DEPTH})`,
         description: "Excessive nesting makes layouts harder to understand and maintain",
         suggestion: "Consider flattening the layout or breaking into separate sections",
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var tooManyButtons = {
+  id: "usability-too-many-buttons",
+  category: "usability",
+  severity: "warning",
+  name: "Too many buttons in container",
+  description: "Too many buttons can cause decision fatigue for users",
+  appliesTo: ["Card", "Section", "Row", "Modal"],
+  check: (node, context) => {
+    if (!hasChildren(node)) {
+      return null;
+    }
+    const buttonCount = getChildren(node).filter((c) => c.type === "Button").length;
+    if (buttonCount > MAX_BUTTONS) {
+      return {
+        ruleId: "usability-too-many-buttons",
+        category: "usability",
+        severity: "warning",
+        message: `Container has ${buttonCount} buttons (recommended max: ${MAX_BUTTONS})`,
+        description: "Too many choices can overwhelm users and slow decision-making",
+        suggestion: "Consider grouping actions in a dropdown or prioritizing the most important actions",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var tooManyFormFields = {
+  id: "usability-too-many-form-fields",
+  category: "usability",
+  severity: "info",
+  name: "Too many form fields",
+  description: "Forms with many fields have higher abandonment rates",
+  appliesTo: ["Card", "Section", "Main", "Modal"],
+  check: (node, context) => {
+    if (!hasChildren(node)) {
+      return null;
+    }
+    const formFieldCount = countInChildren(node, (child) => FORM_INPUT_TYPES.includes(child.type));
+    if (formFieldCount > MAX_FORM_FIELDS) {
+      return {
+        ruleId: "usability-too-many-form-fields",
+        category: "usability",
+        severity: "info",
+        message: `Form area has ${formFieldCount} fields (recommended max: ${MAX_FORM_FIELDS})`,
+        description: "Long forms increase cognitive load and abandonment rates",
+        suggestion: "Consider breaking into multiple steps, using progressive disclosure, or removing optional fields",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var tooManyPageElements = {
+  id: "usability-page-complexity",
+  category: "usability",
+  severity: "info",
+  name: "Page may be too complex",
+  description: "Pages with too many elements can overwhelm users",
+  appliesTo: ["Page"],
+  check: (node, context) => {
+    if (!hasChildren(node)) {
+      return null;
+    }
+    const elementCount = countInChildren(node, () => true);
+    if (elementCount > MAX_PAGE_ELEMENTS) {
+      return {
+        ruleId: "usability-page-complexity",
+        category: "usability",
+        severity: "info",
+        message: `Page has ${elementCount} elements (consider if this complexity is necessary)`,
+        description: "Complex pages can be overwhelming and slow to render",
+        suggestion: "Consider splitting into multiple pages, using tabs, or simplifying the layout",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var drawerWidth = {
+  id: "usability-drawer-width",
+  category: "usability",
+  severity: "info",
+  name: "Drawer should have appropriate width",
+  description: "Drawers should have a defined width for consistent UX",
+  appliesTo: ["Drawer"],
+  check: (node, context) => {
+    const hasWidth = "width" in node || "w" in node;
+    if (!hasWidth) {
+      return {
+        ruleId: "usability-drawer-width",
+        category: "usability",
+        severity: "info",
+        message: "Drawer has no width specified",
+        description: "Drawers without explicit width may render inconsistently across devices",
+        suggestion: 'Add a width attribute (e.g., width="320" or w="80")',
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -874,7 +1190,11 @@ var usabilityRules = [
   loadingStates,
   destructiveActionConfirmation,
   modalCloseButton,
-  maxNestingDepth
+  maxNestingDepth,
+  tooManyButtons,
+  tooManyFormFields,
+  tooManyPageElements,
+  drawerWidth
 ];
 
 // src/rules/navigation.ts
@@ -886,8 +1206,7 @@ var navItemCount = {
   description: "Navigation menus with too many items can overwhelm users",
   appliesTo: ["Nav"],
   check: (node, context) => {
-    const MAX_NAV_ITEMS = 7;
-    const items = "items" in node && Array.isArray(node.items) ? node.items : [];
+    const items = getNodeItems(node);
     if (items.length > MAX_NAV_ITEMS) {
       return {
         ruleId: "nav-item-count",
@@ -898,7 +1217,7 @@ var navItemCount = {
         suggestion: "Group related items into categories or use a hierarchical navigation",
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -912,7 +1231,7 @@ var navActiveState = {
   description: "Users should know which page they are currently on",
   appliesTo: ["Nav"],
   check: (node, context) => {
-    const items = "items" in node && Array.isArray(node.items) ? node.items : [];
+    const items = getNodeItems(node);
     if (items.length === 0) return null;
     const hasActiveItem = items.some((item) => {
       if (typeof item === "object" && item !== null) {
@@ -930,7 +1249,7 @@ var navActiveState = {
         suggestion: "Add active attribute to the current navigation item",
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -944,12 +1263,11 @@ var breadcrumbHasHome = {
   description: "Breadcrumbs typically start with a home or root link",
   appliesTo: ["Breadcrumb"],
   check: (node, context) => {
-    const items = "items" in node && Array.isArray(node.items) ? node.items : [];
+    const items = getNodeItems(node);
     if (items.length === 0) return null;
     const firstItem = items[0];
     const firstLabel = typeof firstItem === "string" ? firstItem.toLowerCase() : firstItem?.label?.toLowerCase() || "";
-    const homeWords = ["home", "dashboard", "main", "start"];
-    if (!homeWords.some((w) => firstLabel.includes(w))) {
+    if (!HOME_WORDS.some((w) => firstLabel.includes(w))) {
       return {
         ruleId: "nav-breadcrumb-home",
         category: "navigation",
@@ -959,7 +1277,7 @@ var breadcrumbHasHome = {
         suggestion: 'Add "Home" or equivalent as the first breadcrumb item',
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -973,15 +1291,9 @@ var tabCount = {
   description: "Too many tabs can be overwhelming",
   appliesTo: ["Tabs"],
   check: (node, context) => {
-    const MAX_TABS = 5;
-    const items = "items" in node && Array.isArray(node.items) ? node.items : [];
-    const children = "children" in node && Array.isArray(node.children) ? node.children : [];
-    const childTabCount = children.filter((c) => {
-      if (typeof c === "object" && c !== null && "type" in c) {
-        return String(c.type).toLowerCase().includes("tab");
-      }
-      return false;
-    }).length;
+    const items = getNodeItems(node);
+    const children = hasChildren(node) ? getChildren(node) : [];
+    const childTabCount = children.filter((c) => c.type.toLowerCase().includes("tab")).length;
     const tabCount2 = items.length || childTabCount;
     if (tabCount2 > MAX_TABS) {
       return {
@@ -993,7 +1305,7 @@ var tabCount = {
         suggestion: "Consider using a different navigation pattern or grouping related content",
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -1007,8 +1319,8 @@ var dropdownHasItems = {
   description: "Dropdown menus need items to be functional",
   appliesTo: ["Dropdown"],
   check: (node, context) => {
-    const items = "items" in node && Array.isArray(node.items) ? node.items : [];
-    const children = "children" in node && Array.isArray(node.children) ? node.children : [];
+    const items = getNodeItems(node);
+    const children = hasChildren(node) ? getChildren(node) : [];
     if (items.length === 0 && children.length === 0) {
       return {
         ruleId: "nav-dropdown-items",
@@ -1019,7 +1331,7 @@ var dropdownHasItems = {
         suggestion: "Add items to the dropdown menu",
         path: context.path,
         nodeType: node.type,
-        location: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0
+        location: getNodeLocation(node)
       };
     }
     return null;
@@ -1033,6 +1345,819 @@ var navigationRules = [
   dropdownHasItems
 ];
 
+// src/rules/content.ts
+var emptyTextContent = {
+  id: "content-empty-text",
+  category: "content",
+  severity: "warning",
+  name: "Avoid empty text content",
+  description: "Text elements should have meaningful content",
+  appliesTo: ["Text", "Title", "Label"],
+  check: (node, context) => {
+    const trimmed = getNodeText(node).trim();
+    if (trimmed === "" || trimmed === "..." || trimmed === "Lorem ipsum") {
+      return {
+        ruleId: "content-empty-text",
+        category: "content",
+        severity: "warning",
+        message: `${node.type} has placeholder or empty content`,
+        description: "Placeholder text should be replaced with meaningful content",
+        suggestion: "Replace with actual content or remove if not needed",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var buttonTextLength = {
+  id: "content-button-text-length",
+  category: "content",
+  severity: "info",
+  name: "Button text should be concise",
+  description: "Button labels should be short and action-oriented",
+  appliesTo: ["Button"],
+  check: (node, context) => {
+    const content = getNodeText(node);
+    if (content.length > MAX_BUTTON_TEXT_LENGTH) {
+      return {
+        ruleId: "content-button-text-length",
+        category: "content",
+        severity: "info",
+        message: `Button text is ${content.length} characters (recommended max: ${MAX_BUTTON_TEXT_LENGTH})`,
+        description: "Long button text can be hard to read and may not fit on smaller screens",
+        suggestion: 'Use concise, action-oriented text (e.g., "Save" instead of "Click here to save your changes")',
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var titleLength = {
+  id: "content-title-length",
+  category: "content",
+  severity: "info",
+  name: "Title should be concise",
+  description: "Titles should be short and descriptive",
+  appliesTo: ["Title"],
+  check: (node, context) => {
+    const content = getNodeText(node);
+    if (content.length > MAX_TITLE_LENGTH) {
+      return {
+        ruleId: "content-title-length",
+        category: "content",
+        severity: "info",
+        message: `Title is ${content.length} characters (recommended max: ${MAX_TITLE_LENGTH})`,
+        description: "Long titles can be hard to scan and may get truncated on smaller screens",
+        suggestion: "Shorten the title and move details to a subtitle or description",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var pageHasTitle = {
+  id: "content-page-title",
+  category: "content",
+  severity: "warning",
+  name: "Page should have a title",
+  description: "Every page should have a clear title to orient users",
+  appliesTo: ["Page"],
+  check: (node, context) => {
+    if (!hasChildren(node)) {
+      return null;
+    }
+    const hasTitleElement = hasChildMatching(node, (child) => child.type === "Title");
+    if (!hasTitleElement) {
+      return {
+        ruleId: "content-page-title",
+        category: "content",
+        severity: "warning",
+        message: "Page has no title",
+        description: "Users need a clear title to understand the page purpose",
+        suggestion: "Add a Title component to identify the page",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var linkHasText = {
+  id: "content-link-text",
+  category: "content",
+  severity: "error",
+  name: "Link should have text",
+  description: "Links must have visible text for users to understand where they lead",
+  appliesTo: ["Link"],
+  check: (node, context) => {
+    const content = getNodeText(node).trim();
+    const hasChildElements = hasChildren(node) && getChildren(node).length > 0;
+    if (!content && !hasChildElements) {
+      return {
+        ruleId: "content-link-text",
+        category: "content",
+        severity: "error",
+        message: "Link has no visible text or content",
+        description: "Users cannot understand or interact with links that have no text",
+        suggestion: "Add descriptive text to the link",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var noPlaceholderContent = {
+  id: "content-no-placeholder",
+  category: "content",
+  severity: "warning",
+  name: "Avoid placeholder content",
+  description: 'Placeholder text like "Lorem ipsum" should be replaced',
+  appliesTo: ["Text", "Title", "Label", "Button"],
+  check: (node, context) => {
+    const content = getNodeText(node).toLowerCase();
+    for (const placeholder of PLACEHOLDER_PATTERNS) {
+      if (content.includes(placeholder)) {
+        return {
+          ruleId: "content-no-placeholder",
+          category: "content",
+          severity: "warning",
+          message: `${node.type} contains placeholder text "${placeholder}"`,
+          description: "Placeholder text should be replaced before production",
+          suggestion: "Replace with actual content",
+          path: context.path,
+          nodeType: node.type,
+          location: getNodeLocation(node)
+        };
+      }
+    }
+    return null;
+  }
+};
+var contentRules = [
+  emptyTextContent,
+  buttonTextLength,
+  titleLength,
+  pageHasTitle,
+  linkHasText,
+  noPlaceholderContent
+];
+
+// src/rules/data-display.ts
+var tableHasHeader = {
+  id: "data-table-header",
+  category: "data-display",
+  severity: "warning",
+  name: "Table should have header",
+  description: "Tables should have a header row to identify columns",
+  appliesTo: ["Table"],
+  check: (node, context) => {
+    const hasHeader = "header" in node && node.header;
+    const hasColumns = "columns" in node && Array.isArray(node.columns) && node.columns.length > 0;
+    if (!hasHeader && !hasColumns) {
+      return {
+        ruleId: "data-table-header",
+        category: "data-display",
+        severity: "warning",
+        message: "Table has no header or columns defined",
+        description: "Table headers help users understand what each column represents",
+        suggestion: "Add a header attribute or define columns for the table",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var listEmptyState = {
+  id: "data-list-empty-state",
+  category: "data-display",
+  severity: "info",
+  name: "Consider empty state for list",
+  description: "Lists should indicate when they have no items",
+  appliesTo: ["List"],
+  check: (node, context) => {
+    const items = getNodeItems(node);
+    const children = hasChildren(node) ? getChildren(node) : [];
+    const hasEmptyStateAttr = "emptyState" in node || "empty" in node;
+    if (items.length > 0 || children.length > 0) {
+      return null;
+    }
+    if (!hasEmptyStateAttr) {
+      return {
+        ruleId: "data-list-empty-state",
+        category: "data-display",
+        severity: "info",
+        message: "Empty list has no empty state defined",
+        description: "Users should see a helpful message when lists are empty",
+        suggestion: "Add an emptyState attribute or component to show when list is empty",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var tableEmptyState = {
+  id: "data-table-empty-state",
+  category: "data-display",
+  severity: "info",
+  name: "Consider empty state for table",
+  description: "Tables should indicate when they have no data",
+  appliesTo: ["Table"],
+  check: (node, context) => {
+    const rows = "rows" in node && Array.isArray(node.rows) ? node.rows : [];
+    const data = "data" in node && Array.isArray(node.data) ? node.data : [];
+    const hasEmptyState = "emptyState" in node || "empty" in node;
+    if (rows.length > 0 || data.length > 0) {
+      return null;
+    }
+    if (!hasEmptyState) {
+      return {
+        ruleId: "data-table-empty-state",
+        category: "data-display",
+        severity: "info",
+        message: "Empty table has no empty state defined",
+        description: "Users should see a helpful message when tables have no data",
+        suggestion: "Add an emptyState attribute to show when table is empty",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var listTooManyItems = {
+  id: "data-list-pagination",
+  category: "data-display",
+  severity: "info",
+  name: "Long list may need pagination",
+  description: "Lists with many items should consider pagination or virtualization",
+  appliesTo: ["List"],
+  check: (node, context) => {
+    const items = getNodeItems(node);
+    const children = hasChildren(node) ? getChildren(node) : [];
+    const hasPagination = "pagination" in node || "paginated" in node;
+    const itemCount = items.length || children.filter((c) => isNodeType(c, "ListItem")).length;
+    if (itemCount > MAX_LIST_ITEMS && !hasPagination) {
+      return {
+        ruleId: "data-list-pagination",
+        category: "data-display",
+        severity: "info",
+        message: `List has ${itemCount} items (consider pagination for better performance)`,
+        description: "Long lists can be slow to render and overwhelming for users",
+        suggestion: "Add pagination, infinite scroll, or virtualization for long lists",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var tableTooManyColumns = {
+  id: "data-table-columns",
+  category: "data-display",
+  severity: "warning",
+  name: "Table has too many columns",
+  description: "Tables with many columns are hard to read on smaller screens",
+  appliesTo: ["Table"],
+  check: (node, context) => {
+    const columns = "columns" in node && Array.isArray(node.columns) ? node.columns : [];
+    if (columns.length > MAX_TABLE_COLUMNS) {
+      return {
+        ruleId: "data-table-columns",
+        category: "data-display",
+        severity: "warning",
+        message: `Table has ${columns.length} columns (recommended max: ${MAX_TABLE_COLUMNS})`,
+        description: "Tables with many columns are difficult to read and may not fit on mobile",
+        suggestion: "Consider hiding less important columns on mobile or using a different layout",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var cardGridConsistency = {
+  id: "data-card-grid",
+  category: "data-display",
+  severity: "info",
+  name: "Card grid should have consistent items",
+  description: "Cards in a grid layout should have consistent dimensions",
+  appliesTo: ["Row"],
+  check: (node, context) => {
+    if (!hasChildren(node)) {
+      return null;
+    }
+    const cards = getChildren(node).filter((c) => c.type === "Card");
+    if (cards.length < 3) return null;
+    const heights = cards.map((c) => "height" in c ? c.height : "h" in c ? c.h : null);
+    const definedHeights = heights.filter((h) => h !== null);
+    const uniqueHeights = [...new Set(definedHeights)];
+    if (uniqueHeights.length > 1) {
+      return {
+        ruleId: "data-card-grid",
+        category: "data-display",
+        severity: "info",
+        message: "Card grid has inconsistent card heights",
+        description: "Inconsistent card sizes can create visual imbalance",
+        suggestion: "Consider using consistent heights for cards in a grid layout",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var dataDisplayRules = [
+  tableHasHeader,
+  listEmptyState,
+  tableEmptyState,
+  listTooManyItems,
+  tableTooManyColumns,
+  cardGridConsistency
+];
+
+// src/rules/feedback.ts
+var spinnerHasContext = {
+  id: "feedback-spinner-context",
+  category: "feedback",
+  severity: "info",
+  name: "Spinner should have context",
+  description: "Loading spinners should indicate what is being loaded",
+  appliesTo: ["Spinner"],
+  check: (node, context) => {
+    const hasText = "text" in node && node.text;
+    const hasLabel = "label" in node && node.label;
+    const hasContent = "content" in node && node.content;
+    const siblingText = context.siblings.some(
+      (s) => s.type === "Text" && "content" in s && String(s.content || "").toLowerCase().includes("loading")
+    );
+    if (!hasText && !hasLabel && !hasContent && !siblingText) {
+      return {
+        ruleId: "feedback-spinner-context",
+        category: "feedback",
+        severity: "info",
+        message: "Spinner has no loading text",
+        description: "Users benefit from knowing what is being loaded",
+        suggestion: 'Add a text/label attribute like "Loading..." or "Please wait..."',
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var progressHasValue = {
+  id: "feedback-progress-value",
+  category: "feedback",
+  severity: "info",
+  name: "Progress should show value",
+  description: "Progress bars should indicate completion percentage",
+  appliesTo: ["Progress"],
+  check: (node, context) => {
+    const hasValue = "value" in node;
+    const hasPercent = "percent" in node;
+    const isIndeterminate = "indeterminate" in node && node.indeterminate;
+    if (isIndeterminate) return null;
+    if (!hasValue && !hasPercent) {
+      return {
+        ruleId: "feedback-progress-value",
+        category: "feedback",
+        severity: "info",
+        message: "Progress bar has no value specified",
+        description: "Users should see how much progress has been made",
+        suggestion: "Add a value attribute (0-100) or use indeterminate for unknown duration",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var toastDuration = {
+  id: "feedback-toast-duration",
+  category: "feedback",
+  severity: "info",
+  name: "Toast should have appropriate duration",
+  description: "Toasts should auto-dismiss after a reasonable time",
+  appliesTo: ["Toast"],
+  check: (node, context) => {
+    const duration = "duration" in node ? Number(node.duration) : null;
+    if (duration !== null) {
+      if (duration < MIN_TOAST_DURATION) {
+        return {
+          ruleId: "feedback-toast-duration",
+          category: "feedback",
+          severity: "info",
+          message: `Toast duration (${duration}ms) may be too short to read`,
+          description: "Users need time to read toast messages",
+          suggestion: `Increase duration to at least ${MIN_TOAST_DURATION}ms`,
+          path: context.path,
+          nodeType: node.type,
+          location: getNodeLocation(node)
+        };
+      }
+      if (duration > MAX_TOAST_DURATION) {
+        return {
+          ruleId: "feedback-toast-duration",
+          category: "feedback",
+          severity: "info",
+          message: `Toast duration (${duration}ms) may be too long`,
+          description: "Long-lasting toasts can be annoying and block UI",
+          suggestion: `Consider reducing duration or using a persistent alert instead`,
+          path: context.path,
+          nodeType: node.type,
+          location: getNodeLocation(node)
+        };
+      }
+    }
+    return null;
+  }
+};
+var alertDismissible = {
+  id: "feedback-alert-dismissible",
+  category: "feedback",
+  severity: "info",
+  name: "Non-critical alerts should be dismissible",
+  description: "Info and success alerts should be dismissible by users",
+  appliesTo: ["Alert"],
+  check: (node, context) => {
+    const variant = "variant" in node ? String(node.variant || "") : "";
+    const isDismissible = "dismissible" in node || "closable" in node || "onClose" in node;
+    if (variant === "danger" || variant === "error") return null;
+    if ((variant === "info" || variant === "success") && !isDismissible) {
+      return {
+        ruleId: "feedback-alert-dismissible",
+        category: "feedback",
+        severity: "info",
+        message: `${variant} alert is not dismissible`,
+        description: "Users should be able to dismiss non-critical alerts",
+        suggestion: "Add dismissible or closable attribute to allow users to close the alert",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var tooltipContentLength = {
+  id: "feedback-tooltip-length",
+  category: "feedback",
+  severity: "info",
+  name: "Tooltip content should be brief",
+  description: "Tooltips should be short and helpful",
+  appliesTo: ["Tooltip"],
+  check: (node, context) => {
+    const tooltipText = getNodeText(node);
+    if (tooltipText.length > MAX_TOOLTIP_LENGTH) {
+      return {
+        ruleId: "feedback-tooltip-length",
+        category: "feedback",
+        severity: "info",
+        message: `Tooltip is ${tooltipText.length} characters (recommended max: ${MAX_TOOLTIP_LENGTH})`,
+        description: "Long tooltips are hard to read and may disappear before being fully read",
+        suggestion: "Keep tooltips brief or use a popover for longer content",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var formErrorFeedback = {
+  id: "feedback-form-errors",
+  category: "feedback",
+  severity: "info",
+  name: "Form should handle errors",
+  description: "Forms should have a way to display validation errors",
+  appliesTo: ["Card", "Section", "Modal"],
+  check: (node, context) => {
+    if (!hasChildren(node)) {
+      return null;
+    }
+    const hasInputs = hasChildMatching(node, (child) => FORM_INPUT_TYPES.includes(child.type));
+    const hasErrorDisplay = hasChildMatching(node, (child) => {
+      if (FORM_INPUT_TYPES.includes(child.type)) {
+        if ("error" in child || "errorText" in child || "helperText" in child) {
+          return true;
+        }
+      }
+      if (child.type === "Alert" && "variant" in child) {
+        const variant = String(child.variant || "");
+        if (variant === "error" || variant === "danger") {
+          return true;
+        }
+      }
+      if (child.type === "Text") {
+        const content = getNodeText(child).toLowerCase();
+        if (content.includes("error") || content.includes("invalid")) {
+          return true;
+        }
+      }
+      return false;
+    });
+    if (hasInputs && !hasErrorDisplay) {
+      return {
+        ruleId: "feedback-form-errors",
+        category: "feedback",
+        severity: "info",
+        message: "Form area has no visible error handling",
+        description: "Users need to see validation errors when they occur",
+        suggestion: "Add error/errorText attributes to inputs or include an Alert for form-level errors",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var feedbackRules = [
+  spinnerHasContext,
+  progressHasValue,
+  toastDuration,
+  alertDismissible,
+  tooltipContentLength,
+  formErrorFeedback
+];
+
+// src/rules/interaction.ts
+var buttonHasAction = {
+  id: "interaction-button-action",
+  category: "interaction",
+  severity: "warning",
+  name: "Button should have action",
+  description: "Buttons should have an onClick, action, or navigation target defined",
+  appliesTo: ["Button"],
+  check: (node, context) => {
+    const hasOnClick = "onClick" in node;
+    const hasAction = "action" in node;
+    const hasHref = "href" in node;
+    const hasTo = "to" in node;
+    const hasNavigate = "navigate" in node;
+    const hasLink = "link" in node;
+    const hasSubmit = "buttonType" in node && node.buttonType === "submit";
+    const hasFormSubmit = "submit" in node;
+    const buttonText = getNodeText(node);
+    if (!hasOnClick && !hasAction && !hasHref && !hasTo && !hasNavigate && !hasLink && !hasSubmit && !hasFormSubmit) {
+      return {
+        ruleId: "interaction-button-action",
+        category: "interaction",
+        severity: "warning",
+        message: buttonText ? `Button "${buttonText}" has no action defined` : "Button has no action defined",
+        description: "Interactive buttons need an action to respond to user clicks",
+        suggestion: "Add onClick, action, href, or navigate attribute to define what happens when clicked",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var linkHasDestination = {
+  id: "interaction-link-destination",
+  category: "interaction",
+  severity: "warning",
+  name: "Link should have destination",
+  description: "Links should have an href or navigation target defined",
+  appliesTo: ["Link", "NavLink", "Anchor"],
+  check: (node, context) => {
+    const hasHref = "href" in node && node.href;
+    const hasTo = "to" in node && node.to;
+    const hasNavigate = "navigate" in node;
+    const hasUrl = "url" in node && node.url;
+    const linkText = getNodeText(node);
+    if (!hasHref && !hasTo && !hasNavigate && !hasUrl) {
+      return {
+        ruleId: "interaction-link-destination",
+        category: "interaction",
+        severity: "warning",
+        message: linkText ? `Link "${linkText}" has no destination` : "Link has no destination defined",
+        description: "Links need a destination URL or route to navigate to",
+        suggestion: "Add href, to, or navigate attribute to define the link destination",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var formHasSubmitAction = {
+  id: "interaction-form-submit",
+  category: "interaction",
+  severity: "warning",
+  name: "Form should have submit action",
+  description: "Forms should have an onSubmit action or form action defined",
+  appliesTo: ["Form"],
+  check: (node, context) => {
+    const hasOnSubmit = "onSubmit" in node;
+    const hasAction = "action" in node && node.action;
+    if (!hasOnSubmit && !hasAction) {
+      return {
+        ruleId: "interaction-form-submit",
+        category: "interaction",
+        severity: "warning",
+        message: "Form has no submit action defined",
+        description: "Forms need an action to handle submission",
+        suggestion: "Add onSubmit or action attribute to define form submission behavior",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var tabItemHasTarget = {
+  id: "interaction-tab-target",
+  category: "interaction",
+  severity: "warning",
+  name: "Tab item should have target",
+  description: "Tab items should link to content or have an action",
+  appliesTo: ["Tab", "TabItem"],
+  check: (node, context) => {
+    const hasTarget = "target" in node;
+    const hasPanel = "panel" in node;
+    const hasContent = "content" in node;
+    const hasOnClick = "onClick" in node;
+    const hasValue = "value" in node;
+    const tabLabel = getNodeText(node);
+    if (!hasTarget && !hasPanel && !hasContent && !hasOnClick && !hasValue) {
+      return {
+        ruleId: "interaction-tab-target",
+        category: "interaction",
+        severity: "warning",
+        message: tabLabel ? `Tab "${tabLabel}" has no target or action` : "Tab item has no target or action defined",
+        description: "Tab items need to reference content or trigger an action",
+        suggestion: "Add target, panel, value, or onClick attribute",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var menuItemHasAction = {
+  id: "interaction-menu-action",
+  category: "interaction",
+  severity: "warning",
+  name: "Menu item should have action",
+  description: "Menu items should have an onClick, href, or action defined",
+  appliesTo: ["MenuItem", "DropdownItem"],
+  check: (node, context) => {
+    const hasOnClick = "onClick" in node;
+    const hasAction = "action" in node;
+    const hasHref = "href" in node;
+    const hasTo = "to" in node;
+    const hasCommand = "command" in node;
+    const itemText = getNodeText(node);
+    if ("divider" in node || "separator" in node) {
+      return null;
+    }
+    if (!hasOnClick && !hasAction && !hasHref && !hasTo && !hasCommand) {
+      return {
+        ruleId: "interaction-menu-action",
+        category: "interaction",
+        severity: "warning",
+        message: itemText ? `Menu item "${itemText}" has no action` : "Menu item has no action defined",
+        description: "Menu items need an action to respond to selection",
+        suggestion: "Add onClick, action, href, or command attribute",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var clickableCardHasAction = {
+  id: "interaction-card-action",
+  category: "interaction",
+  severity: "info",
+  name: "Clickable card should have action",
+  description: "Cards marked as clickable should have an action defined",
+  appliesTo: ["Card"],
+  check: (node, context) => {
+    const isClickable = "clickable" in node || "hoverable" in node || "interactive" in node;
+    if (!isClickable) return null;
+    const hasOnClick = "onClick" in node;
+    const hasHref = "href" in node;
+    const hasTo = "to" in node;
+    const hasAction = "action" in node;
+    if (!hasOnClick && !hasHref && !hasTo && !hasAction) {
+      return {
+        ruleId: "interaction-card-action",
+        category: "interaction",
+        severity: "info",
+        message: "Clickable card has no action defined",
+        description: "Cards marked as clickable/interactive need an action",
+        suggestion: "Add onClick, href, or action attribute to define click behavior",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var iconButtonHasAction = {
+  id: "interaction-icon-button-action",
+  category: "interaction",
+  severity: "warning",
+  name: "Icon button should have action",
+  description: "Icon buttons should have an action defined",
+  appliesTo: ["IconButton"],
+  check: (node, context) => {
+    const hasOnClick = "onClick" in node;
+    const hasAction = "action" in node;
+    const hasHref = "href" in node;
+    const hasTo = "to" in node;
+    const iconName = "icon" in node ? String(node.icon || "") : "name" in node ? String(node.name || "") : "";
+    if (!hasOnClick && !hasAction && !hasHref && !hasTo) {
+      return {
+        ruleId: "interaction-icon-button-action",
+        category: "interaction",
+        severity: "warning",
+        message: iconName ? `Icon button "${iconName}" has no action defined` : "Icon button has no action defined",
+        description: "Icon buttons need an action to respond to clicks",
+        suggestion: "Add onClick, action, or href attribute",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var modalHasCloseAction = {
+  id: "interaction-modal-close",
+  category: "interaction",
+  severity: "info",
+  name: "Modal should have close mechanism",
+  description: "Modals should have a way to close them",
+  appliesTo: ["Modal", "Dialog"],
+  check: (node, context) => {
+    const hasOnClose = "onClose" in node;
+    const hasCloseButton = "closable" in node || "closeButton" in node;
+    const hasDismiss = "dismissible" in node || "dismiss" in node;
+    const hasCloseChild = hasChildren(node) && hasChildMatching(node, (child) => {
+      if (child.type === "Button") {
+        const text = "text" in child ? String(child.text || "").toLowerCase() : "";
+        const label = "label" in child ? String(child.label || "").toLowerCase() : "";
+        const action = "action" in child ? String(child.action || "").toLowerCase() : "";
+        return text.includes("close") || text.includes("cancel") || label.includes("close") || label.includes("cancel") || action.includes("close");
+      }
+      return false;
+    });
+    if (!hasOnClose && !hasCloseButton && !hasDismiss && !hasCloseChild) {
+      return {
+        ruleId: "interaction-modal-close",
+        category: "interaction",
+        severity: "info",
+        message: "Modal has no close mechanism defined",
+        description: "Users need a way to close modals",
+        suggestion: "Add onClose, closable attribute, or a close/cancel button",
+        path: context.path,
+        nodeType: node.type,
+        location: getNodeLocation(node)
+      };
+    }
+    return null;
+  }
+};
+var interactionRules = [
+  buttonHasAction,
+  linkHasDestination,
+  formHasSubmitAction,
+  tabItemHasTarget,
+  menuItemHasAction,
+  clickableCardHasAction,
+  iconButtonHasAction,
+  modalHasCloseAction
+];
+
 // src/rules/index.ts
 var allRules = [
   ...accessibilityRules,
@@ -1040,7 +2165,11 @@ var allRules = [
   ...touchTargetRules,
   ...consistencyRules,
   ...usabilityRules,
-  ...navigationRules
+  ...navigationRules,
+  ...contentRules,
+  ...dataDisplayRules,
+  ...feedbackRules,
+  ...interactionRules
 ];
 var rulesByCategory = {
   accessibility: accessibilityRules,
@@ -1048,7 +2177,11 @@ var rulesByCategory = {
   "touch-target": touchTargetRules,
   consistency: consistencyRules,
   usability: usabilityRules,
-  navigation: navigationRules
+  navigation: navigationRules,
+  content: contentRules,
+  "data-display": dataDisplayRules,
+  feedback: feedbackRules,
+  interaction: interactionRules
 };
 function getRulesForCategories(categories) {
   if (categories.length === 0) return allRules;
@@ -1072,7 +2205,6 @@ function validateUX(ast, options = {}) {
     customRules = [],
     disabledRules = []
   } = options;
-  resetConsistencyTrackers();
   let rules = categories.length > 0 ? getRulesForCategories(categories) : allRules;
   rules = [...rules, ...customRules];
   if (disabledRules.length > 0) {
@@ -1109,10 +2241,11 @@ function validateUX(ast, options = {}) {
     return true;
   }
   function walkNode(node, path, parent, siblings, index, depth) {
+    const rootNode = ast.children?.[0];
     const context = {
       path,
       parent,
-      root: ast.children[0],
+      root: isAnyNode(rootNode) ? rootNode : null,
       siblings,
       index,
       depth
@@ -1157,9 +2290,9 @@ function validateUX(ast, options = {}) {
     return true;
   }
   if (ast.children) {
-    for (let i = 0; i < ast.children.length; i++) {
-      const page = ast.children[i];
-      const children = ast.children;
+    const children = toAnyNodeArray(ast.children);
+    for (let i = 0; i < children.length; i++) {
+      const page = children[i];
       walkNode(page, `pages[${i}]`, null, children, i, 0);
     }
   }
@@ -1225,12 +2358,59 @@ function formatUXResult(result) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ASYNC_ACTION_WORDS,
+  CLOSE_WORDS,
+  CONTAINER_TYPES,
+  DESTRUCTIVE_WORDS,
+  ERROR_WORDS,
+  FORM_INPUT_TYPES,
+  GENERIC_LINK_TEXTS,
+  HOME_WORDS,
+  INPUT_TYPE_SUGGESTIONS,
+  MAX_BUTTONS,
+  MAX_BUTTON_TEXT_LENGTH,
+  MAX_FORM_FIELDS,
+  MAX_LIST_ITEMS,
+  MAX_NAV_ITEMS,
+  MAX_NESTING_DEPTH,
+  MAX_PAGE_ELEMENTS,
+  MAX_TABLE_COLUMNS,
+  MAX_TABS,
+  MAX_TITLE_LENGTH,
+  MAX_TOAST_DURATION,
+  MAX_TOOLTIP_LENGTH,
+  MIN_TOAST_DURATION,
+  MIN_TOUCH_TARGET,
+  PLACEHOLDER_PATTERNS,
+  RECOMMENDED_TOUCH_TARGET,
+  SIZE_MAP,
+  SUBMIT_WORDS,
+  SUCCESS_WORDS,
+  TEXT_CONTENT_TYPES,
+  WARNING_WORDS,
   allRules,
+  containsAnyWord,
+  countInChildren,
+  filterChildren,
+  findInChildren,
   formatUXResult,
+  getButtonStyle,
+  getChildren,
+  getNodeItems,
+  getNodeLocation,
+  getNodeText,
+  getNodeTextLower,
   getRulesForCategories,
+  getSizeValue,
   getUXIssues,
   getUXScore,
+  hasChildMatching,
+  hasChildren,
+  isAnyNode,
+  isNodeType,
   isUXValid,
+  matchesAnyWord,
   rulesByCategory,
+  toAnyNodeArray,
   validateUX
 });