pasika 0.10.73 → 0.10.75

package/dist/eslint/pasika/index.js

@@ -38,8 +38,8 @@ function memberPropertyName(node) {
   }
   return void 0;
 }
-function importedContractMember(expression, propertyName4, imports) {
-  if (expression?.type !== "MemberExpression" || memberPropertyName(expression) !== propertyName4 || expression.object.type !== "Identifier" || !imports.has(expression.object.name)) {
+function importedContractMember(expression, propertyName5, imports) {
+  if (expression?.type !== "MemberExpression" || memberPropertyName(expression) !== propertyName5 || expression.object.type !== "Identifier" || !imports.has(expression.object.name)) {
     return void 0;
   }
   return expression.object.name;
@@ -5023,10 +5023,309 @@ var noMixedConcernsRule = {
 };
 
 // eslint/rules/no-redundant-alias.ts
+import path40 from "path";
+
+// eslint/rules/contract-ownership.ts
 import path39 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";
+}
+function isEstreeTsNodeMap(value) {
+  return typeof value === "object" && value !== null && "get" in value && typeof value.get === "function";
+}
+function typedParserServices(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  if (!("program" in value && "esTreeNodeToTSNodeMap" in value)) return void 0;
+  if (!isTsProgram(value.program) || !isEstreeTsNodeMap(value.esTreeNodeToTSNodeMap)) return void 0;
+  return { program: value.program, esTreeNodeToTSNodeMap: value.esTreeNodeToTSNodeMap };
+}
+var ownershipIndexCache = /* @__PURE__ */ new WeakMap();
+function normalizePath(value) {
+  return value.replaceAll("\\", "/").toLowerCase();
+}
+function isWithin(root, file) {
+  const relative = path39.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path39.isAbsolute(relative);
+}
+function mergeOwnership(values) {
+  if (values.length === 0 || values.includes("unknown")) return "unknown";
+  const known = new Set(values);
+  if (known.size === 1) return [...known][0] ?? "unknown";
+  return "unknown";
+}
+function endpointOwnership(pathValue) {
+  if (pathValue === void 0) return "unknown";
+  if (/^https?:\/\//u.test(pathValue)) return "third-party";
+  if (pathValue.startsWith("/")) return "first-party";
+  return "unknown";
+}
+function resolvedSymbol(checker, symbol) {
+  return symbol.flags === ts7.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+}
+function propertyName3(node) {
+  if (!node) return void 0;
+  if (ts7.isIdentifier(node) || ts7.isStringLiteral(node) || ts7.isNumericLiteral(node)) return node.text;
+  return void 0;
+}
+var ContractOwnershipIndex = class {
+  constructor(program, cwd) {
+    this.program = program;
+    this.cwd = cwd;
+    this.checker = program.getTypeChecker();
+    this.indexApiContracts();
+  }
+  program;
+  cwd;
+  checker;
+  schemaNodeOwnership = /* @__PURE__ */ new Map();
+  sourceMember(node) {
+    const symbol = this.checker.getSymbolAtLocation(node) ?? this.memberNameSymbol(node);
+    const declarations = this.symbolDeclarations(symbol);
+    if (this.isZodSchemaValue(node)) {
+      const typeDeclarations2 = this.typeDeclarations(this.checker.getTypeAtLocation(node));
+      const ownership = this.declarationsOwnership(declarations.length > 0 ? declarations : typeDeclarations2);
+      return { kind: "non-contract", ownership };
+    }
+    if (declarations.length > 0) return this.endpointFromDeclarations(declarations);
+    let object;
+    if (ts7.isPropertyAccessExpression(node) || ts7.isElementAccessExpression(node)) object = node.expression;
+    if (!object) return { kind: "missing", ownership: "unknown" };
+    const type = this.checker.getTypeAtLocation(object);
+    const typeDeclarations = this.typeDeclarations(type);
+    if (typeDeclarations.length === 0) return { kind: "missing", ownership: "unknown" };
+    return this.endpointFromDeclarations(typeDeclarations);
+  }
+  targetProperty(node, name) {
+    if (!ts7.isPropertyAssignment(node) && !ts7.isShorthandPropertyAssignment(node)) {
+      return { kind: "missing", ownership: "unknown" };
+    }
+    const object = node.parent;
+    if (!ts7.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);
+    if (declarations.length === 0) return { kind: "missing", ownership: "unknown" };
+    return this.endpointFromDeclarations(declarations);
+  }
+  memberNameSymbol(node) {
+    if (ts7.isPropertyAccessExpression(node)) return this.checker.getSymbolAtLocation(node.name);
+    if (ts7.isElementAccessExpression(node)) return this.checker.getSymbolAtLocation(node.argumentExpression);
+    return void 0;
+  }
+  propertyDeclarations(type, name) {
+    const types = type.isUnionOrIntersection() ? type.types : [type];
+    const declarations = [];
+    for (const item of types) {
+      const symbol = this.checker.getPropertyOfType(item, name);
+      if (symbol?.declarations) declarations.push(...symbol.declarations);
+    }
+    return declarations;
+  }
+  symbolDeclarations(symbol) {
+    if (!symbol) return [];
+    return [...resolvedSymbol(this.checker, symbol).declarations ?? []];
+  }
+  typeDeclarations(type) {
+    const declarations = [...type.aliasSymbol?.declarations ?? [], ...type.getSymbol()?.declarations ?? []];
+    if (type.isUnionOrIntersection()) {
+      for (const item of type.types) {
+        declarations.push(...item.aliasSymbol?.declarations ?? [], ...item.getSymbol()?.declarations ?? []);
+      }
+    }
+    return declarations;
+  }
+  endpointFromDeclarations(declarations) {
+    const ownership = this.declarationsOwnership(declarations);
+    if (declarations.some((declaration) => this.isDataContractField(declaration))) {
+      return { kind: "data-contract", ownership };
+    }
+    if (declarations.some((declaration) => ts7.isPropertySignature(declaration) || ts7.isPropertyDeclaration(declaration))) {
+      return { kind: "typed-local", ownership };
+    }
+    return { kind: "non-contract", ownership };
+  }
+  isDataContractField(declaration) {
+    if (this.isZodSchemaField(declaration)) return true;
+    if (!ts7.isPropertySignature(declaration) && !ts7.isPropertyDeclaration(declaration)) return false;
+    const fileName = normalizePath(declaration.getSourceFile().fileName);
+    return /(?:^|\/)database(?:[-.]generated)?\.ts$/u.test(fileName);
+  }
+  isZodSchemaValue(node) {
+    const type = this.checker.getTypeAtLocation(node);
+    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 (!ts7.isPropertyAssignment(declaration)) return false;
+    let current = declaration.parent;
+    while (!ts7.isSourceFile(current)) {
+      if (ts7.isVariableDeclaration(current) && ts7.isIdentifier(current.name) && current.name.text.endsWith("Schema")) {
+        return true;
+      }
+      current = current.parent;
+    }
+    return false;
+  }
+  declarationsOwnership(declarations) {
+    if (declarations.length === 0) return "unknown";
+    return mergeOwnership(declarations.map((declaration) => this.declarationOwnership(declaration)));
+  }
+  declarationOwnership(declaration) {
+    const schemaOwnership = this.schemaOwnership(declaration);
+    if (schemaOwnership !== void 0) return schemaOwnership;
+    const fileName = declaration.getSourceFile().fileName;
+    const normalized = normalizePath(fileName);
+    if (/\/typescript\/lib\/lib\.[^/]+\.d\.ts$/u.test(normalized)) return "platform";
+    if (normalized.includes("/node_modules/")) return "third-party";
+    if (isWithin(this.cwd, path39.resolve(fileName))) return "first-party";
+    return "unknown";
+  }
+  schemaOwnership(declaration) {
+    let current = declaration;
+    while (!ts7.isSourceFile(current)) {
+      const ownership = this.schemaNodeOwnership.get(current);
+      if (ownership !== void 0) return ownership;
+      current = current.parent;
+    }
+    return void 0;
+  }
+  indexApiContracts() {
+    for (const sourceFile of this.program.getSourceFiles()) {
+      if (sourceFile.isDeclarationFile || !isWithin(this.cwd, path39.resolve(sourceFile.fileName))) continue;
+      const visit = (node) => {
+        if (ts7.isCallExpression(node) && this.isDefineApiContractCall(node)) this.indexApiContractCall(node);
+        ts7.forEachChild(node, visit);
+      };
+      visit(sourceFile);
+    }
+  }
+  isDefineApiContractCall(node) {
+    if (ts7.isIdentifier(node.expression)) return node.expression.text === "defineApiContract";
+    return ts7.isPropertyAccessExpression(node.expression) && node.expression.name.text === "defineApiContract";
+  }
+  indexApiContractCall(node) {
+    const argument = node.arguments[0];
+    if (!argument || !ts7.isObjectLiteralExpression(argument)) return;
+    let pathExpression;
+    const schemaExpressions = [];
+    for (const property of argument.properties) {
+      if (ts7.isPropertyAssignment(property)) {
+        const name = propertyName3(property.name);
+        if (name === "path") pathExpression = property.initializer;
+        if (name === "requestSchema" || name === "responseSchema") schemaExpressions.push(property.initializer);
+        continue;
+      }
+      if (ts7.isShorthandPropertyAssignment(property)) {
+        const name = property.name.text;
+        if (name === "path") pathExpression = property.name;
+        if (name === "requestSchema" || name === "responseSchema") schemaExpressions.push(property.name);
+      }
+    }
+    const ownership = endpointOwnership(this.staticString(pathExpression, /* @__PURE__ */ new Set()));
+    if (ownership === "first-party") return;
+    for (const expression of schemaExpressions) {
+      this.markSchemaExpression(expression, ownership, /* @__PURE__ */ new Set());
+    }
+  }
+  staticString(node, seen) {
+    if (!node) return void 0;
+    if (ts7.isStringLiteralLike(node)) return node.text;
+    if (ts7.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 (ts7.isVariableDeclaration(declaration) && declaration.initializer) {
+          const value = this.staticString(declaration.initializer, seen);
+          if (value !== void 0) return value;
+        }
+      }
+    }
+    return void 0;
+  }
+  markSchemaExpression(node, ownership, seen) {
+    this.setSchemaOwnership(node, ownership);
+    const symbol = this.schemaReferenceSymbol(node);
+    if (symbol && !seen.has(symbol)) {
+      seen.add(symbol);
+      const resolved = resolvedSymbol(this.checker, symbol);
+      for (const declaration of resolved.declarations ?? []) {
+        this.followSchemaDeclaration(declaration, ownership, seen);
+      }
+    }
+    ts7.forEachChild(node, (child) => {
+      this.markSchemaExpression(child, ownership, seen);
+    });
+  }
+  schemaReferenceSymbol(node) {
+    if (ts7.isIdentifier(node)) {
+      if (!node.text.endsWith("Schema")) return void 0;
+      return this.checker.getSymbolAtLocation(node);
+    }
+    if (ts7.isPropertyAccessExpression(node)) {
+      if (!node.name.text.endsWith("Schema")) return void 0;
+      return this.checker.getSymbolAtLocation(node.name);
+    }
+    if (ts7.isElementAccessExpression(node) && ts7.isStringLiteralLike(node.argumentExpression)) {
+      if (!node.argumentExpression.text.endsWith("Schema")) return void 0;
+      return this.checker.getSymbolAtLocation(node.argumentExpression);
+    }
+    return void 0;
+  }
+  followSchemaDeclaration(declaration, ownership, seen) {
+    this.setSchemaOwnership(declaration, ownership);
+    if (ts7.isVariableDeclaration(declaration) && declaration.initializer) {
+      this.markSchemaExpression(declaration.initializer, ownership, seen);
+      return;
+    }
+    if (ts7.isPropertyAssignment(declaration)) {
+      this.markSchemaExpression(declaration.initializer, ownership, seen);
+      return;
+    }
+    if (ts7.isShorthandPropertyAssignment(declaration)) {
+      const valueSymbol = this.checker.getShorthandAssignmentValueSymbol(declaration);
+      if (!valueSymbol || seen.has(valueSymbol)) return;
+      seen.add(valueSymbol);
+      for (const valueDeclaration of valueSymbol.declarations ?? []) {
+        this.followSchemaDeclaration(valueDeclaration, ownership, seen);
+      }
+    }
+  }
+  setSchemaOwnership(node, ownership) {
+    const previous = this.schemaNodeOwnership.get(node);
+    if (previous === void 0) {
+      this.schemaNodeOwnership.set(node, ownership);
+      return;
+    }
+    if (previous !== ownership) this.schemaNodeOwnership.set(node, "unknown");
+  }
+};
+function contractOwnershipResolver(context) {
+  const services = typedParserServices(context.sourceCode.parserServices);
+  if (!services) return void 0;
+  const { program, esTreeNodeToTSNodeMap: nodeMap } = services;
+  let index = ownershipIndexCache.get(program);
+  if (!index) {
+    index = new ContractOwnershipIndex(program, context.cwd);
+    ownershipIndexCache.set(program, index);
+  }
+  return {
+    sourceMember(node) {
+      const tsNode = nodeMap.get(node);
+      return tsNode ? index.sourceMember(tsNode) : { kind: "missing", ownership: "unknown" };
+    },
+    targetProperty(node, name) {
+      const tsNode = nodeMap.get(node);
+      return tsNode ? index.targetProperty(tsNode, name) : { kind: "missing", ownership: "unknown" };
+    }
+  };
+}
+
+// eslint/rules/no-redundant-alias.ts
 var DOC4 = "See docs/next-codebase-guide/rules/redundant-aliases-rule.md";
 var VALUE_SENTINELS = /* @__PURE__ */ new Set(["undefined", "NaN", "Infinity"]);
 var HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+var FRAMEWORK_MAPPING_KEYS = /* @__PURE__ */ new Set(["default", "apiRoutePath"]);
 var PRIMITIVE_TYPE_NAMES = {
   TSBigIntKeyword: "bigint",
   TSBooleanKeyword: "boolean",
@@ -5061,9 +5360,43 @@ function aliasMessage(alias, source) {
 function bindingAliasMessage(alias, source) {
   return `"${alias}" renames "${source}" while creating a binding. Keep the original name and map it only at the object boundary. ${DOC4}`;
 }
-function objectPropertyMessage(propertyName4, source) {
-  if (source === propertyName4) return `Use property shorthand for "${propertyName4}". ${DOC4}`;
-  return `"${propertyName4}" maps the local "${source}". Keep the local name or map directly from its source object instead. ${DOC4}`;
+function objectPropertyMessage(propertyName5, source) {
+  if (source === propertyName5) return `Use property shorthand for "${propertyName5}". ${DOC4}`;
+  return `"${propertyName5}" maps the local "${source}". Keep the local name or map directly from its source object instead. ${DOC4}`;
+}
+function normalizePropertyName(name) {
+  return name.replace(/[-_\s]/g, "").toLowerCase();
+}
+function memberPropertyName2(node) {
+  if (node.type !== "MemberExpression") return void 0;
+  if (!node.computed && node.property.type === "Identifier") return node.property.name;
+  if (node.computed && node.property.type === "Literal" && typeof node.property.value === "string") {
+    return node.property.value;
+  }
+  return void 0;
+}
+function isNamedMemberValue(propertyName5) {
+  return /^[A-Z]/.test(propertyName5);
+}
+function isQualifiedSourceField(propertyName5, sourceMember, sourcePropertyName) {
+  if (sourceMember.type !== "MemberExpression" || sourceMember.object.type !== "Identifier") return false;
+  return normalizePropertyName(propertyName5) === normalizePropertyName(`${sourceMember.object.name}${sourcePropertyName}`);
+}
+function isInsideSchemaDeclaration(node) {
+  let current = node;
+  while (current.type !== "Program") {
+    if (current.type === "VariableDeclarator" && current.id.type === "Identifier" && current.id.name.endsWith("Schema")) {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function semanticMappingMessage(propertyName5, sourcePropertyName) {
+  return `"${propertyName5}" maps from "${sourcePropertyName}" between first-party contracts. Use one canonical field name across the contracts. ${DOC4}`;
+}
+function unknownContractOwnershipMessage(propertyName5, sourcePropertyName) {
+  return `Cannot determine contract ownership for mapping "${propertyName5}" from "${sourcePropertyName}". Define or propagate a concrete contract, make the boundary schema explicit, or connect a mirrored external schema to its defineApiContract. ${DOC4}`;
 }
 var noRedundantAliasRule = {
   meta: {
@@ -5071,10 +5404,11 @@ var noRedundantAliasRule = {
     type: "problem",
     fixable: "code",
     docs: {
-      description: "Disallow renamed bindings while allowing explicit cross-object property mappings."
+      description: "Disallow redundant aliases and inconsistent object-to-object mappings."
     }
   },
   create(context) {
+    const ownershipResolver = contractOwnershipResolver(context);
     return {
       VariableDeclarator(node) {
         if (node.id.type !== "Identifier" || !node.init) return;
@@ -5082,7 +5416,7 @@ var noRedundantAliasRule = {
         if (declaration.type !== "VariableDeclaration" || declaration.kind !== "const") return;
         if (node.init.type === "Identifier") {
           const exported = declaration.parent.type === "ExportNamedDeclaration";
-          const frameworkRouteAlias = path39.basename(context.filename) === "route.ts" && exported && HTTP_METHODS.has(node.id.name);
+          const frameworkRouteAlias = path40.basename(context.filename) === "route.ts" && exported && HTTP_METHODS.has(node.id.name);
           if (frameworkRouteAlias || VALUE_SENTINELS.has(node.init.name)) return;
           context.report({
             node,
@@ -5091,14 +5425,14 @@ var noRedundantAliasRule = {
           return;
         }
         if (node.init.type !== "MemberExpression") return;
-        let propertyName4;
+        let propertyName5;
         if (!node.init.computed && node.init.property.type === "Identifier") {
-          propertyName4 = node.init.property.name;
+          propertyName5 = node.init.property.name;
         }
         if (node.init.computed && node.init.property.type === "Literal" && typeof node.init.property.value === "string") {
-          propertyName4 = node.init.property.value;
+          propertyName5 = node.init.property.value;
         }
-        if (propertyName4 === void 0 || propertyName4 === node.id.name) return;
+        if (propertyName5 === void 0 || propertyName5 === node.id.name) return;
         context.report({
           node,
           message: bindingAliasMessage(node.id.name, context.sourceCode.getText(node.init))
@@ -5106,34 +5440,69 @@ var noRedundantAliasRule = {
       },
       Property(node) {
         if (node.computed) return;
-        let propertyName4;
-        if (node.key.type === "Identifier") propertyName4 = node.key.name;
+        let propertyName5;
+        if (node.key.type === "Identifier") propertyName5 = node.key.name;
         if (node.key.type === "Literal" && typeof node.key.value === "string") {
-          propertyName4 = node.key.value;
+          propertyName5 = node.key.value;
         }
-        if (propertyName4 === void 0) return;
+        if (propertyName5 === void 0) return;
         if (node.parent.type === "ObjectPattern") {
           let binding;
           if (node.value.type === "Identifier") binding = node.value;
           if (node.value.type === "AssignmentPattern" && node.value.left.type === "Identifier") {
             binding = node.value.left;
           }
-          if (!binding || binding.name === propertyName4) return;
+          if (!binding || binding.name === propertyName5) return;
           context.report({
             node,
-            message: bindingAliasMessage(binding.name, propertyName4)
+            message: bindingAliasMessage(binding.name, propertyName5)
           });
           return;
         }
-        if (node.parent.type !== "ObjectExpression" || node.value.type !== "Identifier") return;
-        if (node.shorthand) return;
-        const source = node.value.name;
+        if (node.parent.type !== "ObjectExpression") return;
+        if (isInsideSchemaDeclaration(node)) return;
+        if (node.value.type === "Identifier") {
+          if (node.shorthand) return;
+          const source = node.value.name;
+          context.report({
+            node,
+            message: objectPropertyMessage(propertyName5, source),
+            fix(fixer) {
+              return propertyName5 === source ? fixer.replaceText(node, propertyName5) : null;
+            }
+          });
+          return;
+        }
+        if (node.value.type !== "MemberExpression") return;
+        const sourcePropertyName = memberPropertyName2(node.value);
+        if (sourcePropertyName === void 0) return;
+        if (normalizePropertyName(propertyName5) === normalizePropertyName(sourcePropertyName)) return;
+        if (FRAMEWORK_MAPPING_KEYS.has(propertyName5) || isNamedMemberValue(sourcePropertyName)) return;
+        if (isQualifiedSourceField(propertyName5, node.value, sourcePropertyName)) return;
+        if (!ownershipResolver) return;
+        const sourceResolution = ownershipResolver.sourceMember(node.value);
+        const targetResolution = ownershipResolver.targetProperty(node, propertyName5);
+        if (sourceResolution.kind === "non-contract" || targetResolution.kind === "non-contract") return;
+        if ((sourceResolution.ownership === "third-party" || sourceResolution.ownership === "platform") && targetResolution.kind !== "missing") {
+          return;
+        }
+        if ((targetResolution.ownership === "third-party" || targetResolution.ownership === "platform") && sourceResolution.kind !== "missing") {
+          return;
+        }
+        const hasDataContract = sourceResolution.kind === "data-contract" || targetResolution.kind === "data-contract";
+        if (!hasDataContract) return;
+        if (sourceResolution.kind === "missing" || targetResolution.kind === "missing" || sourceResolution.ownership === "unknown" || targetResolution.ownership === "unknown") {
+          context.report({
+            node,
+            message: unknownContractOwnershipMessage(propertyName5, sourcePropertyName)
+          });
+          return;
+        }
+        if (sourceResolution.kind !== "data-contract") return;
+        if (sourceResolution.ownership !== "first-party" || targetResolution.ownership !== "first-party") return;
         context.report({
           node,
-          message: objectPropertyMessage(propertyName4, source),
-          fix(fixer) {
-            return propertyName4 === source ? fixer.replaceText(node, propertyName4) : null;
-          }
+          message: semanticMappingMessage(propertyName5, sourcePropertyName)
         });
       },
       TSTypeAliasDeclaration(node) {
@@ -5160,7 +5529,7 @@ var noRedundantAliasRule = {
           const source = specifier.local.name;
           const alias = specifier.exported.name;
           if (source === alias) continue;
-          const frameworkRouteAlias = path39.basename(context.filename) === "route.ts" && HTTP_METHODS.has(alias);
+          const frameworkRouteAlias = path40.basename(context.filename) === "route.ts" && HTTP_METHODS.has(alias);
           if (frameworkRouteAlias) continue;
           context.report({
             node: specifier,
@@ -5185,7 +5554,7 @@ var noRedundantAliasRule = {
 };
 
 // eslint/rules/no-util-barrel.ts
-import path40 from "path";
+import path41 from "path";
 var noUtilBarrelRule = {
   meta: {
     schema: [],
@@ -5195,7 +5564,7 @@ var noUtilBarrelRule = {
     }
   },
   create(context) {
-    const filename = path40.resolve(context.filename);
+    const filename = path41.resolve(context.filename);
     const sourceRoot = sourceRootOf3(context, filename);
     return {
       Program(node) {
@@ -5204,7 +5573,7 @@ var noUtilBarrelRule = {
           if (!target) continue;
           const segments = target.replace(/\\/g, "/").split("/");
           const utilsIndex = segments.lastIndexOf("utils");
-          if (utilsIndex < 0 || !path40.basename(target).startsWith("index.")) continue;
+          if (utilsIndex < 0 || !path41.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`
@@ -5224,10 +5593,10 @@ function importSpecifiers2(source) {
   return specifiers;
 }
 function sourceRootOf3(context, filename) {
-  const marker = `${path40.sep}src${path40.sep}`;
+  const marker = `${path41.sep}src${path41.sep}`;
   const srcIndex = filename.lastIndexOf(marker);
   if (srcIndex >= 0) return filename.slice(0, srcIndex + marker.length - 1);
-  return path40.resolve(context.cwd ?? process.cwd(), "src");
+  return path41.resolve(context.cwd ?? process.cwd(), "src");
 }
 
 // eslint/rules/package-json/exact-version.ts
@@ -5446,7 +5815,7 @@ var nextjsStackRule = {
 
 // eslint/rules/package-json/vitest-coverage.ts
 import { existsSync as existsSync5, readFileSync as readFileSync8 } from "fs";
-import path41 from "path";
+import path42 from "path";
 function memberName5(member) {
   return member.name.type === "String" ? member.name.value : member.name.name;
 }
@@ -5516,7 +5885,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(path41.join(context.cwd, name)));
+        const configName = VITEST_CONFIG_NAMES.find((name) => existsSync5(path42.join(context.cwd, name)));
         if (!configName) {
           context.report({
             node,
@@ -5524,7 +5893,7 @@ var vitestCoverageRule = {
           });
           return;
         }
-        const content = readFileSync8(path41.join(context.cwd, configName), "utf8");
+        const content = readFileSync8(path42.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}.` });
@@ -5570,7 +5939,7 @@ var nextjsPackageJsonRules = {
 };
 
 // eslint/rules/prefer-enum.ts
-import path42 from "path";
+import path43 from "path";
 function isConstAssertion(node) {
   const typeAnnotation = node.typeAnnotation;
   return typeAnnotation?.type === "TSTypeReference" && typeAnnotation.typeName?.type === "Identifier" && typeAnnotation.typeName.name === "const";
@@ -5592,7 +5961,7 @@ function isZodCall(node, method) {
   const { callee } = node;
   return callee?.type === "MemberExpression" && !callee.computed && callee.object.type === "Identifier" && callee.object.name === "z" && callee.property.type === "Identifier" && callee.property.name === method;
 }
-function propertyName3(property) {
+function propertyName4(property) {
   if (property.computed) return void 0;
   if (property.key.type === "Identifier") return property.key.name;
   if (property.key.type === "Literal" && typeof property.key.value === "string") return property.key.value;
@@ -5603,7 +5972,7 @@ function rawZodDiscriminantLiteral(schemaCall, discriminator) {
   const shape = schemaCall.arguments[0];
   if (shape?.type !== "ObjectExpression") return void 0;
   for (const property of shape.properties) {
-    if (property.type !== "Property" || propertyName3(property) !== discriminator) continue;
+    if (property.type !== "Property" || propertyName4(property) !== discriminator) continue;
     if (property.value.type !== "CallExpression" || !isZodCall(property.value, "literal")) return void 0;
     const literal = property.value.arguments[0];
     if (literal?.type === "Literal" && (typeof literal.value === "string" || typeof literal.value === "number")) {
@@ -5622,9 +5991,9 @@ var preferEnumRule = {
     }
   },
   create(context) {
-    const filename = path42.resolve(context.filename);
+    const filename = path43.resolve(context.filename);
     const sourceRoot = sourceRootOf(context);
-    if (!filename.startsWith(sourceRoot + path42.sep)) return {};
+    if (!filename.startsWith(sourceRoot + path43.sep)) return {};
     const objectSchemas = /* @__PURE__ */ new Map();
     const discriminatedUnions = [];
     const reportedDiscriminants = /* @__PURE__ */ new Set();
@@ -5705,24 +6074,80 @@ function directPropertyBinding(context, declarator) {
   const member = declarator.init;
   if (member.computed || member.optional || member.property.type !== "Identifier") return void 0;
   if (context.sourceCode.getCommentsInside(declarator).length > 0) return void 0;
-  const propertyName4 = member.property.name;
+  const propertyName5 = member.property.name;
   const localName = declarator.id.name;
-  if (propertyName4 !== localName) return void 0;
+  if (propertyName5 !== localName) return void 0;
   const source = member.object;
   const sourceText = context.sourceCode.getText(source);
   return {
     declarator,
     member,
-    propertyName: propertyName4,
+    propertyName: propertyName5,
     localName,
     source,
     sourceText,
-    bindingText: propertyName4
+    bindingText: propertyName5
   };
 }
 function canGroupSource(source) {
   return source.type === "Identifier" || source.type === "ThisExpression";
 }
+function isStableObjectSource(source) {
+  if (source.type === "Identifier" || source.type === "ThisExpression") return true;
+  if (source.type !== "MemberExpression") return false;
+  if (source.computed || source.optional || source.property.type !== "Identifier") return false;
+  return isStableObjectSource(source.object);
+}
+function objectUsage(scope, sourceText) {
+  let usage = scope.objects.get(sourceText);
+  if (!usage) {
+    usage = { propertyNames: /* @__PURE__ */ new Set(), directMembers: /* @__PURE__ */ new Map() };
+    scope.objects.set(sourceText, usage);
+  }
+  return usage;
+}
+function memberIsRead(context, member) {
+  const parent = context.sourceCode.getAncestors(member).at(-1);
+  if (!parent) return true;
+  if (parent.type === "AssignmentExpression" && parent.left === member) return false;
+  if (parent.type === "UpdateExpression" && parent.argument === member) return false;
+  if (parent.type === "UnaryExpression" && parent.operator === "delete" && parent.argument === member) return false;
+  if ((parent.type === "ForInStatement" || parent.type === "ForOfStatement") && parent.left === member) return false;
+  if ((parent.type === "CallExpression" || parent.type === "NewExpression") && parent.callee === member) return false;
+  if (parent.type === "TaggedTemplateExpression" && parent.tag === member) return false;
+  return true;
+}
+function memberIsDirectVariableInitializer(context, member) {
+  const parent = context.sourceCode.getAncestors(member).at(-1);
+  return parent?.type === "VariableDeclarator" && parent.init === member;
+}
+function recordMemberUsage(context, scope, member) {
+  if (!scope || member.computed || member.optional || member.property.type !== "Identifier") return;
+  if (!isStableObjectSource(member.object) || !memberIsRead(context, member)) return;
+  const sourceText = context.sourceCode.getText(member.object);
+  const usage = objectUsage(scope, sourceText);
+  const propertyName5 = member.property.name;
+  usage.propertyNames.add(propertyName5);
+  if (!memberIsDirectVariableInitializer(context, member) && !usage.directMembers.has(propertyName5)) {
+    usage.directMembers.set(propertyName5, member);
+  }
+}
+function recordDestructuringUsage(context, scope, declaration) {
+  if (!scope) return;
+  for (const declarator of declaration.declarations) {
+    if (declarator.id.type !== "ObjectPattern" || !declarator.init || !isStableObjectSource(declarator.init)) continue;
+    const sourceText = context.sourceCode.getText(declarator.init);
+    const usage = objectUsage(scope, sourceText);
+    for (const property of declarator.id.properties) {
+      if (property.type !== "Property" || property.computed || property.key.type !== "Identifier") continue;
+      usage.propertyNames.add(property.key.name);
+    }
+  }
+}
+function scopeUsageMessage(sourceText, propertyNames) {
+  const names = [...propertyNames].map((name) => `"${name}"`).join(", ");
+  return `${names} are read from "${sourceText}" in the same block. Destructure them together in one declaration. ${DOC5}`;
+}
 function whitespaceKeepsStatementsAdjacent(text) {
   if (text.trim() !== "") return false;
   return (text.match(/\n/gu) ?? []).length <= 1;
@@ -5799,13 +6224,13 @@ function groupedDestructuringSelections(context, first) {
     if (!previous || nextNode?.type !== "VariableDeclaration" || nextNode.kind !== first.declaration.kind) break;
     const next = destructuringSelection(context, nextNode);
     if (next?.sourceText !== first.sourceText) break;
-    if (next.propertyNames.some((propertyName4) => seenProperties.has(propertyName4))) break;
+    if (next.propertyNames.some((propertyName5) => seenProperties.has(propertyName5))) break;
     const [, previousEnd] = context.sourceCode.getRange(previous);
     const [nextStart] = context.sourceCode.getRange(nextNode);
     const gap = context.sourceCode.text.slice(previousEnd, nextStart);
     if (!whitespaceKeepsStatementsAdjacent(gap)) break;
     group.push(next);
-    for (const propertyName4 of next.propertyNames) seenProperties.add(propertyName4);
+    for (const propertyName5 of next.propertyNames) seenProperties.add(propertyName5);
   }
   return group;
 }
@@ -5833,13 +6258,45 @@ var preferObjectDestructuringRule = {
     type: "problem",
     fixable: "code",
     docs: {
-      description: "Require locals derived directly from object properties to use object destructuring."
+      description: "Require related object-property reads to use one object destructuring declaration."
     }
   },
   create(context) {
     const grouped = /* @__PURE__ */ new Set();
+    const usageScopes = [];
+    const currentUsageScope = () => usageScopes.at(-1);
+    const enterUsageScope = () => {
+      usageScopes.push({ objects: /* @__PURE__ */ new Map() });
+    };
+    const exitUsageScope = () => {
+      const scope = usageScopes.pop();
+      if (!scope) return;
+      for (const [sourceText, usage] of scope.objects) {
+        if (usage.propertyNames.size < 2 || usage.directMembers.size === 0) continue;
+        const firstDirectMember = usage.directMembers.values().next().value;
+        if (!firstDirectMember) continue;
+        context.report({
+          node: firstDirectMember,
+          message: scopeUsageMessage(sourceText, usage.propertyNames)
+        });
+      }
+    };
     return {
+      Program: enterUsageScope,
+      "Program:exit": exitUsageScope,
+      BlockStatement: enterUsageScope,
+      "BlockStatement:exit": exitUsageScope,
+      FunctionDeclaration: enterUsageScope,
+      "FunctionDeclaration:exit": exitUsageScope,
+      FunctionExpression: enterUsageScope,
+      "FunctionExpression:exit": exitUsageScope,
+      ArrowFunctionExpression: enterUsageScope,
+      "ArrowFunctionExpression:exit": exitUsageScope,
+      MemberExpression(node) {
+        recordMemberUsage(context, currentUsageScope(), node);
+      },
       VariableDeclaration(node) {
+        recordDestructuringUsage(context, currentUsageScope(), node);
         if (grouped.has(node)) return;
         const selection = destructuringSelection(context, node);
         if (selection) {
@@ -5869,7 +6326,7 @@ var preferObjectDestructuringRule = {
         if (bindings.length === 0) return;
         const firstBinding = bindings[0];
         if (!firstBinding) return;
-        const sameSourceBindings = bindings.length > 1 && bindings.length === node.declarations.length && bindings.every(({ sourceText }) => sourceText === firstBinding.sourceText) && new Set(bindings.map(({ propertyName: propertyName4 }) => propertyName4)).size === bindings.length;
+        const sameSourceBindings = bindings.length > 1 && bindings.length === node.declarations.length && bindings.every(({ sourceText }) => sourceText === firstBinding.sourceText) && new Set(bindings.map(({ propertyName: propertyName5 }) => propertyName5)).size === bindings.length;
         if (sameSourceBindings) {
           context.report({
             node,
@@ -5926,7 +6383,7 @@ var preferObjectDestructuringRule = {
 };
 
 // eslint/rules/pure-function-extract.ts
-import path43 from "path";
+import path44 from "path";
 var ROUTE_HANDLER_EXPORT_NAMES = /* @__PURE__ */ new Set([
   "GET",
   "POST",
@@ -5991,12 +6448,12 @@ var pureFunctionExtractRule = {
   },
   create(context) {
     const filename = context.filename;
-    const isRouteFile = path43.basename(filename) === "route.ts";
+    const isRouteFile = path44.basename(filename) === "route.ts";
     const isComponentFile = filename.endsWith(".tsx") || filename.endsWith(".jsx");
     const sourceRoot = sourceRootOf(context);
-    const relative = path43.relative(sourceRoot, filename);
+    const relative = path44.relative(sourceRoot, filename);
     if (relative.startsWith("..")) return {};
-    const segments = relative.split(path43.sep);
+    const segments = relative.split(path44.sep);
     const folders = segments.slice(0, -1);
     const isHookSupportFile = folders.includes("hooks") && /\.(?:[cm]?[jt]s)$/.test(filename);
     if (!isComponentFile && !isRouteFile && !isHookSupportFile) return {};
@@ -6056,16 +6513,16 @@ var pureFunctionExtractRule = {
 };
 
 // eslint/rules/repeated-numeric-value.ts
-import path44 from "path";
+import path45 from "path";
 var ignoredValues = /* @__PURE__ */ new Set([-1, 0, 1]);
 function isNonProductionFile(file, sourceRoot) {
-  const relative = path44.relative(sourceRoot, file);
-  const segments = relative.split(path44.sep);
-  const basename = path44.basename(file);
+  const relative = path45.relative(sourceRoot, file);
+  const segments = relative.split(path45.sep);
+  const basename = path45.basename(file);
   return /\.(?:test|spec|mock)\.[^.]+$/.test(basename) || segments.some((segment) => segment === "__tests__" || segment === "__mocks__" || segment === "mocks");
 }
 function isCanonicalConstantFile(file, sourceRoot) {
-  const segments = path44.relative(sourceRoot, file).split(path44.sep);
+  const segments = path45.relative(sourceRoot, file).split(path45.sep);
   return segments.includes("constants") || segments[0] === "config";
 }
 function groupKey(literal) {
@@ -6081,7 +6538,7 @@ var repeatedNumericValueRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path44.resolve(context.filename);
+    const file = path45.resolve(context.filename);
     if (isNonProductionFile(file, sourceRoot) || isCanonicalConstantFile(file, sourceRoot)) return {};
     const index = getProjectIndex(sourceRoot);
     if (!index) return {};
@@ -6301,7 +6758,7 @@ var repeatedStructureRule = {
 
 // eslint/rules/require-barrel-star-exports.ts
 import fs5 from "fs";
-import path45 from "path";
+import path46 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"];
@@ -6309,9 +6766,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 = path45.dirname(indexFile);
-  const direct = path45.resolve(directory, relative);
-  const candidates = path45.extname(direct) ? [direct] : MODULE_EXTENSIONS3.map((extension) => `${direct}${extension}`);
+  const directory = path46.dirname(indexFile);
+  const direct = path46.resolve(directory, relative);
+  const candidates = path46.extname(direct) ? [direct] : MODULE_EXTENSIONS3.map((extension) => `${direct}${extension}`);
   return candidates.find((candidate) => fs5.existsSync(candidate) && fs5.statSync(candidate).isFile());
 }
 var requireBarrelStarExportsRule = {
@@ -6324,9 +6781,9 @@ var requireBarrelStarExportsRule = {
     fixable: "code"
   },
   create(context) {
-    const filename = path45.resolve(context.filename);
-    if (!INDEX_NAMES.has(path45.basename(filename))) return {};
-    if (!SUPPORT_FOLDERS3.has(path45.basename(path45.dirname(filename)))) return {};
+    const filename = path46.resolve(context.filename);
+    if (!INDEX_NAMES.has(path46.basename(filename))) return {};
+    if (!SUPPORT_FOLDERS3.has(path46.basename(path46.dirname(filename)))) return {};
     return {
       ExportNamedDeclaration(node) {
         const sourceNode = node.source;
@@ -6379,7 +6836,7 @@ var requireBarrelStarExportsRule = {
 };
 
 // eslint/rules/root-support-placement.ts
-import path46 from "path";
+import path47 from "path";
 function isSupportFolder(value) {
   return value === "utils" || value === "types" || value === "schemas" || value === "constants";
 }
@@ -6412,7 +6869,7 @@ var rootSupportPlacementRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path46.resolve(context.filename);
+    const file = path47.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     const folderSegments = folderSegmentsOf(file, sourceRoot);
     const supportFolder = folderSegments[folderSegments.length - 1];
@@ -6452,8 +6909,8 @@ var rootSupportPlacementRule = {
 };
 
 // eslint/rules/route-handler-shape.ts
-import path47 from "path";
-import ts7 from "typescript";
+import path48 from "path";
+import ts8 from "typescript";
 var HTTP_METHODS2 = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
 var REQUIRED_BOUNDARY = "withResponse";
 function isFunctionLike(node) {
@@ -6471,33 +6928,33 @@ function findHandler(node) {
   return void 0;
 }
 function isLoop(node) {
-  return ts7.isForStatement(node) || ts7.isForOfStatement(node) || ts7.isForInStatement(node) || ts7.isWhileStatement(node) || ts7.isDoStatement(node);
+  return ts8.isForStatement(node) || ts8.isForOfStatement(node) || ts8.isForInStatement(node) || ts8.isWhileStatement(node) || ts8.isDoStatement(node);
 }
 function isFunctionBoundary(node) {
-  return ts7.isFunctionExpression(node) || ts7.isArrowFunction(node) || ts7.isFunctionDeclaration(node);
+  return ts8.isFunctionExpression(node) || ts8.isArrowFunction(node) || ts8.isFunctionDeclaration(node);
 }
 function analyzeHandlerBody(body, sourceText) {
   const start = body.range?.[0] ?? 0;
   const end = body.range?.[1] ?? sourceText.length;
-  const sourceFile = ts7.createSourceFile(
+  const sourceFile = ts8.createSourceFile(
     "route.ts",
     sourceText.slice(start, end),
-    ts7.ScriptTarget.Latest,
+    ts8.ScriptTarget.Latest,
     true,
-    ts7.ScriptKind.TS
+    ts8.ScriptKind.TS
   );
   const kinds = /* @__PURE__ */ new Set();
   const calledNames = /* @__PURE__ */ new Set();
   const visit = (node) => {
-    if (ts7.isTryStatement(node)) kinds.add("try");
+    if (ts8.isTryStatement(node)) kinds.add("try");
     if (isLoop(node)) kinds.add("loop");
-    if (ts7.isIfStatement(node)) kinds.add("if");
-    if (ts7.isCallExpression(node) && ts7.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map") {
+    if (ts8.isIfStatement(node)) kinds.add("if");
+    if (ts8.isCallExpression(node) && ts8.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map") {
       kinds.add("map");
     }
-    if (ts7.isCallExpression(node) && ts7.isIdentifier(node.expression)) calledNames.add(node.expression.text);
+    if (ts8.isCallExpression(node) && ts8.isIdentifier(node.expression)) calledNames.add(node.expression.text);
     if (isFunctionBoundary(node)) return;
-    ts7.forEachChild(node, visit);
+    ts8.forEachChild(node, visit);
   };
   visit(sourceFile);
   return { kinds, calledNames };
@@ -6537,7 +6994,7 @@ var routeHandlerShapeRule = {
     }
   },
   create(context) {
-    if (path47.basename(context.filename) !== "route.ts") return {};
+    if (path48.basename(context.filename) !== "route.ts") return {};
     const sourceText = context.sourceCode.text;
     function reportUnwrapped(node, name) {
       context.report({
@@ -6596,7 +7053,7 @@ var routeHandlerShapeRule = {
 };
 
 // eslint/rules/schema-casing.ts
-import path48 from "path";
+import path49 from "path";
 function isCamelCase(name) {
   return /^[a-z][a-zA-Z0-9]*$/.test(name);
 }
@@ -6624,9 +7081,9 @@ var schemaCasingRule = {
     }
   },
   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 {};
     let zodLocalName;
     return {
       ImportDeclaration(node) {
@@ -6658,39 +7115,39 @@ var schemaCasingRule = {
 };
 
 // eslint/rules/sole-state-owner.ts
-import path49 from "path";
-import ts8 from "typescript";
+import path50 from "path";
+import ts9 from "typescript";
 function findStateHooks(node) {
   const hooks = [];
   const visit = (child) => {
-    if (ts8.isCallExpression(child) && ts8.isIdentifier(child.expression) && child.expression.text === "useState") {
-      if (ts8.isVariableDeclaration(child.parent)) {
+    if (ts9.isCallExpression(child) && ts9.isIdentifier(child.expression) && child.expression.text === "useState") {
+      if (ts9.isVariableDeclaration(child.parent)) {
         const { name } = child.parent;
-        if (ts8.isArrayBindingPattern(name) && name.elements.length >= 2) {
+        if (ts9.isArrayBindingPattern(name) && name.elements.length >= 2) {
           const value = name.elements[0];
           const updater = name.elements[1];
-          if (value && updater && ts8.isBindingElement(value) && ts8.isBindingElement(updater)) {
+          if (value && updater && ts9.isBindingElement(value) && ts9.isBindingElement(updater)) {
             const valueName = value.name;
             const updaterName = updater.name;
-            if (ts8.isIdentifier(valueName) && ts8.isIdentifier(updaterName)) {
+            if (ts9.isIdentifier(valueName) && ts9.isIdentifier(updaterName)) {
               hooks.push({ value: valueName.text, updater: updaterName.text });
             }
           }
         }
       }
     }
-    ts8.forEachChild(child, visit);
+    ts9.forEachChild(child, visit);
   };
   visit(node);
   return hooks;
 }
 function isHookUsage(node, hook) {
-  if (ts8.isCallExpression(node) && ts8.isIdentifier(node.expression) && node.expression.text === hook.updater) {
+  if (ts9.isCallExpression(node) && ts9.isIdentifier(node.expression) && node.expression.text === hook.updater) {
     return "updater";
   }
-  if (ts8.isIdentifier(node) && node.text === hook.value) {
+  if (ts9.isIdentifier(node) && node.text === hook.value) {
     const parent = node.parent;
-    if (ts8.isBindingElement(parent) || ts8.isPropertyAccessExpression(parent) || ts8.isShorthandPropertyAssignment(parent)) {
+    if (ts9.isBindingElement(parent) || ts9.isPropertyAccessExpression(parent) || ts9.isShorthandPropertyAssignment(parent)) {
       return void 0;
     }
     return "value";
@@ -6700,16 +7157,16 @@ function isHookUsage(node, hook) {
 function topLevelJsxChildren(initial) {
   if (!initial) return void 0;
   let expression = initial;
-  while (ts8.isParenthesizedExpression(expression)) expression = expression.expression;
-  if (ts8.isJsxFragment(expression)) {
+  while (ts9.isParenthesizedExpression(expression)) expression = expression.expression;
+  if (ts9.isJsxFragment(expression)) {
     const children = expression.children.filter(
-      (c) => !ts8.isJsxText(c) && !ts8.isJsxSpreadAttribute(c)
+      (c) => !ts9.isJsxText(c) && !ts9.isJsxSpreadAttribute(c)
     );
     return { root: expression, children };
   }
-  if (ts8.isJsxElement(expression)) {
+  if (ts9.isJsxElement(expression)) {
     const children = expression.children.filter(
-      (c) => !ts8.isJsxText(c) && !ts8.isJsxSpreadAttribute(c)
+      (c) => !ts9.isJsxText(c) && !ts9.isJsxSpreadAttribute(c)
     );
     return { root: expression, children };
   }
@@ -6723,8 +7180,8 @@ function collectUsesIn(child, hook) {
       positions.push(node);
       count += 1;
     }
-    if (ts8.isFunctionDeclaration(node) || ts8.isClassDeclaration(node)) return;
-    ts8.forEachChild(node, visit);
+    if (ts9.isFunctionDeclaration(node) || ts9.isClassDeclaration(node)) return;
+    ts9.forEachChild(node, visit);
   };
   visit(child);
   return { positions, count };
@@ -6738,7 +7195,7 @@ var soleStateOwnerRule = {
     }
   },
   create(context) {
-    const filename = path49.resolve(context.filename);
+    const filename = path50.resolve(context.filename);
     if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx")) return {};
     const text = context.sourceCode.text;
     const components = parseComponentInfo(text, filename);
@@ -6763,18 +7220,18 @@ var soleStateOwnerRule = {
   }
 };
 function analyzeSoleOwner(declaration, hook) {
-  const body = ts8.isFunctionDeclaration(declaration) ? declaration.body : void 0;
-  if (!body || !ts8.isBlock(body)) return void 0;
+  const body = ts9.isFunctionDeclaration(declaration) ? declaration.body : void 0;
+  if (!body || !ts9.isBlock(body)) return void 0;
   const returns = [];
   const visit = (node) => {
-    if (node !== body && (ts8.isFunctionLike(node) || ts8.isClassLike(node))) return;
-    if (ts8.isReturnStatement(node)) returns.push(node);
-    ts8.forEachChild(node, visit);
+    if (node !== body && (ts9.isFunctionLike(node) || ts9.isClassLike(node))) return;
+    if (ts9.isReturnStatement(node)) returns.push(node);
+    ts9.forEachChild(node, visit);
   };
   visit(body);
   if (returns.length !== 1) return void 0;
   const single = returns[0];
-  if (!single?.expression || !ts8.isExpression(single.expression)) return void 0;
+  if (!single?.expression || !ts9.isExpression(single.expression)) return void 0;
   const returnExpression = single.expression;
   const root = topLevelJsxChildren(returnExpression);
   if (!root || root.children.length === 0) return void 0;
@@ -6797,11 +7254,11 @@ function usesOutsideJsx(declaration, hook, children) {
   let outside = false;
   const visit = (node) => {
     if (outside) return;
-    if (node !== declaration && (ts8.isFunctionDeclaration(node) || ts8.isClassDeclaration(node))) return;
+    if (node !== declaration && (ts9.isFunctionDeclaration(node) || ts9.isClassDeclaration(node))) return;
     if (isHookUsage(node, hook)) {
       let current = node;
       let isInJsxChild = false;
-      while (!ts8.isSourceFile(current)) {
+      while (!ts9.isSourceFile(current)) {
         if (children.includes(current)) {
           isInJsxChild = true;
           break;
@@ -6810,14 +7267,14 @@ function usesOutsideJsx(declaration, hook, children) {
       }
       if (!isInJsxChild) outside = true;
     }
-    ts8.forEachChild(node, visit);
+    ts9.forEachChild(node, visit);
   };
   visit(declaration);
   return outside;
 }
 
 // eslint/rules/source-under-src.ts
-import path50 from "path";
+import path51 from "path";
 var NON_SOURCE_ROOT_DIRS = /* @__PURE__ */ new Set([
   ".agents",
   ".cache",
@@ -6858,14 +7315,14 @@ var sourceUnderSrcRule = {
     }
   },
   create(context) {
-    const filename = path50.resolve(context.filename);
+    const filename = path51.resolve(context.filename);
     if (!MODULE_EXTENSION.test(filename)) return {};
-    const relative = path50.relative(context.cwd, filename).replace(/\\/g, "/");
+    const relative = path51.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 = path50.basename(filename);
+      const basename = path51.basename(filename);
       if (CONFIG_FILE.test(basename) || DECLARATION_FILE.test(basename) || basename.startsWith(".")) return {};
     }
     return {
@@ -6881,7 +7338,7 @@ var sourceUnderSrcRule = {
 };
 
 // eslint/rules/stay-flat.ts
-import path51 from "path";
+import path52 from "path";
 var stayFlatRule = {
   meta: {
     schema: [],
@@ -6892,7 +7349,7 @@ var stayFlatRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path51.resolve(context.filename);
+    const file = path52.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length !== 3 || segments[0] !== "features") return {};
     const index = getProjectIndex(sourceRoot);
@@ -6932,7 +7389,7 @@ var stayFlatRule = {
 };
 
 // eslint/rules/support-file-placement.ts
-import path52 from "path";
+import path53 from "path";
 var CONFIG_OWNED_FOLDERS = /* @__PURE__ */ new Set(["types", "constants"]);
 var EXPORT_KIND_BY_SUPPORT_FOLDER = /* @__PURE__ */ new Map([
   ["constants", "constant"],
@@ -6957,7 +7414,7 @@ var supportFilePlacementRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const supportFile = path52.resolve(context.filename);
+    const supportFile = path53.resolve(context.filename);
     const currentFolder = folderSegmentsOf(supportFile, sourceRoot);
     const supportFolder = currentFolder[currentFolder.length - 1];
     if (supportFolder === void 0 || !SUPPORT_FOLDERS.has(supportFolder)) return {};
@@ -7011,7 +7468,7 @@ var supportFilePlacementRule = {
 
 // eslint/rules/support-folder-shape.ts
 import fs6 from "fs";
-import path53 from "path";
+import path54 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 = {
@@ -7023,12 +7480,12 @@ var supportFolderShapeRule = {
     }
   },
   create(context) {
-    const filename = path53.resolve(context.filename);
-    const baseName = path53.basename(filename);
+    const filename = path54.resolve(context.filename);
+    const baseName = path54.basename(filename);
     if (!INDEX_NAMES2.has(baseName)) return {};
-    const folder = path53.basename(path53.dirname(filename));
+    const folder = path54.basename(path54.dirname(filename));
     if (!SUPPORT_FOLDERS4.has(folder)) return {};
-    const directory = path53.dirname(filename);
+    const directory = path54.dirname(filename);
     let entries;
     try {
       entries = fs6.readdirSync(directory);
@@ -7046,7 +7503,7 @@ var supportFolderShapeRule = {
         for (const match of source.matchAll(exportPattern)) {
           hasAnyReExport = true;
           const specifier = match.groups?.specifier;
-          if (specifier?.startsWith(".")) exportedFiles.add(path53.basename(specifier));
+          if (specifier?.startsWith(".")) exportedFiles.add(path54.basename(specifier));
         }
         const guide = `docs/next-codebase-guide/rules/${folder === "constants" ? "constants" : "types-and-schemas"}-rule.md`;
         if (siblingModules.length === 0) {
@@ -7225,11 +7682,11 @@ var baseLayerPairRule = {
 
 // eslint/rules/tailwind/css-entry-point.ts
 import { statSync as statSync4 } from "fs";
-import path56 from "path";
+import path57 from "path";
 
 // eslint/rules/tailwind/source-files.ts
 import { readdirSync as readdirSync3, readFileSync as readFileSync9, statSync as statSync3 } from "fs";
-import path54 from "path";
+import path55 from "path";
 var CSS_EXTENSIONS = [".css"];
 var MODULE_EXTENSIONS4 = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
 var SOURCE_EXTENSIONS = [...MODULE_EXTENSIONS4, ...CSS_EXTENSIONS];
@@ -7242,7 +7699,7 @@ function findFiles(dir, extensions) {
   }
   return entries.flatMap((entry) => {
     if (entry.startsWith(".") || entry === "node_modules") return [];
-    const entryPath = path54.join(dir, entry);
+    const entryPath = path55.join(dir, entry);
     let stats;
     try {
       stats = statSync3(entryPath);
@@ -7250,7 +7707,7 @@ function findFiles(dir, extensions) {
       return [];
     }
     if (stats.isDirectory()) return findFiles(entryPath, extensions);
-    return extensions.includes(path54.extname(entry)) ? [entryPath] : [];
+    return extensions.includes(path55.extname(entry)) ? [entryPath] : [];
   });
 }
 function cachedTextReader() {
@@ -7273,7 +7730,7 @@ function escapeRegExp(text) {
 }
 
 // eslint/rules/tailwind/stylesheet-graph.ts
-import path55 from "path";
+import path56 from "path";
 function registersTailwind(text) {
   return /@import\s+(?:url\(\s*)?["']tailwindcss["']\s*\)?/i.test(text);
 }
@@ -7287,25 +7744,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 path55.resolve(spec);
-  if (spec.startsWith("./") || spec.startsWith("../")) return path55.resolve(path55.dirname(fromFile), spec);
-  if (spec.startsWith("@/")) return path55.resolve(sourceRoot, spec.slice(2));
+  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));
   return void 0;
 }
 function buildStylesheetGraph(options) {
   const { cssFiles, sourceRoot, textOf } = options;
-  const cssSet = new Set(cssFiles.map((file) => path55.normalize(file)));
+  const cssSet = new Set(cssFiles.map((file) => path56.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(path55.normalize(global));
+  for (const global of globals) reachable.add(path56.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 = path55.normalize(target);
+      const normalized = path56.normalize(target);
       if (cssSet.has(normalized) && !reachable.has(normalized)) {
         reachable.add(normalized);
         queue.push(normalized);
@@ -7317,7 +7774,7 @@ function buildStylesheetGraph(options) {
     for (const spec of importedSpecifiers(textOf(global))) {
       const target = resolveSpecifier2(global, spec, sourceRoot);
       if (!target) continue;
-      const normalized = path55.normalize(target);
+      const normalized = path56.normalize(target);
       if (cssSet.has(normalized)) directChildren.add(normalized);
     }
   }
@@ -7325,8 +7782,8 @@ function buildStylesheetGraph(options) {
 }
 
 // eslint/rules/tailwind/css-entry-point.ts
-var APP_STYLES_DIR = path56.join("app", "styles");
-var GLOBAL_STYLESHEET_PATH = path56.join(APP_STYLES_DIR, "globals.css");
+var APP_STYLES_DIR = path57.join("app", "styles");
+var GLOBAL_STYLESHEET_PATH = path57.join(APP_STYLES_DIR, "globals.css");
 var cssEntryPointRule = {
   meta: {
     schema: [],
@@ -7352,8 +7809,8 @@ var cssEntryPointRule = {
     return {
       "StyleSheet:exit"(node) {
         if (globals.length === 0) return;
-        const current = path56.normalize(path56.resolve(context.filename));
-        const relative = path56.relative(sourceRoot, current);
+        const current = path57.normalize(path57.resolve(context.filename));
+        const relative = path57.relative(sourceRoot, current);
         if (globals.includes(current)) {
           if (globals.length > 1) {
             context.report({
@@ -7369,7 +7826,7 @@ var cssEntryPointRule = {
             });
             return;
           }
-          const basename = path56.basename(current);
+          const basename = path57.basename(current);
           const importCount = moduleFiles.filter((modulePath) => moduleImports(textOf(modulePath), basename)).length;
           if (importCount !== 1) {
             context.report({
@@ -7379,7 +7836,7 @@ var cssEntryPointRule = {
           }
           return;
         }
-        const isInAppStyles = relative === APP_STYLES_DIR || relative.startsWith(`${APP_STYLES_DIR}${path56.sep}`);
+        const isInAppStyles = relative === APP_STYLES_DIR || relative.startsWith(`${APP_STYLES_DIR}${path57.sep}`);
         if (!isInAppStyles) {
           context.report({
             node,
@@ -7868,7 +8325,7 @@ var tailwindRules = {
 };
 
 // eslint/rules/type-extraction.ts
-import path57 from "path";
+import path58 from "path";
 var typeExtractionRule = {
   meta: {
     schema: [],
@@ -7879,7 +8336,7 @@ var typeExtractionRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path57.resolve(context.filename);
+    const file = path58.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length === 0) return {};
     const index = getProjectIndex(sourceRoot);
@@ -8020,7 +8477,7 @@ var uiStateRule = {
 // eslint/rules/unknown-utility.ts
 import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync10, statSync as statSync6 } from "fs";
 import { createRequire } from "module";
-import path58 from "path";
+import path59 from "path";
 var PREFIX_NAMESPACES = {
   bg: ["color"],
   text: ["color", "text"],
@@ -8260,7 +8717,7 @@ function stylesheetFiles(dir) {
   }
   return entries.flatMap((entry) => {
     if (entry.startsWith(".") || entry === "node_modules") return [];
-    const entryPath = path58.join(dir, entry);
+    const entryPath = path59.join(dir, entry);
     let stats;
     try {
       stats = statSync6(entryPath);
@@ -8268,7 +8725,7 @@ function stylesheetFiles(dir) {
       return [];
     }
     if (stats.isDirectory()) return stylesheetFiles(entryPath);
-    return path58.extname(entry) === ".css" ? [entryPath] : [];
+    return path59.extname(entry) === ".css" ? [entryPath] : [];
   });
 }
 function packageNameOf(specifier) {
@@ -8279,10 +8736,10 @@ function packageNameOf(specifier) {
 function resolvePackageStylesheet(fromFile, specifier) {
   const packageName = packageNameOf(specifier);
   if (!packageName || packageName === "tailwindcss") return void 0;
-  let directory = path58.dirname(fromFile);
-  while (directory !== path58.dirname(directory)) {
-    const packageRoot = path58.join(directory, "node_modules", packageName);
-    const manifestPath = path58.join(packageRoot, "package.json");
+  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");
     if (existsSync6(manifestPath)) {
       try {
         const manifest = readFileSync10(manifestPath, "utf8");
@@ -8290,13 +8747,13 @@ function resolvePackageStylesheet(fromFile, specifier) {
         const main = /"main"\s*:\s*"(?<file>[^"]+\.css)"/.exec(manifest)?.groups?.file;
         const target = stylesheet ?? main;
         if (!target) return void 0;
-        const resolved = path58.resolve(packageRoot, target);
+        const resolved = path59.resolve(packageRoot, target);
         return existsSync6(resolved) ? resolved : void 0;
       } catch {
         return void 0;
       }
     }
-    directory = path58.dirname(directory);
+    directory = path59.dirname(directory);
   }
   return void 0;
 }
@@ -8547,7 +9004,7 @@ var unknownUtilityRule = {
 };
 
 // eslint/rules/util-file-name.ts
-import path59 from "path";
+import path60 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();
 }
@@ -8560,7 +9017,7 @@ var utilFileNameRule = {
     }
   },
   create(context) {
-    const filename = path59.resolve(context.filename);
+    const filename = path60.resolve(context.filename);
     const segments = filename.replace(/\\/g, "/").split("/");
     if (!segments.includes("utils")) return {};
     let module;
@@ -8574,13 +9031,13 @@ var utilFileNameRule = {
     const functionName = functions[0]?.name;
     if (!functionName) return {};
     const expected = toKebabCase2(functionName);
-    const actual = path59.basename(filename, path59.extname(filename));
+    const actual = path60.basename(filename, path60.extname(filename));
     if (!expected || actual === expected) return {};
     return {
       Program(node) {
         context.report({
           node,
-          message: `A utility file exporting ${functionName} must be named ${expected}.${path59.extname(filename).slice(1)}.`
+          message: `A utility file exporting ${functionName} must be named ${expected}.${path60.extname(filename).slice(1)}.`
         });
       }
     };
@@ -8588,7 +9045,7 @@ var utilFileNameRule = {
 };
 
 // eslint/rules/value-extraction.ts
-import path60 from "path";
+import path61 from "path";
 var valueExtractionRule = {
   meta: {
     schema: [],
@@ -8599,7 +9056,7 @@ var valueExtractionRule = {
   },
   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 === 0 || segments[0] !== "app") return {};
     const index = getProjectIndex(sourceRoot);
@@ -8621,7 +9078,7 @@ var valueExtractionRule = {
 
 // eslint/rules/vulyk/tracked-docs.ts
 import { existsSync as existsSync7, readFileSync as readFileSync11 } from "fs";
-import path61 from "path";
+import path62 from "path";
 var PASIKA_REPO = "Bredansky/pasika";
 var BASE_REQUIRED_TRACKED_DOCS = [
   { name: "documentation-guide", path: "docs/documentation-guide" },
@@ -8654,8 +9111,8 @@ var trackedDocsRule = {
         if (!context.filename.endsWith("package.json")) return;
         const root = node.body;
         if (root.type !== "Object") return;
-        const projectRoot = path61.dirname(path61.resolve(context.filename));
-        const configPath = path61.join(projectRoot, "vulyk.config.ts");
+        const projectRoot = path62.dirname(path62.resolve(context.filename));
+        const configPath = path62.join(projectRoot, "vulyk.config.ts");
         if (!existsSync7(configPath)) {
           context.report({
             node,
@@ -8680,7 +9137,7 @@ var trackedDocsRule = {
             });
           }
         }
-        const agentsPath = path61.join(projectRoot, "AGENTS.md");
+        const agentsPath = path62.join(projectRoot, "AGENTS.md");
         if (!existsSync7(agentsPath)) {
           context.report({
             node,
@@ -8780,7 +9237,7 @@ var withResponseHelperRule = {
 
 // eslint/rules/zirka-baseline.ts
 import fs7 from "fs";
-import path62 from "path";
+import path63 from "path";
 var ESLINT_CONFIG = /^eslint\.config\.(?:ts|mts|cts|js|mjs|cjs)$/;
 var PRETTIER_CONFIGS = [
   "prettier.config.mjs",
@@ -8799,10 +9256,10 @@ var zirkaBaselineRule = {
     }
   },
   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 (!ESLINT_CONFIG.test(basename)) return {};
-    const projectRoot = path62.dirname(filename);
+    const projectRoot = path63.dirname(filename);
     const report3 = (message) => {
       context.report({
         node: context.sourceCode.ast,
@@ -8817,7 +9274,7 @@ var zirkaBaselineRule = {
             'ESLint config must take its configuration from zirka (import { styleguide } from "zirka") instead of restating rules locally.'
           );
         }
-        const tsconfigPath = path62.join(projectRoot, "tsconfig.json");
+        const tsconfigPath = path63.join(projectRoot, "tsconfig.json");
         if (!fs7.existsSync(tsconfigPath)) {
           report3('No tsconfig.json found. Create one extending the zirka TypeScript base config ("zirka/typescript").');
         } else {
@@ -8835,13 +9292,13 @@ var zirkaBaselineRule = {
             report3('tsconfig.json must extend the zirka TypeScript base config ("zirka/typescript").');
           }
         }
-        const prettierConfigFile = PRETTIER_CONFIGS.find((name) => fs7.existsSync(path62.join(projectRoot, name)));
+        const prettierConfigFile = PRETTIER_CONFIGS.find((name) => fs7.existsSync(path63.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(path62.join(projectRoot, prettierConfigFile), "utf8");
+          const content = fs7.readFileSync(path63.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."
@@ -9146,6 +9603,18 @@ var pasikaNextjsAppConfig = {
   },
   rules: Object.fromEntries(pasikaNextjsAppRuleIds.map((id) => [id, "error"]))
 };
+var pasikaTypedProjectServiceConfig = {
+  files: ["src/**/*.{cts,mts,ts,tsx}"],
+  languageOptions: {
+    parser: tsParser,
+    parserOptions: {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      ecmaFeatures: { jsx: true },
+      projectService: true
+    }
+  }
+};
 var tailwindStructureRules = {
   files: ["src/app/styles/globals.css"],
   plugins: {
@@ -9215,6 +9684,7 @@ var pasikaNextjsApp = pasikaNextjsAppWithDiagnostic([
   ...pasikaApp,
   pasikaNextjsAppPackageJsonConfig,
   pasikaNextjsAppConfig,
+  pasikaTypedProjectServiceConfig,
   tailwindStructureRules,
   tailwindImportGraph
 ]);