npm - pasika - Versions diffs - 0.10.103 → 0.10.105 - Mend

pasika 0.10.103 → 0.10.105

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/eslint/pasika/index.d.ts +1 -0
package/dist/eslint/pasika/index.js +469 -276
package/package.json +1 -1

package/dist/eslint/pasika/index.js CHANGED Viewed

@@ -3340,6 +3340,8 @@ var enumPlacementRule = {
     if (!filename.startsWith(sourceRoot + path25.sep)) return {};
     const inConstantsFolder = path25.basename(path25.dirname(filename)) === "constants";
     const index = getProjectIndex(sourceRoot);
+    const component = index?.modules.get(filename)?.exports.find((entry) => entry.kind === "component");
+    const componentConsumers = component ? index?.symbolConsumers.get(symbolKey(filename, component.name)) : void 0;
     return {
       TSEnumDeclaration(node) {
         const enumBody = "body" in node ? node.body : void 0;
@@ -3354,11 +3356,12 @@ var enumPlacementRule = {
           });
           return;
         }
-        const shared = (index?.symbolConsumers.get(symbolKey(filename, enumName))?.size ?? 0) > 0;
-        if (inConstantsFolder || !shared) return;
+        const consumers = index?.symbolConsumers.get(symbolKey(filename, enumName));
+        if (inConstantsFolder || !consumers || consumers.size === 0) return;
+        if (component && [...consumers].every((consumer) => componentConsumers?.has(consumer))) return;
         context.report({
           node,
-          message: "An enum imported by another file must live in a constants/ folder at its CCF; keep file-local enums beside their consumers. See docs/next-codebase-guide/rules/constants-rule.md"
+          message: "An enum imported independently of its component must live in constants/ at its CCF; keep component-owned enums beside their component. See docs/next-codebase-guide/rules/constants-rule.md"
         });
       }
     };
@@ -5376,13 +5379,148 @@ var noArbitraryTailwindRule = {
   }
 };
-// eslint/rules/no-inline-runtime-literal.ts
-import path41 from "path";
+// eslint/rules/no-duplicate-jsx-classes.ts
+import path40 from "path";
-// eslint/project/semantic-literals.ts
+// eslint/project/jsx-class-reuse.ts
 import { readFileSync as readFileSync9 } from "fs";
-import path40 from "path";
 import ts8 from "typescript";
+var MIN_SHARED_CLASSES = 5;
+var cache3 = /* @__PURE__ */ new WeakMap();
+function staticClassText(expression) {
+  if (ts8.isStringLiteral(expression) || ts8.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.text;
+  }
+  if (ts8.isParenthesizedExpression(expression)) return staticClassText(expression.expression);
+  if (!ts8.isCallExpression(expression) || !ts8.isIdentifier(expression.expression)) return void 0;
+  if (expression.expression.text !== "cn") return void 0;
+  const chunks = [];
+  for (const arg of expression.arguments) {
+    if (ts8.isSpreadElement(arg)) return void 0;
+    const text = staticClassText(arg);
+    if (text === void 0) return void 0;
+    chunks.push(text);
+  }
+  return chunks.join(" ");
+}
+function occurrencesInFile(file) {
+  const source = ts8.createSourceFile(file, readFileSync9(file, "utf8"), ts8.ScriptTarget.Latest, true, ts8.ScriptKind.TSX);
+  const result = [];
+  const visit = (node) => {
+    if (ts8.isJsxOpeningElement(node) || ts8.isJsxSelfClosingElement(node)) {
+      const tag = node.tagName.getText(source);
+      if (/^[a-z][a-z0-9-]*$/.test(tag)) {
+        const attribute = node.attributes.properties.find(
+          (item) => ts8.isJsxAttribute(item) && ts8.isIdentifier(item.name) && item.name.text === "className"
+        );
+        if (attribute && ts8.isJsxAttribute(attribute)) {
+          const initializer = attribute.initializer;
+          let text;
+          if (initializer && ts8.isStringLiteral(initializer)) {
+            text = initializer.text;
+          } else if (initializer && ts8.isJsxExpression(initializer) && initializer.expression) {
+            text = staticClassText(initializer.expression);
+          }
+          if (text !== void 0) {
+            const classes = [...new Set(text.split(/\s+/).filter(Boolean))].sort();
+            if (classes.length >= MIN_SHARED_CLASSES) {
+              const location = source.getLineAndCharacterOfPosition(attribute.getStart(source));
+              result.push({
+                file,
+                line: location.line + 1,
+                column: location.character,
+                tag,
+                classes
+              });
+            }
+          }
+        }
+      }
+    }
+    ts8.forEachChild(node, visit);
+  };
+  visit(source);
+  return result;
+}
+function reuseIndex(index) {
+  const byTagAndClasses = /* @__PURE__ */ new Map();
+  for (const file of [...index.modules.keys()].sort()) {
+    if (!/\.(?:tsx|jsx)$/.test(file) || /\.(?:test|spec)\.(?:tsx|jsx)$/.test(file)) continue;
+    try {
+      for (const occurrence of occurrencesInFile(file)) {
+        const key = JSON.stringify([occurrence.tag, occurrence.classes]);
+        const members = byTagAndClasses.get(key) ?? [];
+        members.push(occurrence);
+        byTagAndClasses.set(key, members);
+      }
+    } catch {
+    }
+  }
+  const matches = /* @__PURE__ */ new Map();
+  const groups = [];
+  for (const members of byTagAndClasses.values()) {
+    if (new Set(members.map((member) => member.file)).size < 2) continue;
+    const first = members[0];
+    if (!first) continue;
+    groups.push({ tag: first.tag, members, commonClasses: first.classes });
+    for (const occurrence of members.slice(1)) {
+      const original = members.find((member) => member.file !== occurrence.file);
+      if (!original) continue;
+      const entries = matches.get(occurrence.file) ?? [];
+      entries.push({ occurrence, original, commonClasses: first.classes });
+      matches.set(occurrence.file, entries);
+    }
+  }
+  return { matches, groups };
+}
+function getJsxReuseAnalysis(sourceRoot) {
+  const index = getProjectIndex(sourceRoot);
+  if (!index) return { matches: /* @__PURE__ */ new Map(), groups: [] };
+  const existing = cache3.get(index);
+  if (existing) return existing;
+  const result = reuseIndex(index);
+  cache3.set(index, result);
+  return result;
+}
+function getJsxClassReuses(sourceRoot) {
+  return getJsxReuseAnalysis(sourceRoot).matches;
+}
+// eslint/rules/no-duplicate-jsx-classes.ts
+var noDuplicateJsxClassesRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    docs: { description: "Extract identical static JSX class sets into reusable components." }
+  },
+  create(context) {
+    const file = path40.resolve(context.filename);
+    if (!/\.(?:jsx|tsx)$/.test(file) || /\.(?:test|spec)\.(?:jsx|tsx)$/.test(file)) return {};
+    const root = sourceRootOf(context);
+    const matches = getJsxClassReuses(root).get(file) ?? [];
+    if (matches.length === 0) return {};
+    return {
+      Program(node) {
+        for (const { occurrence, original, commonClasses } of matches) {
+          const reference = path40.relative(path40.dirname(root), original.file).split(path40.sep).join("/");
+          context.report({
+            node,
+            loc: { line: occurrence.line, column: occurrence.column },
+            message: `<${occurrence.tag}> repeats the same set of ${String(commonClasses.length)} classes as ${reference}:${String(original.line)}. Extract a shared component. See docs/next-tailwind-guide/rules/tailwind-class-reuse-rule.md`
+          });
+        }
+      }
+    };
+  }
+};
+// eslint/rules/no-inline-runtime-literal.ts
+import path42 from "path";
+// eslint/project/semantic-literals.ts
+import { readFileSync as readFileSync10 } from "fs";
+import path41 from "path";
+import ts9 from "typescript";
 var excludedProperties = /* @__PURE__ */ new Set([
   "label",
   "title",
@@ -5420,33 +5558,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 = path40.relative(root, file).split(path40.sep);
-  return !(/\.(?:test|spec|mock)\.[^.]+$/.test(path40.basename(file)) || parts.some((part) => part === "__tests__" || part === "__mocks__" || part === "mocks"));
+  const parts = path41.relative(root, file).split(path41.sep);
+  return !(/\.(?:test|spec|mock)\.[^.]+$/.test(path41.basename(file)) || parts.some((part) => part === "__tests__" || part === "__mocks__" || part === "mocks"));
 }
 function featureOf(file, root) {
-  const parts = path40.relative(root, file).split(path40.sep);
+  const parts = path41.relative(root, file).split(path41.sep);
   if (parts[0] === "features" && parts[1]) return `feature:${parts[1]}`;
   return `layer:${parts[0] ?? "src"}`;
 }
 function nameOf(property) {
-  if (ts8.isIdentifier(property) || ts8.isStringLiteral(property)) return property.text;
+  if (ts9.isIdentifier(property) || ts9.isStringLiteral(property)) return property.text;
   return void 0;
 }
 function literalOf(node) {
-  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)) {
+  if (ts9.isStringLiteral(node)) return node.text;
+  if (ts9.isNumericLiteral(node)) return Number(node.text.replaceAll("_", ""));
+  if (ts9.isPrefixUnaryExpression(node) && node.operator === ts9.SyntaxKind.MinusToken && ts9.isNumericLiteral(node.operand)) {
     return -Number(node.operand.text.replaceAll("_", ""));
   }
   return void 0;
 }
 function isLiteralRoot(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);
