pasika 0.10.100 → 0.10.102

package/dist/eslint/pasika/index.js

@@ -38,8 +38,8 @@ function memberPropertyName(node) {
   }
   return void 0;
 }
-function importedContractMember(expression, propertyName5, imports) {
-  if (expression?.type !== "MemberExpression" || memberPropertyName(expression) !== propertyName5 || expression.object.type !== "Identifier" || !imports.has(expression.object.name)) {
+function importedContractMember(expression, propertyName6, imports) {
+  if (expression?.type !== "MemberExpression" || memberPropertyName(expression) !== propertyName6 || expression.object.type !== "Identifier" || !imports.has(expression.object.name)) {
     return void 0;
   }
   return expression.object.name;
@@ -1878,8 +1878,8 @@ function collectSections(node) {
 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) {
+  const steps2 = lists.length > 0 ? lists.flatMap((list) => list.children) : paragraphs.slice(content[0]?.type === "paragraph" ? 1 : 0);
+  for (const step of steps2) {
     section.stepTexts.push(getTextContent(step));
     if (section.stepTexts.length === 1) collectDocLinks(step, section.firstStepLinks);
   }
@@ -2316,11 +2316,11 @@ var guideStepSingleSentenceRule = {
         if (!filename.endsWith("-guide.md")) return;
         if (!listsOnPath.at(-1)?.ordered) return;
         const text = getTextContent(node).trim();
-        const sentenceCount = countSentences(text);
-        if (sentenceCount > 1) {
+        const sentenceCount2 = countSentences(text);
+        if (sentenceCount2 > 1) {
           context.report({
             node,
-            message: `step uses ${String(sentenceCount)} sentences`
+            message: `step uses ${String(sentenceCount2)} sentences`
           });
         }
       }
@@ -2453,7 +2453,7 @@ var overviewRule = {
           }
         }
         if (!titleLine) return;
-        let sentenceCount = 0;
+        let sentenceCount2 = 0;
         let found = false;
         for (const child of node.children) {
           if (child.type === "heading" && getLine(child) > titleLine) break;
@@ -2467,11 +2467,11 @@ var overviewRule = {
               message: "overview links another document"
             });
           }
-          sentenceCount += countSentences2(text);
-          if (sentenceCount > 2) {
+          sentenceCount2 += countSentences2(text);
+          if (sentenceCount2 > 2) {
             context.report({
               node: child,
-              message: `overview uses ${String(sentenceCount)} sentences, at most two are allowed`
+              message: `overview uses ${String(sentenceCount2)} sentences, at most two are allowed`
             });
             break;
           }
@@ -2822,6 +2822,43 @@ var rulePairedExamplesRule = {
             message: `Rule level-2 heading must be an Incorrect/Correct example: ${text}`
           });
         }
+        const firstExampleIndex = node.children.findIndex((child) => child.type === "heading" && child.depth === 2);
+        const requirementsIndex = node.children.findIndex(
+          (child, index) => index < firstExampleIndex && child.type === "list" && !child.ordered
+        );
+        if (requirementsIndex !== -1) {
+          const requirements = node.children[requirementsIndex];
+          if (requirements?.type === "list" && requirements.spread) {
+            context.report({
+              node: requirements,
+              message: "Rule requirement bullets must form one uninterrupted list without blank lines"
+            });
+          }
+          for (const child of node.children.slice(requirementsIndex + 1, firstExampleIndex)) {
+            context.report({
+              node: child,
+              message: "Rule requirements must be followed directly by the first Incorrect/Correct example"
+            });
+          }
+        }
+        let inExample = false;
+        let afterWhy = false;
+        for (const child of node.children) {
+          if (child.type === "heading" && child.depth === 2) {
+            inExample = true;
+            afterWhy = false;
+            continue;
+          }
+          if (!inExample) continue;
+          if (afterWhy) {
+            context.report({
+              node: child,
+              message: "A Why explanation must be the final block of its example"
+            });
+          } else if (child.type === "paragraph" && getTextContent(child).trim().startsWith("Why:")) {
+            afterWhy = true;
+          }
+        }
         const incorrect = exampleHeadings.filter((h) => h.text.startsWith("Incorrect"));
         const correct = exampleHeadings.filter((h) => h.text.startsWith("Correct"));
         if (incorrect.length === 0 || incorrect.length !== correct.length) {
@@ -2922,6 +2959,38 @@ var titleMatchesFileNameRule = {
   }
 };
 
+// eslint/rules/documentation/why-sentence-limit.ts
+var MAX_SENTENCES = 2;
+function sentenceCount(text) {
+  const normalized = text.replace(/\b(?:e\.g|i\.e)\./gi, (match) => match.replaceAll(".", ""));
+  return normalized.split(/[.!?]+["'’”\])]*(?:\s+|$)/).filter((part) => part.trim().length > 0).length;
+}
+var whySentenceLimitRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Why explanations in Rules may use at most two sentences.",
+      recommended: true
+    }
+  },
+  create(context) {
+    return {
+      paragraph(node) {
+        if (!getFilename(context).endsWith("-rule.md")) return;
+        const text = node.children.map((child) => child.type === "inlineCode" ? "code" : getTextContent(child)).join("").trim();
+        if (!text.startsWith("Why:")) return;
+        const count = sentenceCount(text.slice("Why:".length).trim());
+        if (count > MAX_SENTENCES) {
+          context.report({
+            node,
+            message: `Why explanation has ${String(count)} sentences; maximum is ${String(MAX_SENTENCES)}.`
+          });
+        }
+      }
+    };
+  }
+};
+
 // eslint/rules/documentation/index.ts
 var documentationRules = {
   "doc-kind-suffix": docKindSuffixRule,
@@ -2932,6 +3001,7 @@ var documentationRules = {
   "guide-states-no-requirement": guideStatesNoRequirementRule,
   "requirement-present": requirementPresentRule,
   "rule-paired-examples": rulePairedExamplesRule,
+  "why-sentence-limit": whySentenceLimitRule,
   "example-heading-description": exampleHeadingDescriptionRule,
   "policy-no-examples": policyNoExamplesRule,
   "no-cross-document-link": noCrossDocumentLinkRule,
@@ -3832,6 +3902,7 @@ var huskyHookRule = {
           return;
         }
         const content = readFileSync6(hookPath, "utf8");
+        const commands = content.replace(/^[ \t]*#[^\r\n]*$/gm, "");
         const scripts = root.members.find((member) => memberName(member) === "scripts");
         const scriptNames = new Set(scripts?.value.type === "Object" ? scripts.value.members.map(memberName) : []);
         const requireNamedScript = (name) => {
@@ -3847,6 +3918,37 @@ var huskyHookRule = {
         }
         requireNamedScript("typecheck");
         requireNamedScript("test:unit:coverage");
+        const autoStageAll = /^\s*git\s+add\s+(?:--\s+)?(?:-A|--all|-u|\.)(?:\s*(?:#.*)?)?$/m.test(commands);
+        const coverageIndex = commands.indexOf("npm run test:unit:coverage");
+        const coverageGuards = /if\s+!\s+git\s+diff\s+--quiet\s+--\s+vitest\.config\.ts\s*;\s*then[\s\S]*?\bexit\s+1\b[\s\S]*?\bfi\b|git\s+diff\s+--exit-code\s+--\s+vitest\.config\.ts\s*\|\|\s*exit\s+1\b/g;
+        const hasCoverageGuard = [...commands.matchAll(coverageGuards)].some((match) => match.index > coverageIndex);
+        if (coverageIndex >= 0 && !hasCoverageGuard) {
+          context.report({
+            node,
+            message: ".husky/pre-commit must reject unstaged vitest.config.ts changes after coverage."
+          });
+        }
+        if (autoStageAll || /\bgit\s+add\s+(?:--\s+)?vitest\.config\.ts\b/.test(commands)) {
+          context.report({ node, message: ".husky/pre-commit must not auto-stage vitest.config.ts." });
+        }
+        if (existsSync4(path30.join(context.cwd, "vulyk.config.ts"))) {
+          const syncIndex = commands.search(/\bnpx\s+vulyk\s+sync\b/);
+          const agentsIndex = commands.search(/\bnpx\s+vulyk\s+agents\b/);
+          const stagedIndex = commands.indexOf("lint-staged");
+          if (syncIndex < 0 || agentsIndex <= syncIndex || stagedIndex <= agentsIndex) {
+            context.report({
+              node,
+              message: ".husky/pre-commit must run npx vulyk sync and npx vulyk agents before lint-staged."
+            });
+          }
+          const stageIndex = commands.search(/\bnpx\s+vulyk\s+stage\b/);
+          if (stageIndex <= agentsIndex || stageIndex >= stagedIndex) {
+            context.report({
+              node,
+              message: ".husky/pre-commit must run npx vulyk stage after agents and before lint-staged."
+            });
+          }
+        }
         if (!content.includes("libyear --limit-major-individual=1")) {
           context.report({ node, message: ".husky/pre-commit must run npx libyear --limit-major-individual=1." });
         }
@@ -4442,7 +4544,7 @@ var localeDottedPathRule = {
     schema: [],
     type: "problem",
     docs: {
-      description: "Require reading namespaced locales through their full dotted path."
+      description: "Require direct global and feature locale access without destructuring."
     }
   },
   create(context) {
@@ -4463,7 +4565,7 @@ var localeDottedPathRule = {
           if (valueName) {
             context.report({
               node,
-              message: `Destructuring locales.${valueName} loses the namespace; read through the full dotted path instead.`
+              message: `Destructuring locales.${valueName} hides its key path; access locales directly instead.`
             });
           }
         }
@@ -4522,10 +4624,15 @@ var ROLE_POSTFIXES = /* @__PURE__ */ new Set([
 ]);
 var CAMEL_CASE = /^[a-z][a-zA-Z0-9]*$/;
 var ENGLISH = /^[A-Za-z0-9_]*$/;
-function isLocalesFile(filename) {
+function dictionaryName(filename) {
   const segments = path35.resolve(filename).split(path35.sep);
   const srcIdx = segments.lastIndexOf("src");
-  return srcIdx !== -1 && segments[srcIdx + 1] === "locales";
+  if (srcIdx < 0 || segments[srcIdx + 1] !== "locales") return void 0;
+  const remaining = segments.slice(srcIdx + 2);
+  if (remaining.length === 1 && remaining[0] !== "index.ts" && /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*\.ts$/.test(remaining[0] ?? "")) {
+    return remaining[0]?.slice(0, -3).replace(/-[a-z]/g, (match) => match.slice(1).toUpperCase());
+  }
+  return void 0;
 }
 function keyName(key) {
   if (key.type === "Identifier") return key.name;
@@ -4582,31 +4689,28 @@ var localeKeyShapeRule = {
     }
   },
   create(context) {
-    if (!isLocalesFile(context.filename)) return {};
-    function visitObject(node, namespace) {
+    const dictionary = dictionaryName(context.filename) ?? "";
+    if (!dictionary) return {};
+    function visitObject(node) {
       for (const property of node.properties) {
         if (property.type !== "Property") continue;
         const name = keyName(property.key);
         if (name === void 0) continue;
         const nested = localeObject(property.value);
         if (nested) {
-          if (namespace !== void 0) {
-            reportFor(
-              context,
-              property,
-              `Locale "${namespace}.${name}" must not be a nested object. Keep string keys directly inside the "${namespace}" feature namespace. See docs/next-codebase-guide/rules/locales-rule.md`
-            );
-          } else {
-            visitObject(nested, name);
-          }
-        } else if (property.value.type === "Literal" && typeof property.value.value === "string") {
+          reportFor(
+            context,
+            property,
+            `Locale "${dictionary}.${name}" must not be a nested object. Keep string keys directly inside the "${dictionary}" namespace. See docs/next-codebase-guide/rules/locales-rule.md`
+          );
+        } else if (property.value.type === "Literal" && typeof property.value.value === "string" || property.value.type === "TemplateLiteral" && property.value.expressions.length === 0) {
           checkKey(context, property, name);
         }
       }
     }
     return {
       VariableDeclarator(node) {
-        if (node.id.type !== "Identifier" || node.id.name !== "locales") return;
+        if (node.id.type !== "Identifier" || node.id.name !== dictionary) return;
         const root = localeObject(node.init);
         if (!root) return;
         visitObject(root);
@@ -4616,135 +4720,307 @@ var localeKeyShapeRule = {
 };
 
 // eslint/rules/locale-placement.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
+import path37 from "path";
+import ts7 from "typescript";
+
+// eslint/rules/locale-definitions.ts
+import { existsSync as existsSync5, readFileSync as readFileSync7, readdirSync as readdirSync3 } from "fs";
 import path36 from "path";
 import ts6 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"]);
-function forcesTopLevel(segments) {
-  return FORCED_TOP_LEVEL.has(segments[0] ?? "") || SUPPORT_FOLDERS.has(segments[0] ?? "");
+function unwrap(expression) {
+  if (ts6.isAsExpression(expression) || ts6.isSatisfiesExpression(expression) || ts6.isParenthesizedExpression(expression)) {
+    return unwrap(expression.expression);
+  }
+  return expression;
 }
-function localePlacement(text) {
-  const sourceFile = ts6.createSourceFile("locales.ts", text, ts6.ScriptTarget.Latest, true, ts6.ScriptKind.TS);
-  for (const statement of sourceFile.statements) {
+function exportedDictionary(source, name) {
+  for (const statement of source.statements) {
     if (!ts6.isVariableStatement(statement)) continue;
-    const isExported3 = (ts6.getModifiers(statement) ?? []).some(
+    const exported = (ts6.getModifiers(statement) ?? []).some(
       (modifier) => modifier.kind === ts6.SyntaxKind.ExportKeyword
     );
-    if (!isExported3) continue;
+    if (!exported || !(statement.declarationList.flags & ts6.NodeFlags.Const)) continue;
+    if (statement.declarationList.declarations.length !== 1) continue;
     for (const declaration of statement.declarationList.declarations) {
-      if (!ts6.isIdentifier(declaration.name) || declaration.name.text !== "locales") continue;
-      if (!declaration.initializer || !ts6.isObjectLiteralExpression(declaration.initializer)) continue;
-      const placement = /* @__PURE__ */ new Map();
-      for (const property of declaration.initializer.properties) {
-        if (!ts6.isPropertyAssignment(property)) continue;
-        let name;
-        if (ts6.isIdentifier(property.name)) name = property.name.text;
-        else if (ts6.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: ts6.isObjectLiteralExpression(property.initializer) ? "nested" : "top",
-          line
-        });
+      if (ts6.isIdentifier(declaration.name) && declaration.name.text === name && declaration.initializer) {
+        const value = unwrap(declaration.initializer);
+        if (ts6.isObjectLiteralExpression(value)) return value;
       }
-      return placement;
     }
   }
   return void 0;
 }
+function propertyName2(property) {
+  if (ts6.isIdentifier(property) || ts6.isStringLiteral(property)) return property.text;
+  return void 0;
+}
+function expectedPath(localesRoot, namespace) {
+  const kebab = namespace.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+  return path36.join(localesRoot, `${kebab}.ts`);
+}
+function validateDictionary(file, namespace, errors) {
+  const values = /* @__PURE__ */ new Map();
+  if (!existsSync5(file)) {
+    errors.push(`Missing locale dictionary for ${namespace}.`);
+    return values;
+  }
+  const source = ts6.createSourceFile(file, readFileSync7(file, "utf8"), ts6.ScriptTarget.Latest, true, ts6.ScriptKind.TS);
+  const dictionary = exportedDictionary(source, namespace);
+  if (!dictionary || source.statements.length !== 1) {
+    errors.push(`Locale module ${file} must contain only an exported const ${namespace} string dictionary.`);
+    return values;
+  }
+  for (const property of dictionary.properties) {
+    if (!ts6.isPropertyAssignment(property)) {
+      errors.push(`Locale dictionary ${namespace} must use explicit string properties.`);
+      continue;
+    }
+    const name = propertyName2(property.name);
+    const value = unwrap(property.initializer);
+    if (!name || !/^[a-z][a-zA-Z0-9]*$/.test(name) || values.has(name) || !ts6.isStringLiteral(value) && !ts6.isNoSubstitutionTemplateLiteral(value)) {
+      errors.push(`Locale dictionary ${namespace} has an invalid, duplicate, or non-string key.`);
+      continue;
+    }
+    values.set(name, value.text);
+  }
+  return values;
+}
+function readLocaleDefinitions(indexFile) {
+  const definitions = /* @__PURE__ */ new Map();
+  const errors = [];
+  const root = path36.dirname(indexFile);
+  const source = ts6.createSourceFile(
+    indexFile,
+    readFileSync7(indexFile, "utf8"),
+    ts6.ScriptTarget.Latest,
+    true,
+    ts6.ScriptKind.TS
+  );
+  const imports = /* @__PURE__ */ new Map();
+  for (const statement of source.statements) {
+    if (ts6.isImportDeclaration(statement) && ts6.isStringLiteral(statement.moduleSpecifier)) {
+      const named = statement.importClause?.namedBindings;
+      if (!named || !ts6.isNamedImports(named)) {
+        errors.push("Locale index imports must use named imports.");
+        continue;
+      }
+      for (const element of named.elements) {
+        if (element.propertyName || imports.has(element.name.text)) {
+          errors.push("Locale index must import dictionaries by their original names without aliases.");
+        }
+        imports.set(element.name.text, statement.moduleSpecifier.text);
+      }
+    } else if (!ts6.isVariableStatement(statement)) {
+      errors.push("Locale index may contain only imports and the exported locales dictionary.");
+    }
+  }
+  const dictionary = exportedDictionary(source, "locales");
+  if (!dictionary || source.statements.filter(ts6.isVariableStatement).length !== 1) {
+    errors.push("Locale index must export a single const locales dictionary.");
+    return { definitions, errors };
+  }
+  for (const property of dictionary.properties) {
+    let name;
+    let value;
+    if (ts6.isSpreadAssignment(property)) {
+      if (!ts6.isIdentifier(property.expression) || property.expression.text !== "global") {
+        errors.push("Locale index may only spread the global dictionary.");
+        continue;
+      }
+      name = "global";
+      value = "global";
+    } else if (ts6.isShorthandPropertyAssignment(property)) {
+      name = property.name.text;
+      value = name;
+    } else if (ts6.isPropertyAssignment(property)) {
+      name = propertyName2(property.name);
+      const initial = unwrap(property.initializer);
+      if (ts6.isIdentifier(initial)) value = initial.text;
+    }
+    if (!name || !value || name !== value || definitions.has(name) || !/^[a-z][a-zA-Z0-9]*$/.test(name)) {
+      errors.push("Locale index must expose feature dictionaries by name and spread only global, without aliases.");
+      continue;
+    }
+    if (name === "global" && !ts6.isSpreadAssignment(property)) {
+      errors.push("Locale index must spread global keys into the top level.");
+      continue;
+    }
+    if (name === "shared" || name === "compositions") {
+      errors.push(`Locale namespace ${name} must not be used as a catch-all dictionary.`);
+      continue;
+    }
+    const expected = expectedPath(root, name);
+    const actualImport = imports.get(name);
+    if (!actualImport || path36.resolve(root, actualImport + (path36.extname(actualImport) ? "" : ".ts")) !== expected) {
+      errors.push(`Locale namespace ${name} must import its dictionary from ${path36.relative(root, expected)}.`);
+      continue;
+    }
+    const values = validateDictionary(expected, name, errors);
+    definitions.set(name, { namespace: name, file: expected, keys: new Set(values.keys()), values });
+  }
+  if (!definitions.has("global")) {
+    errors.push("Locale index must spread the global dictionary.");
+  }
+  for (const imported of imports.keys()) {
+    if (!definitions.has(imported)) {
+      errors.push(`Imported locale dictionary ${imported} is not exposed in locales.`);
+    }
+  }
+  for (const entry of readdirSync3(root, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      errors.push(
+        `Locale dictionaries must live directly in src/locales/; nested folder ${entry.name} is not allowed.`
+      );
+    } else if (entry.isFile() && entry.name.endsWith(".ts") && entry.name !== "index.ts" && !entry.name.endsWith(".test.ts") && !entry.name.endsWith(".d.ts")) {
+      const name = camelCase(entry.name.slice(0, -3));
+      if (!definitions.has(name) && !imports.has(name)) {
+        errors.push(`Locale module ${entry.name} is not exposed in locales.`);
+      }
+    }
+  }
+  const global = definitions.get("global");
+  if (global) {
+    for (const key of global.keys) {
+      if (definitions.has(key)) {
+        errors.push(`Global locale key ${key} conflicts with a feature namespace.`);
+      }
+    }
+  }
+  return { definitions, errors };
+}
+
+// eslint/rules/locale-placement.ts
+var DOC4 = "See docs/next-codebase-guide/rules/locales-rule.md";
+function localeAccesses(file) {
+  const contents = readFileSync8(file, "utf8");
+  const kind = /\.[jt]sx$/.test(file) ? ts7.ScriptKind.TSX : ts7.ScriptKind.TS;
+  const source = ts7.createSourceFile(file, contents, ts7.ScriptTarget.Latest, true, kind);
+  const accesses = [];
+  const visit = (node) => {
+    if (ts7.isPropertyAccessExpression(node)) {
+      const receiver = node.expression;
+      if (ts7.isPropertyAccessExpression(receiver) && ts7.isIdentifier(receiver.expression) && receiver.expression.text === "locales") {
+        accesses.push({ namespace: receiver.name.text, key: node.name.text });
+      } else if (ts7.isIdentifier(receiver) && receiver.text === "locales" && !(ts7.isPropertyAccessExpression(node.parent) && node.parent.expression === node)) {
+        accesses.push({ namespace: node.name.text });
+      }
+    }
+    ts7.forEachChild(node, visit);
+  };
+  visit(source);
+  return accesses;
+}
 var localePlacementRule = {
   meta: {
     schema: [],
     type: "problem",
     docs: {
-      description: "Require shared locales at the top level and single-feature locales in a namespaced object."
+      description: "Enforce locale placement from consumer folders, with cross-scope strings in global."
     }
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path36.resolve(context.filename);
+    const file = path37.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length === 0) return {};
     const index = getProjectIndex(sourceRoot);
     if (!index) return {};
     const localesFile = [...index.modules.keys()].find((candidate) => {
-      const candidateSegments = segmentsOf(candidate, sourceRoot);
-      return candidateSegments.length === 2 && candidateSegments[0] === "locales" && candidateSegments[1]?.startsWith("index.");
+      const parts = segmentsOf(candidate, sourceRoot);
+      return parts.length === 2 && parts[0] === "locales" && parts[1] === "index.ts";
     });
     if (!localesFile || file !== localesFile) return {};
-    const placement = localePlacement(readFileSync7(localesFile, "utf8"));
-    if (!placement) return {};
-    const keyReaders = /* @__PURE__ */ new Map();
-    const keyFeatures = /* @__PURE__ */ new Map();
-    const keyForcedTopLevel = /* @__PURE__ */ new Set();
+    const { definitions, errors } = readLocaleDefinitions(localesFile);
+    const findings = [...errors];
+    const globalKeys = definitions.get("global")?.keys;
+    const consumers = /* @__PURE__ */ new Map();
     for (const [candidateFile, module] of index.modules) {
       if (candidateFile === localesFile) continue;
+      const candidateSegments = segmentsOf(candidateFile, sourceRoot);
+      if (candidateSegments[0] !== "locales") {
+        const bypassesIndex = module.imports.some((moduleImport) => {
+          const resolved = resolveSpecifier(candidateFile, moduleImport.specifier, sourceRoot);
+          if (!resolved) return false;
+          const target = segmentsOf(resolved, sourceRoot);
+          return target[0] === "locales" && target.length > 1 && target[1] !== "index.ts";
+        });
+        if (bypassesIndex) findings.push(`Locale dictionaries must be imported through src/locales/index.ts. ${DOC4}`);
+      }
       const importsLocales = module.imports.some(
         (moduleImport) => resolveSpecifier(candidateFile, moduleImport.specifier, sourceRoot) === localesFile
       );
       if (!importsLocales) continue;
-      const candidateSegments = segmentsOf(candidateFile, sourceRoot);
-      for (const match of readFileSync7(candidateFile, "utf8").matchAll(LOCALE_ACCESS)) {
-        const key = match.groups?.key;
-        if (key === void 0) continue;
-        const readers = keyReaders.get(key) ?? /* @__PURE__ */ new Set();
-        readers.add(candidateFile);
-        keyReaders.set(key, readers);
-        if (candidateSegments[0] === "features" && candidateSegments.length >= 2) {
-          const features = keyFeatures.get(key) ?? /* @__PURE__ */ new Set();
-          features.add(candidateSegments[1] ?? "");
-          keyFeatures.set(key, features);
-        } else if (forcesTopLevel(candidateSegments)) {
-          keyForcedTopLevel.add(key);
+      for (const { namespace, key } of localeAccesses(candidateFile)) {
+        if (key) {
+          if (!definitions.get(namespace)?.keys.has(key) || namespace === "global") {
+            findings.push(`Locale locales.${namespace}.${key} is not defined in a feature dictionary. ${DOC4}`);
+          }
+        } else if (definitions.has(namespace)) {
+          findings.push(`Locale access locales.${namespace} must include a feature key. ${DOC4}`);
+        } else if (!globalKeys?.has(namespace)) {
+          findings.push(`Locale locales.${namespace} is not defined in the global dictionary. ${DOC4}`);
+        }
+        const access = key ? `${namespace}.${key}` : `global.${namespace}`;
+        const used = consumers.get(access) ?? /* @__PURE__ */ new Set();
+        used.add(candidateFile);
+        consumers.set(access, used);
+      }
+    }
+    for (const [namespace, definition] of definitions) {
+      const folder = namespace.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+      for (const key of definition.keys) {
+        const used = [...consumers.get(`${namespace}.${key}`) ?? []];
+        if (used.length === 0) continue;
+        const featureOf2 = (candidate) => {
+          const parts = segmentsOf(candidate, sourceRoot);
+          return parts[0] === "features" ? parts[1] : void 0;
+        };
+        if (namespace === "global") {
+          const features = new Set(used.map(featureOf2));
+          const feature = [...features][0];
+          if (features.size === 1 && feature !== void 0) {
+            findings.push(
+              `Locale locales.${key} is consumed only by src/features/${feature}/; move it into that feature dictionary. ${DOC4}`
+            );
+          }
+        } else if (used.some((candidate) => featureOf2(candidate) !== folder)) {
+          findings.push(
+            `Locale locales.${namespace}.${key} is used outside src/features/${folder}/; move it into global. ${DOC4}`
+          );
         }
       }
     }
-    const findings = [];
-    for (const [key, readers] of keyReaders) {
-      const features = keyFeatures.get(key) ?? /* @__PURE__ */ new Set();
-      const shared = features.size > 1 || keyForcedTopLevel.has(key);
-      const current = placement.get(key);
-      if (shared) {
-        if (current?.kind === "nested") {
-          findings.push({
-            line: current.line,
-            message: `Locale "${key}" is read by ${describeConsumers([...readers], sourceRoot)} and must live at the top level of locales. See docs/next-codebase-guide/rules/locales-rule.md`
-          });
-        }
-        continue;
+    const translations = /* @__PURE__ */ new Map();
+    for (const [namespace, definition] of definitions) {
+      for (const [key, value] of definition.values) {
+        const entries = translations.get(value) ?? /* @__PURE__ */ new Set();
+        entries.add(`${namespace}.${key}`);
+        translations.set(value, entries);
       }
-      if (features.size !== 1) continue;
-      const featureName = [...features][0] ?? "";
-      const expected = camelCase(featureName);
-      if (current?.kind === "top") {
-        findings.push({
-          line: current.line,
-          message: `Locale "${key}" is read only by the ${featureName} feature; it must live in an object named "${expected}". See docs/next-codebase-guide/rules/locales-rule.md`
-        });
-      } else if (current?.kind === "nested" && key !== expected) {
-        findings.push({
-          line: current.line,
-          message: `Locale "${key}" is read only by the ${featureName} feature; it must live in an object named "${expected}", not "${key}". See docs/next-codebase-guide/rules/locales-rule.md`
-        });
+    }
+    for (const [value, entries] of translations) {
+      const namespaces = new Set([...entries].map((entry) => entry.split(".")[0]));
+      if (namespaces.size > 1) {
+        findings.push(
+          `Locale text ${JSON.stringify(value)} is duplicated across dictionaries (${[...entries].join(", ")}); reuse one global key. ${DOC4}`
+        );
       }
     }
     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 });
-        }
+        for (const message of findings) context.report({ node, message });
       }
     };
   }
 };
 
 // eslint/rules/locales-location.ts
-import path37 from "path";
-function isLocalesFile2(filename) {
-  const segments = path37.resolve(filename).split(path37.sep);
+import path38 from "path";
+function isLocalesFile(filename) {
+  const segments = path38.resolve(filename).split(path38.sep);
   const srcIdx = segments.lastIndexOf("src");
   return srcIdx !== -1 && segments[srcIdx + 1] === "locales";
 }
@@ -4822,9 +5098,9 @@ var localesLocationRule = {
     }
   },
   create(context) {
-    if (isLocalesFile2(context.filename) || isTestFile(context.filename)) return {};
+    if (isLocalesFile(context.filename) || isTestFile(context.filename)) return {};
     const filename = context.filename;
-    const segments = path37.resolve(filename).split(path37.sep);
+    const segments = path38.resolve(filename).split(path38.sep);
     const srcIdx = segments.lastIndexOf("src");
     if (srcIdx === -1) return {};
     const folder = segments[srcIdx + 1];
@@ -4909,7 +5185,7 @@ var localesLocationRule = {
 };
 
 // eslint/rules/named-exports.ts
-import path38 from "path";
+import path39 from "path";
 var FRAMEWORK_DEFAULT_EXPORT_FILES = /* @__PURE__ */ new Set([
   // App Router routing files
   "default",
@@ -4931,9 +5207,9 @@ var FRAMEWORK_DEFAULT_EXPORT_FILES = /* @__PURE__ */ new Set([
   "twitter-image"
 ]);
 function isFrameworkDefaultExportFile(filename) {
-  const normalized = filename.replaceAll(path38.sep, "/");
+  const normalized = filename.replaceAll(path39.sep, "/");
   if (!normalized.includes("/src/app/")) return false;
-  const basename = path38.basename(filename, path38.extname(filename));
+  const basename = path39.basename(filename, path39.extname(filename));
   return FRAMEWORK_DEFAULT_EXPORT_FILES.has(basename);
 }
 var namedExportsRule = {
@@ -5101,12 +5377,12 @@ var noArbitraryTailwindRule = {
 };
 
 // eslint/rules/no-inline-runtime-literal.ts
-import path40 from "path";
+import path41 from "path";
 
 // eslint/project/semantic-literals.ts
-import { readFileSync as readFileSync8 } from "fs";
-import path39 from "path";
-import ts7 from "typescript";
+import { readFileSync as readFileSync9 } from "fs";
+import path40 from "path";
+import ts8 from "typescript";
 var excludedProperties = /* @__PURE__ */ new Set([
   "label",
   "title",
@@ -5144,33 +5420,33 @@ var columnMethods = /* @__PURE__ */ new Set([
 var eventMethods = /* @__PURE__ */ new Set(["emit", "on", "off", "once", "addListener", "removeListener"]);
 var ignoredNumbers = /* @__PURE__ */ new Set([-1, 0, 1]);
 function isProductionSource(file, root) {
-  const parts = path39.relative(root, file).split(path39.sep);
-  return !(/\.(?:test|spec|mock)\.[^.]+$/.test(path39.basename(file)) || parts.some((part) => part === "__tests__" || part === "__mocks__" || part === "mocks"));
+  const parts = path40.relative(root, file).split(path40.sep);
+  return !(/\.(?:test|spec|mock)\.[^.]+$/.test(path40.basename(file)) || parts.some((part) => part === "__tests__" || part === "__mocks__" || part === "mocks"));
 }
 function featureOf(file, root) {
-  const parts = path39.relative(root, file).split(path39.sep);
+  const parts = path40.relative(root, file).split(path40.sep);
   if (parts[0] === "features" && parts[1]) return `feature:${parts[1]}`;
   return `layer:${parts[0] ?? "src"}`;
 }
 function nameOf(property) {
-  if (ts7.isIdentifier(property) || ts7.isStringLiteral(property)) return property.text;
+  if (ts8.isIdentifier(property) || ts8.isStringLiteral(property)) return property.text;
   return void 0;
 }
 function literalOf(node) {
-  if (ts7.isStringLiteral(node)) return node.text;
-  if (ts7.isNumericLiteral(node)) return Number(node.text.replaceAll("_", ""));
-  if (ts7.isPrefixUnaryExpression(node) && node.operator === ts7.SyntaxKind.MinusToken && ts7.isNumericLiteral(node.operand)) {
+  if (ts8.isStringLiteral(node)) return node.text;
+  if (ts8.isNumericLiteral(node)) return Number(node.text.replaceAll("_", ""));
+  if (ts8.isPrefixUnaryExpression(node) && node.operator === ts8.SyntaxKind.MinusToken && ts8.isNumericLiteral(node.operand)) {
     return -Number(node.operand.text.replaceAll("_", ""));
   }
   return void 0;
 }
 function isLiteralRoot(node) {
-  if (ts7.isPrefixUnaryExpression(node)) return literalOf(node) !== void 0;
-  return (ts7.isStringLiteral(node) || ts7.isNumericLiteral(node)) && !(ts7.isPrefixUnaryExpression(node.parent) && node.parent.operand === node);
+  if (ts8.isPrefixUnaryExpression(node)) return literalOf(node) !== void 0;
+  return (ts8.isStringLiteral(node) || ts8.isNumericLiteral(node)) && !(ts8.isPrefixUnaryExpression(node.parent) && node.parent.operand === node);
 }
 function invocation(node) {
-  if (ts7.isIdentifier(node.expression)) return { method: node.expression.text };
-  if (ts7.isPropertyAccessExpression(node.expression)) {
+  if (ts8.isIdentifier(node.expression)) return { method: node.expression.text };
+  if (ts8.isPropertyAccessExpression(node.expression)) {
     const receiver = node.expression.expression.getText();
     if (!/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)?$/.test(receiver)) return void 0;
     return { method: node.expression.name.text, receiver };
@@ -5178,7 +5454,7 @@ function invocation(node) {
   return void 0;
 }
 function isPathname(node) {
-  return ts7.isPropertyAccessExpression(node) && node.name.text === "pathname";
+  return ts8.isPropertyAccessExpression(node) && node.name.text === "pathname";
 }
 function contextFor(node, value, file, root) {
   if (typeof value === "number" && ignoredNumbers.has(value)) return void 0;
@@ -5187,7 +5463,7 @@ function contextFor(node, value, file, root) {
   const scope = featureOf(file, root);
   const isApiRoute = typeof value === "string" && value.startsWith("/api/") && !/[?&#\s]/.test(value);
   const route = () => ({ role: "api-route", family: "api-route" });
-  if (ts7.isPropertyAssignment(parent) && parent.initializer === node) {
+  if (ts8.isPropertyAssignment(parent) && parent.initializer === node) {
     const name = nameOf(parent.name);
     if (!name) return void 0;
     if (name === "path" && isApiRoute) return route();
@@ -5196,14 +5472,14 @@ function contextFor(node, value, file, root) {
     if (isApiRoute && /route|path|endpoint/i.test(name)) return route();
     return { role: `property:${name}:${scope}`, family: `property:${name}` };
   }
-  if (ts7.isVariableDeclaration(parent) && parent.initializer === node && ts7.isIdentifier(parent.name)) {
+  if (ts8.isVariableDeclaration(parent) && parent.initializer === node && ts8.isIdentifier(parent.name)) {
     if (typeof value === "number") return void 0;
     const name = parent.name.text;
     if (excludedProperties.has(name) || !semanticVariableName.test(name)) return void 0;
     if (isApiRoute && /route|path|endpoint/i.test(name)) return route();
     return { role: `variable:${name}:${scope}`, family: `variable:${name}` };
   }
-  if (ts7.isCallExpression(parent)) {
+  if (ts8.isCallExpression(parent)) {
     const position = parent.arguments.findIndex((argument) => argument === node);
     if (position < 0) return void 0;
     const call = invocation(parent);
@@ -5222,45 +5498,45 @@ function contextFor(node, value, file, root) {
       return { role: `column:${scope}`, family: "column" };
     }
   }
-  if (isApiRoute && ts7.isBinaryExpression(parent) && (parent.operatorToken.kind === ts7.SyntaxKind.EqualsEqualsEqualsToken || parent.operatorToken.kind === ts7.SyntaxKind.ExclamationEqualsEqualsToken) && (parent.left === node && isPathname(parent.right) || parent.right === node && isPathname(parent.left))) {
+  if (isApiRoute && ts8.isBinaryExpression(parent) && (parent.operatorToken.kind === ts8.SyntaxKind.EqualsEqualsEqualsToken || parent.operatorToken.kind === ts8.SyntaxKind.ExclamationEqualsEqualsToken) && (parent.left === node && isPathname(parent.right) || parent.right === node && isPathname(parent.left))) {
     return route();
   }
-  if (isApiRoute && ts7.isCallExpression(parent) && parent.arguments[0] === node && ts7.isPropertyAccessExpression(parent.expression) && parent.expression.name.text === "startsWith" && isPathname(parent.expression.expression)) {
+  if (isApiRoute && ts8.isCallExpression(parent) && parent.arguments[0] === node && ts8.isPropertyAccessExpression(parent.expression) && parent.expression.name.text === "startsWith" && isPathname(parent.expression.expression)) {
     return route();
   }
   return void 0;
 }
 function isExported2(node) {
-  return ts7.canHaveModifiers(node) && (ts7.getModifiers(node) ?? []).some((modifier) => modifier.kind === ts7.SyntaxKind.ExportKeyword);
+  return ts8.canHaveModifiers(node) && (ts8.getModifiers(node) ?? []).some((modifier) => modifier.kind === ts8.SyntaxKind.ExportKeyword);
 }
 function parse(file, root, output) {
   if (!isProductionSource(file, root)) return;
-  const source = ts7.createSourceFile(
+  const source = ts8.createSourceFile(
     file,
-    readFileSync8(file, "utf8"),
-    ts7.ScriptTarget.Latest,
+    readFileSync9(file, "utf8"),
+    ts8.ScriptTarget.Latest,
     true,
-    file.endsWith(".tsx") || file.endsWith(".jsx") ? ts7.ScriptKind.TSX : ts7.ScriptKind.TS
+    file.endsWith(".tsx") || file.endsWith(".jsx") ? ts8.ScriptKind.TSX : ts8.ScriptKind.TS
   );
-  const inConstants = path39.relative(root, file).split(path39.sep).includes("constants");
+  const inConstants = path40.relative(root, file).split(path40.sep).includes("constants");
   for (const statement of source.statements) {
-    if (inConstants && ts7.isEnumDeclaration(statement) && isExported2(statement)) {
+    if (inConstants && ts8.isEnumDeclaration(statement) && isExported2(statement)) {
       for (const member of statement.members) {
         const value = member.initializer && literalOf(member.initializer);
-        const memberName9 = nameOf(member.name);
-        if (value === void 0 || !memberName9) continue;
+        const memberName10 = nameOf(member.name);
+        if (value === void 0 || !memberName10) continue;
         output.canonicals.push({
           file,
-          name: memberName9,
+          name: memberName10,
           owner: statement.name.text,
           kind: typeof value === "string" ? "string" : "number",
           value
         });
       }
     }
-    if (inConstants && ts7.isVariableStatement(statement) && isExported2(statement)) {
+    if (inConstants && ts8.isVariableStatement(statement) && isExported2(statement)) {
       for (const declaration of statement.declarationList.declarations) {
-        if (!ts7.isIdentifier(declaration.name) || !declaration.initializer) continue;
+        if (!ts8.isIdentifier(declaration.name) || !declaration.initializer) continue;
         const value = literalOf(declaration.initializer);
         if (value === void 0) continue;
         output.canonicals.push({
@@ -5279,7 +5555,7 @@ function parse(file, root, output) {
         const semantic = contextFor(node, value, file, root);
         if (semantic) {
           const declaration = node.parent;
-          const isCanonicalDefinition = inConstants && (ts7.isVariableDeclaration(declaration) && ts7.isVariableStatement(declaration.parent.parent) && isExported2(declaration.parent.parent) || ts7.isEnumMember(declaration));
+          const isCanonicalDefinition = inConstants && (ts8.isVariableDeclaration(declaration) && ts8.isVariableStatement(declaration.parent.parent) && isExported2(declaration.parent.parent) || ts8.isEnumMember(declaration));
           if ((!inConstants || semantic.family === "api-route") && !isCanonicalDefinition) {
             const position = source.getLineAndCharacterOfPosition(node.getStart(source));
             output.uses.push({
@@ -5294,7 +5570,7 @@ function parse(file, root, output) {
         }
       }
     }
-    ts7.forEachChild(node, visit);
+    ts8.forEachChild(node, visit);
   };
   visit(source);
 }
@@ -5314,8 +5590,8 @@ function getSemanticLiteralIndex(index) {
 }
 
 // eslint/rules/no-inline-runtime-literal.ts
-var DOC4 = "See docs/next-codebase-guide/rules/constants-rule.md";
-var MESSAGE2 = `Every runtime string or numeric value must use a named constant or enum member, including single-use values. Inline JSX className and canonical locale strings are exempt. ${DOC4}`;
+var DOC5 = "See docs/next-codebase-guide/rules/constants-rule.md";
+var MESSAGE2 = `Every runtime string or numeric value must use a named constant or enum member, including single-use values. Inline JSX className/data-component, canonical locale strings, and static Next.js matchers are exempt. ${DOC5}`;
 function isClassNameProp(node) {
   let current = node;
   while (current.parent) {
@@ -5328,15 +5604,43 @@ function isClassNameProp(node) {
   }
   return false;
 }
-function containsInlineString(node) {
-  if (typeof node !== "object" || node === null || !("type" in node)) return false;
-  if (node.type === "TemplateLiteral") return true;
-  if (node.type === "Literal") return "value" in node && typeof node.value === "string";
-  if (node.type === "BinaryExpression") {
-    return "left" in node && containsInlineString(node.left) || "right" in node && containsInlineString(node.right);
-  }
-  if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression") {
-    return "expression" in node && containsInlineString(node.expression);
+function isStaticDataComponentMarker(node) {
+  const parent = node.parent;
+  if (parent?.type !== "JSXAttribute" || parent.value !== node) return false;
+  const name = parent.name;
+  return typeof name === "object" && name !== null && "name" in name && name.name === "data-component";
+}
+function isStaticMatcherValue(node, root, file) {
+  const relativeFile = path41.relative(root, file);
+  if (relativeFile !== "middleware.ts" && relativeFile !== "proxy.ts") return false;
+  let current = node;
+  while (current.parent) {
+    const parent = current.parent;
+    if (parent.type === "ArrayExpression" && Array.isArray(parent.elements) && parent.elements.includes(current)) {
+      current = parent;
+      continue;
+    }
+    if (parent.type === "ObjectExpression" && Array.isArray(parent.properties) && parent.properties.includes(current)) {
+      current = parent;
+      continue;
+    }
+    if (parent.type !== "Property" || parent.value !== current || parent.computed) return false;
+    const key = parent.key;
+    if (typeof key !== "object" || key === null) return false;
+    const isMatcher = "name" in key && key.name === "matcher" || "value" in key && key.value === "matcher";
+    if (!isMatcher) {
+      current = parent;
+      continue;
+    }
+    const object = parent.parent;
+    if (object?.type !== "ObjectExpression") return false;
+    let configValue = object;
+    while ((configValue.parent?.type === "TSAsExpression" || configValue.parent?.type === "TSSatisfiesExpression") && configValue.parent.expression === configValue) {
+      configValue = configValue.parent;
+    }
+    const declaration = configValue.parent;
+    const id = declaration?.id;
+    return declaration?.type === "VariableDeclarator" && declaration.init === configValue && typeof id === "object" && id !== null && "name" in id && id.name === "config" && declaration.parent?.type === "VariableDeclaration" && declaration.parent.kind === "const" && declaration.parent.parent?.type === "ExportNamedDeclaration";
   }
   return false;
 }
@@ -5346,8 +5650,7 @@ function isNamedValue(node) {
     const parent2 = current.parent;
     const isTypeWrapper = parent2.type === "TSAsExpression" || parent2.type === "TSSatisfiesExpression";
     const isSignedNumber = parent2.type === "UnaryExpression" && parent2.argument === current && (parent2.operator === "-" || parent2.operator === "+");
-    const isArithmetic = parent2.type === "BinaryExpression" && typeof parent2.operator === "string" && ["+", "-", "*", "/", "%", "**", "<<", ">>", ">>>", "&", "|", "^"].includes(parent2.operator) && !containsInlineString(parent2.left) && !containsInlineString(parent2.right);
-    if (!isTypeWrapper && !isSignedNumber && !isArithmetic) break;
+    if (!isTypeWrapper && !isSignedNumber) break;
     current = parent2;
   }
   const parent = current.parent;
@@ -5360,6 +5663,7 @@ function isNamedValue(node) {
 function isSyntacticString(node) {
   const parent = node.parent;
   if (!parent) return false;
+  if (parent.type === "TSModuleDeclaration" && parent.id === node) return true;
   if (parent.type === "ImportDeclaration" || parent.type === "ExportNamedDeclaration" || parent.type === "ExportAllDeclaration" || parent.type === "ImportExpression" || parent.type === "TSLiteralType" || parent.type === "TSExternalModuleReference") {
     return true;
   }
@@ -5370,27 +5674,25 @@ function isSyntacticString(node) {
   return false;
 }
 function isRuntimeMockSource(file, root) {
-  const parts = path40.relative(root, file).split(path40.sep);
-  return parts.includes("mocks") && !parts.some((part) => part === "__tests__" || part === "__mocks__") && !/\.(?:test|spec|mock)\.[^.]+$/.test(path40.basename(file));
+  const parts = path41.relative(root, file).split(path41.sep);
+  return parts.includes("mocks") && !parts.some((part) => part === "__tests__" || part === "__mocks__") && !/\.(?:test|spec|mock)\.[^.]+$/.test(path41.basename(file));
 }
 function isCanonicalLocaleString(node, root, file) {
-  if (path40.relative(root, file) !== path40.join("locales", "index.ts")) return false;
-  let current = node;
-  let depth = 0;
-  while (current.parent?.type === "Property" && current.parent.value === current) {
-    const object = current.parent.parent;
-    if (object?.type !== "ObjectExpression") return false;
-    current = object;
-    depth += 1;
-  }
-  if (depth < 1 || depth > 2) return false;
+  const relative = path41.relative(root, file).split(path41.sep);
+  let namespace;
+  if (relative.length === 2 && relative[0] === "locales" && relative[1] !== "index.ts" && /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*\.ts$/.test(relative[1] ?? "")) {
+    namespace = (relative[1] ?? "").slice(0, -3).replace(/-[a-z]/g, (match) => match.slice(1).toUpperCase());
+  }
+  if (!namespace) return false;
+  if (node.parent?.type !== "Property" || node.parent.value !== node) return false;
+  let current = node.parent.parent;
+  if (current?.type !== "ObjectExpression") return false;
   while ((current.parent?.type === "TSAsExpression" || current.parent?.type === "TSSatisfiesExpression") && current.parent.expression === current) {
     current = current.parent;
   }
   const declaration = current.parent;
-  if (declaration?.type !== "VariableDeclarator" || declaration.init !== current) return false;
-  const id = declaration.id;
-  return typeof id === "object" && id !== null && "type" in id && id.type === "Identifier" && "name" in id && id.name === "locales" && declaration.parent?.type === "VariableDeclaration" && declaration.parent.kind === "const" && declaration.parent.parent?.type === "ExportNamedDeclaration";
+  const id = declaration?.id;
+  return declaration?.type === "VariableDeclarator" && declaration.init === current && typeof id === "object" && id !== null && "type" in id && id.type === "Identifier" && "name" in id && id.name === namespace && declaration.parent?.type === "VariableDeclaration" && declaration.parent.kind === "const" && declaration.parent.parent?.type === "ExportNamedDeclaration";
 }
 var noInlineRuntimeLiteralRule = {
   meta: {
@@ -5400,8 +5702,8 @@ var noInlineRuntimeLiteralRule = {
   },
   create(context) {
     const root = sourceRootOf(context);
-    const file = path40.resolve(context.filename);
-    if (!file.startsWith(root + path40.sep) || !isProductionSource(file, root) && !isRuntimeMockSource(file, root)) {
+    const file = path41.resolve(context.filename);
+    if (!file.startsWith(root + path41.sep) || !isProductionSource(file, root) && !isRuntimeMockSource(file, root)) {
       return {};
     }
     return {
@@ -5409,7 +5711,7 @@ var noInlineRuntimeLiteralRule = {
         if (typeof node.value !== "string" && typeof node.value !== "number" && typeof node.value !== "bigint" && !("bigint" in node && typeof node.bigint === "string")) {
           return;
         }
-        if (typeof node.value === "string" && (isClassNameProp(node) || isCanonicalLocaleString(node, root, file)) || isNamedValue(node) || isSyntacticString(node)) {
+        if (typeof node.value === "string" && (isClassNameProp(node) || isStaticDataComponentMarker(node) || isCanonicalLocaleString(node, root, file)) || isStaticMatcherValue(node, root, file) || isNamedValue(node) || isSyntacticString(node)) {
           return;
         }
         context.report({ node, message: MESSAGE2 });
@@ -5448,7 +5750,7 @@ function isStaticValue(value) {
   }
   return false;
 }
-function propertyName2(property) {
+function propertyName3(property) {
   if (!property.computed && property.key.type === "Identifier") return property.key.name;
   if (property.key.type === "Literal" && typeof property.key.value === "string") return property.key.value;
   return void 0;
@@ -5456,7 +5758,7 @@ function propertyName2(property) {
 function findStaticDeclaration(expression) {
   for (const property of expression.properties) {
     if (property.type !== "Property" || property.kind !== "init") continue;
-    const name = propertyName2(property);
+    const name = propertyName3(property);
     if (!name) continue;
     if (isStaticValue(property.value)) return name;
   }
@@ -5498,8 +5800,8 @@ var noLiteralInlineStyleRule = {
 };
 
 // eslint/rules/no-mixed-concerns.ts
-import { readFileSync as readFileSync9 } from "fs";
-import path41 from "path";
+import { readFileSync as readFileSync10 } from "fs";
+import path42 from "path";
 var noMixedConcernsRule = {
   meta: {
     schema: [],
@@ -5523,7 +5825,7 @@ var noMixedConcernsRule = {
         if (components.length > 1) return;
         const componentName = components[0]?.name;
         if (!componentName) return;
-        const file = path41.resolve(context.filename);
+        const file = path42.resolve(context.filename);
         const sourceRoot = sourceRootOf(context);
         const index = getProjectIndex(sourceRoot);
         const componentConsumers = index?.symbolConsumers.get(symbolKey(file, componentName)) ?? /* @__PURE__ */ new Set();
@@ -5534,6 +5836,7 @@ var noMixedConcernsRule = {
           if (name === componentName) return;
           if (isNextPageOrLayout) {
             if (["metadata", "viewport", "generateMetadata", "generateViewport"].includes(name)) return;
+            if (name === "generateStaticParams" && /\[[^\]]+\]/.test(context.filename)) return;
             context.report({
               loc,
               message: `Next.js page/layout files cannot export "${name}". Use a separate module for supporting values.`
@@ -5567,7 +5870,7 @@ var noMixedConcernsRule = {
               continue;
             }
             const target = typeof statement.source?.value === "string" ? resolveSpecifier(file, statement.source.value, sourceRoot) : void 0;
-            const forwardedComponents = target?.endsWith(".tsx") ? parseComponentInfo(readFileSync9(target, "utf8"), target).map((component) => component.name) : [];
+            const forwardedComponents = target?.endsWith(".tsx") ? parseComponentInfo(readFileSync10(target, "utf8"), target).map((component) => component.name) : [];
             for (const specifier of statement.specifiers) {
               if (/^type\b/.test(context.sourceCode.getText(specifier))) continue;
               if (specifier.local.type !== "Identifier") continue;
@@ -5601,11 +5904,11 @@ var noMixedConcernsRule = {
 };
 
 // eslint/rules/no-redundant-alias.ts
-import path43 from "path";
+import path44 from "path";
 
 // eslint/rules/contract-ownership.ts
-import path42 from "path";
-import ts8 from "typescript";
+import path43 from "path";
+import ts9 from "typescript";
 function isTsProgram(value) {
   return typeof value === "object" && value !== null && "getTypeChecker" in value && typeof value.getTypeChecker === "function" && "getSourceFiles" in value && typeof value.getSourceFiles === "function";
 }
@@ -5623,8 +5926,8 @@ function normalizePath(value) {
   return value.replaceAll("\\", "/").toLowerCase();
 }
 function isWithin2(root, file) {
-  const relative = path42.relative(root, file);
-  return relative === "" || !relative.startsWith("..") && !path42.isAbsolute(relative);
+  const relative = path43.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path43.isAbsolute(relative);
 }
 function mergeOwnership(values) {
   if (values.length === 0 || values.includes("unknown")) return "unknown";
@@ -5639,11 +5942,11 @@ function endpointOwnership(pathValue) {
   return "unknown";
 }
 function resolvedSymbol(checker, symbol) {
-  return symbol.flags === ts8.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+  return symbol.flags === ts9.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
 }
-function propertyName3(node) {
+function propertyName4(node) {
   if (!node) return void 0;
-  if (ts8.isIdentifier(node) || ts8.isStringLiteral(node) || ts8.isNumericLiteral(node)) return node.text;
+  if (ts9.isIdentifier(node) || ts9.isStringLiteral(node) || ts9.isNumericLiteral(node)) return node.text;
   return void 0;
 }
 var ContractOwnershipIndex = class {
@@ -5667,7 +5970,7 @@ var ContractOwnershipIndex = class {
     }
     if (declarations.length > 0) return this.endpointFromDeclarations(declarations);
     let object;
-    if (ts8.isPropertyAccessExpression(node) || ts8.isElementAccessExpression(node)) object = node.expression;
+    if (ts9.isPropertyAccessExpression(node) || ts9.isElementAccessExpression(node)) object = node.expression;
     if (!object) return { kind: "missing", ownership: "unknown" };
     const type = this.checker.getTypeAtLocation(object);
     const typeDeclarations = this.typeDeclarations(type);
@@ -5675,7 +5978,7 @@ var ContractOwnershipIndex = class {
     return this.endpointFromDeclarations(typeDeclarations);
   }
   sourceBinding(node, name) {
-    if (!ts8.isVariableDeclaration(node) || !node.initializer) {
+    if (!ts9.isVariableDeclaration(node) || !node.initializer) {
       return { kind: "missing", ownership: "unknown" };
     }
     const sourceType = this.checker.getTypeAtLocation(node.initializer);
@@ -5684,11 +5987,11 @@ var ContractOwnershipIndex = class {
     return this.endpointFromDeclarations(declarations);
   }
   targetProperty(node, name) {
-    if (!ts8.isPropertyAssignment(node) && !ts8.isShorthandPropertyAssignment(node)) {
+    if (!ts9.isPropertyAssignment(node) && !ts9.isShorthandPropertyAssignment(node)) {
       return { kind: "missing", ownership: "unknown" };
     }
     const object = node.parent;
-    if (!ts8.isObjectLiteralExpression(object)) return { kind: "missing", ownership: "unknown" };
+    if (!ts9.isObjectLiteralExpression(object)) return { kind: "missing", ownership: "unknown" };
     const contextualType = this.checker.getContextualType(object);
     if (!contextualType) return { kind: "missing", ownership: "unknown" };
     const declarations = this.propertyDeclarations(contextualType, name);
@@ -5696,8 +5999,8 @@ var ContractOwnershipIndex = class {
     return this.endpointFromDeclarations(declarations);
   }
   memberNameSymbol(node) {
-    if (ts8.isPropertyAccessExpression(node)) return this.checker.getSymbolAtLocation(node.name);
-    if (ts8.isElementAccessExpression(node)) return this.checker.getSymbolAtLocation(node.argumentExpression);
+    if (ts9.isPropertyAccessExpression(node)) return this.checker.getSymbolAtLocation(node.name);
+    if (ts9.isElementAccessExpression(node)) return this.checker.getSymbolAtLocation(node.argumentExpression);
     return void 0;
   }
   propertyDeclarations(type, name) {
@@ -5727,14 +6030,14 @@ var ContractOwnershipIndex = class {
     if (declarations.some((declaration) => this.isDataContractField(declaration))) {
       return { kind: "data-contract", ownership };
     }
-    if (declarations.some((declaration) => ts8.isPropertySignature(declaration) || ts8.isPropertyDeclaration(declaration))) {
+    if (declarations.some((declaration) => ts9.isPropertySignature(declaration) || ts9.isPropertyDeclaration(declaration))) {
       return { kind: "typed-local", ownership };
     }
     return { kind: "non-contract", ownership };
   }
   isDataContractField(declaration) {
     if (this.isZodSchemaField(declaration)) return true;
-    if (!ts8.isPropertySignature(declaration) && !ts8.isPropertyDeclaration(declaration)) return false;
+    if (!ts9.isPropertySignature(declaration) && !ts9.isPropertyDeclaration(declaration)) return false;
     const fileName = normalizePath(declaration.getSourceFile().fileName);
     return /(?:^|\/)database(?:[-.]generated)?\.ts$/u.test(fileName);
   }
@@ -5743,10 +6046,10 @@ var ContractOwnershipIndex = class {
     return this.checker.getPropertyOfType(type, "_zod") !== void 0 && this.checker.getPropertyOfType(type, "parse") !== void 0 && this.checker.getPropertyOfType(type, "safeParse") !== void 0;
   }
   isZodSchemaField(declaration) {
-    if (!ts8.isPropertyAssignment(declaration)) return false;
+    if (!ts9.isPropertyAssignment(declaration)) return false;
     let current = declaration.parent;
-    while (!ts8.isSourceFile(current)) {
-      if (ts8.isVariableDeclaration(current) && ts8.isIdentifier(current.name) && current.name.text.endsWith("Schema")) {
+    while (!ts9.isSourceFile(current)) {
+      if (ts9.isVariableDeclaration(current) && ts9.isIdentifier(current.name) && current.name.text.endsWith("Schema")) {
         return true;
       }
       current = current.parent;
@@ -5764,12 +6067,12 @@ var ContractOwnershipIndex = class {
     const normalized = normalizePath(fileName);
     if (/\/typescript\/lib\/lib\.[^/]+\.d\.ts$/u.test(normalized)) return "platform";
     if (normalized.includes("/node_modules/")) return "third-party";
-    if (isWithin2(this.cwd, path42.resolve(fileName))) return "first-party";
+    if (isWithin2(this.cwd, path43.resolve(fileName))) return "first-party";
     return "unknown";
   }
   schemaOwnership(declaration) {
     let current = declaration;
-    while (!ts8.isSourceFile(current)) {
+    while (!ts9.isSourceFile(current)) {
       const ownership = this.schemaNodeOwnership.get(current);
       if (ownership !== void 0) return ownership;
       current = current.parent;
@@ -5778,31 +6081,31 @@ var ContractOwnershipIndex = class {
   }
   indexApiContracts() {
     for (const sourceFile of this.program.getSourceFiles()) {
-      if (sourceFile.isDeclarationFile || !isWithin2(this.cwd, path42.resolve(sourceFile.fileName))) continue;
+      if (sourceFile.isDeclarationFile || !isWithin2(this.cwd, path43.resolve(sourceFile.fileName))) continue;
       const visit = (node) => {
-        if (ts8.isCallExpression(node) && this.isDefineApiContractCall(node)) this.indexApiContractCall(node);
-        ts8.forEachChild(node, visit);
+        if (ts9.isCallExpression(node) && this.isDefineApiContractCall(node)) this.indexApiContractCall(node);
+        ts9.forEachChild(node, visit);
       };
       visit(sourceFile);
     }
   }
   isDefineApiContractCall(node) {
-    if (ts8.isIdentifier(node.expression)) return node.expression.text === "defineApiContract";
-    return ts8.isPropertyAccessExpression(node.expression) && node.expression.name.text === "defineApiContract";
+    if (ts9.isIdentifier(node.expression)) return node.expression.text === "defineApiContract";
+    return ts9.isPropertyAccessExpression(node.expression) && node.expression.name.text === "defineApiContract";
   }
   indexApiContractCall(node) {
     const argument = node.arguments[0];
-    if (!argument || !ts8.isObjectLiteralExpression(argument)) return;
+    if (!argument || !ts9.isObjectLiteralExpression(argument)) return;
     let pathExpression;
     const schemaExpressions = [];
     for (const property of argument.properties) {
-      if (ts8.isPropertyAssignment(property)) {
-        const name = propertyName3(property.name);
+      if (ts9.isPropertyAssignment(property)) {
+        const name = propertyName4(property.name);
         if (name === "path") pathExpression = property.initializer;
         if (name === "requestSchema" || name === "responseSchema") schemaExpressions.push(property.initializer);
         continue;
       }
-      if (ts8.isShorthandPropertyAssignment(property)) {
+      if (ts9.isShorthandPropertyAssignment(property)) {
         const name = property.name.text;
         if (name === "path") pathExpression = property.name;
         if (name === "requestSchema" || name === "responseSchema") schemaExpressions.push(property.name);
@@ -5816,13 +6119,13 @@ var ContractOwnershipIndex = class {
   }
   staticString(node, seen) {
     if (!node) return void 0;
-    if (ts8.isStringLiteralLike(node)) return node.text;
-    if (ts8.isIdentifier(node)) {
+    if (ts9.isStringLiteralLike(node)) return node.text;
+    if (ts9.isIdentifier(node)) {
       const symbol = this.checker.getSymbolAtLocation(node);
       if (!symbol || seen.has(symbol)) return void 0;
       seen.add(symbol);
       for (const declaration of resolvedSymbol(this.checker, symbol).declarations ?? []) {
-        if (ts8.isVariableDeclaration(declaration) && declaration.initializer) {
+        if (ts9.isVariableDeclaration(declaration) && declaration.initializer) {
           const value = this.staticString(declaration.initializer, seen);
           if (value !== void 0) return value;
         }
@@ -5840,20 +6143,20 @@ var ContractOwnershipIndex = class {
         this.followSchemaDeclaration(declaration, ownership, seen);
       }
     }
-    ts8.forEachChild(node, (child) => {
+    ts9.forEachChild(node, (child) => {
       this.markSchemaExpression(child, ownership, seen);
     });
   }
   schemaReferenceSymbol(node) {
-    if (ts8.isIdentifier(node)) {
+    if (ts9.isIdentifier(node)) {
       if (!node.text.endsWith("Schema")) return void 0;
       return this.checker.getSymbolAtLocation(node);
     }
-    if (ts8.isPropertyAccessExpression(node)) {
+    if (ts9.isPropertyAccessExpression(node)) {
       if (!node.name.text.endsWith("Schema")) return void 0;
       return this.checker.getSymbolAtLocation(node.name);
     }
-    if (ts8.isElementAccessExpression(node) && ts8.isStringLiteralLike(node.argumentExpression)) {
+    if (ts9.isElementAccessExpression(node) && ts9.isStringLiteralLike(node.argumentExpression)) {
       if (!node.argumentExpression.text.endsWith("Schema")) return void 0;
       return this.checker.getSymbolAtLocation(node.argumentExpression);
     }
@@ -5861,15 +6164,15 @@ var ContractOwnershipIndex = class {
   }
   followSchemaDeclaration(declaration, ownership, seen) {
     this.setSchemaOwnership(declaration, ownership);
-    if (ts8.isVariableDeclaration(declaration) && declaration.initializer) {
+    if (ts9.isVariableDeclaration(declaration) && declaration.initializer) {
       this.markSchemaExpression(declaration.initializer, ownership, seen);
       return;
     }
-    if (ts8.isPropertyAssignment(declaration)) {
+    if (ts9.isPropertyAssignment(declaration)) {
       this.markSchemaExpression(declaration.initializer, ownership, seen);
       return;
     }
-    if (ts8.isShorthandPropertyAssignment(declaration)) {
+    if (ts9.isShorthandPropertyAssignment(declaration)) {
       const valueSymbol = this.checker.getShorthandAssignmentValueSymbol(declaration);
       if (!valueSymbol || seen.has(valueSymbol)) return;
       seen.add(valueSymbol);
@@ -5913,7 +6216,7 @@ function contractOwnershipResolver(context) {
 }
 
 // eslint/rules/no-redundant-alias.ts
-var DOC5 = "See docs/next-codebase-guide/rules/redundant-aliases-rule.md";
+var DOC6 = "See docs/next-codebase-guide/rules/redundant-aliases-rule.md";
 var VALUE_SENTINELS = /* @__PURE__ */ new Set(["undefined", "NaN", "Infinity"]);
 var HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
 var FRAMEWORK_MAPPING_KEYS = /* @__PURE__ */ new Set(["default", "apiRoutePath"]);
@@ -5946,14 +6249,14 @@ function aliasedTypeName(annotation) {
 function aliasMessage(alias, source) {
   const aliasName = alias ?? "This declaration";
   const sourceName = source ?? "the original symbol";
-  return `"${aliasName}" only renames "${sourceName}". Use "${sourceName}" directly or rename the original symbol and its consumers. ${DOC5}`;
+  return `"${aliasName}" only renames "${sourceName}". Use "${sourceName}" directly or rename the original symbol and its consumers. ${DOC6}`;
 }
 function bindingAliasMessage(alias, source) {
-  return `"${alias}" renames "${source}" while creating a binding. Keep the original name and map it only at the object boundary. ${DOC5}`;
+  return `"${alias}" renames "${source}" while creating a binding. Keep the original name and map it only at the object boundary. ${DOC6}`;
 }
-function objectPropertyMessage(propertyName5, source) {
-  if (source === propertyName5) return `Use property shorthand for "${propertyName5}". ${DOC5}`;
-  return `"${propertyName5}" maps the local "${source}". Keep the local name or map directly from its source object instead. ${DOC5}`;
+function objectPropertyMessage(propertyName6, source) {
+  if (source === propertyName6) return `Use property shorthand for "${propertyName6}". ${DOC6}`;
+  return `"${propertyName6}" maps the local "${source}". Keep the local name or map directly from its source object instead. ${DOC6}`;
 }
 function normalizePropertyName(name) {
   return name.replace(/[-_\s]/g, "").toLowerCase();
@@ -5966,12 +6269,12 @@ function memberPropertyName2(node) {
   }
   return void 0;
 }
-function isNamedMemberValue(propertyName5) {
-  return /^[A-Z]/.test(propertyName5);
+function isNamedMemberValue(propertyName6) {
+  return /^[A-Z]/.test(propertyName6);
 }
-function isQualifiedSourceField(propertyName5, sourceMember, sourcePropertyName) {
+function isQualifiedSourceField(propertyName6, sourceMember, sourcePropertyName) {
   if (sourceMember.type !== "MemberExpression" || sourceMember.object.type !== "Identifier") return false;
-  return normalizePropertyName(propertyName5) === normalizePropertyName(`${sourceMember.object.name}${sourcePropertyName}`);
+  return normalizePropertyName(propertyName6) === normalizePropertyName(`${sourceMember.object.name}${sourcePropertyName}`);
 }
 function isInsideSchemaDeclaration(node) {
   let current = node;
@@ -5983,11 +6286,11 @@ function isInsideSchemaDeclaration(node) {
   }
   return false;
 }
-function semanticMappingMessage(propertyName5, sourcePropertyName) {
-  return `"${propertyName5}" maps from "${sourcePropertyName}" between first-party contracts. Use one canonical field name across the contracts. ${DOC5}`;
+function semanticMappingMessage(propertyName6, sourcePropertyName) {
+  return `"${propertyName6}" maps from "${sourcePropertyName}" between first-party contracts. Use one canonical field name across the contracts. ${DOC6}`;
 }
-function unknownContractOwnershipMessage(propertyName5, sourcePropertyName) {
-  return `Cannot determine contract ownership for mapping "${propertyName5}" from "${sourcePropertyName}". Define or propagate a concrete contract, make the boundary schema explicit, or connect a mirrored external schema to its defineApiContract. ${DOC5}`;
+function unknownContractOwnershipMessage(propertyName6, sourcePropertyName) {
+  return `Cannot determine contract ownership for mapping "${propertyName6}" from "${sourcePropertyName}". Define or propagate a concrete contract, make the boundary schema explicit, or connect a mirrored external schema to its defineApiContract. ${DOC6}`;
 }
 function destructuredBindingSource(context, identifier) {
   const initialScope = context.sourceCode.getScope(identifier);
@@ -6014,7 +6317,7 @@ function destructuredBindingSource(context, identifier) {
   }
   return void 0;
 }
-function contractMappingViolation(propertyName5, sourcePropertyName, sourceResolution, targetResolution) {
+function contractMappingViolation(propertyName6, sourcePropertyName, sourceResolution, targetResolution) {
   if (sourceResolution.kind === "non-contract" || targetResolution.kind === "non-contract") return void 0;
   if ((sourceResolution.ownership === "third-party" || sourceResolution.ownership === "platform") && targetResolution.kind !== "missing") {
     return void 0;
@@ -6025,11 +6328,11 @@ function contractMappingViolation(propertyName5, sourcePropertyName, sourceResol
   const hasDataContract = sourceResolution.kind === "data-contract" || targetResolution.kind === "data-contract";
   if (!hasDataContract) return void 0;
   if (sourceResolution.kind === "missing" || targetResolution.kind === "missing" || sourceResolution.ownership === "unknown" || targetResolution.ownership === "unknown") {
-    return unknownContractOwnershipMessage(propertyName5, sourcePropertyName);
+    return unknownContractOwnershipMessage(propertyName6, sourcePropertyName);
   }
   if (sourceResolution.kind !== "data-contract") return void 0;
   if (sourceResolution.ownership !== "first-party" || targetResolution.ownership !== "first-party") return void 0;
-  return semanticMappingMessage(propertyName5, sourcePropertyName);
+  return semanticMappingMessage(propertyName6, sourcePropertyName);
 }
 var noRedundantAliasRule = {
   meta: {
@@ -6049,7 +6352,7 @@ var noRedundantAliasRule = {
         if (declaration.type !== "VariableDeclaration" || declaration.kind !== "const") return;
         if (node.init.type === "Identifier") {
           const exported = declaration.parent.type === "ExportNamedDeclaration";
-          const frameworkRouteAlias = path43.basename(context.filename) === "route.ts" && exported && HTTP_METHODS.has(node.id.name);
+          const frameworkRouteAlias = path44.basename(context.filename) === "route.ts" && exported && HTTP_METHODS.has(node.id.name);
           if (frameworkRouteAlias || VALUE_SENTINELS.has(node.init.name)) return;
           context.report({
             node,
@@ -6058,14 +6361,14 @@ var noRedundantAliasRule = {
           return;
         }
         if (node.init.type !== "MemberExpression") return;
-        let propertyName5;
+        let propertyName6;
         if (!node.init.computed && node.init.property.type === "Identifier") {
-          propertyName5 = node.init.property.name;
+          propertyName6 = node.init.property.name;
         }
         if (node.init.computed && node.init.property.type === "Literal" && typeof node.init.property.value === "string") {
-          propertyName5 = node.init.property.value;
+          propertyName6 = node.init.property.value;
         }
-        if (propertyName5 === void 0 || propertyName5 === node.id.name) return;
+        if (propertyName6 === void 0 || propertyName6 === node.id.name) return;
         context.report({
           node,
           message: bindingAliasMessage(node.id.name, context.sourceCode.getText(node.init))
@@ -6073,22 +6376,22 @@ var noRedundantAliasRule = {
       },
       Property(node) {
         if (node.computed) return;
-        let propertyName5;
-        if (node.key.type === "Identifier") propertyName5 = node.key.name;
+        let propertyName6;
+        if (node.key.type === "Identifier") propertyName6 = node.key.name;
         if (node.key.type === "Literal" && typeof node.key.value === "string") {
-          propertyName5 = node.key.value;
+          propertyName6 = node.key.value;
         }
-        if (propertyName5 === void 0) return;
+        if (propertyName6 === void 0) return;
         if (node.parent.type === "ObjectPattern") {
           let binding;
           if (node.value.type === "Identifier") binding = node.value;
           if (node.value.type === "AssignmentPattern" && node.value.left.type === "Identifier") {
             binding = node.value.left;
           }
-          if (!binding || binding.name === propertyName5) return;
+          if (!binding || binding.name === propertyName6) return;
           context.report({
             node,
-            message: bindingAliasMessage(binding.name, propertyName5)
+            message: bindingAliasMessage(binding.name, propertyName6)
           });
           return;
         }
@@ -6097,12 +6400,12 @@ var noRedundantAliasRule = {
         if (node.value.type === "Identifier") {
           if (node.shorthand) return;
           const source = node.value.name;
-          if (propertyName5 === source) {
+          if (propertyName6 === source) {
             context.report({
               node,
-              message: objectPropertyMessage(propertyName5, source),
+              message: objectPropertyMessage(propertyName6, source),
               fix(fixer) {
-                return fixer.replaceText(node, propertyName5);
+                return fixer.replaceText(node, propertyName6);
               }
             });
             return;
@@ -6110,29 +6413,29 @@ var noRedundantAliasRule = {
           const bindingSource = destructuredBindingSource(context, node.value);
           if (!bindingSource || !ownershipResolver) return;
           const sourcePropertyName2 = bindingSource.propertyName;
-          if (normalizePropertyName(propertyName5) === normalizePropertyName(sourcePropertyName2)) return;
-          if (FRAMEWORK_MAPPING_KEYS.has(propertyName5) || isNamedMemberValue(sourcePropertyName2)) return;
+          if (normalizePropertyName(propertyName6) === normalizePropertyName(sourcePropertyName2)) return;
+          if (FRAMEWORK_MAPPING_KEYS.has(propertyName6) || isNamedMemberValue(sourcePropertyName2)) return;
           const sourceResolution2 = ownershipResolver.sourceBinding(bindingSource.declarator, sourcePropertyName2);
-          const targetResolution2 = ownershipResolver.targetProperty(node, propertyName5);
+          const targetResolution2 = ownershipResolver.targetProperty(node, propertyName6);
           const hasDataContract = sourceResolution2.kind === "data-contract" || targetResolution2.kind === "data-contract";
           if (!hasDataContract) return;
           context.report({
             node,
-            message: contractMappingViolation(propertyName5, sourcePropertyName2, sourceResolution2, targetResolution2) ?? objectPropertyMessage(propertyName5, source)
+            message: contractMappingViolation(propertyName6, sourcePropertyName2, sourceResolution2, targetResolution2) ?? objectPropertyMessage(propertyName6, source)
           });
           return;
         }
         if (node.value.type !== "MemberExpression") return;
         const sourcePropertyName = memberPropertyName2(node.value);
         if (sourcePropertyName === void 0) return;
-        if (normalizePropertyName(propertyName5) === normalizePropertyName(sourcePropertyName)) return;
-        if (FRAMEWORK_MAPPING_KEYS.has(propertyName5) || isNamedMemberValue(sourcePropertyName)) return;
-        if (isQualifiedSourceField(propertyName5, node.value, sourcePropertyName)) return;
+        if (normalizePropertyName(propertyName6) === normalizePropertyName(sourcePropertyName)) return;
+        if (FRAMEWORK_MAPPING_KEYS.has(propertyName6) || isNamedMemberValue(sourcePropertyName)) return;
+        if (isQualifiedSourceField(propertyName6, node.value, sourcePropertyName)) return;
         if (!ownershipResolver) return;
         const sourceResolution = ownershipResolver.sourceMember(node.value);
-        const targetResolution = ownershipResolver.targetProperty(node, propertyName5);
+        const targetResolution = ownershipResolver.targetProperty(node, propertyName6);
         const violation = contractMappingViolation(
-          propertyName5,
+          propertyName6,
           sourcePropertyName,
           sourceResolution,
           targetResolution
@@ -6156,6 +6459,11 @@ var noRedundantAliasRule = {
       },
       ImportSpecifier(node) {
         if (node.imported.type !== "Identifier" || node.imported.name === node.local.name) return;
+        const importDeclaration = node.parent;
+        const source = importDeclaration.type === "ImportDeclaration" ? importDeclaration.source.value : void 0;
+        if (typeof source === "string" && !source.startsWith(".") && !source.startsWith("/") && !source.startsWith("@/") && !source.startsWith("~/") && node.imported.name.includes("_") && /^[a-z][A-Za-z0-9]*$/.test(node.local.name)) {
+          return;
+        }
         context.report({
           node,
           message: bindingAliasMessage(node.local.name, node.imported.name)
@@ -6167,7 +6475,7 @@ var noRedundantAliasRule = {
           const source = specifier.local.name;
           const alias = specifier.exported.name;
           if (source === alias) continue;
-          const frameworkRouteAlias = path43.basename(context.filename) === "route.ts" && HTTP_METHODS.has(alias);
+          const frameworkRouteAlias = path44.basename(context.filename) === "route.ts" && HTTP_METHODS.has(alias);
           if (frameworkRouteAlias) continue;
           context.report({
             node: specifier,
@@ -6192,7 +6500,7 @@ var noRedundantAliasRule = {
 };
 
 // eslint/rules/no-util-barrel.ts
-import path44 from "path";
+import path45 from "path";
 var noUtilBarrelRule = {
   meta: {
     schema: [],
@@ -6202,7 +6510,7 @@ var noUtilBarrelRule = {
     }
   },
   create(context) {
-    const filename = path44.resolve(context.filename);
+    const filename = path45.resolve(context.filename);
     const sourceRoot = sourceRootOf3(context, filename);
     return {
       Program(node) {
@@ -6211,7 +6519,7 @@ var noUtilBarrelRule = {
           if (!target) continue;
           const segments = target.replace(/\\/g, "/").split("/");
           const utilsIndex = segments.lastIndexOf("utils");
-          if (utilsIndex < 0 || !path44.basename(target).startsWith("index.")) continue;
+          if (utilsIndex < 0 || !path45.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`
@@ -6231,16 +6539,146 @@ function importSpecifiers2(source) {
   return specifiers;
 }
 function sourceRootOf3(context, filename) {
-  const marker = `${path44.sep}src${path44.sep}`;
+  const marker = `${path45.sep}src${path45.sep}`;
   const srcIndex = filename.lastIndexOf(marker);
   if (srcIndex >= 0) return filename.slice(0, srcIndex + marker.length - 1);
-  return path44.resolve(context.cwd ?? process.cwd(), "src");
+  return path45.resolve(context.cwd ?? process.cwd(), "src");
 }
 
-// eslint/rules/package-json/exact-version.ts
+// eslint/rules/package-json/ci-checks.ts
+import { existsSync as existsSync6, readFileSync as readFileSync11, readdirSync as readdirSync4 } from "fs";
+import path46 from "path";
+import { parse as parse2 } from "yaml";
+function mapping(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? Object.fromEntries(Object.entries(value)) : void 0;
+}
 function memberName2(member) {
   return member.name.type === "String" ? member.name.value : member.name.name;
 }
+function scriptsOf(root) {
+  if (root.type !== "Object") return /* @__PURE__ */ new Map();
+  const scripts = root.members.find((member) => memberName2(member) === "scripts");
+  const members = scripts?.value.type === "Object" ? scripts.value.members : [];
+  return new Map(
+    members.flatMap(
+      (member) => member.value.type === "String" ? [[memberName2(member), member.value.value]] : []
+    )
+  );
+}
+function events(workflow) {
+  const on = workflow.on;
+  if (typeof on === "string") return { [on]: null };
+  if (Array.isArray(on)) {
+    return Object.fromEntries(
+      on.filter((item) => typeof item === "string").map((item) => [item, null])
+    );
+  }
+  return mapping(on) ?? {};
+}
+function branchesTrigger(workflow) {
+  const push = events(workflow).push;
+  const branches = mapping(push)?.branches;
+  return typeof branches === "string" ? branches.length > 0 : Array.isArray(branches) && branches.some((branch) => typeof branch === "string" && branch.length > 0);
+}
+function jobs(workflow) {
+  return mapping(workflow.jobs) ?? {};
+}
+function steps(job) {
+  const entries = mapping(job)?.steps;
+  return Array.isArray(entries) ? entries.flatMap((entry) => {
+    const step = mapping(entry);
+    return step ? [step] : [];
+  }) : [];
+}
+function runsScript(run, name) {
+  if (typeof run !== "string") return false;
+  return new RegExp(`(?:^|[\\n;&|])\\s*npm\\s+run\\s+${name}(?=\\s|$)`).test(run);
+}
+function runsNpmCi(run) {
+  return typeof run === "string" && /(?:^|[\n;&|])\s*npm\s+ci(?=\s|$)/.test(run);
+}
+function usesAction(value, action) {
+  return typeof value === "string" && value.startsWith(`${action}@`);
+}
+function readWorkflows(dir) {
+  const workflows = [];
+  const errors = [];
+  for (const file of readdirSync4(dir).filter((name) => /\.ya?ml$/i.test(name)).sort()) {
+    try {
+      const parsed = parse2(readFileSync11(path46.join(dir, file), "utf8"), { uniqueKeys: true });
+      const content = mapping(parsed);
+      if (!content) throw new Error("expected a YAML mapping");
+      workflows.push(content);
+    } catch (error) {
+      errors.push(`${file}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return { workflows, errors };
+}
+var ciChecksRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: {
+      description: "Require GitHub Actions validation for pull requests and branch pushes."
+    }
+  },
+  create(context) {
+    return {
+      Document(node) {
+        if (!context.filename.endsWith("package.json")) return;
+        const dir = path46.join(context.cwd, ".github", "workflows");
+        if (!existsSync6(dir)) return;
+        const report3 = (message) => {
+          context.report({ node, message });
+        };
+        const { workflows, errors } = readWorkflows(dir);
+        for (const error of errors) report3(`Invalid GitHub Actions workflow: ${error}`);
+        const check = workflows.find(
+          (workflow) => Object.hasOwn(events(workflow), "pull_request") && branchesTrigger(workflow)
+        );
+        if (!check) {
+          report3("GitHub Actions must run shared checks for pull requests and branch pushes.");
+          return;
+        }
+        const scripts = scriptsOf(node.body);
+        const requiredScripts = ["format", "lint", "typecheck", "test:unit:coverage:check"];
+        if (scripts.has("build")) requiredScripts.push("build");
+        const checkJobs = Object.values(jobs(check));
+        const allSteps = checkJobs.flatMap(steps);
+        for (const job of checkJobs) {
+          const jobSteps = steps(job);
+          const firstCheck = jobSteps.findIndex((step) => requiredScripts.some((name) => runsScript(step.run, name)));
+          if (firstCheck < 0) continue;
+          const checkout = jobSteps.findIndex((step) => usesAction(step.uses, "actions/checkout"));
+          const install = jobSteps.findIndex((step) => runsNpmCi(step.run));
+          if (checkout < 0 || checkout >= firstCheck) {
+            report3("GitHub Actions checks must check out the repository before running npm scripts.");
+          }
+          if (install < 0 || install >= firstCheck || checkout >= 0 && install <= checkout) {
+            report3("GitHub Actions checks must install dependencies with npm ci.");
+          }
+        }
+        for (const name of requiredScripts) {
+          if (!allSteps.some((step) => runsScript(step.run, name))) {
+            report3(`GitHub Actions checks must run npm run ${name}.`);
+          }
+        }
+        const coverage = scripts.get("test:unit:coverage:check");
+        if (!coverage || !/npm\s+run\s+test:unit:coverage(?=\s|$)/.test(coverage) || !coverage.includes("--coverage.thresholds.autoUpdate=false") || !/&&\s*git\s+diff\s+--exit-code/.test(coverage)) {
+          report3(
+            "package.json must declare test:unit:coverage:check that runs coverage with autoUpdate=false and verifies no Git diff."
+          );
+        }
+      }
+    };
+  }
+};
+
+// eslint/rules/package-json/exact-version.ts
+function memberName3(member) {
+  return member.name.type === "String" ? member.name.value : member.name.name;
+}
 var EXACT_VERSION_PATTERN = /^\d+\.\d+\.\d+$/;
 function memberValue(member) {
   return member.value.type === "String" ? member.value.value : null;
@@ -6259,7 +6697,7 @@ var exactVersionRule = {
         const root = node.body;
         if (root.type !== "Object") return;
         for (const key of ["dependencies", "devDependencies"]) {
-          const section = root.members.find((member) => memberName2(member) === key);
+          const section = root.members.find((member) => memberName3(member) === key);
           if (section?.value.type !== "Object") continue;
           for (const member of section.value.members) {
             const version = memberValue(member);
@@ -6267,7 +6705,7 @@ var exactVersionRule = {
             if (!EXACT_VERSION_PATTERN.test(version)) {
               context.report({
                 node: member,
-                message: `${memberName2(member)} must pin an exact version (e.g. "1.2.3"), not a range or cap such as "${version}".`
+                message: `${memberName3(member)} must pin an exact version (e.g. "1.2.3"), not a range or cap such as "${version}".`
               });
             }
           }
@@ -6278,7 +6716,7 @@ var exactVersionRule = {
 };
 
 // eslint/rules/package-json/lint-setup.ts
-function memberName3(member) {
+function memberName4(member) {
   return member.name.type === "String" ? member.name.value : member.name.name;
 }
 function memberValue2(member) {
@@ -6320,9 +6758,9 @@ var lintSetupRule = {
       Document(node) {
         const root = node.body;
         if (root.type !== "Object") return;
-        const scripts = root.members.find((member) => memberName3(member) === "scripts");
+        const scripts = root.members.find((member) => memberName4(member) === "scripts");
         const scriptMembers = scripts?.value.type === "Object" ? scripts.value.members : [];
-        const findScript = (name) => scriptMembers.find((member) => memberName3(member) === name);
+        const findScript = (name) => scriptMembers.find((member) => memberName4(member) === name);
         const lint = findScript("lint");
         const lintCommand = memberValue2(lint);
         if (lintCommand === void 0 || !runsEslintDirectly(lintCommand) || !REPOSITORY_ARGUMENT_PATTERN.test(lintCommand)) {
@@ -6355,10 +6793,10 @@ var lintSetupRule = {
             message: 'package.json must declare a "format:staged" script that runs prettier with no repository-wide argument (e.g. "prettier --write").'
           });
         }
-        const lintStagedConfig = root.members.find((member) => memberName3(member) === "lint-staged");
+        const lintStagedConfig = root.members.find((member) => memberName4(member) === "lint-staged");
         const stagedMembers = lintStagedConfig?.value.type === "Object" ? lintStagedConfig.value.members : [];
         const runsStagedScriptForGlob = (name, matchesGlob) => stagedMembers.some(
-          (member) => matchesGlob(memberName3(member)) && stringValues(member.value).some((command) => runsNamedScript(command, name))
+          (member) => matchesGlob(memberName4(member)) && stringValues(member.value).some((command) => runsNamedScript(command, name))
         );
         const runsStagedScriptForExtension = (name, extension) => runsStagedScriptForGlob(name, (glob) => globIncludesExtension(glob, extension));
         const hasStagedSourceLint = runsStagedScriptForGlob("lint:staged", (glob) => SOURCE_GLOB_PATTERN.test(glob));
@@ -6409,13 +6847,13 @@ var NEXTJS_STACK_DEV_DEPENDENCIES = [
   "@testing-library/react",
   "@testing-library/dom"
 ];
-function memberName4(member) {
+function memberName5(member) {
   return member.name.type === "String" ? member.name.value : member.name.name;
 }
 function sectionPackages(root, section) {
-  const member = root.type === "Object" ? root.members.find((entry) => memberName4(entry) === section) : void 0;
+  const member = root.type === "Object" ? root.members.find((entry) => memberName5(entry) === section) : void 0;
   if (member?.value.type !== "Object") return /* @__PURE__ */ new Set();
-  return new Set(member.value.members.map(memberName4));
+  return new Set(member.value.members.map(memberName5));
 }
 var nextjsStackRule = {
   meta: {
@@ -6452,9 +6890,9 @@ var nextjsStackRule = {
 };
 
 // eslint/rules/package-json/vitest-coverage.ts
-import { existsSync as existsSync5, readFileSync as readFileSync10 } from "fs";
-import path45 from "path";
-function memberName5(member) {
+import { existsSync as existsSync7, readFileSync as readFileSync12 } from "fs";
+import path47 from "path";
+function memberName6(member) {
   return member.name.type === "String" ? member.name.value : member.name.name;
 }
 function memberValue3(member) {
@@ -6492,9 +6930,9 @@ var vitestCoverageRule = {
       Document(node) {
         const root = node.body;
         if (root.type !== "Object") return;
-        const devDependencies = root.members.find((member) => memberName5(member) === "devDependencies");
+        const devDependencies = root.members.find((member) => memberName6(member) === "devDependencies");
         const devDependencyNames = new Set(
-          devDependencies?.value.type === "Object" ? devDependencies.value.members.map(memberName5) : []
+          devDependencies?.value.type === "Object" ? devDependencies.value.members.map(memberName6) : []
         );
         if (!devDependencyNames.has("vitest")) {
           context.report({ node, message: "vitest must be listed in package.json as a devDependency." });
@@ -6505,9 +6943,9 @@ var vitestCoverageRule = {
             message: "@vitest/coverage-v8 must be listed in package.json as a devDependency."
           });
         }
-        const scripts = root.members.find((member) => memberName5(member) === "scripts");
+        const scripts = root.members.find((member) => memberName6(member) === "scripts");
         const scriptMembers = scripts?.value.type === "Object" ? scripts.value.members : [];
-        const unit = scriptMembers.find((member) => memberName5(member) === "test:unit");
+        const unit = scriptMembers.find((member) => memberName6(member) === "test:unit");
         const unitCommand = memberValue3(unit);
         if (unitCommand === void 0 || !/\bvitest\b/.test(unitCommand) || COVERAGE_FLAG_PATTERN.test(unitCommand)) {
           context.report({
@@ -6515,7 +6953,7 @@ var vitestCoverageRule = {
             message: 'package.json must declare a "test:unit" script that runs Vitest without coverage.'
           });
         }
-        const coverage = scriptMembers.find((member) => memberName5(member) === "test:unit:coverage");
+        const coverage = scriptMembers.find((member) => memberName6(member) === "test:unit:coverage");
         const coverageCommand = memberValue3(coverage);
         if (coverageCommand === void 0 || !/\bvitest\b/.test(coverageCommand) || !COVERAGE_FLAG_PATTERN.test(coverageCommand)) {
           context.report({
@@ -6523,7 +6961,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) => existsSync5(path45.join(context.cwd, name)));
+        const configName = VITEST_CONFIG_NAMES.find((name) => existsSync7(path47.join(context.cwd, name)));
         if (!configName) {
           context.report({
             node,
@@ -6531,7 +6969,7 @@ var vitestCoverageRule = {
           });
           return;
         }
-        const content = readFileSync10(path45.join(context.cwd, configName), "utf8");
+        const content = readFileSync12(path47.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}.` });
@@ -6543,7 +6981,7 @@ var vitestCoverageRule = {
             message: `${configName} must enable coverage.thresholds.autoUpdate with true or the monotonic 0.1-point buffered formatter.`
           });
         }
-        const stagedTests = scriptMembers.find((member) => memberName5(member) === "test:unit:staged");
+        const stagedTests = scriptMembers.find((member) => memberName6(member) === "test:unit:staged");
         const stagedTestsCommand = memberValue3(stagedTests);
         if (stagedTestsCommand === void 0 || !/\bvitest\b/.test(stagedTestsCommand) || !RELATED_PATTERN.test(stagedTestsCommand) || COVERAGE_FLAG_PATTERN.test(stagedTestsCommand)) {
           context.report({
@@ -6551,9 +6989,9 @@ var vitestCoverageRule = {
             message: 'package.json must declare a "test:unit:staged" script that runs vitest related without coverage.'
           });
         }
-        const lintStaged = root.members.find((member) => memberName5(member) === "lint-staged");
+        const lintStaged = root.members.find((member) => memberName6(member) === "lint-staged");
         const hasStagedTests = lintStaged?.value.type === "Object" && lintStaged.value.members.some(
-          (member) => SOURCE_GLOB_PATTERN2.test(memberName5(member)) && stringValues2(member.value).some((command) => command.includes("npm run test:unit:staged"))
+          (member) => SOURCE_GLOB_PATTERN2.test(memberName6(member)) && stringValues2(member.value).some((command) => command.includes("npm run test:unit:staged"))
         );
         if (!hasStagedTests) {
           context.report({
@@ -6568,6 +7006,7 @@ var vitestCoverageRule = {
 
 // eslint/rules/package-json/index.ts
 var repoPackageJsonRules = {
+  "ci-checks": ciChecksRule,
   "exact-version": exactVersionRule,
   "lint-setup": lintSetupRule,
   "vitest-coverage": vitestCoverageRule
@@ -6577,8 +7016,8 @@ var nextjsPackageJsonRules = {
 };
 
 // eslint/rules/prefer-enum.ts
-import path46 from "path";
-import ts9 from "typescript";
+import path48 from "path";
+import ts10 from "typescript";
 function isConstAssertion(node) {
   const typeAnnotation = node.typeAnnotation;
   return typeAnnotation?.type === "TSTypeReference" && typeAnnotation.typeName?.type === "Identifier" && typeAnnotation.typeName.name === "const";
@@ -6600,7 +7039,7 @@ function isZodCall(node, method) {
   const { callee } = node;
   return callee?.type === "MemberExpression" && !callee.computed && callee.object.type === "Identifier" && callee.object.name === "z" && callee.property.type === "Identifier" && callee.property.name === method;
 }
-function propertyName4(property) {
+function propertyName5(property) {
   if (property.computed) return void 0;
   if (property.key.type === "Identifier") return property.key.name;
   if (property.key.type === "Literal" && typeof property.key.value === "string") return property.key.value;
@@ -6611,7 +7050,7 @@ function rawZodDiscriminantLiteral(schemaCall, discriminator) {
   const shape = schemaCall.arguments[0];
   if (shape?.type !== "ObjectExpression") return void 0;
   for (const property of shape.properties) {
-    if (property.type !== "Property" || propertyName4(property) !== discriminator) continue;
+    if (property.type !== "Property" || propertyName5(property) !== discriminator) continue;
     if (property.value.type !== "CallExpression" || !isZodCall(property.value, "literal")) return void 0;
     const literal = property.value.arguments[0];
     if (literal?.type === "Literal" && (typeof literal.value === "string" || typeof literal.value === "number")) {
@@ -6632,13 +7071,13 @@ function isLiteralTupleAssertion(node) {
   return values.every((value) => value !== void 0) && new Set(values).size >= 2;
 }
 function isTsLiteralTupleDeclaration(declaration) {
-  if (!ts9.isVariableDeclaration(declaration) || !declaration.initializer) return false;
+  if (!ts10.isVariableDeclaration(declaration) || !declaration.initializer) return false;
   const init = declaration.initializer;
-  if (!ts9.isAsExpression(init) || !ts9.isTypeReferenceNode(init.type) || !ts9.isIdentifier(init.type.typeName) || init.type.typeName.text !== "const" || !ts9.isArrayLiteralExpression(init.expression) || init.expression.elements.length < 2) {
+  if (!ts10.isAsExpression(init) || !ts10.isTypeReferenceNode(init.type) || !ts10.isIdentifier(init.type.typeName) || init.type.typeName.text !== "const" || !ts10.isArrayLiteralExpression(init.expression) || init.expression.elements.length < 2) {
     return false;
   }
   const values = init.expression.elements.map(
-    (element) => ts9.isStringLiteral(element) || ts9.isNumericLiteral(element) ? element.text : void 0
+    (element) => ts10.isStringLiteral(element) || ts10.isNumericLiteral(element) ? element.text : void 0
   );
   return values.every((value) => value !== void 0) && new Set(values).size >= 2;
 }
@@ -6651,9 +7090,9 @@ var preferEnumRule = {
     }
   },
   create(context) {
-    const filename = path46.resolve(context.filename);
+    const filename = path48.resolve(context.filename);
     const sourceRoot = sourceRootOf(context);
-    if (!filename.startsWith(sourceRoot + path46.sep)) return {};
+    if (!filename.startsWith(sourceRoot + path48.sep)) return {};
     const objectSchemas = /* @__PURE__ */ new Map();
     const literalTuples = /* @__PURE__ */ new Set();
     const enumTupleUses = [];
@@ -6667,7 +7106,7 @@ var preferEnumRule = {
       const checker = services.program.getTypeChecker();
       const symbol = checker.getSymbolAtLocation(tsNode);
       if (!symbol) return false;
-      const original = symbol.flags === ts9.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+      const original = symbol.flags === ts10.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
       return (original.declarations ?? []).some(isTsLiteralTupleDeclaration);
     }
     return {
@@ -6762,8 +7201,8 @@ var preferEnumRule = {
 };
 
 // eslint/rules/prefer-object-destructuring.ts
-import ts10 from "typescript";
-var DOC6 = "See docs/next-codebase-guide/rules/redundant-aliases-rule.md";
+import ts11 from "typescript";
+var DOC7 = "See docs/next-codebase-guide/rules/redundant-aliases-rule.md";
 function hasTypeAnnotation(identifier) {
   return "typeAnnotation" in identifier && identifier.typeAnnotation !== void 0;
 }
@@ -6775,19 +7214,19 @@ function directPropertyBinding(context, declarator, isEnumValue) {
   if (member.computed || member.optional || member.property.type !== "Identifier") return void 0;
   if (!memberCanBecomeLocal(member)) return void 0;
   if (context.sourceCode.getCommentsInside(declarator).length > 0) return void 0;
-  const propertyName5 = member.property.name;
+  const propertyName6 = member.property.name;
   const localName = declarator.id.name;
-  if (propertyName5 !== localName) return void 0;
+  if (propertyName6 !== localName) return void 0;
   const source = member.object;
   const sourceText = context.sourceCode.getText(source);
   return {
     declarator,
     member,
-    propertyName: propertyName5,
+    propertyName: propertyName6,
     localName,
     source,
     sourceText,
-    bindingText: propertyName5
+    bindingText: propertyName6
   };
 }
 function canGroupSource(source) {
@@ -6805,8 +7244,8 @@ function rootIdentifierName(node) {
   if (node.type !== "MemberExpression" || node.object.type === "Super") return void 0;
   return rootIdentifierName(node.object);
 }
-function isCompliantLocalName(propertyName5) {
-  return !propertyName5.includes("_") || /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/u.test(propertyName5);
+function isCompliantLocalName(propertyName6) {
+  return !propertyName6.includes("_") || /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/u.test(propertyName6);
 }
 function propertyNameOf(node) {
   if (node.type !== "Property" || node.computed) return void 0;
@@ -6855,8 +7294,8 @@ function enumValueResolver(context) {
   const checker = services.program.getTypeChecker();
   const { esTreeNodeToTSNodeMap: nodeMap } = services;
   const isEnumSymbol = (symbol) => {
-    const resolved = symbol.flags === ts10.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
-    return (resolved.declarations ?? []).some((declaration) => ts10.isEnumDeclaration(declaration));
+    const resolved = symbol.flags === ts11.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+    return (resolved.declarations ?? []).some((declaration) => ts11.isEnumDeclaration(declaration));
   };
   return (node) => {
     const tsNode = nodeMap.get(node);
@@ -6872,27 +7311,27 @@ function detachableCallResolver(context) {
   if (!services) return () => false;
   const checker = services.program.getTypeChecker();
   const { esTreeNodeToTSNodeMap: nodeMap } = services;
-  const isUnboundFunctionType = (type) => ts10.isFunctionTypeNode(type) && !type.parameters.some((parameter) => ts10.isIdentifier(parameter.name) && parameter.name.text === "this");
+  const isUnboundFunctionType = (type) => ts11.isFunctionTypeNode(type) && !type.parameters.some((parameter) => ts11.isIdentifier(parameter.name) && parameter.name.text === "this");
   return (member) => {
     const node = nodeMap.get(member);
-    if (!node || !ts10.isPropertyAccessExpression(node)) return false;
+    if (!node || !ts11.isPropertyAccessExpression(node)) return false;
     const symbol = checker.getSymbolAtLocation(node.name);
     const declarations = symbol?.declarations;
     if (!declarations?.length) return false;
     return declarations.every((declaration) => {
-      if (ts10.isPropertySignature(declaration) || ts10.isPropertyDeclaration(declaration)) {
-        return declaration.type !== void 0 && isUnboundFunctionType(declaration.type) || ts10.isPropertyDeclaration(declaration) && declaration.initializer !== void 0 && ts10.isArrowFunction(declaration.initializer);
+      if (ts11.isPropertySignature(declaration) || ts11.isPropertyDeclaration(declaration)) {
+        return declaration.type !== void 0 && isUnboundFunctionType(declaration.type) || ts11.isPropertyDeclaration(declaration) && declaration.initializer !== void 0 && ts11.isArrowFunction(declaration.initializer);
       }
-      if (ts10.isPropertyAssignment(declaration)) return ts10.isArrowFunction(declaration.initializer);
+      if (ts11.isPropertyAssignment(declaration)) return ts11.isArrowFunction(declaration.initializer);
       return false;
     });
   };
 }
 function directMappingRequiresQualifiedAccess(context, ownershipResolver, member) {
-  const mapping = renamedDirectMapping(context, member);
-  if (!mapping || !ownershipResolver) return false;
-  const sourceResolution = ownershipResolver.sourceMember(mapping.sourceMember);
-  const targetResolution = ownershipResolver.targetProperty(mapping.property, mapping.targetName);
+  const mapping2 = renamedDirectMapping(context, member);
+  if (!mapping2 || !ownershipResolver) return false;
+  const sourceResolution = ownershipResolver.sourceMember(mapping2.sourceMember);
+  const targetResolution = ownershipResolver.targetProperty(mapping2.property, mapping2.targetName);
   return sourceResolution.kind === "data-contract" || targetResolution.kind === "data-contract";
 }
 function memberCanBeDestructured(context, ownershipResolver, member, isEnumValue) {
@@ -6928,10 +7367,10 @@ function recordMemberUsage(context, scope, ownershipResolver, member, isEnumValu
   if (!isGroupedUsageSource(member.object) || !memberIsRead(context, member, detachableCall)) return;
   const sourceText = context.sourceCode.getText(member.object);
   const usage = objectUsage(scope, sourceText);
-  const propertyName5 = member.property.name;
-  usage.propertyNames.add(propertyName5);
+  const propertyName6 = member.property.name;
+  usage.propertyNames.add(propertyName6);
   if (!memberIsDirectVariableInitializer(context, member)) {
-    usage.directMembers.push({ member, propertyName: propertyName5 });
+    usage.directMembers.push({ member, propertyName: propertyName6 });
   }
 }
 function recordDestructuringUsage(context, scope, declaration, isEnumValue) {
@@ -6954,7 +7393,7 @@ function recordDestructuringUsage(context, scope, declaration, isEnumValue) {
 }
 function scopeUsageMessage(sourceText, propertyNames) {
   const names = [...propertyNames].map((name) => `"${name}"`).join(", ");
-  return `${names} are read from "${sourceText}" in the same block. Destructure them together in one declaration. ${DOC6}`;
+  return `${names} are read from "${sourceText}" in the same block. Destructure them together in one declaration. ${DOC7}`;
 }
 function hasBinding(context, node, name) {
   const initialScope = context.sourceCode.getScope(node);
@@ -7058,13 +7497,13 @@ function groupedDestructuringSelections(context, first, isEnumValue) {
     if (!previous || nextNode?.type !== "VariableDeclaration" || nextNode.kind !== first.declaration.kind) break;
     const next = destructuringSelection(context, nextNode, isEnumValue);
     if (next?.sourceText !== first.sourceText) break;
-    if (next.propertyNames.some((propertyName5) => seenProperties.has(propertyName5))) break;
+    if (next.propertyNames.some((propertyName6) => seenProperties.has(propertyName6))) break;
     const [, previousEnd] = context.sourceCode.getRange(previous);
     const [nextStart] = context.sourceCode.getRange(nextNode);
     const gap = context.sourceCode.text.slice(previousEnd, nextStart);
     if (!whitespaceKeepsStatementsAdjacent(gap)) break;
     group.push(next);
-    for (const propertyName5 of next.propertyNames) seenProperties.add(propertyName5);
+    for (const propertyName6 of next.propertyNames) seenProperties.add(propertyName6);
   }
   return group;
 }
@@ -7072,19 +7511,19 @@ function declarationTerminator(context, declaration) {
   return context.sourceCode.getText(declaration).trimEnd().endsWith(";") ? ";" : "";
 }
 function singlePropertyMessage(binding) {
-  return `"${binding.propertyName}" is the only property bound from "${binding.sourceText}". Read "${binding.sourceText}.${binding.propertyName}" directly instead of creating a local binding. ${DOC6}`;
+  return `"${binding.propertyName}" is the only property bound from "${binding.sourceText}". Read "${binding.sourceText}.${binding.propertyName}" directly instead of creating a local binding. ${DOC7}`;
 }
 function groupMessage(bindings) {
   const firstBinding = bindings[0];
-  if (!firstBinding) return `Use one object destructuring declaration. ${DOC6}`;
+  if (!firstBinding) return `Use one object destructuring declaration. ${DOC7}`;
   const names = bindings.map(({ localName }) => `"${localName}"`).join(", ");
-  return `${names} are derived directly from properties of "${firstBinding.sourceText}". Use one object destructuring declaration. ${DOC6}`;
+  return `${names} are derived directly from properties of "${firstBinding.sourceText}". Use one object destructuring declaration. ${DOC7}`;
 }
 function repeatedDestructuringMessage(group) {
   const first = group[0];
-  if (!first) return `Combine repeated destructuring into one declaration. ${DOC6}`;
+  if (!first) return `Combine repeated destructuring into one declaration. ${DOC7}`;
   const names = group.flatMap(({ localNames }) => localNames).map((name) => `"${name}"`).join(", ");
-  return `${names} destructure the same source "${first.sourceText}" repeatedly. Combine them into one object destructuring declaration. ${DOC6}`;
+  return `${names} destructure the same source "${first.sourceText}" repeatedly. Combine them into one object destructuring declaration. ${DOC7}`;
 }
 var preferObjectDestructuringRule = {
   meta: {
@@ -7118,9 +7557,9 @@ var preferObjectDestructuringRule = {
         const { member: firstDirectMember } = firstDirectUsage;
         const propertyNames = [...usage.propertyNames];
         const missingPropertyNames = propertyNames.filter(
-          (propertyName5) => !usage.destructuring?.propertyNames.has(propertyName5)
+          (propertyName6) => !usage.destructuring?.propertyNames.has(propertyName6)
         );
-        if (missingPropertyNames.some((propertyName5) => hasBinding(context, firstDirectMember, propertyName5))) {
+        if (missingPropertyNames.some((propertyName6) => hasBinding(context, firstDirectMember, propertyName6))) {
           continue;
         }
         context.report({
@@ -7134,7 +7573,7 @@ var preferObjectDestructuringRule = {
               return null;
             }
             const memberFixes = usage.directMembers.map(
-              ({ member, propertyName: propertyName5 }) => fixer.replaceText(member, propertyName5)
+              ({ member, propertyName: propertyName6 }) => fixer.replaceText(member, propertyName6)
             );
             if (usage.destructuring) {
               if (missingPropertyNames.length === 0) return memberFixes;
@@ -7173,7 +7612,7 @@ ${indentation}`;
           continue;
         }
         if (fromSameSource.length > 1) {
-          const names = new Set(fromSameSource.map(({ propertyName: propertyName5 }) => propertyName5));
+          const names = new Set(fromSameSource.map(({ propertyName: propertyName6 }) => propertyName6));
           if (names.size > 1) {
             context.report({ node: binding.node, message: scopeUsageMessage(binding.sourceText, names) });
             continue;
@@ -7202,7 +7641,7 @@ ${indentation}`;
           const sourceText = context.sourceCode.getText(declarator.init);
           context.report({
             node: declarator.id,
-            message: `"${sourceText}" is an enum. Keep enum member accesses qualified instead of destructuring it. ${DOC6}`
+            message: `"${sourceText}" is an enum. Keep enum member accesses qualified instead of destructuring it. ${DOC7}`
           });
         }
         recordDestructuringUsage(context, currentUsageScope(), node, isEnumValue);
@@ -7213,12 +7652,12 @@ ${indentation}`;
           if (group.length <= 1) {
             if (node.kind === "const" && selection.propertyNames.length === 1 && supportsSinglePropertySource(selection.source)) {
               const declarator = node.declarations[0];
-              const propertyName5 = selection.propertyNames[0];
-              if (declarator && propertyName5) {
+              const propertyName6 = selection.propertyNames[0];
+              if (declarator && propertyName6) {
                 currentUsageScope()?.singleProperties.push({
                   node: declarator.id,
                   sourceText: selection.sourceText,
-                  propertyName: propertyName5
+                  propertyName: propertyName6
                 });
               }
             }
@@ -7248,7 +7687,7 @@ ${indentation}`;
         if (bindings.length === 0) return;
         const firstBinding = bindings[0];
         if (!firstBinding) return;
-        const sameSourceBindings = bindings.length > 1 && bindings.length === node.declarations.length && bindings.every(({ sourceText }) => sourceText === firstBinding.sourceText) && new Set(bindings.map(({ propertyName: propertyName5 }) => propertyName5)).size === bindings.length;
+        const sameSourceBindings = bindings.length > 1 && bindings.length === node.declarations.length && bindings.every(({ sourceText }) => sourceText === firstBinding.sourceText) && new Set(bindings.map(({ propertyName: propertyName6 }) => propertyName6)).size === bindings.length;
         if (sameSourceBindings) {
           context.report({
             node,
@@ -7303,7 +7742,7 @@ ${indentation}`;
 };
 
 // eslint/rules/pure-function-extract.ts
-import path47 from "path";
+import path49 from "path";
 var ROUTE_HANDLER_EXPORT_NAMES = /* @__PURE__ */ new Set([
   "GET",
   "POST",
@@ -7368,12 +7807,12 @@ var pureFunctionExtractRule = {
   },
   create(context) {
     const filename = context.filename;
-    const isRouteFile = path47.basename(filename) === "route.ts";
+    const isRouteFile = path49.basename(filename) === "route.ts";
     const isComponentFile = filename.endsWith(".tsx") || filename.endsWith(".jsx");
     const sourceRoot = sourceRootOf(context);
-    const relative = path47.relative(sourceRoot, filename);
+    const relative = path49.relative(sourceRoot, filename);
     if (relative.startsWith("..")) return {};
-    const segments = relative.split(path47.sep);
+    const segments = relative.split(path49.sep);
     const folders = segments.slice(0, -1);
     const isHookSupportFile = folders.includes("hooks") && /\.(?:[cm]?[jt]s)$/.test(filename);
     if (!isComponentFile && !isRouteFile && !isHookSupportFile) return {};
@@ -7433,15 +7872,15 @@ var pureFunctionExtractRule = {
 };
 
 // eslint/rules/repeated-numeric-value.ts
-import path48 from "path";
+import path50 from "path";
 function isNonProductionFile(file, sourceRoot) {
-  const relative = path48.relative(sourceRoot, file);
-  const segments = relative.split(path48.sep);
-  const basename = path48.basename(file);
+  const relative = path50.relative(sourceRoot, file);
+  const segments = relative.split(path50.sep);
+  const basename = path50.basename(file);
   return /\.(?:test|spec|mock)\.[^.]+$/.test(basename) || segments.some((segment) => segment === "__tests__" || segment === "__mocks__" || segment === "mocks");
 }
 function isCanonicalConstantFile(file, sourceRoot) {
-  const segments = path48.relative(sourceRoot, file).split(path48.sep);
+  const segments = path50.relative(sourceRoot, file).split(path50.sep);
   return segments.includes("constants") || segments[0] === "config";
 }
 function groupKey(literal) {
@@ -7457,7 +7896,7 @@ var repeatedNumericValueRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path48.resolve(context.filename);
+    const file = path50.resolve(context.filename);
     if (isNonProductionFile(file, sourceRoot) || isCanonicalConstantFile(file, sourceRoot)) return {};
     const index = getProjectIndex(sourceRoot);
     if (!index) return {};
@@ -7494,11 +7933,11 @@ var repeatedNumericValueRule = {
 };
 
 // eslint/rules/repeated-semantic-literal.ts
-import path50 from "path";
+import path52 from "path";
 
 // eslint/rules/imported-enum-literals.ts
-import path49 from "path";
-import ts11 from "typescript";
+import path51 from "path";
+import ts12 from "typescript";
 var columnMethods2 = /* @__PURE__ */ new Set([
   "eq",
   "neq",
@@ -7514,13 +7953,13 @@ var columnMethods2 = /* @__PURE__ */ new Set([
   "filter",
   "not"
 ]);
-function memberName6(name) {
-  if (ts11.isIdentifier(name) || ts11.isStringLiteral(name)) return name.text;
+function memberName7(name) {
+  if (ts12.isIdentifier(name) || ts12.isStringLiteral(name)) return name.text;
   return void 0;
 }
 function isWithin3(root, file) {
-  const relative = path49.relative(root, file);
-  return relative === "" || !relative.startsWith("..") && !path49.isAbsolute(relative);
+  const relative = path51.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path51.isAbsolute(relative);
 }
 function domainOf(name) {
   if (name.endsWith("ColumnEnum")) return "column";
@@ -7530,23 +7969,23 @@ function domainOf(name) {
 function importedEnums(file, checker, sourceRoot, importedNames) {
   const matches = /* @__PURE__ */ new Map();
   for (const statement of file.statements) {
-    if (!ts11.isImportDeclaration(statement) || !statement.importClause?.namedBindings || !ts11.isNamedImports(statement.importClause.namedBindings)) {
+    if (!ts12.isImportDeclaration(statement) || !statement.importClause?.namedBindings || !ts12.isNamedImports(statement.importClause.namedBindings)) {
       continue;
     }
     for (const specifier of statement.importClause.namedBindings.elements) {
       if (!importedNames.has(specifier.name.text)) continue;
       const symbol = checker.getSymbolAtLocation(specifier.name);
       if (!symbol) continue;
-      const resolved = symbol.flags === ts11.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+      const resolved = symbol.flags === ts12.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
       for (const declaration of resolved.declarations ?? []) {
-        if (!ts11.isEnumDeclaration(declaration)) continue;
-        const declarationFile = path49.resolve(declaration.getSourceFile().fileName);
+        if (!ts12.isEnumDeclaration(declaration)) continue;
+        const declarationFile = path51.resolve(declaration.getSourceFile().fileName);
         if (!isWithin3(sourceRoot, declarationFile)) continue;
         const domain = domainOf(declaration.name.text);
         if (!domain) continue;
         for (const member of declaration.members) {
-          if (!member.initializer || !ts11.isStringLiteral(member.initializer)) continue;
-          const name = memberName6(member.name);
+          if (!member.initializer || !ts12.isStringLiteral(member.initializer)) continue;
+          const name = memberName7(member.name);
           if (!name) continue;
           const entries = matches.get(member.initializer.text) ?? [];
           entries.push({
@@ -7562,25 +8001,25 @@ function importedEnums(file, checker, sourceRoot, importedNames) {
   return matches;
 }
 function isPathname2(node) {
-  return ts11.isPropertyAccessExpression(node) && node.name.text === "pathname";
+  return ts12.isPropertyAccessExpression(node) && node.name.text === "pathname";
 }
 function domainForUse(node) {
   const parent = node.parent;
-  if (ts11.isPropertyAssignment(parent) && parent.initializer === node && memberName6(parent.name) === "path") {
+  if (ts12.isPropertyAssignment(parent) && parent.initializer === node && memberName7(parent.name) === "path") {
     return "route";
   }
-  if (ts11.isCallExpression(parent) && parent.arguments[0] === node && ts11.isPropertyAccessExpression(parent.expression)) {
+  if (ts12.isCallExpression(parent) && parent.arguments[0] === node && ts12.isPropertyAccessExpression(parent.expression)) {
     const { expression, name } = parent.expression;
     if (columnMethods2.has(name.text)) return "column";
     if (name.text === "startsWith" && isPathname2(expression)) return "route";
   }
-  if (ts11.isBinaryExpression(parent) && (parent.operatorToken.kind === ts11.SyntaxKind.EqualsEqualsEqualsToken || parent.operatorToken.kind === ts11.SyntaxKind.ExclamationEqualsEqualsToken) && (parent.left === node && isPathname2(parent.right) || parent.right === node && isPathname2(parent.left))) {
+  if (ts12.isBinaryExpression(parent) && (parent.operatorToken.kind === ts12.SyntaxKind.EqualsEqualsEqualsToken || parent.operatorToken.kind === ts12.SyntaxKind.ExclamationEqualsEqualsToken) && (parent.left === node && isPathname2(parent.right) || parent.right === node && isPathname2(parent.left))) {
     return "route";
   }
   return void 0;
 }
 function importedEnumLiteralUses(context, root) {
-  const filename = path49.resolve(context.filename);
+  const filename = path51.resolve(context.filename);
   if (!isWithin3(root, filename)) return [];
   const services = typedParserServices(context.sourceCode.parserServices);
   if (!services) return [];
@@ -7596,7 +8035,7 @@ function importedEnumLiteralUses(context, root) {
   if (matches.size === 0) return [];
   const uses = [];
   const visit = (node) => {
-    if (ts11.isStringLiteral(node)) {
+    if (ts12.isStringLiteral(node)) {
       const domain = domainForUse(node);
       const candidates = matches.get(node.text)?.filter((entry) => entry.domain === domain) ?? [];
       if (candidates.length === 1) {
@@ -7613,14 +8052,14 @@ function importedEnumLiteralUses(context, root) {
         }
       }
     }
-    ts11.forEachChild(node, visit);
+    ts12.forEachChild(node, visit);
   };
   visit(file);
   return uses;
 }
 
 // eslint/rules/repeated-semantic-literal.ts
-var DOC7 = "See docs/next-codebase-guide/rules/constants-rule.md";
+var DOC8 = "See docs/next-codebase-guide/rules/constants-rule.md";
 var closedDomainFamilies = /* @__PURE__ */ new Set(["api-route", "event", "storage"]);
 function canonicalMatches(use, canonical, sourceRoot) {
   if (use.kind !== canonical.kind || use.value !== canonical.value) return false;
@@ -7634,7 +8073,7 @@ function canonicalMatches(use, canonical, sourceRoot) {
     const semanticName2 = use.family.split(":")[1];
     if (!semanticName2 || !name.toLowerCase().includes(semanticName2.toLowerCase())) return false;
     const location = featureOf(canonical.file, sourceRoot);
-    return location === featureOf(use.file, sourceRoot) || path50.relative(sourceRoot, canonical.file).split(path50.sep)[0] === "constants";
+    return location === featureOf(use.file, sourceRoot) || path52.relative(sourceRoot, canonical.file).split(path52.sep)[0] === "constants";
   }
   return false;
 }
@@ -7648,14 +8087,14 @@ function messageFor(use, matches, duplicateRouteDomains, existingRouteEnum, root
   const count = new Set(matches.map((match) => match.file)).size;
   const kind = use.kind === "string" ? "string" : "numeric";
   if (use.family === "api-route" && existingRouteEnum?.owner) {
-    const location = path50.relative(root, existingRouteEnum.file).replaceAll(path50.sep, "/");
-    return `The route ${formatValue(use)} repeats; add a member to existing ${existingRouteEnum.owner} in src/${location} and reuse it. ${DOC7}`;
+    const location = path52.relative(root, existingRouteEnum.file).replaceAll(path52.sep, "/");
+    return `The route ${formatValue(use)} repeats; add a member to existing ${existingRouteEnum.owner} in src/${location} and reuse it. ${DOC8}`;
   }
   if (count === 1) {
-    return `The ${kind} literal ${formatValue(use)} repeats in the same semantic role in this file. Extract a file-local const. ${DOC7}`;
+    return `The ${kind} literal ${formatValue(use)} repeats in the same semantic role in this file. Extract a file-local const. ${DOC8}`;
   }
   const placement = use.family === "api-route" && duplicateRouteDomains.has(use.role) ? "a shared enum for this closed route domain" : "one shared const";
-  return `The ${kind} literal ${formatValue(use)} repeats in ${String(count)} production files for the same semantic role. Extract ${placement} at the consumers' CCF and import it. ${DOC7}`;
+  return `The ${kind} literal ${formatValue(use)} repeats in ${String(count)} production files for the same semantic role. Extract ${placement} at the consumers' CCF and import it. ${DOC8}`;
 }
 var repeatedSemanticLiteralRule = {
   meta: {
@@ -7667,7 +8106,7 @@ var repeatedSemanticLiteralRule = {
   },
   create(context) {
     const root = sourceRootOf(context);
-    const file = path50.resolve(context.filename);
+    const file = path52.resolve(context.filename);
     if (!isProductionSource(file, root)) return {};
     const project = getProjectIndex(root);
     if (!project?.modules.has(file)) return {};
@@ -7712,11 +8151,11 @@ var repeatedSemanticLiteralRule = {
     return {
       Program(node) {
         for (const use of imported) {
-          const relative = path50.relative(root, use.sourceFile).replaceAll(path50.sep, "/");
+          const relative = path52.relative(root, use.sourceFile).replaceAll(path52.sep, "/");
           context.report({
             node,
             loc: { line: use.line, column: use.column },
-            message: `Reuse ${use.reference} from src/${relative} instead of raw ${JSON.stringify(use.value)}. ${DOC7}`
+            message: `Reuse ${use.reference} from src/${relative} instead of raw ${JSON.stringify(use.value)}. ${DOC8}`
           });
         }
         for (const use of current) {
@@ -7727,11 +8166,11 @@ var repeatedSemanticLiteralRule = {
           if (candidates.length === 1) {
             const canonical = candidates[0];
             if (!canonical) continue;
-            const relative = path50.relative(root, canonical.file).replaceAll(path50.sep, "/");
+            const relative = path52.relative(root, canonical.file).replaceAll(path52.sep, "/");
             context.report({
               node,
               loc: { line: use.line, column: use.column },
-              message: `Reuse ${canonicalName(canonical)} from src/${relative} instead of raw ${formatValue(use)}. ${DOC7}`
+              message: `Reuse ${canonicalName(canonical)} from src/${relative} instead of raw ${formatValue(use)}. ${DOC8}`
             });
             continue;
           }
@@ -7740,11 +8179,11 @@ var repeatedSemanticLiteralRule = {
           const peers = groups.get(key) ?? [];
           if (peers.length < 2) {
             if (use.family === "api-route" && existingRouteEnum?.owner) {
-              const location = path50.relative(root, existingRouteEnum.file).replaceAll(path50.sep, "/");
+              const location = path52.relative(root, existingRouteEnum.file).replaceAll(path52.sep, "/");
               context.report({
                 node,
                 loc: { line: use.line, column: use.column },
-                message: `The route ${formatValue(use)} belongs to existing ${existingRouteEnum.owner}; add a member in src/${location} and reuse it. ${DOC7}`
+                message: `The route ${formatValue(use)} belongs to existing ${existingRouteEnum.owner}; add a member in src/${location} and reuse it. ${DOC8}`
               });
               continue;
             }
@@ -7753,7 +8192,7 @@ var repeatedSemanticLiteralRule = {
               context.report({
                 node,
                 loc: { line: use.line, column: use.column },
-                message: `The string literal ${formatValue(use)} is one of ${String(domain.size)} values in a closed ${use.family} domain. Declare the domain in a shared enum at the consumers' CCF and reuse it. ${DOC7}`
+                message: `The string literal ${formatValue(use)} is one of ${String(domain.size)} values in a closed ${use.family} domain. Declare the domain in a shared enum at the consumers' CCF and reuse it. ${DOC8}`
               });
             }
             continue;
@@ -7952,7 +8391,7 @@ var repeatedStructureRule = {
 
 // eslint/rules/require-barrel-star-exports.ts
 import fs5 from "fs";
-import path51 from "path";
+import path53 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 MODULE_EXTENSIONS3 = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
@@ -7960,9 +8399,9 @@ function resolveSiblingModule(indexFile, specifier) {
   if (!specifier.startsWith("./")) return void 0;
   const relative = specifier.slice(2);
   if (!relative || relative.includes("/")) return void 0;
-  const directory = path51.dirname(indexFile);
-  const direct = path51.resolve(directory, relative);
-  const candidates = path51.extname(direct) ? [direct] : MODULE_EXTENSIONS3.map((extension) => `${direct}${extension}`);
+  const directory = path53.dirname(indexFile);
+  const direct = path53.resolve(directory, relative);
+  const candidates = path53.extname(direct) ? [direct] : MODULE_EXTENSIONS3.map((extension) => `${direct}${extension}`);
   return candidates.find((candidate) => fs5.existsSync(candidate) && fs5.statSync(candidate).isFile());
 }
 var requireBarrelStarExportsRule = {
@@ -7975,9 +8414,9 @@ var requireBarrelStarExportsRule = {
     fixable: "code"
   },
   create(context) {
-    const filename = path51.resolve(context.filename);
-    if (!INDEX_NAMES.has(path51.basename(filename))) return {};
-    if (!SUPPORT_FOLDERS3.has(path51.basename(path51.dirname(filename)))) return {};
+    const filename = path53.resolve(context.filename);
+    if (!INDEX_NAMES.has(path53.basename(filename))) return {};
+    if (!SUPPORT_FOLDERS3.has(path53.basename(path53.dirname(filename)))) return {};
     return {
       ExportNamedDeclaration(node) {
         const sourceNode = node.source;
@@ -8030,7 +8469,7 @@ var requireBarrelStarExportsRule = {
 };
 
 // eslint/rules/root-support-placement.ts
-import path52 from "path";
+import path54 from "path";
 function isSupportFolder(value) {
   return value === "utils" || value === "types" || value === "schemas" || value === "constants";
 }
@@ -8063,7 +8502,7 @@ var rootSupportPlacementRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path52.resolve(context.filename);
+    const file = path54.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     const folderSegments = folderSegmentsOf(file, sourceRoot);
     const supportFolder = folderSegments[folderSegments.length - 1];
@@ -8109,8 +8548,104 @@ var rootSupportPlacementRule = {
 };
 
 // eslint/rules/route-handler-shape.ts
-import path53 from "path";
-import ts12 from "typescript";
+import path56 from "path";
+import ts13 from "typescript";
+
+// eslint/rules/route-single-use-delegation.ts
+import path55 from "path";
+function responseCall(expression) {
+  if (!expression) return void 0;
+  if (expression.type === "AwaitExpression") return responseCall(expression.argument);
+  if (expression.type === "CallExpression" && expression.callee.type === "Identifier") return expression;
+  if (expression.type !== "ObjectExpression") return void 0;
+  const dataProperties = expression.properties.filter(
+    (property) => property.type === "Property" && !property.computed && (property.key.type === "Identifier" && property.key.name === "data" || property.key.type === "Literal" && property.key.value === "data")
+  );
+  if (dataProperties.length !== 1) return void 0;
+  const otherProperties = expression.properties.filter((property) => !dataProperties.includes(property));
+  if (otherProperties.some(
+    (property) => property.type !== "Property" || property.value.type !== "Literal" || property.computed
+  )) {
+    return void 0;
+  }
+  return responseCall(dataProperties[0]?.type === "Property" ? dataProperties[0].value : void 0);
+}
+function soleDelegation(handler) {
+  if (handler.body.type !== "BlockStatement") return responseCall(handler.body);
+  const statements = handler.body.body;
+  if (statements.length === 1 && statements[0]?.type === "ReturnStatement") {
+    return responseCall(statements[0].argument);
+  }
+  const [declaration, returned] = statements;
+  if (statements.length !== 2 || declaration?.type !== "VariableDeclaration" || declaration.declarations.length !== 1 || returned?.type !== "ReturnStatement") {
+    return void 0;
+  }
+  const variable = declaration.declarations[0];
+  if (variable?.id.type !== "Identifier") return void 0;
+  const call = responseCall(variable.init);
+  if (!call || !returned.argument) return void 0;
+  if (returned.argument.type === "Identifier" && returned.argument.name === variable.id.name) return call;
+  if (returned.argument.type !== "ObjectExpression") return void 0;
+  const properties = returned.argument.properties;
+  if (properties.length !== 1 || properties[0]?.type !== "Property") return void 0;
+  const property = properties[0];
+  const key = property.key;
+  const isData = !property.computed && (key.type === "Identifier" && key.name === "data" || key.type === "Literal" && key.value === "data");
+  return isData && property.value.type === "Identifier" && property.value.name === variable.id.name ? call : void 0;
+}
+function isTestFile2(file) {
+  return /(?:\.test|\.spec)\.[cm]?[jt]sx?$/.test(file) || path55.normalize(file).split(path55.sep).includes("__tests__");
+}
+function functionSource(index, file, name, sourceRoot, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(file)) return void 0;
+  visited.add(file);
+  const module = index.modules.get(file);
+  if (!module) return void 0;
+  if (module.exports.some((entry) => entry.name === name && entry.kind === "function")) return file;
+  if (!module.exports.some((entry) => entry.name === name) && !module.reexports.some((entry) => entry.names.length === 0)) {
+    return void 0;
+  }
+  for (const entry of module.reexports) {
+    if (entry.names.length > 0 && !entry.names.includes(name)) continue;
+    const target = resolveSpecifier(file, entry.specifier, sourceRoot);
+    if (!target) continue;
+    const original = functionSource(index, target, name, sourceRoot, visited);
+    if (original) return original;
+  }
+  return void 0;
+}
+function singleUseResponseDelegate(context, handler) {
+  const call = soleDelegation(handler);
+  if (call?.callee.type !== "Identifier") return void 0;
+  const name = call.callee.name;
+  const sourceRoot = sourceRootOf(context);
+  const index = getProjectIndex(sourceRoot);
+  if (!index) return void 0;
+  for (const statement of context.sourceCode.ast.body) {
+    if (statement.type !== "ImportDeclaration" || typeof statement.source.value !== "string") continue;
+    const target = resolveSpecifier(context.filename, statement.source.value, sourceRoot);
+    if (target === void 0 || target === context.filename) continue;
+    for (const specifier of statement.specifiers) {
+      if (specifier.type !== "ImportSpecifier" || specifier.local.name !== name) continue;
+      const original = specifier.imported.type === "Identifier" ? specifier.imported.name : String(specifier.imported.value);
+      const source = functionSource(index, target, original, sourceRoot);
+      if (!source) continue;
+      const bindings = context.sourceCode.getDeclaredVariables(specifier);
+      if (!bindings.some((binding) => binding.references.length === 1)) continue;
+      const consumers = index.symbolConsumers.get(symbolKey(source, original));
+      if (!consumers?.has(context.filename)) continue;
+      const activeConsumers = [...consumers].filter((consumer) => {
+        if (isTestFile2(consumer)) return false;
+        const module = index.modules.get(consumer);
+        return !(module && module.reexports.length > 0 && module.imports.length === module.reexports.length && module.exports.every((entry) => entry.kind === "other"));
+      });
+      if (activeConsumers.length === 1 && activeConsumers[0] === context.filename) return original;
+    }
+  }
+  return void 0;
+}
+
+// eslint/rules/route-handler-shape.ts
 var HTTP_METHODS2 = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
 var REQUIRED_BOUNDARY = "withResponse";
 function isFunctionLike(node) {
@@ -8128,33 +8663,33 @@ function findHandler(node) {
   return void 0;
 }
 function isLoop(node) {
-  return ts12.isForStatement(node) || ts12.isForOfStatement(node) || ts12.isForInStatement(node) || ts12.isWhileStatement(node) || ts12.isDoStatement(node);
+  return ts13.isForStatement(node) || ts13.isForOfStatement(node) || ts13.isForInStatement(node) || ts13.isWhileStatement(node) || ts13.isDoStatement(node);
 }
 function isFunctionBoundary(node) {
-  return ts12.isFunctionExpression(node) || ts12.isArrowFunction(node) || ts12.isFunctionDeclaration(node);
+  return ts13.isFunctionExpression(node) || ts13.isArrowFunction(node) || ts13.isFunctionDeclaration(node);
 }
 function analyzeHandlerBody(body, sourceText) {
   const start = body.range?.[0] ?? 0;
   const end = body.range?.[1] ?? sourceText.length;
-  const sourceFile = ts12.createSourceFile(
+  const sourceFile = ts13.createSourceFile(
     "route.ts",
     sourceText.slice(start, end),
-    ts12.ScriptTarget.Latest,
+    ts13.ScriptTarget.Latest,
     true,
-    ts12.ScriptKind.TS
+    ts13.ScriptKind.TS
   );
   const kinds = /* @__PURE__ */ new Set();
   const calledNames = /* @__PURE__ */ new Set();
   const visit = (node) => {
-    if (ts12.isTryStatement(node)) kinds.add("try");
+    if (ts13.isTryStatement(node)) kinds.add("try");
     if (isLoop(node)) kinds.add("loop");
-    if (ts12.isIfStatement(node)) kinds.add("if");
-    if (ts12.isCallExpression(node) && ts12.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map") {
+    if (ts13.isIfStatement(node)) kinds.add("if");
+    if (ts13.isCallExpression(node) && ts13.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map") {
       kinds.add("map");
     }
-    if (ts12.isCallExpression(node) && ts12.isIdentifier(node.expression)) calledNames.add(node.expression.text);
+    if (ts13.isCallExpression(node) && ts13.isIdentifier(node.expression)) calledNames.add(node.expression.text);
     if (isFunctionBoundary(node)) return;
-    ts12.forEachChild(node, visit);
+    ts13.forEachChild(node, visit);
   };
   visit(sourceFile);
   return { kinds, calledNames };
@@ -8194,7 +8729,7 @@ var routeHandlerShapeRule = {
     }
   },
   create(context) {
-    if (path53.basename(context.filename) !== "route.ts") return {};
+    if (path56.basename(context.filename) !== "route.ts") return {};
     const sourceText = context.sourceCode.text;
     function reportUnwrapped(node, name) {
       context.report({
@@ -8217,6 +8752,13 @@ var routeHandlerShapeRule = {
         });
         return;
       }
+      const singleUseDelegate = singleUseResponseDelegate(context, handler);
+      if (singleUseDelegate) {
+        context.report({
+          node,
+          message: `Handler "${name}" delegates its entire response to single-use utility "${singleUseDelegate}"; inline its workflow in route.ts. See docs/next-codebase-guide/rules/route-handler-rule.md`
+        });
+      }
       const { kinds, calledNames } = analyzeHandlerBody(handler.body, sourceText);
       for (const kind of kinds) {
         context.report({
@@ -8253,7 +8795,7 @@ var routeHandlerShapeRule = {
 };
 
 // eslint/rules/schema-casing.ts
-import path54 from "path";
+import path57 from "path";
 function isCamelCase(name) {
   return /^[a-z][a-zA-Z0-9]*$/.test(name);
 }
@@ -8281,9 +8823,9 @@ var schemaCasingRule = {
     }
   },
   create(context) {
-    const filename = path54.resolve(context.filename);
+    const filename = path57.resolve(context.filename);
     const sourceRoot = sourceRootOf(context);
-    if (!filename.startsWith(sourceRoot + path54.sep)) return {};
+    if (!filename.startsWith(sourceRoot + path57.sep)) return {};
     let zodLocalName;
     return {
       ImportDeclaration(node) {
@@ -8315,39 +8857,39 @@ var schemaCasingRule = {
 };
 
 // eslint/rules/sole-state-owner.ts
-import path55 from "path";
-import ts13 from "typescript";
+import path58 from "path";
+import ts14 from "typescript";
 function findStateHooks(node) {
   const hooks = [];
   const visit = (child) => {
-    if (ts13.isCallExpression(child) && ts13.isIdentifier(child.expression) && child.expression.text === "useState") {
-      if (ts13.isVariableDeclaration(child.parent)) {
+    if (ts14.isCallExpression(child) && ts14.isIdentifier(child.expression) && child.expression.text === "useState") {
+      if (ts14.isVariableDeclaration(child.parent)) {
         const { name } = child.parent;
-        if (ts13.isArrayBindingPattern(name) && name.elements.length >= 2) {
+        if (ts14.isArrayBindingPattern(name) && name.elements.length >= 2) {
           const value = name.elements[0];
           const updater = name.elements[1];
-          if (value && updater && ts13.isBindingElement(value) && ts13.isBindingElement(updater)) {
+          if (value && updater && ts14.isBindingElement(value) && ts14.isBindingElement(updater)) {
             const valueName = value.name;
             const updaterName = updater.name;
-            if (ts13.isIdentifier(valueName) && ts13.isIdentifier(updaterName)) {
+            if (ts14.isIdentifier(valueName) && ts14.isIdentifier(updaterName)) {
               hooks.push({ value: valueName.text, updater: updaterName.text });
             }
           }
         }
       }
     }
-    ts13.forEachChild(child, visit);
+    ts14.forEachChild(child, visit);
   };
   visit(node);
   return hooks;
 }
 function isHookUsage(node, hook) {
-  if (ts13.isCallExpression(node) && ts13.isIdentifier(node.expression) && node.expression.text === hook.updater) {
+  if (ts14.isCallExpression(node) && ts14.isIdentifier(node.expression) && node.expression.text === hook.updater) {
     return "updater";
   }
-  if (ts13.isIdentifier(node) && node.text === hook.value) {
+  if (ts14.isIdentifier(node) && node.text === hook.value) {
     const parent = node.parent;
-    if (ts13.isBindingElement(parent) || ts13.isPropertyAccessExpression(parent) || ts13.isShorthandPropertyAssignment(parent)) {
+    if (ts14.isBindingElement(parent) || ts14.isPropertyAccessExpression(parent) || ts14.isShorthandPropertyAssignment(parent)) {
       return void 0;
     }
     return "value";
@@ -8357,16 +8899,16 @@ function isHookUsage(node, hook) {
 function topLevelJsxChildren(initial) {
   if (!initial) return void 0;
   let expression = initial;
-  while (ts13.isParenthesizedExpression(expression)) expression = expression.expression;
-  if (ts13.isJsxFragment(expression)) {
+  while (ts14.isParenthesizedExpression(expression)) expression = expression.expression;
+  if (ts14.isJsxFragment(expression)) {
     const children = expression.children.filter(
-      (c) => !ts13.isJsxText(c) && !ts13.isJsxSpreadAttribute(c)
+      (c) => !ts14.isJsxText(c) && !ts14.isJsxSpreadAttribute(c)
     );
     return { root: expression, children };
   }
-  if (ts13.isJsxElement(expression)) {
+  if (ts14.isJsxElement(expression)) {
     const children = expression.children.filter(
-      (c) => !ts13.isJsxText(c) && !ts13.isJsxSpreadAttribute(c)
+      (c) => !ts14.isJsxText(c) && !ts14.isJsxSpreadAttribute(c)
     );
     return { root: expression, children };
   }
@@ -8380,8 +8922,8 @@ function collectUsesIn(child, hook) {
       positions.push(node);
       count += 1;
     }
-    if (ts13.isFunctionDeclaration(node) || ts13.isClassDeclaration(node)) return;
-    ts13.forEachChild(node, visit);
+    if (ts14.isFunctionDeclaration(node) || ts14.isClassDeclaration(node)) return;
+    ts14.forEachChild(node, visit);
   };
   visit(child);
   return { positions, count };
@@ -8395,7 +8937,7 @@ var soleStateOwnerRule = {
     }
   },
   create(context) {
-    const filename = path55.resolve(context.filename);
+    const filename = path58.resolve(context.filename);
     if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx")) return {};
     const text = context.sourceCode.text;
     const components = parseComponentInfo(text, filename);
@@ -8420,18 +8962,18 @@ var soleStateOwnerRule = {
   }
 };
 function analyzeSoleOwner(declaration, hook) {
-  const body = ts13.isFunctionDeclaration(declaration) ? declaration.body : void 0;
-  if (!body || !ts13.isBlock(body)) return void 0;
+  const body = ts14.isFunctionDeclaration(declaration) ? declaration.body : void 0;
+  if (!body || !ts14.isBlock(body)) return void 0;
   const returns = [];
   const visit = (node) => {
-    if (node !== body && (ts13.isFunctionLike(node) || ts13.isClassLike(node))) return;
-    if (ts13.isReturnStatement(node)) returns.push(node);
-    ts13.forEachChild(node, visit);
+    if (node !== body && (ts14.isFunctionLike(node) || ts14.isClassLike(node))) return;
+    if (ts14.isReturnStatement(node)) returns.push(node);
+    ts14.forEachChild(node, visit);
   };
   visit(body);
   if (returns.length !== 1) return void 0;
   const single = returns[0];
-  if (!single?.expression || !ts13.isExpression(single.expression)) return void 0;
+  if (!single?.expression || !ts14.isExpression(single.expression)) return void 0;
   const returnExpression = single.expression;
   const root = topLevelJsxChildren(returnExpression);
   if (!root || root.children.length === 0) return void 0;
@@ -8454,11 +8996,11 @@ function usesOutsideJsx(declaration, hook, children) {
   let outside = false;
   const visit = (node) => {
     if (outside) return;
-    if (node !== declaration && (ts13.isFunctionDeclaration(node) || ts13.isClassDeclaration(node))) return;
+    if (node !== declaration && (ts14.isFunctionDeclaration(node) || ts14.isClassDeclaration(node))) return;
     if (isHookUsage(node, hook)) {
       let current = node;
       let isInJsxChild = false;
-      while (!ts13.isSourceFile(current)) {
+      while (!ts14.isSourceFile(current)) {
         if (children.includes(current)) {
           isInJsxChild = true;
           break;
@@ -8467,14 +9009,14 @@ function usesOutsideJsx(declaration, hook, children) {
       }
       if (!isInJsxChild) outside = true;
     }
-    ts13.forEachChild(node, visit);
+    ts14.forEachChild(node, visit);
   };
   visit(declaration);
   return outside;
 }
 
 // eslint/rules/source-under-src.ts
-import path56 from "path";
+import path59 from "path";
 var NON_SOURCE_ROOT_DIRS = /* @__PURE__ */ new Set([
   ".agents",
   ".cache",
@@ -8515,14 +9057,14 @@ var sourceUnderSrcRule = {
     }
   },
   create(context) {
-    const filename = path56.resolve(context.filename);
+    const filename = path59.resolve(context.filename);
     if (!MODULE_EXTENSION.test(filename)) return {};
-    const relative = path56.relative(context.cwd, filename).replace(/\\/g, "/");
+    const relative = path59.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 = path56.basename(filename);
+      const basename = path59.basename(filename);
       if (CONFIG_FILE.test(basename) || DECLARATION_FILE.test(basename) || basename.startsWith(".")) return {};
     }
     return {
@@ -8538,7 +9080,7 @@ var sourceUnderSrcRule = {
 };
 
 // eslint/rules/stay-flat.ts
-import path57 from "path";
+import path60 from "path";
 var stayFlatRule = {
   meta: {
     schema: [],
@@ -8549,7 +9091,7 @@ var stayFlatRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path57.resolve(context.filename);
+    const file = path60.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length !== 3 || segments[0] !== "features") return {};
     const index = getProjectIndex(sourceRoot);
@@ -8589,7 +9131,7 @@ var stayFlatRule = {
 };
 
 // eslint/rules/support-file-placement.ts
-import path58 from "path";
+import path61 from "path";
 var CONFIG_OWNED_FOLDERS = /* @__PURE__ */ new Set(["types", "constants"]);
 var EXPORT_KIND_BY_SUPPORT_FOLDER = /* @__PURE__ */ new Map([
   ["constants", "constant"],
@@ -8614,7 +9156,7 @@ var supportFilePlacementRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const supportFile = path58.resolve(context.filename);
+    const supportFile = path61.resolve(context.filename);
     const currentFolder = folderSegmentsOf(supportFile, sourceRoot);
     const supportFolder = currentFolder[currentFolder.length - 1];
     if (supportFolder === void 0 || !SUPPORT_FOLDERS.has(supportFolder)) return {};
@@ -8668,7 +9210,7 @@ var supportFilePlacementRule = {
 
 // eslint/rules/support-folder-shape.ts
 import fs6 from "fs";
-import path59 from "path";
+import path62 from "path";
 var SUPPORT_FOLDERS4 = /* @__PURE__ */ new Set(["constants", "types", "schemas"]);
 var INDEX_NAMES2 = /* @__PURE__ */ new Set(["index.ts", "index.tsx", "index.mts", "index.cts"]);
 var supportFolderShapeRule = {
@@ -8680,12 +9222,12 @@ var supportFolderShapeRule = {
     }
   },
   create(context) {
-    const filename = path59.resolve(context.filename);
-    const baseName = path59.basename(filename);
+    const filename = path62.resolve(context.filename);
+    const baseName = path62.basename(filename);
     if (!INDEX_NAMES2.has(baseName)) return {};
-    const folder = path59.basename(path59.dirname(filename));
+    const folder = path62.basename(path62.dirname(filename));
     if (!SUPPORT_FOLDERS4.has(folder)) return {};
-    const directory = path59.dirname(filename);
+    const directory = path62.dirname(filename);
     let entries;
     try {
       entries = fs6.readdirSync(directory);
@@ -8703,7 +9245,7 @@ var supportFolderShapeRule = {
         for (const match of source.matchAll(exportPattern)) {
           hasAnyReExport = true;
           const specifier = match.groups?.specifier;
-          if (specifier?.startsWith(".")) exportedFiles.add(path59.basename(specifier));
+          if (specifier?.startsWith(".")) exportedFiles.add(path62.basename(specifier));
         }
         const guide = `docs/next-codebase-guide/rules/${folder === "constants" ? "constants" : "types-and-schemas"}-rule.md`;
         if (siblingModules.length === 0) {
@@ -8882,24 +9424,24 @@ var baseLayerPairRule = {
 
 // eslint/rules/tailwind/css-entry-point.ts
 import { statSync as statSync4 } from "fs";
-import path62 from "path";
+import path65 from "path";
 
 // eslint/rules/tailwind/source-files.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync11, statSync as statSync3 } from "fs";
-import path60 from "path";
+import { readdirSync as readdirSync5, readFileSync as readFileSync13, statSync as statSync3 } from "fs";
+import path63 from "path";
 var CSS_EXTENSIONS = [".css"];
 var MODULE_EXTENSIONS4 = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
 var SOURCE_EXTENSIONS = [...MODULE_EXTENSIONS4, ...CSS_EXTENSIONS];
 function findFiles(dir, extensions) {
   let entries;
   try {
-    entries = readdirSync3(dir);
+    entries = readdirSync5(dir);
   } catch {
     return [];
   }
   return entries.flatMap((entry) => {
     if (entry.startsWith(".") || entry === "node_modules") return [];
-    const entryPath = path60.join(dir, entry);
+    const entryPath = path63.join(dir, entry);
     let stats;
     try {
       stats = statSync3(entryPath);
@@ -8907,7 +9449,7 @@ function findFiles(dir, extensions) {
       return [];
     }
     if (stats.isDirectory()) return findFiles(entryPath, extensions);
-    return extensions.includes(path60.extname(entry)) ? [entryPath] : [];
+    return extensions.includes(path63.extname(entry)) ? [entryPath] : [];
   });
 }
 function cachedTextReader() {
@@ -8916,7 +9458,7 @@ function cachedTextReader() {
     let text = texts.get(file);
     if (text === void 0) {
       try {
-        text = readFileSync11(file, "utf8");
+        text = readFileSync13(file, "utf8");
       } catch {
         text = "";
       }
@@ -8930,7 +9472,7 @@ function escapeRegExp(text) {
 }
 
 // eslint/rules/tailwind/stylesheet-graph.ts
-import path61 from "path";
+import path64 from "path";
 function registersTailwind(text) {
   return /@import\s+(?:url\(\s*)?["']tailwindcss["']\s*\)?/i.test(text);
 }
@@ -8944,25 +9486,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 path61.resolve(spec);
-  if (spec.startsWith("./") || spec.startsWith("../")) return path61.resolve(path61.dirname(fromFile), spec);
-  if (spec.startsWith("@/")) return path61.resolve(sourceRoot, spec.slice(2));
+  if (spec.startsWith("/")) return path64.resolve(spec);
+  if (spec.startsWith("./") || spec.startsWith("../")) return path64.resolve(path64.dirname(fromFile), spec);
+  if (spec.startsWith("@/")) return path64.resolve(sourceRoot, spec.slice(2));
   return void 0;
 }
 function buildStylesheetGraph(options) {
   const { cssFiles, sourceRoot, textOf } = options;
-  const cssSet = new Set(cssFiles.map((file) => path61.normalize(file)));
+  const cssSet = new Set(cssFiles.map((file) => path64.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(path61.normalize(global));
+  for (const global of globals) reachable.add(path64.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 = path61.normalize(target);
+      const normalized = path64.normalize(target);
       if (cssSet.has(normalized) && !reachable.has(normalized)) {
         reachable.add(normalized);
         queue.push(normalized);
@@ -8974,7 +9516,7 @@ function buildStylesheetGraph(options) {
     for (const spec of importedSpecifiers(textOf(global))) {
       const target = resolveSpecifier2(global, spec, sourceRoot);
       if (!target) continue;
-      const normalized = path61.normalize(target);
+      const normalized = path64.normalize(target);
       if (cssSet.has(normalized)) directChildren.add(normalized);
     }
   }
@@ -8982,8 +9524,8 @@ function buildStylesheetGraph(options) {
 }
 
 // eslint/rules/tailwind/css-entry-point.ts
-var APP_STYLES_DIR = path62.join("app", "styles");
-var GLOBAL_STYLESHEET_PATH = path62.join(APP_STYLES_DIR, "globals.css");
+var APP_STYLES_DIR = path65.join("app", "styles");
+var GLOBAL_STYLESHEET_PATH = path65.join(APP_STYLES_DIR, "globals.css");
 var cssEntryPointRule = {
   meta: {
     schema: [],
@@ -9009,8 +9551,8 @@ var cssEntryPointRule = {
     return {
       "StyleSheet:exit"(node) {
         if (globals.length === 0) return;
-        const current = path62.normalize(path62.resolve(context.filename));
-        const relative = path62.relative(sourceRoot, current);
+        const current = path65.normalize(path65.resolve(context.filename));
+        const relative = path65.relative(sourceRoot, current);
         if (globals.includes(current)) {
           if (globals.length > 1) {
             context.report({
@@ -9026,7 +9568,7 @@ var cssEntryPointRule = {
             });
             return;
           }
-          const basename = path62.basename(current);
+          const basename = path65.basename(current);
           const importCount = moduleFiles.filter((modulePath) => moduleImports(textOf(modulePath), basename)).length;
           if (importCount !== 1) {
             context.report({
@@ -9036,7 +9578,7 @@ var cssEntryPointRule = {
           }
           return;
         }
-        const isInAppStyles = relative === APP_STYLES_DIR || relative.startsWith(`${APP_STYLES_DIR}${path62.sep}`);
+        const isInAppStyles = relative === APP_STYLES_DIR || relative.startsWith(`${APP_STYLES_DIR}${path65.sep}`);
         if (!isInAppStyles) {
           context.report({
             node,
@@ -9525,7 +10067,7 @@ var tailwindRules = {
 };
 
 // eslint/rules/type-extraction.ts
-import path63 from "path";
+import path66 from "path";
 var typeExtractionRule = {
   meta: {
     schema: [],
@@ -9536,7 +10078,7 @@ var typeExtractionRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path63.resolve(context.filename);
+    const file = path66.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length === 0) return {};
     const index = getProjectIndex(sourceRoot);
@@ -9675,9 +10217,9 @@ var uiStateRule = {
 };
 
 // eslint/rules/unknown-utility.ts
-import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync12, statSync as statSync6 } from "fs";
+import { existsSync as existsSync8, readdirSync as readdirSync6, readFileSync as readFileSync14, statSync as statSync6 } from "fs";
 import { createRequire } from "module";
-import path64 from "path";
+import path67 from "path";
 var PREFIX_NAMESPACES = {
   bg: ["color"],
   text: ["color", "text"],
@@ -9911,13 +10453,13 @@ function isBuiltInTailwindUtility(utility) {
 function stylesheetFiles(dir) {
   let entries;
   try {
-    entries = readdirSync4(dir);
+    entries = readdirSync6(dir);
   } catch {
     return [];
   }
   return entries.flatMap((entry) => {
     if (entry.startsWith(".") || entry === "node_modules") return [];
-    const entryPath = path64.join(dir, entry);
+    const entryPath = path67.join(dir, entry);
     let stats;
     try {
       stats = statSync6(entryPath);
@@ -9925,7 +10467,7 @@ function stylesheetFiles(dir) {
       return [];
     }
     if (stats.isDirectory()) return stylesheetFiles(entryPath);
-    return path64.extname(entry) === ".css" ? [entryPath] : [];
+    return path67.extname(entry) === ".css" ? [entryPath] : [];
   });
 }
 function packageNameOf(specifier) {
@@ -9936,24 +10478,24 @@ function packageNameOf(specifier) {
 function resolvePackageStylesheet(fromFile, specifier) {
   const packageName = packageNameOf(specifier);
   if (!packageName || packageName === "tailwindcss") return void 0;
-  let directory = path64.dirname(fromFile);
-  while (directory !== path64.dirname(directory)) {
-    const packageRoot = path64.join(directory, "node_modules", packageName);
-    const manifestPath = path64.join(packageRoot, "package.json");
-    if (existsSync6(manifestPath)) {
+  let directory = path67.dirname(fromFile);
+  while (directory !== path67.dirname(directory)) {
+    const packageRoot = path67.join(directory, "node_modules", packageName);
+    const manifestPath = path67.join(packageRoot, "package.json");
+    if (existsSync8(manifestPath)) {
       try {
-        const manifest = readFileSync12(manifestPath, "utf8");
+        const manifest = readFileSync14(manifestPath, "utf8");
         const stylesheet = /"style"\s*:\s*"(?<file>[^"]+\.css)"/.exec(manifest)?.groups?.file;
         const main = /"main"\s*:\s*"(?<file>[^"]+\.css)"/.exec(manifest)?.groups?.file;
         const target = stylesheet ?? main;
         if (!target) return void 0;
-        const resolved = path64.resolve(packageRoot, target);
-        return existsSync6(resolved) ? resolved : void 0;
+        const resolved = path67.resolve(packageRoot, target);
+        return existsSync8(resolved) ? resolved : void 0;
       } catch {
         return void 0;
       }
     }
-    directory = path64.dirname(directory);
+    directory = path67.dirname(directory);
   }
   return void 0;
 }
@@ -9962,7 +10504,7 @@ function inventoryStylesheetFiles(projectFiles) {
   for (const file of projectFiles) {
     let css2;
     try {
-      css2 = readFileSync12(file, "utf8");
+      css2 = readFileSync14(file, "utf8");
     } catch {
       continue;
     }
@@ -10028,7 +10570,7 @@ function readInventory(files) {
   for (const file of files) {
     let css2;
     try {
-      css2 = readFileSync12(file, "utf8");
+      css2 = readFileSync14(file, "utf8");
     } catch {
       continue;
     }
@@ -10204,7 +10746,7 @@ var unknownUtilityRule = {
 };
 
 // eslint/rules/util-file-name.ts
-import path65 from "path";
+import path68 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();
 }
@@ -10217,7 +10759,7 @@ var utilFileNameRule = {
     }
   },
   create(context) {
-    const filename = path65.resolve(context.filename);
+    const filename = path68.resolve(context.filename);
     const segments = filename.replace(/\\/g, "/").split("/");
     if (!segments.includes("utils")) return {};
     let module;
@@ -10231,13 +10773,13 @@ var utilFileNameRule = {
     const functionName = functions[0]?.name;
     if (!functionName) return {};
     const expected = toKebabCase2(functionName);
-    const actual = path65.basename(filename, path65.extname(filename));
+    const actual = path68.basename(filename, path68.extname(filename));
     if (!expected || actual === expected) return {};
     return {
       Program(node) {
         context.report({
           node,
-          message: `A utility file exporting ${functionName} must be named ${expected}.${path65.extname(filename).slice(1)}.`
+          message: `A utility file exporting ${functionName} must be named ${expected}.${path68.extname(filename).slice(1)}.`
         });
       }
     };
@@ -10245,7 +10787,7 @@ var utilFileNameRule = {
 };
 
 // eslint/rules/value-extraction.ts
-import path66 from "path";
+import path69 from "path";
 var valueExtractionRule = {
   meta: {
     schema: [],
@@ -10256,7 +10798,7 @@ var valueExtractionRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path66.resolve(context.filename);
+    const file = path69.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length === 0 || segments[0] !== "app") return {};
     const index = getProjectIndex(sourceRoot);
@@ -10277,8 +10819,8 @@ var valueExtractionRule = {
 };
 
 // eslint/rules/vulyk/tracked-docs.ts
-import { existsSync as existsSync7, readFileSync as readFileSync13 } from "fs";
-import path67 from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync15 } from "fs";
+import path70 from "path";
 var PASIKA_REPO = "Bredansky/pasika";
 var BASE_REQUIRED_TRACKED_DOCS = [
   { name: "documentation-guide", path: "docs/documentation-guide" },
@@ -10289,13 +10831,13 @@ 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 memberName8(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) => memberName8(member) === "dependencies");
   if (section?.value.type !== "Object") return false;
-  return section.value.members.some((member) => memberName7(member) === name);
+  return section.value.members.some((member) => memberName8(member) === name);
 }
 var trackedDocsRule = {
   meta: {
@@ -10311,16 +10853,16 @@ var trackedDocsRule = {
         if (!context.filename.endsWith("package.json")) return;
         const root = node.body;
         if (root.type !== "Object") return;
-        const projectRoot = path67.dirname(path67.resolve(context.filename));
-        const configPath = path67.join(projectRoot, "vulyk.config.ts");
-        if (!existsSync7(configPath)) {
+        const projectRoot = path70.dirname(path70.resolve(context.filename));
+        const configPath = path70.join(projectRoot, "vulyk.config.ts");
+        if (!existsSync9(configPath)) {
           context.report({
             node,
             message: "No vulyk.config.ts found. Run npx vulyk init to create one that tracks the framework's required tracked docs."
           });
           return;
         }
-        const config = readFileSync13(configPath, "utf8");
+        const config = readFileSync15(configPath, "utf8");
         if (!config.includes(PASIKA_REPO)) {
           context.report({
             node,
@@ -10337,8 +10879,8 @@ var trackedDocsRule = {
             });
           }
         }
-        const agentsPath = path67.join(projectRoot, "AGENTS.md");
-        if (!existsSync7(agentsPath)) {
+        const agentsPath = path70.join(projectRoot, "AGENTS.md");
+        if (!existsSync9(agentsPath)) {
           context.report({
             node,
             message: "No AGENTS.md found. Run npx vulyk agents to generate the agent file that routes to the tracked docs."
@@ -10350,14 +10892,14 @@ var trackedDocsRule = {
 };
 
 // eslint/rules/vulyk/vulyk-dependency.ts
-function memberName8(member) {
+function memberName9(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) => memberName8(member) === sectionName);
+  const section = root.members.find((member) => memberName9(member) === sectionName);
   if (section?.value.type !== "Object") return void 0;
-  return section.value.members.find((member) => memberName8(member) === "vulyk");
+  return section.value.members.find((member) => memberName9(member) === "vulyk");
 }
 var vulykDependencyRule = {
   meta: {
@@ -10398,9 +10940,9 @@ var vulykRules = {
 // eslint/rules/with-response-helper.ts
 var HELPER3 = "withResponse";
 var ENTRY3 = "pasika/with-response";
-var DOC8 = "docs/pasika-adoption-guide/rules/with-response-helper-rule.md";
-var DECLARED3 = `A repository must not declare its own ${HELPER3}; import it from ${ENTRY3}. See ${DOC8}`;
-var IMPORTED3 = `${HELPER3} must be imported from ${ENTRY3}. See ${DOC8}`;
+var DOC9 = "docs/pasika-adoption-guide/rules/with-response-helper-rule.md";
+var DECLARED3 = `A repository must not declare its own ${HELPER3}; import it from ${ENTRY3}. See ${DOC9}`;
+var IMPORTED3 = `${HELPER3} must be imported from ${ENTRY3}. See ${DOC9}`;
 function isNamed3(node, name) {
   return node?.type === "Identifier" && node.name === name;
 }
@@ -10437,7 +10979,7 @@ var withResponseHelperRule = {
 
 // eslint/rules/zirka-baseline.ts
 import fs7 from "fs";
-import path68 from "path";
+import path71 from "path";
 var ESLINT_CONFIG = /^eslint\.config\.(?:ts|mts|cts|js|mjs|cjs)$/;
 var PRETTIER_CONFIGS = [
   "prettier.config.mjs",
@@ -10456,10 +10998,10 @@ var zirkaBaselineRule = {
     }
   },
   create(context) {
-    const filename = path68.resolve(context.filename);
-    const basename = path68.basename(filename);
+    const filename = path71.resolve(context.filename);
+    const basename = path71.basename(filename);
     if (!ESLINT_CONFIG.test(basename)) return {};
-    const projectRoot = path68.dirname(filename);
+    const projectRoot = path71.dirname(filename);
     const report3 = (message) => {
       context.report({
         node: context.sourceCode.ast,
@@ -10474,7 +11016,7 @@ var zirkaBaselineRule = {
             'ESLint config must take its configuration from zirka (import { styleguide } from "zirka") instead of restating rules locally.'
           );
         }
-        const tsconfigPath = path68.join(projectRoot, "tsconfig.json");
+        const tsconfigPath = path71.join(projectRoot, "tsconfig.json");
         if (!fs7.existsSync(tsconfigPath)) {
           report3('No tsconfig.json found. Create one extending the zirka TypeScript base config ("zirka/typescript").');
         } else {
@@ -10492,13 +11034,13 @@ var zirkaBaselineRule = {
             report3('tsconfig.json must extend the zirka TypeScript base config ("zirka/typescript").');
           }
         }
-        const prettierConfigFile = PRETTIER_CONFIGS.find((name) => fs7.existsSync(path68.join(projectRoot, name)));
+        const prettierConfigFile = PRETTIER_CONFIGS.find((name) => fs7.existsSync(path71.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 = fs7.readFileSync(path68.join(projectRoot, prettierConfigFile), "utf8");
+          const content = fs7.readFileSync(path71.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."
@@ -10521,10 +11063,10 @@ function referencesZirka(sourceCode) {
 // eslint/rules/zod-fetch-helper.ts
 var HELPER4 = "zodFetch";
 var ENTRY4 = "pasika/zod-fetch";
-var DOC9 = "docs/pasika-adoption-guide/rules/zod-fetch-helper-rule.md";
-var FETCHED = `fetch must not be called; make the request through ${HELPER4} from ${ENTRY4}. See ${DOC9}`;
-var DECLARED4 = `A file must not declare its own ${HELPER4}; import it from ${ENTRY4}. See ${DOC9}`;
-var IMPORTED4 = `${HELPER4} must be imported from ${ENTRY4}. See ${DOC9}`;
+var DOC10 = "docs/pasika-adoption-guide/rules/zod-fetch-helper-rule.md";
+var FETCHED = `fetch must not be called; make the request through ${HELPER4} from ${ENTRY4}. See ${DOC10}`;
+var DECLARED4 = `A file must not declare its own ${HELPER4}; import it from ${ENTRY4}. See ${DOC10}`;
+var IMPORTED4 = `${HELPER4} must be imported from ${ENTRY4}. See ${DOC10}`;
 var GLOBAL_OBJECTS = /* @__PURE__ */ new Set(["globalThis", "window", "self", "global"]);
 var TEST_FILE2 = /(?:^|[\\/])(?:__tests__|tests)[\\/]|[.](?:test|spec)[.][cm]?[jt]sx?$/;
 function isNamed4(node, name) {
@@ -10644,14 +11186,14 @@ var zodSchemaValidationRule = {
 };
 
 // eslint/ts-alignment.ts
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync16 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import { join } from "path";
 var ownRequire = createRequire2(import.meta.url);
 var majorOf = (version) => Number(version.split(".")[0]);
 function versionOf(packagePath) {
   try {
-    const parsed = JSON.parse(readFileSync14(packagePath, "utf8"));
+    const parsed = JSON.parse(readFileSync16(packagePath, "utf8"));
     if (typeof parsed !== "object" || parsed === null || !("version" in parsed)) return null;
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {