eslint-plugin-sweepit 0.0.1

package/dist/index.js

@@ -0,0 +1,2732 @@
+// src/configs/react.ts
+import tsParser from "@typescript-eslint/parser";
+import tsEslintPlugin from "@typescript-eslint/eslint-plugin";
+import reactPlugin from "eslint-plugin-react";
+import reactHooksPlugin from "eslint-plugin-react-hooks";
+import reactNoEffectPlugin from "eslint-plugin-react-you-might-not-need-an-effect";
+function createReactConfig(sweepitPlugin) {
+  const reactConfig = {
+    plugins: {
+      sweepit: sweepitPlugin,
+      react: reactPlugin,
+      "react-hooks": reactHooksPlugin,
+      "react-you-might-not-need-an-effect": reactNoEffectPlugin,
+      "@typescript-eslint": tsEslintPlugin
+    },
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        ecmaVersion: "latest",
+        sourceType: "module",
+        ecmaFeatures: {
+          jsx: true
+        }
+      }
+    },
+    settings: {
+      react: {
+        version: "detect"
+      }
+    },
+    rules: {
+      "react/jsx-handler-names": [
+        "error",
+        {
+          eventHandlerPrefix: "handle",
+          eventHandlerPropPrefix: "on"
+        }
+      ],
+      "react/jsx-no-constructed-context-values": "error",
+      "react/jsx-no-useless-fragment": "error",
+      "react/jsx-pascal-case": "error",
+      "react/no-unstable-nested-components": "error",
+      "react-hooks/rules-of-hooks": "error",
+      "react-hooks/exhaustive-deps": "error",
+      "react-you-might-not-need-an-effect/no-effect": "error",
+      "sweepit/no-title-case-props": "error",
+      "sweepit/no-custom-kebab-case-props": "error",
+      "sweepit/no-set-prefix-utils": "error",
+      "sweepit/no-useless-hook": "error",
+      "sweepit/no-hook-jsx": "error",
+      "sweepit/no-exported-context-hooks": "error",
+      "sweepit/no-handler-return-type": "error",
+      "sweepit/jsx-server-action-prop-suffix": "error",
+      "sweepit/jsx-on-handler-verb-suffix": "error",
+      "sweepit/no-render-helper-functions": "error",
+      "sweepit/no-element-props": "error",
+      "sweepit/no-componenttype-props": "error",
+      "sweepit/no-object-props": "error",
+      "sweepit/no-array-props": "error",
+      "sweepit/no-prefixed-prop-bundles": "error",
+      "sweepit/no-optional-props-without-defaults": "error",
+      "sweepit/no-boolean-capability-props": "error",
+      "sweepit/max-custom-props": "error",
+      "sweepit/jsx-bem-compound-naming": "error",
+      "sweepit/jsx-compound-part-export-naming": "error",
+      "sweepit/no-pass-through-props": "error",
+      "sweepit/jsx-flat-owner-tree": "error"
+    }
+  };
+  return [reactConfig];
+}
+
+// src/rules/no-title-case-props.ts
+function getPropName(node) {
+  if (node.type === "JSXIdentifier") {
+    return node.name;
+  }
+  if (node.type === "JSXNamespacedName") {
+    return `${node.namespace.name}:${node.name.name}`;
+  }
+  return null;
+}
+function isTitleCase(name) {
+  if (name.length === 0) return false;
+  const first = name[0];
+  return first >= "A" && first <= "Z";
+}
+var rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow TitleCase JSX props",
+      url: "https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-title-case-props.md"
+    },
+    messages: {
+      noTitleCase: "Prop '{{prop}}' uses TitleCase. Use camelCase instead (e.g. {{suggestion}}). See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-title-case-props.md."
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      JSXAttribute(node) {
+        const attrName = node.name;
+        const propName = getPropName(attrName);
+        if (!propName || !isTitleCase(propName)) return;
+        const suggestion = propName.length > 1 ? propName[0].toLowerCase() + propName.slice(1) : propName.toLowerCase();
+        context.report({
+          node: node.name,
+          messageId: "noTitleCase",
+          data: { prop: propName, suggestion }
+        });
+      }
+    };
+  }
+};
+var no_title_case_props_default = rule;
+
+// src/rules/no-custom-kebab-case-props.ts
+var DEFAULT_ALLOWED_KEBAB_PREFIXES = ["aria-", "data-"];
+function getPropName2(node) {
+  if (node.type === "JSXIdentifier") {
+    return node.name;
+  }
+  if (node.type === "JSXNamespacedName") {
+    return `${node.namespace.name}:${node.name.name}`;
+  }
+  return null;
+}
+function isKebabCase(name) {
+  return name.includes("-");
+}
+function kebabToCamelCase(name) {
+  const segments = name.split("-").filter(Boolean);
+  if (segments.length === 0) return name;
+  const first = segments[0] ?? "";
+  const tail = segments.slice(1).map((segment) => segment[0]?.toUpperCase() + segment.slice(1)).join("");
+  return `${first}${tail}`;
+}
+function resolveRuleOptions(context) {
+  const option = context.options[0] ?? {};
+  const allowedPrefixes = Array.from(
+    /* @__PURE__ */ new Set([...DEFAULT_ALLOWED_KEBAB_PREFIXES, ...option.extendPrefixes ?? []])
+  );
+  const allowedProps = new Set(option.allowedProps ?? []);
+  return {
+    allowedPrefixes,
+    allowedProps
+  };
+}
+function isAllowedKebabProp(name, options) {
+  if (options.allowedProps.has(name)) return true;
+  return options.allowedPrefixes.some((prefix) => name.startsWith(prefix));
+}
+var rule2 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow custom kebab-case JSX props (allows aria-* and data-* by default with configurable additions)",
+      url: "https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-custom-kebab-case-props.md"
+    },
+    messages: {
+      noCustomKebab: "Custom kebab-case prop '{{prop}}' is not allowed. Rename to camelCase (for example '{{suggestion}}'), or keep kebab-case only for allowed native/custom prefixes. See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-custom-kebab-case-props.md."
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          extendPrefixes: {
+            type: "array",
+            items: { type: "string" }
+          },
+          allowedProps: {
+            type: "array",
+            items: { type: "string" }
+          }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  create(context) {
+    const options = resolveRuleOptions(context);
+    return {
+      JSXAttribute(node) {
+        const attrName = node.name;
+        const propName = getPropName2(attrName);
+        if (!propName || !isKebabCase(propName)) return;
+        if (isAllowedKebabProp(propName, options)) return;
+        context.report({
+          node: node.name,
+          messageId: "noCustomKebab",
+          data: { prop: propName, suggestion: kebabToCamelCase(propName) }
+        });
+      }
+    };
+  }
+};
+var no_custom_kebab_case_props_default = rule2;
+
+// src/rules/no-set-prefix-utils.ts
+var SET_PREFIX = "set";
+function startsWithSet(name) {
+  return name.startsWith(SET_PREFIX) && name.length > SET_PREFIX.length;
+}
+function isUseStateCall(node) {
+  if (!node || node.type !== "CallExpression") return false;
+  const call = node;
+  const callee = call.callee;
+  if (callee.type === "Identifier") {
+    return callee.name === "useState";
+  }
+  if (callee.type === "MemberExpression") {
+    const mem = callee;
+    return mem.property.type === "Identifier" && mem.property.name === "useState";
+  }
+  return false;
+}
+function isFunctionInit(node) {
+  if (!node) return false;
+  return node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
+}
+var rule3 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Forbid util/helper functions prefixed with set*; allow React state setter identifiers from useState tuple destructuring",
+      url: "https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-set-prefix-utils.md"
+    },
+    messages: {
+      noSetPrefixUtil: "Util/helper function '{{name}}' should not use set* prefix. Reserve set* for React useState setters. See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-set-prefix-utils.md."
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      FunctionDeclaration(node) {
+        const fn = node;
+        if (!fn.id || !startsWithSet(fn.id.name)) return;
+        context.report({
+          node: fn.id,
+          messageId: "noSetPrefixUtil",
+          data: { name: fn.id.name }
+        });
+      },
+      VariableDeclarator(node) {
+        const decl = node;
+        const { id, init } = decl;
+        if (id.type === "ArrayPattern") {
+          const arr = id;
+          if (arr.elements.length >= 2 && arr.elements[1]?.type === "Identifier" && isUseStateCall(init)) {
+            return;
+          }
+        }
+        if (id.type === "Identifier" && startsWithSet(id.name) && isFunctionInit(init)) {
+          context.report({
+            node: id,
+            messageId: "noSetPrefixUtil",
+            data: { name: id.name }
+          });
+        }
+      }
+    };
+  }
+};
+var no_set_prefix_utils_default = rule3;
+
+// src/rules/no-useless-hook.ts
+var HOOK_NAMES = /* @__PURE__ */ new Set([
+  "useState",
+  "useEffect",
+  "useReducer",
+  "useRef",
+  "useContext",
+  "useLayoutEffect",
+  "useImperativeHandle",
+  "useDebugValue",
+  "useId",
+  "useSyncExternalStore",
+  "useTransition",
+  "useDeferredValue",
+  "useOptimistic",
+  "useActionState",
+  "useFormStatus"
+]);
+function isUseName(name) {
+  return name.startsWith("use") && name.length > 3;
+}
+function isBuiltInOrCustomHookName(name) {
+  return HOOK_NAMES.has(name) || isUseName(name);
+}
+function isHookCall(node) {
+  if (!node || node.type !== "CallExpression") return false;
+  const call = node;
+  const callee = call.callee;
+  if (callee.type === "Identifier") {
+    return isBuiltInOrCustomHookName(callee.name);
+  }
+  if (callee.type === "MemberExpression") {
+    const mem = callee;
+    return mem.property.type === "Identifier" && mem.property.name != null && isBuiltInOrCustomHookName(mem.property.name);
+  }
+  return false;
+}
+var CHILD_KEYS = {
+  Program: ["body"],
+  BlockStatement: ["body"],
+  FunctionDeclaration: ["params", "body"],
+  FunctionExpression: ["params", "body"],
+  ArrowFunctionExpression: ["params", "body"],
+  CallExpression: ["callee", "arguments"],
+  ReturnStatement: ["argument"],
+  VariableDeclaration: ["declarations"],
+  VariableDeclarator: ["id", "init"],
+  ExpressionStatement: ["expression"],
+  MemberExpression: ["object", "property"],
+  ArrayPattern: ["elements"],
+  ObjectExpression: ["properties"]
+};
+function* traverse(node) {
+  if (!node || typeof node !== "object") return;
+  const stack = [node];
+  const seen = /* @__PURE__ */ new WeakSet();
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (seen.has(current)) continue;
+    seen.add(current);
+    yield current;
+    const keys = CHILD_KEYS[current.type ?? ""] ?? [];
+    const n = current;
+    for (const key of keys) {
+      const val = n[key];
+      if (val && typeof val === "object") {
+        if (Array.isArray(val)) {
+          for (let i = val.length - 1; i >= 0; i--) {
+            const child = val[i];
+            if (child && typeof child === "object" && "type" in child) {
+              stack.push(child);
+            }
+          }
+        } else if ("type" in val) {
+          stack.push(val);
+        }
+      }
+    }
+  }
+}
+function callsAnyHook(body) {
+  for (const child of traverse(body)) {
+    if (isHookCall(child)) return true;
+  }
+  return false;
+}
+function getFunctionBody(node) {
+  return node.body;
+}
+var rule4 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow use* functions that do not call any React hook (useState, useEffect, useReducer, useRef, useContext)",
+      url: "https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-useless-hook.md"
+    },
+    messages: {
+      noUselessHook: "Function '{{name}}' is named like a hook but does not call any React hook. Rename or add hook calls. See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-useless-hook.md."
+    },
+    schema: []
+  },
+  create(context) {
+    function checkHookLikeFunction(name, body, reportNode) {
+      if (!isUseName(name)) return;
+      if (callsAnyHook(body)) return;
+      context.report({
+        node: reportNode,
+        messageId: "noUselessHook",
+        data: { name }
+      });
+    }
+    return {
+      FunctionDeclaration(node) {
+        const fn = node;
+        if (!fn.id) return;
+        checkHookLikeFunction(fn.id.name, getFunctionBody(node), fn.id);
+      },
+      VariableDeclarator(node) {
+        const decl = node;
+        const { id, init } = decl;
+        if (id.type !== "Identifier") return;
+        const name = id.name;
+        if (!isUseName(name)) return;
+        if (init?.type !== "ArrowFunctionExpression" && init?.type !== "FunctionExpression") {
+          return;
+        }
+        const body = getFunctionBody(init);
+        checkHookLikeFunction(name, body, id);
+      }
+    };
+  }
+};
+var no_useless_hook_default = rule4;
+
+// src/rules/no-hook-jsx.ts
+function isUseName2(name) {
+  return name.startsWith("use") && name.length > 3;
+}
+function isJSXNode(node) {
+  if (!node) return false;
+  const type = node.type;
+  return type === "JSXElement" || type === "JSXFragment";
+}
+var CHILD_KEYS2 = {
+  Program: ["body"],
+  BlockStatement: ["body"],
+  ReturnStatement: ["argument"],
+  VariableDeclarator: ["id", "init"],
+  ExpressionStatement: ["expression"],
+  IfStatement: ["test", "consequent", "alternate"],
+  ForStatement: ["init", "test", "update", "body"],
+  ForInStatement: ["left", "right", "body"],
+  ForOfStatement: ["left", "right", "body"],
+  WhileStatement: ["test", "body"],
+  DoWhileStatement: ["body", "test"],
+  SwitchStatement: ["discriminant", "cases"],
+  SwitchCase: ["test", "consequent"],
+  TryStatement: ["block", "handler", "finalizer"],
+  CatchClause: ["param", "body"],
+  // Expression nodes that may contain nested JSX
+  ArrowFunctionExpression: ["params", "body"],
+  FunctionExpression: ["params", "body"],
+  ObjectExpression: ["properties"],
+  Property: ["key", "value"],
+  ArrayExpression: ["elements"],
+  ConditionalExpression: ["test", "consequent", "alternate"],
+  LogicalExpression: ["left", "right"],
+  CallExpression: ["callee", "arguments"],
+  SequenceExpression: ["expressions"],
+  SpreadElement: ["argument"],
+  MemberExpression: ["object", "property"],
+  JSXElement: ["openingElement", "closingElement", "children"],
+  JSXFragment: ["openingFragment", "closingFragment", "children"]
+};
+var STATEMENT_CHILD_KEYS = {
+  ...CHILD_KEYS2,
+  // Do not descend into nested function bodies when finding ReturnStatements
+  FunctionDeclaration: ["params"],
+  FunctionExpression: ["params"],
+  ArrowFunctionExpression: ["params"]
+};
+function* traverse2(node, opts) {
+  if (!node || typeof node !== "object") return;
+  const keysMap = opts?.skipFunctionBodies ? STATEMENT_CHILD_KEYS : CHILD_KEYS2;
+  const stack = [node];
+  const seen = /* @__PURE__ */ new WeakSet();
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current || seen.has(current)) continue;
+    seen.add(current);
+    yield current;
+    const keys = keysMap[current.type ?? ""] ?? [];
+    const n = current;
+    for (const key of keys) {
+      const val = n[key];
+      if (val && typeof val === "object") {
+        if (Array.isArray(val)) {
+          for (let i = val.length - 1; i >= 0; i--) {
+            const child = val[i];
+            if (child && typeof child === "object" && "type" in child) {
+              stack.push(child);
+            }
+          }
+        } else if ("type" in val) {
+          stack.push(val);
+        }
+      }
+    }
+  }
+}
+function containsJSX(node) {
+  for (const n of traverse2(node)) {
+    if (isJSXNode(n)) return true;
+  }
+  return false;
+}
+function returnsJSX(body) {
+  if (!body) return false;
+  const b = body;
+  if (b.type === "JSXElement" || b.type === "JSXFragment") {
+    return true;
+  }
+  if (b.type === "BlockStatement") {
+    const block = body;
+    for (const statement of block.body ?? []) {
+      for (const child of traverse2(statement, {
+        skipFunctionBodies: true
+      })) {
+        const c = child;
+        if (c.type === "ReturnStatement" && c.argument) {
+          if (containsJSX(c.argument)) return true;
+        }
+      }
+    }
+    return false;
+  }
+  return containsJSX(body);
+}
+var rule5 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow use* functions that return JSX. Hooks should return values, not components.",
+      url: "https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-hook-jsx.md"
+    },
+    messages: {
+      noHookJsx: "Function '{{name}}' is named like a hook but returns JSX. Hooks should return data, not render. Use a component instead. See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-hook-jsx.md."
+    },
+    schema: []
+  },
+  create(context) {
+    function checkHookLikeFunction(name, body, reportNode) {
+      if (!isUseName2(name)) return;
+      if (!returnsJSX(body)) return;
+      context.report({
+        node: reportNode,
+        messageId: "noHookJsx",
+        data: { name }
+      });
+    }
+    return {
+      FunctionDeclaration(node) {
+        const fn = node;
+        if (!fn.id) return;
+        checkHookLikeFunction(fn.id.name, fn.body, fn.id);
+      },
+      VariableDeclarator(node) {
+        const decl = node;
+        const { id, init } = decl;
+        if (id.type !== "Identifier") return;
+        const name = id.name;
+        if (!isUseName2(name)) return;
+        if (init?.type !== "ArrowFunctionExpression" && init?.type !== "FunctionExpression") {
+          return;
+        }
+        const body = init.body;
+        checkHookLikeFunction(name, body, id);
+      }
+    };
+  }
+};
+var no_hook_jsx_default = rule5;
+
+// src/rules/no-exported-context-hooks.ts
+function isContextHookName(name) {
+  return name.startsWith("use") && name.endsWith("Context") && name.length > 10;
+}
+function reportIfContextHook(context, node, name) {
+  if (!isContextHookName(name)) return;
+  context.report({
+    node,
+    messageId: "noExportedContextHook",
+    data: { name }
+  });
+}
+var rule6 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow exporting use*Context hooks. Keep context hooks private to the component module.",
+      url: "https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-exported-context-hooks.md"
+    },
+    messages: {
+      noExportedContextHook: "Do not export context hook '{{name}}'. Keep it private and expose a controlled component API instead (for example `open` + `onOpenChange`). See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-exported-context-hooks.md."
+    },
+    schema: []
+  },
+  create(context) {
+    function checkNamedExport(node) {
+      const exp = node;
+      const declaration = exp.declaration;
+      if (declaration?.type === "FunctionDeclaration") {
+        const fn = declaration;
+        if (!fn.id?.name) return;
+        reportIfContextHook(context, declaration, fn.id.name);
+        return;
+      }
+      if (declaration?.type === "VariableDeclaration") {
+        const decl = declaration;
+        for (const entry of decl.declarations ?? []) {
+          const d = entry;
+          if (d.id?.type !== "Identifier") continue;
+          const id = d.id;
+          reportIfContextHook(context, d.id, id.name);
+        }
+        return;
+      }
+      for (const specifier of exp.specifiers ?? []) {
+        if (specifier.type !== "ExportSpecifier") continue;
+        const s = specifier;
+        if (s.local?.type === "Identifier") {
+          const local = s.local;
+          reportIfContextHook(context, s.local, local.name);
+          continue;
+        }
+        if (s.exported?.type === "Identifier") {
+          const exported = s.exported;
+          reportIfContextHook(context, s.exported, exported.name);
+        }
+      }
+    }
+    function checkDefaultExport(node) {
+      const exp = node;
+      const declaration = exp.declaration;
+      if (!declaration) return;
+      if (declaration.type === "Identifier") {
+        const id = declaration;
+        reportIfContextHook(context, declaration, id.name);
+        return;
+      }
+      if (declaration.type === "FunctionDeclaration") {
+        const fn = declaration;
+        if (!fn.id?.name) return;
+        reportIfContextHook(context, declaration, fn.id.name);
+      }
+    }
+    return {
+      ExportNamedDeclaration: checkNamedExport,
+      ExportDefaultDeclaration: checkDefaultExport
+    };
+  }
+};
+var no_exported_context_hooks_default = rule6;
+
+// src/rules/no-handler-return-type.ts
+function getKeyName(node) {
+  if (node.type === "Identifier") return node.name;
+  if (node.type === "Literal" && typeof node.value === "string") return node.value;
+  return null;
+}
+function isHandlerProp(name) {
+  if (!name.startsWith("on") || name.length <= 2) return false;
+  const third = name[2];
+  return third >= "A" && third <= "Z";
+}
+function getReturnTypeAnnotation(node) {
+  const rt = node.returnType;
+  return rt?.typeAnnotation ?? null;
+}
+function isVoidType(typeNode) {
+  return typeNode.type === "TSVoidKeyword";
+}
+function isAllowedHandlerReturnType(typeNode) {
+  return isVoidType(typeNode);
+}
+function getFunctionReturnTypes(typeNode) {
+  const n = typeNode;
+  if (n.type === "TSFunctionType") {
+    const returnType = getReturnTypeAnnotation(typeNode);
+    return returnType ? [returnType] : [];
+  }
+  if (n.type === "TSParenthesizedType" && n.typeAnnotation) {
+    return getFunctionReturnTypes(n.typeAnnotation);
+  }
+  if ((n.type === "TSUnionType" || n.type === "TSIntersectionType") && Array.isArray(n.types)) {
+    const result = [];
+    for (const entry of n.types) result.push(...getFunctionReturnTypes(entry));
+    return result;
+  }
+  return [];
+}
+function getInvalidReturnType(typeNode) {
+  const returnTypes = getFunctionReturnTypes(typeNode);
+  for (const returnType of returnTypes) {
+    if (!isAllowedHandlerReturnType(returnType)) return returnType;
+  }
+  return null;
+}
+function reportInvalidReturnType(context, node, propName, returnType) {
+  context.report({
+    node,
+    messageId: "noHandlerReturnType",
+    data: {
+      prop: propName,
+      returnType: context.sourceCode.getText(returnType)
+    }
+  });
+}
+function isComponentPropsContractName(name) {
+  return name?.endsWith("Props") ?? false;
+}
+var rule7 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow handler prop definitions (on*) that expect return values. Handler contracts must return void.",
+      url: "https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-handler-return-type.md"
+    },
+    messages: {
+      noHandlerReturnType: "Handler prop '{{prop}}' expects return type '{{returnType}}'. Handler prop definitions must not expect return values; use void. See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-handler-return-type.md."
+    },
+    schema: []
+  },
+  create(context) {
+    function checkPropertySignature(node) {
+      const property = node;
+      if (!property.key || !property.typeAnnotation?.typeAnnotation) return;
+      const propName = getKeyName(property.key);
+      if (!propName || !isHandlerProp(propName)) return;
+      const invalidReturnType = getInvalidReturnType(property.typeAnnotation.typeAnnotation);
+      if (!invalidReturnType) return;
+      reportInvalidReturnType(context, node, propName, invalidReturnType);
+    }
+    function checkMethodSignature(node) {
+      const method = node;
+      if (!method.key || !method.returnType?.typeAnnotation) return;
+      const propName = getKeyName(method.key);
+      if (!propName || !isHandlerProp(propName)) return;
+      if (isAllowedHandlerReturnType(method.returnType.typeAnnotation)) return;
+      reportInvalidReturnType(context, node, propName, method.returnType.typeAnnotation);
+    }
+    function checkMembers(members) {
+      for (const member of members) {
+        const maybeMember = member;
+        if (maybeMember.type === "TSPropertySignature") {
+          checkPropertySignature(member);
+          continue;
+        }
+        if (maybeMember.type === "TSMethodSignature") {
+          checkMethodSignature(member);
+        }
+      }
+    }
+    return {
+      TSInterfaceDeclaration(node) {
+        const declaration = node;
+        if (!isComponentPropsContractName(declaration.id?.name)) return;
+        if (declaration.body?.type !== "TSInterfaceBody") return;
+        checkMembers(declaration.body.body ?? []);
+      },
+      TSTypeAliasDeclaration(node) {
+        const declaration = node;
+        if (!isComponentPropsContractName(declaration.id?.name)) return;
+        if (declaration.typeAnnotation?.type !== "TSTypeLiteral") return;
+        checkMembers(declaration.typeAnnotation.members ?? []);
+      }
+    };
+  }
+};
+var no_handler_return_type_default = rule7;
+
+// src/rules/jsx-server-action-prop-suffix.ts
+function getKeyName2(node) {
+  if (node.type === "Identifier") return node.name;
+  if (node.type === "Literal" && typeof node.value === "string") return node.value;
+  return null;
+}
+function isActionPropName(name) {
+  return name === "action" || name.endsWith("Action");
+}
+function getReturnTypeAnnotation2(node) {
+  return node.returnType?.typeAnnotation ?? null;
+}
+function isPromiseType(typeNode) {
+  const n = typeNode;
+  if (n.type !== "TSTypeReference") return false;
+  const typeName = n.typeName?.name ?? n.typeName?.right?.name;
+  return typeName === "Promise";
+}
+function isComponentPropsContractName2(name) {
+  return name?.endsWith("Props") ?? false;
+}
+function getFunctionReturnTypes2(typeNode) {
+  const n = typeNode;
+  if (n.type === "TSFunctionType") {
+    const returnType = getReturnTypeAnnotation2(typeNode);
+    return returnType ? [returnType] : [];
+  }
+  if (n.type === "TSParenthesizedType" && n.typeAnnotation) {
+    return getFunctionReturnTypes2(n.typeAnnotation);
+  }
+  if ((n.type === "TSUnionType" || n.type === "TSIntersectionType") && Array.isArray(n.types)) {
+    const result = [];
+    for (const entry of n.types) result.push(...getFunctionReturnTypes2(entry));
+    return result;
+  }
+  return [];
+}
+var rule8 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce async function prop contracts to use action prop names (action or *Action).",
+      url: "https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/jsx-server-action-prop-suffix.md"
+    },
+    messages: {
+      asyncPropRequiresActionName: "Prop '{{prop}}' expects an async function type ('{{returnType}}'). Async function props must be named 'action' or end with 'Action'. See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/jsx-server-action-prop-suffix.md."
+    },
+    schema: []
+  },
+  create(context) {
+    function reportIfNeeded(node, propName, returnType) {
+      if (isActionPropName(propName)) return;
+      context.report({
+        node,
+        messageId: "asyncPropRequiresActionName",
+        data: { prop: propName, returnType: context.sourceCode.getText(returnType) }
+      });
+    }
+    function checkPropertySignature(node) {
+      const property = node;
+      const key = property.key;
+      const typeNode = property.typeAnnotation?.typeAnnotation;
+      if (!key || !typeNode) return;
+      const propName = getKeyName2(key);
+      if (!propName) return;
+      for (const returnType of getFunctionReturnTypes2(typeNode)) {
+        if (isPromiseType(returnType)) {
+          reportIfNeeded(node, propName, returnType);
+          return;
+        }
+      }
+    }
+    function checkMethodSignature(node) {
+      const method = node;
+      const key = method.key;
+      const returnType = method.returnType?.typeAnnotation;
+      if (!key || !returnType) return;
+      if (!isPromiseType(returnType)) return;
+      const propName = getKeyName2(key);
+      if (!propName) return;
+      reportIfNeeded(node, propName, returnType);
+    }
+    function checkMembers(members) {
+      for (const member of members) {
+        const maybeMember = member;
+        if (maybeMember.type === "TSPropertySignature") {
+          checkPropertySignature(member);
+          continue;
+        }
+        if (maybeMember.type === "TSMethodSignature") {
+          checkMethodSignature(member);
+        }
+      }
+    }
+    return {
+      TSInterfaceDeclaration(node) {
+        const declaration = node;
+        if (!isComponentPropsContractName2(declaration.id?.name)) return;
+        if (declaration.body?.type !== "TSInterfaceBody") return;
+        checkMembers(declaration.body.body ?? []);
+      },
+      TSTypeAliasDeclaration(node) {
+        const declaration = node;
+        if (!isComponentPropsContractName2(declaration.id?.name)) return;
+        if (declaration.typeAnnotation?.type !== "TSTypeLiteral") return;
+        checkMembers(declaration.typeAnnotation.members ?? []);
+      }
+    };
+  }
+};
+var jsx_server_action_prop_suffix_default = rule8;
+
+// src/rules/jsx-on-handler-verb-suffix.ts
+var DEFAULT_VERBS = [
+  "abort",
+  "access",
+  "activate",
+  "add",
+  "blur",
+  "cancel",
+  "change",
+  "clear",
+  "click",
+  "close",
+  "collapse",
+  "complete",
+  "connect",
+  "copy",
+  "create",
+  "deactivate",
+  "delete",
+  "disable",
+  "dismiss",
+  "drag",
+  "drop",
+  "edit",
+  "enable",
+  "end",
+  "error",
+  "expand",
+  "finish",
+  "focus",
+  "generate",
+  "get",
+  "hide",
+  "hover",
+  "input",
+  "install",
+  "keydown",
+  "keyup",
+  "load",
+  "mount",
+  "move",
+  "open",
+  "paste",
+  "pause",
+  "persist",
+  "play",
+  "press",
+  "progress",
+  "query",
+  "ready",
+  "remove",
+  "rename",
+  "request",
+  "reset",
+  "resize",
+  "retry",
+  "revalidate",
+  "revert",
+  "save",
+  "scroll",
+  "seek",
+  "select",
+  "show",
+  "skip",
+  "start",
+  "submit",
+  "success",
+  "track",
+  "undo",
+  "update",
+  "upgrade",
+  "upload",
+  "validate",
+  "wheel"
+];
+function mergeAllowedValues(defaults, configured) {
+  const configuredValues = configured ?? [];
+  const allValues = [...defaults, ...configuredValues];
+  return [...new Set(allValues.map(normalizeConfigValue).filter(Boolean))];
+}
+function normalizeConfigValue(value) {
+  return value.trim().toLowerCase().replace(/\s+/g, "");
+}
+function getPropName3(node) {
+  if (node.type === "JSXIdentifier") {
+    return node.name;
+  }
+  if (node.type === "JSXNamespacedName") {
+    return `${node.namespace.name}:${node.name.name}`;
+  }
+  return null;
+}
+function isHandlerProp2(name) {
+  if (!name.startsWith("on") || name.length <= 2) return false;
+  const third = name[2];
+  return third >= "A" && third <= "Z";
+}
+function hasVerbSuffix(rest, verbs) {
+  const restLower = rest.toLowerCase();
+  return verbs.some((verb) => restLower.endsWith(verb));
+}
+function getVerbSuffixSuggestion(propName, verbs) {
+  if (!isHandlerProp2(propName)) return null;
+  const rest = propName.slice(2);
+  const restLower = rest.toLowerCase();
+  if (rest.length < 2) return null;
+  if (hasVerbSuffix(rest, verbs)) return null;
+  for (const verb of verbs) {
+    if (!restLower.startsWith(verb)) continue;
+    const verbOriginal = rest.slice(0, verb.length);
+    const subject = rest.slice(verb.length);
+    if (subject.length < 1) continue;
+    if (subject[0] !== subject[0].toUpperCase()) continue;
+    return `on${subject}${verbOriginal}`;
+  }
+  return null;
+}
+var rule9 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Ensure on* handler prop names end with a verb (for example onValueChange).",
+      url: "https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/jsx-on-handler-verb-suffix.md"
+    },
+    messages: {
+      mustEndWithVerb: "Handler prop '{{prop}}' should end with a verb (for example 'onValueChange'). If the suffix is a legitimate domain verb, add it to this rule's 'extendVerbs' option. AI agents: update rule options before renaming APIs. See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/jsx-on-handler-verb-suffix.md.",
+      preferVerbSuffix: "Prefer '{{suggestion}}' over '{{prop}}' so the handler name ends with a verb. See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/jsx-on-handler-verb-suffix.md."
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          extendVerbs: {
+            type: "array",
+            items: {
+              type: "string"
+            }
+          }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  create(context) {
+    const options = context.options[0] ?? {};
+    const verbs = mergeAllowedValues(DEFAULT_VERBS, options.extendVerbs);
+    verbs.sort((a, b) => b.length - a.length);
+    return {
+      JSXAttribute(node) {
+        const attr = node;
+        const propName = getPropName3(attr.name);
+        if (!propName) return;
+        if (!isHandlerProp2(propName)) return;
+        const rest = propName.slice(2);
+        if (hasVerbSuffix(rest, verbs)) return;
+        const suggestion = getVerbSuffixSuggestion(propName, verbs);
+        context.report({
+          node: attr.name,
+          messageId: suggestion ? "preferVerbSuffix" : "mustEndWithVerb",
+          data: suggestion ? { prop: propName, suggestion } : { prop: propName }
+        });
+      }
+    };
+  }
+};
+var jsx_on_handler_verb_suffix_default = rule9;
+
+// src/rules/no-render-helper-functions.ts
+function isPascalCase(name) {
+  if (!name || name.length === 0) return false;
+  return /^[A-Z][a-zA-Z0-9]*$/.test(name);
+}
+function expressionReturnsJSX(node) {
+  if (!node) return false;
+  const n = node;
+  const t = n.type;
+  if (t === "JSXElement" || t === "JSXFragment") return true;
+  if (t === "ParenthesizedExpression") {
+    return expressionReturnsJSX(n.expression);
+  }
+  if (t === "ConditionalExpression") {
+    return expressionReturnsJSX(n.consequent) || expressionReturnsJSX(n.alternate);
+  }
+  if (t === "LogicalExpression") {
+    return expressionReturnsJSX(n.left) || expressionReturnsJSX(n.right);
+  }
+  return false;
+}
+var STATEMENT_CHILD_KEYS2 = {
+  BlockStatement: ["body"],
+  IfStatement: ["test", "consequent", "alternate"],
+  ForStatement: ["init", "test", "update", "body"],
+  ForInStatement: ["left", "right", "body"],
+  ForOfStatement: ["left", "right", "body"],
+  WhileStatement: ["test", "body"],
+  DoWhileStatement: ["body", "test"],
+  SwitchStatement: ["discriminant", "cases"],
+  SwitchCase: ["test", "consequent"],
+  TryStatement: ["block", "handler", "finalizer"],
+  CatchClause: ["param", "body"],
+  ReturnStatement: ["argument"],
+  ExpressionStatement: ["expression"],
+  VariableDeclaration: ["declarations"]
+};
+function* traverseStatements(node) {
+  if (!node || typeof node !== "object") return;
+  const stack = [node];
+  const seen = /* @__PURE__ */ new WeakSet();
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (seen.has(current)) continue;
+    seen.add(current);
+    yield current;
+    const keys = STATEMENT_CHILD_KEYS2[current.type ?? ""] ?? [];
+    const n = current;
+    for (const key of keys) {
+      const val = n[key];
+      if (val && typeof val === "object") {
+        if (Array.isArray(val)) {
+          for (let i = val.length - 1; i >= 0; i--) {
+            const child = val[i];
+            if (child && typeof child === "object" && "type" in child) {
+              stack.push(child);
+            }
+          }
+        } else if ("type" in val) {
+          stack.push(val);
+        }
+      }
+    }
+  }
+}
+function functionReturnsJSX(body) {
+  if (!body) return false;
+  const b = body;
+  if (b.type === "JSXElement" || b.type === "JSXFragment") {
+    return true;
+  }
+  if (b.type === "BlockStatement") {
+    for (const child of traverseStatements(body)) {
+      const s = child;
+      if (s.type === "ReturnStatement" && s.argument) {
+        if (expressionReturnsJSX(s.argument)) return true;
+      }
+    }
+  }
+  return false;
+}
+var rule10 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Forbid JSX returned from non-component functions. Functions that return JSX should use PascalCase names.",
+      url: "https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-render-helper-functions.md"
+    },
+    messages: {
+      noRenderHelperFunctions: "Function '{{name}}' returns JSX but is not PascalCase. Use a component name (PascalCase) or move the JSX elsewhere. See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-render-helper-functions.md."
+    },
+    schema: []
+  },
+  create(context) {
+    function checkFunction(name, body, reportNode) {
+      if (isPascalCase(name)) return;
+      if (!functionReturnsJSX(body)) return;
+      context.report({
+        node: reportNode,
+        messageId: "noRenderHelperFunctions",
+        data: { name }
+      });
+    }
+    return {
+      FunctionDeclaration(node) {
+        const fn = node;
+        if (!fn.id) return;
+        checkFunction(fn.id.name, fn.body, fn.id);
+      },
+      VariableDeclarator(node) {
+        const decl = node;
+        const { id, init } = decl;
+        if (id.type !== "Identifier") return;
+        const name = id.name;
+        if (init?.type !== "ArrowFunctionExpression" && init?.type !== "FunctionExpression") {
+          return;
+        }
+        const body = init.body;
+        checkFunction(name, body, id);
+      }
+    };
+  }
+};
+var no_render_helper_functions_default = rule10;
+
+// src/rules/no-element-props.ts
+function getPropKeyName(prop) {
+  const key = prop.key;
+  if (key.type === "Identifier" && "name" in key) return key.name ?? null;
+  return null;
+}
+function getPropsFromInterfaceBody(body) {
+  return body.body ?? [];
+}
+function getPropsFromTypeLiteral(typeNode) {
+  const n = typeNode;
+  if (n && n.type === "TSTypeLiteral" && Array.isArray(n.members)) return n.members;
+  return [];
+}
+function isComponentPropsContractName3(name) {
+  return name?.endsWith("Props") ?? false;
+}
+var rule11 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow ReactNode/ReactElement-typed props except children/render.",
+      url: "https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-element-props.md"
+    },
+    messages: {
+      noElementProps: "Prop '{{prop}}' has an element type (ReactNode/ReactElement). Use compound composition instead: expose parts and compose via 'children' (for example <Card><Card.Header /></Card>) rather than passing '{{prop}}' as an element prop. See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-element-props.md."
+    },
+    schema: []
+  },
+  create(context) {
+    const aliasTypeMap = /* @__PURE__ */ new Map();
+    function getTypeNameFromRef2(node) {
+      const typeName = node.typeName;
+      if ("name" in typeName && typeName.name) return typeName.name;
+      if ("right" in typeName && typeName.right?.name) return typeName.right.name;
+      return null;
+    }
+    function astContainsReactType(typeNode, reactTypeName, visitedAliases) {
+      if (!typeNode || typeof typeNode !== "object") return false;
+      const node = typeNode;
+      if (node.type === "TSTypeReference") {
+        const ref = node;
+        const typeName = getTypeNameFromRef2(ref);
+        if (typeName === reactTypeName) return true;
+        if (typeName && aliasTypeMap.has(typeName) && !visitedAliases.has(typeName)) {
+          visitedAliases.add(typeName);
+          return astContainsReactType(aliasTypeMap.get(typeName), reactTypeName, visitedAliases);
+        }
+        return false;
+      }
+      if (node.type === "TSUnionType" || node.type === "TSIntersectionType") {
+        const unionNode = node;
+        return (unionNode.types ?? []).some(
+          (entry) => astContainsReactType(entry, reactTypeName, visitedAliases)
+        );
+      }
+      if (node.type === "TSOptionalType" || node.type === "TSParenthesizedType") {
+        const wrapped = node;
+        return astContainsReactType(wrapped.typeAnnotation, reactTypeName, visitedAliases);
+      }
+      return false;
+    }
+    function checkProp(prop, reportNode) {
+      const name = getPropKeyName(prop);
+      if (!name) return;
+      const typeAnn = prop.typeAnnotation?.typeAnnotation;
+      const hasReactNodeType = astContainsReactType(typeAnn, "ReactNode", /* @__PURE__ */ new Set());
+      const hasReactElementType = astContainsReactType(typeAnn, "ReactElement", /* @__PURE__ */ new Set());
+      const hasElementType = hasReactNodeType || hasReactElementType;
+      if (hasElementType && name !== "children" && name !== "render") {
+        context.report({
+          node: reportNode,
+          messageId: "noElementProps",
+          data: { prop: name }
+        });
+      }
+    }
+    function visitProps(props) {
+      for (const prop of props) {
+        if (prop.type !== "TSPropertySignature") continue;
+        checkProp(prop, prop.key);
+      }
+    }
+    const pendingChecks = [];
+    return {
+      TSInterfaceDeclaration(node) {
+        const decl = node;
+        if (!isComponentPropsContractName3(decl.id?.name)) return;
+        if (decl.body?.type === "TSInterfaceBody") {
+          const props = getPropsFromInterfaceBody(decl.body);
+          pendingChecks.push(() => visitProps(props));
+        }
+      },
+      TSTypeAliasDeclaration(node) {
+        const decl = node;
+        if (decl.id?.type === "Identifier" && decl.id.name && decl.typeAnnotation) {
+          aliasTypeMap.set(decl.id.name, decl.typeAnnotation);
+        }
+        if (!isComponentPropsContractName3(decl.id?.name)) return;
+        const typeAnn = decl.typeAnnotation;
+        if (typeAnn) {
+          const props = getPropsFromTypeLiteral(typeAnn);
+          pendingChecks.push(() => visitProps(props));
+        }
+      },
+      "Program:exit"() {
+        for (const check of pendingChecks) check();
+      }
+    };
+  }
+};
+var no_element_props_default = rule11;
+
+// src/rules/no-componenttype-props.ts
+var FORBIDDEN_TYPE_NAMES = /* @__PURE__ */ new Set(["ComponentType", "FC", "FunctionComponent"]);
+function getTypeNameFromRef(node) {
+  const tn = node.typeName;
+  if ("name" in tn && tn.name) return tn.name;
+  if ("right" in tn && tn.right) return tn.right.name;
+  return null;
+}
+function isComponentTypeProp(typeNode, resolveAliasType, seenAliases = /* @__PURE__ */ new Set()) {
+  if (!typeNode || typeof typeNode !== "object") return false;
+  const n = typeNode;
+  if (n.type === "TSTypeReference") {
+    const ref = n;
+    const name = getTypeNameFromRef(ref);
+    if (name !== null && FORBIDDEN_TYPE_NAMES.has(name)) return true;
+    if (!name || !resolveAliasType || seenAliases.has(name)) return false;
+    const aliasType = resolveAliasType(name);
+    if (!aliasType) return false;
+    const nextSeenAliases = new Set(seenAliases);
+    nextSeenAliases.add(name);
+    return isComponentTypeProp(aliasType, resolveAliasType, nextSeenAliases);
+  }
+  if (n.type === "TSUnionType" || n.type === "TSIntersectionType") {
+    const union = n;
+    return (union.types ?? []).some((t) => isComponentTypeProp(t, resolveAliasType, seenAliases));
+  }
+  if (n.type === "TSOptionalType") {
+    const opt = n;
+    return isComponentTypeProp(opt.typeAnnotation, resolveAliasType, seenAliases);
+  }
+  return false;
+}
+function getPropKeyName2(prop) {
+  const key = prop.key;
+  if (key.type === "Identifier" && "name" in key) return key.name ?? null;
+  return null;
+}
+function getPropsFromInterfaceBody2(body) {
+  return body.body ?? [];
+}
+function getPropsFromTypeLiteral2(typeNode) {
+  const n = typeNode;
+  if (n && n.type === "TSTypeLiteral" && Array.isArray(n.members)) return n.members;
+  return [];
+}
+function isComponentPropsContractName4(name) {
+  return name?.endsWith("Props") ?? false;
+}
+var rule12 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow ComponentType/FC/FunctionComponent in prop definitions. Prefer asChild or render prop for polymorphism.",
+      url: "https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-componenttype-props.md"
+    },
+    messages: {
+      noComponentTypeProps: "Prop '{{prop}}' uses ComponentType/FC/FunctionComponent. Prefer asChild or a render prop for polymorphism. AI agents: replace component-constructor props with composition or explicit render callbacks. See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-componenttype-props.md."
+    },
+    schema: []
+  },
+  create(context) {
+    const localTypeAliases = /* @__PURE__ */ new Map();
+    function checkProp(prop) {
+      const name = getPropKeyName2(prop);
+      if (!name) return;
+      const typeAnn = prop.typeAnnotation?.typeAnnotation;
+      if (!typeAnn) return;
+      if (!isComponentTypeProp(typeAnn, (aliasName) => localTypeAliases.get(aliasName) ?? null)) {
+        return;
+      }
+      context.report({
+        node: prop.key,
+        messageId: "noComponentTypeProps",
+        data: { prop: name }
+      });
+    }
+    function visitProps(props) {
+      for (const prop of props) {
+        if (prop.type !== "TSPropertySignature") continue;
+        checkProp(prop);
+      }
+    }
+    const pendingChecks = [];
+    return {
+      TSInterfaceDeclaration(node) {
+        const decl = node;
+        if (!isComponentPropsContractName4(decl.id?.name)) return;
+        if (decl.body?.type === "TSInterfaceBody") {
+          const props = getPropsFromInterfaceBody2(decl.body);
+          pendingChecks.push(() => visitProps(props));
+        }
+      },
+      TSTypeAliasDeclaration(node) {
+        const decl = node;
+        const typeAliasName = decl.id?.name;
+        if (typeAliasName) {
+          localTypeAliases.set(typeAliasName, decl.typeAnnotation);
+        }
+        if (!isComponentPropsContractName4(typeAliasName)) return;
+        const typeAnn = decl.typeAnnotation;
+        if (typeAnn) {
+          const props = getPropsFromTypeLiteral2(typeAnn);
+          pendingChecks.push(() => visitProps(props));
+        }
+      },
+      "Program:exit"() {
+        for (const check of pendingChecks) check();
+      }
+    };
+  }
+};
+var no_componenttype_props_default = rule12;
+
+// src/rules/no-object-props.ts
+import ts from "typescript";
+var rule13 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow object-valued JSX props (more accurate when TypeScript type information is available)",
+      url: "https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-object-props.md"
+    },
+    messages: {
+      noObjectProps: "Object value passed to prop '{{prop}}'. Avoid object props; prefer primitive props and compound composition. If object-shaped data must be shared across parts, use private context inside the compound root instead of passing object props. See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-object-props.md."
+    },
+    schema: []
+  },
+  create(context) {
+    const parserServices = context.sourceCode.parserServices ?? context.parserServices;
+    const checker = parserServices?.program?.getTypeChecker();
+    const hasTypeInformation = Boolean(checker && parserServices?.esTreeNodeToTSNodeMap);
+    function isDisallowedObjectType(type) {
+      if (!type || !checker) return false;
+      if (type.isUnionOrIntersection()) {
+        return type.types.some((entry) => isDisallowedObjectType(entry));
+      }
+      if (checker.isArrayType(type) || checker.isTupleType(type)) return false;
+      if (checker.getSignaturesOfType(type, ts.SignatureKind.Call).length > 0) return false;
+      if (checker.getSignaturesOfType(type, ts.SignatureKind.Construct).length > 0) return false;
+      const isObjectLike = (type.flags & ts.TypeFlags.Object) !== 0 || (type.flags & ts.TypeFlags.NonPrimitive) !== 0;
+      return isObjectLike;
+    }
+    function expressionHasObjectType(expression) {
+      if (!hasTypeInformation || !checker || !parserServices?.esTreeNodeToTSNodeMap) return false;
+      const tsNode = parserServices.esTreeNodeToTSNodeMap.get(expression);
+      if (!tsNode) return false;
+      return isDisallowedObjectType(checker.getTypeAtLocation(tsNode));
+    }
+    return {
+      JSXAttribute(node) {
+        const attr = node;
+        if (attr.name?.type !== "JSXIdentifier" || !attr.name.name) return;
+        if (attr.name.name === "style") return;
+        if (!attr.value || attr.value.type !== "JSXExpressionContainer") return;
+        const expression = attr.value.expression;
+        if (!expression) return;
+        const isInlineObject = expression.type === "ObjectExpression";
+        const isObjectTyped = expressionHasObjectType(expression);
+        if (!isInlineObject && !isObjectTyped) return;
+        context.report({
+          node: attr.value,
+          messageId: "noObjectProps",
+          data: { prop: attr.name.name }
+        });
+      }
+    };
+  }
+};
+var no_object_props_default = rule13;
+
+// src/rules/no-array-props.ts
+var rule14 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow array-valued JSX props (more accurate when TypeScript type information is available)",
+      url: "https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-array-props.md"
+    },
+    messages: {
+      noArrayProps: "Array value passed to prop '{{prop}}'. Avoid array props; prefer primitive props and compound composition. If array-shaped data must be shared across parts, use private context inside the compound root instead of passing array props. See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-array-props.md."
+    },
+    schema: []
+  },
+  create(context) {
+    const parserServices = context.sourceCode.parserServices ?? context.parserServices;
+    const checker = parserServices?.program?.getTypeChecker();
+    const hasTypeInformation = Boolean(checker && parserServices?.esTreeNodeToTSNodeMap);
+    function isDisallowedArrayType(type) {
+      if (!type || !checker) return false;
+      if (type.isUnionOrIntersection()) {
+        return type.types.some((entry) => isDisallowedArrayType(entry));
+      }
+      return checker.isArrayType(type) || checker.isTupleType(type);
+    }
+    function expressionHasArrayType(expression) {
+      if (!hasTypeInformation || !checker || !parserServices?.esTreeNodeToTSNodeMap) return false;
+      const tsNode = parserServices.esTreeNodeToTSNodeMap.get(expression);
+      if (!tsNode) return false;
+      return isDisallowedArrayType(checker.getTypeAtLocation(tsNode));
+    }
+    return {
+      JSXAttribute(node) {
+        const attr = node;
+        if (attr.name?.type !== "JSXIdentifier" || !attr.name.name) return;
+        if (!attr.value || attr.value.type !== "JSXExpressionContainer") return;
+        const expression = attr.value.expression;
+        if (!expression) return;
+        const isInlineArray = expression.type === "ArrayExpression";
+        const isArrayTyped = expressionHasArrayType(expression);
+        if (!isInlineArray && !isArrayTyped) return;
+        context.report({
+          node: attr.value,
+          messageId: "noArrayProps",
+          data: { prop: attr.name.name }
+        });
+      }
+    };
+  }
+};
+var no_array_props_default = rule14;
+
+// src/rules/no-prefixed-prop-bundles.ts
+var DEFAULT_THRESHOLD = 3;
+var IGNORED_PREFIXES = /* @__PURE__ */ new Set(["aria", "can", "data", "has", "is", "on", "should"]);
+function getBundlePrefix(propName) {
+  if (!propName) return null;
+  const first = propName[0];
+  if (!first || first < "a" || first > "z") return null;
+  let firstUpperIndex = -1;
+  for (let index = 1; index < propName.length; index += 1) {
+    const char = propName[index];
+    if (char >= "A" && char <= "Z") {
+      firstUpperIndex = index;
+      break;
+    }
+  }
+  if (firstUpperIndex <= 0 || firstUpperIndex >= propName.length) return null;
+  const prefix = propName.slice(0, firstUpperIndex);
+  if (!prefix || IGNORED_PREFIXES.has(prefix)) return null;
+  return prefix;
+}
+function getPropName4(node) {
+  const key = node.key;
+  if (key.type === "Identifier") return key.name;
+  if (key.type === "Literal" && typeof key.value === "string") return key.value;
+  return null;
+}
+function reportPrefixedPropBundle(context, properties, prefix) {
+  for (const property of properties) {
+    const propName = getPropName4(property);
+    if (!propName) continue;
+    context.report({
+      node: property.key,
+      messageId: "noPrefixedPropBundle",
+      data: {
+        prop: propName,
+        prefix,
+        count: String(properties.length)
+      }
+    });
+  }
+}
+function checkMembersForPrefixedBundles(context, members, threshold) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const memberNode of members) {
+    const maybeProperty = memberNode;
+    if (maybeProperty.type !== "TSPropertySignature") continue;
+    const property = memberNode;
+    const propName = getPropName4(property);
+    if (!propName) continue;
+    const prefix = getBundlePrefix(propName);
+    if (!prefix) continue;
+    const existing = groups.get(prefix);
+    if (existing) {
+      existing.push(property);
+      continue;
+    }
+    groups.set(prefix, [property]);
+  }
+  for (const [prefix, properties] of groups.entries()) {
+    if (properties.length < threshold) continue;
+    reportPrefixedPropBundle(context, properties, prefix);
+  }
+}
+function isComponentPropsContractName5(name) {
+  return name?.endsWith("Props") ?? false;
+}
+var rule15 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow bundles of similarly-prefixed prop type declarations that suggest over-grouped component APIs",
+      url: "https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-prefixed-prop-bundles.md"
+    },
+    messages: {
+      noPrefixedPropBundle: "Prop '{{prop}}' is part of a '{{prefix}}*' prop bundle ({{count}} props). Prefer unprefixed, explicit props and compound composition. If grouped data must be shared, use context. AI agents: split monolithic props into compound parts instead of introducing object bundles. See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-prefixed-prop-bundles.md."
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          threshold: {
+            type: "integer",
+            minimum: 2
+          }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  create(context) {
+    const options = context.options[0] ?? {};
+    const threshold = options.threshold ?? DEFAULT_THRESHOLD;
+    return {
+      TSInterfaceDeclaration(node) {
+        const declaration = node;
+        if (!isComponentPropsContractName5(declaration.id?.name)) return;
+        if (declaration.body?.type !== "TSInterfaceBody") return;
+        checkMembersForPrefixedBundles(context, declaration.body.body ?? [], threshold);
+      },
+      TSTypeAliasDeclaration(node) {
+        const declaration = node;
+        if (!isComponentPropsContractName5(declaration.id?.name)) return;
+        const annotation = declaration.typeAnnotation;
+        if (!annotation || annotation.type !== "TSTypeLiteral") return;
+        checkMembersForPrefixedBundles(context, annotation.members ?? [], threshold);
+      }
+    };
+  }
+};
+var no_prefixed_prop_bundles_default = rule15;
+
+// src/rules/no-optional-props-without-defaults.ts
+import ts2 from "typescript";
+function getParserServices(context) {
+  return context.sourceCode.parserServices ?? context.parserServices ?? null;
+}
+function isPascalCaseName(name) {
+  const first = name[0];
+  return Boolean(first && first >= "A" && first <= "Z");
+}
+function getPropertyName(node) {
+  if (node.type === "Identifier") return node.name;
+  if (node.type === "Literal" && typeof node.value === "string") return node.value;
+  return null;
+}
+function getTypeReferenceName(typeNode) {
+  const maybeRef = typeNode;
+  if (maybeRef.type !== "TSTypeReference" || !maybeRef.typeName) return null;
+  if (maybeRef.typeName.type === "Identifier" && maybeRef.typeName.name) {
+    return maybeRef.typeName.name;
+  }
+  if (maybeRef.typeName.type === "TSQualifiedName" && maybeRef.typeName.right?.name) {
+    return maybeRef.typeName.right.name;
+  }
+  return null;
+}
+function collectOptionalPropNamesFromMembers(members) {
+  const optionalPropNames = /* @__PURE__ */ new Set();
+  for (const member of members) {
+    const maybeProperty = member;
+    if (maybeProperty.type !== "TSPropertySignature" || !maybeProperty.optional) continue;
+    const propName = getPropertyName(maybeProperty.key);
+    if (!propName) continue;
+    optionalPropNames.add(propName);
+  }
+  return optionalPropNames;
+}
+function getOptionalPropNamesFromTypeNode(typeNode, optionalPropMap) {
+  if (!typeNode) return /* @__PURE__ */ new Set();
+  const maybeTypeLiteral = typeNode;
+  if (maybeTypeLiteral.type === "TSTypeLiteral") {
+    return collectOptionalPropNamesFromMembers(maybeTypeLiteral.members ?? []);
+  }
+  const typeRefName = getTypeReferenceName(typeNode);
+  if (typeRefName) {
+    return new Set(optionalPropMap.get(typeRefName) ?? []);
+  }
+  return /* @__PURE__ */ new Set();
+}
+function collectDefaultedParamKeys(paramNode) {
+  const defaultedKeys = /* @__PURE__ */ new Set();
+  const maybeObjectPattern = paramNode;
+  if (maybeObjectPattern.type !== "ObjectPattern") return defaultedKeys;
+  for (const propertyNode of maybeObjectPattern.properties ?? []) {
+    const maybeProperty = propertyNode;
+    if (maybeProperty.type !== "Property") continue;
+    const propName = getPropertyName(maybeProperty.key);
+    if (!propName) continue;
+    const maybeValue = maybeProperty.value;
+    if (!maybeValue || maybeValue.type !== "AssignmentPattern") continue;
+    defaultedKeys.add(propName);
+  }
+  return defaultedKeys;
+}
+function getParamTypeAnnotationNode(paramNode) {
+  const maybeAnnotatedParam = paramNode;
+  if (maybeAnnotatedParam.typeAnnotation?.typeAnnotation) {
+    return maybeAnnotatedParam.typeAnnotation.typeAnnotation;
+  }
+  const maybeAssignment = paramNode;
+  if (maybeAssignment.type !== "AssignmentPattern") return null;
+  const maybeAssignmentLeft = maybeAssignment.left;
+  return maybeAssignmentLeft.typeAnnotation?.typeAnnotation ?? null;
+}
+function getComponentOptionalPropNamesFromTypeChecker(paramNode, checker, parserServices) {
+  if (!checker || !parserServices?.esTreeNodeToTSNodeMap) return /* @__PURE__ */ new Set();
+  const tsNode = parserServices.esTreeNodeToTSNodeMap.get(paramNode);
+  if (!tsNode) return /* @__PURE__ */ new Set();
+  const paramType = checker.getTypeAtLocation(tsNode);
+  const optionalPropNames = /* @__PURE__ */ new Set();
+  for (const symbol of checker.getPropertiesOfType(paramType)) {
+    if ((symbol.flags & ts2.SymbolFlags.Optional) === 0) continue;
+    const propName = symbol.getName();
+    if (!propName || propName.startsWith("__@")) continue;
+    optionalPropNames.add(propName);
+  }
+  return optionalPropNames;
+}
+var rule16 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow optional component props unless they are defaulted at the component boundary (more accurate when TypeScript type information is available)",
+      url: "https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-optional-props-without-defaults.md"
+    },
+    messages: {
+      noOptionalPropWithoutDefault: "Component '{{component}}' prop '{{prop}}' is optional without a default at the component boundary. Default configurable props, and keep time-based readiness checks outside component prop contracts. AI agents: default this prop at the parameter boundary or move readiness checks upstream. See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-optional-props-without-defaults.md."
+    },
+    schema: []
+  },
+  create(context) {
+    const parserServices = getParserServices(context);
+    const checker = parserServices?.program?.getTypeChecker();
+    const hasTypeInformation = Boolean(checker && parserServices?.esTreeNodeToTSNodeMap);
+    const optionalPropsByTypeName = /* @__PURE__ */ new Map();
+    function storeTypeOptionalProps(typeName, members) {
+      optionalPropsByTypeName.set(typeName, collectOptionalPropNamesFromMembers(members));
+    }
+    function reportOptionalPropsWithoutDefaults(componentName, paramNode) {
+      const defaultedKeys = collectDefaultedParamKeys(paramNode);
+      const paramTypeAnnotation = getParamTypeAnnotationNode(paramNode);
+      const optionalPropNamesFromAst = getOptionalPropNamesFromTypeNode(
+        paramTypeAnnotation ?? void 0,
+        optionalPropsByTypeName
+      );
+      const optionalPropNamesFromChecker = getComponentOptionalPropNamesFromTypeChecker(
+        paramNode,
+        hasTypeInformation ? checker : void 0,
+        hasTypeInformation ? parserServices : null
+      );
+      const optionalPropNames = /* @__PURE__ */ new Set([
+        ...optionalPropNamesFromAst,
+        ...optionalPropNamesFromChecker
+      ]);
+      for (const propName of optionalPropNames) {
+        if (defaultedKeys.has(propName)) continue;
+        context.report({
+          node: paramNode,
+          messageId: "noOptionalPropWithoutDefault",
+          data: {
+            component: componentName,
+            prop: propName
+          }
+        });
+      }
+    }
+    return {
+      TSInterfaceDeclaration(node) {
+        const declaration = node;
+        const typeName = declaration.id?.name;
+        if (!typeName) return;
+        if (declaration.body?.type !== "TSInterfaceBody") return;
+        storeTypeOptionalProps(typeName, declaration.body.body ?? []);
+      },
+      TSTypeAliasDeclaration(node) {
+        const declaration = node;
+        const typeName = declaration.id?.name;
+        if (!typeName) return;
+        const typeAnnotation = declaration.typeAnnotation;
+        if (typeAnnotation?.type !== "TSTypeLiteral") return;
+        storeTypeOptionalProps(typeName, typeAnnotation.members ?? []);
+      },
+      FunctionDeclaration(node) {
+        const declaration = node;
+        const componentName = declaration.id?.name;
+        if (!componentName || !isPascalCaseName(componentName)) return;
+        const firstParam = declaration.params?.[0];
+        if (!firstParam) return;
+        reportOptionalPropsWithoutDefaults(componentName, firstParam);
+      },
+      VariableDeclarator(node) {
+        const declaration = node;
+        const componentName = declaration.id?.name;
+        if (!componentName || !isPascalCaseName(componentName)) return;
+        const init = declaration.init;
+        if (!init) return;
+        if (init.type !== "ArrowFunctionExpression" && init.type !== "FunctionExpression") return;
+        const firstParam = init.params?.[0];
+        if (!firstParam) return;
+        reportOptionalPropsWithoutDefaults(componentName, firstParam);
+      }
+    };
+  }
+};
+var no_optional_props_without_defaults_default = rule16;
+
+// src/rules/no-boolean-capability-props.ts
+function getPropName5(node) {
+  if (node.type === "Identifier") return node.name;
+  if (node.type === "Literal" && typeof node.value === "string") return node.value;
+  return null;
+}
+function isBooleanLikeType(typeNode) {
+  if (!typeNode) return false;
+  const maybeType = typeNode;
+  if (maybeType.type === "TSBooleanKeyword") return true;
+  if (maybeType.type === "TSLiteralType") {
+    const literalValue = maybeType.literal?.value;
+    return literalValue === true || literalValue === false;
+  }
+  if (maybeType.type === "TSParenthesizedType" || maybeType.type === "TSOptionalType") {
+    return isBooleanLikeType(maybeType.typeAnnotation);
+  }
+  if (maybeType.type === "TSUnionType" || maybeType.type === "TSIntersectionType") {
+    return (maybeType.types ?? []).some((member) => isBooleanLikeType(member));
+  }
+  return false;
+}
+function isHandlerPropName(name) {
+  if (!name.startsWith("on") || name.length <= 2) return false;
+  const firstCharAfterPrefix = name[2];
+  return firstCharAfterPrefix >= "A" && firstCharAfterPrefix <= "Z";
+}
+function isFunctionLikeType(typeNode) {
+  if (!typeNode) return false;
+  const maybeType = typeNode;
+  if (maybeType.type === "TSFunctionType") return true;
+  if (maybeType.type === "TSParenthesizedType" || maybeType.type === "TSOptionalType") {
+    return isFunctionLikeType(maybeType.typeAnnotation);
+  }
+  if (maybeType.type === "TSUnionType" || maybeType.type === "TSIntersectionType") {
+    return (maybeType.types ?? []).some((member) => isFunctionLikeType(member));
+  }
+  return false;
+}
+function capitalize(value) {
+  if (!value) return value;
+  return value[0].toUpperCase() + value.slice(1);
+}
+function isComponentPropsContractName6(name) {
+  return name?.endsWith("Props") ?? false;
+}
+var rule17 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow boolean component props without associated control handlers in prop contracts",
+      url: "https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-boolean-capability-props.md"
+    },
+    messages: {
+      noBooleanCapabilityProp: "Boolean prop '{{prop}}' has no associated control handler starting with '{{handlerPrefix}}'. Each boolean doubles possible states and adds hidden variants. Prefer explicit handlers or compound composition. AI agents: add a matching `on{Prop}` handler or split this into composed variants. See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-boolean-capability-props.md."
+    },
+    schema: []
+  },
+  create(context) {
+    function checkMembers(members) {
+      const booleanProps = [];
+      const handlerProps = /* @__PURE__ */ new Set();
+      for (const memberNode of members) {
+        const maybeProperty = memberNode;
+        if (maybeProperty.type !== "TSPropertySignature") continue;
+        const propName = getPropName5(maybeProperty.key);
+        if (!propName) continue;
+        const typeNode = maybeProperty.typeAnnotation?.typeAnnotation;
+        if (isFunctionLikeType(typeNode) && isHandlerPropName(propName)) {
+          handlerProps.add(propName);
+          continue;
+        }
+        if (!isBooleanLikeType(typeNode)) continue;
+        booleanProps.push({ name: propName, node: maybeProperty });
+      }
+      for (const booleanProp of booleanProps) {
+        const handlerPrefix = `on${capitalize(booleanProp.name)}`;
+        const hasAssociatedHandler = [...handlerProps].some(
+          (handlerName) => handlerName.startsWith(handlerPrefix)
+        );
+        if (hasAssociatedHandler) continue;
+        context.report({
+          node: booleanProp.node.key,
+          messageId: "noBooleanCapabilityProp",
+          data: { prop: booleanProp.name, handlerPrefix }
+        });
+      }
+    }
+    return {
+      TSInterfaceDeclaration(node) {
+        const declaration = node;
+        if (!isComponentPropsContractName6(declaration.id?.name)) return;
+        if (declaration.body?.type !== "TSInterfaceBody") return;
+        checkMembers(declaration.body.body ?? []);
+      },
+      TSTypeAliasDeclaration(node) {
+        const declaration = node;
+        if (!isComponentPropsContractName6(declaration.id?.name)) return;
+        const typeAnnotation = declaration.typeAnnotation;
+        if (!typeAnnotation || typeAnnotation.type !== "TSTypeLiteral") return;
+        checkMembers(typeAnnotation.members ?? []);
+      }
+    };
+  }
+};
+var no_boolean_capability_props_default = rule17;
+
+// src/rules/max-custom-props.ts
+var DEFAULT_THRESHOLD2 = 8;
+var DEFAULT_IGNORED_PROPS = /* @__PURE__ */ new Set(["children"]);
+function isComponentPropsContractName7(name) {
+  return name.endsWith("Props");
+}
+function getCustomPropCount(members, ignoredProps) {
+  let count = 0;
+  for (const member of members) {
+    const maybeMember = member;
+    if (maybeMember.type !== "TSPropertySignature" && maybeMember.type !== "TSMethodSignature") {
+      continue;
+    }
+    const key = maybeMember.key;
+    if (!key) continue;
+    let propName = null;
+    if (key.type === "Identifier" && key.name) propName = key.name;
+    if (key.type === "Literal" && typeof key.value === "string") propName = key.value;
+    if (!propName) continue;
+    if (ignoredProps.has(propName)) continue;
+    count += 1;
+  }
+  return count;
+}
+var rule18 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Limit the number of custom props in component prop contracts to encourage composition",
+      url: "https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/max-custom-props.md"
+    },
+    messages: {
+      maxCustomProps: "Component prop contract '{{name}}' declares {{count}} custom props (max {{threshold}}). This is a composition pressure signal; prefer splitting APIs into compound parts. AI agents: extract parts before adding more top-level props. See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/max-custom-props.md."
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          threshold: {
+            type: "integer",
+            minimum: 1
+          },
+          ignore: {
+            type: "array",
+            items: {
+              type: "string"
+            }
+          }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  create(context) {
+    const options = context.options[0] ?? {};
+    const threshold = options.threshold ?? DEFAULT_THRESHOLD2;
+    const ignoredProps = /* @__PURE__ */ new Set([...DEFAULT_IGNORED_PROPS, ...options.ignore ?? []]);
+    function checkContract(contractName, members, node) {
+      if (!contractName || !isComponentPropsContractName7(contractName)) return;
+      const customPropCount = getCustomPropCount(members ?? [], ignoredProps);
+      if (customPropCount <= threshold) return;
+      context.report({
+        node,
+        messageId: "maxCustomProps",
+        data: {
+          name: contractName,
+          count: String(customPropCount),
+          threshold: String(threshold)
+        }
+      });
+    }
+    return {
+      TSInterfaceDeclaration(node) {
+        const declaration = node;
+        if (declaration.body?.type !== "TSInterfaceBody") return;
+        checkContract(declaration.id?.name, declaration.body.body, node);
+      },
+      TSTypeAliasDeclaration(node) {
+        const declaration = node;
+        if (declaration.typeAnnotation?.type !== "TSTypeLiteral") return;
+        checkContract(declaration.id?.name, declaration.typeAnnotation.members, node);
+      }
+    };
+  }
+};
+var max_custom_props_default = rule18;
+
+// src/rules/jsx-bem-compound-naming.ts
+import path from "path";
+function isPascalCase2(name) {
+  if (name.length === 0) return false;
+  const first = name[0];
+  return first >= "A" && first <= "Z";
+}
+function isFunctionLikeComponentInit(node) {
+  if (!node) return false;
+  const typed = node;
+  return typed.type === "ArrowFunctionExpression" || typed.type === "FunctionExpression";
+}
+function normalizeForComparison(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function buildExampleName(block, localName) {
+  if (localName.startsWith(block)) return localName;
+  let overlapLength = 0;
+  for (let index = 1; index < block.length; index += 1) {
+    const suffix = block.slice(index);
+    if (localName.startsWith(suffix)) {
+      overlapLength = suffix.length;
+      break;
+    }
+  }
+  if (overlapLength === 0) return `${block}${localName}`;
+  return `${block}${localName.slice(overlapLength)}`;
+}
+function getFileStem(filename) {
+  if (!filename || filename === "<input>") return null;
+  const base = path.basename(filename);
+  const ext = path.extname(base);
+  if (!ext) return base;
+  return base.slice(0, -ext.length);
+}
+function getExportedIdentifierName(node) {
+  if (!node) return null;
+  const typedNode = node;
+  if (typedNode.type === "Identifier" && typedNode.name) return typedNode.name;
+  if (typedNode.type === "Literal" && typeof typedNode.value === "string") return typedNode.value;
+  return null;
+}
+var rule19 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce compound component export naming by matching exported component names to the file stem block prefix",
+      url: "https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/jsx-bem-compound-naming.md"
+    },
+    messages: {
+      exportedPartMustUseBlockPrefix: "Exported component '{{name}}' should be prefixed with compound block '{{block}}' in this file (for example '{{example}}'). See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/jsx-bem-compound-naming.md."
+    },
+    schema: []
+  },
+  create(context) {
+    const localComponents = /* @__PURE__ */ new Map();
+    const exportedComponents = [];
+    function registerLocalComponent(name, node) {
+      if (!isPascalCase2(name)) return;
+      localComponents.set(name, node);
+    }
+    function recordExport(localName, exportedName, node) {
+      if (!localComponents.has(localName)) return;
+      if (!isPascalCase2(exportedName)) return;
+      exportedComponents.push({ localName, exportedName, node });
+    }
+    return {
+      FunctionDeclaration(node) {
+        const fn = node;
+        const idName = getExportedIdentifierName(fn.id);
+        if (!idName) return;
+        registerLocalComponent(idName, fn.id);
+      },
+      VariableDeclarator(node) {
+        const declaration = node;
+        if (!isFunctionLikeComponentInit(declaration.init)) return;
+        const idName = getExportedIdentifierName(declaration.id);
+        if (!idName || !declaration.id) return;
+        registerLocalComponent(idName, declaration.id);
+      },
+      ExportNamedDeclaration(node) {
+        const declaration = node;
+        if (declaration.source) return;
+        if (declaration.declaration?.type === "FunctionDeclaration") {
+          const fn = declaration.declaration;
+          const idName = getExportedIdentifierName(fn.id);
+          if (!idName || !fn.id) return;
+          registerLocalComponent(idName, fn.id);
+          recordExport(idName, idName, fn.id);
+          return;
+        }
+        if (declaration.declaration?.type === "VariableDeclaration") {
+          const variableDeclaration = declaration.declaration;
+          for (const entry of variableDeclaration.declarations ?? []) {
+            if (!isFunctionLikeComponentInit(entry.init)) continue;
+            const idName = getExportedIdentifierName(entry.id);
+            if (!idName || !entry.id) continue;
+            registerLocalComponent(idName, entry.id);
+            recordExport(idName, idName, entry.id);
+          }
+          return;
+        }
+        for (const specifier of declaration.specifiers ?? []) {
+          if (specifier.type !== "ExportSpecifier") continue;
+          const exportSpecifier = specifier;
+          const localName = getExportedIdentifierName(exportSpecifier.local);
+          const exportedName = getExportedIdentifierName(exportSpecifier.exported);
+          if (!localName || !exportedName) continue;
+          if (!exportSpecifier.exported) continue;
+          recordExport(localName, exportedName, exportSpecifier.exported);
+        }
+      },
+      ExportDefaultDeclaration(node) {
+        const declaration = node;
+        const declared = declaration.declaration;
+        if (!declared) return;
+        if (declared.type === "FunctionDeclaration") {
+          const fn = declared;
+          const idName = getExportedIdentifierName(fn.id);
+          if (!idName || !fn.id) return;
+          registerLocalComponent(idName, fn.id);
+          recordExport(idName, idName, fn.id);
+          return;
+        }
+        if (declared.type === "Identifier") {
+          const idName = getExportedIdentifierName(declared);
+          if (!idName) return;
+          recordExport(idName, idName, declared);
+        }
+      },
+      "Program:exit"() {
+        if (exportedComponents.length < 2) return;
+        const stem = getFileStem(context.filename);
+        if (!stem) return;
+        if (stem.toLowerCase() === "index") return;
+        const normalizedStem = normalizeForComparison(stem);
+        const blockCandidates = exportedComponents.map((entry) => entry.localName).filter((name) => normalizeForComparison(name) === normalizedStem);
+        if (blockCandidates.length === 0) return;
+        for (const exported of exportedComponents) {
+          const isBlockExport = blockCandidates.includes(exported.localName);
+          if (isBlockExport) continue;
+          const usesAnyBlockPrefix = blockCandidates.some(
+            (block) => exported.localName.startsWith(block)
+          );
+          if (usesAnyBlockPrefix) continue;
+          const preferredBlock = blockCandidates[0] ?? "Block";
+          context.report({
+            node: exported.node,
+            messageId: "exportedPartMustUseBlockPrefix",
+            data: {
+              name: exported.localName,
+              block: preferredBlock,
+              example: buildExampleName(preferredBlock, exported.localName)
+            }
+          });
+        }
+      }
+    };
+  }
+};
+var jsx_bem_compound_naming_default = rule19;
+
+// src/rules/jsx-compound-part-export-naming.ts
+import path2 from "path";
+function isPascalCase3(name) {
+  if (name.length === 0) return false;
+  const first = name[0];
+  return first >= "A" && first <= "Z";
+}
+function normalizeForComparison2(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function getFileStem2(filename) {
+  if (!filename || filename === "<input>") return null;
+  const base = path2.basename(filename);
+  const ext = path2.extname(base);
+  if (!ext) return base;
+  return base.slice(0, -ext.length);
+}
+function isFunctionLikeComponentInit2(node) {
+  if (!node) return false;
+  const typed = node;
+  return typed.type === "ArrowFunctionExpression" || typed.type === "FunctionExpression";
+}
+function getIdentifierLikeName(node) {
+  if (!node) return null;
+  const typedNode = node;
+  if (typedNode.type === "Identifier" && typedNode.name) return typedNode.name;
+  if (typedNode.type === "Literal" && typeof typedNode.value === "string") return typedNode.value;
+  return null;
+}
+var rule20 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce compound export aliasing from file-stem block and disallow runtime object export APIs",
+      url: "https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/jsx-compound-part-export-naming.md"
+    },
+    messages: {
+      requirePartAlias: "Export part '{{local}}' as '{{part}}' for block '{{block}}' (export { {{local}} as {{part}} }). See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/jsx-compound-part-export-naming.md.",
+      requireRootExport: "Compound block '{{block}}' exports parts. Also export its root namespace as `export { {{block}} as Root }`. See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/jsx-compound-part-export-naming.md.",
+      requireRootAlias: "Export block '{{block}}' as 'Root' (export { {{block}} as Root }). See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/jsx-compound-part-export-naming.md.",
+      noRuntimeObjectExport: "Avoid exporting runtime object '{{name}}' for compound APIs. Export root/parts with aliases instead. See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/jsx-compound-part-export-naming.md."
+    },
+    schema: []
+  },
+  create(context) {
+    const localComponents = /* @__PURE__ */ new Set();
+    const exports = [];
+    const objectExports = [];
+    function registerLocalComponent(name) {
+      if (!isPascalCase3(name)) return;
+      localComponents.add(name);
+    }
+    function recordExport(localName, exportedName, node) {
+      exports.push({ localName, exportedName, node });
+    }
+    return {
+      FunctionDeclaration(node) {
+        const fn = node;
+        const idName = getIdentifierLikeName(fn.id);
+        if (!idName) return;
+        registerLocalComponent(idName);
+      },
+      VariableDeclarator(node) {
+        const declaration = node;
+        if (!isFunctionLikeComponentInit2(declaration.init)) return;
+        const idName = getIdentifierLikeName(declaration.id);
+        if (!idName) return;
+        registerLocalComponent(idName);
+      },
+      ExportNamedDeclaration(node) {
+        const declaration = node;
+        if (declaration.source) return;
+        if (declaration.declaration?.type === "FunctionDeclaration") {
+          const fn = declaration.declaration;
+          const idName = getIdentifierLikeName(fn.id);
+          if (!idName || !fn.id) return;
+          registerLocalComponent(idName);
+          recordExport(idName, idName, fn.id);
+          return;
+        }
+        if (declaration.declaration?.type === "VariableDeclaration") {
+          const variableDeclaration = declaration.declaration;
+          for (const entry of variableDeclaration.declarations ?? []) {
+            const idName = getIdentifierLikeName(entry.id);
+            if (!idName || !entry.id) continue;
+            if (entry.init?.type === "ObjectExpression" && isPascalCase3(idName)) {
+              objectExports.push({ name: idName, node: entry.id });
+              continue;
+            }
+            if (!isFunctionLikeComponentInit2(entry.init)) continue;
+            registerLocalComponent(idName);
+            recordExport(idName, idName, entry.id);
+          }
+          return;
+        }
+        for (const specifier of declaration.specifiers ?? []) {
+          if (specifier.type !== "ExportSpecifier") continue;
+          const exportSpecifier = specifier;
+          const localName = getIdentifierLikeName(exportSpecifier.local);
+          const exportedName = getIdentifierLikeName(exportSpecifier.exported);
+          if (!localName || !exportedName || !exportSpecifier.exported) continue;
+          recordExport(localName, exportedName, exportSpecifier.exported);
+        }
+      },
+      ExportDefaultDeclaration(node) {
+        const declaration = node;
+        const declared = declaration.declaration;
+        if (!declared) return;
+        if (declared.type === "FunctionDeclaration") {
+          const fn = declared;
+          const idName = getIdentifierLikeName(fn.id);
+          if (!idName || !fn.id) return;
+          registerLocalComponent(idName);
+          recordExport(idName, idName, fn.id);
+          return;
+        }
+        if (declared.type === "Identifier") {
+          const idName = getIdentifierLikeName(declared);
+          if (!idName) return;
+          recordExport(idName, idName, declared);
+        }
+      },
+      "Program:exit"() {
+        const stem = getFileStem2(context.filename);
+        if (!stem) return;
+        if (stem.toLowerCase() === "index") return;
+        const componentExports = exports.filter(
+          (entry) => localComponents.has(entry.localName) && isPascalCase3(entry.localName)
+        );
+        if (componentExports.length < 2) return;
+        const normalizedStem = normalizeForComparison2(stem);
+        const blockCandidates = [
+          .../* @__PURE__ */ new Set([...localComponents, ...objectExports.map((e) => e.name)])
+        ].filter((name) => normalizeForComparison2(name) === normalizedStem);
+        if (blockCandidates.length === 0) return;
+        const block = blockCandidates[0];
+        if (!block) return;
+        const blockExports = componentExports.filter((entry) => entry.localName === block);
+        const partExports = componentExports.filter(
+          (entry) => entry.localName !== block && entry.localName.startsWith(block)
+        );
+        for (const partExport of partExports) {
+          const expectedPartAlias = partExport.localName.slice(block.length);
+          if (expectedPartAlias.length === 0) continue;
+          if (partExport.exportedName === expectedPartAlias) continue;
+          context.report({
+            node: partExport.node,
+            messageId: "requirePartAlias",
+            data: {
+              local: partExport.localName,
+              part: expectedPartAlias,
+              block
+            }
+          });
+        }
+        if (partExports.length > 0) {
+          if (blockExports.length === 0) {
+            const firstPartExport = partExports[0];
+            if (!firstPartExport) return;
+            context.report({
+              node: firstPartExport.node,
+              messageId: "requireRootExport",
+              data: { block }
+            });
+          } else {
+            const hasRootAlias = blockExports.some((entry) => entry.exportedName === "Root");
+            if (!hasRootAlias) {
+              const firstBlockExport = blockExports[0];
+              if (!firstBlockExport) return;
+              context.report({
+                node: firstBlockExport.node,
+                messageId: "requireRootAlias",
+                data: { block }
+              });
+            }
+          }
+        }
+        if (partExports.length === 0) return;
+        for (const objectExport of objectExports) {
+          if (objectExport.name !== block) continue;
+          context.report({
+            node: objectExport.node,
+            messageId: "noRuntimeObjectExport",
+            data: { name: objectExport.name }
+          });
+        }
+      }
+    };
+  }
+};
+var jsx_compound_part_export_naming_default = rule20;
+
+// src/rules/no-pass-through-props.ts
+function isPascalCase4(name) {
+  if (name.length === 0) return false;
+  const first = name[0];
+  return first >= "A" && first <= "Z";
+}
+function walkAst(node, parent, seen, visitor) {
+  if (!node || typeof node !== "object") return;
+  if (seen.has(node)) return;
+  seen.add(node);
+  visitor(node, parent);
+  const record = node;
+  for (const [key, value] of Object.entries(record)) {
+    if (key === "parent") continue;
+    if (!value) continue;
+    if (Array.isArray(value)) {
+      for (const entry of value) {
+        if (entry && typeof entry === "object" && "type" in entry) {
+          walkAst(entry, node, seen, visitor);
+        }
+      }
+      continue;
+    }
+    if (typeof value === "object" && "type" in value) {
+      walkAst(value, node, seen, visitor);
+    }
+  }
+}
+function getIdentifierFromPattern(pattern) {
+  if (!pattern) return null;
+  if (pattern.type === "Identifier") return pattern;
+  if (pattern.type === "AssignmentPattern") {
+    const assignmentPattern = pattern;
+    if (assignmentPattern.left?.type === "Identifier") return assignmentPattern.left;
+  }
+  return null;
+}
+function getStaticPropKey(property) {
+  if (property.type !== "Property") return null;
+  const prop = property;
+  if (!prop.key || prop.computed) return null;
+  if (prop.key.type === "Identifier") {
+    return prop.key.name;
+  }
+  if (prop.key.type === "Literal") {
+    const literal = prop.key;
+    return typeof literal.value === "string" ? literal.value : null;
+  }
+  return null;
+}
+function getPropBindings(param) {
+  if (!param || param.type !== "ObjectPattern") return [];
+  const objectPattern = param;
+  const bindings = [];
+  for (const property of objectPattern.properties ?? []) {
+    if (property.type !== "Property") continue;
+    const prop = property;
+    if (!prop.value) continue;
+    const identifier = getIdentifierFromPattern(prop.value);
+    if (!identifier) continue;
+    const localName = identifier.name;
+    const propName = getStaticPropKey(property) ?? localName;
+    bindings.push({
+      propName,
+      localName,
+      node: identifier
+    });
+  }
+  return bindings;
+}
+function isDefinitionLikeIdentifier(node, parent, name) {
+  if (!parent) return false;
+  if (parent.type === "Property") {
+    const property = parent;
+    if (property.key === node && !property.computed) return true;
+    if (property.value === node && property.value?.type === "Identifier") {
+      const value = property.value;
+      if (value.name === name && property.key === node) return true;
+    }
+  }
+  if (parent.type === "VariableDeclarator") {
+    const declarator = parent;
+    if (declarator.id === node) return true;
+  }
+  if (parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression") {
+    const fn = parent;
+    if (fn.id === node) return true;
+    if ((fn.params ?? []).includes(node)) return true;
+  }
+  if (parent.type === "ArrowFunctionExpression") {
+    const arrow = parent;
+    if ((arrow.params ?? []).includes(node)) return true;
+  }
+  return false;
+}
+function isDirectJsxAttributeForward(node, parent, parentMap) {
+  if (!parent) return false;
+  const typedParent = parent;
+  if (typedParent.type !== "JSXExpressionContainer") return false;
+  const container = parent;
+  if (container.expression !== node) return false;
+  const ref = parentMap.get(parent);
+  if (!ref?.parent) return false;
+  const typedGrandParent = ref.parent;
+  return typedGrandParent.type === "JSXAttribute";
+}
+function getForwardedTargetProp(node, parent, parentMap) {
+  if (!isDirectJsxAttributeForward(node, parent, parentMap)) return null;
+  const ref = parent ? parentMap.get(parent) : null;
+  const grandParent = ref?.parent;
+  if (!grandParent || grandParent.type !== "JSXAttribute") return null;
+  if (grandParent.name?.type !== "JSXIdentifier") return null;
+  return grandParent.name.name ?? null;
+}
+function checkComponent(context, functionNode, name, params, body) {
+  if (!name || !isPascalCase4(name)) return;
+  const firstParam = (params ?? [])[0];
+  const bindings = getPropBindings(firstParam);
+  if (bindings.length === 0) return;
+  const bindingMap = /* @__PURE__ */ new Map();
+  for (const binding of bindings) {
+    if (binding.propName === "children") continue;
+    bindingMap.set(binding.localName, binding);
+  }
+  if (bindingMap.size === 0) return;
+  const usageMap = /* @__PURE__ */ new Map();
+  for (const localName of bindingMap.keys()) {
+    usageMap.set(localName, { seen: false, owned: false, forwardedTo: /* @__PURE__ */ new Set() });
+  }
+  const parentMap = /* @__PURE__ */ new WeakMap();
+  const seenForParents = /* @__PURE__ */ new WeakSet();
+  walkAst(body, functionNode, seenForParents, (node, parent) => {
+    parentMap.set(node, { parent });
+  });
+  const seenForUsage = /* @__PURE__ */ new WeakSet();
+  walkAst(body, functionNode, seenForUsage, (node, parent) => {
+    if (node.type !== "Identifier") return;
+    const identifier = node;
+    const usage = usageMap.get(identifier.name);
+    if (!usage) return;
+    if (isDefinitionLikeIdentifier(node, parent, identifier.name)) return;
+    usage.seen = true;
+    const forwardedTarget = getForwardedTargetProp(node, parent, parentMap);
+    if (!forwardedTarget) {
+      usage.owned = true;
+      return;
+    }
+    usage.forwardedTo.add(forwardedTarget);
+  });
+  for (const [localName, usage] of usageMap.entries()) {
+    if (!usage.seen || usage.owned) continue;
+    const binding = bindingMap.get(localName);
+    if (!binding) continue;
+    context.report({
+      node: binding.node,
+      messageId: "noPassThroughProp",
+      data: {
+        prop: binding.propName,
+        component: name,
+        forwardedTo: usage.forwardedTo.size > 0 ? Array.from(usage.forwardedTo).sort().join(", ") : "child prop"
+      }
+    });
+  }
+}
+var rule21 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow pass-through-only props in component owners (accepting props only to forward them)",
+      url: "https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-pass-through-props.md"
+    },
+    messages: {
+      noPassThroughProp: "Prop '{{prop}}' in '{{component}}' is only forwarded to '{{forwardedTo}}'. Remove the pass-through prop, derive a local value, or expose composition via children at the ownership boundary. See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/no-pass-through-props.md."
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      FunctionDeclaration(node) {
+        const fn = node;
+        checkComponent(context, node, fn.id?.name, fn.params, fn.body);
+      },
+      VariableDeclarator(node) {
+        const declaration = node;
+        if (declaration.id?.type !== "Identifier") return;
+        const id = declaration.id;
+        const init = declaration.init;
+        if (!init) return;
+        if (init.type !== "ArrowFunctionExpression" && init.type !== "FunctionExpression") return;
+        const component = init;
+        checkComponent(context, init, id.name, component.params, component.body);
+      }
+    };
+  }
+};
+var no_pass_through_props_default = rule21;
+
+// src/rules/jsx-flat-owner-tree.ts
+var DEFAULT_ALLOWED_CHAIN_DEPTH = 2;
+function isPascalCase5(name) {
+  if (name.length === 0) return false;
+  const first = name[0];
+  return first >= "A" && first <= "Z";
+}
+function getCustomJsxName(node) {
+  if (!node) return null;
+  const typedNode = node;
+  if (typedNode.type === "JSXIdentifier" && typedNode.name) {
+    const name = typedNode.name;
+    return isPascalCase5(name) ? name : null;
+  }
+  if (typedNode.type === "JSXMemberExpression" && typedNode.object) {
+    const member = typedNode;
+    const typedObject = member.object;
+    if (typedObject.type === "JSXIdentifier" && typedObject.name) {
+      const object = typedObject;
+      return isPascalCase5(object.name) ? object.name : null;
+    }
+  }
+  return null;
+}
+function collectSelfClosingCustomJsxNames(node, names) {
+  if (!node) return;
+  const typedNode = node;
+  if (typedNode.type === "JSXElement") {
+    const element = node;
+    if (element.openingElement.selfClosing) {
+      const customName = getCustomJsxName(element.openingElement.name);
+      if (customName) names.add(customName);
+    }
+    for (const child of element.children ?? []) {
+      const typedChild = child;
+      if (typedChild.type !== "JSXElement" && typedChild.type !== "JSXFragment") continue;
+      collectSelfClosingCustomJsxNames(child, names);
+    }
+    return;
+  }
+  if (typedNode.type === "JSXFragment") {
+    const fragment = node;
+    for (const child of fragment.children ?? []) {
+      const typedChild = child;
+      if (typedChild.type !== "JSXElement" && typedChild.type !== "JSXFragment") continue;
+      collectSelfClosingCustomJsxNames(child, names);
+    }
+  }
+}
+function getSelfClosingCustomChildren(body) {
+  const names = /* @__PURE__ */ new Set();
+  if (!body) return names;
+  const typedBody = body;
+  if (typedBody.type === "JSXElement" || typedBody.type === "JSXFragment") {
+    collectSelfClosingCustomJsxNames(body, names);
+  } else if (typedBody.type === "BlockStatement") {
+    const block = body;
+    for (const statement of block.body ?? []) {
+      if (statement.type !== "ReturnStatement") continue;
+      const returnStatement = statement;
+      const argument = returnStatement.argument;
+      if (!argument) continue;
+      const typedArgument = argument;
+      if (typedArgument.type !== "JSXElement" && typedArgument.type !== "JSXFragment") continue;
+      collectSelfClosingCustomJsxNames(argument, names);
+    }
+  }
+  return names;
+}
+function computeLongestChain(componentName, components, memo, visiting) {
+  const cached = memo.get(componentName);
+  if (cached != null) return cached;
+  if (visiting.has(componentName)) {
+    return [componentName];
+  }
+  visiting.add(componentName);
+  const component = components.get(componentName);
+  if (!component) {
+    memo.set(componentName, [componentName]);
+    visiting.delete(componentName);
+    return [componentName];
+  }
+  if (component.selfClosingCustomChildren.size === 0) {
+    const base = [componentName];
+    memo.set(componentName, base);
+    visiting.delete(componentName);
+    return base;
+  }
+  let bestChildChain = [];
+  for (const childName of component.selfClosingCustomChildren) {
+    if (!components.has(childName)) continue;
+    const childChain = computeLongestChain(childName, components, memo, visiting);
+    if (childChain.length > bestChildChain.length) bestChildChain = childChain;
+  }
+  const fullChain = [componentName, ...bestChildChain];
+  memo.set(componentName, fullChain);
+  visiting.delete(componentName);
+  return fullChain;
+}
+var rule22 = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Encourage flatter parent component chains by reporting self-closing custom component handoffs deeper than allowedChainDepth",
+      url: "https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/jsx-flat-owner-tree.md"
+    },
+    messages: {
+      deepParentTree: "Component '{{component}}' is in a {{depth}}-deep self-closing handoff chain (allowed: {{allowedDepth}}): {{chain}}. Start flattening at '{{nextHandoff}}' by inlining/compounding intermediate relays. See: https://github.com/jjenzz/sweepit/tree/main/packages/eslint-plugin-sweepit/docs/rules/jsx-flat-owner-tree.md."
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowedChainDepth: {
+            type: "integer",
+            minimum: 1
+          }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  create(context) {
+    const rawOptions = context.options[0] ?? {};
+    const allowedChainDepthRaw = rawOptions.allowedChainDepth;
+    const allowedChainDepth = Number.isInteger(allowedChainDepthRaw) && (allowedChainDepthRaw ?? 0) >= 1 ? allowedChainDepthRaw : DEFAULT_ALLOWED_CHAIN_DEPTH;
+    const minReportedChainDepth = allowedChainDepth + 1;
+    const components = /* @__PURE__ */ new Map();
+    function registerComponent(name, body, node) {
+      if (!name || !isPascalCase5(name)) return;
+      components.set(name, {
+        name,
+        node,
+        selfClosingCustomChildren: getSelfClosingCustomChildren(body)
+      });
+    }
+    return {
+      FunctionDeclaration(node) {
+        const fn = node;
+        registerComponent(fn.id?.name, fn.body, node);
+      },
+      VariableDeclarator(node) {
+        const declaration = node;
+        if (declaration.id?.type !== "Identifier") return;
+        if (!declaration.init) return;
+        if (declaration.init.type !== "ArrowFunctionExpression" && declaration.init.type !== "FunctionExpression") {
+          return;
+        }
+        const id = declaration.id;
+        const init = declaration.init;
+        registerComponent(id.name, init.body, declaration.id);
+      },
+      "Program:exit"() {
+        const memo = /* @__PURE__ */ new Map();
+        for (const component of components.values()) {
+          const chain = computeLongestChain(component.name, components, memo, /* @__PURE__ */ new Set());
+          const depth = chain.length;
+          if (depth < minReportedChainDepth) continue;
+          context.report({
+            node: component.node,
+            messageId: "deepParentTree",
+            data: {
+              component: component.name,
+              depth: String(depth),
+              allowedDepth: String(allowedChainDepth),
+              chain: chain.join(" -> "),
+              nextHandoff: chain[1] ?? component.name
+            }
+          });
+        }
+      }
+    };
+  }
+};
+var jsx_flat_owner_tree_default = rule22;
+
+// src/index.ts
+var plugin = {
+  meta: {
+    name: "eslint-plugin-sweepit",
+    version: "0.0.0"
+  },
+  rules: {
+    "no-title-case-props": no_title_case_props_default,
+    "no-custom-kebab-case-props": no_custom_kebab_case_props_default,
+    "no-set-prefix-utils": no_set_prefix_utils_default,
+    "no-useless-hook": no_useless_hook_default,
+    "no-hook-jsx": no_hook_jsx_default,
+    "no-exported-context-hooks": no_exported_context_hooks_default,
+    "no-handler-return-type": no_handler_return_type_default,
+    "jsx-server-action-prop-suffix": jsx_server_action_prop_suffix_default,
+    "jsx-on-handler-verb-suffix": jsx_on_handler_verb_suffix_default,
+    "no-render-helper-functions": no_render_helper_functions_default,
+    "no-element-props": no_element_props_default,
+    "no-componenttype-props": no_componenttype_props_default,
+    "no-object-props": no_object_props_default,
+    "no-array-props": no_array_props_default,
+    "no-prefixed-prop-bundles": no_prefixed_prop_bundles_default,
+    "no-optional-props-without-defaults": no_optional_props_without_defaults_default,
+    "no-boolean-capability-props": no_boolean_capability_props_default,
+    "max-custom-props": max_custom_props_default,
+    "jsx-bem-compound-naming": jsx_bem_compound_naming_default,
+    "jsx-compound-part-export-naming": jsx_compound_part_export_naming_default,
+    "no-pass-through-props": no_pass_through_props_default,
+    "jsx-flat-owner-tree": jsx_flat_owner_tree_default
+  },
+  configs: {}
+};
+plugin.configs = {
+  react: createReactConfig(plugin)
+};
+var index_default = plugin;
+export {
+  index_default as default,
+  plugin
+};