pasika 0.9.0 → 0.10.0

package/dist/eslint/pasika/index.js

@@ -1079,13 +1079,13 @@ function classifyFunction(name, isTsx, hasJsx) {
   return "function";
 }
 function classifyValue(name, initializer, isTsx) {
-  const isFunctionLike = initializer !== void 0 && (ts2.isArrowFunction(initializer) || ts2.isFunctionExpression(initializer) || ts2.isFunctionDeclaration(initializer));
+  const isFunctionLike2 = initializer !== void 0 && (ts2.isArrowFunction(initializer) || ts2.isFunctionExpression(initializer) || ts2.isFunctionDeclaration(initializer));
   if (isHookName(name)) return "hook";
   if (isSchemaName(name)) return "schema";
-  if (isTsx && isPascalCase3(name) && (initializer === void 0 || returnsJsx(initializer) || isFunctionLike)) {
+  if (isTsx && isPascalCase3(name) && (initializer === void 0 || returnsJsx(initializer) || isFunctionLike2)) {
     return "component";
   }
-  if (isFunctionLike) return "function";
+  if (isFunctionLike2) return "function";
   return "constant";
 }
 function parseModule(file) {
@@ -1121,7 +1121,11 @@ function parseModule(file) {
       }
       if (statement.exportClause && ts2.isNamedExports(statement.exportClause)) {
         for (const element of statement.exportClause.elements) {
-          exports.push({ name: element.name.text, kind: "other", line: lineOf(sourceFile, element) });
+          exports.push({
+            name: element.name.text,
+            kind: "other",
+            line: lineOf(sourceFile, element)
+          });
         }
       }
       continue;
@@ -1149,7 +1153,11 @@ function parseModule(file) {
       continue;
     }
     if (ts2.isTypeAliasDeclaration(statement) || ts2.isInterfaceDeclaration(statement)) {
-      exports.push({ name: statement.name.text, kind: "type", line: lineOf(sourceFile, statement) });
+      exports.push({
+        name: statement.name.text,
+        kind: "type",
+        line: lineOf(sourceFile, statement)
+      });
     }
   }
   return { file: path6.resolve(file), imports, exports };
@@ -1382,41 +1390,81 @@ var enforceCnMergeRule = {
 };
 
 // eslint/rules/cn-helper.ts
-function isIdentifier(node, name) {
+import path9 from "path";
+var HELPER = "cn";
+var DOC = "docs/pasika-adoption-guide/rules/cn-helper-rule.md";
+var ESLINT_CONFIG = /^eslint\.config\.(?:cjs|cts|js|mjs|mts|ts)$/;
+function isNamed(node, name) {
   return node?.type === "Identifier" && node.name === name;
 }
+function isCallTo(node, callee) {
+  return node?.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === callee;
+}
+function isComposition(node) {
+  if (!isCallTo(node, "twMerge")) return false;
+  const first = node.arguments[0];
+  return first !== void 0 && first.type !== "SpreadElement" && isCallTo(first, "clsx");
+}
+function returnedExpression(body) {
+  if (!body) return void 0;
+  if (body.type !== "BlockStatement") return body;
+  for (const statement of body.body) {
+    if (statement.type === "ReturnStatement") return statement.argument ?? void 0;
+  }
+  return void 0;
+}
+function sourceRootFor(context) {
+  return path9.join(path9.dirname(path9.resolve(context.filename)), "src");
+}
+function definesHelper(context, name) {
+  const index = getProjectIndex(sourceRootFor(context));
+  if (!index) return true;
+  for (const parsed of index.modules.values()) {
+    if (parsed.exports.some((exported) => exported.name === name)) return true;
+  }
+  return false;
+}
 var cnHelperRule = {
   meta: {
     schema: [],
     type: "problem",
     docs: {
-      description: "Require the cn helper to merge clsx and tailwind-merge."
+      description: `Require a repository to define a ${HELPER} helper that returns twMerge(clsx(...)).`
     }
   },
   create(context) {
+    if (ESLINT_CONFIG.test(path9.basename(context.filename))) {
+      return {
+        Program() {
+          if (definesHelper(context, HELPER)) return;
+          context.report({
+            node: context.sourceCode.ast,
+            loc: { line: 1, column: 0 },
+            message: `A repository must define a ${HELPER} helper. See ${DOC}`
+          });
+        }
+      };
+    }
+    const check = (body, reportNode) => {
+      if (isComposition(returnedExpression(body))) return;
+      context.report({
+        node: reportNode,
+        message: `${HELPER} must return twMerge(clsx(...)). See ${DOC}`
+      });
+    };
     return {
       FunctionDeclaration(node) {
-        if (isIdentifier(node.id, "cn")) checkBody(context, node.body);
+        if (isNamed(node.id, HELPER)) check(node.body, node);
       },
       VariableDeclarator(node) {
-        if (node.init?.type === "ArrowFunctionExpression" && isIdentifier(node.id, "cn")) {
-          checkBody(context, node.init.body);
-        }
+        if (!isNamed(node.id.type === "Identifier" ? node.id : null, HELPER)) return;
+        const init = node.init;
+        if (init?.type !== "ArrowFunctionExpression" && init?.type !== "FunctionExpression") return;
+        check(init.body, node);
       }
     };
   }
 };
-function checkBody(context, body) {
-  const source = context.sourceCode.getText(body);
-  const usesClsx = /\bclsx\b/.test(source);
-  const usesTwMerge = /\btwMerge\b|\btailwind-merge\b/.test(source);
-  if (!usesClsx || !usesTwMerge) {
-    context.report({
-      node: body,
-      message: "cn must be built from clsx and tailwind-merge (e.g. cn = twMerge(clsx(inputs)))."
-    });
-  }
-}
 
 // eslint/rules/enforce-cva-variant-props.ts
 var enforceCvaVariantPropsRule = {
@@ -1482,7 +1530,7 @@ var enforceCvaVariantPropsRule = {
 };
 
 // eslint/rules/enforce-barrel-exports.ts
-import path9 from "path";
+import path10 from "path";
 import fs from "fs";
 function isPascalCase4(str) {
   return /^[A-Z][A-Za-z0-9]*$/.test(str);
@@ -1492,7 +1540,7 @@ function isKebabCase2(str) {
 }
 var SUPPORT_FOLDERS = /* @__PURE__ */ new Set(["types", "schemas", "hooks", "constants", "utils", "config", "locales"]);
 function parentComponentName(dirPath, folderName) {
-  const componentFile = path9.join(dirPath, `${folderName}.tsx`);
+  const componentFile = path10.join(dirPath, `${folderName}.tsx`);
   if (!fs.existsSync(componentFile)) return void 0;
   try {
     const exports = parseModule(componentFile).exports;
@@ -1512,11 +1560,11 @@ var enforceBarrelExportsRule = {
   create(context) {
     const filename = context.filename;
     if (!filename) return {};
-    const baseName = path9.basename(filename);
+    const baseName = path10.basename(filename);
     if (baseName !== "index.ts" && baseName !== "index.cts" && baseName !== "index.mts") return {};
-    const dirPath = path9.dirname(filename);
-    const folderName = path9.basename(dirPath);
-    const parentFolderName = path9.basename(path9.dirname(dirPath));
+    const dirPath = path10.dirname(filename);
+    const folderName = path10.basename(dirPath);
+    const parentFolderName = path10.basename(path10.dirname(dirPath));
     if (SUPPORT_FOLDERS.has(folderName)) return {};
     if (!isPascalCase4(folderName) && !isKebabCase2(folderName)) return {};
     const parentName = parentComponentName(dirPath, folderName);
@@ -1555,14 +1603,14 @@ var enforceBarrelExportsRule = {
 
 // eslint/rules/component-placement.ts
 import fs2 from "fs";
-import path11 from "path";
+import path12 from "path";
 
 // eslint/project/ccf.ts
-import path10 from "path";
+import path11 from "path";
 var SUPPORT_FOLDERS2 = /* @__PURE__ */ new Set(["hooks", "types", "schemas", "constants", "utils"]);
 function segmentsOf(file, sourceRoot) {
-  const relative = path10.relative(sourceRoot, file);
-  return relative.startsWith("..") ? [] : relative.split(path10.sep);
+  const relative = path11.relative(sourceRoot, file);
+  return relative.startsWith("..") ? [] : relative.split(path11.sep);
 }
 function folderSegmentsOf(file, sourceRoot) {
   return segmentsOf(file, sourceRoot).slice(0, -1);
@@ -1641,7 +1689,7 @@ function resolveSupportPlacement(supportFile, supportFolder, index) {
 }
 function describeConsumers(consumers, sourceRoot) {
   const shown = 3;
-  const names = consumers.map((consumer) => path10.relative(path10.dirname(sourceRoot), consumer).split(path10.sep).join("/")).sort((left, right) => left.localeCompare(right));
+  const names = consumers.map((consumer) => path11.relative(path11.dirname(sourceRoot), consumer).split(path11.sep).join("/")).sort((left, right) => left.localeCompare(right));
   if (names.length <= shown) return names.join(", ");
   return `${names.slice(0, shown).join(", ")} and ${String(names.length - shown)} more`;
 }
@@ -1658,7 +1706,7 @@ function isNestedInside(expectedFolder, currentFolder, componentFile) {
   if (!sameFolder(currentFolder.slice(0, -1), expectedFolder)) return false;
   const folderName = currentFolder[currentFolder.length - 1];
   if (!folderName) return false;
-  return fs2.existsSync(path11.join(path11.dirname(componentFile), `${folderName}.tsx`));
+  return fs2.existsSync(path12.join(path12.dirname(componentFile), `${folderName}.tsx`));
 }
 var componentPlacementRule = {
   meta: {
@@ -1674,7 +1722,7 @@ var componentPlacementRule = {
     const sourceRoot = sourceRootOf(context);
     const index = getProjectIndex(sourceRoot);
     if (!index) return {};
-    const componentFile = path11.resolve(filename);
+    const componentFile = path12.resolve(filename);
     const segments = segmentsOf(componentFile, sourceRoot);
     if (segments.length === 0) return {};
     if (isUnderApp(segments) || isConfigModule(segments)) return {};
@@ -1708,7 +1756,7 @@ var componentPlacementRule = {
 };
 
 // eslint/rules/support-file-placement.ts
-import path12 from "path";
+import path13 from "path";
 var CONFIG_OWNED_FOLDERS = /* @__PURE__ */ new Set(["types", "constants"]);
 var REASON_TEXT2 = {
   "app-consumer": "a file under src/app/ imports it, so it belongs to the app-wide support folder",
@@ -1728,7 +1776,7 @@ var supportFilePlacementRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const supportFile = path12.resolve(context.filename);
+    const supportFile = path13.resolve(context.filename);
     const currentFolder = folderSegmentsOf(supportFile, sourceRoot);
     const supportFolder = currentFolder[currentFolder.length - 1];
     if (supportFolder === void 0 || !SUPPORT_FOLDERS2.has(supportFolder)) return {};
@@ -1753,7 +1801,7 @@ var supportFilePlacementRule = {
 
 // eslint/rules/application-structure.ts
 import fs3 from "fs";
-import path13 from "path";
+import path14 from "path";
 var MODULE_EXTENSIONS2 = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"]);
 var ROUTING_FILES = /* @__PURE__ */ new Set([
   "default",
@@ -1791,7 +1839,7 @@ function report2(context, message) {
   };
 }
 function isCodeFile(filename) {
-  return MODULE_EXTENSIONS2.has(path13.extname(filename));
+  return MODULE_EXTENSIONS2.has(path14.extname(filename));
 }
 function isRootSupportFolder(folder) {
   return SUPPORT_FOLDERS2.has(folder);
@@ -1812,7 +1860,7 @@ function expectedSupportFolder(kinds) {
 function configModuleRoot(filename, sourceRoot) {
   const segments = segmentsOf(filename, sourceRoot);
   if (segments[0] !== "config" || segments.length < 3) return void 0;
-  return path13.join(sourceRoot, "config", segments[1] ?? "");
+  return path14.join(sourceRoot, "config", segments[1] ?? "");
 }
 function componentFolderStart(segments) {
   if (segments[0] === "features") return 2;
@@ -1825,12 +1873,12 @@ function componentFolderViolation(segments, sourceRoot) {
   for (let depth = segments.length - 2; depth >= start; depth -= 1) {
     const folder = segments[depth];
     if (!folder || SUPPORT_FOLDERS2.has(folder)) continue;
-    const folderPath = path13.join(sourceRoot, ...segments.slice(0, depth + 1));
+    const folderPath = path14.join(sourceRoot, ...segments.slice(0, depth + 1));
     const label = `src/${segments.slice(0, depth + 1).join("/")}/`;
-    if (!fs3.existsSync(path13.join(folderPath, `${folder}.tsx`))) {
+    if (!fs3.existsSync(path14.join(folderPath, `${folder}.tsx`))) {
       return `A folder that is not a support folder must be a component folder; add "${folder}.tsx" to ${label} or move its files into a support folder.`;
     }
-    if (!fs3.existsSync(path13.join(folderPath, "index.ts"))) {
+    if (!fs3.existsSync(path14.join(folderPath, "index.ts"))) {
       return `A component folder must have an index.ts that named-re-exports its component; add index.ts to ${label}.`;
     }
   }
@@ -1845,7 +1893,7 @@ var applicationStructureRule = {
     }
   },
   create(context) {
-    const filename = path13.resolve(context.filename);
+    const filename = path14.resolve(context.filename);
     const sourceRoot = sourceRootOf(context);
     const segments = segmentsOf(filename, sourceRoot);
     if (segments.length === 0) return {};
@@ -1876,43 +1924,43 @@ var applicationStructureRule = {
         );
       }
       const moduleRoot = configModuleRoot(filename, sourceRoot);
-      if (moduleRoot && !fs3.existsSync(path13.join(moduleRoot, "index.ts"))) {
+      if (moduleRoot && !fs3.existsSync(path14.join(moduleRoot, "index.ts"))) {
         return report2(
           context,
-          `Add src/config/${path13.basename(moduleRoot)}/index.ts as the configuration module entry point.`
+          `Add src/config/${path14.basename(moduleRoot)}/index.ts as the configuration module entry point.`
         );
       }
-      if (moduleRoot && segments.length === 3 && path13.basename(filename) !== "index.ts") {
+      if (moduleRoot && segments.length === 3 && path14.basename(filename) !== "index.ts") {
         const kinds2 = exportedKinds(filename);
         const expected2 = expectedSupportFolder(kinds2);
         if (expected2 !== void 0) {
           return report2(
             context,
-            `Move this configuration support file into src/config/${path13.basename(moduleRoot)}/${expected2}/.`
+            `Move this configuration support file into src/config/${path14.basename(moduleRoot)}/${expected2}/.`
           );
         }
       }
     }
     if (topLevel === "app" && isCodeFile(filename)) {
-      const basename = path13.basename(filename, path13.extname(filename));
-      const currentFolder2 = path13.basename(path13.dirname(filename));
+      const basename = path14.basename(filename, path14.extname(filename));
+      const currentFolder2 = path14.basename(path14.dirname(filename));
       if (SUPPORT_FOLDERS2.has(currentFolder2)) {
         return report2(
           context,
           "src/app/ may contain routing files and framework assets, but ordinary components and support files must live outside src/app/."
         );
       }
-      if (!ROUTING_FILES.has(basename) && path13.extname(filename) !== ".css") {
+      if (!ROUTING_FILES.has(basename) && path14.extname(filename) !== ".css") {
         return report2(
           context,
           "src/app/ may contain routing files and framework assets, but ordinary components and support files must live outside src/app/."
         );
       }
-      if (ROUTING_FILES.has(basename) || path13.extname(filename) === ".css") return {};
+      if (ROUTING_FILES.has(basename) || path14.extname(filename) === ".css") return {};
     }
-    const currentFolder = path13.basename(path13.dirname(filename));
+    const currentFolder = path14.basename(path14.dirname(filename));
     const kinds = exportedKinds(filename);
-    const isConfigModuleRoot = topLevel === "config" && segments.length === 3 && path13.basename(filename) === "index.ts";
+    const isConfigModuleRoot = topLevel === "config" && segments.length === 3 && path14.basename(filename) === "index.ts";
     if (isConfigModuleRoot) return {};
     if (!SUPPORT_FOLDERS2.has(currentFolder)) {
       const expected2 = expectedSupportFolder(kinds);
@@ -1929,7 +1977,7 @@ var applicationStructureRule = {
     if (kinds.has("component")) {
       return report2(
         context,
-        `A support folder must not contain a component; move ${path13.basename(filename)} beside ${currentFolder}/.`
+        `A support folder must not contain a component; move ${path14.basename(filename)} beside ${currentFolder}/.`
       );
     }
     const expected = expectedSupportFolder(kinds);
@@ -1946,7 +1994,7 @@ var applicationStructureRule = {
 };
 
 // eslint/rules/named-exports.ts
-import path14 from "path";
+import path15 from "path";
 var FRAMEWORK_DEFAULT_EXPORT_FILES = /* @__PURE__ */ new Set([
   // App Router routing files
   "default",
@@ -1968,9 +2016,9 @@ var FRAMEWORK_DEFAULT_EXPORT_FILES = /* @__PURE__ */ new Set([
   "twitter-image"
 ]);
 function isFrameworkDefaultExportFile(filename) {
-  const normalized = filename.replaceAll(path14.sep, "/");
+  const normalized = filename.replaceAll(path15.sep, "/");
   if (!normalized.includes("/src/app/")) return false;
-  const basename = path14.basename(filename, path14.extname(filename));
+  const basename = path15.basename(filename, path15.extname(filename));
   return FRAMEWORK_DEFAULT_EXPORT_FILES.has(basename);
 }
 var namedExportsRule = {
@@ -1995,7 +2043,7 @@ var namedExportsRule = {
 };
 
 // eslint/rules/data-testid-case.ts
-import path15 from "path";
+import path16 from "path";
 var NEXT_ROUTING_FILES2 = /* @__PURE__ */ new Set([
   "default",
   "error",
@@ -2028,9 +2076,9 @@ var dataTestIdCaseRule = {
     }
   },
   create(context) {
-    const filename = path15.resolve(context.filename);
+    const filename = path16.resolve(context.filename);
     if (!filename.endsWith(".tsx")) return {};
-    const base = path15.basename(filename, path15.extname(filename));
+    const base = path16.basename(filename, path16.extname(filename));
     if (NEXT_ROUTING_FILES2.has(base)) return {};
     const text = context.sourceCode.text;
     const components = parseComponentInfo(text, filename);
@@ -2072,7 +2120,7 @@ function toKebabCase(value) {
 
 // eslint/rules/support-folder-shape.ts
 import fs4 from "fs";
-import path16 from "path";
+import path17 from "path";
 var SUPPORT_FOLDERS3 = /* @__PURE__ */ new Set(["constants", "types", "schemas"]);
 var INDEX_NAMES = /* @__PURE__ */ new Set(["index.ts", "index.tsx", "index.mts", "index.cts"]);
 var supportFolderShapeRule = {
@@ -2084,12 +2132,12 @@ var supportFolderShapeRule = {
     }
   },
   create(context) {
-    const filename = path16.resolve(context.filename);
-    const baseName = path16.basename(filename);
+    const filename = path17.resolve(context.filename);
+    const baseName = path17.basename(filename);
     if (!INDEX_NAMES.has(baseName)) return {};
-    const folder = path16.basename(path16.dirname(filename));
+    const folder = path17.basename(path17.dirname(filename));
     if (!SUPPORT_FOLDERS3.has(folder)) return {};
-    const directory = path16.dirname(filename);
+    const directory = path17.dirname(filename);
     let entries;
     try {
       entries = fs4.readdirSync(directory);
@@ -2106,7 +2154,7 @@ var supportFolderShapeRule = {
         const exportPattern = /export\s+(?:\{[^}]*\}|\*[^;]*)\s+from\s+["'](?<specifier>\.[^"']+)["']/g;
         for (const match of source.matchAll(exportPattern)) {
           const specifier = match.groups?.specifier;
-          if (specifier) exportedFiles.add(path16.basename(specifier));
+          if (specifier) exportedFiles.add(path17.basename(specifier));
         }
         const hasAnyReExport = exportedFiles.size > 0;
         const guide = `docs/next-codebase-guide/rules/${folder === "constants" ? "constants" : "types-and-schemas"}-rule.md`;
@@ -2133,7 +2181,7 @@ var supportFolderShapeRule = {
 };
 
 // eslint/rules/constant-casing.ts
-import path17 from "path";
+import path18 from "path";
 var NEXTJS_ROUTE_HANDLER_NAMES = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
 function isScreamingSnakeCase(name) {
   return /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/.test(name);
@@ -2147,9 +2195,9 @@ var constantCasingRule = {
     }
   },
   create(context) {
-    const filename = path17.resolve(context.filename);
+    const filename = path18.resolve(context.filename);
     const sourceRoot = sourceRootOf(context);
-    if (!filename.startsWith(sourceRoot + path17.sep)) return {};
+    if (!filename.startsWith(sourceRoot + path18.sep)) return {};
     return {
       VariableDeclarator(node) {
         if (node.id.type !== "Identifier") return;
@@ -2171,7 +2219,7 @@ var constantCasingRule = {
 };
 
 // eslint/rules/prefer-enum.ts
-import path18 from "path";
+import path19 from "path";
 function isConstAssertion(node) {
   const typeAnnotation = node.typeAnnotation;
   return typeAnnotation?.type === "TSTypeReference" && typeAnnotation.typeName?.type === "Identifier" && typeAnnotation.typeName.name === "const";
@@ -2190,9 +2238,9 @@ var preferEnumRule = {
     }
   },
   create(context) {
-    const filename = path18.resolve(context.filename);
+    const filename = path19.resolve(context.filename);
     const sourceRoot = sourceRootOf(context);
-    if (!filename.startsWith(sourceRoot + path18.sep)) return {};
+    if (!filename.startsWith(sourceRoot + path19.sep)) return {};
     return {
       TSAsExpression(node) {
         if (!isConstAssertion(node)) return;
@@ -2210,7 +2258,7 @@ var preferEnumRule = {
 };
 
 // eslint/rules/import-through-index.ts
-import path19 from "path";
+import path20 from "path";
 var importThroughIndexRule = {
   meta: {
     schema: [],
@@ -2220,7 +2268,7 @@ var importThroughIndexRule = {
     }
   },
   create(context) {
-    const filename = path19.resolve(context.filename);
+    const filename = path20.resolve(context.filename);
     const sourceRoot = sourceRootOf2(context, filename);
     return {
       Program(node) {
@@ -2232,7 +2280,7 @@ var importThroughIndexRule = {
             (segment) => ["constants", "types", "schemas"].includes(segment)
           );
           const supportFolder = supportFolderIndex >= 0 ? targetSegments[supportFolderIndex] : void 0;
-          if (!supportFolder || path19.basename(target).startsWith("index.")) continue;
+          if (!supportFolder || path20.basename(target).startsWith("index.")) continue;
           const folderIndex = targetSegments.slice(0, supportFolderIndex + 1);
           const expected = `@/${folderIndex.join("/")}`;
           context.report({
@@ -2254,14 +2302,14 @@ function importSpecifiers(source) {
   return specifiers;
 }
 function sourceRootOf2(context, filename) {
-  const marker = `${path19.sep}src${path19.sep}`;
+  const marker = `${path20.sep}src${path20.sep}`;
   const srcIndex = filename.lastIndexOf(marker);
   if (srcIndex >= 0) return filename.slice(0, srcIndex + marker.length - 1);
-  return path19.resolve(context.cwd ?? process.cwd(), "src");
+  return path20.resolve(context.cwd ?? process.cwd(), "src");
 }
 
 // eslint/rules/util-file-name.ts
-import path20 from "path";
+import path21 from "path";
 function toKebabCase2(value) {
   return value.replace(/(?<lower>[a-z0-9])(?<upper>[A-Z])/g, "$<lower>-$<upper>").replace(/(?<first>[A-Z])(?<rest>[A-Z][a-z])/g, "$<first>-$<rest>").toLowerCase();
 }
@@ -2274,7 +2322,7 @@ var utilFileNameRule = {
     }
   },
   create(context) {
-    const filename = path20.resolve(context.filename);
+    const filename = path21.resolve(context.filename);
     const segments = filename.replace(/\\/g, "/").split("/");
     if (!segments.includes("utils")) return {};
     let module;
@@ -2288,13 +2336,13 @@ var utilFileNameRule = {
     const functionName = functions[0]?.name;
     if (!functionName) return {};
     const expected = toKebabCase2(functionName);
-    const actual = path20.basename(filename, path20.extname(filename));
+    const actual = path21.basename(filename, path21.extname(filename));
     if (!expected || actual === expected) return {};
     return {
       Program(node) {
         context.report({
           node,
-          message: `A utility file exporting ${functionName} must be named ${expected}.${path20.extname(filename).slice(1)}.`
+          message: `A utility file exporting ${functionName} must be named ${expected}.${path21.extname(filename).slice(1)}.`
         });
       }
     };
@@ -2302,7 +2350,7 @@ var utilFileNameRule = {
 };
 
 // eslint/rules/no-util-barrel.ts
-import path21 from "path";
+import path22 from "path";
 var noUtilBarrelRule = {
   meta: {
     schema: [],
@@ -2312,7 +2360,7 @@ var noUtilBarrelRule = {
     }
   },
   create(context) {
-    const filename = path21.resolve(context.filename);
+    const filename = path22.resolve(context.filename);
     const sourceRoot = sourceRootOf3(context, filename);
     return {
       Program(node) {
@@ -2321,7 +2369,7 @@ var noUtilBarrelRule = {
           if (!target) continue;
           const segments = target.replace(/\\/g, "/").split("/");
           const utilsIndex = segments.lastIndexOf("utils");
-          if (utilsIndex < 0 || !path21.basename(target).startsWith("index.")) continue;
+          if (utilsIndex < 0 || !path22.basename(target).startsWith("index.")) continue;
           context.report({
             node,
             message: `Import utilities directly instead of through "${specifier}". See docs/next-codebase-guide/rules/utilities-rule.md`
@@ -2341,10 +2389,10 @@ function importSpecifiers2(source) {
   return specifiers;
 }
 function sourceRootOf3(context, filename) {
-  const marker = `${path21.sep}src${path21.sep}`;
+  const marker = `${path22.sep}src${path22.sep}`;
   const srcIndex = filename.lastIndexOf(marker);
   if (srcIndex >= 0) return filename.slice(0, srcIndex + marker.length - 1);
-  return path21.resolve(context.cwd ?? process.cwd(), "src");
+  return path22.resolve(context.cwd ?? process.cwd(), "src");
 }
 
 // eslint/rules/jsx-hygiene.ts
@@ -2437,7 +2485,7 @@ var jsxHygieneRule = {
 };
 
 // eslint/rules/interactive-component.ts
-import path22 from "path";
+import path23 from "path";
 var INTERACTIVE_TAGS = /* @__PURE__ */ new Set([
   "a",
   "button",
@@ -2592,8 +2640,8 @@ var interactiveComponentRule = {
   },
   create(context) {
     if (!context.filename.endsWith(".tsx") && !context.filename.endsWith(".jsx")) return {};
-    const filename = path22.resolve(context.filename);
-    const base = path22.basename(filename, path22.extname(filename));
+    const filename = path23.resolve(context.filename);
+    const base = path23.basename(filename, path23.extname(filename));
     if (NEXT_ROUTING_FILES3.has(base)) return {};
     return {
       JSXElement(node) {
@@ -2844,12 +2892,12 @@ var cvaBooleanVariantsRule = {
 };
 
 // eslint/rules/cross-feature-import.ts
-import path23 from "path";
+import path24 from "path";
 var FEATURES_SEGMENT = "features";
 function featureNameOf(resolvedPath, sourceRoot) {
-  const relative = path23.relative(sourceRoot, resolvedPath);
+  const relative = path24.relative(sourceRoot, resolvedPath);
   if (relative.startsWith("..")) return void 0;
-  const segments = relative.split(path23.sep);
+  const segments = relative.split(path24.sep);
   if (segments[0] !== FEATURES_SEGMENT || segments.length < 2) return void 0;
   return segments[1];
 }
@@ -2865,9 +2913,9 @@ var crossFeatureImportRule = {
     const filename = context.filename;
     if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx")) return {};
     const sourceRoot = sourceRootOf(context);
-    const fileRelative = path23.relative(sourceRoot, filename);
+    const fileRelative = path24.relative(sourceRoot, filename);
     if (fileRelative.startsWith("..")) return {};
-    const fileSegments = fileRelative.split(path23.sep);
+    const fileSegments = fileRelative.split(path24.sep);
     const isInCompositions = fileSegments[0] === "compositions";
     const isInApp = fileSegments[0] === "app";
     const isConfig = fileSegments[0] === "config";
@@ -2881,9 +2929,9 @@ var crossFeatureImportRule = {
         if (typeof source.value !== "string") return;
         let resolved;
         if (source.value.startsWith("@/")) {
-          resolved = path23.resolve(sourceRoot, source.value.slice(2));
+          resolved = path24.resolve(sourceRoot, source.value.slice(2));
         } else if (source.value.startsWith(".")) {
-          resolved = path23.resolve(path23.dirname(filename), source.value);
+          resolved = path24.resolve(path24.dirname(filename), source.value);
         }
         if (!resolved) return;
         const feature = featureNameOf(resolved, sourceRoot);
@@ -2902,7 +2950,24 @@ var crossFeatureImportRule = {
 };
 
 // eslint/rules/pure-function-extract.ts
-import path24 from "path";
+import path25 from "path";
+var ROUTE_HANDLER_EXPORT_NAMES = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS",
+  "dynamic",
+  "dynamicParams",
+  "revalidate",
+  "fetchCache",
+  "runtime",
+  "preferredRegion",
+  "maxDuration",
+  "generateStaticParams"
+]);
 function isComponentLikeName(name) {
   return /^[A-Z]/.test(name);
 }
@@ -2929,13 +2994,14 @@ var pureFunctionExtractRule = {
   },
   create(context) {
     const filename = context.filename;
-    if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx")) return {};
+    const isRouteFile = path25.basename(filename) === "route.ts";
+    if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx") && !isRouteFile) return {};
     const sourceRoot = sourceRootOf(context);
-    const relative = path24.relative(sourceRoot, filename);
+    const relative = path25.relative(sourceRoot, filename);
     if (relative.startsWith("..")) return {};
-    const segments = relative.split(path24.sep);
+    const segments = relative.split(path25.sep);
     if (segments[0] === "utils") return {};
-    if (segments[0] === "app") return {};
+    if (segments[0] === "app" && !isRouteFile) return {};
     const supportFolders = /* @__PURE__ */ new Set(["hooks", "types", "schemas", "constants", "utils"]);
     if (segments.length >= 2 && supportFolders.has(segments[segments.length - 1] ?? "")) return {};
     function report3(node, name) {
@@ -2946,35 +3012,544 @@ var pureFunctionExtractRule = {
     }
     return {
       FunctionDeclaration(node) {
-        const exported = node.parent?.type === "ExportNamedDeclaration";
-        if (!exported) return;
-        const name = node.id?.name;
-        if (!name) return;
-        if (isComponentLikeName(name) || isHookName2(name)) return;
-        if (!node.body || hasHookUsage(node.body)) return;
-        report3(node, name);
+        const exported = node.parent?.type === "ExportNamedDeclaration";
+        const moduleLevel = exported || node.parent?.type === "Program";
+        if (!moduleLevel) return;
+        if (!isRouteFile && !exported) return;
+        const name = node.id?.name;
+        if (!name) return;
+        if (isRouteFile && ROUTE_HANDLER_EXPORT_NAMES.has(name)) return;
+        if (isComponentLikeName(name) || isHookName2(name)) return;
+        if (!node.body || hasHookUsage(node.body)) return;
+        report3(node, name);
+      },
+      VariableDeclarator(node) {
+        if (node.id.type !== "Identifier") return;
+        const name = node.id.name;
+        if (!name) return;
+        const container = node.parent.parent;
+        const exported = container?.type === "ExportNamedDeclaration";
+        const moduleLevel = exported || container?.type === "Program";
+        if (!moduleLevel) return;
+        if (!isRouteFile && !exported) return;
+        if (isRouteFile && ROUTE_HANDLER_EXPORT_NAMES.has(name)) return;
+        if (isComponentLikeName(name) || isHookName2(name)) return;
+        const init = node.init;
+        if (!init || init.type !== "ArrowFunctionExpression" && init.type !== "FunctionExpression") {
+          return;
+        }
+        if (init.body.type === "BlockStatement" && hasHookUsage(init.body)) return;
+        report3(node, name);
+      }
+    };
+  }
+};
+
+// eslint/rules/root-support-placement.ts
+import path26 from "path";
+function isSupportFolder(value) {
+  return value === "utils" || value === "types" || value === "schemas" || value === "constants";
+}
+var TYPES_AND_SCHEMAS_DOC = "docs/next-codebase-guide/rules/types-and-schemas-rule.md";
+var KIND_FOR_SUPPORT_FOLDER = {
+  utils: "function",
+  types: "type",
+  schemas: "schema",
+  constants: "constant"
+};
+var LABEL_FOR_SUPPORT_FOLDER = {
+  utils: "Function",
+  types: "Type",
+  schemas: "Schema",
+  constants: "Constant"
+};
+var DOC_FOR_SUPPORT_FOLDER = {
+  utils: "docs/next-codebase-guide/rules/utilities-rule.md",
+  types: TYPES_AND_SCHEMAS_DOC,
+  schemas: TYPES_AND_SCHEMAS_DOC,
+  constants: "docs/next-codebase-guide/rules/constants-rule.md"
+};
+var rootSupportPlacementRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require a zero-consumer support-folder export to live under a feature folder, not root or elsewhere."
+    }
+  },
+  create(context) {
+    const sourceRoot = sourceRootOf(context);
+    const file = path26.resolve(context.filename);
+    const segments = segmentsOf(file, sourceRoot);
+    const folderSegments = folderSegmentsOf(file, sourceRoot);
+    const supportFolder = folderSegments[folderSegments.length - 1];
+    if (!isSupportFolder(supportFolder)) return {};
+    const expectedKind = KIND_FOR_SUPPORT_FOLDER[supportFolder];
+    const doc = DOC_FOR_SUPPORT_FOLDER[supportFolder];
+    const label = LABEL_FOR_SUPPORT_FOLDER[supportFolder];
+    const isRoot = segments[0] === supportFolder;
+    const isUnderFeature = segments[0] === "features";
+    if (isUnderFeature) return {};
+    const index = getProjectIndex(sourceRoot);
+    if (!index) return {};
+    const module = index.modules.get(file);
+    if (!module) return {};
+    const findings = [];
+    for (const exp of module.exports) {
+      if (exp.kind !== expectedKind) continue;
+      const consumers = [...index.symbolConsumers.get(symbolKey(file, exp.name)) ?? []];
+      if (consumers.length === 0) continue;
+      const real = consumers.filter((consumer) => {
+        const consumerSegments = segmentsOf(consumer, sourceRoot);
+        return !isUnderApp(consumerSegments) && !isConfigModule(consumerSegments);
+      });
+      if (real.length > 0) continue;
+      const where = isRoot ? `root src/${supportFolder}/` : `src/${folderSegments.join("/")}/`;
+      findings.push({
+        line: exp.line,
+        message: `${label} "${exp.name}" has no consumer outside src/app/ or a configuration module, so it has not earned ${where}; move it into the feature it represents (src/features/<feature>/${supportFolder}/). If no existing feature applies, introduce a new feature folder. See ${doc}`
+      });
+    }
+    if (findings.length === 0) return {};
+    return {
+      Program(node) {
+        for (const finding of findings) {
+          context.report({ node, loc: { line: finding.line, column: 0 }, message: finding.message });
+        }
+      }
+    };
+  }
+};
+
+// eslint/rules/route-handler-shape.ts
+import path27 from "path";
+import ts4 from "typescript";
+var HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+var REQUIRED_BOUNDARY = "withResponse";
+function isFunctionLike(node) {
+  return node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
+}
+function findHandler(node) {
+  if (isFunctionLike(node)) return node;
+  if (node.type === "CallExpression") {
+    for (const arg of node.arguments) {
+      if (arg.type === "SpreadElement") continue;
+      const found = findHandler(arg);
+      if (found) return found;
+    }
+  }
+  return void 0;
+}
+function isLoop(node) {
+  return ts4.isForStatement(node) || ts4.isForOfStatement(node) || ts4.isForInStatement(node) || ts4.isWhileStatement(node) || ts4.isDoStatement(node);
+}
+function isFunctionBoundary(node) {
+  return ts4.isFunctionExpression(node) || ts4.isArrowFunction(node) || ts4.isFunctionDeclaration(node);
+}
+function analyzeHandlerBody(body, sourceText) {
+  const start = body.range?.[0] ?? 0;
+  const end = body.range?.[1] ?? sourceText.length;
+  const sourceFile = ts4.createSourceFile(
+    "route.ts",
+    sourceText.slice(start, end),
+    ts4.ScriptTarget.Latest,
+    true,
+    ts4.ScriptKind.TS
+  );
+  const kinds = /* @__PURE__ */ new Set();
+  const calledNames = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (ts4.isTryStatement(node)) kinds.add("try");
+    if (isLoop(node)) kinds.add("loop");
+    if (ts4.isIfStatement(node)) kinds.add("if");
+    if (ts4.isCallExpression(node) && ts4.isIdentifier(node.expression)) calledNames.add(node.expression.text);
+    if (isFunctionBoundary(node)) return;
+    ts4.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return { kinds, calledNames };
+}
+var CONTROL_FLOW_MESSAGES = {
+  try: "a try statement",
+  loop: "a loop",
+  if: "an if statement"
+};
+function isFunctionLikeInit(node) {
+  return node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+}
+function collectLocallyDeclaredNames(programBody) {
+  const names = /* @__PURE__ */ new Set();
+  for (const statement of programBody) {
+    const declaration = statement.type === "ExportNamedDeclaration" && statement.declaration ? statement.declaration : statement;
+    if (declaration.type === "FunctionDeclaration") {
+      names.add(declaration.id.name);
+    }
+    if (declaration.type === "VariableDeclaration") {
+      for (const declarator of declaration.declarations) {
+        if (declarator.id.type === "Identifier" && isFunctionLikeInit(declarator.init)) {
+          names.add(declarator.id.name);
+        }
+      }
+    }
+  }
+  return names;
+}
+var routeHandlerShapeRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require a route.ts handler to be wrapped in withResponse, with no try, loop, or if of its own, and every function it calls imported rather than declared in route.ts."
+    }
+  },
+  create(context) {
+    if (path27.basename(context.filename) !== "route.ts") return {};
+    const sourceText = context.sourceCode.text;
+    function reportUnwrapped(node, name) {
+      context.report({
+        node,
+        message: `Handler "${name}" must be wrapped in withResponse. See docs/next-codebase-guide/rules/route-handler-rule.md`
+      });
+    }
+    function checkExport(node, name, init) {
+      if (init.type === "Identifier") return;
+      const boundary = init.type === "CallExpression" && init.callee.type === "Identifier" ? init.callee.name : void 0;
+      if (boundary !== REQUIRED_BOUNDARY) {
+        reportUnwrapped(node, name);
+        return;
+      }
+      const handler = findHandler(init);
+      if (!handler?.body) return;
+      const { kinds, calledNames } = analyzeHandlerBody(handler.body, sourceText);
+      for (const kind of kinds) {
+        context.report({
+          node,
+          message: `Handler "${name}" contains ${CONTROL_FLOW_MESSAGES[kind]} of its own; delegate that to a function it calls. See docs/next-codebase-guide/rules/route-handler-rule.md`
+        });
+      }
+      const localNames = collectLocallyDeclaredNames(context.sourceCode.ast.body);
+      for (const calledName of calledNames) {
+        if (localNames.has(calledName)) {
+          context.report({
+            node,
+            message: `Handler "${name}" calls "${calledName}", which is declared in route.ts instead of imported. See docs/next-codebase-guide/rules/route-handler-rule.md`
+          });
+        }
+      }
+    }
+    return {
+      FunctionDeclaration(node) {
+        const exported = node.parent?.type === "ExportNamedDeclaration";
+        const name = node.id?.name;
+        if (!exported || !name || !HTTP_METHODS.has(name) || !node.body) return;
+        reportUnwrapped(node, name);
+      },
+      VariableDeclarator(node) {
+        if (node.id.type !== "Identifier") return;
+        const name = node.id.name;
+        const exported = node.parent.parent?.type === "ExportNamedDeclaration";
+        if (!exported || !HTTP_METHODS.has(name) || !node.init) return;
+        checkExport(node, name, node.init);
+      }
+    };
+  }
+};
+
+// eslint/rules/http-error-usage.ts
+import { readFileSync as readFileSync4 } from "fs";
+import path28 from "path";
+import ts5 from "typescript";
+var HTTP_ERROR = "HttpError";
+var ROUTE_FILE = "route.ts";
+var DOC2 = "docs/next-codebase-guide/rules/route-handler-rule.md";
+var HERITAGE_DEPTH = 5;
+var HANDS_ERROR_BACK = `A delegated module must throw the HttpError it reports a failure with, not return it. See ${DOC2}`;
+var delegatedModuleMessage = (name) => `A delegated module must report a failure by throwing an HttpError, not "${name}". See ${DOC2}`;
+function constructedErrorName(node) {
+  if (node === void 0) return void 0;
+  if (node.type === "NewExpression") {
+    return node.callee.type === "Identifier" ? node.callee.name : void 0;
+  }
+  if (node.type === "AwaitExpression") return constructedErrorName(node.argument);
+  if (node.type === "ConditionalExpression") {
+    return constructedErrorName(node.consequent) ?? constructedErrorName(node.alternate);
+  }
+  if (node.type === "LogicalExpression") {
+    return constructedErrorName(node.left) ?? constructedErrorName(node.right);
+  }
+  if (node.type !== "CallExpression") return void 0;
+  for (const argument of node.arguments) {
+    const found = constructedErrorName(argument);
+    if (found) return found;
+  }
+  return void 0;
+}
+function parentClassOf(file, name) {
+  let text;
+  try {
+    text = readFileSync4(file, "utf8");
+  } catch {
+    return void 0;
+  }
+  const sourceFile = ts5.createSourceFile(file, text, ts5.ScriptTarget.Latest, true, ts5.ScriptKind.TSX);
+  for (const statement of sourceFile.statements) {
+    if (!ts5.isClassDeclaration(statement) || statement.name?.text !== name) continue;
+    const heritage = statement.heritageClauses?.find((clause) => clause.token === ts5.SyntaxKind.ExtendsKeyword);
+    const parent = heritage?.types[0]?.expression;
+    return parent && ts5.isIdentifier(parent) ? parent.text : void 0;
+  }
+  return void 0;
+}
+function importedFrom(file, name, sourceRoot, index) {
+  const module = index.modules.get(path28.resolve(file));
+  const moduleImport = module?.imports.find((entry) => entry.names.includes(name));
+  if (!moduleImport) return void 0;
+  return resolveSpecifier(file, moduleImport.specifier, sourceRoot);
+}
+function isHttpErrorClass(file, name, sourceRoot, index) {
+  let currentFile = path28.resolve(file);
+  let currentName = name;
+  for (let depth = 0; depth <= HERITAGE_DEPTH; depth += 1) {
+    if (currentName === HTTP_ERROR) return true;
+    const parent = parentClassOf(currentFile, currentName);
+    if (parent) {
+      currentName = parent;
+      continue;
+    }
+    const imported = importedFrom(currentFile, currentName, sourceRoot, index);
+    if (!imported) return false;
+    currentFile = imported;
+  }
+  return false;
+}
+var pipelineCache;
+function pipelineFiles(sourceRoot) {
+  const index = getProjectIndex(sourceRoot);
+  if (!index) return void 0;
+  if (pipelineCache?.index === index) return pipelineCache.files;
+  const files = /* @__PURE__ */ new Set();
+  const queue = [...index.modules.keys()].filter((file) => path28.basename(file) === ROUTE_FILE);
+  while (queue.length > 0) {
+    const file = queue.pop();
+    if (file === void 0 || files.has(file)) continue;
+    files.add(file);
+    for (const moduleImport of index.modules.get(file)?.imports ?? []) {
+      const target = resolveSpecifier(file, moduleImport.specifier, index.sourceRoot);
+      if (target && index.modules.has(target) && !files.has(target)) queue.push(target);
+    }
+  }
+  pipelineCache = { index, files };
+  return files;
+}
+var httpErrorUsageRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require a delegated module to report a failure by throwing an HttpError, never another error type and never a returned value."
+    }
+  },
+  create(context) {
+    const sourceRoot = sourceRootOf(context);
+    const file = path28.resolve(context.filename);
+    let delegated;
+    function inPipeline() {
+      delegated ??= pipelineFiles(sourceRoot)?.has(file) ?? false;
+      return delegated;
+    }
+    return {
+      ReturnStatement(node) {
+        if (node.argument === null) return;
+        if (!inPipeline()) return;
+        if (constructedErrorName(node.argument) !== HTTP_ERROR) return;
+        context.report({ node, message: HANDS_ERROR_BACK });
+      },
+      ArrowFunctionExpression(node) {
+        if (node.body.type === "BlockStatement") return;
+        if (!inPipeline()) return;
+        if (constructedErrorName(node.body) !== HTTP_ERROR) return;
+        context.report({ node, message: HANDS_ERROR_BACK });
+      },
+      ThrowStatement(node) {
+        const thrown = node.argument;
+        if (thrown.type !== "NewExpression" || thrown.callee.type !== "Identifier") return;
+        const name = thrown.callee.name;
+        if (name === HTTP_ERROR) return;
+        const index = getProjectIndex(sourceRoot);
+        if (!index || !inPipeline()) return;
+        if (isHttpErrorClass(file, name, sourceRoot, index)) return;
+        context.report({ node, message: delegatedModuleMessage(name) });
+      }
+    };
+  }
+};
+
+// eslint/rules/with-response-helper.ts
+import path29 from "path";
+import ts6 from "typescript";
+var HELPER2 = "withResponse";
+var DOC3 = "docs/pasika-adoption-guide/rules/with-response-helper-rule.md";
+var ESLINT_CONFIG2 = /^eslint\.config\.(?:cjs|cts|js|mjs|mts|ts)$/;
+var BEAT_KEYS = [
+  "awaitsHandler",
+  "validatesWithSchema",
+  "checksHttpError",
+  "answersWithNullData",
+  "usesErrorStatus",
+  "rethrows"
+];
+var BEAT_MESSAGES = {
+  awaitsHandler: "must await the handler",
+  validatesWithSchema: "must validate the handler's returned data through the response schema",
+  checksHttpError: "must check the caught error with instanceof HttpError",
+  answersWithNullData: "must answer a thrown HttpError with { data: null, message }",
+  usesErrorStatus: "must answer at the caught error's status",
+  rethrows: "must rethrow a caught error that is not an HttpError"
+};
+function isNamed2(node, name) {
+  return node?.type === "Identifier" && node.name === name;
+}
+function sourceRootFor2(context) {
+  return path29.join(path29.dirname(path29.resolve(context.filename)), "src");
+}
+function definesHelper2(context, name) {
+  const index = getProjectIndex(sourceRootFor2(context));
+  if (!index) return true;
+  for (const parsed of index.modules.values()) {
+    if (parsed.exports.some((exported) => exported.name === name)) return true;
+  }
+  return false;
+}
+function contains(node, check) {
+  let found = false;
+  const visit = (current) => {
+    if (found) return;
+    if (check(current)) {
+      found = true;
+      return;
+    }
+    ts6.forEachChild(current, visit);
+  };
+  visit(node);
+  return found;
+}
+function findTryStatement(node) {
+  let found;
+  const visit = (current) => {
+    if (found) return;
+    if (ts6.isTryStatement(current)) {
+      found = current;
+      return;
+    }
+    ts6.forEachChild(current, visit);
+  };
+  visit(node);
+  return found;
+}
+function awaitsHandlerCall(handlerName) {
+  return (node) => ts6.isAwaitExpression(node) && ts6.isCallExpression(node.expression) && ts6.isIdentifier(node.expression.expression) && node.expression.expression.text === handlerName;
+}
+function parsesThroughSchema(schemaName) {
+  return (node) => ts6.isCallExpression(node) && ts6.isPropertyAccessExpression(node.expression) && ts6.isIdentifier(node.expression.expression) && node.expression.expression.text === schemaName && (node.expression.name.text === "parse" || node.expression.name.text === "safeParse");
+}
+function checksHttpError(node) {
+  return ts6.isBinaryExpression(node) && node.operatorToken.kind === ts6.SyntaxKind.InstanceOfKeyword && ts6.isIdentifier(node.right) && node.right.text === "HttpError";
+}
+function answersWithNullData(node) {
+  if (!ts6.isCallExpression(node) || !ts6.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "json") {
+    return false;
+  }
+  return node.arguments.some((argument) => {
+    if (!ts6.isObjectLiteralExpression(argument)) return false;
+    return argument.properties.some((property) => {
+      if (!ts6.isPropertyAssignment(property)) return false;
+      const name = ts6.isIdentifier(property.name) ? property.name.text : void 0;
+      return name === "data" && property.initializer.kind === ts6.SyntaxKind.NullKeyword;
+    });
+  });
+}
+function readsErrorStatus(errorName) {
+  return (node) => ts6.isPropertyAccessExpression(node) && node.name.text === "status" && ts6.isIdentifier(node.expression) && node.expression.text === errorName;
+}
+function collectBeats(text, schemaName, handlerName) {
+  const beats = {
+    awaitsHandler: false,
+    validatesWithSchema: false,
+    checksHttpError: false,
+    answersWithNullData: false,
+    usesErrorStatus: false,
+    rethrows: false
+  };
+  const sourceFile = ts6.createSourceFile("with-response.ts", text, ts6.ScriptTarget.Latest, true, ts6.ScriptKind.TS);
+  const tryStatement = findTryStatement(sourceFile);
+  if (!tryStatement) return beats;
+  beats.awaitsHandler = contains(tryStatement.tryBlock, awaitsHandlerCall(handlerName));
+  beats.validatesWithSchema = contains(tryStatement.tryBlock, parsesThroughSchema(schemaName));
+  const catchClause = tryStatement.catchClause;
+  if (!catchClause) return beats;
+  const errorName = catchClause.variableDeclaration?.name;
+  const caughtName = errorName && ts6.isIdentifier(errorName) ? errorName.text : void 0;
+  beats.checksHttpError = contains(catchClause.block, checksHttpError);
+  beats.answersWithNullData = contains(catchClause.block, answersWithNullData);
+  beats.usesErrorStatus = contains(catchClause.block, readsErrorStatus(caughtName));
+  beats.rethrows = contains(catchClause.block, ts6.isThrowStatement);
+  return beats;
+}
+function parameterNames(node) {
+  if (node.type !== "FunctionDeclaration" && node.type !== "FunctionExpression" && node.type !== "ArrowFunctionExpression") {
+    return [];
+  }
+  return node.params.map((parameter) => parameter.type === "Identifier" ? parameter.name : void 0);
+}
+var withResponseHelperRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: `Require a repository to define a ${HELPER2} helper that validates the handler's data and maps a thrown HttpError to a response.`
+    }
+  },
+  create(context) {
+    if (ESLINT_CONFIG2.test(path29.basename(context.filename))) {
+      return {
+        Program() {
+          if (definesHelper2(context, HELPER2)) return;
+          context.report({
+            node: context.sourceCode.ast,
+            loc: { line: 1, column: 0 },
+            message: `A repository must define a ${HELPER2} helper. See ${DOC3}`
+          });
+        }
+      };
+    }
+    const check = (node, parameters) => {
+      const [start, end] = node.range ?? [0, context.sourceCode.text.length];
+      const beats = collectBeats(context.sourceCode.text.slice(start, end), parameters[0], parameters[1]);
+      for (const beat of BEAT_KEYS) {
+        if (beats[beat]) continue;
+        context.report({
+          node,
+          message: `${HELPER2} ${BEAT_MESSAGES[beat]}. See ${DOC3}`
+        });
+      }
+    };
+    return {
+      FunctionDeclaration(node) {
+        if (isNamed2(node.id, HELPER2)) check(node, parameterNames(node));
       },
       VariableDeclarator(node) {
-        if (node.id.type !== "Identifier") return;
-        const name = node.id.name;
-        if (!name) return;
-        const exported = node.parent.parent?.type === "ExportNamedDeclaration";
-        if (!exported) return;
-        if (isComponentLikeName(name) || isHookName2(name)) return;
+        if (!isNamed2(node.id.type === "Identifier" ? node.id : null, HELPER2)) return;
         const init = node.init;
-        if (!init || init.type !== "ArrowFunctionExpression" && init.type !== "FunctionExpression") {
-          return;
-        }
-        if (init.body.type === "BlockStatement" && hasHookUsage(init.body)) return;
-        report3(node, name);
+        if (init?.type !== "ArrowFunctionExpression" && init?.type !== "FunctionExpression") return;
+        check(init, parameterNames(init));
       }
     };
   }
 };
 
 // eslint/rules/hook-complexity.ts
-import path25 from "path";
-import ts4 from "typescript";
+import path30 from "path";
+import ts7 from "typescript";
 var REACT_HOOKS = /* @__PURE__ */ new Set([
   "useState",
   "useEffect",
@@ -2992,28 +3567,67 @@ var REACT_HOOKS = /* @__PURE__ */ new Set([
   "useSyncExternalStore",
   "useInsertionEffect"
 ]);
+var SUBSCRIPTION_METHODS = /* @__PURE__ */ new Set(["on", "off", "addEventListener", "removeEventListener"]);
+var STORAGE_OBJECTS = /* @__PURE__ */ new Set(["localStorage", "sessionStorage", "indexedDB"]);
+var DOM_METHODS = /* @__PURE__ */ new Set(["focus", "blur", "scrollIntoView", "click"]);
+var DOM_PROPERTIES = /* @__PURE__ */ new Set(["classList"]);
+var DOM_CONSTRUCTORS = /* @__PURE__ */ new Set(["MutationObserver", "ResizeObserver", "IntersectionObserver"]);
+var LIFECYCLE_METHODS = /* @__PURE__ */ new Set(["load", "destroy", "dispose", "close", "cleanup", "unmount"]);
 function isHookName3(name) {
   return /^use[A-Z]/.test(name);
 }
-function countImperativeCategories(body, sourceText) {
+function calledMethodName(node) {
+  return ts7.isPropertyAccessExpression(node.expression) ? node.expression.name.text : void 0;
+}
+function calledOnObjectName(node) {
+  if (!ts7.isPropertyAccessExpression(node.expression)) return void 0;
+  const object = node.expression.expression;
+  return ts7.isIdentifier(object) ? object.text : void 0;
+}
+function calledHookName(node) {
+  return ts7.isCallExpression(node) && ts7.isIdentifier(node.expression) && REACT_HOOKS.has(node.expression.text) ? node.expression.text : void 0;
+}
+function sideEffectCategoryOf(node) {
+  if (ts7.isAwaitExpression(node)) return "externalIO";
+  if (ts7.isNewExpression(node) && ts7.isIdentifier(node.expression) && DOM_CONSTRUCTORS.has(node.expression.text)) {
+    return "domManipulation";
+  }
+  if (ts7.isPropertyAccessExpression(node) && DOM_PROPERTIES.has(node.name.text)) {
+    return "domManipulation";
+  }
+  if (ts7.isCallExpression(node)) {
+    if (ts7.isIdentifier(node.expression) && node.expression.text === "fetch") return "externalIO";
+    const method = calledMethodName(node);
+    if (method && SUBSCRIPTION_METHODS.has(method)) return "subscription";
+    if (method && LIFECYCLE_METHODS.has(method)) return "lifecycle";
+    if (method && DOM_METHODS.has(method)) return "domManipulation";
+    const object = calledOnObjectName(node);
+    if (object && STORAGE_OBJECTS.has(object)) return "externalIO";
+  }
+  return void 0;
+}
+function computeExtractionScore(body, sourceText) {
   const start = body.range?.[0] ?? 0;
   const end = body.range?.[1] ?? sourceText.length;
-  const sourceFile = ts4.createSourceFile(
+  const sourceFile = ts7.createSourceFile(
     "hook.ts",
     sourceText.slice(start, end),
-    ts4.ScriptTarget.Latest,
+    ts7.ScriptTarget.Latest,
     true,
-    ts4.ScriptKind.TS
+    ts7.ScriptKind.TS
   );
-  const categories = /* @__PURE__ */ new Set();
+  const hookNames = /* @__PURE__ */ new Set();
+  const sideEffectCategories = /* @__PURE__ */ new Set();
   const visit = (node) => {
-    if (ts4.isCallExpression(node) && ts4.isIdentifier(node.expression) && REACT_HOOKS.has(node.expression.text)) {
-      categories.add(node.expression.text);
-    }
-    ts4.forEachChild(node, visit);
+    const hookName = calledHookName(node);
+    if (hookName) hookNames.add(hookName);
+    const sideEffect = sideEffectCategoryOf(node);
+    if (sideEffect) sideEffectCategories.add(sideEffect);
+    ts7.forEachChild(node, visit);
   };
   visit(sourceFile);
-  return categories.size;
+  const hookDiversityPoint = hookNames.size >= 2 ? 1 : 0;
+  return hookDiversityPoint + sideEffectCategories.size;
 }
 var hookComplexityRule = {
   meta: {
@@ -3026,26 +3640,26 @@ var hookComplexityRule = {
   create(context) {
     const filename = context.filename;
     const sourceRoot = sourceRootOf(context);
-    const relative = path25.relative(sourceRoot, filename);
+    const relative = path30.relative(sourceRoot, filename);
     if (relative.startsWith("..")) return {};
-    const segments = relative.split(path25.sep);
+    const segments = relative.split(path30.sep);
     const sourceText = context.sourceCode.text;
     function checkHook(node, name, body, exported) {
       if (!exported) return;
       if (!name || !isHookName3(name)) return;
       if (!body) return;
-      const imperativeCount = countImperativeCategories(body, sourceText);
+      const score = computeExtractionScore(body, sourceText);
       const parentFolder = segments.length >= 2 ? segments[segments.length - 2] : void 0;
       const inSupportFolder = parentFolder === "hooks";
-      if (imperativeCount >= 2 && !inSupportFolder) {
+      if (score >= 2 && !inSupportFolder) {
         context.report({
           node,
-          message: `Hook "${name}" has ${String(imperativeCount)} imperative categories and must be extracted to a hooks/ folder. See docs/next-codebase-guide/rules/hook-extraction-rule.md`
+          message: `Hook "${name}" has an extraction score of ${String(score)} and must be extracted to a hooks/ folder. See docs/next-codebase-guide/rules/hook-extraction-rule.md`
         });
-      } else if (imperativeCount < 2 && inSupportFolder) {
+      } else if (score < 2 && inSupportFolder) {
         context.report({
           node,
-          message: `Hook "${name}" has fewer than two imperative categories and must stay inline in its consumer file. See docs/next-codebase-guide/rules/hook-extraction-rule.md`
+          message: `Hook "${name}" has an extraction score below two and must stay inline in its consumer file. See docs/next-codebase-guide/rules/hook-extraction-rule.md`
         });
       }
     }
@@ -3070,9 +3684,9 @@ var hookComplexityRule = {
 };
 
 // eslint/rules/locale-dotted-path.ts
-import path26 from "path";
+import path31 from "path";
 function isInLocalesDir(filename) {
-  const segments = path26.resolve(filename).split(path26.sep);
+  const segments = path31.resolve(filename).split(path31.sep);
   const srcIdx = segments.lastIndexOf("src");
   return srcIdx !== -1 && segments[srcIdx + 1] === "locales";
 }
@@ -3121,9 +3735,9 @@ var localeDottedPathRule = {
 };
 
 // eslint/rules/locales-location.ts
-import path27 from "path";
+import path32 from "path";
 function isLocalesFile(filename) {
-  const segments = path27.resolve(filename).split(path27.sep);
+  const segments = path32.resolve(filename).split(path32.sep);
   const srcIdx = segments.lastIndexOf("src");
   return srcIdx !== -1 && segments[srcIdx + 1] === "locales";
 }
@@ -3148,7 +3762,7 @@ var localesLocationRule = {
   create(context) {
     if (isLocalesFile(context.filename) || isTestFile(context.filename)) return {};
     const filename = context.filename;
-    const segments = path27.resolve(filename).split(path27.sep);
+    const segments = path32.resolve(filename).split(path32.sep);
     const srcIdx = segments.lastIndexOf("src");
     if (srcIdx === -1) return {};
     const folder = segments[srcIdx + 1];
@@ -3172,7 +3786,7 @@ var localesLocationRule = {
 };
 
 // eslint/rules/hook-extraction.ts
-import path28 from "path";
+import path33 from "path";
 var hookExtractionRule = {
   meta: {
     schema: [],
@@ -3183,7 +3797,7 @@ var hookExtractionRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path28.resolve(context.filename);
+    const file = path33.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length === 0) return {};
     const index = getProjectIndex(sourceRoot);
@@ -3209,7 +3823,7 @@ var hookExtractionRule = {
 };
 
 // eslint/rules/value-extraction.ts
-import path29 from "path";
+import path34 from "path";
 var valueExtractionRule = {
   meta: {
     schema: [],
@@ -3220,7 +3834,7 @@ var valueExtractionRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path29.resolve(context.filename);
+    const file = path34.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length === 0 || segments[0] !== "app") return {};
     const index = getProjectIndex(sourceRoot);
@@ -3241,7 +3855,7 @@ var valueExtractionRule = {
 };
 
 // eslint/rules/config-extraction.ts
-import path30 from "path";
+import path35 from "path";
 var configExtractionRule = {
   meta: {
     schema: [],
@@ -3252,7 +3866,7 @@ var configExtractionRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path30.resolve(context.filename);
+    const file = path35.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length < 3 || segments[0] !== "config") return {};
     if (SUPPORT_FOLDERS2.has(segments[2] ?? "")) return {};
@@ -3290,7 +3904,7 @@ var configExtractionRule = {
 };
 
 // eslint/rules/component-nesting.ts
-import path31 from "path";
+import path36 from "path";
 var componentNestingRule = {
   meta: {
     schema: [],
@@ -3301,7 +3915,7 @@ var componentNestingRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path31.resolve(context.filename);
+    const file = path36.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length !== 4 || segments[0] !== "features") return {};
     const index = getProjectIndex(sourceRoot);
@@ -3334,7 +3948,7 @@ var componentNestingRule = {
 };
 
 // eslint/rules/stay-flat.ts
-import path32 from "path";
+import path37 from "path";
 var stayFlatRule = {
   meta: {
     schema: [],
@@ -3345,7 +3959,7 @@ var stayFlatRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path32.resolve(context.filename);
+    const file = path37.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length !== 3 || segments[0] !== "features") return {};
     const index = getProjectIndex(sourceRoot);
@@ -3385,7 +3999,7 @@ var stayFlatRule = {
 };
 
 // eslint/rules/type-extraction.ts
-import path33 from "path";
+import path38 from "path";
 var typeExtractionRule = {
   meta: {
     schema: [],
@@ -3396,7 +4010,7 @@ var typeExtractionRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path33.resolve(context.filename);
+    const file = path38.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length === 0) return {};
     const index = getProjectIndex(sourceRoot);
@@ -3442,9 +4056,9 @@ var typeExtractionRule = {
 };
 
 // eslint/rules/locale-placement.ts
-import path34 from "path";
-import { readFileSync as readFileSync4 } from "fs";
-import ts5 from "typescript";
+import path39 from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import ts8 from "typescript";
 var LOCALE_ACCESS = /\blocales\.(?<key>[A-Za-z_$][\w$]*)/g;
 var camelCase = (name) => name.replace(/-[a-z]/g, (match) => match.slice(1).toUpperCase());
 var FORCED_TOP_LEVEL = /* @__PURE__ */ new Set(["app", "shared", "compositions", "config"]);
@@ -3452,26 +4066,26 @@ function forcesTopLevel(segments) {
   return FORCED_TOP_LEVEL.has(segments[0] ?? "") || SUPPORT_FOLDERS2.has(segments[0] ?? "");
 }
 function localePlacement(text) {
-  const sourceFile = ts5.createSourceFile("locales.ts", text, ts5.ScriptTarget.Latest, true, ts5.ScriptKind.TS);
+  const sourceFile = ts8.createSourceFile("locales.ts", text, ts8.ScriptTarget.Latest, true, ts8.ScriptKind.TS);
   for (const statement of sourceFile.statements) {
-    if (!ts5.isVariableStatement(statement)) continue;
-    const isExported2 = (ts5.getModifiers(statement) ?? []).some(
-      (modifier) => modifier.kind === ts5.SyntaxKind.ExportKeyword
+    if (!ts8.isVariableStatement(statement)) continue;
+    const isExported2 = (ts8.getModifiers(statement) ?? []).some(
+      (modifier) => modifier.kind === ts8.SyntaxKind.ExportKeyword
     );
     if (!isExported2) continue;
     for (const declaration of statement.declarationList.declarations) {
-      if (!ts5.isIdentifier(declaration.name) || declaration.name.text !== "locales") continue;
-      if (!declaration.initializer || !ts5.isObjectLiteralExpression(declaration.initializer)) continue;
+      if (!ts8.isIdentifier(declaration.name) || declaration.name.text !== "locales") continue;
+      if (!declaration.initializer || !ts8.isObjectLiteralExpression(declaration.initializer)) continue;
       const placement = /* @__PURE__ */ new Map();
       for (const property of declaration.initializer.properties) {
-        if (!ts5.isPropertyAssignment(property)) continue;
+        if (!ts8.isPropertyAssignment(property)) continue;
         let name;
-        if (ts5.isIdentifier(property.name)) name = property.name.text;
-        else if (ts5.isStringLiteral(property.name)) name = property.name.text;
+        if (ts8.isIdentifier(property.name)) name = property.name.text;
+        else if (ts8.isStringLiteral(property.name)) name = property.name.text;
         if (name === void 0) continue;
         const line = sourceFile.getLineAndCharacterOfPosition(property.getStart(sourceFile)).line + 1;
         placement.set(name, {
-          kind: ts5.isObjectLiteralExpression(property.initializer) ? "nested" : "top",
+          kind: ts8.isObjectLiteralExpression(property.initializer) ? "nested" : "top",
           line
         });
       }
@@ -3490,7 +4104,7 @@ var localePlacementRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path34.resolve(context.filename);
+    const file = path39.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length === 0) return {};
     const index = getProjectIndex(sourceRoot);
@@ -3500,7 +4114,7 @@ var localePlacementRule = {
       return candidateSegments.length === 2 && candidateSegments[0] === "locales" && candidateSegments[1]?.startsWith("index.");
     });
     if (!localesFile || file !== localesFile) return {};
-    const placement = localePlacement(readFileSync4(localesFile, "utf8"));
+    const placement = localePlacement(readFileSync5(localesFile, "utf8"));
     if (!placement) return {};
     const keyReaders = /* @__PURE__ */ new Map();
     const keyFeatures = /* @__PURE__ */ new Map();
@@ -3512,7 +4126,7 @@ var localePlacementRule = {
       );
       if (!importsLocales) continue;
       const candidateSegments = segmentsOf(candidateFile, sourceRoot);
-      for (const match of readFileSync4(candidateFile, "utf8").matchAll(LOCALE_ACCESS)) {
+      for (const match of readFileSync5(candidateFile, "utf8").matchAll(LOCALE_ACCESS)) {
         const key = match.groups?.key;
         if (key === void 0) continue;
         const readers = keyReaders.get(key) ?? /* @__PURE__ */ new Set();
@@ -3568,39 +4182,39 @@ var localePlacementRule = {
 };
 
 // eslint/rules/sole-state-owner.ts
-import path35 from "path";
-import ts6 from "typescript";
+import path40 from "path";
+import ts9 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)) {
+    if (ts9.isCallExpression(child) && ts9.isIdentifier(child.expression) && child.expression.text === "useState") {
+      if (ts9.isVariableDeclaration(child.parent)) {
         const { name } = child.parent;
-        if (ts6.isArrayBindingPattern(name) && name.elements.length >= 2) {
+        if (ts9.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)) {
+          if (value && updater && ts9.isBindingElement(value) && ts9.isBindingElement(updater)) {
             const valueName = value.name;
             const updaterName = updater.name;
-            if (ts6.isIdentifier(valueName) && ts6.isIdentifier(updaterName)) {
+            if (ts9.isIdentifier(valueName) && ts9.isIdentifier(updaterName)) {
               hooks.push({ value: valueName.text, updater: updaterName.text });
             }
           }
         }
       }
     }
-    ts6.forEachChild(child, visit);
+    ts9.forEachChild(child, visit);
   };
   visit(node);
   return hooks;
 }
 function isHookUsage(node, hook) {
-  if (ts6.isCallExpression(node) && ts6.isIdentifier(node.expression) && node.expression.text === hook.updater) {
+  if (ts9.isCallExpression(node) && ts9.isIdentifier(node.expression) && node.expression.text === hook.updater) {
     return "updater";
   }
-  if (ts6.isIdentifier(node) && node.text === hook.value) {
+  if (ts9.isIdentifier(node) && node.text === hook.value) {
     const parent = node.parent;
-    if (ts6.isBindingElement(parent) || ts6.isPropertyAccessExpression(parent) || ts6.isShorthandPropertyAssignment(parent)) {
+    if (ts9.isBindingElement(parent) || ts9.isPropertyAccessExpression(parent) || ts9.isShorthandPropertyAssignment(parent)) {
       return void 0;
     }
     return "value";
@@ -3610,16 +4224,16 @@ function isHookUsage(node, hook) {
 function topLevelJsxChildren(initial) {
   if (!initial) return void 0;
   let expression = initial;
-  while (ts6.isParenthesizedExpression(expression)) expression = expression.expression;
-  if (ts6.isJsxFragment(expression)) {
+  while (ts9.isParenthesizedExpression(expression)) expression = expression.expression;
+  if (ts9.isJsxFragment(expression)) {
     const children = expression.children.filter(
-      (c) => !ts6.isJsxText(c) && !ts6.isJsxSpreadAttribute(c)
+      (c) => !ts9.isJsxText(c) && !ts9.isJsxSpreadAttribute(c)
     );
     return { root: expression, children };
   }
-  if (ts6.isJsxElement(expression)) {
+  if (ts9.isJsxElement(expression)) {
     const children = expression.children.filter(
-      (c) => !ts6.isJsxText(c) && !ts6.isJsxSpreadAttribute(c)
+      (c) => !ts9.isJsxText(c) && !ts9.isJsxSpreadAttribute(c)
     );
     return { root: expression, children };
   }
@@ -3633,8 +4247,8 @@ function collectUsesIn(child, hook) {
       positions.push(node);
       count += 1;
     }
-    if (ts6.isFunctionDeclaration(node) || ts6.isClassDeclaration(node)) return;
-    ts6.forEachChild(node, visit);
+    if (ts9.isFunctionDeclaration(node) || ts9.isClassDeclaration(node)) return;
+    ts9.forEachChild(node, visit);
   };
   visit(child);
   return { positions, count };
@@ -3648,7 +4262,7 @@ var soleStateOwnerRule = {
     }
   },
   create(context) {
-    const filename = path35.resolve(context.filename);
+    const filename = path40.resolve(context.filename);
     if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx")) return {};
     const text = context.sourceCode.text;
     const components = parseComponentInfo(text, filename);
@@ -3673,18 +4287,18 @@ var soleStateOwnerRule = {
   }
 };
 function analyzeSoleOwner(declaration, hook) {
-  const body = ts6.isFunctionDeclaration(declaration) ? declaration.body : void 0;
-  if (!body || !ts6.isBlock(body)) return void 0;
+  const body = ts9.isFunctionDeclaration(declaration) ? declaration.body : void 0;
+  if (!body || !ts9.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);
+    if (node !== body && (ts9.isFunctionLike(node) || ts9.isClassLike(node))) return;
+    if (ts9.isReturnStatement(node)) returns.push(node);
+    ts9.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;
+  if (!single?.expression || !ts9.isExpression(single.expression)) return void 0;
   const returnExpression = single.expression;
   const root = topLevelJsxChildren(returnExpression);
   if (!root || root.children.length === 0) return void 0;
@@ -3707,11 +4321,11 @@ 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 (node !== declaration && (ts9.isFunctionDeclaration(node) || ts9.isClassDeclaration(node))) return;
     if (isHookUsage(node, hook)) {
       let current = node;
       let isInJsxChild = false;
-      while (!ts6.isSourceFile(current)) {
+      while (!ts9.isSourceFile(current)) {
         if (children.includes(current)) {
           isInJsxChild = true;
           break;
@@ -3720,14 +4334,14 @@ function usesOutsideJsx(declaration, hook, children) {
       }
       if (!isInJsxChild) outside = true;
     }
-    ts6.forEachChild(node, visit);
+    ts9.forEachChild(node, visit);
   };
   visit(declaration);
   return outside;
 }
 
 // eslint/rules/locale-key-shape.ts
-import path36 from "path";
+import path41 from "path";
 var MAX_KEY_LENGTH = 30;
 var ROLE_POSTFIXES = /* @__PURE__ */ new Set([
   "Button",
@@ -3777,7 +4391,7 @@ var ROLE_POSTFIXES = /* @__PURE__ */ new Set([
 var CAMEL_CASE = /^[a-z][a-zA-Z0-9]*$/;
 var ENGLISH = /^[A-Za-z0-9_]*$/;
 function isLocalesFile2(filename) {
-  const segments = path36.resolve(filename).split(path36.sep);
+  const segments = path41.resolve(filename).split(path41.sep);
   const srcIdx = segments.lastIndexOf("src");
   return srcIdx !== -1 && segments[srcIdx + 1] === "locales";
 }
@@ -3848,8 +4462,8 @@ var localeKeyShapeRule = {
 };
 
 // eslint/rules/shared-style-dedup.ts
-import path37 from "path";
-import { readFileSync as readFileSync5, statSync as statSync3 } from "fs";
+import path42 from "path";
+import { readFileSync as readFileSync6, statSync as statSync3 } from "fs";
 var CLASS_NAME = /className="(?<classes>[^"]+)"/g;
 var comboCache;
 function combosFor(index) {
@@ -3863,7 +4477,7 @@ function combosFor(index) {
   }
   const combos = /* @__PURE__ */ new Map();
   for (const file of files) {
-    const text = readFileSync5(file, "utf8");
+    const text = readFileSync6(file, "utf8");
     for (const match of text.matchAll(CLASS_NAME)) {
       const classes = (match.groups?.classes ?? "").split(/\s+/).filter(Boolean);
       if (classes.length < 2) continue;
@@ -3886,7 +4500,7 @@ var sharedStyleDedupRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path37.resolve(context.filename);
+    const file = path42.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length === 0) return {};
     const index = getProjectIndex(sourceRoot);
@@ -4090,7 +4704,7 @@ var zodSchemaValidationRule = {
 };
 
 // eslint/rules/schema-casing.ts
-import path38 from "path";
+import path43 from "path";
 function isCamelCase(name) {
   return /^[a-z][a-zA-Z0-9]*$/.test(name);
 }
@@ -4118,9 +4732,9 @@ var schemaCasingRule = {
     }
   },
   create(context) {
-    const filename = path38.resolve(context.filename);
+    const filename = path43.resolve(context.filename);
     const sourceRoot = sourceRootOf(context);
-    if (!filename.startsWith(sourceRoot + path38.sep)) return {};
+    if (!filename.startsWith(sourceRoot + path43.sep)) return {};
     let zodLocalName;
     return {
       ImportDeclaration(node) {
@@ -4152,7 +4766,7 @@ var schemaCasingRule = {
 };
 
 // eslint/rules/component-casing.ts
-import path39 from "path";
+import path44 from "path";
 function isPascalCase6(name) {
   return /^[A-Z][A-Za-z0-9]*$/.test(name);
 }
@@ -4165,10 +4779,10 @@ var componentCasingRule = {
     }
   },
   create(context) {
-    const filename = path39.resolve(context.filename);
+    const filename = path44.resolve(context.filename);
     const sourceRoot = sourceRootOf(context);
-    if (!filename.startsWith(sourceRoot + path39.sep)) return {};
-    if (path39.extname(filename) !== ".tsx") return {};
+    if (!filename.startsWith(sourceRoot + path44.sep)) return {};
+    if (path44.extname(filename) !== ".tsx") return {};
     return {
       Program(node) {
         for (const declaration of findJsxReturningDeclarations(context.sourceCode.text, filename)) {
@@ -4185,7 +4799,7 @@ var componentCasingRule = {
 };
 
 // eslint/rules/source-under-src.ts
-import path40 from "path";
+import path45 from "path";
 var NON_SOURCE_ROOT_DIRS = /* @__PURE__ */ new Set([
   ".agents",
   ".cache",
@@ -4226,14 +4840,14 @@ var sourceUnderSrcRule = {
     }
   },
   create(context) {
-    const filename = path40.resolve(context.filename);
+    const filename = path45.resolve(context.filename);
     if (!MODULE_EXTENSION.test(filename)) return {};
-    const relative = path40.relative(context.cwd, filename).replace(/\\/g, "/");
+    const relative = path45.relative(context.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 = path40.basename(filename);
+      const basename = path45.basename(filename);
       if (CONFIG_FILE.test(basename) || DECLARATION_FILE.test(basename) || basename.startsWith(".")) return {};
     }
     return {
@@ -4250,8 +4864,8 @@ var sourceUnderSrcRule = {
 
 // eslint/rules/zirka-baseline.ts
 import fs5 from "fs";
-import path41 from "path";
-var ESLINT_CONFIG = /^eslint\.config\.(?:ts|mts|cts|js|mjs|cjs)$/;
+import path46 from "path";
+var ESLINT_CONFIG3 = /^eslint\.config\.(?:ts|mts|cts|js|mjs|cjs)$/;
 var PRETTIER_CONFIGS = [
   "prettier.config.mjs",
   "prettier.config.cjs",
@@ -4269,10 +4883,10 @@ var zirkaBaselineRule = {
     }
   },
   create(context) {
-    const filename = path41.resolve(context.filename);
-    const basename = path41.basename(filename);
-    if (!ESLINT_CONFIG.test(basename)) return {};
-    const projectRoot = path41.dirname(filename);
+    const filename = path46.resolve(context.filename);
+    const basename = path46.basename(filename);
+    if (!ESLINT_CONFIG3.test(basename)) return {};
+    const projectRoot = path46.dirname(filename);
     const report3 = (message) => {
       context.report({
         node: context.sourceCode.ast,
@@ -4287,7 +4901,7 @@ var zirkaBaselineRule = {
             'ESLint config must take its configuration from zirka (import { styleguide } from "zirka") instead of restating rules locally.'
           );
         }
-        const tsconfigPath = path41.join(projectRoot, "tsconfig.json");
+        const tsconfigPath = path46.join(projectRoot, "tsconfig.json");
         if (!fs5.existsSync(tsconfigPath)) {
           report3('No tsconfig.json found. Create one extending the zirka TypeScript base config ("zirka/typescript").');
         } else {
@@ -4305,13 +4919,13 @@ var zirkaBaselineRule = {
             report3('tsconfig.json must extend the zirka TypeScript base config ("zirka/typescript").');
           }
         }
-        const prettierConfigFile = PRETTIER_CONFIGS.find((name) => fs5.existsSync(path41.join(projectRoot, name)));
+        const prettierConfigFile = PRETTIER_CONFIGS.find((name) => fs5.existsSync(path46.join(projectRoot, name)));
         if (!prettierConfigFile) {
           report3(
             "No prettier config found. Create one that takes its configuration from zirka (styleguide({ prettier: true }).prettierConfig)."
           );
         } else {
-          const content = fs5.readFileSync(path41.join(projectRoot, prettierConfigFile), "utf8");
+          const content = fs5.readFileSync(path46.join(projectRoot, prettierConfigFile), "utf8");
           if (!content.includes("zirka")) {
             report3(
               "The prettier config must take its configuration from zirka (styleguide({ prettier: true }).prettierConfig) instead of restating it locally."
@@ -4353,6 +4967,15 @@ function getTextContent(node) {
 function getLine(node) {
   return node.position?.start.line ?? 0;
 }
+function linkTarget(url) {
+  return url.split("#")[0] ?? url;
+}
+function isDocLink(url) {
+  return linkTarget(url).endsWith(".md");
+}
+function headingAnchor(text) {
+  return text.trim().toLowerCase().replaceAll(/[^\p{L}\p{N}\s-]/gu, "").replaceAll(/\s+/g, "-");
+}
 
 // eslint/rules/documentation/doc-kind-suffix.ts
 var docKindSuffixRule = {
@@ -4381,7 +5004,7 @@ var docKindSuffixRule = {
 };
 
 // eslint/rules/documentation/title-matches-file-name.ts
-import path42 from "path";
+import path47 from "path";
 function toExpectedFileName(title) {
   return `${title.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "")}.md`;
 }
@@ -4401,7 +5024,7 @@ var titleMatchesFileNameRule = {
         if (!filename.endsWith(".md")) return;
         const title = getTextContent(node).trim();
         const expectedFileName = toExpectedFileName(title);
-        const actualFileName = path42.basename(filename);
+        const actualFileName = path47.basename(filename);
         if (!title) {
           context.report({
             node,
@@ -4556,7 +5179,7 @@ var guideStepSingleSentenceRule = {
 
 // eslint/rules/documentation/guide-step-single-link.ts
 function countDocLinks(node) {
-  if (node.type === "link" && node.url.endsWith(".md")) return 1;
+  if (node.type === "link" && isDocLink(node.url)) return 1;
   if ("children" in node) {
     return node.children.reduce((sum, child) => sum + countDocLinks(child), 0);
   }
@@ -4774,7 +5397,7 @@ var noCrossDocumentLinkRule = {
         const filename = getFilename(context);
         const kind = linkedKind(filename);
         if (!kind) return;
-        if (node.url.endsWith(".md")) {
+        if (isDocLink(node.url)) {
           context.report({
             node,
             message: `${kind} links another document: ${node.url}`
@@ -4842,22 +5465,46 @@ var referenceBlockHeadingsRule = {
   }
 };
 
+// eslint/rules/documentation/reference-max-heading-depth.ts
+var referenceMaxHeadingDepthRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Reference max heading depth rule.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      heading(node) {
+        const filename = getFilename(context);
+        if (!filename.endsWith("-reference.md")) return;
+        if (node.depth <= 2) return;
+        context.report({
+          node,
+          message: "reference heading is deeper than level 2; flatten it into the section it would nest under"
+        });
+      }
+    };
+  }
+};
+
 // eslint/rules/documentation/support-document-placement.ts
 import { existsSync as existsSync2 } from "fs";
-import path43 from "path";
+import path48 from "path";
 function checkPlacement(filename, kind) {
-  const parentFolder = path43.basename(path43.dirname(filename));
+  const parentFolder = path48.basename(path48.dirname(filename));
   const expectedParent = `${kind}s`;
   if (parentFolder !== expectedParent) {
     return `${kind} lives in "${parentFolder}/" instead of "${expectedParent}/"`;
   }
-  const guideFolderPath = path43.dirname(path43.dirname(filename));
-  const guideFolder = path43.basename(guideFolderPath);
+  const guideFolderPath = path48.dirname(path48.dirname(filename));
+  const guideFolder = path48.basename(guideFolderPath);
   if (!guideFolder.endsWith("-guide")) {
     return `${kind} owner folder "${guideFolder}/" does not use the "*-guide/" suffix`;
   }
   const entryPoint = `${guideFolder}.md`;
-  if (!existsSync2(path43.join(guideFolderPath, entryPoint))) {
+  if (!existsSync2(path48.join(guideFolderPath, entryPoint))) {
     return `${kind} owner folder "${guideFolder}/" has no "${entryPoint}" entry point`;
   }
   return void 0;
@@ -4916,11 +5563,11 @@ var noTemplatePromptRule = {
 };
 
 // eslint/rules/documentation/guide-folder-entry-point.ts
-import path45 from "path";
+import path50 from "path";
 
 // eslint/rules/documentation/project-index.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync6, statSync as statSync4 } from "fs";
-import path44 from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync7, statSync as statSync4 } from "fs";
+import path49 from "path";
 var KIND_BY_SUFFIX = [
   ["-rule.md", "rule"],
   ["-guide.md", "guide"],
@@ -4929,7 +5576,7 @@ var KIND_BY_SUFFIX = [
 ];
 function listMarkdownFiles(dir) {
   return readdirSync3(dir).flatMap((entry) => {
-    const entryPath = path44.join(dir, entry);
+    const entryPath = path49.join(dir, entry);
     if (statSync4(entryPath).isDirectory()) {
       return entry.startsWith("_") ? [] : listMarkdownFiles(entryPath);
     }
@@ -4937,7 +5584,7 @@ function listMarkdownFiles(dir) {
   });
 }
 function extractTitle(filePath) {
-  const content = readFileSync6(filePath, "utf8");
+  const content = readFileSync7(filePath, "utf8");
   const match = /^# (?<title>.+)$/m.exec(content);
   return match?.groups?.title?.trim() ?? "";
 }
@@ -4947,11 +5594,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 = path44.basename(filePath);
+    const fileName = path49.basename(filePath);
     const kind = KIND_BY_SUFFIX.find(([suffix]) => fileName.endsWith(suffix))?.[1];
     return {
       filePath,
-      doc: path44.relative(docsRoot, filePath).split(path44.sep).join("/"),
+      doc: path49.relative(docsRoot, filePath).split(path49.sep).join("/"),
       fileName,
       kind,
       title: extractTitle(filePath)
@@ -4961,12 +5608,12 @@ function getProjectDocs(docsRoot) {
   return docs;
 }
 function findDocsRoot(filePath) {
-  let dir = path44.dirname(filePath);
+  let dir = path49.dirname(filePath);
   for (; ; ) {
-    if (path44.basename(dir) === "docs" && statSync4(dir).isDirectory()) {
+    if (path49.basename(dir) === "docs" && statSync4(dir).isDirectory()) {
       return dir;
     }
-    const parent = path44.dirname(dir);
+    const parent = path49.dirname(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -4990,13 +5637,13 @@ var guideFolderEntryPointRule = {
         if (!docsRoot) return;
         const docs = getProjectDocs(docsRoot);
         const guideFolders = new Set(
-          docs.filter((doc) => ["rules", "references"].includes(path45.basename(path45.dirname(doc.filePath)))).map((doc) => path45.dirname(path45.dirname(doc.filePath))).filter((folder) => path45.resolve(folder) !== path45.resolve(docsRoot))
+          docs.filter((doc) => ["rules", "references"].includes(path50.basename(path50.dirname(doc.filePath)))).map((doc) => path50.dirname(path50.dirname(doc.filePath))).filter((folder) => path50.resolve(folder) !== path50.resolve(docsRoot))
         );
-        const currentDir = path45.dirname(filename);
+        const currentDir = path50.dirname(filename);
         if (guideFolders.has(currentDir)) {
-          const expectedEntryPoint = `${path45.basename(currentDir)}.md`;
+          const expectedEntryPoint = `${path50.basename(currentDir)}.md`;
           const hasEntryPoint = docs.some(
-            (doc) => doc.kind === "guide" && path45.dirname(doc.filePath) === currentDir && doc.fileName === expectedEntryPoint
+            (doc) => doc.kind === "guide" && path50.dirname(doc.filePath) === currentDir && doc.fileName === expectedEntryPoint
           );
           if (!hasEntryPoint) {
             context.report({
@@ -5140,6 +5787,8 @@ var policySubjectHeadingsRule = {
 };
 
 // eslint/rules/documentation/guide-link-anchors.ts
+import { existsSync as existsSync3, readFileSync as readFileSync8 } from "fs";
+import path51 from "path";
 function visitSteps2(node, check) {
   if (node.type === "list" && node.ordered) {
     for (const child of node.children) check(child);
@@ -5149,17 +5798,52 @@ function visitSteps2(node, check) {
   }
 }
 function collectGuideLinks(node) {
-  if (node.type === "link" && node.url.endsWith("-guide.md")) return [node];
+  if (node.type === "link" && linkTarget(node.url).endsWith("-guide.md")) return [node];
   if ("children" in node) {
     return node.children.flatMap(collectGuideLinks);
   }
   return [];
 }
+function collectLinks(node, out) {
+  if (node.type === "link") out.push(node);
+  if ("children" in node) {
+    for (const child of node.children) collectLinks(child, out);
+  }
+}
+var anchorsByFile = /* @__PURE__ */ new Map();
+function documentAnchors(filePath) {
+  const cached = anchorsByFile.get(filePath);
+  if (cached) return cached;
+  const anchors = /* @__PURE__ */ new Set();
+  anchorsByFile.set(filePath, anchors);
+  let content;
+  try {
+    content = readFileSync8(filePath, "utf8");
+  } catch {
+    return anchors;
+  }
+  const seen = /* @__PURE__ */ new Map();
+  let fenced = false;
+  for (const line of content.split("\n")) {
+    if (/^\s*(?:```|~~~)/.test(line)) {
+      fenced = !fenced;
+      continue;
+    }
+    if (fenced) continue;
+    const heading = /^#{1,6}\s+(?<text>.+)$/.exec(line)?.groups?.text;
+    if (!heading) continue;
+    const base = headingAnchor(heading);
+    const count = seen.get(base) ?? 0;
+    seen.set(base, count + 1);
+    anchors.add(count === 0 ? base : `${base}-${String(count)}`);
+  }
+  return anchors;
+}
 var guideLinkAnchorsRule = {
   meta: {
     type: "problem",
     docs: {
-      description: "A step that links another Guide must link directly to a How To section.",
+      description: "A step that links another Guide must link directly to a How To section, and a link that carries an anchor must point at a heading the linked document has.",
       recommended: true
     }
   },
@@ -5178,6 +5862,19 @@ var guideLinkAnchorsRule = {
             }
           }
         });
+        const links = [];
+        collectLinks(node, links);
+        for (const link of links) {
+          const [target = "", fragment = ""] = link.url.split("#");
+          if (!fragment || !isDocLink(link.url)) continue;
+          const targetPath = path51.resolve(path51.dirname(filename), target);
+          if (!existsSync3(targetPath)) continue;
+          if (documentAnchors(targetPath).has(fragment.toLowerCase())) continue;
+          context.report({
+            node: link,
+            message: `link ${link.url} points at a heading the document does not have`
+          });
+        }
       }
     };
   }
@@ -5220,41 +5917,82 @@ var noNestedHowToRule = {
 };
 
 // eslint/rules/documentation/glossary-term-linking.ts
-import { readFileSync as readFileSync7 } from "fs";
-import path46 from "path";
+import { readFileSync as readFileSync9 } from "fs";
+import path52 from "path";
+function isGlossary(filePath) {
+  return path52.basename(filePath).includes("glossary");
+}
+function termNames(cell) {
+  const abbreviation = /\((?<abbreviation>[^()]+)\)/.exec(cell)?.groups?.abbreviation?.trim();
+  return abbreviation ? [cell, abbreviation] : [cell];
+}
+function extractTableTerms(content) {
+  const terms = [];
+  const rowPattern = /^\|(?<cell>[^|]*)\|/gm;
+  for (const match of content.matchAll(rowPattern)) {
+    const cell = match.groups?.cell?.trim() ?? "";
+    if (!cell || /^:?-+:?$/.test(cell) || cell.toLowerCase() === "term") continue;
+    terms.push({ term: cell, names: termNames(cell) });
+  }
+  return terms;
+}
 function extractGlossaryTerms(filePath) {
-  const content = readFileSync7(filePath, "utf8");
+  if (!isGlossary(filePath)) return [];
+  const content = readFileSync9(filePath, "utf8");
+  const tableTerms = extractTableTerms(content);
+  if (tableTerms.length > 0) return tableTerms;
   const terms = [];
   const headingPattern = /^## (?<term>.+)$/gm;
-  let match;
-  while ((match = headingPattern.exec(content)) !== null) {
+  for (const match of content.matchAll(headingPattern)) {
     const term = match.groups?.term?.trim();
-    if (term) terms.push(term);
+    if (term) terms.push({ term, names: termNames(term) });
   }
   return terms;
 }
-function collectSteps(node) {
-  const texts = [];
-  const firstStepLinks = [];
-  if (node.type === "list" && node.ordered) {
-    for (const item of node.children) {
-      texts.push(getTextContent(item));
-      if (firstStepLinks.length === 0) {
-        collectDocLinks(item, firstStepLinks);
-      }
+function extractBlockHeadings(filePath) {
+  const headings = [];
+  let fenced = false;
+  for (const line of readFileSync9(filePath, "utf8").split("\n")) {
+    if (/^\s*(?:```|~~~)/.test(line)) {
+      fenced = !fenced;
+      continue;
     }
+    if (fenced) continue;
+    const heading = /^##\s+(?<text>.+)$/.exec(line)?.groups?.text;
+    if (heading) headings.push(heading.trim());
   }
-  if ("children" in node) {
-    for (const child of node.children) {
-      const nested = collectSteps(child);
-      texts.push(...nested.texts);
-      if (firstStepLinks.length === 0) firstStepLinks.push(...nested.firstStepLinks);
-    }
+  return headings;
+}
+function normalize(text) {
+  return text.replaceAll("`", "").toLowerCase();
+}
+function collectSections(node) {
+  const sections = [];
+  const children = node.children;
+  for (const [index, child] of children.entries()) {
+    if (child.type !== "heading" || child.depth !== 2) continue;
+    const title = getTextContent(child).trim();
+    if (!/^How To \S/.test(title)) continue;
+    const end = children.findIndex(
+      (sibling, siblingIndex) => siblingIndex > index && sibling.type === "heading" && sibling.depth === 2
+    );
+    const section = { heading: child, title, stepTexts: [], firstStepLinks: [] };
+    collectSteps(children.slice(index + 1, end === -1 ? children.length : end), section);
+    sections.push(section);
+  }
+  return sections;
+}
+function collectSteps(content, section) {
+  const lists = content.filter((node) => node.type === "list");
+  const paragraphs = content.filter((node) => node.type === "paragraph");
+  const steps = lists.length > 0 ? lists.flatMap((list) => list.children) : paragraphs.slice(content[0]?.type === "paragraph" ? 1 : 0);
+  for (const step of steps) {
+    section.stepTexts.push(getTextContent(step));
+    if (section.stepTexts.length === 1) collectDocLinks(step, section.firstStepLinks);
   }
-  return { texts, firstStepLinks };
 }
 function collectDocLinks(node, out) {
-  if (node.type === "link" && node.url.endsWith(".md")) out.push(node.url);
+  if (node.type === "link" && isDocLink(node.url)) out.push(node.url);
   if ("children" in node) {
     for (const child of node.children) collectDocLinks(child, out);
   }
@@ -5263,7 +6001,7 @@ var glossaryTermLinkingRule = {
   meta: {
     type: "problem",
     docs: {
-      description: "A Guide whose steps use glossary terms must link that Reference from its first step.",
+      description: "A How To section whose steps use glossary terms must link that Reference from the first step, and every block of a shared glossary must be read by one of them.",
       recommended: true
     }
   },
@@ -5275,25 +6013,55 @@ var glossaryTermLinkingRule = {
         const docsRoot = findDocsRoot(filename);
         if (!docsRoot) return;
         const docs = getProjectDocs(docsRoot);
-        const guideDir = path46.dirname(filename);
+        const guideDir = path52.dirname(filename);
+        const referencesDir = path52.join(guideDir, "references");
         const guideReferences = docs.filter(
-          (doc) => doc.kind === "reference" && path46.dirname(doc.filePath) === guideDir
+          (doc) => doc.kind === "reference" && path52.dirname(doc.filePath) === referencesDir
         );
-        if (guideReferences.length === 0) return;
+        const glossaryReferences = guideReferences.filter((doc) => isGlossary(doc.filePath));
+        if (glossaryReferences.length === 0) return;
         const glossaryTerms = [];
-        for (const ref of guideReferences) {
+        for (const ref of glossaryReferences) {
           glossaryTerms.push(...extractGlossaryTerms(ref.filePath));
         }
         if (glossaryTerms.length === 0) return;
-        const { texts: stepTexts, firstStepLinks } = collectSteps(node);
-        const usedTerms = glossaryTerms.filter((term) => stepTexts.some((text) => text.includes(term)));
-        if (usedTerms.length === 0) return;
-        const hasRefLink = firstStepLinks.some((link) => guideReferences.some((ref) => link.includes(ref.fileName)));
-        if (!hasRefLink) {
-          context.report({
-            node,
-            message: `guide uses glossary terms (${usedTerms.join(", ")}) but first step does not link the reference`
-          });
+        const sections = collectSections(node);
+        for (const ref of glossaryReferences) {
+          for (const heading of extractBlockHeadings(ref.filePath)) {
+            const anchor = headingAnchor(heading);
+            const anchored = sections.some(
+              (section) => section.firstStepLinks.some((link) => {
+                const fragment = link.split("#")[1] ?? "";
+                if (fragment.toLowerCase() !== anchor) return false;
+                return path52.resolve(guideDir, linkTarget(link)) === path52.resolve(ref.filePath);
+              })
+            );
+            if (!anchored) {
+              context.report({
+                node,
+                message: `shared glossary block "${heading}" is not read by any How To section's first step`
+              });
+            }
+          }
+        }
+        for (const section of sections) {
+          const normalizedStepTexts = section.stepTexts.map(normalize);
+          const usedTerms = glossaryTerms.filter(
+            (entry) => entry.names.some((name) => {
+              const needle = normalize(name);
+              return normalizedStepTexts.some((text) => text.includes(needle));
+            })
+          ).map((entry) => entry.term);
+          if (usedTerms.length === 0) continue;
+          const hasGlossaryLink = section.firstStepLinks.some(
+            (link) => glossaryReferences.some((ref) => link.includes(ref.fileName))
+          );
+          if (!hasGlossaryLink) {
+            context.report({
+              node: section.heading,
+              message: `guide section "${section.title}" uses glossary terms (${usedTerms.join(", ")}) but its first step does not link the glossary reference`
+            });
+          }
         }
       }
     };
@@ -5301,8 +6069,8 @@ var glossaryTermLinkingRule = {
 };
 
 // eslint/rules/documentation/guide-mentions-documents.ts
-import { existsSync as existsSync3 } from "fs";
-import path47 from "path";
+import { existsSync as existsSync4 } from "fs";
+import path53 from "path";
 function visitSteps3(node, check) {
   if (node.type === "list" && node.ordered) {
     for (const child of node.children) check(child);
@@ -5312,14 +6080,11 @@ function visitSteps3(node, check) {
   }
 }
 function collectMarkdownLinks(node, out) {
-  if (node.type === "link" && node.url.endsWith(".md")) out.push(node);
+  if (node.type === "link" && isDocLink(node.url)) out.push(node);
   if ("children" in node) {
     for (const child of node.children) collectMarkdownLinks(child, out);
   }
 }
-function linkTarget(url) {
-  return url.split("#")[0] ?? url;
-}
 var guideMentionsDocumentsRule = {
   meta: {
     type: "problem",
@@ -5335,12 +6100,12 @@ var guideMentionsDocumentsRule = {
         if (!filename.endsWith("-guide.md")) return;
         const docsRoot = findDocsRoot(filename);
         if (!docsRoot) return;
-        const guideDir = path47.dirname(filename);
-        if (path47.basename(filename, ".md") !== path47.basename(guideDir)) return;
+        const guideDir = path53.dirname(filename);
+        if (path53.basename(filename, ".md") !== path53.basename(guideDir)) return;
         const docs = getProjectDocs(docsRoot);
         const owned = docs.filter((doc) => {
-          const parent = path47.dirname(doc.filePath);
-          return parent === path47.join(guideDir, "rules") || parent === path47.join(guideDir, "references");
+          const parent = path53.dirname(doc.filePath);
+          return parent === path53.join(guideDir, "rules") || parent === path53.join(guideDir, "references");
         });
         const allLinks = [];
         collectMarkdownLinks(node, allLinks);
@@ -5348,7 +6113,7 @@ var guideMentionsDocumentsRule = {
         visitSteps3(node, (item) => {
           collectMarkdownLinks(item, stepLinks);
         });
-        const mentionsOf = (links, fileName) => links.some((link) => link.url.split("/").pop() === fileName);
+        const mentionsOf = (links, fileName) => links.some((link) => linkTarget(link.url).split("/").pop() === fileName);
         for (const doc of owned) {
           if (doc.kind === "rule") {
             if (!mentionsOf(stepLinks, doc.fileName)) {
@@ -5367,8 +6132,8 @@ var guideMentionsDocumentsRule = {
         for (const link of allLinks) {
           const target = linkTarget(link.url);
           if (!target.endsWith(".md")) continue;
-          const resolved = path47.normalize(path47.join(guideDir, target));
-          if (!existsSync3(resolved)) {
+          const resolved = path53.normalize(path53.join(guideDir, target));
+          if (!existsSync4(resolved)) {
             context.report({
               node: link,
               message: `Guide links a document that does not exist: ${link.url}`
@@ -5445,6 +6210,7 @@ var documentationRules = {
   "no-cross-document-link": noCrossDocumentLinkRule,
   "reference-no-rfc-vocabulary": referenceNoRfcVocabularyRule,
   "reference-block-headings": referenceBlockHeadingsRule,
+  "reference-max-heading-depth": referenceMaxHeadingDepthRule,
   "support-document-placement": supportDocumentPlacementRule,
   "no-template-prompt": noTemplatePromptRule,
   "guide-folder-entry-point": guideFolderEntryPointRule,
@@ -5917,11 +6683,11 @@ var themeVariableNamespaceRule = {
 
 // eslint/rules/tailwind/css-entry-point.ts
 import { statSync as statSync6 } from "fs";
-import path50 from "path";
+import path56 from "path";
 
 // eslint/rules/tailwind/source-files.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync8, statSync as statSync5 } from "fs";
-import path48 from "path";
+import { readdirSync as readdirSync4, readFileSync as readFileSync10, statSync as statSync5 } from "fs";
+import path54 from "path";
 var CSS_EXTENSIONS = [".css"];
 var MODULE_EXTENSIONS3 = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
 var SOURCE_EXTENSIONS = [...MODULE_EXTENSIONS3, ...CSS_EXTENSIONS];
@@ -5934,7 +6700,7 @@ function findFiles(dir, extensions) {
   }
   return entries.flatMap((entry) => {
     if (entry.startsWith(".") || entry === "node_modules") return [];
-    const entryPath = path48.join(dir, entry);
+    const entryPath = path54.join(dir, entry);
     let stats;
     try {
       stats = statSync5(entryPath);
@@ -5942,7 +6708,7 @@ function findFiles(dir, extensions) {
       return [];
     }
     if (stats.isDirectory()) return findFiles(entryPath, extensions);
-    return extensions.includes(path48.extname(entry)) ? [entryPath] : [];
+    return extensions.includes(path54.extname(entry)) ? [entryPath] : [];
   });
 }
 function cachedTextReader() {
@@ -5951,7 +6717,7 @@ function cachedTextReader() {
     let text = texts.get(file);
     if (text === void 0) {
       try {
-        text = readFileSync8(file, "utf8");
+        text = readFileSync10(file, "utf8");
       } catch {
         text = "";
       }
@@ -5965,7 +6731,7 @@ function escapeRegExp(text) {
 }
 
 // eslint/rules/tailwind/stylesheet-graph.ts
-import path49 from "path";
+import path55 from "path";
 function registersTailwind(text) {
   return /@import\s+(?:url\(\s*)?["']tailwindcss["']\s*\)?/i.test(text);
 }
@@ -5979,25 +6745,25 @@ function moduleImports(text, fileName) {
   return new RegExp(`(?:import|require)\\s*\\(?\\s*["'][^"']*${escaped}["']`, "i").test(text);
 }
 function resolveSpecifier2(fromFile, spec, sourceRoot) {
-  if (spec.startsWith("/")) return path49.resolve(spec);
-  if (spec.startsWith("./") || spec.startsWith("../")) return path49.resolve(path49.dirname(fromFile), spec);
-  if (spec.startsWith("@/")) return path49.resolve(sourceRoot, spec.slice(2));
+  if (spec.startsWith("/")) return path55.resolve(spec);
+  if (spec.startsWith("./") || spec.startsWith("../")) return path55.resolve(path55.dirname(fromFile), spec);
+  if (spec.startsWith("@/")) return path55.resolve(sourceRoot, spec.slice(2));
   return void 0;
 }
 function buildStylesheetGraph(options) {
   const { cssFiles, sourceRoot, textOf } = options;
-  const cssSet = new Set(cssFiles.map((file) => path49.normalize(file)));
+  const cssSet = new Set(cssFiles.map((file) => path55.normalize(file)));
   const globals = cssFiles.filter((file) => registersTailwind(textOf(file)));
   const reachable = /* @__PURE__ */ new Set();
   const queue = [...globals];
-  for (const global of globals) reachable.add(path49.normalize(global));
+  for (const global of globals) reachable.add(path55.normalize(global));
   while (queue.length > 0) {
     const from = queue.shift();
     if (!from) continue;
     for (const spec of importedSpecifiers(textOf(from))) {
       const target = resolveSpecifier2(from, spec, sourceRoot);
       if (!target) continue;
-      const normalized = path49.normalize(target);
+      const normalized = path55.normalize(target);
       if (cssSet.has(normalized) && !reachable.has(normalized)) {
         reachable.add(normalized);
         queue.push(normalized);
@@ -6009,7 +6775,7 @@ function buildStylesheetGraph(options) {
     for (const spec of importedSpecifiers(textOf(global))) {
       const target = resolveSpecifier2(global, spec, sourceRoot);
       if (!target) continue;
-      const normalized = path49.normalize(target);
+      const normalized = path55.normalize(target);
       if (cssSet.has(normalized)) directChildren.add(normalized);
     }
   }
@@ -6042,7 +6808,7 @@ var cssEntryPointRule = {
     return {
       "StyleSheet:exit"(node) {
         if (globals.length === 0) return;
-        const current = path50.normalize(path50.resolve(context.filename));
+        const current = path56.normalize(path56.resolve(context.filename));
         if (globals.includes(current)) {
           if (globals.length > 1) {
             context.report({
@@ -6051,7 +6817,7 @@ var cssEntryPointRule = {
             });
             return;
           }
-          const basename = path50.basename(current);
+          const basename = path56.basename(current);
           const importCount = moduleFiles.filter((modulePath) => moduleImports(textOf(modulePath), basename)).length;
           if (importCount !== 1) {
             context.report({
@@ -6379,8 +7145,8 @@ var nextjsStackRule = {
 };
 
 // eslint/rules/package-json/vitest-coverage.ts
-import { existsSync as existsSync4, readFileSync as readFileSync9 } from "fs";
-import path51 from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync11 } from "fs";
+import path57 from "path";
 function memberName4(member) {
   return member.name.type === "String" ? member.name.value : member.name.name;
 }
@@ -6449,7 +7215,7 @@ var vitestCoverageRule = {
             message: 'package.json must declare a "test:unit:coverage" script that runs Vitest with coverage.'
           });
         }
-        const configName = VITEST_CONFIG_NAMES.find((name) => existsSync4(path51.join(context.cwd, name)));
+        const configName = VITEST_CONFIG_NAMES.find((name) => existsSync5(path57.join(context.cwd, name)));
         if (!configName) {
           context.report({
             node,
@@ -6457,7 +7223,7 @@ var vitestCoverageRule = {
           });
           return;
         }
-        const content = readFileSync9(path51.join(context.cwd, configName), "utf8");
+        const content = readFileSync11(path57.join(context.cwd, configName), "utf8");
         for (const metric of THRESHOLD_METRICS) {
           if (!new RegExp(`\\b${metric}\\s*:\\s*[1-9]\\d*`).test(content)) {
             context.report({ node, message: `${configName} must set a coverage threshold above zero for ${metric}.` });
@@ -6503,8 +7269,8 @@ var nextjsPackageJsonRules = {
 };
 
 // eslint/rules/husky/husky-hook.ts
-import { existsSync as existsSync5, readFileSync as readFileSync10 } from "fs";
-import path52 from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync12 } from "fs";
+import path58 from "path";
 var VITEST_CONFIG_NAMES2 = [
   "vitest.config.ts",
   "vitest.config.mts",
@@ -6530,15 +7296,15 @@ var huskyHookRule = {
         const root = node.body;
         if (root.type !== "Object") return;
         if (!context.filename.endsWith("package.json")) return;
-        const hookPath = path52.join(context.cwd, ".husky", "pre-commit");
-        if (!existsSync5(hookPath)) {
+        const hookPath = path58.join(context.cwd, ".husky", "pre-commit");
+        if (!existsSync6(hookPath)) {
           context.report({
             node,
             message: "No .husky/pre-commit hook found. Configure husky to run checks before commits."
           });
           return;
         }
-        const content = readFileSync10(hookPath, "utf8");
+        const content = readFileSync12(hookPath, "utf8");
         const scripts = root.members.find((member) => memberName5(member) === "scripts");
         const scriptNames = new Set(scripts?.value.type === "Object" ? scripts.value.members.map(memberName5) : []);
         const requireNamedScript = (name) => {
@@ -6554,7 +7320,7 @@ var huskyHookRule = {
         }
         requireNamedScript("typecheck");
         requireNamedScript("test:unit:coverage");
-        const vitestConfigName = VITEST_CONFIG_NAMES2.find((name) => existsSync5(path52.join(context.cwd, name)));
+        const vitestConfigName = VITEST_CONFIG_NAMES2.find((name) => existsSync6(path58.join(context.cwd, name)));
         if (vitestConfigName !== void 0) {
           const coverageIndex = content.indexOf("npm run test:unit:coverage");
           const localAddIndex = content.indexOf(`git add ${vitestConfigName}`);
@@ -6568,8 +7334,8 @@ var huskyHookRule = {
         if (!content.includes("libyear --limit-major-individual=1")) {
           context.report({ node, message: ".husky/pre-commit must run npx libyear --limit-major-individual=1." });
         }
-        const suppressionsPath = path52.join(context.cwd, "eslint-suppressions.json");
-        if (existsSync5(suppressionsPath)) {
+        const suppressionsPath = path58.join(context.cwd, "eslint-suppressions.json");
+        if (existsSync6(suppressionsPath)) {
           requireNamedScript("lint:prune");
           const pruneIndex = content.indexOf("npm run lint:prune");
           const localAddIndex = content.indexOf("git add eslint-suppressions.json");
@@ -6599,73 +7365,33 @@ var huskyRules = {
   "husky-hook": huskyHookRule
 };
 
-// eslint/rules/vulyk/vulyk-dependency.ts
-function memberName6(member) {
-  return member.name.type === "String" ? member.name.value : member.name.name;
-}
-function dependency(root, sectionName) {
-  if (root.type !== "Object") return void 0;
-  const section = root.members.find((member) => memberName6(member) === sectionName);
-  if (section?.value.type !== "Object") return void 0;
-  return section.value.members.find((member) => memberName6(member) === "vulyk");
-}
-var vulykDependencyRule = {
-  meta: {
-    schema: [],
-    type: "problem",
-    docs: {
-      description: "Require vulyk in devDependencies so its typed config and CLI use the pinned package."
-    }
-  },
-  create(context) {
-    return {
-      Document(node) {
-        const runtimeDependency = dependency(node.body, "dependencies");
-        const developmentDependency = dependency(node.body, "devDependencies");
-        if (runtimeDependency) {
-          context.report({
-            node: runtimeDependency,
-            message: "vulyk must be listed in devDependencies, not dependencies."
-          });
-        }
-        if (!developmentDependency && !runtimeDependency) {
-          context.report({
-            node,
-            message: "vulyk must be listed in package.json as a devDependency."
-          });
-        }
-      }
-    };
-  }
-};
-
-// eslint/rules/vulyk/vulyk-docs.ts
-import { existsSync as existsSync6, readFileSync as readFileSync11 } from "fs";
-import path53 from "path";
+// eslint/rules/vulyk/tracked-docs.ts
+import { existsSync as existsSync7, readFileSync as readFileSync13 } from "fs";
+import path59 from "path";
 var PASIKA_REPO = "Bredansky/pasika";
-var BASE_REQUIRED_DOCS = [
+var BASE_REQUIRED_TRACKED_DOCS = [
   { name: "documentation-guide", path: "docs/documentation-guide" },
   { name: "pasika-adoption-guide", path: "docs/pasika-adoption-guide" },
   { name: "repository-policy", path: "docs/repository-policy.md" }
 ];
-var NEXTJS_REQUIRED_DOCS = [
+var NEXTJS_REQUIRED_TRACKED_DOCS = [
   { name: "next-codebase-guide", path: "docs/next-codebase-guide" },
   { name: "next-tailwind-guide", path: "docs/next-tailwind-guide" }
 ];
-function memberName7(member) {
+function memberName6(member) {
   return member.name.type === "String" ? member.name.value : member.name.name;
 }
 function hasDependency(root, name) {
-  const section = root.members.find((member) => memberName7(member) === "dependencies");
+  const section = root.members.find((member) => memberName6(member) === "dependencies");
   if (section?.value.type !== "Object") return false;
-  return section.value.members.some((member) => memberName7(member) === name);
+  return section.value.members.some((member) => memberName6(member) === name);
 }
-var vulykDocsRule = {
+var trackedDocsRule = {
   meta: {
     schema: [],
     type: "problem",
     docs: {
-      description: "Require vulyk.config.ts to track the framework's required docs from pasika and the generated AGENTS.md."
+      description: "Require vulyk.config.ts to track the framework's required tracked docs from pasika and the generated AGENTS.md."
     }
   },
   create(context) {
@@ -6674,34 +7400,34 @@ var vulykDocsRule = {
         if (!context.filename.endsWith("package.json")) return;
         const root = node.body;
         if (root.type !== "Object") return;
-        const projectRoot = path53.dirname(path53.resolve(context.filename));
-        const configPath = path53.join(projectRoot, "vulyk.config.ts");
-        if (!existsSync6(configPath)) {
+        const projectRoot = path59.dirname(path59.resolve(context.filename));
+        const configPath = path59.join(projectRoot, "vulyk.config.ts");
+        if (!existsSync7(configPath)) {
           context.report({
             node,
-            message: "No vulyk.config.ts found. Run npx vulyk init to create one that tracks the framework's docs."
+            message: "No vulyk.config.ts found. Run npx vulyk init to create one that tracks the framework's required tracked docs."
           });
           return;
         }
-        const config = readFileSync11(configPath, "utf8");
+        const config = readFileSync13(configPath, "utf8");
         if (!config.includes(PASIKA_REPO)) {
           context.report({
             node,
-            message: "vulyk.config.ts must track the framework's docs from the pasika repository."
+            message: "vulyk.config.ts must track the framework's required tracked docs from the pasika repository."
           });
           return;
         }
-        const requiredDocs = hasDependency(root, "next") ? [...BASE_REQUIRED_DOCS, ...NEXTJS_REQUIRED_DOCS] : BASE_REQUIRED_DOCS;
-        for (const doc of requiredDocs) {
-          if (!config.includes(doc.path)) {
+        const requiredTrackedDocs = hasDependency(root, "next") ? [...BASE_REQUIRED_TRACKED_DOCS, ...NEXTJS_REQUIRED_TRACKED_DOCS] : BASE_REQUIRED_TRACKED_DOCS;
+        for (const trackedDoc of requiredTrackedDocs) {
+          if (!config.includes(trackedDoc.path)) {
             context.report({
               node,
-              message: `vulyk.config.ts must track the framework's ${doc.name} docs from pasika (${PASIKA_REPO}/${doc.path}).`
+              message: `vulyk.config.ts must track the framework's ${trackedDoc.name} tracked docs from pasika (${PASIKA_REPO}/${trackedDoc.path}).`
             });
           }
         }
-        const agentsPath = path53.join(projectRoot, "AGENTS.md");
-        if (!existsSync6(agentsPath)) {
+        const agentsPath = path59.join(projectRoot, "AGENTS.md");
+        if (!existsSync7(agentsPath)) {
           context.report({
             node,
             message: "No AGENTS.md found. Run npx vulyk agents to generate the agent file that routes to the tracked docs."
@@ -6712,10 +7438,50 @@ var vulykDocsRule = {
   }
 };
 
+// eslint/rules/vulyk/vulyk-dependency.ts
+function memberName7(member) {
+  return member.name.type === "String" ? member.name.value : member.name.name;
+}
+function dependency(root, sectionName) {
+  if (root.type !== "Object") return void 0;
+  const section = root.members.find((member) => memberName7(member) === sectionName);
+  if (section?.value.type !== "Object") return void 0;
+  return section.value.members.find((member) => memberName7(member) === "vulyk");
+}
+var vulykDependencyRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require vulyk in devDependencies so its typed config and CLI use the pinned package."
+    }
+  },
+  create(context) {
+    return {
+      Document(node) {
+        const runtimeDependency = dependency(node.body, "dependencies");
+        const developmentDependency = dependency(node.body, "devDependencies");
+        if (runtimeDependency) {
+          context.report({
+            node: runtimeDependency,
+            message: "vulyk must be listed in devDependencies, not dependencies."
+          });
+        }
+        if (!developmentDependency && !runtimeDependency) {
+          context.report({
+            node,
+            message: "vulyk must be listed in package.json as a devDependency."
+          });
+        }
+      }
+    };
+  }
+};
+
 // eslint/rules/vulyk/index.ts
 var vulykRules = {
   "vulyk-dependency": vulykDependencyRule,
-  "vulyk-docs": vulykDocsRule
+  "tracked-docs": trackedDocsRule
 };
 
 // eslint/index.ts
@@ -6757,6 +7523,10 @@ var pasikaNextjsAppRules = {
   "cva-boolean-variants": cvaBooleanVariantsRule,
   "cross-feature-import": crossFeatureImportRule,
   "pure-function-extract": pureFunctionExtractRule,
+  "root-support-placement": rootSupportPlacementRule,
+  "route-handler-shape": routeHandlerShapeRule,
+  "http-error-usage": httpErrorUsageRule,
+  "with-response-helper": withResponseHelperRule,
   "hook-complexity": hookComplexityRule,
   "locale-dotted-path": localeDottedPathRule,
   "locales-location": localesLocationRule,
@@ -6861,6 +7631,11 @@ var zirkaConfig = {
   plugins: { pasika: pasikaPlugin },
   rules: { "pasika/zirka-baseline": "error" }
 };
+var nextjsHelperConfig = {
+  files: ["eslint.config.{ts,mts,cts,js,mjs,cjs}"],
+  plugins: { pasika: pasikaPlugin },
+  rules: { "pasika/cn-helper": "error", "pasika/with-response-helper": "error" }
+};
 var documentationConfig = {
   files: ["docs/**/*.md"],
   // vulyk-generated agent files are not authored docs: with per-directory
@@ -6890,6 +7665,7 @@ var pasikaNextjsAppWithDiagnostic = (preset) => {
 var pasikaNextjsApp = pasikaNextjsAppWithDiagnostic([
   ...pasikaApp,
   pasikaNextjsAppPackageJsonConfig,
+  nextjsHelperConfig,
   pasikaNextjsAppConfig,
   tailwindStructureRules,
   tailwindImportGraph