+  if (ts9.isPrefixUnaryExpression(node)) return literalOf(node) !== void 0;
+  return (ts9.isStringLiteral(node) || ts9.isNumericLiteral(node)) && !(ts9.isPrefixUnaryExpression(node.parent) && node.parent.operand === node);
 }
 function invocation(node) {
-  if (ts8.isIdentifier(node.expression)) return { method: node.expression.text };
-  if (ts8.isPropertyAccessExpression(node.expression)) {
+  if (ts9.isIdentifier(node.expression)) return { method: node.expression.text };
+  if (ts9.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 };
@@ -5454,7 +5592,7 @@ function invocation(node) {
   return void 0;
 }
 function isPathname(node) {
-  return ts8.isPropertyAccessExpression(node) && node.name.text === "pathname";
+  return ts9.isPropertyAccessExpression(node) && node.name.text === "pathname";
 }
 function contextFor(node, value, file, root) {
   if (typeof value === "number" && ignoredNumbers.has(value)) return void 0;
@@ -5463,7 +5601,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 (ts8.isPropertyAssignment(parent) && parent.initializer === node) {
+  if (ts9.isPropertyAssignment(parent) && parent.initializer === node) {
     const name = nameOf(parent.name);
     if (!name) return void 0;
     if (name === "path" && isApiRoute) return route();
@@ -5472,14 +5610,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 (ts8.isVariableDeclaration(parent) && parent.initializer === node && ts8.isIdentifier(parent.name)) {
+  if (ts9.isVariableDeclaration(parent) && parent.initializer === node && ts9.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 (ts8.isCallExpression(parent)) {
+  if (ts9.isCallExpression(parent)) {
     const position = parent.arguments.findIndex((argument) => argument === node);
     if (position < 0) return void 0;
     const call = invocation(parent);
@@ -5498,29 +5636,29 @@ function contextFor(node, value, file, root) {
       return { role: `column:${scope}`, family: "column" };
     }
   }
-  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))) {
+  if (isApiRoute && ts9.isBinaryExpression(parent) && (parent.operatorToken.kind === ts9.SyntaxKind.EqualsEqualsEqualsToken || parent.operatorToken.kind === ts9.SyntaxKind.ExclamationEqualsEqualsToken) && (parent.left === node && isPathname(parent.right) || parent.right === node && isPathname(parent.left))) {
     return route();
   }
-  if (isApiRoute && ts8.isCallExpression(parent) && parent.arguments[0] === node && ts8.isPropertyAccessExpression(parent.expression) && parent.expression.name.text === "startsWith" && isPathname(parent.expression.expression)) {
+  if (isApiRoute && ts9.isCallExpression(parent) && parent.arguments[0] === node && ts9.isPropertyAccessExpression(parent.expression) && parent.expression.name.text === "startsWith" && isPathname(parent.expression.expression)) {
     return route();
   }
   return void 0;
 }
 function isExported2(node) {
-  return ts8.canHaveModifiers(node) && (ts8.getModifiers(node) ?? []).some((modifier) => modifier.kind === ts8.SyntaxKind.ExportKeyword);
+  return ts9.canHaveModifiers(node) && (ts9.getModifiers(node) ?? []).some((modifier) => modifier.kind === ts9.SyntaxKind.ExportKeyword);
 }
 function parse(file, root, output) {
   if (!isProductionSource(file, root)) return;
-  const source = ts8.createSourceFile(
+  const source = ts9.createSourceFile(
     file,
-    readFileSync9(file, "utf8"),
-    ts8.ScriptTarget.Latest,
+    readFileSync10(file, "utf8"),
+    ts9.ScriptTarget.Latest,
     true,
-    file.endsWith(".tsx") || file.endsWith(".jsx") ? ts8.ScriptKind.TSX : ts8.ScriptKind.TS
+    file.endsWith(".tsx") || file.endsWith(".jsx") ? ts9.ScriptKind.TSX : ts9.ScriptKind.TS
   );
-  const inConstants = path40.relative(root, file).split(path40.sep).includes("constants");
+  const inConstants = path41.relative(root, file).split(path41.sep).includes("constants");
   for (const statement of source.statements) {
-    if (inConstants && ts8.isEnumDeclaration(statement) && isExported2(statement)) {
+    if (inConstants && ts9.isEnumDeclaration(statement) && isExported2(statement)) {
       for (const member of statement.members) {
         const value = member.initializer && literalOf(member.initializer);
         const memberName10 = nameOf(member.name);
@@ -5534,9 +5672,9 @@ function parse(file, root, output) {
         });
       }
     }
-    if (inConstants && ts8.isVariableStatement(statement) && isExported2(statement)) {
+    if (inConstants && ts9.isVariableStatement(statement) && isExported2(statement)) {
       for (const declaration of statement.declarationList.declarations) {
-        if (!ts8.isIdentifier(declaration.name) || !declaration.initializer) continue;
+        if (!ts9.isIdentifier(declaration.name) || !declaration.initializer) continue;
         const value = literalOf(declaration.initializer);
         if (value === void 0) continue;
         output.canonicals.push({
@@ -5555,7 +5693,7 @@ function parse(file, root, output) {
         const semantic = contextFor(node, value, file, root);
         if (semantic) {
           const declaration = node.parent;
-          const isCanonicalDefinition = inConstants && (ts8.isVariableDeclaration(declaration) && ts8.isVariableStatement(declaration.parent.parent) && isExported2(declaration.parent.parent) || ts8.isEnumMember(declaration));
+          const isCanonicalDefinition = inConstants && (ts9.isVariableDeclaration(declaration) && ts9.isVariableStatement(declaration.parent.parent) && isExported2(declaration.parent.parent) || ts9.isEnumMember(declaration));
           if ((!inConstants || semantic.family === "api-route") && !isCanonicalDefinition) {
             const position = source.getLineAndCharacterOfPosition(node.getStart(source));
             output.uses.push({
@@ -5570,13 +5708,13 @@ function parse(file, root, output) {
         }
       }
     }
-    ts8.forEachChild(node, visit);
+    ts9.forEachChild(node, visit);
   };
   visit(source);
 }
-var cache3 = /* @__PURE__ */ new WeakMap();
+var cache4 = /* @__PURE__ */ new WeakMap();
 function getSemanticLiteralIndex(index) {
-  const previous = cache3.get(index);
+  const previous = cache4.get(index);
   if (previous) return previous;
   const result = { uses: [], canonicals: [] };
   for (const file of index.modules.keys()) {
@@ -5585,7 +5723,7 @@ function getSemanticLiteralIndex(index) {
     } catch {
     }
   }
-  cache3.set(index, result);
+  cache4.set(index, result);
   return result;
 }
@@ -5611,7 +5749,7 @@ function isStaticDataComponentMarker(node) {
   return typeof name === "object" && name !== null && "name" in name && name.name === "data-component";
 }
 function isStaticMatcherValue(node, root, file) {
-  const relativeFile = path41.relative(root, file);
+  const relativeFile = path42.relative(root, file);
   if (relativeFile !== "middleware.ts" && relativeFile !== "proxy.ts") return false;
   let current = node;
   while (current.parent) {
@@ -5674,11 +5812,11 @@ function isSyntacticString(node) {
   return false;
 }
 function isRuntimeMockSource(file, root) {
-  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));
+  const parts = path42.relative(root, file).split(path42.sep);
+  return parts.includes("mocks") && !parts.some((part) => part === "__tests__" || part === "__mocks__") && !/\.(?:test|spec|mock)\.[^.]+$/.test(path42.basename(file));
 }
 function isCanonicalLocaleString(node, root, file) {
-  const relative = path41.relative(root, file).split(path41.sep);
+  const relative = path42.relative(root, file).split(path42.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());
@@ -5702,8 +5840,8 @@ var noInlineRuntimeLiteralRule = {
   },
   create(context) {
     const root = sourceRootOf(context);
-    const file = path41.resolve(context.filename);
-    if (!file.startsWith(root + path41.sep) || !isProductionSource(file, root) && !isRuntimeMockSource(file, root)) {
+    const file = path42.resolve(context.filename);
+    if (!file.startsWith(root + path42.sep) || !isProductionSource(file, root) && !isRuntimeMockSource(file, root)) {
       return {};
     }
     return {
@@ -5800,8 +5938,33 @@ var noLiteralInlineStyleRule = {
 };
 // eslint/rules/no-mixed-concerns.ts
-import { readFileSync as readFileSync10 } from "fs";
-import path42 from "path";
+import { readFileSync as readFileSync11 } from "fs";
+import path43 from "path";
+function isComponentSupportKind(kind) {
+  return kind === "constant" || kind === "type" || kind === "schema";
+}
+function componentSupportExport(file, name, index, visited = /* @__PURE__ */ new Set()) {
+  const key = symbolKey(file, name);
+  if (visited.has(key)) return void 0;
+  visited.add(key);
+  const module = index.modules.get(file);
+  if (!module) return void 0;
+  const supportFolder = path43.basename(path43.dirname(file));
+  if (["constants", "types", "schemas"].includes(supportFolder)) {
+    const exported = module.exports.find((item) => item.name === name && isComponentSupportKind(item.kind));
+    if (exported && isComponentSupportKind(exported.kind)) {
+      return { file, name, kind: exported.kind };
+    }
+  }
+  for (const forwarded of module.reexports) {
+    if (forwarded.names.length > 0 && !forwarded.names.includes(name)) continue;
+    const target = resolveSpecifier(file, forwarded.specifier, index.sourceRoot);
+    if (!target) continue;
+    const exported = componentSupportExport(target, name, index, visited);
+    if (exported) return exported;
+  }
+  return void 0;
+}
 var noMixedConcernsRule = {
   meta: {
     schema: [],
@@ -5825,10 +5988,39 @@ var noMixedConcernsRule = {
         if (components.length > 1) return;
         const componentName = components[0]?.name;
         if (!componentName) return;
-        const file = path42.resolve(context.filename);
+        const file = path43.resolve(context.filename);
         const sourceRoot = sourceRootOf(context);
         const index = getProjectIndex(sourceRoot);
         const componentConsumers = index?.symbolConsumers.get(symbolKey(file, componentName)) ?? /* @__PURE__ */ new Set();
+        if (index) {
+          const examined = /* @__PURE__ */ new Set();
+          for (const imported of index.modules.get(file)?.imports ?? []) {
+            const importedFile = resolveSpecifier(file, imported.specifier, sourceRoot);
+            if (!importedFile) continue;
+            for (const name of imported.names) {
+              const support = componentSupportExport(importedFile, name, index);
+              if (!support) continue;
+              const key = symbolKey(support.file, support.name);
+              if (examined.has(key)) continue;
+              examined.add(key);
+              const consumers = /* @__PURE__ */ new Set([
+                ...index.symbolConsumers.get(key) ?? [],
+                ...index.symbolConsumers.get(symbolKey(importedFile, name)) ?? []
+              ]);
+              if (!consumers.has(file)) continue;
+              const independentlyUsed = [...consumers].some((consumer) => {
+                if (consumer === file || componentConsumers.has(consumer)) return false;
+                const isForwarder = index.modules.get(consumer)?.reexports.some((forwarded) => forwarded.names.length === 0 || forwarded.names.includes(name));
+                return !isForwarder;
+              });
+              if (independentlyUsed) continue;
+              context.report({
+                loc: { line: imported.line, column: 0 },
+                message: `Supporting ${support.kind} "${support.name}" is consumed only with component "${componentName}". Define it in the component file; extract it into a support folder only when consumed independently. See docs/next-codebase-guide/rules/no-mixed-concerns-rule.md`
+              });
+            }
+          }
+        }
         const isNextPageOrLayout = /(?:^|[/\\])src[/\\]app[/\\](?:[^/\\]+[/\\])*(?:page|layout)\.tsx$/.test(
           context.filename
         );
@@ -5870,7 +6062,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(readFileSync10(target, "utf8"), target).map((component) => component.name) : [];
+            const forwardedComponents = target?.endsWith(".tsx") ? parseComponentInfo(readFileSync11(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;
@@ -5904,11 +6096,11 @@ var noMixedConcernsRule = {
 };
 // eslint/rules/no-redundant-alias.ts
-import path44 from "path";
+import path45 from "path";
 // eslint/rules/contract-ownership.ts
-import path43 from "path";
-import ts9 from "typescript";
+import path44 from "path";
+import ts10 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";
 }
@@ -5926,8 +6118,8 @@ function normalizePath(value) {
   return value.replaceAll("\\", "/").toLowerCase();
 }
 function isWithin2(root, file) {
-  const relative = path43.relative(root, file);
-  return relative === "" || !relative.startsWith("..") && !path43.isAbsolute(relative);
+  const relative = path44.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path44.isAbsolute(relative);
 }
 function mergeOwnership(values) {
   if (values.length === 0 || values.includes("unknown")) return "unknown";
@@ -5942,11 +6134,11 @@ function endpointOwnership(pathValue) {
   return "unknown";
 }
 function resolvedSymbol(checker, symbol) {
-  return symbol.flags === ts9.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+  return symbol.flags === ts10.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
 }
 function propertyName4(node) {
   if (!node) return void 0;
-  if (ts9.isIdentifier(node) || ts9.isStringLiteral(node) || ts9.isNumericLiteral(node)) return node.text;
+  if (ts10.isIdentifier(node) || ts10.isStringLiteral(node) || ts10.isNumericLiteral(node)) return node.text;
   return void 0;
 }
 var ContractOwnershipIndex = class {
@@ -5970,7 +6162,7 @@ var ContractOwnershipIndex = class {
     }
     if (declarations.length > 0) return this.endpointFromDeclarations(declarations);
     let object;
-    if (ts9.isPropertyAccessExpression(node) || ts9.isElementAccessExpression(node)) object = node.expression;
+    if (ts10.isPropertyAccessExpression(node) || ts10.isElementAccessExpression(node)) object = node.expression;
     if (!object) return { kind: "missing", ownership: "unknown" };
     const type = this.checker.getTypeAtLocation(object);
     const typeDeclarations = this.typeDeclarations(type);
@@ -5978,7 +6170,7 @@ var ContractOwnershipIndex = class {
     return this.endpointFromDeclarations(typeDeclarations);
   }
   sourceBinding(node, name) {
-    if (!ts9.isVariableDeclaration(node) || !node.initializer) {
+    if (!ts10.isVariableDeclaration(node) || !node.initializer) {
       return { kind: "missing", ownership: "unknown" };
     }
     const sourceType = this.checker.getTypeAtLocation(node.initializer);
@@ -5987,11 +6179,11 @@ var ContractOwnershipIndex = class {
     return this.endpointFromDeclarations(declarations);
   }
   targetProperty(node, name) {
-    if (!ts9.isPropertyAssignment(node) && !ts9.isShorthandPropertyAssignment(node)) {
+    if (!ts10.isPropertyAssignment(node) && !ts10.isShorthandPropertyAssignment(node)) {
       return { kind: "missing", ownership: "unknown" };
     }
     const object = node.parent;
-    if (!ts9.isObjectLiteralExpression(object)) return { kind: "missing", ownership: "unknown" };
+    if (!ts10.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);
@@ -5999,8 +6191,8 @@ var ContractOwnershipIndex = class {
     return this.endpointFromDeclarations(declarations);
   }
   memberNameSymbol(node) {
-    if (ts9.isPropertyAccessExpression(node)) return this.checker.getSymbolAtLocation(node.name);
-    if (ts9.isElementAccessExpression(node)) return this.checker.getSymbolAtLocation(node.argumentExpression);
+    if (ts10.isPropertyAccessExpression(node)) return this.checker.getSymbolAtLocation(node.name);
+    if (ts10.isElementAccessExpression(node)) return this.checker.getSymbolAtLocation(node.argumentExpression);
     return void 0;
   }
   propertyDeclarations(type, name) {
@@ -6030,14 +6222,14 @@ var ContractOwnershipIndex = class {
     if (declarations.some((declaration) => this.isDataContractField(declaration))) {
       return { kind: "data-contract", ownership };
     }
-    if (declarations.some((declaration) => ts9.isPropertySignature(declaration) || ts9.isPropertyDeclaration(declaration))) {
+    if (declarations.some((declaration) => ts10.isPropertySignature(declaration) || ts10.isPropertyDeclaration(declaration))) {
       return { kind: "typed-local", ownership };
     }
     return { kind: "non-contract", ownership };
   }
   isDataContractField(declaration) {
     if (this.isZodSchemaField(declaration)) return true;
-    if (!ts9.isPropertySignature(declaration) && !ts9.isPropertyDeclaration(declaration)) return false;
+    if (!ts10.isPropertySignature(declaration) && !ts10.isPropertyDeclaration(declaration)) return false;
     const fileName = normalizePath(declaration.getSourceFile().fileName);
     return /(?:^|\/)database(?:[-.]generated)?\.ts$/u.test(fileName);
   }
@@ -6046,10 +6238,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 (!ts9.isPropertyAssignment(declaration)) return false;
+    if (!ts10.isPropertyAssignment(declaration)) return false;
     let current = declaration.parent;
-    while (!ts9.isSourceFile(current)) {
-      if (ts9.isVariableDeclaration(current) && ts9.isIdentifier(current.name) && current.name.text.endsWith("Schema")) {
+    while (!ts10.isSourceFile(current)) {
+      if (ts10.isVariableDeclaration(current) && ts10.isIdentifier(current.name) && current.name.text.endsWith("Schema")) {
         return true;
       }
       current = current.parent;
@@ -6067,12 +6259,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, path43.resolve(fileName))) return "first-party";
+    if (isWithin2(this.cwd, path44.resolve(fileName))) return "first-party";
     return "unknown";
   }
   schemaOwnership(declaration) {
     let current = declaration;
-    while (!ts9.isSourceFile(current)) {
+    while (!ts10.isSourceFile(current)) {
       const ownership = this.schemaNodeOwnership.get(current);
       if (ownership !== void 0) return ownership;
       current = current.parent;
@@ -6081,31 +6273,31 @@ var ContractOwnershipIndex = class {
   }
   indexApiContracts() {
     for (const sourceFile of this.program.getSourceFiles()) {
-      if (sourceFile.isDeclarationFile || !isWithin2(this.cwd, path43.resolve(sourceFile.fileName))) continue;
+      if (sourceFile.isDeclarationFile || !isWithin2(this.cwd, path44.resolve(sourceFile.fileName))) continue;
       const visit = (node) => {
-        if (ts9.isCallExpression(node) && this.isDefineApiContractCall(node)) this.indexApiContractCall(node);
-        ts9.forEachChild(node, visit);
+        if (ts10.isCallExpression(node) && this.isDefineApiContractCall(node)) this.indexApiContractCall(node);
+        ts10.forEachChild(node, visit);
       };
       visit(sourceFile);
     }
   }
   isDefineApiContractCall(node) {
-    if (ts9.isIdentifier(node.expression)) return node.expression.text === "defineApiContract";
-    return ts9.isPropertyAccessExpression(node.expression) && node.expression.name.text === "defineApiContract";
+    if (ts10.isIdentifier(node.expression)) return node.expression.text === "defineApiContract";
+    return ts10.isPropertyAccessExpression(node.expression) && node.expression.name.text === "defineApiContract";
   }
   indexApiContractCall(node) {
     const argument = node.arguments[0];
-    if (!argument || !ts9.isObjectLiteralExpression(argument)) return;
+    if (!argument || !ts10.isObjectLiteralExpression(argument)) return;
     let pathExpression;
     const schemaExpressions = [];
     for (const property of argument.properties) {
-      if (ts9.isPropertyAssignment(property)) {
+      if (ts10.isPropertyAssignment(property)) {
         const name = propertyName4(property.name);
         if (name === "path") pathExpression = property.initializer;
         if (name === "requestSchema" || name === "responseSchema") schemaExpressions.push(property.initializer);
         continue;
       }
-      if (ts9.isShorthandPropertyAssignment(property)) {
+      if (ts10.isShorthandPropertyAssignment(property)) {
         const name = property.name.text;
         if (name === "path") pathExpression = property.name;
         if (name === "requestSchema" || name === "responseSchema") schemaExpressions.push(property.name);
@@ -6119,13 +6311,13 @@ var ContractOwnershipIndex = class {
   }
   staticString(node, seen) {
     if (!node) return void 0;
-    if (ts9.isStringLiteralLike(node)) return node.text;
-    if (ts9.isIdentifier(node)) {
+    if (ts10.isStringLiteralLike(node)) return node.text;
+    if (ts10.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 (ts9.isVariableDeclaration(declaration) && declaration.initializer) {
+        if (ts10.isVariableDeclaration(declaration) && declaration.initializer) {
           const value = this.staticString(declaration.initializer, seen);
           if (value !== void 0) return value;
         }
@@ -6143,20 +6335,20 @@ var ContractOwnershipIndex = class {
         this.followSchemaDeclaration(declaration, ownership, seen);
       }
     }
-    ts9.forEachChild(node, (child) => {
+    ts10.forEachChild(node, (child) => {
       this.markSchemaExpression(child, ownership, seen);
     });
   }
   schemaReferenceSymbol(node) {
-    if (ts9.isIdentifier(node)) {
+    if (ts10.isIdentifier(node)) {
       if (!node.text.endsWith("Schema")) return void 0;
       return this.checker.getSymbolAtLocation(node);
     }
-    if (ts9.isPropertyAccessExpression(node)) {
+    if (ts10.isPropertyAccessExpression(node)) {
       if (!node.name.text.endsWith("Schema")) return void 0;
       return this.checker.getSymbolAtLocation(node.name);
     }
-    if (ts9.isElementAccessExpression(node) && ts9.isStringLiteralLike(node.argumentExpression)) {
+    if (ts10.isElementAccessExpression(node) && ts10.isStringLiteralLike(node.argumentExpression)) {
       if (!node.argumentExpression.text.endsWith("Schema")) return void 0;
       return this.checker.getSymbolAtLocation(node.argumentExpression);
     }
@@ -6164,15 +6356,15 @@ var ContractOwnershipIndex = class {
   }
   followSchemaDeclaration(declaration, ownership, seen) {
     this.setSchemaOwnership(declaration, ownership);
-    if (ts9.isVariableDeclaration(declaration) && declaration.initializer) {
+    if (ts10.isVariableDeclaration(declaration) && declaration.initializer) {
       this.markSchemaExpression(declaration.initializer, ownership, seen);
       return;
     }
-    if (ts9.isPropertyAssignment(declaration)) {
+    if (ts10.isPropertyAssignment(declaration)) {
       this.markSchemaExpression(declaration.initializer, ownership, seen);
       return;
     }
-    if (ts9.isShorthandPropertyAssignment(declaration)) {
+    if (ts10.isShorthandPropertyAssignment(declaration)) {
       const valueSymbol = this.checker.getShorthandAssignmentValueSymbol(declaration);
       if (!valueSymbol || seen.has(valueSymbol)) return;
       seen.add(valueSymbol);
@@ -6352,7 +6544,7 @@ var noRedundantAliasRule = {
         if (declaration.type !== "VariableDeclaration" || declaration.kind !== "const") return;
         if (node.init.type === "Identifier") {
           const exported = declaration.parent.type === "ExportNamedDeclaration";
-          const frameworkRouteAlias = path44.basename(context.filename) === "route.ts" && exported && HTTP_METHODS.has(node.id.name);
+          const frameworkRouteAlias = path45.basename(context.filename) === "route.ts" && exported && HTTP_METHODS.has(node.id.name);
           if (frameworkRouteAlias || VALUE_SENTINELS.has(node.init.name)) return;
           context.report({
             node,
@@ -6475,7 +6667,7 @@ var noRedundantAliasRule = {
           const source = specifier.local.name;
           const alias = specifier.exported.name;
           if (source === alias) continue;
-          const frameworkRouteAlias = path44.basename(context.filename) === "route.ts" && HTTP_METHODS.has(alias);
+          const frameworkRouteAlias = path45.basename(context.filename) === "route.ts" && HTTP_METHODS.has(alias);
           if (frameworkRouteAlias) continue;
           context.report({
             node: specifier,
@@ -6500,7 +6692,7 @@ var noRedundantAliasRule = {
 };
 // eslint/rules/no-util-barrel.ts
-import path45 from "path";
+import path46 from "path";
 var noUtilBarrelRule = {
   meta: {
     schema: [],
@@ -6510,7 +6702,7 @@ var noUtilBarrelRule = {
     }
   },
   create(context) {
-    const filename = path45.resolve(context.filename);
+    const filename = path46.resolve(context.filename);
     const sourceRoot = sourceRootOf3(context, filename);
     return {
       Program(node) {
@@ -6519,7 +6711,7 @@ var noUtilBarrelRule = {
           if (!target) continue;
           const segments = target.replace(/\\/g, "/").split("/");
           const utilsIndex = segments.lastIndexOf("utils");
-          if (utilsIndex < 0 || !path45.basename(target).startsWith("index.")) continue;
+          if (utilsIndex < 0 || !path46.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`
@@ -6539,15 +6731,15 @@ function importSpecifiers2(source) {
   return specifiers;
 }
 function sourceRootOf3(context, filename) {
-  const marker = `${path45.sep}src${path45.sep}`;
+  const marker = `${path46.sep}src${path46.sep}`;
   const srcIndex = filename.lastIndexOf(marker);
   if (srcIndex >= 0) return filename.slice(0, srcIndex + marker.length - 1);
-  return path45.resolve(context.cwd ?? process.cwd(), "src");
+  return path46.resolve(context.cwd ?? process.cwd(), "src");
 }
 // eslint/rules/package-json/ci-checks.ts
-import { existsSync as existsSync6, readFileSync as readFileSync11, readdirSync as readdirSync4 } from "fs";
-import path46 from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync12, readdirSync as readdirSync4 } from "fs";
+import path47 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;
@@ -6605,7 +6797,7 @@ function readWorkflows(dir) {
   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 parsed = parse2(readFileSync12(path47.join(dir, file), "utf8"), { uniqueKeys: true });
       const content = mapping(parsed);
       if (!content) throw new Error("expected a YAML mapping");
       workflows.push(content);
@@ -6627,7 +6819,7 @@ var ciChecksRule = {
     return {
       Document(node) {
         if (!context.filename.endsWith("package.json")) return;
-        const dir = path46.join(context.cwd, ".github", "workflows");
+        const dir = path47.join(context.cwd, ".github", "workflows");
         if (!existsSync6(dir)) return;
         const report3 = (message) => {
           context.report({ node, message });
@@ -6889,8 +7081,8 @@ var nextjsStackRule = {
 };
 // eslint/rules/package-json/vitest-coverage.ts
-import { existsSync as existsSync7, readFileSync as readFileSync12 } from "fs";
-import path47 from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync13 } from "fs";
+import path48 from "path";
 function memberName6(member) {
   return member.name.type === "String" ? member.name.value : member.name.name;
 }
@@ -6960,7 +7152,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) => existsSync7(path47.join(context.cwd, name)));
+        const configName = VITEST_CONFIG_NAMES.find((name) => existsSync7(path48.join(context.cwd, name)));
         if (!configName) {
           context.report({
             node,
@@ -6968,7 +7160,7 @@ var vitestCoverageRule = {
           });
           return;
         }
-        const content = readFileSync12(path47.join(context.cwd, configName), "utf8");
+        const content = readFileSync13(path48.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}.` });
@@ -7015,8 +7207,8 @@ var nextjsPackageJsonRules = {
 };
 // eslint/rules/prefer-enum.ts
-import path48 from "path";
-import ts10 from "typescript";
+import path49 from "path";
+import ts11 from "typescript";
 function isConstAssertion(node) {
   const typeAnnotation = node.typeAnnotation;
   return typeAnnotation?.type === "TSTypeReference" && typeAnnotation.typeName?.type === "Identifier" && typeAnnotation.typeName.name === "const";
@@ -7070,13 +7262,13 @@ function isLiteralTupleAssertion(node) {
   return values.every((value) => value !== void 0) && new Set(values).size >= 2;
 }
 function isTsLiteralTupleDeclaration(declaration) {
-  if (!ts10.isVariableDeclaration(declaration) || !declaration.initializer) return false;
+  if (!ts11.isVariableDeclaration(declaration) || !declaration.initializer) return false;
   const init = declaration.initializer;
-  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) {
+  if (!ts11.isAsExpression(init) || !ts11.isTypeReferenceNode(init.type) || !ts11.isIdentifier(init.type.typeName) || init.type.typeName.text !== "const" || !ts11.isArrayLiteralExpression(init.expression) || init.expression.elements.length < 2) {
     return false;
   }
   const values = init.expression.elements.map(
-    (element) => ts10.isStringLiteral(element) || ts10.isNumericLiteral(element) ? element.text : void 0
+    (element) => ts11.isStringLiteral(element) || ts11.isNumericLiteral(element) ? element.text : void 0
   );
   return values.every((value) => value !== void 0) && new Set(values).size >= 2;
 }
@@ -7089,9 +7281,9 @@ var preferEnumRule = {
     }
   },
   create(context) {
-    const filename = path48.resolve(context.filename);
+    const filename = path49.resolve(context.filename);
     const sourceRoot = sourceRootOf(context);
-    if (!filename.startsWith(sourceRoot + path48.sep)) return {};
+    if (!filename.startsWith(sourceRoot + path49.sep)) return {};
     const objectSchemas = /* @__PURE__ */ new Map();
     const literalTuples = /* @__PURE__ */ new Set();
     const enumTupleUses = [];
@@ -7105,7 +7297,7 @@ var preferEnumRule = {
       const checker = services.program.getTypeChecker();
       const symbol = checker.getSymbolAtLocation(tsNode);
       if (!symbol) return false;
-      const original = symbol.flags === ts10.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+      const original = symbol.flags === ts11.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
       return (original.declarations ?? []).some(isTsLiteralTupleDeclaration);
     }
     return {
@@ -7200,7 +7392,7 @@ var preferEnumRule = {
 };
 // eslint/rules/prefer-object-destructuring.ts
-import ts11 from "typescript";
+import ts12 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;
@@ -7293,8 +7485,8 @@ function enumValueResolver(context) {
   const checker = services.program.getTypeChecker();
   const { esTreeNodeToTSNodeMap: nodeMap } = services;
   const isEnumSymbol = (symbol) => {
-    const resolved = symbol.flags === ts11.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
-    return (resolved.declarations ?? []).some((declaration) => ts11.isEnumDeclaration(declaration));
+    const resolved = symbol.flags === ts12.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+    return (resolved.declarations ?? []).some((declaration) => ts12.isEnumDeclaration(declaration));
   };
   return (node) => {
     const tsNode = nodeMap.get(node);
@@ -7310,18 +7502,18 @@ function detachableCallResolver(context) {
   if (!services) return () => false;
   const checker = services.program.getTypeChecker();
   const { esTreeNodeToTSNodeMap: nodeMap } = services;
-  const isUnboundFunctionType = (type) => ts11.isFunctionTypeNode(type) && !type.parameters.some((parameter) => ts11.isIdentifier(parameter.name) && parameter.name.text === "this");
+  const isUnboundFunctionType = (type) => ts12.isFunctionTypeNode(type) && !type.parameters.some((parameter) => ts12.isIdentifier(parameter.name) && parameter.name.text === "this");
   return (member) => {
     const node = nodeMap.get(member);
-    if (!node || !ts11.isPropertyAccessExpression(node)) return false;
+    if (!node || !ts12.isPropertyAccessExpression(node)) return false;
     const symbol = checker.getSymbolAtLocation(node.name);
     const declarations = symbol?.declarations;
     if (!declarations?.length) return false;
     return declarations.every((declaration) => {
-      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 (ts12.isPropertySignature(declaration) || ts12.isPropertyDeclaration(declaration)) {
+        return declaration.type !== void 0 && isUnboundFunctionType(declaration.type) || ts12.isPropertyDeclaration(declaration) && declaration.initializer !== void 0 && ts12.isArrowFunction(declaration.initializer);
       }
-      if (ts11.isPropertyAssignment(declaration)) return ts11.isArrowFunction(declaration.initializer);
+      if (ts12.isPropertyAssignment(declaration)) return ts12.isArrowFunction(declaration.initializer);
       return false;
     });
   };
@@ -7741,7 +7933,7 @@ ${indentation}`;
 };
 // eslint/rules/pure-function-extract.ts
-import path49 from "path";
+import path50 from "path";
 var ROUTE_HANDLER_EXPORT_NAMES = /* @__PURE__ */ new Set([
   "GET",
   "POST",
@@ -7806,12 +7998,12 @@ var pureFunctionExtractRule = {
   },
   create(context) {
     const filename = context.filename;
-    const isRouteFile = path49.basename(filename) === "route.ts";
+    const isRouteFile = path50.basename(filename) === "route.ts";
     const isComponentFile = filename.endsWith(".tsx") || filename.endsWith(".jsx");
     const sourceRoot = sourceRootOf(context);
-    const relative = path49.relative(sourceRoot, filename);
+    const relative = path50.relative(sourceRoot, filename);
     if (relative.startsWith("..")) return {};
-    const segments = relative.split(path49.sep);
+    const segments = relative.split(path50.sep);
     const folders = segments.slice(0, -1);
     const isHookSupportFile = folders.includes("hooks") && /\.(?:[cm]?[jt]s)$/.test(filename);
     if (!isComponentFile && !isRouteFile && !isHookSupportFile) return {};
@@ -7871,15 +8063,15 @@ var pureFunctionExtractRule = {
 };
 // eslint/rules/repeated-numeric-value.ts
-import path50 from "path";
+import path51 from "path";
 function isNonProductionFile(file, sourceRoot) {
-  const relative = path50.relative(sourceRoot, file);
-  const segments = relative.split(path50.sep);
-  const basename = path50.basename(file);
+  const relative = path51.relative(sourceRoot, file);
+  const segments = relative.split(path51.sep);
+  const basename = path51.basename(file);
   return /\.(?:test|spec|mock)\.[^.]+$/.test(basename) || segments.some((segment) => segment === "__tests__" || segment === "__mocks__" || segment === "mocks");
 }
 function isCanonicalConstantFile(file, sourceRoot) {
-  const segments = path50.relative(sourceRoot, file).split(path50.sep);
+  const segments = path51.relative(sourceRoot, file).split(path51.sep);
   return segments.includes("constants") || segments[0] === "config";
 }
 function groupKey(literal) {
@@ -7895,7 +8087,7 @@ var repeatedNumericValueRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path50.resolve(context.filename);
+    const file = path51.resolve(context.filename);
     if (isNonProductionFile(file, sourceRoot) || isCanonicalConstantFile(file, sourceRoot)) return {};
     const index = getProjectIndex(sourceRoot);
     if (!index) return {};
@@ -7932,11 +8124,11 @@ var repeatedNumericValueRule = {
 };
 // eslint/rules/repeated-semantic-literal.ts
-import path52 from "path";
+import path53 from "path";
 // eslint/rules/imported-enum-literals.ts
-import path51 from "path";
-import ts12 from "typescript";
+import path52 from "path";
+import ts13 from "typescript";
 var columnMethods2 = /* @__PURE__ */ new Set([
   "eq",
   "neq",
@@ -7953,12 +8145,12 @@ var columnMethods2 = /* @__PURE__ */ new Set([
   "not"
 ]);
 function memberName7(name) {
-  if (ts12.isIdentifier(name) || ts12.isStringLiteral(name)) return name.text;
+  if (ts13.isIdentifier(name) || ts13.isStringLiteral(name)) return name.text;
   return void 0;
 }
 function isWithin3(root, file) {
-  const relative = path51.relative(root, file);
-  return relative === "" || !relative.startsWith("..") && !path51.isAbsolute(relative);
+  const relative = path52.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path52.isAbsolute(relative);
 }
 function domainOf(name) {
   if (name.endsWith("ColumnEnum")) return "column";
@@ -7968,22 +8160,22 @@ function domainOf(name) {
 function importedEnums(file, checker, sourceRoot, importedNames) {
   const matches = /* @__PURE__ */ new Map();
   for (const statement of file.statements) {
-    if (!ts12.isImportDeclaration(statement) || !statement.importClause?.namedBindings || !ts12.isNamedImports(statement.importClause.namedBindings)) {
+    if (!ts13.isImportDeclaration(statement) || !statement.importClause?.namedBindings || !ts13.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 === ts12.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+      const resolved = symbol.flags === ts13.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
       for (const declaration of resolved.declarations ?? []) {
-        if (!ts12.isEnumDeclaration(declaration)) continue;
-        const declarationFile = path51.resolve(declaration.getSourceFile().fileName);
+        if (!ts13.isEnumDeclaration(declaration)) continue;
+        const declarationFile = path52.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 || !ts12.isStringLiteral(member.initializer)) continue;
+          if (!member.initializer || !ts13.isStringLiteral(member.initializer)) continue;
           const name = memberName7(member.name);
           if (!name) continue;
           const entries = matches.get(member.initializer.text) ?? [];
@@ -8000,25 +8192,25 @@ function importedEnums(file, checker, sourceRoot, importedNames) {
   return matches;
 }
 function isPathname2(node) {
-  return ts12.isPropertyAccessExpression(node) && node.name.text === "pathname";
+  return ts13.isPropertyAccessExpression(node) && node.name.text === "pathname";
 }
 function domainForUse(node) {
   const parent = node.parent;
-  if (ts12.isPropertyAssignment(parent) && parent.initializer === node && memberName7(parent.name) === "path") {
+  if (ts13.isPropertyAssignment(parent) && parent.initializer === node && memberName7(parent.name) === "path") {
     return "route";
   }
-  if (ts12.isCallExpression(parent) && parent.arguments[0] === node && ts12.isPropertyAccessExpression(parent.expression)) {
+  if (ts13.isCallExpression(parent) && parent.arguments[0] === node && ts13.isPropertyAccessExpression(parent.expression)) {
     const { expression, name } = parent.expression;
     if (columnMethods2.has(name.text)) return "column";
     if (name.text === "startsWith" && isPathname2(expression)) return "route";
   }
-  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))) {
+  if (ts13.isBinaryExpression(parent) && (parent.operatorToken.kind === ts13.SyntaxKind.EqualsEqualsEqualsToken || parent.operatorToken.kind === ts13.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 = path51.resolve(context.filename);
+  const filename = path52.resolve(context.filename);
   if (!isWithin3(root, filename)) return [];
   const services = typedParserServices(context.sourceCode.parserServices);
   if (!services) return [];
@@ -8034,7 +8226,7 @@ function importedEnumLiteralUses(context, root) {
   if (matches.size === 0) return [];
   const uses = [];
   const visit = (node) => {
-    if (ts12.isStringLiteral(node)) {
+    if (ts13.isStringLiteral(node)) {
       const domain = domainForUse(node);
       const candidates = matches.get(node.text)?.filter((entry) => entry.domain === domain) ?? [];
       if (candidates.length === 1) {
@@ -8051,7 +8243,7 @@ function importedEnumLiteralUses(context, root) {
         }
       }
     }
-    ts12.forEachChild(node, visit);
+    ts13.forEachChild(node, visit);
   };
   visit(file);
   return uses;
@@ -8072,7 +8264,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) || path52.relative(sourceRoot, canonical.file).split(path52.sep)[0] === "constants";
+    return location === featureOf(use.file, sourceRoot) || path53.relative(sourceRoot, canonical.file).split(path53.sep)[0] === "constants";
   }
   return false;
 }
@@ -8086,7 +8278,7 @@ 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 = path52.relative(root, existingRouteEnum.file).replaceAll(path52.sep, "/");
+    const location = path53.relative(root, existingRouteEnum.file).replaceAll(path53.sep, "/");
     return `The route ${formatValue(use)} repeats; add a member to existing ${existingRouteEnum.owner} in src/${location} and reuse it. ${DOC8}`;
   }
   if (count === 1) {
@@ -8105,7 +8297,7 @@ var repeatedSemanticLiteralRule = {
   },
   create(context) {
     const root = sourceRootOf(context);
-    const file = path52.resolve(context.filename);
+    const file = path53.resolve(context.filename);
     if (!isProductionSource(file, root)) return {};
     const project = getProjectIndex(root);
     if (!project?.modules.has(file)) return {};
@@ -8150,7 +8342,7 @@ var repeatedSemanticLiteralRule = {
     return {
       Program(node) {
         for (const use of imported) {
-          const relative = path52.relative(root, use.sourceFile).replaceAll(path52.sep, "/");
+          const relative = path53.relative(root, use.sourceFile).replaceAll(path53.sep, "/");
           context.report({
             node,
             loc: { line: use.line, column: use.column },
@@ -8165,7 +8357,7 @@ var repeatedSemanticLiteralRule = {
           if (candidates.length === 1) {
             const canonical = candidates[0];
             if (!canonical) continue;
-            const relative = path52.relative(root, canonical.file).replaceAll(path52.sep, "/");
+            const relative = path53.relative(root, canonical.file).replaceAll(path53.sep, "/");
             context.report({
               node,
               loc: { line: use.line, column: use.column },
@@ -8178,7 +8370,7 @@ var repeatedSemanticLiteralRule = {
           const peers = groups.get(key) ?? [];
           if (peers.length < 2) {
             if (use.family === "api-route" && existingRouteEnum?.owner) {
-              const location = path52.relative(root, existingRouteEnum.file).replaceAll(path52.sep, "/");
+              const location = path53.relative(root, existingRouteEnum.file).replaceAll(path53.sep, "/");
               context.report({
                 node,
                 loc: { line: use.line, column: use.column },
@@ -8390,7 +8582,7 @@ var repeatedStructureRule = {
 // eslint/rules/require-barrel-star-exports.ts
 import fs5 from "fs";
-import path53 from "path";
+import path54 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"];
@@ -8398,9 +8590,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 = path53.dirname(indexFile);
-  const direct = path53.resolve(directory, relative);
-  const candidates = path53.extname(direct) ? [direct] : MODULE_EXTENSIONS3.map((extension) => `${direct}${extension}`);
+  const directory = path54.dirname(indexFile);
+  const direct = path54.resolve(directory, relative);
+  const candidates = path54.extname(direct) ? [direct] : MODULE_EXTENSIONS3.map((extension) => `${direct}${extension}`);
   return candidates.find((candidate) => fs5.existsSync(candidate) && fs5.statSync(candidate).isFile());
 }
 var requireBarrelStarExportsRule = {
@@ -8413,9 +8605,9 @@ var requireBarrelStarExportsRule = {
     fixable: "code"
   },
   create(context) {
-    const filename = path53.resolve(context.filename);
-    if (!INDEX_NAMES.has(path53.basename(filename))) return {};
-    if (!SUPPORT_FOLDERS3.has(path53.basename(path53.dirname(filename)))) return {};
+    const filename = path54.resolve(context.filename);
+    if (!INDEX_NAMES.has(path54.basename(filename))) return {};
+    if (!SUPPORT_FOLDERS3.has(path54.basename(path54.dirname(filename)))) return {};
     return {
       ExportNamedDeclaration(node) {
         const sourceNode = node.source;
@@ -8468,7 +8660,7 @@ var requireBarrelStarExportsRule = {
 };
 // eslint/rules/root-support-placement.ts
-import path54 from "path";
+import path55 from "path";
 function isSupportFolder(value) {
   return value === "utils" || value === "types" || value === "schemas" || value === "constants";
 }
@@ -8501,7 +8693,7 @@ var rootSupportPlacementRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path54.resolve(context.filename);
+    const file = path55.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     const folderSegments = folderSegmentsOf(file, sourceRoot);
     const supportFolder = folderSegments[folderSegments.length - 1];
@@ -8547,11 +8739,11 @@ var rootSupportPlacementRule = {
 };
 // eslint/rules/route-handler-shape.ts
-import path56 from "path";
-import ts13 from "typescript";
+import path57 from "path";
+import ts14 from "typescript";
 // eslint/rules/route-single-use-delegation.ts
-import path55 from "path";
+import path56 from "path";
 function responseCall(expression) {
   if (!expression) return void 0;
   if (expression.type === "AwaitExpression") return responseCall(expression.argument);
@@ -8593,7 +8785,7 @@ function soleDelegation(handler) {
   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__");
+  return /(?:\.test|\.spec)\.[cm]?[jt]sx?$/.test(file) || path56.normalize(file).split(path56.sep).includes("__tests__");
 }
 function functionSource(index, file, name, sourceRoot, visited = /* @__PURE__ */ new Set()) {
   if (visited.has(file)) return void 0;
@@ -8662,33 +8854,33 @@ function findHandler(node) {
   return void 0;
 }
 function isLoop(node) {
-  return ts13.isForStatement(node) || ts13.isForOfStatement(node) || ts13.isForInStatement(node) || ts13.isWhileStatement(node) || ts13.isDoStatement(node);
+  return ts14.isForStatement(node) || ts14.isForOfStatement(node) || ts14.isForInStatement(node) || ts14.isWhileStatement(node) || ts14.isDoStatement(node);
 }
 function isFunctionBoundary(node) {
-  return ts13.isFunctionExpression(node) || ts13.isArrowFunction(node) || ts13.isFunctionDeclaration(node);
+  return ts14.isFunctionExpression(node) || ts14.isArrowFunction(node) || ts14.isFunctionDeclaration(node);
 }
 function analyzeHandlerBody(body, sourceText) {
   const start = body.range?.[0] ?? 0;
   const end = body.range?.[1] ?? sourceText.length;
-  const sourceFile = ts13.createSourceFile(
+  const sourceFile = ts14.createSourceFile(
     "route.ts",
     sourceText.slice(start, end),
-    ts13.ScriptTarget.Latest,
+    ts14.ScriptTarget.Latest,
     true,
-    ts13.ScriptKind.TS
+    ts14.ScriptKind.TS
   );
   const kinds = /* @__PURE__ */ new Set();
   const calledNames = /* @__PURE__ */ new Set();
   const visit = (node) => {
-    if (ts13.isTryStatement(node)) kinds.add("try");
+    if (ts14.isTryStatement(node)) kinds.add("try");
     if (isLoop(node)) kinds.add("loop");
-    if (ts13.isIfStatement(node)) kinds.add("if");
-    if (ts13.isCallExpression(node) && ts13.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map") {
+    if (ts14.isIfStatement(node)) kinds.add("if");
+    if (ts14.isCallExpression(node) && ts14.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map") {
       kinds.add("map");
     }
-    if (ts13.isCallExpression(node) && ts13.isIdentifier(node.expression)) calledNames.add(node.expression.text);
+    if (ts14.isCallExpression(node) && ts14.isIdentifier(node.expression)) calledNames.add(node.expression.text);
     if (isFunctionBoundary(node)) return;
-    ts13.forEachChild(node, visit);
+    ts14.forEachChild(node, visit);
   };
   visit(sourceFile);
   return { kinds, calledNames };
@@ -8728,7 +8920,7 @@ var routeHandlerShapeRule = {
     }
   },
   create(context) {
-    if (path56.basename(context.filename) !== "route.ts") return {};
+    if (path57.basename(context.filename) !== "route.ts") return {};
     const sourceText = context.sourceCode.text;
     function reportUnwrapped(node, name) {
       context.report({
@@ -8794,7 +8986,7 @@ var routeHandlerShapeRule = {
 };
 // eslint/rules/schema-casing.ts
-import path57 from "path";
+import path58 from "path";
 function isCamelCase(name) {
   return /^[a-z][a-zA-Z0-9]*$/.test(name);
 }
@@ -8822,9 +9014,9 @@ var schemaCasingRule = {
     }
   },
   create(context) {
-    const filename = path57.resolve(context.filename);
+    const filename = path58.resolve(context.filename);
     const sourceRoot = sourceRootOf(context);
-    if (!filename.startsWith(sourceRoot + path57.sep)) return {};
+    if (!filename.startsWith(sourceRoot + path58.sep)) return {};
     let zodLocalName;
     return {
       ImportDeclaration(node) {
@@ -8856,39 +9048,39 @@ var schemaCasingRule = {
 };
 // eslint/rules/sole-state-owner.ts
-import path58 from "path";
-import ts14 from "typescript";
+import path59 from "path";
+import ts15 from "typescript";
 function findStateHooks(node) {
   const hooks = [];
   const visit = (child) => {
-    if (ts14.isCallExpression(child) && ts14.isIdentifier(child.expression) && child.expression.text === "useState") {
-      if (ts14.isVariableDeclaration(child.parent)) {
+    if (ts15.isCallExpression(child) && ts15.isIdentifier(child.expression) && child.expression.text === "useState") {
+      if (ts15.isVariableDeclaration(child.parent)) {
         const { name } = child.parent;
-        if (ts14.isArrayBindingPattern(name) && name.elements.length >= 2) {
+        if (ts15.isArrayBindingPattern(name) && name.elements.length >= 2) {
           const value = name.elements[0];
           const updater = name.elements[1];
-          if (value && updater && ts14.isBindingElement(value) && ts14.isBindingElement(updater)) {
+          if (value && updater && ts15.isBindingElement(value) && ts15.isBindingElement(updater)) {
             const valueName = value.name;
             const updaterName = updater.name;
-            if (ts14.isIdentifier(valueName) && ts14.isIdentifier(updaterName)) {
+            if (ts15.isIdentifier(valueName) && ts15.isIdentifier(updaterName)) {
               hooks.push({ value: valueName.text, updater: updaterName.text });
             }
           }
         }
       }
     }
-    ts14.forEachChild(child, visit);
+    ts15.forEachChild(child, visit);
   };
   visit(node);
   return hooks;
 }
 function isHookUsage(node, hook) {
-  if (ts14.isCallExpression(node) && ts14.isIdentifier(node.expression) && node.expression.text === hook.updater) {
+  if (ts15.isCallExpression(node) && ts15.isIdentifier(node.expression) && node.expression.text === hook.updater) {
     return "updater";
   }
-  if (ts14.isIdentifier(node) && node.text === hook.value) {
+  if (ts15.isIdentifier(node) && node.text === hook.value) {
     const parent = node.parent;
-    if (ts14.isBindingElement(parent) || ts14.isPropertyAccessExpression(parent) || ts14.isShorthandPropertyAssignment(parent)) {
+    if (ts15.isBindingElement(parent) || ts15.isPropertyAccessExpression(parent) || ts15.isShorthandPropertyAssignment(parent)) {
       return void 0;
     }
     return "value";
@@ -8898,16 +9090,16 @@ function isHookUsage(node, hook) {
 function topLevelJsxChildren(initial) {
   if (!initial) return void 0;
   let expression = initial;
-  while (ts14.isParenthesizedExpression(expression)) expression = expression.expression;
-  if (ts14.isJsxFragment(expression)) {
+  while (ts15.isParenthesizedExpression(expression)) expression = expression.expression;
+  if (ts15.isJsxFragment(expression)) {
     const children = expression.children.filter(
-      (c) => !ts14.isJsxText(c) && !ts14.isJsxSpreadAttribute(c)
+      (c) => !ts15.isJsxText(c) && !ts15.isJsxSpreadAttribute(c)
     );
     return { root: expression, children };
   }
-  if (ts14.isJsxElement(expression)) {
+  if (ts15.isJsxElement(expression)) {
     const children = expression.children.filter(
-      (c) => !ts14.isJsxText(c) && !ts14.isJsxSpreadAttribute(c)
+      (c) => !ts15.isJsxText(c) && !ts15.isJsxSpreadAttribute(c)
     );
     return { root: expression, children };
   }
@@ -8921,8 +9113,8 @@ function collectUsesIn(child, hook) {
       positions.push(node);
       count += 1;
     }
-    if (ts14.isFunctionDeclaration(node) || ts14.isClassDeclaration(node)) return;
-    ts14.forEachChild(node, visit);
+    if (ts15.isFunctionDeclaration(node) || ts15.isClassDeclaration(node)) return;
+    ts15.forEachChild(node, visit);
   };
   visit(child);
   return { positions, count };
@@ -8936,7 +9128,7 @@ var soleStateOwnerRule = {
     }
   },
   create(context) {
-    const filename = path58.resolve(context.filename);
+    const filename = path59.resolve(context.filename);
     if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx")) return {};
     const text = context.sourceCode.text;
     const components = parseComponentInfo(text, filename);
@@ -8961,18 +9153,18 @@ var soleStateOwnerRule = {
   }
 };
 function analyzeSoleOwner(declaration, hook) {
-  const body = ts14.isFunctionDeclaration(declaration) ? declaration.body : void 0;
-  if (!body || !ts14.isBlock(body)) return void 0;
+  const body = ts15.isFunctionDeclaration(declaration) ? declaration.body : void 0;
+  if (!body || !ts15.isBlock(body)) return void 0;
   const returns = [];
   const visit = (node) => {
-    if (node !== body && (ts14.isFunctionLike(node) || ts14.isClassLike(node))) return;
-    if (ts14.isReturnStatement(node)) returns.push(node);
-    ts14.forEachChild(node, visit);
+    if (node !== body && (ts15.isFunctionLike(node) || ts15.isClassLike(node))) return;
+    if (ts15.isReturnStatement(node)) returns.push(node);
+    ts15.forEachChild(node, visit);
   };
   visit(body);
   if (returns.length !== 1) return void 0;
   const single = returns[0];
-  if (!single?.expression || !ts14.isExpression(single.expression)) return void 0;
+  if (!single?.expression || !ts15.isExpression(single.expression)) return void 0;
   const returnExpression = single.expression;
   const root = topLevelJsxChildren(returnExpression);
   if (!root || root.children.length === 0) return void 0;
@@ -8995,11 +9187,11 @@ function usesOutsideJsx(declaration, hook, children) {
   let outside = false;
   const visit = (node) => {
     if (outside) return;
-    if (node !== declaration && (ts14.isFunctionDeclaration(node) || ts14.isClassDeclaration(node))) return;
+    if (node !== declaration && (ts15.isFunctionDeclaration(node) || ts15.isClassDeclaration(node))) return;
     if (isHookUsage(node, hook)) {
       let current = node;
       let isInJsxChild = false;
-      while (!ts14.isSourceFile(current)) {
+      while (!ts15.isSourceFile(current)) {
         if (children.includes(current)) {
           isInJsxChild = true;
           break;
@@ -9008,14 +9200,14 @@ function usesOutsideJsx(declaration, hook, children) {
       }
       if (!isInJsxChild) outside = true;
     }
-    ts14.forEachChild(node, visit);
+    ts15.forEachChild(node, visit);
   };
   visit(declaration);
   return outside;
 }
 // eslint/rules/source-under-src.ts
-import path59 from "path";
+import path60 from "path";
 var NON_SOURCE_ROOT_DIRS = /* @__PURE__ */ new Set([
   ".agents",
   ".cache",
@@ -9056,14 +9248,14 @@ var sourceUnderSrcRule = {
     }
   },
   create(context) {
-    const filename = path59.resolve(context.filename);
+    const filename = path60.resolve(context.filename);
     if (!MODULE_EXTENSION.test(filename)) return {};
-    const relative = path59.relative(context.cwd, filename).replace(/\\/g, "/");
+    const relative = path60.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 = path59.basename(filename);
+      const basename = path60.basename(filename);
       if (CONFIG_FILE.test(basename) || DECLARATION_FILE.test(basename) || basename.startsWith(".")) return {};
     }
     return {
@@ -9079,7 +9271,7 @@ var sourceUnderSrcRule = {
 };
 // eslint/rules/stay-flat.ts
-import path60 from "path";
+import path61 from "path";
 var stayFlatRule = {
   meta: {
     schema: [],
@@ -9090,7 +9282,7 @@ var stayFlatRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path60.resolve(context.filename);
+    const file = path61.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length !== 3 || segments[0] !== "features") return {};
     const index = getProjectIndex(sourceRoot);
@@ -9130,7 +9322,7 @@ var stayFlatRule = {
 };
 // eslint/rules/support-file-placement.ts
-import path61 from "path";
+import path62 from "path";
 var CONFIG_OWNED_FOLDERS = /* @__PURE__ */ new Set(["types", "constants"]);
 var EXPORT_KIND_BY_SUPPORT_FOLDER = /* @__PURE__ */ new Map([
   ["constants", "constant"],
@@ -9155,7 +9347,7 @@ var supportFilePlacementRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const supportFile = path61.resolve(context.filename);
+    const supportFile = path62.resolve(context.filename);
     const currentFolder = folderSegmentsOf(supportFile, sourceRoot);
     const supportFolder = currentFolder[currentFolder.length - 1];
     if (supportFolder === void 0 || !SUPPORT_FOLDERS.has(supportFolder)) return {};
@@ -9209,7 +9401,7 @@ var supportFilePlacementRule = {
 // eslint/rules/support-folder-shape.ts
 import fs6 from "fs";
-import path62 from "path";
+import path63 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 = {
@@ -9221,12 +9413,12 @@ var supportFolderShapeRule = {
     }
   },
   create(context) {
-    const filename = path62.resolve(context.filename);
-    const baseName = path62.basename(filename);
+    const filename = path63.resolve(context.filename);
+    const baseName = path63.basename(filename);
     if (!INDEX_NAMES2.has(baseName)) return {};
-    const folder = path62.basename(path62.dirname(filename));
+    const folder = path63.basename(path63.dirname(filename));
     if (!SUPPORT_FOLDERS4.has(folder)) return {};
-    const directory = path62.dirname(filename);
+    const directory = path63.dirname(filename);
     let entries;
     try {
       entries = fs6.readdirSync(directory);
@@ -9244,7 +9436,7 @@ var supportFolderShapeRule = {
         for (const match of source.matchAll(exportPattern)) {
           hasAnyReExport = true;
           const specifier = match.groups?.specifier;
-          if (specifier?.startsWith(".")) exportedFiles.add(path62.basename(specifier));
+          if (specifier?.startsWith(".")) exportedFiles.add(path63.basename(specifier));
         }
         const guide = `docs/next-codebase-guide/rules/${folder === "constants" ? "constants" : "types-and-schemas"}-rule.md`;
         if (siblingModules.length === 0) {
@@ -9423,11 +9615,11 @@ var baseLayerPairRule = {
 // eslint/rules/tailwind/css-entry-point.ts
 import { statSync as statSync4 } from "fs";
-import path65 from "path";
+import path66 from "path";
 // eslint/rules/tailwind/source-files.ts
-import { readdirSync as readdirSync5, readFileSync as readFileSync13, statSync as statSync3 } from "fs";
-import path63 from "path";
+import { readdirSync as readdirSync5, readFileSync as readFileSync14, statSync as statSync3 } from "fs";
+import path64 from "path";
 var CSS_EXTENSIONS = [".css"];
 var MODULE_EXTENSIONS4 = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
 var SOURCE_EXTENSIONS = [...MODULE_EXTENSIONS4, ...CSS_EXTENSIONS];
@@ -9440,7 +9632,7 @@ function findFiles(dir, extensions) {
   }
   return entries.flatMap((entry) => {
     if (entry.startsWith(".") || entry === "node_modules") return [];
-    const entryPath = path63.join(dir, entry);
+    const entryPath = path64.join(dir, entry);
     let stats;
     try {
       stats = statSync3(entryPath);
@@ -9448,7 +9640,7 @@ function findFiles(dir, extensions) {
       return [];
     }
     if (stats.isDirectory()) return findFiles(entryPath, extensions);
-    return extensions.includes(path63.extname(entry)) ? [entryPath] : [];
+    return extensions.includes(path64.extname(entry)) ? [entryPath] : [];
   });
 }
 function cachedTextReader() {
@@ -9457,7 +9649,7 @@ function cachedTextReader() {
     let text = texts.get(file);
     if (text === void 0) {
       try {
-        text = readFileSync13(file, "utf8");
+        text = readFileSync14(file, "utf8");
       } catch {
         text = "";
       }
@@ -9471,7 +9663,7 @@ function escapeRegExp(text) {
 }
 // eslint/rules/tailwind/stylesheet-graph.ts
-import path64 from "path";
+import path65 from "path";
 function registersTailwind(text) {
   return /@import\s+(?:url\(\s*)?["']tailwindcss["']\s*\)?/i.test(text);
 }
@@ -9485,25 +9677,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 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));
+  if (spec.startsWith("/")) return path65.resolve(spec);
+  if (spec.startsWith("./") || spec.startsWith("../")) return path65.resolve(path65.dirname(fromFile), spec);
+  if (spec.startsWith("@/")) return path65.resolve(sourceRoot, spec.slice(2));
   return void 0;
 }
 function buildStylesheetGraph(options) {
   const { cssFiles, sourceRoot, textOf } = options;
-  const cssSet = new Set(cssFiles.map((file) => path64.normalize(file)));
+  const cssSet = new Set(cssFiles.map((file) => path65.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(path64.normalize(global));
+  for (const global of globals) reachable.add(path65.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 = path64.normalize(target);
+      const normalized = path65.normalize(target);
       if (cssSet.has(normalized) && !reachable.has(normalized)) {
         reachable.add(normalized);
         queue.push(normalized);
@@ -9515,7 +9707,7 @@ function buildStylesheetGraph(options) {
     for (const spec of importedSpecifiers(textOf(global))) {
       const target = resolveSpecifier2(global, spec, sourceRoot);
       if (!target) continue;
-      const normalized = path64.normalize(target);
+      const normalized = path65.normalize(target);
       if (cssSet.has(normalized)) directChildren.add(normalized);
     }
   }
@@ -9523,8 +9715,8 @@ function buildStylesheetGraph(options) {
 }
 // eslint/rules/tailwind/css-entry-point.ts
-var APP_STYLES_DIR = path65.join("app", "styles");
-var GLOBAL_STYLESHEET_PATH = path65.join(APP_STYLES_DIR, "globals.css");
+var APP_STYLES_DIR = path66.join("app", "styles");
+var GLOBAL_STYLESHEET_PATH = path66.join(APP_STYLES_DIR, "globals.css");
 var cssEntryPointRule = {
   meta: {
     schema: [],
@@ -9550,8 +9742,8 @@ var cssEntryPointRule = {
     return {
       "StyleSheet:exit"(node) {
         if (globals.length === 0) return;
-        const current = path65.normalize(path65.resolve(context.filename));
-        const relative = path65.relative(sourceRoot, current);
+        const current = path66.normalize(path66.resolve(context.filename));
+        const relative = path66.relative(sourceRoot, current);
         if (globals.includes(current)) {
           if (globals.length > 1) {
             context.report({
@@ -9567,7 +9759,7 @@ var cssEntryPointRule = {
             });
             return;
           }
-          const basename = path65.basename(current);
+          const basename = path66.basename(current);
           const importCount = moduleFiles.filter((modulePath) => moduleImports(textOf(modulePath), basename)).length;
           if (importCount !== 1) {
             context.report({
@@ -9577,7 +9769,7 @@ var cssEntryPointRule = {
           }
           return;
         }
-        const isInAppStyles = relative === APP_STYLES_DIR || relative.startsWith(`${APP_STYLES_DIR}${path65.sep}`);
+        const isInAppStyles = relative === APP_STYLES_DIR || relative.startsWith(`${APP_STYLES_DIR}${path66.sep}`);
         if (!isInAppStyles) {
           context.report({
             node,
@@ -10066,7 +10258,7 @@ var tailwindRules = {
 };
 // eslint/rules/type-extraction.ts
-import path66 from "path";
+import path67 from "path";
 var typeExtractionRule = {
   meta: {
     schema: [],
@@ -10077,7 +10269,7 @@ var typeExtractionRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path66.resolve(context.filename);
+    const file = path67.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length === 0) return {};
     const index = getProjectIndex(sourceRoot);
@@ -10216,9 +10408,9 @@ var uiStateRule = {
 };
 // eslint/rules/unknown-utility.ts
-import { existsSync as existsSync8, readdirSync as readdirSync6, readFileSync as readFileSync14, statSync as statSync6 } from "fs";
+import { existsSync as existsSync8, readdirSync as readdirSync6, readFileSync as readFileSync15, statSync as statSync6 } from "fs";
 import { createRequire } from "module";
-import path67 from "path";
+import path68 from "path";
 var PREFIX_NAMESPACES = {
   bg: ["color"],
   text: ["color", "text"],
@@ -10458,7 +10650,7 @@ function stylesheetFiles(dir) {
   }
   return entries.flatMap((entry) => {
     if (entry.startsWith(".") || entry === "node_modules") return [];
-    const entryPath = path67.join(dir, entry);
+    const entryPath = path68.join(dir, entry);
     let stats;
     try {
       stats = statSync6(entryPath);
@@ -10466,7 +10658,7 @@ function stylesheetFiles(dir) {
       return [];
     }
     if (stats.isDirectory()) return stylesheetFiles(entryPath);
-    return path67.extname(entry) === ".css" ? [entryPath] : [];
+    return path68.extname(entry) === ".css" ? [entryPath] : [];
   });
 }
 function packageNameOf(specifier) {
@@ -10477,24 +10669,24 @@ function packageNameOf(specifier) {
 function resolvePackageStylesheet(fromFile, specifier) {
   const packageName = packageNameOf(specifier);
   if (!packageName || packageName === "tailwindcss") return void 0;
-  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");
+  let directory = path68.dirname(fromFile);
+  while (directory !== path68.dirname(directory)) {
+    const packageRoot = path68.join(directory, "node_modules", packageName);
+    const manifestPath = path68.join(packageRoot, "package.json");
     if (existsSync8(manifestPath)) {
       try {
-        const manifest = readFileSync14(manifestPath, "utf8");
+        const manifest = readFileSync15(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 = path67.resolve(packageRoot, target);
+        const resolved = path68.resolve(packageRoot, target);
         return existsSync8(resolved) ? resolved : void 0;
       } catch {
         return void 0;
       }
     }
-    directory = path67.dirname(directory);
+    directory = path68.dirname(directory);
   }
   return void 0;
 }
@@ -10503,7 +10695,7 @@ function inventoryStylesheetFiles(projectFiles) {
   for (const file of projectFiles) {
     let css2;
     try {
-      css2 = readFileSync14(file, "utf8");
+      css2 = readFileSync15(file, "utf8");
     } catch {
       continue;
     }
@@ -10569,7 +10761,7 @@ function readInventory(files) {
   for (const file of files) {
     let css2;
     try {
-      css2 = readFileSync14(file, "utf8");
+      css2 = readFileSync15(file, "utf8");
     } catch {
       continue;
     }
@@ -10745,7 +10937,7 @@ var unknownUtilityRule = {
 };
 // eslint/rules/util-file-name.ts
-import path68 from "path";
+import path69 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();
 }
@@ -10758,7 +10950,7 @@ var utilFileNameRule = {
     }
   },
   create(context) {
-    const filename = path68.resolve(context.filename);
+    const filename = path69.resolve(context.filename);
     const segments = filename.replace(/\\/g, "/").split("/");
     if (!segments.includes("utils")) return {};
     let module;
@@ -10772,13 +10964,13 @@ var utilFileNameRule = {
     const functionName = functions[0]?.name;
     if (!functionName) return {};
     const expected = toKebabCase2(functionName);
-    const actual = path68.basename(filename, path68.extname(filename));
+    const actual = path69.basename(filename, path69.extname(filename));
     if (!expected || actual === expected) return {};
     return {
       Program(node) {
         context.report({
           node,
-          message: `A utility file exporting ${functionName} must be named ${expected}.${path68.extname(filename).slice(1)}.`
+          message: `A utility file exporting ${functionName} must be named ${expected}.${path69.extname(filename).slice(1)}.`
         });
       }
     };
@@ -10786,7 +10978,7 @@ var utilFileNameRule = {
 };
 // eslint/rules/value-extraction.ts
-import path69 from "path";
+import path70 from "path";
 var valueExtractionRule = {
   meta: {
     schema: [],
@@ -10797,7 +10989,7 @@ var valueExtractionRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path69.resolve(context.filename);
+    const file = path70.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length === 0 || segments[0] !== "app") return {};
     const index = getProjectIndex(sourceRoot);
@@ -10818,8 +11010,8 @@ var valueExtractionRule = {
 };
 // eslint/rules/vulyk/tracked-docs.ts
-import { existsSync as existsSync9, readFileSync as readFileSync15 } from "fs";
-import path70 from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync16 } from "fs";
+import path71 from "path";
 var PASIKA_REPO = "Bredansky/pasika";
 var BASE_REQUIRED_TRACKED_DOCS = [
   { name: "documentation-guide", path: "docs/documentation-guide" },
@@ -10852,8 +11044,8 @@ var trackedDocsRule = {
         if (!context.filename.endsWith("package.json")) return;
         const root = node.body;
         if (root.type !== "Object") return;
-        const projectRoot = path70.dirname(path70.resolve(context.filename));
-        const configPath = path70.join(projectRoot, "vulyk.config.ts");
+        const projectRoot = path71.dirname(path71.resolve(context.filename));
+        const configPath = path71.join(projectRoot, "vulyk.config.ts");
         if (!existsSync9(configPath)) {
           context.report({
             node,
@@ -10861,7 +11053,7 @@ var trackedDocsRule = {
           });
           return;
         }
-        const config = readFileSync15(configPath, "utf8");
+        const config = readFileSync16(configPath, "utf8");
         if (!config.includes(PASIKA_REPO)) {
           context.report({
             node,
@@ -10878,7 +11070,7 @@ var trackedDocsRule = {
             });
           }
         }
-        const agentsPath = path70.join(projectRoot, "AGENTS.md");
+        const agentsPath = path71.join(projectRoot, "AGENTS.md");
         if (!existsSync9(agentsPath)) {
           context.report({
             node,
@@ -10978,7 +11170,7 @@ var withResponseHelperRule = {
 // eslint/rules/zirka-baseline.ts
 import fs7 from "fs";
-import path71 from "path";
+import path72 from "path";
 var ESLINT_CONFIG = /^eslint\.config\.(?:ts|mts|cts|js|mjs|cjs)$/;
 var PRETTIER_CONFIGS = [
   "prettier.config.mjs",
@@ -10997,10 +11189,10 @@ var zirkaBaselineRule = {
     }
   },
   create(context) {
-    const filename = path71.resolve(context.filename);
-    const basename = path71.basename(filename);
+    const filename = path72.resolve(context.filename);
+    const basename = path72.basename(filename);
     if (!ESLINT_CONFIG.test(basename)) return {};
-    const projectRoot = path71.dirname(filename);
+    const projectRoot = path72.dirname(filename);
     const report3 = (message) => {
       context.report({
         node: context.sourceCode.ast,
@@ -11015,7 +11207,7 @@ var zirkaBaselineRule = {
             'ESLint config must take its configuration from zirka (import { styleguide } from "zirka") instead of restating rules locally.'
           );
         }
-        const tsconfigPath = path71.join(projectRoot, "tsconfig.json");
+        const tsconfigPath = path72.join(projectRoot, "tsconfig.json");
         if (!fs7.existsSync(tsconfigPath)) {
           report3('No tsconfig.json found. Create one extending the zirka TypeScript base config ("zirka/typescript").');
         } else {
@@ -11033,13 +11225,13 @@ var zirkaBaselineRule = {
             report3('tsconfig.json must extend the zirka TypeScript base config ("zirka/typescript").');
           }
         }
-        const prettierConfigFile = PRETTIER_CONFIGS.find((name) => fs7.existsSync(path71.join(projectRoot, name)));
+        const prettierConfigFile = PRETTIER_CONFIGS.find((name) => fs7.existsSync(path72.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(path71.join(projectRoot, prettierConfigFile), "utf8");
+          const content = fs7.readFileSync(path72.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."
@@ -11185,14 +11377,14 @@ var zodSchemaValidationRule = {
 };
 // eslint/ts-alignment.ts
-import { readFileSync as readFileSync16 } from "fs";
+import { readFileSync as readFileSync17 } 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(readFileSync16(packagePath, "utf8"));
+    const parsed = JSON.parse(readFileSync17(packagePath, "utf8"));
     if (typeof parsed !== "object" || parsed === null || !("version" in parsed)) return null;
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
@@ -11270,6 +11462,7 @@ var pasikaNextjsAppRules = {
   "interactive-component": interactiveComponentRule,
   "ui-state": uiStateRule,
   "no-mixed-concerns": noMixedConcernsRule,
+  "no-duplicate-jsx-classes": noDuplicateJsxClassesRule,
   "no-arbitrary-tailwind": noArbitraryTailwindRule,
   "no-literal-inline-style": noLiteralInlineStyleRule,
   "unknown-utility": unknownUtilityRule,