pasika 0.3.4 → 0.3.5

package/dist/eslint/pasika/index.js

@@ -586,8 +586,8 @@ var enforceCvaVariantPropsRule = {
         if (node.typeAnnotation?.type !== "TSTypeLiteral") return;
         for (const member of node.typeAnnotation.members ?? []) {
           if (member.type !== "TSPropertySignature") continue;
-          const keyName = member.key?.type === "Identifier" ? member.key.name : void 0;
-          if (!keyName) continue;
+          const keyName2 = member.key?.type === "Identifier" ? member.key.name : void 0;
+          if (!keyName2) continue;
           const typeAnn = member.typeAnnotation?.typeAnnotation;
           if (typeAnn?.type !== "TSUnionType") continue;
           const allStringLiterals = (typeAnn.types ?? []).every(
@@ -595,10 +595,10 @@ var enforceCvaVariantPropsRule = {
           );
           if (allStringLiterals && (typeAnn.types?.length ?? 0) >= 2) {
             for (const variantNames of cvaDefinitions.values()) {
-              if (variantNames.includes(keyName)) {
+              if (variantNames.includes(keyName2)) {
                 context.report({
                   node,
-                  message: `Variant prop "${keyName}" duplicates CVA variant values. Use VariantProps<typeof variants> instead of manually writing union types. See docs/styling-guide/rules/component-variant-rule.md`
+                  message: `Variant prop "${keyName2}" duplicates CVA variant values. Use VariantProps<typeof variants> instead of manually writing union types. See docs/styling-guide/rules/component-variant-rule.md`
                 });
                 return;
               }
@@ -1334,21 +1334,27 @@ var dataTestIdCaseRule = {
       Program(node) {
         for (const component of components) {
           const root = findSimpleRoot(component, text, filename);
-          if (!root) continue;
-          const { value } = getTestId(root);
-          const expected = component.smart ? component.name : toKebabCase(component.name);
-          if (component.smart && value === void 0) {
-            context.report({
-              node,
-              message: `Smart component "${component.name}" with one outer DOM element must set data-testid="${expected}".`
-            });
-            continue;
-          }
-          if (value === void 0 || value === expected) continue;
-          if (component.smart ? !isPascalCase5(value) || value !== expected : !isKebabCase3(value)) {
+          if (root) {
+            const { value } = getTestId(root);
+            const expected = component.smart ? component.name : toKebabCase(component.name);
+            if (component.smart && value === void 0) {
+              context.report({
+                node,
+                message: `Smart component "${component.name}" with one outer DOM element must set data-testid="${expected}".`
+              });
+              continue;
+            }
+            if (value === void 0 || value === expected) continue;
+            if (component.smart ? !isPascalCase5(value) || value !== expected : !isKebabCase3(value)) {
+              context.report({
+                node,
+                message: `data-testid for ${component.smart ? "smart" : "dumb"} component "${component.name}" must be ${component.smart ? "PascalCase" : "kebab-case"}: expected "${expected}".`
+              });
+            }
+          } else if (component.smart) {
             context.report({
               node,
-              message: `data-testid for ${component.smart ? "smart" : "dumb"} component "${component.name}" must be ${component.smart ? "PascalCase" : "kebab-case"}: expected "${expected}".`
+              message: `Smart component "${component.name}" has no single outer element; wrap its content in one outer element with data-testid="${component.name}" instead of rendering multiple roots. See docs/code-organization-guide/rules/smart-vs-dumb-component-rule.md`
             });
           }
         }
@@ -1831,14 +1837,14 @@ var cvaAppearancePropsRule = {
         if (node.typeAnnotation?.type !== "TSTypeLiteral") return;
         for (const member of node.typeAnnotation.members ?? []) {
           if (member.type !== "TSPropertySignature") continue;
-          const keyName = member.key?.type === "Identifier" ? member.key.name : void 0;
-          if (!keyName || !VISUAL_OPTION_NAMES.has(keyName)) continue;
+          const keyName2 = member.key?.type === "Identifier" ? member.key.name : void 0;
+          if (!keyName2 || !VISUAL_OPTION_NAMES.has(keyName2)) continue;
           const typeAnnotation = member.typeAnnotation?.typeAnnotation ?? member.typeAnnotation;
           if (!typeAnnotation) continue;
           if (typeAnnotation.type === "TSUnionType" || typeAnnotation.type === "TSTypeLiteral") {
             context.report({
               node,
-              message: `Visual option prop "${keyName}" must be defined through a cva() call rather than a manual union type. See docs/styling-guide/rules/component-variant-rule.md`
+              message: `Visual option prop "${keyName2}" must be defined through a cva() call rather than a manual union type. See docs/styling-guide/rules/component-variant-rule.md`
             });
           }
         }
@@ -1858,15 +1864,15 @@ function extractCvaInfo(node) {
   if (options?.type !== "ObjectExpression") return { variantNames, compoundVariants };
   for (const prop of options.properties) {
     if (prop.type !== "Property") continue;
-    const keyName = prop.key.type === "Identifier" ? prop.key.name : void 0;
-    if (keyName === "variants" && prop.value.type === "ObjectExpression") {
+    const keyName2 = prop.key.type === "Identifier" ? prop.key.name : void 0;
+    if (keyName2 === "variants" && prop.value.type === "ObjectExpression") {
       for (const vProp of prop.value.properties) {
         if (vProp.type !== "Property") continue;
         const vName = vProp.key.type === "Identifier" ? vProp.key.name : void 0;
         if (vName) variantNames.add(vName);
       }
     }
-    if (keyName === "compoundVariants" && prop.value.type === "ArrayExpression") {
+    if (keyName2 === "compoundVariants" && prop.value.type === "ArrayExpression") {
       for (const entry of prop.value.elements) {
         if (entry?.type !== "ObjectExpression") continue;
         for (const cvProp of entry.properties) {
@@ -2637,8 +2643,279 @@ var localePlacementRule = {
   }
 };
 
-// eslint/pasika/rules/shared-style-dedup.ts
+// eslint/pasika/rules/sole-state-owner.ts
 import path29 from "path";
+import ts6 from "typescript";
+function findStateHooks(node) {
+  const hooks = [];
+  const visit = (child) => {
+    if (ts6.isCallExpression(child) && ts6.isIdentifier(child.expression) && child.expression.text === "useState") {
+      if (ts6.isVariableDeclaration(child.parent)) {
+        const { name } = child.parent;
+        if (ts6.isArrayBindingPattern(name) && name.elements.length >= 2) {
+          const value = name.elements[0];
+          const updater = name.elements[1];
+          if (value && updater && ts6.isBindingElement(value) && ts6.isBindingElement(updater)) {
+            const valueName = value.name;
+            const updaterName = updater.name;
+            if (ts6.isIdentifier(valueName) && ts6.isIdentifier(updaterName)) {
+              hooks.push({ value: valueName.text, updater: updaterName.text });
+            }
+          }
+        }
+      }
+    }
+    ts6.forEachChild(child, visit);
+  };
+  visit(node);
+  return hooks;
+}
+function isHookUsage(node, hook) {
+  if (ts6.isCallExpression(node) && ts6.isIdentifier(node.expression) && node.expression.text === hook.updater) {
+    return "updater";
+  }
+  if (ts6.isIdentifier(node) && node.text === hook.value) {
+    const parent = node.parent;
+    if (ts6.isBindingElement(parent) || ts6.isPropertyAccessExpression(parent) || ts6.isShorthandPropertyAssignment(parent)) {
+      return void 0;
+    }
+    return "value";
+  }
+  return void 0;
+}
+function topLevelJsxChildren(initial) {
+  if (!initial) return void 0;
+  let expression = initial;
+  while (ts6.isParenthesizedExpression(expression)) expression = expression.expression;
+  if (ts6.isJsxFragment(expression)) {
+    const children = expression.children.filter(
+      (c) => !ts6.isJsxText(c) && !ts6.isJsxSpreadAttribute(c)
+    );
+    return { root: expression, children };
+  }
+  if (ts6.isJsxElement(expression)) {
+    const children = expression.children.filter(
+      (c) => !ts6.isJsxText(c) && !ts6.isJsxSpreadAttribute(c)
+    );
+    return { root: expression, children };
+  }
+  return void 0;
+}
+function collectUsesIn(child, hook) {
+  const positions = [];
+  let count = 0;
+  const visit = (node) => {
+    if (isHookUsage(node, hook)) {
+      positions.push(node);
+      count += 1;
+    }
+    if (ts6.isFunctionDeclaration(node) || ts6.isClassDeclaration(node)) return;
+    ts6.forEachChild(node, visit);
+  };
+  visit(child);
+  return { positions, count };
+}
+var soleStateOwnerRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require extracting a JSX part that is the sole owner of a useState hook as a named component."
+    }
+  },
+  create(context) {
+    const filename = path29.resolve(context.filename);
+    if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx")) return {};
+    const text = context.sourceCode.text;
+    const components = parseComponentInfo(text, filename);
+    return {
+      Program(node) {
+        for (const component of components) {
+          const hooks = findStateHooks(component.declaration);
+          for (const hook of hooks) {
+            const result = analyzeSoleOwner(component.declaration, hook);
+            if (!result) continue;
+            const { run, totalTopLevel } = result;
+            if (run === 0 || totalTopLevel === 0) continue;
+            context.report({
+              node,
+              loc: { line: 1, column: 0 },
+              message: `Component "${component.name}" uses state "${hook.value}" in ${String(run)} contiguous top-level JSX part${run === 1 ? "" : "s"}; extract that part into a named component that owns useState instead of reading it in the parent. See docs/code-organization-guide/rules/sole-state-owner-rule.md`
+            });
+          }
+        }
+      }
+    };
+  }
+};
+function analyzeSoleOwner(declaration, hook) {
+  const body = ts6.isFunctionDeclaration(declaration) ? declaration.body : void 0;
+  if (!body || !ts6.isBlock(body)) return void 0;
+  const returns = [];
+  const visit = (node) => {
+    if (node !== body && (ts6.isFunctionLike(node) || ts6.isClassLike(node))) return;
+    if (ts6.isReturnStatement(node)) returns.push(node);
+    ts6.forEachChild(node, visit);
+  };
+  visit(body);
+  if (returns.length !== 1) return void 0;
+  const single = returns[0];
+  if (!single?.expression || !ts6.isExpression(single.expression)) return void 0;
+  const returnExpression = single.expression;
+  const root = topLevelJsxChildren(returnExpression);
+  if (!root || root.children.length === 0) return void 0;
+  const totalTopLevel = root.children.length;
+  const usagePerChild = root.children.map((child) => collectUsesIn(child, hook));
+  const outsideJsx = usesOutsideJsx(declaration, hook, root.children);
+  if (outsideJsx) return void 0;
+  const usedLabels = usagePerChild.map((u) => u.count > 0);
+  const firstUsed = usedLabels.findIndex((v) => v);
+  const lastUsed = usedLabels.lastIndexOf(true);
+  if (firstUsed === -1 || lastUsed === -1) return void 0;
+  const windowHasUnused = usedLabels.slice(firstUsed, lastUsed + 1).some((v) => !v);
+  if (windowHasUnused) return void 0;
+  const run = lastUsed - firstUsed + 1;
+  const hasOutside = firstUsed > 0 || lastUsed < totalTopLevel - 1;
+  if (!hasOutside) return void 0;
+  return { run, totalTopLevel };
+}
+function usesOutsideJsx(declaration, hook, children) {
+  let outside = false;
+  const visit = (node) => {
+    if (outside) return;
+    if (node !== declaration && (ts6.isFunctionDeclaration(node) || ts6.isClassDeclaration(node))) return;
+    if (isHookUsage(node, hook)) {
+      let current = node;
+      let isInJsxChild = false;
+      while (!ts6.isSourceFile(current)) {
+        if (children.includes(current)) {
+          isInJsxChild = true;
+          break;
+        }
+        current = current.parent;
+      }
+      if (!isInJsxChild) outside = true;
+    }
+    ts6.forEachChild(node, visit);
+  };
+  visit(declaration);
+  return outside;
+}
+
+// eslint/pasika/rules/locale-key-shape.ts
+import path30 from "path";
+var MAX_KEY_LENGTH = 30;
+var ROLE_POSTFIXES = /* @__PURE__ */ new Set([
+  "Button",
+  "Link",
+  "Dialog",
+  "AlertDialog",
+  "Tooltip",
+  "Banner",
+  "Alert",
+  "Status",
+  "Tab",
+  "TabPanel",
+  "Menu",
+  "MenuItem",
+  "MenuBar",
+  "Checkbox",
+  "Radio",
+  "RadioGroup",
+  "Switch",
+  "ComboBox",
+  "ListBox",
+  "Option",
+  "Search",
+  "SearchBox",
+  "Navigation",
+  "ProgressBar",
+  "Slider",
+  "SpinButton",
+  "TextBox",
+  "Tree",
+  "TreeItem",
+  "TreeGrid",
+  "Grid",
+  "GridCell",
+  "Feed",
+  "Log",
+  "Timer",
+  "Marquee",
+  "Region",
+  "Main",
+  "Complementary",
+  "ContentInfo",
+  "Form",
+  "Toolbar",
+  "ScrollBar"
+]);
+var CAMEL_CASE = /^[a-z][a-zA-Z0-9]*$/;
+function isLocalesFile2(filename) {
+  const segments = path30.resolve(filename).split(path30.sep);
+  const srcIdx = segments.lastIndexOf("src");
+  return srcIdx !== -1 && segments[srcIdx + 1] === "locales";
+}
+function keyName(key) {
+  if (key.type === "Identifier") return key.name;
+  if (key.type === "Literal" && typeof key.value === "string") return key.value;
+  return void 0;
+}
+function reportFor(context, node, message) {
+  context.report({ node, message });
+}
+function checkKey(context, node, name) {
+  if (!CAMEL_CASE.test(name)) {
+    reportFor(
+      context,
+      node,
+      `Locale key "${name}" must be camelCase English based on the text. See docs/code-organization-guide/rules/locales-rule.md`
+    );
+    return;
+  }
+  if (name.length <= MAX_KEY_LENGTH) return;
+  const hasRolePostfix = [...ROLE_POSTFIXES].some((role) => name.endsWith(role));
+  if (hasRolePostfix) return;
+  reportFor(
+    context,
+    node,
+    `Locale key "${name}" is longer than ${String(MAX_KEY_LENGTH)} characters, so it must describe the message's purpose instead of the text; end it with an element role such as "Button", "Link", or "Dialog" (see WAI-ARIA roles). See docs/code-organization-guide/rules/locales-rule.md`
+  );
+}
+var localeKeyShapeRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require locale keys to be camelCase, and purpose-based element roles when long."
+    }
+  },
+  create(context) {
+    if (!isLocalesFile2(context.filename)) return {};
+    function visitObject(node) {
+      for (const property of node.properties) {
+        if (property.type !== "Property") continue;
+        const name = keyName(property.key);
+        if (name === void 0) continue;
+        if (property.value.type === "ObjectExpression") {
+          visitObject(property.value);
+        } else if (property.value.type === "Literal" && typeof property.value.value === "string") {
+          checkKey(context, property, name);
+        }
+      }
+    }
+    return {
+      VariableDeclarator(node) {
+        if (node.id.type !== "Identifier" || node.id.name !== "locales") return;
+        if (node.init?.type !== "ObjectExpression") return;
+        visitObject(node.init);
+      }
+    };
+  }
+};
+
+// eslint/pasika/rules/shared-style-dedup.ts
+import path31 from "path";
 import { readFileSync as readFileSync3, statSync as statSync2 } from "fs";
 var CLASS_NAME = /className="(?<classes>[^"]+)"/g;
 var comboCache;
@@ -2679,8 +2956,8 @@ var sharedStyleDedupRule = {
     }
   },
   create(context) {
-    const sourceRoot2 = path29.resolve("src");
-    const file = path29.resolve(context.filename);
+    const sourceRoot2 = path31.resolve("src");
+    const file = path31.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot2);
     if (segments.length === 0) return {};
     const index = getProjectIndex(sourceRoot2);
@@ -2702,6 +2979,114 @@ var sharedStyleDedupRule = {
   }
 };
 
+// eslint/pasika/rules/repeated-structure.ts
+function nodeKind(node) {
+  return node.type;
+}
+function isJsxNode(node) {
+  const kind = nodeKind(node);
+  return kind === "JSXElement" || kind === "JSXFragment";
+}
+function isJsxExpressionContainer(node) {
+  return node.type === "JSXExpressionContainer";
+}
+function walkJsx(current, visit) {
+  if (isJsxNode(current)) {
+    visit(current);
+    for (const child of current.children ?? []) walkJsx(child, visit);
+  } else if (isJsxExpressionContainer(current)) {
+    if (current.expression) walkJsx(current.expression, visit);
+  } else if (current.type === "ArrowFunctionExpression") {
+    walkJsx(current.body, visit);
+  } else if (current.type === "CallExpression") {
+    for (const argument of current.arguments) walkJsx(argument, visit);
+  } else if (current.type === "ConditionalExpression") {
+    walkJsx(current.consequent, visit);
+    walkJsx(current.alternate, visit);
+  } else if (current.type === "LogicalExpression") {
+    walkJsx(current.left, visit);
+    walkJsx(current.right, visit);
+  }
+}
+function signature(node) {
+  const parts = [];
+  const visit = (current) => {
+    const opening = nodeKind(current) === "JSXFragment" ? "<>" : current.openingElement?.name.name ?? "<>";
+    parts.push(opening);
+    if (nodeKind(current) === "JSXElement") {
+      const attributes = (current.openingElement?.attributes ?? []).filter((attribute) => attribute.type === "JSXAttribute").map((attribute) => {
+        const name = attribute.name?.name ?? "";
+        if (name === "className" && attribute.value?.type === "Literal" && typeof attribute.value.value === "string") {
+          return `class="${attribute.value.value.split(/\s+/).filter(Boolean).sort().join(" ")}"`;
+        }
+        return name;
+      }).sort();
+      parts.push(`[${attributes.join(",")}]`);
+    }
+    for (const child of current.children ?? []) {
+      if (isJsxNode(child)) {
+        visit(child);
+      } else if (isJsxExpressionContainer(child)) {
+        walkJsx(child, visit);
+        parts.push("{}");
+      } else {
+        parts.push("{}");
+      }
+    }
+  };
+  visit(node);
+  return parts.join("/");
+}
+function isSubstantial(node) {
+  let count = 0;
+  walkJsx(node, () => {
+    count += 1;
+  });
+  return count >= 3;
+}
+function blockChildren(node) {
+  return (node.children ?? []).filter(isJsxNode);
+}
+var repeatedStructureRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require extracting a repeated block of elements as a named component."
+    }
+  },
+  create(context) {
+    if (!context.filename.endsWith(".tsx") && !context.filename.endsWith(".jsx")) return {};
+    return {
+      JSXElement(node) {
+        checkChildren(node);
+      },
+      JSXFragment(node) {
+        checkChildren(node);
+      }
+    };
+    function checkChildren(node) {
+      const children = blockChildren(node);
+      const seen = /* @__PURE__ */ new Map();
+      for (const child of children) {
+        const sig = signature(child);
+        const group = seen.get(sig) ?? [];
+        group.push(child);
+        seen.set(sig, group);
+      }
+      for (const [, group] of seen) {
+        if (group.length < 2) continue;
+        const first = group[0];
+        if (!first || !isSubstantial(first)) continue;
+        context.report({
+          node: first,
+          message: `The same arrangement of elements appears ${String(group.length)} times here; extract it as a named component. Different data or labels do not prevent extraction. See docs/code-organization-guide/rules/repeated-structure-rule.md`
+        });
+      }
+    }
+  }
+};
+
 // eslint/pasika/rules/no-eslint-disable.ts
 var noEslintDisableRule = {
   meta: {
@@ -2801,7 +3186,7 @@ var zodSchemaValidationRule = {
 };
 
 // eslint/pasika/rules/source-under-src.ts
-import path30 from "path";
+import path32 from "path";
 var NON_SOURCE_ROOT_DIRS = /* @__PURE__ */ new Set([
   ".agents",
   ".cache",
@@ -2842,14 +3227,14 @@ var sourceUnderSrcRule = {
     }
   },
   create(context) {
-    const filename = path30.resolve(context.filename);
+    const filename = path32.resolve(context.filename);
     if (!MODULE_EXTENSION.test(filename)) return {};
-    const relative = path30.relative(process.cwd(), filename).replace(/\\/g, "/");
+    const relative = path32.relative(process.cwd(), filename).replace(/\\/g, "/");
     if (relative === "src" || relative.startsWith("src/")) return {};
     const topLevel = relative.split("/")[0] ?? "";
     if (NON_SOURCE_ROOT_DIRS.has(topLevel)) return {};
     if (!relative.includes("/")) {
-      const basename = path30.basename(filename);
+      const basename = path32.basename(filename);
       if (CONFIG_FILE.test(basename) || DECLARATION_FILE.test(basename) || basename.startsWith(".")) return {};
     }
     return {
@@ -2911,7 +3296,7 @@ var docKindSuffixRule = {
 };
 
 // eslint/pasika/rules/md/title-matches-file-name.ts
-import path31 from "path";
+import path33 from "path";
 function toExpectedFileName(title) {
   return `${title.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "")}.md`;
 }
@@ -2931,7 +3316,7 @@ var titleMatchesFileNameRule = {
         if (!filename.endsWith(".md")) return;
         const title = getTextContent(node).trim();
         const expectedFileName = toExpectedFileName(title);
-        const actualFileName = path31.basename(filename);
+        const actualFileName = path33.basename(filename);
         if (!title) {
           context.report({
             node,
@@ -3404,7 +3789,7 @@ var referenceBlockHeadingsRule = {
 };
 
 // eslint/pasika/rules/md/support-document-placement.ts
-import path32 from "path";
+import path34 from "path";
 var supportDocumentPlacementRule = {
   meta: {
     type: "problem",
@@ -3418,7 +3803,7 @@ var supportDocumentPlacementRule = {
       root(node) {
         const filename = getFilename(context);
         if (!filename.endsWith(".md")) return;
-        const parentFolder = path32.basename(path32.dirname(filename));
+        const parentFolder = path34.basename(path34.dirname(filename));
         if (filename.endsWith("-rule.md") && parentFolder !== "rules") {
           context.report({
             node,
@@ -3461,11 +3846,11 @@ var noTemplatePromptRule = {
 };
 
 // eslint/pasika/rules/md/guide-folder-entry-point.ts
-import path34 from "path";
+import path36 from "path";
 
 // eslint/pasika/rules/md/project-index.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync3 } from "fs";
-import path33 from "path";
+import path35 from "path";
 var KIND_BY_SUFFIX = [
   ["-rule.md", "rule"],
   ["-guide.md", "guide"],
@@ -3474,7 +3859,7 @@ var KIND_BY_SUFFIX = [
 ];
 function listMarkdownFiles(dir) {
   return readdirSync2(dir).flatMap((entry) => {
-    const entryPath = path33.join(dir, entry);
+    const entryPath = path35.join(dir, entry);
     if (statSync3(entryPath).isDirectory()) {
       return entry.startsWith("_") ? [] : listMarkdownFiles(entryPath);
     }
@@ -3492,11 +3877,11 @@ function getProjectDocs(docsRoot) {
   if (cached) return cached;
   const files = listMarkdownFiles(docsRoot);
   const docs = files.sort((a, b) => a.localeCompare(b)).map((filePath) => {
-    const fileName = path33.basename(filePath);
+    const fileName = path35.basename(filePath);
     const kind = KIND_BY_SUFFIX.find(([suffix]) => fileName.endsWith(suffix))?.[1];
     return {
       filePath,
-      doc: path33.relative(docsRoot, filePath).split(path33.sep).join("/"),
+      doc: path35.relative(docsRoot, filePath).split(path35.sep).join("/"),
       fileName,
       kind,
       title: extractTitle(filePath)
@@ -3506,12 +3891,12 @@ function getProjectDocs(docsRoot) {
   return docs;
 }
 function findDocsRoot(filePath) {
-  let dir = path33.dirname(filePath);
+  let dir = path35.dirname(filePath);
   for (; ; ) {
-    if (path33.basename(dir) === "docs" && statSync3(dir).isDirectory()) {
+    if (path35.basename(dir) === "docs" && statSync3(dir).isDirectory()) {
       return dir;
     }
-    const parent = path33.dirname(dir);
+    const parent = path35.dirname(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -3535,13 +3920,13 @@ var guideFolderEntryPointRule = {
         if (!docsRoot) return;
         const docs = getProjectDocs(docsRoot);
         const guideFolders = new Set(
-          docs.filter((doc) => ["rules", "references"].includes(path34.basename(path34.dirname(doc.filePath)))).map((doc) => path34.dirname(path34.dirname(doc.filePath))).filter((folder) => path34.resolve(folder) !== path34.resolve(docsRoot))
+          docs.filter((doc) => ["rules", "references"].includes(path36.basename(path36.dirname(doc.filePath)))).map((doc) => path36.dirname(path36.dirname(doc.filePath))).filter((folder) => path36.resolve(folder) !== path36.resolve(docsRoot))
         );
-        const currentDir = path34.dirname(filename);
+        const currentDir = path36.dirname(filename);
         if (guideFolders.has(currentDir)) {
-          const expectedEntryPoint = `${path34.basename(currentDir)}.md`;
+          const expectedEntryPoint = `${path36.basename(currentDir)}.md`;
           const hasEntryPoint = docs.some(
-            (doc) => doc.kind === "guide" && path34.dirname(doc.filePath) === currentDir && doc.fileName === expectedEntryPoint
+            (doc) => doc.kind === "guide" && path36.dirname(doc.filePath) === currentDir && doc.fileName === expectedEntryPoint
           );
           if (!hasEntryPoint) {
             context.report({
@@ -3598,6 +3983,39 @@ var rfcOnlyInBulletsRule = {
   }
 };
 
+// eslint/pasika/rules/md/rfc-keyword-in-every-bullet.ts
+function checkBullets(node, context) {
+  if (node.type === "listItem" && !containsRfcKeyword(getTextContent(node))) {
+    context.report({
+      node,
+      message: "bullet point contains no RFC 2119 keyword"
+    });
+  }
+  if ("children" in node) {
+    for (const child of node.children) {
+      checkBullets(child, context);
+    }
+  }
+}
+var rfcKeywordInEveryBulletRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Every bullet in a rule or policy document must contain an RFC 2119 keyword.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      root(node) {
+        const filename = getFilename(context);
+        if (!filename.endsWith("-rule.md") && !filename.endsWith("-policy.md")) return;
+        checkBullets(node, context);
+      }
+    };
+  }
+};
+
 // eslint/pasika/rules/md/policy-subject-headings.ts
 var policySubjectHeadingsRule = {
   meta: {
@@ -3733,7 +4151,7 @@ var noNestedHowToRule = {
 
 // eslint/pasika/rules/md/glossary-term-linking.ts
 import { readFileSync as readFileSync5 } from "fs";
-import path35 from "path";
+import path37 from "path";
 function extractGlossaryTerms(filePath) {
   const content = readFileSync5(filePath, "utf8");
   const terms = [];
@@ -3787,9 +4205,9 @@ var glossaryTermLinkingRule = {
         const docsRoot = findDocsRoot(filename);
         if (!docsRoot) return;
         const docs = getProjectDocs(docsRoot);
-        const guideDir = path35.dirname(filename);
+        const guideDir = path37.dirname(filename);
         const guideReferences = docs.filter(
-          (doc) => doc.kind === "reference" && path35.dirname(doc.filePath) === guideDir
+          (doc) => doc.kind === "reference" && path37.dirname(doc.filePath) === guideDir
         );
         if (guideReferences.length === 0) return;
         const glossaryTerms = [];
@@ -3833,6 +4251,7 @@ var mdRules = {
   "no-template-prompt": noTemplatePromptRule,
   "guide-folder-entry-point": guideFolderEntryPointRule,
   "rfc-only-in-bullets": rfcOnlyInBulletsRule,
+  "rfc-keyword-in-every-bullet": rfcKeywordInEveryBulletRule,
   "policy-subject-headings": policySubjectHeadingsRule,
   "guide-link-anchors": guideLinkAnchorsRule,
   "no-nested-how-to": noNestedHowToRule,
@@ -3862,7 +4281,7 @@ function atrules(node) {
 function atrulesNamed(node, name) {
   return atrules(node).filter((candidate) => candidate.type === "Atrule" && candidate.name === name);
 }
-function blockChildren(node) {
+function blockChildren2(node) {
   if (!node) return [];
   if (!("block" in node) || !node.block) return [];
   return node.block.children;
@@ -3909,7 +4328,7 @@ var themeResetRule = {
     return {
       "StyleSheet:exit"(node) {
         const resetFound = atrulesNamed(node, "theme").some(
-          (theme) => blockChildren(theme).some((child) => {
+          (theme) => blockChildren2(theme).some((child) => {
             if (child.type === "Declaration") return child.property.startsWith("--*");
             if (child.type === "Raw") return child.value.includes("--*: initial");
             return false;
@@ -3940,7 +4359,7 @@ var rootVariablesRule = {
       "StyleSheet:exit"(node) {
         const hasRootVars = rules(node).some((rule) => {
           if (!selectorNames(rule).includes("root")) return false;
-          return blockChildren(rule).some((child) => child.type === "Declaration");
+          return blockChildren2(rule).some((child) => child.type === "Declaration");
         });
         if (!hasRootVars) {
           context.report({
@@ -3949,7 +4368,7 @@ var rootVariablesRule = {
           });
         }
         const referencingThemes = atrulesNamed(node, "theme").filter(
-          (theme) => blockChildren(theme).some((child) => {
+          (theme) => blockChildren2(theme).some((child) => {
             if (child.type === "Raw") return child.value.includes("var(");
             if (child.type === "Declaration") return JSON.stringify(child.value).includes("var(");
             return false;
@@ -3983,9 +4402,9 @@ var applyUsageRule = {
       "StyleSheet:exit"(node) {
         const layers = node.children.filter((child) => child.type === "Atrule" && child.name === "layer");
         for (const layer of layers) {
-          for (const child of blockChildren(layer)) {
+          for (const child of blockChildren2(layer)) {
             if (child.type !== "Rule") continue;
-            for (const declaration of blockChildren(child)) {
+            for (const declaration of blockChildren2(child)) {
               if (declaration.type !== "Declaration") continue;
               context.report({
                 node: declaration,
@@ -4015,10 +4434,10 @@ var baseLayerPairRule = {
         if (baseLayers.length === 0) return;
         const applied = [];
         for (const layer of baseLayers) {
-          for (const child of blockChildren(layer)) {
+          for (const child of blockChildren2(layer)) {
             if (child.type !== "Rule") continue;
             if (!selectorNames(child).includes("body")) continue;
-            for (const declaration of blockChildren(child)) {
+            for (const declaration of blockChildren2(child)) {
               if (declaration.type !== "Atrule" || declaration.name !== "apply") continue;
               applied.push(...preludeIdentifiers(declaration));
             }
@@ -4143,7 +4562,7 @@ var customUtilityApplyRule = {
     return {
       "StyleSheet:exit"(node) {
         for (const utility of atrulesNamed(node, "utility")) {
-          for (const child of blockChildren(utility)) {
+          for (const child of blockChildren2(utility)) {
             if (child.type === "Atrule" && child.name === "apply") continue;
             if (child.type === "Declaration") {
               context.report({
@@ -4215,7 +4634,7 @@ var themeVariableNamespaceRule = {
       "StyleSheet:exit"(node) {
         const namespaces = /* @__PURE__ */ new Set();
         for (const theme of atrulesNamed(node, "theme")) {
-          for (const child of blockChildren(theme)) {
+          for (const child of blockChildren2(theme)) {
             if (child.type !== "Declaration") continue;
             const segments = child.property.replace(/^--/, "").split("-");
             if (segments[0]) namespaces.add(segments[0]);
@@ -4394,7 +4813,10 @@ var pasikaRules = {
   "stay-flat": stayFlatRule,
   "type-extraction": typeExtractionRule,
   "locale-placement": localePlacementRule,
+  "sole-state-owner": soleStateOwnerRule,
+  "locale-key-shape": localeKeyShapeRule,
   "shared-style-dedup": sharedStyleDedupRule,
+  "repeated-structure": repeatedStructureRule,
   "no-eslint-disable": noEslintDisableRule,
   "zod-schema-validation": zodSchemaValidationRule,
   "source-under-src": sourceUnderSrcRule