pasika 0.10.89 → 0.10.91

package/dist/eslint/pasika/index.js

@@ -5120,20 +5120,21 @@ var noLiteralInlineStyleRule = {
 };
 
 // eslint/rules/no-mixed-concerns.ts
+import { readFileSync as readFileSync8 } from "fs";
+import path39 from "path";
 var noMixedConcernsRule = {
   meta: {
     schema: [],
     type: "problem",
     docs: {
-      description: "Enforce one React component and one exported runtime value per .tsx file."
+      description: "Enforce one React component per .tsx file and colocated exports consumed alongside it."
     }
   },
   create(context) {
     if (!context.filename.endsWith(".tsx")) return {};
-    const sourceCode = context.sourceCode.text;
     return {
       "Program:exit"() {
-        const components = parseComponentInfo(sourceCode, context.filename, { includeNonExported: true });
+        const components = parseComponentInfo(context.sourceCode.text, context.filename, { includeNonExported: true });
         if (components.length === 0) return;
         for (const extra of components.slice(1)) {
           context.report({
@@ -5144,44 +5145,77 @@ var noMixedConcernsRule = {
         if (components.length > 1) return;
         const componentName = components[0]?.name;
         if (!componentName) return;
+        const file = path39.resolve(context.filename);
+        const sourceRoot = sourceRootOf(context);
+        const index = getProjectIndex(sourceRoot);
+        const componentConsumers = index?.symbolConsumers.get(symbolKey(file, componentName)) ?? /* @__PURE__ */ new Set();
         const isNextPageOrLayout = /(?:^|[/\\])src[/\\]app[/\\](?:[^/\\]+[/\\])*(?:page|layout)\.tsx$/.test(
           context.filename
         );
+        const checkSupportingExport = (name, loc) => {
+          if (name === componentName) return;
+          if (isNextPageOrLayout) {
+            if (["metadata", "viewport", "generateMetadata", "generateViewport"].includes(name)) return;
+            context.report({
+              loc,
+              message: `Next.js page/layout files cannot export "${name}". Use a separate module for supporting values.`
+            });
+            return;
+          }
+          const consumers = index?.symbolConsumers.get(symbolKey(file, name));
+          if (!consumers) return;
+          const independent = [...consumers].filter((consumer) => !componentConsumers.has(consumer));
+          if (independent.length > 0) {
+            context.report({
+              loc,
+              message: `Supporting export "${name}" is imported without its component "${componentName}". Import them together or extract the supporting value to its appropriate module. See docs/next-codebase-guide/rules/no-mixed-concerns-rule.md`
+            });
+          }
+        };
         for (const statement of context.sourceCode.ast.body) {
           if (statement.type === "ExportNamedDeclaration") {
             if (/^export\s+(?:type|interface)\b/.test(context.sourceCode.getText(statement))) continue;
             const declaration = statement.declaration;
-            if (isNextPageOrLayout && declaration?.type === "VariableDeclaration" && declaration.declarations.every(
-              (item) => item.id.type === "Identifier" && (item.id.name === "metadata" || item.id.name === "viewport")
-            )) {
+            if (declaration?.type === "FunctionDeclaration" || declaration?.type === "ClassDeclaration") {
+              checkSupportingExport(declaration.id.name, statement.loc?.start ?? { line: 1, column: 0 });
               continue;
             }
-            if (isNextPageOrLayout && declaration?.type === "FunctionDeclaration" && (declaration.id.name === "generateMetadata" || declaration.id.name === "generateViewport")) {
-              continue;
-            }
-            if (declaration?.type === "FunctionDeclaration" && declaration.id.name === componentName) continue;
-            if (declaration?.type === "VariableDeclaration" && declaration.declarations.length === 1 && declaration.declarations[0]?.id.type === "Identifier" && declaration.declarations[0].id.name === componentName) {
+            if (declaration?.type === "VariableDeclaration") {
+              for (const variable of declaration.declarations) {
+                if (variable.id.type === "Identifier") {
+                  checkSupportingExport(variable.id.name, statement.loc?.start ?? { line: 1, column: 0 });
+                }
+              }
               continue;
             }
-            if (!declaration && statement.specifiers.every(
-              (specifier) => /^type\b/.test(context.sourceCode.getText(specifier)) || !statement.source && specifier.local.type === "Identifier" && specifier.local.name === componentName
-            )) {
-              continue;
+            const target = typeof statement.source?.value === "string" ? resolveSpecifier(file, statement.source.value, sourceRoot) : void 0;
+            const forwardedComponents = target?.endsWith(".tsx") ? parseComponentInfo(readFileSync8(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;
+              if (target && forwardedComponents.includes(specifier.local.name)) {
+                context.report({
+                  node: statement,
+                  message: `Component file "${componentName}" must not re-export another component "${specifier.local.name}". Import that component directly.`
+                });
+              } else if (!statement.source) {
+                checkSupportingExport(specifier.local.name, statement.loc?.start ?? { line: 1, column: 0 });
+              } else if (specifier.exported.type === "Identifier") {
+                checkSupportingExport(specifier.exported.name, statement.loc?.start ?? { line: 1, column: 0 });
+              }
             }
           } else if (statement.type === "ExportAllDeclaration") {
             if (/^export\s+type\b/.test(context.sourceCode.getText(statement))) continue;
+            context.report({
+              node: statement,
+              message: `Component file "${componentName}" must not use a wildcard runtime re-export. Export named supporting values only.`
+            });
           } else if (statement.type === "ExportDefaultDeclaration") {
-            if (statement.declaration.type === "Identifier" && statement.declaration.name === componentName) continue;
-            if (statement.declaration.type === "FunctionDeclaration" && statement.declaration.id?.name === componentName) {
-              continue;
-            }
-          } else {
-            continue;
+            const declaration = statement.declaration;
+            if (declaration.type === "Identifier" && declaration.name === componentName) continue;
+            if (declaration.type === "FunctionDeclaration" && declaration.id?.name === componentName) continue;
+            checkSupportingExport("default", statement.loc?.start ?? { line: 1, column: 0 });
           }
-          context.report({
-            node: statement,
-            message: `Component files must export only their own component "${componentName}". Import other values directly from their files.`
-          });
         }
       }
     };
@@ -5189,10 +5223,10 @@ var noMixedConcernsRule = {
 };
 
 // eslint/rules/no-redundant-alias.ts
-import path40 from "path";
+import path41 from "path";
 
 // eslint/rules/contract-ownership.ts
-import path39 from "path";
+import path40 from "path";
 import ts7 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";
@@ -5211,8 +5245,8 @@ function normalizePath(value) {
   return value.replaceAll("\\", "/").toLowerCase();
 }
 function isWithin2(root, file) {
-  const relative = path39.relative(root, file);
-  return relative === "" || !relative.startsWith("..") && !path39.isAbsolute(relative);
+  const relative = path40.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path40.isAbsolute(relative);
 }
 function mergeOwnership(values) {
   if (values.length === 0 || values.includes("unknown")) return "unknown";
@@ -5352,7 +5386,7 @@ 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, path39.resolve(fileName))) return "first-party";
+    if (isWithin2(this.cwd, path40.resolve(fileName))) return "first-party";
     return "unknown";
   }
   schemaOwnership(declaration) {
@@ -5366,7 +5400,7 @@ var ContractOwnershipIndex = class {
   }
   indexApiContracts() {
     for (const sourceFile of this.program.getSourceFiles()) {
-      if (sourceFile.isDeclarationFile || !isWithin2(this.cwd, path39.resolve(sourceFile.fileName))) continue;
+      if (sourceFile.isDeclarationFile || !isWithin2(this.cwd, path40.resolve(sourceFile.fileName))) continue;
       const visit = (node) => {
         if (ts7.isCallExpression(node) && this.isDefineApiContractCall(node)) this.indexApiContractCall(node);
         ts7.forEachChild(node, visit);
@@ -5637,7 +5671,7 @@ var noRedundantAliasRule = {
         if (declaration.type !== "VariableDeclaration" || declaration.kind !== "const") return;
         if (node.init.type === "Identifier") {
           const exported = declaration.parent.type === "ExportNamedDeclaration";
-          const frameworkRouteAlias = path40.basename(context.filename) === "route.ts" && exported && HTTP_METHODS.has(node.id.name);
+          const frameworkRouteAlias = path41.basename(context.filename) === "route.ts" && exported && HTTP_METHODS.has(node.id.name);
           if (frameworkRouteAlias || VALUE_SENTINELS.has(node.init.name)) return;
           context.report({
             node,
@@ -5755,7 +5789,7 @@ var noRedundantAliasRule = {
           const source = specifier.local.name;
           const alias = specifier.exported.name;
           if (source === alias) continue;
-          const frameworkRouteAlias = path40.basename(context.filename) === "route.ts" && HTTP_METHODS.has(alias);
+          const frameworkRouteAlias = path41.basename(context.filename) === "route.ts" && HTTP_METHODS.has(alias);
           if (frameworkRouteAlias) continue;
           context.report({
             node: specifier,
@@ -5780,7 +5814,7 @@ var noRedundantAliasRule = {
 };
 
 // eslint/rules/no-util-barrel.ts
-import path41 from "path";
+import path42 from "path";
 var noUtilBarrelRule = {
   meta: {
     schema: [],
@@ -5790,7 +5824,7 @@ var noUtilBarrelRule = {
     }
   },
   create(context) {
-    const filename = path41.resolve(context.filename);
+    const filename = path42.resolve(context.filename);
     const sourceRoot = sourceRootOf3(context, filename);
     return {
       Program(node) {
@@ -5799,7 +5833,7 @@ var noUtilBarrelRule = {
           if (!target) continue;
           const segments = target.replace(/\\/g, "/").split("/");
           const utilsIndex = segments.lastIndexOf("utils");
-          if (utilsIndex < 0 || !path41.basename(target).startsWith("index.")) continue;
+          if (utilsIndex < 0 || !path42.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`
@@ -5819,10 +5853,10 @@ function importSpecifiers2(source) {
   return specifiers;
 }
 function sourceRootOf3(context, filename) {
-  const marker = `${path41.sep}src${path41.sep}`;
+  const marker = `${path42.sep}src${path42.sep}`;
   const srcIndex = filename.lastIndexOf(marker);
   if (srcIndex >= 0) return filename.slice(0, srcIndex + marker.length - 1);
-  return path41.resolve(context.cwd ?? process.cwd(), "src");
+  return path42.resolve(context.cwd ?? process.cwd(), "src");
 }
 
 // eslint/rules/package-json/exact-version.ts
@@ -6040,8 +6074,8 @@ var nextjsStackRule = {
 };
 
 // eslint/rules/package-json/vitest-coverage.ts
-import { existsSync as existsSync5, readFileSync as readFileSync8 } from "fs";
-import path42 from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync9 } from "fs";
+import path43 from "path";
 function memberName5(member) {
   return member.name.type === "String" ? member.name.value : member.name.name;
 }
@@ -6111,7 +6145,7 @@ var vitestCoverageRule = {
             message: 'package.json must declare a "test:unit:coverage" script that runs Vitest with coverage.'
           });
         }
-        const configName = VITEST_CONFIG_NAMES.find((name) => existsSync5(path42.join(context.cwd, name)));
+        const configName = VITEST_CONFIG_NAMES.find((name) => existsSync5(path43.join(context.cwd, name)));
         if (!configName) {
           context.report({
             node,
@@ -6119,7 +6153,7 @@ var vitestCoverageRule = {
           });
           return;
         }
-        const content = readFileSync8(path42.join(context.cwd, configName), "utf8");
+        const content = readFileSync9(path43.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}.` });
@@ -6165,7 +6199,8 @@ var nextjsPackageJsonRules = {
 };
 
 // eslint/rules/prefer-enum.ts
-import path43 from "path";
+import path44 from "path";
+import ts8 from "typescript";
 function isConstAssertion(node) {
   const typeAnnotation = node.typeAnnotation;
   return typeAnnotation?.type === "TSTypeReference" && typeAnnotation.typeName?.type === "Identifier" && typeAnnotation.typeName.name === "const";
@@ -6208,33 +6243,88 @@ function rawZodDiscriminantLiteral(schemaCall, discriminator) {
   }
   return void 0;
 }
+function isLiteralTupleAssertion(node) {
+  if (!isConstAssertion(node)) return false;
+  const expression = node.expression;
+  if (expression?.type !== "ArrayExpression" || expression.elements.length < 2) return false;
+  const values = expression.elements.map((element) => {
+    if (element?.type !== "Literal") return void 0;
+    return typeof element.value === "string" || typeof element.value === "number" ? element.value : void 0;
+  });
+  return values.every((value) => value !== void 0) && new Set(values).size >= 2;
+}
+function isTsLiteralTupleDeclaration(declaration) {
+  if (!ts8.isVariableDeclaration(declaration) || !declaration.initializer) return false;
+  const init = declaration.initializer;
+  if (!ts8.isAsExpression(init) || !ts8.isTypeReferenceNode(init.type) || !ts8.isIdentifier(init.type.typeName) || init.type.typeName.text !== "const" || !ts8.isArrayLiteralExpression(init.expression) || init.expression.elements.length < 2) {
+    return false;
+  }
+  const values = init.expression.elements.map(
+    (element) => ts8.isStringLiteral(element) || ts8.isNumericLiteral(element) ? element.text : void 0
+  );
+  return values.every((value) => value !== void 0) && new Set(values).size >= 2;
+}
 var preferEnumRule = {
   meta: {
     schema: [],
     type: "problem",
     docs: {
-      description: "Require fixed sets of named string/number values to be TypeScript enums, including Zod discriminated-union discriminator values."
+      description: "Require fixed sets of named string/number values to be TypeScript enums, including named Zod enum tuples and discriminated-union discriminator values."
     }
   },
   create(context) {
-    const filename = path43.resolve(context.filename);
+    const filename = path44.resolve(context.filename);
     const sourceRoot = sourceRootOf(context);
-    if (!filename.startsWith(sourceRoot + path43.sep)) return {};
+    if (!filename.startsWith(sourceRoot + path44.sep)) return {};
     const objectSchemas = /* @__PURE__ */ new Map();
+    const literalTuples = /* @__PURE__ */ new Set();
+    const enumTupleUses = [];
     const discriminatedUnions = [];
     const reportedDiscriminants = /* @__PURE__ */ new Set();
+    const services = typedParserServices(context.sourceCode.parserServices);
+    function isTupleDomain(name) {
+      if (!services) return literalTuples.has(name.name);
+      const tsNode = services.esTreeNodeToTSNodeMap.get(name);
+      if (!tsNode) return false;
+      const checker = services.program.getTypeChecker();
+      const symbol = checker.getSymbolAtLocation(tsNode);
+      if (!symbol) return false;
+      const original = symbol.flags === ts8.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+      return (original.declarations ?? []).some(isTsLiteralTupleDeclaration);
+    }
     return {
       VariableDeclarator(node) {
         const { id, init } = node;
-        if (id?.type !== "Identifier" || init?.type !== "CallExpression" || !isZodCall(init, "object")) return;
-        objectSchemas.set(id.name, init);
+        if (id?.type !== "Identifier" || !init) return;
+        if (init.type === "CallExpression" && isZodCall(init, "object")) {
+          objectSchemas.set(id.name, init);
+        }
       },
       CallExpression(node) {
         if (isZodCall(node, "discriminatedUnion")) {
           discriminatedUnions.push(node);
         }
+        const argument = node.arguments?.[0];
+        if (isZodCall(node, "enum") && argument?.type === "Identifier") {
+          enumTupleUses.push({ name: argument, node });
+        }
+      },
+      TSIndexedAccessType(node) {
+        const { objectType, indexType } = node;
+        if (objectType?.type === "TSTypeQuery" && objectType.exprName?.type === "Identifier" && indexType?.type === "TSNumberKeyword") {
+          enumTupleUses.push({ name: objectType.exprName, node });
+        }
       },
       "Program:exit"() {
+        const reportedTuples = /* @__PURE__ */ new Set();
+        for (const use of enumTupleUses) {
+          if (reportedTuples.has(use.name.name) || !isTupleDomain(use.name)) continue;
+          reportedTuples.add(use.name.name);
+          context.report({
+            node: use.node,
+            message: "A const tuple used as a named enum domain must be replaced with a TypeScript enum. See docs/next-codebase-guide/rules/constants-rule.md"
+          });
+        }
         for (const unionCall of discriminatedUnions) {
           const [discriminatorArg, optionsArg] = unionCall.arguments ?? [];
           if (discriminatorArg?.type !== "Literal" || typeof discriminatorArg.value !== "string" || optionsArg?.type !== "ArrayExpression") {
@@ -6261,6 +6351,10 @@ var preferEnumRule = {
       },
       TSAsExpression(node) {
         if (!isConstAssertion(node)) return;
+        if (isLiteralTupleAssertion(node) && node.parent?.type === "VariableDeclarator") {
+          const { id } = node.parent;
+          if (id.type === "Identifier") literalTuples.add(id.name);
+        }
         const expression = node.expression;
         if (!expression || expression.type !== "ObjectExpression") return;
         if (expression.properties.length === 0) return;
@@ -6290,7 +6384,7 @@ var preferEnumRule = {
 };
 
 // eslint/rules/prefer-object-destructuring.ts
-import ts8 from "typescript";
+import ts9 from "typescript";
 var DOC5 = "See docs/next-codebase-guide/rules/redundant-aliases-rule.md";
 function hasTypeAnnotation(identifier) {
   return "typeAnnotation" in identifier && identifier.typeAnnotation !== void 0;
@@ -6379,8 +6473,8 @@ function enumValueResolver(context) {
   const checker = services.program.getTypeChecker();
   const { esTreeNodeToTSNodeMap: nodeMap } = services;
   const isEnumSymbol = (symbol) => {
-    const resolved = symbol.flags === ts8.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
-    return (resolved.declarations ?? []).some((declaration) => ts8.isEnumDeclaration(declaration));
+    const resolved = symbol.flags === ts9.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+    return (resolved.declarations ?? []).some((declaration) => ts9.isEnumDeclaration(declaration));
   };
   return (node) => {
     const tsNode = nodeMap.get(node);
@@ -6762,7 +6856,7 @@ ${indentation}`;
 };
 
 // eslint/rules/pure-function-extract.ts
-import path44 from "path";
+import path45 from "path";
 var ROUTE_HANDLER_EXPORT_NAMES = /* @__PURE__ */ new Set([
   "GET",
   "POST",
@@ -6827,12 +6921,12 @@ var pureFunctionExtractRule = {
   },
   create(context) {
     const filename = context.filename;
-    const isRouteFile = path44.basename(filename) === "route.ts";
+    const isRouteFile = path45.basename(filename) === "route.ts";
     const isComponentFile = filename.endsWith(".tsx") || filename.endsWith(".jsx");
     const sourceRoot = sourceRootOf(context);
-    const relative = path44.relative(sourceRoot, filename);
+    const relative = path45.relative(sourceRoot, filename);
     if (relative.startsWith("..")) return {};
-    const segments = relative.split(path44.sep);
+    const segments = relative.split(path45.sep);
     const folders = segments.slice(0, -1);
     const isHookSupportFile = folders.includes("hooks") && /\.(?:[cm]?[jt]s)$/.test(filename);
     if (!isComponentFile && !isRouteFile && !isHookSupportFile) return {};
@@ -6892,16 +6986,16 @@ var pureFunctionExtractRule = {
 };
 
 // eslint/rules/repeated-numeric-value.ts
-import path45 from "path";
+import path46 from "path";
 var ignoredValues = /* @__PURE__ */ new Set([-1, 0, 1]);
 function isNonProductionFile(file, sourceRoot) {
-  const relative = path45.relative(sourceRoot, file);
-  const segments = relative.split(path45.sep);
-  const basename = path45.basename(file);
+  const relative = path46.relative(sourceRoot, file);
+  const segments = relative.split(path46.sep);
+  const basename = path46.basename(file);
   return /\.(?:test|spec|mock)\.[^.]+$/.test(basename) || segments.some((segment) => segment === "__tests__" || segment === "__mocks__" || segment === "mocks");
 }
 function isCanonicalConstantFile(file, sourceRoot) {
-  const segments = path45.relative(sourceRoot, file).split(path45.sep);
+  const segments = path46.relative(sourceRoot, file).split(path46.sep);
   return segments.includes("constants") || segments[0] === "config";
 }
 function groupKey(literal) {
@@ -6917,7 +7011,7 @@ var repeatedNumericValueRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path45.resolve(context.filename);
+    const file = path46.resolve(context.filename);
     if (isNonProductionFile(file, sourceRoot) || isCanonicalConstantFile(file, sourceRoot)) return {};
     const index = getProjectIndex(sourceRoot);
     if (!index) return {};
@@ -7137,7 +7231,7 @@ var repeatedStructureRule = {
 
 // eslint/rules/require-barrel-star-exports.ts
 import fs5 from "fs";
-import path46 from "path";
+import path47 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"];
@@ -7145,9 +7239,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 = path46.dirname(indexFile);
-  const direct = path46.resolve(directory, relative);
-  const candidates = path46.extname(direct) ? [direct] : MODULE_EXTENSIONS3.map((extension) => `${direct}${extension}`);
+  const directory = path47.dirname(indexFile);
+  const direct = path47.resolve(directory, relative);
+  const candidates = path47.extname(direct) ? [direct] : MODULE_EXTENSIONS3.map((extension) => `${direct}${extension}`);
   return candidates.find((candidate) => fs5.existsSync(candidate) && fs5.statSync(candidate).isFile());
 }
 var requireBarrelStarExportsRule = {
@@ -7160,9 +7254,9 @@ var requireBarrelStarExportsRule = {
     fixable: "code"
   },
   create(context) {
-    const filename = path46.resolve(context.filename);
-    if (!INDEX_NAMES.has(path46.basename(filename))) return {};
-    if (!SUPPORT_FOLDERS3.has(path46.basename(path46.dirname(filename)))) return {};
+    const filename = path47.resolve(context.filename);
+    if (!INDEX_NAMES.has(path47.basename(filename))) return {};
+    if (!SUPPORT_FOLDERS3.has(path47.basename(path47.dirname(filename)))) return {};
     return {
       ExportNamedDeclaration(node) {
         const sourceNode = node.source;
@@ -7215,7 +7309,7 @@ var requireBarrelStarExportsRule = {
 };
 
 // eslint/rules/root-support-placement.ts
-import path47 from "path";
+import path48 from "path";
 function isSupportFolder(value) {
   return value === "utils" || value === "types" || value === "schemas" || value === "constants";
 }
@@ -7248,7 +7342,7 @@ var rootSupportPlacementRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path47.resolve(context.filename);
+    const file = path48.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     const folderSegments = folderSegmentsOf(file, sourceRoot);
     const supportFolder = folderSegments[folderSegments.length - 1];
@@ -7294,8 +7388,8 @@ var rootSupportPlacementRule = {
 };
 
 // eslint/rules/route-handler-shape.ts
-import path48 from "path";
-import ts9 from "typescript";
+import path49 from "path";
+import ts10 from "typescript";
 var HTTP_METHODS2 = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
 var REQUIRED_BOUNDARY = "withResponse";
 function isFunctionLike(node) {
@@ -7313,33 +7407,33 @@ function findHandler(node) {
   return void 0;
 }
 function isLoop(node) {
-  return ts9.isForStatement(node) || ts9.isForOfStatement(node) || ts9.isForInStatement(node) || ts9.isWhileStatement(node) || ts9.isDoStatement(node);
+  return ts10.isForStatement(node) || ts10.isForOfStatement(node) || ts10.isForInStatement(node) || ts10.isWhileStatement(node) || ts10.isDoStatement(node);
 }
 function isFunctionBoundary(node) {
-  return ts9.isFunctionExpression(node) || ts9.isArrowFunction(node) || ts9.isFunctionDeclaration(node);
+  return ts10.isFunctionExpression(node) || ts10.isArrowFunction(node) || ts10.isFunctionDeclaration(node);
 }
 function analyzeHandlerBody(body, sourceText) {
   const start = body.range?.[0] ?? 0;
   const end = body.range?.[1] ?? sourceText.length;
-  const sourceFile = ts9.createSourceFile(
+  const sourceFile = ts10.createSourceFile(
     "route.ts",
     sourceText.slice(start, end),
-    ts9.ScriptTarget.Latest,
+    ts10.ScriptTarget.Latest,
     true,
-    ts9.ScriptKind.TS
+    ts10.ScriptKind.TS
   );
   const kinds = /* @__PURE__ */ new Set();
   const calledNames = /* @__PURE__ */ new Set();
   const visit = (node) => {
-    if (ts9.isTryStatement(node)) kinds.add("try");
+    if (ts10.isTryStatement(node)) kinds.add("try");
     if (isLoop(node)) kinds.add("loop");
-    if (ts9.isIfStatement(node)) kinds.add("if");
-    if (ts9.isCallExpression(node) && ts9.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map") {
+    if (ts10.isIfStatement(node)) kinds.add("if");
+    if (ts10.isCallExpression(node) && ts10.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map") {
       kinds.add("map");
     }
-    if (ts9.isCallExpression(node) && ts9.isIdentifier(node.expression)) calledNames.add(node.expression.text);
+    if (ts10.isCallExpression(node) && ts10.isIdentifier(node.expression)) calledNames.add(node.expression.text);
     if (isFunctionBoundary(node)) return;
-    ts9.forEachChild(node, visit);
+    ts10.forEachChild(node, visit);
   };
   visit(sourceFile);
   return { kinds, calledNames };
@@ -7379,7 +7473,7 @@ var routeHandlerShapeRule = {
     }
   },
   create(context) {
-    if (path48.basename(context.filename) !== "route.ts") return {};
+    if (path49.basename(context.filename) !== "route.ts") return {};
     const sourceText = context.sourceCode.text;
     function reportUnwrapped(node, name) {
       context.report({
@@ -7438,7 +7532,7 @@ var routeHandlerShapeRule = {
 };
 
 // eslint/rules/schema-casing.ts
-import path49 from "path";
+import path50 from "path";
 function isCamelCase(name) {
   return /^[a-z][a-zA-Z0-9]*$/.test(name);
 }
@@ -7466,9 +7560,9 @@ var schemaCasingRule = {
     }
   },
   create(context) {
-    const filename = path49.resolve(context.filename);
+    const filename = path50.resolve(context.filename);
     const sourceRoot = sourceRootOf(context);
-    if (!filename.startsWith(sourceRoot + path49.sep)) return {};
+    if (!filename.startsWith(sourceRoot + path50.sep)) return {};
     let zodLocalName;
     return {
       ImportDeclaration(node) {
@@ -7500,39 +7594,39 @@ var schemaCasingRule = {
 };
 
 // eslint/rules/sole-state-owner.ts
-import path50 from "path";
-import ts10 from "typescript";
+import path51 from "path";
+import ts11 from "typescript";
 function findStateHooks(node) {
   const hooks = [];
   const visit = (child) => {
-    if (ts10.isCallExpression(child) && ts10.isIdentifier(child.expression) && child.expression.text === "useState") {
-      if (ts10.isVariableDeclaration(child.parent)) {
+    if (ts11.isCallExpression(child) && ts11.isIdentifier(child.expression) && child.expression.text === "useState") {
+      if (ts11.isVariableDeclaration(child.parent)) {
         const { name } = child.parent;
-        if (ts10.isArrayBindingPattern(name) && name.elements.length >= 2) {
+        if (ts11.isArrayBindingPattern(name) && name.elements.length >= 2) {
           const value = name.elements[0];
           const updater = name.elements[1];
-          if (value && updater && ts10.isBindingElement(value) && ts10.isBindingElement(updater)) {
+          if (value && updater && ts11.isBindingElement(value) && ts11.isBindingElement(updater)) {
             const valueName = value.name;
             const updaterName = updater.name;
-            if (ts10.isIdentifier(valueName) && ts10.isIdentifier(updaterName)) {
+            if (ts11.isIdentifier(valueName) && ts11.isIdentifier(updaterName)) {
               hooks.push({ value: valueName.text, updater: updaterName.text });
             }
           }
         }
       }
     }
-    ts10.forEachChild(child, visit);
+    ts11.forEachChild(child, visit);
   };
   visit(node);
   return hooks;
 }
 function isHookUsage(node, hook) {
-  if (ts10.isCallExpression(node) && ts10.isIdentifier(node.expression) && node.expression.text === hook.updater) {
+  if (ts11.isCallExpression(node) && ts11.isIdentifier(node.expression) && node.expression.text === hook.updater) {
     return "updater";
   }
-  if (ts10.isIdentifier(node) && node.text === hook.value) {
+  if (ts11.isIdentifier(node) && node.text === hook.value) {
     const parent = node.parent;
-    if (ts10.isBindingElement(parent) || ts10.isPropertyAccessExpression(parent) || ts10.isShorthandPropertyAssignment(parent)) {
+    if (ts11.isBindingElement(parent) || ts11.isPropertyAccessExpression(parent) || ts11.isShorthandPropertyAssignment(parent)) {
       return void 0;
     }
     return "value";
@@ -7542,16 +7636,16 @@ function isHookUsage(node, hook) {
 function topLevelJsxChildren(initial) {
   if (!initial) return void 0;
   let expression = initial;
-  while (ts10.isParenthesizedExpression(expression)) expression = expression.expression;
-  if (ts10.isJsxFragment(expression)) {
+  while (ts11.isParenthesizedExpression(expression)) expression = expression.expression;
+  if (ts11.isJsxFragment(expression)) {
     const children = expression.children.filter(
-      (c) => !ts10.isJsxText(c) && !ts10.isJsxSpreadAttribute(c)
+      (c) => !ts11.isJsxText(c) && !ts11.isJsxSpreadAttribute(c)
     );
     return { root: expression, children };
   }
-  if (ts10.isJsxElement(expression)) {
+  if (ts11.isJsxElement(expression)) {
     const children = expression.children.filter(
-      (c) => !ts10.isJsxText(c) && !ts10.isJsxSpreadAttribute(c)
+      (c) => !ts11.isJsxText(c) && !ts11.isJsxSpreadAttribute(c)
     );
     return { root: expression, children };
   }
@@ -7565,8 +7659,8 @@ function collectUsesIn(child, hook) {
       positions.push(node);
       count += 1;
     }
-    if (ts10.isFunctionDeclaration(node) || ts10.isClassDeclaration(node)) return;
-    ts10.forEachChild(node, visit);
+    if (ts11.isFunctionDeclaration(node) || ts11.isClassDeclaration(node)) return;
+    ts11.forEachChild(node, visit);
   };
   visit(child);
   return { positions, count };
@@ -7580,7 +7674,7 @@ var soleStateOwnerRule = {
     }
   },
   create(context) {
-    const filename = path50.resolve(context.filename);
+    const filename = path51.resolve(context.filename);
     if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx")) return {};
     const text = context.sourceCode.text;
     const components = parseComponentInfo(text, filename);
@@ -7605,18 +7699,18 @@ var soleStateOwnerRule = {
   }
 };
 function analyzeSoleOwner(declaration, hook) {
-  const body = ts10.isFunctionDeclaration(declaration) ? declaration.body : void 0;
-  if (!body || !ts10.isBlock(body)) return void 0;
+  const body = ts11.isFunctionDeclaration(declaration) ? declaration.body : void 0;
+  if (!body || !ts11.isBlock(body)) return void 0;
   const returns = [];
   const visit = (node) => {
-    if (node !== body && (ts10.isFunctionLike(node) || ts10.isClassLike(node))) return;
-    if (ts10.isReturnStatement(node)) returns.push(node);
-    ts10.forEachChild(node, visit);
+    if (node !== body && (ts11.isFunctionLike(node) || ts11.isClassLike(node))) return;
+    if (ts11.isReturnStatement(node)) returns.push(node);
+    ts11.forEachChild(node, visit);
   };
   visit(body);
   if (returns.length !== 1) return void 0;
   const single = returns[0];
-  if (!single?.expression || !ts10.isExpression(single.expression)) return void 0;
+  if (!single?.expression || !ts11.isExpression(single.expression)) return void 0;
   const returnExpression = single.expression;
   const root = topLevelJsxChildren(returnExpression);
   if (!root || root.children.length === 0) return void 0;
@@ -7639,11 +7733,11 @@ function usesOutsideJsx(declaration, hook, children) {
   let outside = false;
   const visit = (node) => {
     if (outside) return;
-    if (node !== declaration && (ts10.isFunctionDeclaration(node) || ts10.isClassDeclaration(node))) return;
+    if (node !== declaration && (ts11.isFunctionDeclaration(node) || ts11.isClassDeclaration(node))) return;
     if (isHookUsage(node, hook)) {
       let current = node;
       let isInJsxChild = false;
-      while (!ts10.isSourceFile(current)) {
+      while (!ts11.isSourceFile(current)) {
         if (children.includes(current)) {
           isInJsxChild = true;
           break;
@@ -7652,14 +7746,14 @@ function usesOutsideJsx(declaration, hook, children) {
       }
       if (!isInJsxChild) outside = true;
     }
-    ts10.forEachChild(node, visit);
+    ts11.forEachChild(node, visit);
   };
   visit(declaration);
   return outside;
 }
 
 // eslint/rules/source-under-src.ts
-import path51 from "path";
+import path52 from "path";
 var NON_SOURCE_ROOT_DIRS = /* @__PURE__ */ new Set([
   ".agents",
   ".cache",
@@ -7700,14 +7794,14 @@ var sourceUnderSrcRule = {
     }
   },
   create(context) {
-    const filename = path51.resolve(context.filename);
+    const filename = path52.resolve(context.filename);
     if (!MODULE_EXTENSION.test(filename)) return {};
-    const relative = path51.relative(context.cwd, filename).replace(/\\/g, "/");
+    const relative = path52.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 = path51.basename(filename);
+      const basename = path52.basename(filename);
       if (CONFIG_FILE.test(basename) || DECLARATION_FILE.test(basename) || basename.startsWith(".")) return {};
     }
     return {
@@ -7723,7 +7817,7 @@ var sourceUnderSrcRule = {
 };
 
 // eslint/rules/stay-flat.ts
-import path52 from "path";
+import path53 from "path";
 var stayFlatRule = {
   meta: {
     schema: [],
@@ -7734,7 +7828,7 @@ var stayFlatRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path52.resolve(context.filename);
+    const file = path53.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length !== 3 || segments[0] !== "features") return {};
     const index = getProjectIndex(sourceRoot);
@@ -7774,7 +7868,7 @@ var stayFlatRule = {
 };
 
 // eslint/rules/support-file-placement.ts
-import path53 from "path";
+import path54 from "path";
 var CONFIG_OWNED_FOLDERS = /* @__PURE__ */ new Set(["types", "constants"]);
 var EXPORT_KIND_BY_SUPPORT_FOLDER = /* @__PURE__ */ new Map([
   ["constants", "constant"],
@@ -7799,7 +7893,7 @@ var supportFilePlacementRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const supportFile = path53.resolve(context.filename);
+    const supportFile = path54.resolve(context.filename);
     const currentFolder = folderSegmentsOf(supportFile, sourceRoot);
     const supportFolder = currentFolder[currentFolder.length - 1];
     if (supportFolder === void 0 || !SUPPORT_FOLDERS.has(supportFolder)) return {};
@@ -7853,7 +7947,7 @@ var supportFilePlacementRule = {
 
 // eslint/rules/support-folder-shape.ts
 import fs6 from "fs";
-import path54 from "path";
+import path55 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 = {
@@ -7865,12 +7959,12 @@ var supportFolderShapeRule = {
     }
   },
   create(context) {
-    const filename = path54.resolve(context.filename);
-    const baseName = path54.basename(filename);
+    const filename = path55.resolve(context.filename);
+    const baseName = path55.basename(filename);
     if (!INDEX_NAMES2.has(baseName)) return {};
-    const folder = path54.basename(path54.dirname(filename));
+    const folder = path55.basename(path55.dirname(filename));
     if (!SUPPORT_FOLDERS4.has(folder)) return {};
-    const directory = path54.dirname(filename);
+    const directory = path55.dirname(filename);
     let entries;
     try {
       entries = fs6.readdirSync(directory);
@@ -7888,7 +7982,7 @@ var supportFolderShapeRule = {
         for (const match of source.matchAll(exportPattern)) {
           hasAnyReExport = true;
           const specifier = match.groups?.specifier;
-          if (specifier?.startsWith(".")) exportedFiles.add(path54.basename(specifier));
+          if (specifier?.startsWith(".")) exportedFiles.add(path55.basename(specifier));
         }
         const guide = `docs/next-codebase-guide/rules/${folder === "constants" ? "constants" : "types-and-schemas"}-rule.md`;
         if (siblingModules.length === 0) {
@@ -8067,11 +8161,11 @@ var baseLayerPairRule = {
 
 // eslint/rules/tailwind/css-entry-point.ts
 import { statSync as statSync4 } from "fs";
-import path57 from "path";
+import path58 from "path";
 
 // eslint/rules/tailwind/source-files.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync9, statSync as statSync3 } from "fs";
-import path55 from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync10, statSync as statSync3 } from "fs";
+import path56 from "path";
 var CSS_EXTENSIONS = [".css"];
 var MODULE_EXTENSIONS4 = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
 var SOURCE_EXTENSIONS = [...MODULE_EXTENSIONS4, ...CSS_EXTENSIONS];
@@ -8084,7 +8178,7 @@ function findFiles(dir, extensions) {
   }
   return entries.flatMap((entry) => {
     if (entry.startsWith(".") || entry === "node_modules") return [];
-    const entryPath = path55.join(dir, entry);
+    const entryPath = path56.join(dir, entry);
     let stats;
     try {
       stats = statSync3(entryPath);
@@ -8092,7 +8186,7 @@ function findFiles(dir, extensions) {
       return [];
     }
     if (stats.isDirectory()) return findFiles(entryPath, extensions);
-    return extensions.includes(path55.extname(entry)) ? [entryPath] : [];
+    return extensions.includes(path56.extname(entry)) ? [entryPath] : [];
   });
 }
 function cachedTextReader() {
@@ -8101,7 +8195,7 @@ function cachedTextReader() {
     let text = texts.get(file);
     if (text === void 0) {
       try {
-        text = readFileSync9(file, "utf8");
+        text = readFileSync10(file, "utf8");
       } catch {
         text = "";
       }
@@ -8115,7 +8209,7 @@ function escapeRegExp(text) {
 }
 
 // eslint/rules/tailwind/stylesheet-graph.ts
-import path56 from "path";
+import path57 from "path";
 function registersTailwind(text) {
   return /@import\s+(?:url\(\s*)?["']tailwindcss["']\s*\)?/i.test(text);
 }
@@ -8129,25 +8223,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 path56.resolve(spec);
-  if (spec.startsWith("./") || spec.startsWith("../")) return path56.resolve(path56.dirname(fromFile), spec);
-  if (spec.startsWith("@/")) return path56.resolve(sourceRoot, spec.slice(2));
+  if (spec.startsWith("/")) return path57.resolve(spec);
+  if (spec.startsWith("./") || spec.startsWith("../")) return path57.resolve(path57.dirname(fromFile), spec);
+  if (spec.startsWith("@/")) return path57.resolve(sourceRoot, spec.slice(2));
   return void 0;
 }
 function buildStylesheetGraph(options) {
   const { cssFiles, sourceRoot, textOf } = options;
-  const cssSet = new Set(cssFiles.map((file) => path56.normalize(file)));
+  const cssSet = new Set(cssFiles.map((file) => path57.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(path56.normalize(global));
+  for (const global of globals) reachable.add(path57.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 = path56.normalize(target);
+      const normalized = path57.normalize(target);
       if (cssSet.has(normalized) && !reachable.has(normalized)) {
         reachable.add(normalized);
         queue.push(normalized);
@@ -8159,7 +8253,7 @@ function buildStylesheetGraph(options) {
     for (const spec of importedSpecifiers(textOf(global))) {
       const target = resolveSpecifier2(global, spec, sourceRoot);
       if (!target) continue;
-      const normalized = path56.normalize(target);
+      const normalized = path57.normalize(target);
       if (cssSet.has(normalized)) directChildren.add(normalized);
     }
   }
@@ -8167,8 +8261,8 @@ function buildStylesheetGraph(options) {
 }
 
 // eslint/rules/tailwind/css-entry-point.ts
-var APP_STYLES_DIR = path57.join("app", "styles");
-var GLOBAL_STYLESHEET_PATH = path57.join(APP_STYLES_DIR, "globals.css");
+var APP_STYLES_DIR = path58.join("app", "styles");
+var GLOBAL_STYLESHEET_PATH = path58.join(APP_STYLES_DIR, "globals.css");
 var cssEntryPointRule = {
   meta: {
     schema: [],
@@ -8194,8 +8288,8 @@ var cssEntryPointRule = {
     return {
       "StyleSheet:exit"(node) {
         if (globals.length === 0) return;
-        const current = path57.normalize(path57.resolve(context.filename));
-        const relative = path57.relative(sourceRoot, current);
+        const current = path58.normalize(path58.resolve(context.filename));
+        const relative = path58.relative(sourceRoot, current);
         if (globals.includes(current)) {
           if (globals.length > 1) {
             context.report({
@@ -8211,7 +8305,7 @@ var cssEntryPointRule = {
             });
             return;
           }
-          const basename = path57.basename(current);
+          const basename = path58.basename(current);
           const importCount = moduleFiles.filter((modulePath) => moduleImports(textOf(modulePath), basename)).length;
           if (importCount !== 1) {
             context.report({
@@ -8221,7 +8315,7 @@ var cssEntryPointRule = {
           }
           return;
         }
-        const isInAppStyles = relative === APP_STYLES_DIR || relative.startsWith(`${APP_STYLES_DIR}${path57.sep}`);
+        const isInAppStyles = relative === APP_STYLES_DIR || relative.startsWith(`${APP_STYLES_DIR}${path58.sep}`);
         if (!isInAppStyles) {
           context.report({
             node,
@@ -8710,7 +8804,7 @@ var tailwindRules = {
 };
 
 // eslint/rules/type-extraction.ts
-import path58 from "path";
+import path59 from "path";
 var typeExtractionRule = {
   meta: {
     schema: [],
@@ -8721,7 +8815,7 @@ var typeExtractionRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path58.resolve(context.filename);
+    const file = path59.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length === 0) return {};
     const index = getProjectIndex(sourceRoot);
@@ -8860,9 +8954,9 @@ var uiStateRule = {
 };
 
 // eslint/rules/unknown-utility.ts
-import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync10, statSync as statSync6 } from "fs";
+import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync11, statSync as statSync6 } from "fs";
 import { createRequire } from "module";
-import path59 from "path";
+import path60 from "path";
 var PREFIX_NAMESPACES = {
   bg: ["color"],
   text: ["color", "text"],
@@ -9102,7 +9196,7 @@ function stylesheetFiles(dir) {
   }
   return entries.flatMap((entry) => {
     if (entry.startsWith(".") || entry === "node_modules") return [];
-    const entryPath = path59.join(dir, entry);
+    const entryPath = path60.join(dir, entry);
     let stats;
     try {
       stats = statSync6(entryPath);
@@ -9110,7 +9204,7 @@ function stylesheetFiles(dir) {
       return [];
     }
     if (stats.isDirectory()) return stylesheetFiles(entryPath);
-    return path59.extname(entry) === ".css" ? [entryPath] : [];
+    return path60.extname(entry) === ".css" ? [entryPath] : [];
   });
 }
 function packageNameOf(specifier) {
@@ -9121,24 +9215,24 @@ function packageNameOf(specifier) {
 function resolvePackageStylesheet(fromFile, specifier) {
   const packageName = packageNameOf(specifier);
   if (!packageName || packageName === "tailwindcss") return void 0;
-  let directory = path59.dirname(fromFile);
-  while (directory !== path59.dirname(directory)) {
-    const packageRoot = path59.join(directory, "node_modules", packageName);
-    const manifestPath = path59.join(packageRoot, "package.json");
+  let directory = path60.dirname(fromFile);
+  while (directory !== path60.dirname(directory)) {
+    const packageRoot = path60.join(directory, "node_modules", packageName);
+    const manifestPath = path60.join(packageRoot, "package.json");
     if (existsSync6(manifestPath)) {
       try {
-        const manifest = readFileSync10(manifestPath, "utf8");
+        const manifest = readFileSync11(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 = path59.resolve(packageRoot, target);
+        const resolved = path60.resolve(packageRoot, target);
         return existsSync6(resolved) ? resolved : void 0;
       } catch {
         return void 0;
       }
     }
-    directory = path59.dirname(directory);
+    directory = path60.dirname(directory);
   }
   return void 0;
 }
@@ -9147,7 +9241,7 @@ function inventoryStylesheetFiles(projectFiles) {
   for (const file of projectFiles) {
     let css2;
     try {
-      css2 = readFileSync10(file, "utf8");
+      css2 = readFileSync11(file, "utf8");
     } catch {
       continue;
     }
@@ -9213,7 +9307,7 @@ function readInventory(files) {
   for (const file of files) {
     let css2;
     try {
-      css2 = readFileSync10(file, "utf8");
+      css2 = readFileSync11(file, "utf8");
     } catch {
       continue;
     }
@@ -9389,7 +9483,7 @@ var unknownUtilityRule = {
 };
 
 // eslint/rules/util-file-name.ts
-import path60 from "path";
+import path61 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();
 }
@@ -9402,7 +9496,7 @@ var utilFileNameRule = {
     }
   },
   create(context) {
-    const filename = path60.resolve(context.filename);
+    const filename = path61.resolve(context.filename);
     const segments = filename.replace(/\\/g, "/").split("/");
     if (!segments.includes("utils")) return {};
     let module;
@@ -9416,13 +9510,13 @@ var utilFileNameRule = {
     const functionName = functions[0]?.name;
     if (!functionName) return {};
     const expected = toKebabCase2(functionName);
-    const actual = path60.basename(filename, path60.extname(filename));
+    const actual = path61.basename(filename, path61.extname(filename));
     if (!expected || actual === expected) return {};
     return {
       Program(node) {
         context.report({
           node,
-          message: `A utility file exporting ${functionName} must be named ${expected}.${path60.extname(filename).slice(1)}.`
+          message: `A utility file exporting ${functionName} must be named ${expected}.${path61.extname(filename).slice(1)}.`
         });
       }
     };
@@ -9430,7 +9524,7 @@ var utilFileNameRule = {
 };
 
 // eslint/rules/value-extraction.ts
-import path61 from "path";
+import path62 from "path";
 var valueExtractionRule = {
   meta: {
     schema: [],
@@ -9441,7 +9535,7 @@ var valueExtractionRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path61.resolve(context.filename);
+    const file = path62.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length === 0 || segments[0] !== "app") return {};
     const index = getProjectIndex(sourceRoot);
@@ -9462,8 +9556,8 @@ var valueExtractionRule = {
 };
 
 // eslint/rules/vulyk/tracked-docs.ts
-import { existsSync as existsSync7, readFileSync as readFileSync11 } from "fs";
-import path62 from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync12 } from "fs";
+import path63 from "path";
 var PASIKA_REPO = "Bredansky/pasika";
 var BASE_REQUIRED_TRACKED_DOCS = [
   { name: "documentation-guide", path: "docs/documentation-guide" },
@@ -9496,8 +9590,8 @@ var trackedDocsRule = {
         if (!context.filename.endsWith("package.json")) return;
         const root = node.body;
         if (root.type !== "Object") return;
-        const projectRoot = path62.dirname(path62.resolve(context.filename));
-        const configPath = path62.join(projectRoot, "vulyk.config.ts");
+        const projectRoot = path63.dirname(path63.resolve(context.filename));
+        const configPath = path63.join(projectRoot, "vulyk.config.ts");
         if (!existsSync7(configPath)) {
           context.report({
             node,
@@ -9505,7 +9599,7 @@ var trackedDocsRule = {
           });
           return;
         }
-        const config = readFileSync11(configPath, "utf8");
+        const config = readFileSync12(configPath, "utf8");
         if (!config.includes(PASIKA_REPO)) {
           context.report({
             node,
@@ -9522,7 +9616,7 @@ var trackedDocsRule = {
             });
           }
         }
-        const agentsPath = path62.join(projectRoot, "AGENTS.md");
+        const agentsPath = path63.join(projectRoot, "AGENTS.md");
         if (!existsSync7(agentsPath)) {
           context.report({
             node,
@@ -9622,7 +9716,7 @@ var withResponseHelperRule = {
 
 // eslint/rules/zirka-baseline.ts
 import fs7 from "fs";
-import path63 from "path";
+import path64 from "path";
 var ESLINT_CONFIG = /^eslint\.config\.(?:ts|mts|cts|js|mjs|cjs)$/;
 var PRETTIER_CONFIGS = [
   "prettier.config.mjs",
@@ -9641,10 +9735,10 @@ var zirkaBaselineRule = {
     }
   },
   create(context) {
-    const filename = path63.resolve(context.filename);
-    const basename = path63.basename(filename);
+    const filename = path64.resolve(context.filename);
+    const basename = path64.basename(filename);
     if (!ESLINT_CONFIG.test(basename)) return {};
-    const projectRoot = path63.dirname(filename);
+    const projectRoot = path64.dirname(filename);
     const report3 = (message) => {
       context.report({
         node: context.sourceCode.ast,
@@ -9659,7 +9753,7 @@ var zirkaBaselineRule = {
             'ESLint config must take its configuration from zirka (import { styleguide } from "zirka") instead of restating rules locally.'
           );
         }
-        const tsconfigPath = path63.join(projectRoot, "tsconfig.json");
+        const tsconfigPath = path64.join(projectRoot, "tsconfig.json");
         if (!fs7.existsSync(tsconfigPath)) {
           report3('No tsconfig.json found. Create one extending the zirka TypeScript base config ("zirka/typescript").');
         } else {
@@ -9677,13 +9771,13 @@ var zirkaBaselineRule = {
             report3('tsconfig.json must extend the zirka TypeScript base config ("zirka/typescript").');
           }
         }
-        const prettierConfigFile = PRETTIER_CONFIGS.find((name) => fs7.existsSync(path63.join(projectRoot, name)));
+        const prettierConfigFile = PRETTIER_CONFIGS.find((name) => fs7.existsSync(path64.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(path63.join(projectRoot, prettierConfigFile), "utf8");
+          const content = fs7.readFileSync(path64.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."
@@ -9829,14 +9923,14 @@ var zodSchemaValidationRule = {
 };
 
 // eslint/ts-alignment.ts
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync13 } 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(readFileSync12(packagePath, "utf8"));
+    const parsed = JSON.parse(readFileSync13(packagePath, "utf8"));
     if (typeof parsed !== "object" || parsed === null || !("version" in parsed)) return null;
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pasika",
-  "version": "0.10.89",
+  "version": "0.10.91",
   "description": "Reusable agent setup package",
   "repository": {
     "type": "git",