pasika 0.10.104 → 0.10.106

package/dist/eslint/pasika/index.js

@@ -5379,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",
@@ -5423,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 };
@@ -5457,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;
@@ -5466,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();
@@ -5475,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);
@@ -5501,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);
@@ -5537,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({
@@ -5558,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({
@@ -5573,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()) {
@@ -5588,7 +5723,7 @@ function getSemanticLiteralIndex(index) {
     } catch {
     }
   }
-  cache3.set(index, result);
+  cache4.set(index, result);
   return result;
 }
 
@@ -5614,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) {
@@ -5677,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());
@@ -5705,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 {
@@ -5803,8 +5938,8 @@ 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";
 }
@@ -5814,7 +5949,7 @@ function componentSupportExport(file, name, index, visited = /* @__PURE__ */ new
   visited.add(key);
   const module = index.modules.get(file);
   if (!module) return void 0;
-  const supportFolder = path42.basename(path42.dirname(file));
+  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)) {
@@ -5853,7 +5988,7 @@ 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();
@@ -5927,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;
@@ -5961,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";
 }
@@ -5983,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";
@@ -5999,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 {
@@ -6027,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);
@@ -6035,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);
@@ -6044,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);
@@ -6056,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) {
@@ -6087,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);
   }
@@ -6103,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;
@@ -6124,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;
@@ -6138,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);
@@ -6176,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;
         }
@@ -6200,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);
     }
@@ -6221,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);
@@ -6409,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,
@@ -6532,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,
@@ -6557,7 +6692,7 @@ var noRedundantAliasRule = {
 };
 
 // eslint/rules/no-util-barrel.ts
-import path45 from "path";
+import path46 from "path";
 var noUtilBarrelRule = {
   meta: {
     schema: [],
@@ -6567,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) {
@@ -6576,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`
@@ -6596,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;
@@ -6662,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);
@@ -6684,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 });
@@ -6946,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;
 }
@@ -7017,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,
@@ -7025,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}.` });
@@ -7072,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";
@@ -7127,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;
 }
@@ -7146,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 = [];
@@ -7162,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 {
@@ -7257,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;
@@ -7350,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);
@@ -7367,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;
     });
   };
@@ -7798,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",
@@ -7863,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 {};
@@ -7928,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) {
@@ -7952,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 {};
@@ -7989,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",
@@ -8010,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";
@@ -8025,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) ?? [];
@@ -8057,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 [];
@@ -8091,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) {
@@ -8108,7 +8243,7 @@ function importedEnumLiteralUses(context, root) {
         }
       }
     }
-    ts12.forEachChild(node, visit);
+    ts13.forEachChild(node, visit);
   };
   visit(file);
   return uses;
@@ -8129,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;
 }
@@ -8143,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) {
@@ -8162,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 {};
@@ -8207,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 },
@@ -8222,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 },
@@ -8235,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 },
@@ -8447,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"];
@@ -8455,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 = {
@@ -8470,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;
@@ -8525,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";
 }
@@ -8558,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];
@@ -8604,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);
@@ -8650,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;
@@ -8719,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 };
@@ -8785,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({
@@ -8851,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);
 }
@@ -8879,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) {
@@ -8913,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";
@@ -8955,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 };
   }
@@ -8978,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 };
@@ -8993,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);
@@ -9018,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;
@@ -9052,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;
@@ -9065,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",
@@ -9113,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 {
@@ -9136,7 +9271,7 @@ var sourceUnderSrcRule = {
 };
 
 // eslint/rules/stay-flat.ts
-import path60 from "path";
+import path61 from "path";
 var stayFlatRule = {
   meta: {
     schema: [],
@@ -9147,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);
@@ -9187,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"],
@@ -9212,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 {};
@@ -9266,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 = {
@@ -9278,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);
@@ -9301,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) {
@@ -9480,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];
@@ -9497,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);
@@ -9505,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() {
@@ -9514,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 = "";
       }
@@ -9528,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);
 }
@@ -9542,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);
@@ -9572,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);
     }
   }
@@ -9580,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: [],
@@ -9607,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({
@@ -9624,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({
@@ -9634,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,
@@ -9665,6 +9800,12 @@ var cssEntryPointRule = {
   }
 };
 
+// eslint/project/semantic-color-role.ts
+var BOUNDARY_PROPERTY_WORDS = /* @__PURE__ */ new Set(["border", "outline", "ring", "stroke"]);
+function violatesBoundaryColorRole(token) {
+  return !token.endsWith("-edge") && token.split("-").some((word) => BOUNDARY_PROPERTY_WORDS.has(word));
+}
+
 // eslint/rules/tailwind/css-variable-naming.ts
 var EDGE_PROPERTY_WORDS = /* @__PURE__ */ new Set(["border", "outline", "ring", "stroke"]);
 var NON_COLOR_WORDS = /* @__PURE__ */ new Set(["height", "leading", "offset", "radius", "size", "spacing", "style", "width"]);
@@ -9712,7 +9853,15 @@ var cssVariableNamingRule = {
       Declaration(node) {
         const property = node.property;
         if (!property.startsWith("--")) return;
-        if (isTailwindThemeVariable(property)) return;
+        if (isTailwindThemeVariable(property)) {
+          if (property.startsWith("--color-") && violatesBoundaryColorRole(property.slice("--color-".length))) {
+            context.report({
+              node,
+              message: `Theme color "${property}" names a boundary using a CSS property; use --color-<role>-edge and border-<role>-edge instead.`
+            });
+          }
+          return;
+        }
         const lower = property.toLowerCase();
         if ((lower.includes("bg") || lower.includes("background")) && !lower.endsWith("-canvas")) {
           context.report({
@@ -10123,7 +10272,7 @@ var tailwindRules = {
 };
 
 // eslint/rules/type-extraction.ts
-import path66 from "path";
+import path67 from "path";
 var typeExtractionRule = {
   meta: {
     schema: [],
@@ -10134,7 +10283,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);
@@ -10273,9 +10422,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"],
@@ -10515,7 +10664,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);
@@ -10523,7 +10672,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) {
@@ -10534,24 +10683,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;
 }
@@ -10560,7 +10709,7 @@ function inventoryStylesheetFiles(projectFiles) {
   for (const file of projectFiles) {
     let css2;
     try {
-      css2 = readFileSync14(file, "utf8");
+      css2 = readFileSync15(file, "utf8");
     } catch {
       continue;
     }
@@ -10626,7 +10775,7 @@ function readInventory(files) {
   for (const file of files) {
     let css2;
     try {
-      css2 = readFileSync14(file, "utf8");
+      css2 = readFileSync15(file, "utf8");
     } catch {
       continue;
     }
@@ -10672,6 +10821,18 @@ function isColorToken(token, inventory) {
   if (hyphen === -1) return false;
   return DEFAULT_PALETTE_FAMILIES.has(token.slice(0, hyphen)) && DEFAULT_PALETTE_SHADES.has(token.slice(hyphen + 1));
 }
+function isInvalidBoundaryColorClass(className, inventory) {
+  if (className.includes("[") || className.includes("(")) return false;
+  const utility = (className.replace(/!+$/, "").split(":").pop() ?? "").split("/")[0] ?? "";
+  const compound = Object.keys(PREFIX_NAMESPACES).find(
+    (prefix2) => prefix2.includes("-") && utility.startsWith(`${prefix2}-`)
+  );
+  const dash = utility.indexOf("-");
+  if (dash === -1) return false;
+  const prefix = compound ?? utility.slice(0, dash);
+  const token = utility.slice(prefix.length + 1);
+  return (PREFIX_NAMESPACES[prefix]?.includes("color") ?? false) && (inventory.themeTokens.get("color")?.has(token) ?? false) && violatesBoundaryColorRole(token);
+}
 function isKnown(className, inventory) {
   if (className.includes("[") || className.includes("(")) return true;
   const segments = className.replace(/!+$/, "").split(":");
@@ -10732,6 +10893,13 @@ var unknownUtilityRule = {
       for (const candidate of value.split(/\s+/)) {
         if (!candidate || seen.has(candidate)) continue;
         seen.add(candidate);
+        if (isInvalidBoundaryColorClass(candidate, inventory)) {
+          context.report({
+            node,
+            message: `Utility class "${candidate}" uses a boundary color token named after a CSS property; use a semantic -edge color token instead (for example, border-control-edge).`
+          });
+          continue;
+        }
         if (isKnown(candidate, inventory)) continue;
         const plainBase = candidate.replace(/!+$/, "").split(":").pop() ?? "";
         if (inventory.plainClasses.has(plainBase)) {
@@ -10802,7 +10970,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();
 }
@@ -10815,7 +10983,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;
@@ -10829,13 +10997,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)}.`
         });
       }
     };
@@ -10843,7 +11011,7 @@ var utilFileNameRule = {
 };
 
 // eslint/rules/value-extraction.ts
-import path69 from "path";
+import path70 from "path";
 var valueExtractionRule = {
   meta: {
     schema: [],
@@ -10854,7 +11022,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);
@@ -10875,8 +11043,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" },
@@ -10909,8 +11077,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,
@@ -10918,7 +11086,7 @@ var trackedDocsRule = {
           });
           return;
         }
-        const config = readFileSync15(configPath, "utf8");
+        const config = readFileSync16(configPath, "utf8");
         if (!config.includes(PASIKA_REPO)) {
           context.report({
             node,
@@ -10935,7 +11103,7 @@ var trackedDocsRule = {
             });
           }
         }
-        const agentsPath = path70.join(projectRoot, "AGENTS.md");
+        const agentsPath = path71.join(projectRoot, "AGENTS.md");
         if (!existsSync9(agentsPath)) {
           context.report({
             node,
@@ -11035,7 +11203,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",
@@ -11054,10 +11222,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,
@@ -11072,7 +11240,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 {
@@ -11090,13 +11258,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."
@@ -11242,14 +11410,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 {
@@ -11327,6 +11495,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,