@sarj/eslint-plugin 16.0.0 → 16.1.0

package/dist/index.cjs

@@ -489,8 +489,8 @@ var prefer_typed_reflection_default = createRule({
     const services = import_utils3.ESLintUtils.getParserServices(context);
     if (!services.program) return {};
     const checker = services.program.getTypeChecker();
-    const globalName = (node, name) => node.type === import_utils3.AST_NODE_TYPES.Identifier && node.name === name && !import_utils3.ASTUtils.findVariable(context.sourceCode.getScope(node), name)?.defs.length;
     const isReflect = (node) => globalName(node, "Reflect") || node.type === import_utils3.AST_NODE_TYPES.MemberExpression && propertyName(node) === "Reflect" && globalName(node.object, "globalThis");
+    const globalName = (node, name) => node.type === import_utils3.AST_NODE_TYPES.Identifier && node.name === name && !import_utils3.ASTUtils.findVariable(context.sourceCode.getScope(node), name)?.defs.length;
     const closedObject = (type) => {
       if (type.isUnion()) return type.types.every(closedObject);
       return knownType(type) && type.getProperties().length > 0 && checker.getIndexInfosOfType(type).length === 0;
@@ -727,6 +727,14 @@ var no_reduce_accumulator_copy_default = createRule({
         const accumulator = context.sourceCode.getDeclaredVariables(callback).find((variable) => variable.identifiers.includes(parameter));
         if (!accumulator || accumulator.references.some((reference) => reference.isWrite())) return;
         const referencesAccumulator = (value) => value.type === import_utils5.AST_NODE_TYPES.Identifier && import_utils5.ASTUtils.findVariable(context.sourceCode.getScope(value), value.name) === accumulator;
+        const inspect = (current) => {
+          if (current !== callback.body && [import_utils5.AST_NODE_TYPES.ArrowFunctionExpression, import_utils5.AST_NODE_TYPES.FunctionExpression, import_utils5.AST_NODE_TYPES.FunctionDeclaration].some((kind) => kind === current.type)) return;
+          if (current.type === import_utils5.AST_NODE_TYPES.SpreadElement && (arraySeed && current.parent.type === import_utils5.AST_NODE_TYPES.ArrayExpression || objectSeed && current.parent.type === import_utils5.AST_NODE_TYPES.ObjectExpression) && referencesAccumulator(current.argument)) {
+            context.report({ node: current, messageId: "copy" });
+          }
+          if (current.type === import_utils5.AST_NODE_TYPES.CallExpression) inspectCall(current);
+          forEachAstChild(current, context.sourceCode.visitorKeys, inspect);
+        };
         const inspectCall = (current) => {
           if (current.callee.type !== import_utils5.AST_NODE_TYPES.MemberExpression) return;
           const member = current.callee;
@@ -739,14 +747,6 @@ var no_reduce_accumulator_copy_default = createRule({
           const assignCopy = objectSeed && name === "assign" && globalObject && target?.type === import_utils5.AST_NODE_TYPES.ObjectExpression && current.arguments.slice(1).some(referencesAccumulator);
           if (directCopy || fromCopy || assignCopy) context.report({ node: current, messageId: "copy" });
         };
-        const inspect = (current) => {
-          if (current !== callback.body && [import_utils5.AST_NODE_TYPES.ArrowFunctionExpression, import_utils5.AST_NODE_TYPES.FunctionExpression, import_utils5.AST_NODE_TYPES.FunctionDeclaration].some((kind) => kind === current.type)) return;
-          if (current.type === import_utils5.AST_NODE_TYPES.SpreadElement && (arraySeed && current.parent.type === import_utils5.AST_NODE_TYPES.ArrayExpression || objectSeed && current.parent.type === import_utils5.AST_NODE_TYPES.ObjectExpression) && referencesAccumulator(current.argument)) {
-            context.report({ node: current, messageId: "copy" });
-          }
-          if (current.type === import_utils5.AST_NODE_TYPES.CallExpression) inspectCall(current);
-          forEachAstChild(current, context.sourceCode.visitorKeys, inspect);
-        };
         inspect(callback.body);
       }
     };
@@ -3650,28 +3650,6 @@ var no_cors_wildcard_with_credentials_default = createRule({
     const scopeHeaderSets = /* @__PURE__ */ new Map();
     const variableIds = /* @__PURE__ */ new WeakMap();
     let nextVariableId = 0;
-    function variableId(variable) {
-      const existing = variableIds.get(variable);
-      if (existing !== void 0) return existing;
-      const value = nextVariableId++;
-      variableIds.set(variable, value);
-      return value;
-    }
-    function receiverIdentity(node) {
-      if (node.type === import_utils23.AST_NODE_TYPES.Identifier) {
-        const variable = import_utils23.ASTUtils.findVariable(
-          context.sourceCode.getScope(node),
-          node.name
-        );
-        return variable === null ? `global:${node.name}` : `variable:${variableId(variable)}`;
-      }
-      if (node.type === import_utils23.AST_NODE_TYPES.ThisExpression) return "this";
-      if (node.type === import_utils23.AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === import_utils23.AST_NODE_TYPES.Identifier) {
-        const owner = receiverIdentity(node.object);
-        return owner === null ? null : `${owner}.${node.property.name}`;
-      }
-      return null;
-    }
     function recordHeaderSet(node, kind) {
       if (node.callee.type !== import_utils23.AST_NODE_TYPES.MemberExpression) return;
       const receiver = receiverIdentity(node.callee.object);
@@ -3693,6 +3671,28 @@ var no_cors_wildcard_with_credentials_default = createRule({
         entry.credentialsNodes.push(node);
       }
     }
+    function receiverIdentity(node) {
+      if (node.type === import_utils23.AST_NODE_TYPES.Identifier) {
+        const variable = import_utils23.ASTUtils.findVariable(
+          context.sourceCode.getScope(node),
+          node.name
+        );
+        return variable === null ? `global:${node.name}` : `variable:${variableId(variable)}`;
+      }
+      if (node.type === import_utils23.AST_NODE_TYPES.ThisExpression) return "this";
+      if (node.type === import_utils23.AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === import_utils23.AST_NODE_TYPES.Identifier) {
+        const owner = receiverIdentity(node.object);
+        return owner === null ? null : `${owner}.${node.property.name}`;
+      }
+      return null;
+    }
+    function variableId(variable) {
+      const existing = variableIds.get(variable);
+      if (existing !== void 0) return existing;
+      const value = nextVariableId++;
+      variableIds.set(variable, value);
+      return value;
+    }
     return {
       NewExpression(node) {
         if (isCorsWildcardCredentialsCall(node)) {
@@ -4482,20 +4482,6 @@ function functionComplexity(fn, visitorKeys) {
   function add(node, nesting, construct) {
     points.push({ line: node.loc.start.line, amount: nesting + 1, construct });
   }
-  function logical(node, nesting) {
-    let previous;
-    function flatten(expression) {
-      if (expression.type !== import_utils29.AST_NODE_TYPES.LogicalExpression || expression.operator === "??") {
-        visit(expression, nesting);
-        return;
-      }
-      flatten(expression.left);
-      if (previous !== expression.operator) add(expression, 0, expression.operator);
-      previous = expression.operator;
-      flatten(expression.right);
-    }
-    flatten(node);
-  }
   function conditional(node, nesting) {
     add(node, nesting, "if");
     let branch = node;
@@ -4574,6 +4560,20 @@ function functionComplexity(fn, visitorKeys) {
     }
     visitChildren(node, nesting);
   }
+  function logical(node, nesting) {
+    let previous;
+    function flatten(expression) {
+      if (expression.type !== import_utils29.AST_NODE_TYPES.LogicalExpression || expression.operator === "??") {
+        visit(expression, nesting);
+        return;
+      }
+      flatten(expression.left);
+      if (previous !== expression.operator) add(expression, 0, expression.operator);
+      previous = expression.operator;
+      flatten(expression.right);
+    }
+    flatten(node);
+  }
   function visitChildren(node, nesting) {
     forEachAstChild(node, visitorKeys, (child) => visit(child, nesting));
   }
@@ -5196,6 +5196,14 @@ var no_hand_rolled_sleep_default = createRule({
       const callee = callback.type === import_utils31.AST_NODE_TYPES.Identifier ? callback : callback.type === import_utils31.AST_NODE_TYPES.ArrowFunctionExpression || callback.type === import_utils31.AST_NODE_TYPES.FunctionExpression ? soleCall(callback)?.callee : null;
       return callee?.type === import_utils31.AST_NODE_TYPES.Identifier && bindingOf(callee) === bindingOf(parameter);
     };
+    let clientModule = null;
+    const reportsSleepHere = () => {
+      if (checkClientModules) {
+        return true;
+      }
+      clientModule ??= isClientModule2();
+      return !clientModule;
+    };
     function isClientModule2() {
       if (/\.[cm]?[jt]sx$/.test(filename)) {
         return true;
@@ -5211,14 +5219,6 @@ var no_hand_rolled_sleep_default = createRule({
       }
       return false;
     }
-    let clientModule = null;
-    const reportsSleepHere = () => {
-      if (checkClientModules) {
-        return true;
-      }
-      clientModule ??= isClientModule2();
-      return !clientModule;
-    };
     return {
       NewExpression(node) {
         if (node.callee.type !== import_utils31.AST_NODE_TYPES.Identifier || node.callee.name !== "Promise" || !isGlobal(node.callee)) {
@@ -5648,13 +5648,6 @@ var no_detached_global_fetch_default = createRule({
       const variable = bindingOf(identifier);
       if (variable !== null && isStableAlias(variable)) aliases.add(variable);
     }
-    function isGlobalFetchMember(node) {
-      if (!isGlobalReceiver(node.object)) return false;
-      if (!node.computed) {
-        return node.property.type === import_utils34.AST_NODE_TYPES.Identifier && node.property.name === "fetch";
-      }
-      return node.property.type === import_utils34.AST_NODE_TYPES.Literal && node.property.value === "fetch";
-    }
     function staticMemberName9(node) {
       if (!node.computed) {
         return node.property.type === import_utils34.AST_NODE_TYPES.Identifier ? node.property.name : null;
@@ -5683,6 +5676,13 @@ var no_detached_global_fetch_default = createRule({
       }
       return false;
     }
+    function isGlobalFetchMember(node) {
+      if (!isGlobalReceiver(node.object)) return false;
+      if (!node.computed) {
+        return node.property.type === import_utils34.AST_NODE_TYPES.Identifier && node.property.name === "fetch";
+      }
+      return node.property.type === import_utils34.AST_NODE_TYPES.Literal && node.property.value === "fetch";
+    }
     function recordAliasFromValue(identifier, value) {
       if (mayBeRawFetch(value)) recordAlias(identifier);
     }
@@ -6241,17 +6241,6 @@ var no_impossible_zod_literal_bounds_default = createRule({
       }
       return false;
     }
-    function baseKind(node) {
-      const callee = node.callee;
-      if (callee.type === import_utils37.AST_NODE_TYPES.Identifier) {
-        return resolvesToTrackedImport(callee) ? constructors.get(callee.name) ?? null : null;
-      }
-      if (callee.type !== import_utils37.AST_NODE_TYPES.MemberExpression || callee.object.type !== import_utils37.AST_NODE_TYPES.Identifier || !namespaces.has(callee.object.name) || !resolvesToTrackedImport(callee.object)) {
-        return null;
-      }
-      const name = memberName(callee);
-      return name !== null && KINDS.has(name) ? name : null;
-    }
     function readChain(node) {
       const calls = [];
       let current = node;
@@ -6268,6 +6257,17 @@ var no_impossible_zod_literal_bounds_default = createRule({
         current = callee.object;
       }
     }
+    function baseKind(node) {
+      const callee = node.callee;
+      if (callee.type === import_utils37.AST_NODE_TYPES.Identifier) {
+        return resolvesToTrackedImport(callee) ? constructors.get(callee.name) ?? null : null;
+      }
+      if (callee.type !== import_utils37.AST_NODE_TYPES.MemberExpression || callee.object.type !== import_utils37.AST_NODE_TYPES.Identifier || !namespaces.has(callee.object.name) || !resolvesToTrackedImport(callee.object)) {
+        return null;
+      }
+      const name = memberName(callee);
+      return name !== null && KINDS.has(name) ? name : null;
+    }
     function isInsideReshapingCall(node) {
       let child = node;
       let parent = child.parent;
@@ -6581,30 +6581,30 @@ var no_redundant_optional_array_default_default = createRule({
       }
       return false;
     }
-    function isZodSchemaExpression(node) {
+    function isArraySchemaExpression(node) {
       if (node.type !== import_utils39.AST_NODE_TYPES.CallExpression) return false;
       const { callee } = node;
       if (callee.type === import_utils39.AST_NODE_TYPES.Identifier) {
-        return resolvesToTrackedImport(callee);
+        return arrayConstructors.has(callee.name) && resolvesToTrackedImport(callee);
       }
       if (callee.type !== import_utils39.AST_NODE_TYPES.MemberExpression) return false;
-      if (callee.object.type === import_utils39.AST_NODE_TYPES.Identifier && namespaces.has(callee.object.name) && resolvesToTrackedImport(callee.object)) {
+      const method = memberName2(callee);
+      if (method === "array" && (callee.object.type === import_utils39.AST_NODE_TYPES.Identifier ? namespaces.has(callee.object.name) && resolvesToTrackedImport(callee.object) : isZodSchemaExpression(callee.object))) {
         return true;
       }
-      return isZodSchemaExpression(callee.object);
+      return isArraySchemaExpression(callee.object);
     }
-    function isArraySchemaExpression(node) {
+    function isZodSchemaExpression(node) {
       if (node.type !== import_utils39.AST_NODE_TYPES.CallExpression) return false;
       const { callee } = node;
       if (callee.type === import_utils39.AST_NODE_TYPES.Identifier) {
-        return arrayConstructors.has(callee.name) && resolvesToTrackedImport(callee);
+        return resolvesToTrackedImport(callee);
       }
       if (callee.type !== import_utils39.AST_NODE_TYPES.MemberExpression) return false;
-      const method = memberName2(callee);
-      if (method === "array" && (callee.object.type === import_utils39.AST_NODE_TYPES.Identifier ? namespaces.has(callee.object.name) && resolvesToTrackedImport(callee.object) : isZodSchemaExpression(callee.object))) {
+      if (callee.object.type === import_utils39.AST_NODE_TYPES.Identifier && namespaces.has(callee.object.name) && resolvesToTrackedImport(callee.object)) {
         return true;
       }
-      return isArraySchemaExpression(callee.object);
+      return isZodSchemaExpression(callee.object);
     }
     return {
       ImportDeclaration(node) {
@@ -7036,10 +7036,6 @@ var no_log_only_catch_default = createRule({
       }
       return matcher.isLoggingCall(statement.expression);
     }
-    function hasCommentDirectlyAbove(node) {
-      const above = sourceCode.getCommentsBefore(node).at(-1);
-      return above !== void 0 && above.loc.end.line === node.loc.start.line - 1;
-    }
     function hasAdjacentRationale(node) {
       const tryStatement = node.parent;
       if (hasCommentDirectlyAbove(tryStatement) || hasCommentDirectlyAbove(node)) return true;
@@ -7049,6 +7045,10 @@ var no_log_only_catch_default = createRule({
       }
       return hasCommentDirectlyAbove(block.parent);
     }
+    function hasCommentDirectlyAbove(node) {
+      const above = sourceCode.getCommentsBefore(node).at(-1);
+      return above !== void 0 && above.loc.end.line === node.loc.start.line - 1;
+    }
     if (isTestFile(filename) || BENCHMARK_DIR_RE.test(filename.replaceAll("\\", "/"))) {
       return {};
     }
@@ -8049,6 +8049,10 @@ var no_positional_tuple_return_default = createRule({
         data: { name, count: String(tuple.elements.length) }
       });
     };
+    const enterFunction = (node) => {
+      functionStack.push(node);
+      check(node);
+    };
     const check = (node) => {
       if (isQueryKeyFactory(node)) return;
       const annotation = node.returnType?.typeAnnotation;
@@ -8064,10 +8068,6 @@ var no_positional_tuple_return_default = createRule({
       }
       report2(annotation, name);
     };
-    const enterFunction = (node) => {
-      functionStack.push(node);
-      check(node);
-    };
     const exitFunction = () => {
       functionStack.pop();
     };
@@ -8514,32 +8514,16 @@ var no_raw_fetch_outside_clients_default = createRule({
       const definition = variable.defs[0];
       return definition?.type === "Variable" && definition.parent.kind === "const" && definition.node.init !== null && !variable.references.some((reference) => reference.isWrite() && reference.init !== true) && !(definition.node.init.type === import_utils51.AST_NODE_TYPES.ObjectExpression && variable.references.some((reference) => reference.identifier !== node && reference.init !== true)) ? definition.node.init : node;
     }
-    function propertyValue(node, name) {
-      if (node?.type !== import_utils51.AST_NODE_TYPES.ObjectExpression) return null;
-      if (node.properties.some((property) => property.type !== import_utils51.AST_NODE_TYPES.Property || property.computed)) return null;
-      for (const property of [...node.properties].reverse()) {
-        if (property.type !== import_utils51.AST_NODE_TYPES.Property || property.computed) continue;
-        const key = property.key;
-        const keyName = key.type === import_utils51.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils51.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
-        if (keyName !== name) continue;
-        return property.value.type === import_utils51.AST_NODE_TYPES.AssignmentPattern || property.value.type === import_utils51.AST_NODE_TYPES.ArrayPattern || property.value.type === import_utils51.AST_NODE_TYPES.ObjectPattern ? null : property.value;
-      }
-      return null;
-    }
-    function isInternalApiUrl(node) {
-      const resolved = resolveNode2(node ?? void 0);
-      if (resolved?.type === import_utils51.AST_NODE_TYPES.Literal) {
-        return typeof resolved.value === "string" && internalApiPrefixes.some(
-          (prefix) => resolved.value === prefix || resolved.value.startsWith(`${prefix}/`)
-        );
+    function serverActionOwns(node) {
+      if (node.callee.type !== import_utils51.AST_NODE_TYPES.Identifier || !hasUseClientDirective || hasUseServerDirective || importsServerOnly || SERVER_ACTION_SKIP_FILE_RE.test(filename) || nonReactFramework) {
+        return false;
       }
-      if (resolved?.type === import_utils51.AST_NODE_TYPES.TemplateLiteral) {
-        const prefix = resolved.quasis[0]?.value.cooked;
-        return typeof prefix === "string" && internalApiPrefixes.some(
-          (apiPrefix) => prefix === apiPrefix || prefix.startsWith(`${apiPrefix}/`)
-        );
+      const url = node.arguments[0];
+      const init = node.arguments[1];
+      if (url === void 0 || url.type === import_utils51.AST_NODE_TYPES.SpreadElement || init === void 0 || init.type === import_utils51.AST_NODE_TYPES.SpreadElement || !isInternalApiUrl(url)) {
+        return false;
       }
-      return resolved?.type === import_utils51.AST_NODE_TYPES.BinaryExpression && resolved.operator === "+" && isInternalApiUrl(resolved.left);
+      return isMutationMethod2(propertyValue(resolveNode2(init), "method"));
     }
     function isMutationMethod2(node) {
       const resolved = resolveNode2(node ?? void 0);
@@ -8556,16 +8540,32 @@ var no_raw_fetch_outside_clients_default = createRule({
       }
       return resolved?.type === import_utils51.AST_NODE_TYPES.LogicalExpression && resolved.operator === "||" && (isMutationMethod2(resolved.left) || isMutationMethod2(resolved.right));
     }
-    function serverActionOwns(node) {
-      if (node.callee.type !== import_utils51.AST_NODE_TYPES.Identifier || !hasUseClientDirective || hasUseServerDirective || importsServerOnly || SERVER_ACTION_SKIP_FILE_RE.test(filename) || nonReactFramework) {
-        return false;
+    function isInternalApiUrl(node) {
+      const resolved = resolveNode2(node ?? void 0);
+      if (resolved?.type === import_utils51.AST_NODE_TYPES.Literal) {
+        return typeof resolved.value === "string" && internalApiPrefixes.some(
+          (prefix) => resolved.value === prefix || resolved.value.startsWith(`${prefix}/`)
+        );
       }
-      const url = node.arguments[0];
-      const init = node.arguments[1];
-      if (url === void 0 || url.type === import_utils51.AST_NODE_TYPES.SpreadElement || init === void 0 || init.type === import_utils51.AST_NODE_TYPES.SpreadElement || !isInternalApiUrl(url)) {
-        return false;
+      if (resolved?.type === import_utils51.AST_NODE_TYPES.TemplateLiteral) {
+        const prefix = resolved.quasis[0]?.value.cooked;
+        return typeof prefix === "string" && internalApiPrefixes.some(
+          (apiPrefix) => prefix === apiPrefix || prefix.startsWith(`${apiPrefix}/`)
+        );
       }
-      return isMutationMethod2(propertyValue(resolveNode2(init), "method"));
+      return resolved?.type === import_utils51.AST_NODE_TYPES.BinaryExpression && resolved.operator === "+" && isInternalApiUrl(resolved.left);
+    }
+    function propertyValue(node, name) {
+      if (node?.type !== import_utils51.AST_NODE_TYPES.ObjectExpression) return null;
+      if (node.properties.some((property) => property.type !== import_utils51.AST_NODE_TYPES.Property || property.computed)) return null;
+      for (const property of [...node.properties].reverse()) {
+        if (property.type !== import_utils51.AST_NODE_TYPES.Property || property.computed) continue;
+        const key = property.key;
+        const keyName = key.type === import_utils51.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils51.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+        if (keyName !== name) continue;
+        return property.value.type === import_utils51.AST_NODE_TYPES.AssignmentPattern || property.value.type === import_utils51.AST_NODE_TYPES.ArrayPattern || property.value.type === import_utils51.AST_NODE_TYPES.ObjectPattern ? null : property.value;
+      }
+      return null;
     }
     if (allowed.some((re) => re.test(filename))) {
       return {};
@@ -9664,35 +9664,30 @@ var no_secret_in_log_default = createRule({
   create(context, [loggingOptions]) {
     const matcher = createLogMatcher(loggingOptions);
     const blobArmApplies = !isTestFile(context.filename);
-    function reportSecretArgument(arg) {
-      const name = valueName(arg);
-      if (name === null || !isSecretKeyword(name)) {
-        return false;
+    function inspectLoggedValue(value) {
+      if (value.type === "ObjectExpression") {
+        for (const property of literalProperties(value)) {
+          if (reportSecretProperty(property) || reportRawBlob(property, property.value)) continue;
+          inspectLoggedValue(property.value);
+        }
+        return;
       }
-      context.report({ node: arg, messageId: "noSecretInLog", data: { name } });
-      return true;
-    }
-    function reportSecretProperty(prop) {
-      const keyName = propertyKeyName2(prop);
-      const value = valueName(prop.value);
-      if (value !== null && hasRedactionMarker(value)) return false;
-      const name = value !== null && isSecretKeyword(value) ? value : keyName;
-      if (name === null || !isSecretKeyword(name) || !isRawSecretValue(prop)) {
-        return false;
+      if (value.type === "ArrayExpression") {
+        for (const element of value.elements) {
+          if (element !== null && element.type !== "SpreadElement") inspectLoggedValue(element);
+        }
+        return;
       }
-      context.report({ node: prop, messageId: "noSecretInLog", data: { name } });
-      return true;
-    }
-    function reportRawBlob(node, value) {
-      if (!blobArmApplies) {
-        return false;
+      if (value.type === "TemplateLiteral") {
+        for (const expression of value.expressions) inspectLoggedValue(expression);
+        return;
       }
-      const name = rawBlobValueName(value);
-      if (name !== null) {
-        context.report({ node, messageId: "noRawBodyInLog", data: { name } });
-        return true;
+      if (value.type === "BinaryExpression" && value.operator === "+") {
+        inspectLoggedValue(value.left);
+        inspectLoggedValue(value.right);
+        return;
       }
-      return false;
+      if (!reportSecretArgument(value)) reportRawBlob(value, value);
     }
     function literalProperties(value) {
       const effective = /* @__PURE__ */ new Map();
@@ -9717,30 +9712,35 @@ var no_secret_in_log_default = createRule({
       }
       return [...effective.values()];
     }
-    function inspectLoggedValue(value) {
-      if (value.type === "ObjectExpression") {
-        for (const property of literalProperties(value)) {
-          if (reportSecretProperty(property) || reportRawBlob(property, property.value)) continue;
-          inspectLoggedValue(property.value);
-        }
-        return;
+    function reportRawBlob(node, value) {
+      if (!blobArmApplies) {
+        return false;
       }
-      if (value.type === "ArrayExpression") {
-        for (const element of value.elements) {
-          if (element !== null && element.type !== "SpreadElement") inspectLoggedValue(element);
-        }
-        return;
+      const name = rawBlobValueName(value);
+      if (name !== null) {
+        context.report({ node, messageId: "noRawBodyInLog", data: { name } });
+        return true;
       }
-      if (value.type === "TemplateLiteral") {
-        for (const expression of value.expressions) inspectLoggedValue(expression);
-        return;
+      return false;
+    }
+    function reportSecretProperty(prop) {
+      const keyName = propertyKeyName2(prop);
+      const value = valueName(prop.value);
+      if (value !== null && hasRedactionMarker(value)) return false;
+      const name = value !== null && isSecretKeyword(value) ? value : keyName;
+      if (name === null || !isSecretKeyword(name) || !isRawSecretValue(prop)) {
+        return false;
       }
-      if (value.type === "BinaryExpression" && value.operator === "+") {
-        inspectLoggedValue(value.left);
-        inspectLoggedValue(value.right);
-        return;
+      context.report({ node: prop, messageId: "noSecretInLog", data: { name } });
+      return true;
+    }
+    function reportSecretArgument(arg) {
+      const name = valueName(arg);
+      if (name === null || !isSecretKeyword(name)) {
+        return false;
       }
-      if (!reportSecretArgument(value)) reportRawBlob(value, value);
+      context.report({ node: arg, messageId: "noSecretInLog", data: { name } });
+      return true;
     }
     return {
       CallExpression(node) {
@@ -10038,9 +10038,6 @@ function bindsName(param, name) {
 }
 function subtreeReadsName(node, name) {
   let found = false;
-  const shadowsName = (fn) => isFunctionNode(fn) && fn.params.some(
-    (param) => bindsName(param, name)
-  );
   const recurse = (current) => {
     if (found) {
       return;
@@ -10057,6 +10054,9 @@ function subtreeReadsName(node, name) {
       return found;
     }, (key) => !isNonReadingProperty(current, key));
   };
+  const shadowsName = (fn) => isFunctionNode(fn) && fn.params.some(
+    (param) => bindsName(param, name)
+  );
   recurse(node);
   return found;
 }
@@ -11918,14 +11918,6 @@ var no_declaration_comment_wall_default = createRule({
       const trail = startingOn.get(member.loc.end.line);
       return trail !== void 0 && trail.range[0] > member.range[0] ? trail : void 0;
     }
-    function isGroupLabel(comment, member, headsRun) {
-      if (comment.loc.end.line >= member.node.loc.start.line) return false;
-      const body2 = commentBody(comment);
-      if (!BARE_LABEL_RE.test(body2)) return false;
-      if (labelStems(body2) === labelStems(sourceCode.getText(member.key))) return false;
-      const lineAbove = sourceCode.lines[comment.loc.start.line - 2];
-      return headsRun || lineAbove !== void 0 && lineAbove.trim().length === 0;
-    }
     function check(node, members) {
       const judged = members.map(named).filter((member) => member !== void 0);
       if (judged.length === 0) return;
@@ -11964,6 +11956,14 @@ var no_declaration_comment_wall_default = createRule({
         data: { restated: String(restated), commented: String(commented) }
       });
     }
+    function isGroupLabel(comment, member, headsRun) {
+      if (comment.loc.end.line >= member.node.loc.start.line) return false;
+      const body2 = commentBody(comment);
+      if (!BARE_LABEL_RE.test(body2)) return false;
+      if (labelStems(body2) === labelStems(sourceCode.getText(member.key))) return false;
+      const lineAbove = sourceCode.lines[comment.loc.start.line - 2];
+      return headsRun || lineAbove !== void 0 && lineAbove.trim().length === 0;
+    }
     return {
       ClassBody: (node) => {
         check(node, node.body);
@@ -12199,14 +12199,6 @@ var no_type_member_comment_wall_default = createRule({
       const trail = startingOn.get(member.loc.end.line);
       return trail !== void 0 && trail.range[0] > member.range[0] ? trail : void 0;
     }
-    function isGroupLabel(comment, member, headsRun) {
-      if (comment.loc.end.line >= member.loc.start.line) return false;
-      const body2 = commentBody(comment);
-      if (!BARE_LABEL_RE.test(body2)) return false;
-      if (labelStems(body2) === labelStems(sourceCode.getText(member.key))) return false;
-      const lineAbove = sourceCode.lines[comment.loc.start.line - 2];
-      return headsRun || lineAbove !== void 0 && lineAbove.trim().length === 0;
-    }
     function check(node) {
       const members = node.type === import_utils71.AST_NODE_TYPES.TSInterfaceBody ? node.body : node.members;
       const named2 = members.filter(isNamedMember);
@@ -12242,6 +12234,14 @@ var no_type_member_comment_wall_default = createRule({
         data: { restated: String(restated), commented: String(commented) }
       });
     }
+    function isGroupLabel(comment, member, headsRun) {
+      if (comment.loc.end.line >= member.loc.start.line) return false;
+      const body2 = commentBody(comment);
+      if (!BARE_LABEL_RE.test(body2)) return false;
+      if (labelStems(body2) === labelStems(sourceCode.getText(member.key))) return false;
+      const lineAbove = sourceCode.lines[comment.loc.start.line - 2];
+      return headsRun || lineAbove !== void 0 && lineAbove.trim().length === 0;
+    }
     return {
       TSInterfaceBody: check,
       TSTypeLiteral: check
@@ -12557,6 +12557,11 @@ var no_unsafe_mock_casting_default = createRule({
       const binding = resolve2(identifier);
       if (binding !== null) destination.add(binding);
     }
+    function checkAssertion(node) {
+      if (isMockTypeReference(node.typeAnnotation)) {
+        context.report({ node, messageId: "unsafeMockCast" });
+      }
+    }
     function isMockTypeReference(node) {
       if (node.type !== import_utils73.AST_NODE_TYPES.TSTypeReference) return false;
       const typeName = node.typeName;
@@ -12570,11 +12575,6 @@ var no_unsafe_mock_casting_default = createRule({
       }
       return false;
     }
-    function checkAssertion(node) {
-      if (isMockTypeReference(node.typeAnnotation)) {
-        context.report({ node, messageId: "unsafeMockCast" });
-      }
-    }
     return {
       ImportDeclaration(node) {
         if (!MOCK_MODULES.has(node.source.value)) return;
@@ -17885,7 +17885,7 @@ var staticallyImportsExternalRenderer = (program) => program.body.some((statemen
 var semanticForegroundRoles = (filename) => {
   const packageRoot = nearestPackageRoot((0, import_path.dirname)(filename));
   if (packageRoot === null) return /* @__PURE__ */ new Set();
-  const candidates = CSS_DETECTION_FILES.map((relative2) => (0, import_path.join)(packageRoot, relative2));
+  const candidates = CSS_DETECTION_FILES.map((relative3) => (0, import_path.join)(packageRoot, relative3));
   const fingerprint = candidates.map(fileFingerprint2).join("|");
   const cached = SEMANTIC_DECLARATIONS_CACHE.get(packageRoot);
   if (cached?.fingerprint === fingerprint) return cached.value;
@@ -17968,6 +17968,34 @@ var prefer_semantic_colors_default = createRule({
       const key = `${node.range[0]}:${node.range[1]}:${messageId}:${JSON.stringify(data)}`;
       pendingReports.set(key, { node, messageId, data });
     };
+    const checkClassNode = (node, objectKeys = false) => {
+      if (node === null) return;
+      switch (node.type) {
+        case import_utils103.AST_NODE_TYPES.Literal:
+          if (typeof node.value === "string") reportClasses(node.value, node);
+          break;
+        case import_utils103.AST_NODE_TYPES.TemplateLiteral:
+          for (const quasi of node.quasis) reportClasses(quasi.value.cooked ?? "", quasi);
+          break;
+        case import_utils103.AST_NODE_TYPES.ArrayExpression:
+          for (const element of node.elements) {
+            if (element !== null && element.type !== import_utils103.AST_NODE_TYPES.SpreadElement) checkClassNode(element, objectKeys);
+          }
+          break;
+        case import_utils103.AST_NODE_TYPES.ObjectExpression:
+          checkClassProperties(node, objectKeys);
+          break;
+        case import_utils103.AST_NODE_TYPES.ConditionalExpression:
+          checkClassNode(node.consequent, objectKeys);
+          checkClassNode(node.alternate, objectKeys);
+          break;
+        case import_utils103.AST_NODE_TYPES.LogicalExpression:
+          checkClassNode(node.right, objectKeys);
+          break;
+        default:
+          break;
+      }
+    };
     const reportClasses = (value, node) => {
       const tokens = classTokens(value);
       for (const token of tokens) {
@@ -17999,34 +18027,6 @@ var prefer_semantic_colors_default = createRule({
         });
       }
     };
-    const checkClassNode = (node, objectKeys = false) => {
-      if (node === null) return;
-      switch (node.type) {
-        case import_utils103.AST_NODE_TYPES.Literal:
-          if (typeof node.value === "string") reportClasses(node.value, node);
-          break;
-        case import_utils103.AST_NODE_TYPES.TemplateLiteral:
-          for (const quasi of node.quasis) reportClasses(quasi.value.cooked ?? "", quasi);
-          break;
-        case import_utils103.AST_NODE_TYPES.ArrayExpression:
-          for (const element of node.elements) {
-            if (element !== null && element.type !== import_utils103.AST_NODE_TYPES.SpreadElement) checkClassNode(element, objectKeys);
-          }
-          break;
-        case import_utils103.AST_NODE_TYPES.ObjectExpression:
-          checkClassProperties(node, objectKeys);
-          break;
-        case import_utils103.AST_NODE_TYPES.ConditionalExpression:
-          checkClassNode(node.consequent, objectKeys);
-          checkClassNode(node.alternate, objectKeys);
-          break;
-        case import_utils103.AST_NODE_TYPES.LogicalExpression:
-          checkClassNode(node.right, objectKeys);
-          break;
-        default:
-          break;
-      }
-    };
     function checkClassProperties(node, objectKeys) {
       for (const property of node.properties) {
         if (property.type !== import_utils103.AST_NODE_TYPES.Property) continue;
@@ -18460,80 +18460,6 @@ var prefer_whole_object_assertion_default = createRule({
       return {};
     }
     const { sourceCode } = context;
-    function parseAssertion(statement) {
-      if (statement.type !== import_utils105.AST_NODE_TYPES.ExpressionStatement) {
-        return null;
-      }
-      const call = statement.expression;
-      if (call.type !== import_utils105.AST_NODE_TYPES.CallExpression) {
-        return null;
-      }
-      const callee = call.callee;
-      if (callee.type !== import_utils105.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils105.AST_NODE_TYPES.Identifier) {
-        return null;
-      }
-      const matcher = callee.property.name;
-      const expectCall = callee.object;
-      if (expectCall.type !== import_utils105.AST_NODE_TYPES.CallExpression || expectCall.callee.type !== import_utils105.AST_NODE_TYPES.Identifier || expectCall.callee.name !== "expect" || expectCall.arguments.length !== 1) {
-        return null;
-      }
-      const actual = expectCall.arguments[0];
-      if (!isTestExpect(expectCall.callee)) return null;
-      if (actual === void 0 || actual.type !== import_utils105.AST_NODE_TYPES.MemberExpression || actual.optional) {
-        return null;
-      }
-      if (!isPureReceiver(actual.object)) {
-        return null;
-      }
-      let key;
-      let receiver;
-      if (actual.computed) {
-        const index = literalIndex(actual.property);
-        if (index === null) {
-          return null;
-        }
-        key = { kind: "index", index };
-        receiver = actual.object;
-      } else {
-        const access = propertyAccess(actual);
-        if (access === null) return null;
-        key = { kind: "property", path: access.path };
-        receiver = access.receiver;
-      }
-      return assertionExpectation(statement, call, receiver, key, matcher);
-    }
-    function assertionExpectation(statement, call, receiver, key, matcher) {
-      const synthetic = SYNTHETIC_LITERAL_MATCHERS.get(matcher);
-      if (synthetic !== void 0 && call.arguments.length === 0) {
-        return { statement, receiver, key, matcher, expectedText: synthetic, expectedIsLiteral: true };
-      }
-      if (!MERGEABLE_MATCHERS.has(matcher)) {
-        return null;
-      }
-      const expected = call.arguments[0];
-      if (call.arguments.length !== 1 || expected === void 0 || expected.type === import_utils105.AST_NODE_TYPES.SpreadElement) {
-        return null;
-      }
-      const literal = literalText(expected, (node) => sourceCode.getText(node));
-      return {
-        statement,
-        receiver,
-        key,
-        matcher,
-        expectedText: literal ?? sourceCode.getText(expected),
-        expectedIsLiteral: literal !== null
-      };
-    }
-    function isTestExpect(callee) {
-      const variable = import_utils105.ASTUtils.findVariable(sourceCode.getScope(callee), callee.name);
-      if (variable !== null && variable.defs.some((definition) => {
-        if (definition.node.type !== import_utils105.AST_NODE_TYPES.ImportSpecifier) return true;
-        const declaration = definition.node.parent;
-        const imported = definition.node.imported;
-        return declaration.type !== import_utils105.AST_NODE_TYPES.ImportDeclaration || !["vitest", "@jest/globals", "@playwright/test", "bun:test"].includes(String(declaration.source.value)) || (imported.type === import_utils105.AST_NODE_TYPES.Identifier ? imported.name : imported.value) !== "expect";
-      })) return false;
-      return true;
-    }
     function reportPropertyRun(run) {
       const tree = /* @__PURE__ */ new Map();
       const paths = [];
@@ -18643,6 +18569,80 @@ var prefer_whole_object_assertion_default = createRule({
       }
       flush();
     }
+    function parseAssertion(statement) {
+      if (statement.type !== import_utils105.AST_NODE_TYPES.ExpressionStatement) {
+        return null;
+      }
+      const call = statement.expression;
+      if (call.type !== import_utils105.AST_NODE_TYPES.CallExpression) {
+        return null;
+      }
+      const callee = call.callee;
+      if (callee.type !== import_utils105.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils105.AST_NODE_TYPES.Identifier) {
+        return null;
+      }
+      const matcher = callee.property.name;
+      const expectCall = callee.object;
+      if (expectCall.type !== import_utils105.AST_NODE_TYPES.CallExpression || expectCall.callee.type !== import_utils105.AST_NODE_TYPES.Identifier || expectCall.callee.name !== "expect" || expectCall.arguments.length !== 1) {
+        return null;
+      }
+      const actual = expectCall.arguments[0];
+      if (!isTestExpect(expectCall.callee)) return null;
+      if (actual === void 0 || actual.type !== import_utils105.AST_NODE_TYPES.MemberExpression || actual.optional) {
+        return null;
+      }
+      if (!isPureReceiver(actual.object)) {
+        return null;
+      }
+      let key;
+      let receiver;
+      if (actual.computed) {
+        const index = literalIndex(actual.property);
+        if (index === null) {
+          return null;
+        }
+        key = { kind: "index", index };
+        receiver = actual.object;
+      } else {
+        const access = propertyAccess(actual);
+        if (access === null) return null;
+        key = { kind: "property", path: access.path };
+        receiver = access.receiver;
+      }
+      return assertionExpectation(statement, call, receiver, key, matcher);
+    }
+    function isTestExpect(callee) {
+      const variable = import_utils105.ASTUtils.findVariable(sourceCode.getScope(callee), callee.name);
+      if (variable !== null && variable.defs.some((definition) => {
+        if (definition.node.type !== import_utils105.AST_NODE_TYPES.ImportSpecifier) return true;
+        const declaration = definition.node.parent;
+        const imported = definition.node.imported;
+        return declaration.type !== import_utils105.AST_NODE_TYPES.ImportDeclaration || !["vitest", "@jest/globals", "@playwright/test", "bun:test"].includes(String(declaration.source.value)) || (imported.type === import_utils105.AST_NODE_TYPES.Identifier ? imported.name : imported.value) !== "expect";
+      })) return false;
+      return true;
+    }
+    function assertionExpectation(statement, call, receiver, key, matcher) {
+      const synthetic = SYNTHETIC_LITERAL_MATCHERS.get(matcher);
+      if (synthetic !== void 0 && call.arguments.length === 0) {
+        return { statement, receiver, key, matcher, expectedText: synthetic, expectedIsLiteral: true };
+      }
+      if (!MERGEABLE_MATCHERS.has(matcher)) {
+        return null;
+      }
+      const expected = call.arguments[0];
+      if (call.arguments.length !== 1 || expected === void 0 || expected.type === import_utils105.AST_NODE_TYPES.SpreadElement) {
+        return null;
+      }
+      const literal = literalText(expected, (node) => sourceCode.getText(node));
+      return {
+        statement,
+        receiver,
+        key,
+        matcher,
+        expectedText: literal ?? sourceCode.getText(expected),
+        expectedIsLiteral: literal !== null
+      };
+    }
     return {
       BlockStatement: (node) => {
         checkBody(node.body);
@@ -21382,6 +21382,11 @@ var require_use_form_default_values_default = createRule({
       const value = unwrapExpression6(node);
       return value.type === import_utils115.AST_NODE_TYPES.UnaryExpression && value.operator === "void" || value.type === import_utils115.AST_NODE_TYPES.Identifier && value.name === "undefined" && (bindingOf(value)?.defs.length ?? 0) === 0;
     };
+    const uninitializedUseFormCall = (node) => {
+      if (node.type !== import_utils115.AST_NODE_TYPES.CallExpression || node.callee.type !== import_utils115.AST_NODE_TYPES.Identifier || importedKind(node.callee) !== "useForm") return false;
+      const options = node.arguments[0];
+      return options?.type !== import_utils115.AST_NODE_TYPES.SpreadElement && initializationState(options) === "uninitialized";
+    };
     const initializationState = (node) => {
       if (node === void 0) return "uninitialized";
       if (node.type !== import_utils115.AST_NODE_TYPES.ObjectExpression) return "unknown";
@@ -21394,11 +21399,6 @@ var require_use_form_default_values_default = createRule({
       }
       return [...initialization.values()].some(Boolean) ? "initialized" : "uninitialized";
     };
-    const uninitializedUseFormCall = (node) => {
-      if (node.type !== import_utils115.AST_NODE_TYPES.CallExpression || node.callee.type !== import_utils115.AST_NODE_TYPES.Identifier || importedKind(node.callee) !== "useForm") return false;
-      const options = node.arguments[0];
-      return options?.type !== import_utils115.AST_NODE_TYPES.SpreadElement && initializationState(options) === "uninitialized";
-    };
     const isUninitializedForm = (node) => {
       if (node.type !== import_utils115.AST_NODE_TYPES.Identifier) return false;
       const variable = bindingOf(node);
@@ -21627,28 +21627,13 @@ var require_zod_form_validation_default = createRule({
       context.sourceCode.getScope(identifier),
       identifier.name
     );
-    const isProvablyNonZodLocal = (identifier) => {
-      const binding = resolvedBinding(identifier);
-      if (binding === null || zodBindings.has(binding) || binding.defs.length !== 1) {
-        return false;
-      }
-      const definition = binding.defs[0];
-      if (definition?.type !== "Variable" || definition.node.type !== import_utils117.AST_NODE_TYPES.VariableDeclarator) {
-        return false;
-      }
-      const init = definition.node.init;
-      return init?.type === import_utils117.AST_NODE_TYPES.ObjectExpression || init?.type === import_utils117.AST_NODE_TYPES.ArrayExpression || init?.type === import_utils117.AST_NODE_TYPES.Literal || init?.type === import_utils117.AST_NODE_TYPES.ArrowFunctionExpression || init?.type === import_utils117.AST_NODE_TYPES.FunctionExpression;
-    };
-    const isZodParseCall = (node) => {
-      if (node.type !== import_utils117.AST_NODE_TYPES.CallExpression) return false;
+    const isFormDataGetCall = (node) => {
       const callee = node.callee;
-      if (callee.type !== import_utils117.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils117.AST_NODE_TYPES.Identifier || !ZOD_PARSE_METHODS.has(callee.property.name)) {
+      if (callee.type !== import_utils117.AST_NODE_TYPES.MemberExpression) return false;
+      if (callee.property.type !== import_utils117.AST_NODE_TYPES.Identifier || !FORM_VALUE_METHODS.has(callee.property.name)) {
         return false;
       }
-      const root = zodReceiverRoot(callee.object);
-      if (root === null) return false;
-      const binding = resolvedBinding(root);
-      return binding !== null && zodBindings.has(binding) || (root.name === "z" || ZOD_SCHEMA_NAME_RE.test(root.name)) && !isProvablyNonZodLocal(root);
+      return isFormSourceIdentifier(callee.object);
     };
     const isFormSourceIdentifier = (node) => {
       if (node.type !== import_utils117.AST_NODE_TYPES.Identifier) return false;
@@ -21667,14 +21652,6 @@ var require_zod_form_validation_default = createRule({
       }
       return conventionalName;
     };
-    const isFormDataGetCall = (node) => {
-      const callee = node.callee;
-      if (callee.type !== import_utils117.AST_NODE_TYPES.MemberExpression) return false;
-      if (callee.property.type !== import_utils117.AST_NODE_TYPES.Identifier || !FORM_VALUE_METHODS.has(callee.property.name)) {
-        return false;
-      }
-      return isFormSourceIdentifier(callee.object);
-    };
     const zodParseAncestor = (node) => {
       let parent = node.parent;
       while (parent !== null && parent !== void 0) {
@@ -21692,6 +21669,29 @@ var require_zod_form_validation_default = createRule({
       }
       return null;
     };
+    const isZodParseCall = (node) => {
+      if (node.type !== import_utils117.AST_NODE_TYPES.CallExpression) return false;
+      const callee = node.callee;
+      if (callee.type !== import_utils117.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils117.AST_NODE_TYPES.Identifier || !ZOD_PARSE_METHODS.has(callee.property.name)) {
+        return false;
+      }
+      const root = zodReceiverRoot(callee.object);
+      if (root === null) return false;
+      const binding = resolvedBinding(root);
+      return binding !== null && zodBindings.has(binding) || (root.name === "z" || ZOD_SCHEMA_NAME_RE.test(root.name)) && !isProvablyNonZodLocal(root);
+    };
+    const isProvablyNonZodLocal = (identifier) => {
+      const binding = resolvedBinding(identifier);
+      if (binding === null || zodBindings.has(binding) || binding.defs.length !== 1) {
+        return false;
+      }
+      const definition = binding.defs[0];
+      if (definition?.type !== "Variable" || definition.node.type !== import_utils117.AST_NODE_TYPES.VariableDeclarator) {
+        return false;
+      }
+      const init = definition.node.init;
+      return init?.type === import_utils117.AST_NODE_TYPES.ObjectExpression || init?.type === import_utils117.AST_NODE_TYPES.ArrayExpression || init?.type === import_utils117.AST_NODE_TYPES.Literal || init?.type === import_utils117.AST_NODE_TYPES.ArrowFunctionExpression || init?.type === import_utils117.AST_NODE_TYPES.FunctionExpression;
+    };
     const hasZodParseAncestor = (node) => zodParseAncestor(node) !== null;
     const isInstanceofNarrowing = (node) => {
       const parent = node.parent;
@@ -21720,28 +21720,6 @@ var require_zod_form_validation_default = createRule({
       }
       return null;
     };
-    const zodParseMethod = (call) => {
-      const callee = call.callee;
-      return callee.type === import_utils117.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils117.AST_NODE_TYPES.Identifier ? callee.property.name : null;
-    };
-    const hasConditionalAncestorBeforeStatement = (node, statement) => {
-      let current = node.parent;
-      while (current !== void 0 && current !== statement) {
-        if (current.type === import_utils117.AST_NODE_TYPES.LogicalExpression || current.type === import_utils117.AST_NODE_TYPES.ConditionalExpression) {
-          return true;
-        }
-        current = current.parent;
-      }
-      return false;
-    };
-    const isAwaitedBeforeStatement = (node, statement) => {
-      let current = node.parent;
-      while (current !== void 0 && current !== statement) {
-        if (current.type === import_utils117.AST_NODE_TYPES.AwaitExpression) return true;
-        current = current.parent;
-      }
-      return false;
-    };
     const guaranteedValidationStatement = (declarator, reference) => {
       const parse2 = zodParseAncestor(reference);
       if (parse2 === null) return null;
@@ -21760,6 +21738,28 @@ var require_zod_form_validation_default = createRule({
       }
       return null;
     };
+    const isAwaitedBeforeStatement = (node, statement) => {
+      let current = node.parent;
+      while (current !== void 0 && current !== statement) {
+        if (current.type === import_utils117.AST_NODE_TYPES.AwaitExpression) return true;
+        current = current.parent;
+      }
+      return false;
+    };
+    const hasConditionalAncestorBeforeStatement = (node, statement) => {
+      let current = node.parent;
+      while (current !== void 0 && current !== statement) {
+        if (current.type === import_utils117.AST_NODE_TYPES.LogicalExpression || current.type === import_utils117.AST_NODE_TYPES.ConditionalExpression) {
+          return true;
+        }
+        current = current.parent;
+      }
+      return false;
+    };
+    const zodParseMethod = (call) => {
+      const callee = call.callee;
+      return callee.type === import_utils117.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils117.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+    };
     const isSafePrevalidationInspection = (identifier) => {
       const parent = identifier.parent;
       if (parent.type === import_utils117.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof") {
@@ -21940,7 +21940,7 @@ var STEPDOWN_DOCUMENTATION = {
   remediation: "Consider moving the private helper below its sole caller after reviewing initialization and reflection dependencies.",
   category: "maintainability",
   limitations: [
-    "Generated and test files, cycles, dynamic or escaped references, overload targets, and helpers with multiple callers are excluded; immutable local callable aliases are followed only when every use stays in the caller.",
+    "Generated and test files, cycles, dynamic or escaped references, overload targets, and helpers with multiple callers are excluded; immutable local callable aliases are followed only when every use stays in the caller. Function bodies include nested sibling helpers.",
     "Class helpers must be private; their sole caller may be public, protected, or private.",
     "Runtime class-field, static-block, computed-member, and decorator barriers are never crossed; non-hoisted module helpers also cannot cross eager execution or unrelated initialization.",
     "This rule is report-only: reordering methods can change reflective property order, and moving module declarations can change initialization behavior or introduce temporal-dead-zone failures. Review module cycles and eager callers manually."
@@ -22083,8 +22083,9 @@ function localCallCount(context, node, owner) {
   }
   return count;
 }
-function moduleScope(context, program) {
+function declarationScope(context, program) {
   const declarations = moduleDefinitions(program);
+  if (declarations.length < 2) return;
   const counts = /* @__PURE__ */ new Map();
   for (const node of declarations) counts.set(node.name, (counts.get(node.name) ?? 0) + 1);
   const overloadNames = new Set(
@@ -22093,7 +22094,7 @@ function moduleScope(context, program) {
       return node?.type === import_utils119.AST_NODE_TYPES.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
     })
   );
-  const exported = exportedNames(program);
+  const exported = program.type === import_utils119.AST_NODE_TYPES.Program ? exportedNames(program) : /* @__PURE__ */ new Set();
   const scopeDefinitions = declarations.filter((node) => counts.get(node.name) === 1);
   const definitions = scopeDefinitions.filter(
     (definition) => !exported.has(definition.name) && !overloadNames.has(definition.name)
@@ -22104,17 +22105,17 @@ function moduleScope(context, program) {
   for (const statement of program.body) {
     runtimeBarrierPrefix.push((runtimeBarrierPrefix.at(-1) ?? 0) + (isDeferredModuleStatement(statement) ? 0 : 1));
   }
-  const statementIndex = (definition) => {
-    let current = definition.node;
-    while (current.parent !== void 0 && current.parent.type !== import_utils119.AST_NODE_TYPES.Program) current = current.parent;
-    return statementIndexes.get(current);
-  };
   const canMove = (helper, caller) => {
     if (helper.node.type === import_utils119.AST_NODE_TYPES.FunctionDeclaration) return true;
     const helperIndex = statementIndex(helper);
     const callerIndex = statementIndex(caller);
     return helperIndex !== void 0 && callerIndex !== void 0 && runtimeBarrierPrefix[callerIndex + 1] === runtimeBarrierPrefix[helperIndex + 1];
   };
+  const statementIndex = (definition) => {
+    let current = definition.node;
+    while (current.parent !== void 0 && current.parent !== program) current = current.parent;
+    return statementIndexes.get(current);
+  };
   reportMisordered(context, definitions, scopeDefinitions, calls, pinned, canMove);
 }
 function moduleCallGraph(context, scopeDefinitions) {
@@ -22215,9 +22216,38 @@ function methodKey(name, isStatic2) {
 function receiverDomain(context, object, receivers, thisIsStatic) {
   const unwrapped = unwrapExpression7(object);
   if (unwrapped.type === import_utils119.AST_NODE_TYPES.ThisExpression) return thisIsStatic;
-  if (unwrapped.type !== import_utils119.AST_NODE_TYPES.Identifier) return null;
-  const variable = import_utils119.ASTUtils.findVariable(context.sourceCode.getScope(unwrapped), unwrapped.name);
-  return variable === null ? null : receivers.get(variable) ?? null;
+  return externalReceiverDomain(context, unwrapped, receivers);
+}
+function externalReceiverDomain(context, object, receivers) {
+  const origin = receiverOrigin(context, object, receivers);
+  if (origin === null || typeof origin === "boolean") return origin;
+  if (origin.type === import_utils119.AST_NODE_TYPES.NewExpression) {
+    return receiverOrigin(context, origin.callee, receivers) === true ? false : null;
+  }
+  if (origin.type === import_utils119.AST_NODE_TYPES.ObjectExpression || origin.type === import_utils119.AST_NODE_TYPES.ArrayExpression || origin.type === import_utils119.AST_NODE_TYPES.Literal || origin.type === import_utils119.AST_NODE_TYPES.ArrowFunctionExpression || origin.type === import_utils119.AST_NODE_TYPES.FunctionExpression) return "unrelated";
+  return null;
+}
+function receiverOrigin(context, object, receivers) {
+  let current = object;
+  const seen = /* @__PURE__ */ new Set();
+  while (true) {
+    const unwrapped = unwrapExpression7(current);
+    if (unwrapped.type !== import_utils119.AST_NODE_TYPES.Identifier) return unwrapped;
+    const variable = import_utils119.ASTUtils.findVariable(context.sourceCode.getScope(unwrapped), unwrapped.name);
+    if (variable === null) return null;
+    const known = receivers.get(variable);
+    if (known !== void 0) return known;
+    const initializer = immutableInitializer(variable, seen);
+    if (initializer === null) return null;
+    current = initializer;
+  }
+}
+function immutableInitializer(variable, seen) {
+  if (seen.has(variable) || !stableVariable(variable) || variable.defs.length !== 1) return null;
+  seen.add(variable);
+  const definition = variable.defs[0];
+  if (definition?.node.type !== import_utils119.AST_NODE_TYPES.VariableDeclarator || definition.node.parent.type !== import_utils119.AST_NODE_TYPES.VariableDeclaration || definition.node.parent.kind !== "const") return null;
+  return definition.node.init;
 }
 function stableVariable(variable) {
   return !variable.references.some((reference) => reference.isWrite() && reference.init !== true);
@@ -22232,7 +22262,7 @@ function walk(node, visitorKeys, visit, nestedFunction = false) {
   const nested = nestedFunction || isFunction(node) || node.type === import_utils119.AST_NODE_TYPES.ClassDeclaration || node.type === import_utils119.AST_NODE_TYPES.ClassExpression;
   forEachAstChild(node, visitorKeys, (child) => walk(child, visitorKeys, visit, nested));
 }
-function classScope(context, node, computedReferenceNames) {
+function classScope(context, node, computedReferences) {
   const methods = node.body.body.filter(
     (member) => member.type === import_utils119.AST_NODE_TYPES.MethodDefinition
   );
@@ -22289,7 +22319,7 @@ function classScope(context, node, computedReferenceNames) {
     const collectAlias = (current, nestedFunction) => {
       if (nestedFunction || current.type !== import_utils119.AST_NODE_TYPES.VariableDeclarator || current.init === null) return;
       const domain = receiverDomain(context, current.init, receivers, method.static);
-      if (domain === null) return;
+      if (domain === null || domain === "unrelated") return;
       if (current.id.type === import_utils119.AST_NODE_TYPES.ObjectPattern) {
         pinDestructuredMembers(current.id, domain);
         return;
@@ -22314,11 +22344,12 @@ function classScope(context, node, computedReferenceNames) {
       const destructuring = receiverDestructuring(current);
       if (destructuring !== null) {
         const domain2 = receiverDomain(context, destructuring.value, receivers, method.static);
-        pinDestructuredMembers(destructuring.binding, domain2);
+        if (domain2 !== "unrelated") pinDestructuredMembers(destructuring.binding, domain2);
       }
       if (current.type !== import_utils119.AST_NODE_TYPES.MemberExpression) return;
       const domain = receiverDomain(context, current.object, receivers, method.static);
       const targetName = referencedPropertyName(current);
+      if (domain === "unrelated") return;
       if (domain === null) {
         pinNames(targetName);
         return;
@@ -22352,11 +22383,20 @@ function classScope(context, node, computedReferenceNames) {
     if (member.type === import_utils119.AST_NODE_TYPES.MethodDefinition || member.type === import_utils119.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
     walk(member, context.sourceCode.visitorKeys, (current) => {
       if (current.type !== import_utils119.AST_NODE_TYPES.MemberExpression) return;
+      if (externalReceiverDomain(context, current.object, classReceivers) === "unrelated") return;
       pinNames(referencedPropertyName(current));
     });
   }
-  for (const definition of definitions) {
-    if (computedReferenceNames.has(definition.name)) pinned.add(definition.key);
+  const externalReceivers = new Map(classReceivers);
+  for (const variable of context.sourceCode.getDeclaredVariables(node)) {
+    if (stableVariable(variable)) externalReceivers.set(variable, true);
+  }
+  for (const reference of computedReferences) {
+    if (context.sourceCode.getAncestors(reference).includes(node)) continue;
+    const domain = externalReceiverDomain(context, reference.object, externalReceivers);
+    if (domain === "unrelated") continue;
+    const name = referencedPropertyName(reference);
+    if (name !== null || domain !== null) pinNames(name, domain);
   }
   const memberIndexes = new Map(node.body.body.map((member, index) => [member, index]));
   const runtimeBarrierPrefix = [0];
@@ -22420,6 +22460,7 @@ var stepdown_default = createRule({
   create(context) {
     if (isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
     const classes = [];
+    const functionBodies = [];
     return {
       ClassDeclaration: (node) => {
         classes.push(node);
@@ -22427,13 +22468,17 @@ var stepdown_default = createRule({
       ClassExpression: (node) => {
         classes.push(node);
       },
+      "FunctionDeclaration, FunctionExpression, ArrowFunctionExpression": (node) => {
+        if (isFunction(node) && node.body?.type === import_utils119.AST_NODE_TYPES.BlockStatement) functionBodies.push(node.body);
+      },
       "Program:exit": (program) => {
-        moduleScope(context, program);
-        const computedReferenceNames = /* @__PURE__ */ new Set();
+        declarationScope(context, program);
+        for (const body2 of functionBodies) declarationScope(context, body2);
+        const computedReferences = [];
         walk(program, context.sourceCode.visitorKeys, (node) => {
-          if (node.type === import_utils119.AST_NODE_TYPES.MemberExpression && node.computed && node.property.type === import_utils119.AST_NODE_TYPES.Literal && typeof node.property.value === "string") computedReferenceNames.add(node.property.value);
+          if (node.type === import_utils119.AST_NODE_TYPES.MemberExpression && node.computed) computedReferences.push(node);
         });
-        for (const node of classes) classScope(context, node, computedReferenceNames);
+        for (const node of classes) classScope(context, node, computedReferences);
       }
     };
   }
@@ -22785,6 +22830,59 @@ function importedAssertionKind(specifier) {
 
 // src/rules/sole-export-matches-filename.ts
 var import_utils121 = require("@typescript-eslint/utils");
+
+// src/rules/_is-framework-entrypoint.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"]);
+var NEXT_COMPONENT = /^(?:src\/)?app\/(?:.*\/)?(?:page|layout|loading|not-found|template|error|global-error|default|forbidden|unauthorized)\.[jt]sx?$/u;
+var NEXT_ROUTE = /^(?:src\/)?app\/(?:.*\/)?route\.[jt]s$/u;
+function isFrameworkEntrypoint(filename, exportKey) {
+  const normalized = filename.replaceAll("\\", "/");
+  if (!/(?:^|\/)(?:app|pages)\/|(?:^|\/)(?:middleware|proxy)\.[jt]s$/u.test(normalized)) return false;
+  const owner = packageOwner(normalized);
+  if (owner === null) return false;
+  const path = (0, import_node_path2.relative)(owner.root, normalized).replaceAll("\\", "/");
+  if (declaresFramework(owner.metadata, "next") && isNextEntrypoint(path, exportKey)) return true;
+  return declaresFramework(owner.metadata, "astro") && isAstroEntrypoint(path, exportKey);
+}
+function isNextEntrypoint(path, exportKey) {
+  const privateAppFolder = /^(?:src\/)?app\/(?:.*\/)?_[^/]+\//u.test(path);
+  if (!privateAppFolder && NEXT_COMPONENT.test(path) && exportKey === "default") return true;
+  if (!privateAppFolder && NEXT_ROUTE.test(path) && HTTP_METHODS.has(exportKey)) return true;
+  if (/^(?:src\/)?pages\/.*\.[jt]sx?$/u.test(path) && exportKey === "default") return true;
+  const middleware = /^(?:src\/)?(middleware|proxy)\.[jt]s$/u.exec(path);
+  return middleware !== null && (exportKey === "default" || exportKey === middleware[1]);
+}
+function isAstroEntrypoint(path, exportKey) {
+  return (
+    // Astro pages implicitly export their rendered component, including when only a routing hook is explicit.
+    /^src\/pages\/.*\.astro$/u.test(path) || /^src\/pages\/.*\.[jt]s$/u.test(path) && (HTTP_METHODS.has(exportKey) || exportKey === "ALL") || /^src\/middleware\.[jt]s$/u.test(path) && exportKey === "onRequest"
+  );
+}
+function packageOwner(filename) {
+  let root = (0, import_node_path2.dirname)(filename);
+  while (true) {
+    try {
+      return { root, metadata: JSON.parse((0, import_node_fs2.readFileSync)((0, import_node_path2.join)(root, "package.json"), "utf8")) };
+    } catch (error) {
+      if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "ENOENT") return null;
+    }
+    const parent = (0, import_node_path2.dirname)(root);
+    if (parent === root) return null;
+    root = parent;
+  }
+}
+function declaresFramework(metadata, name) {
+  if (typeof metadata !== "object" || metadata === null) return false;
+  for (const section of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
+    const dependencies = Reflect.get(metadata, section);
+    if (typeof dependencies === "object" && dependencies !== null && typeof Reflect.get(dependencies, name) === "string") return true;
+  }
+  return false;
+}
+
+// src/rules/sole-export-matches-filename.ts
 var SOLE_EXPORT_MATCHES_FILENAME_DOCUMENTATION = {
   defaultLevel: "error",
   summary: "Make a module filename reflect its sole named public runtime export.",
@@ -22794,7 +22892,8 @@ var SOLE_EXPORT_MATCHES_FILENAME_DOCUMENTATION = {
   limitations: [
     "Framework entrypoints, generic stems covered by no-generic-single-export-module, tests, generated files, anonymous defaults, CommonJS, unresolved re-exports, and emission-dependent exports are excluded.",
     "The rule compares the primary filename stem and preserves a single private underscore prefix and conventional suffixes such as .server or .worker. Supporting types do not exempt a sole runtime export; public runtime aliases count as distinct exports.",
-    "Exported destructuring patterns are excluded rather than undercounted as public exports."
+    "Exported destructuring patterns are excluded rather than undercounted as public exports.",
+    "Next.js and Astro routing exemptions require the nearest package.json to declare the framework, a conventional entrypoint path, and its expected runtime export. Custom routing roots and pageExtensions are not inferred."
   ],
   examples: [
     { id: "matching-class", title: "Match a class and module", outcome: "no-match", files: [{ path: "src/artifact-store.ts", source: "export class ArtifactStore {}" }], focusPath: "src/artifact-store.ts", expectedCount: 0, public: true },
@@ -22804,13 +22903,6 @@ var SOLE_EXPORT_MATCHES_FILENAME_DOCUMENTATION = {
 var EXCLUDED_STEMS = /* @__PURE__ */ new Set([
   "global",
   "index",
-  "layout",
-  "loading",
-  "middleware",
-  "not-found",
-  "page",
-  "route",
-  "template",
   "types"
 ]);
 function stem3(filename) {
@@ -22835,7 +22927,7 @@ var sole_export_matches_filename_default = createRule({
   create(context) {
     const fileStem = stem3(context.filename);
     const normalizedFilename = context.filename.replaceAll("\\", "/");
-    if (EXCLUDED_STEMS.has(fileStem) || GENERIC_MODULE_STEMS.has(fileStem) || /(?:^|\/)app\/(?:.*\/)?(?:global-)?error\.[jt]sx?$/u.test(normalizedFilename) || normalizedFilename.includes("/pages/") || context.filename.endsWith(".d.ts") || isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
+    if (EXCLUDED_STEMS.has(fileStem) || GENERIC_MODULE_STEMS.has(fileStem) || context.filename.endsWith(".d.ts") || isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
     let hasCommonJsExport = false;
     return {
       "CallExpression, MemberExpression"(node) {
@@ -22847,6 +22939,7 @@ var sole_export_matches_filename_default = createRule({
         if (exports2.ambiguous || exports2.exports.length !== 1) return;
         const only = exports2.exports[0];
         if (only === void 0) return;
+        if (isFrameworkEntrypoint(normalizedFilename, only.key)) return;
         if (only.name === "onRouterTransitionStart" && /(?:^|\/)instrumentation-client\.[jt]s$/u.test(normalizedFilename)) return;
         if (only.name === "collections" && /(?:^|\/)src\/content\.config\.(?:ts|js|mjs)$/u.test(normalizedFilename) && program.body.some((statement) => statement.type === import_utils121.AST_NODE_TYPES.ImportDeclaration && statement.source.value === "astro:content")) return;
         const exportedStem = kebabCase(only.name);
@@ -23107,16 +23200,6 @@ var require_pascal_case_zod_schema_name_default = createRule({
       const binding = resolvedBinding(identifier);
       if (binding !== null) zodBindings.add(binding);
     }
-    function isZodChain(node) {
-      const root = calleeChainRoot2(node);
-      if (root === null) return false;
-      const binding = resolvedBinding(root);
-      return binding !== null && zodBindings.has(binding);
-    }
-    function isSchemaBinding(identifier) {
-      const binding = resolvedBinding(identifier);
-      return binding !== null && schemaBindings.has(binding);
-    }
     function isConfirmedSchema(expression) {
       const init = unwrapExpression8(expression);
       if (init.type === import_utils122.AST_NODE_TYPES.Identifier) return isSchemaBinding(init);
@@ -23133,6 +23216,16 @@ var require_pascal_case_zod_schema_name_default = createRule({
       const root = calleeChainRoot2(init.callee);
       return root !== null && isSchemaBinding(root) && SCHEMA_RETURNING_METHODS.has(terminal);
     }
+    function isSchemaBinding(identifier) {
+      const binding = resolvedBinding(identifier);
+      return binding !== null && schemaBindings.has(binding);
+    }
+    function isZodChain(node) {
+      const root = calleeChainRoot2(node);
+      if (root === null) return false;
+      const binding = resolvedBinding(root);
+      return binding !== null && zodBindings.has(binding);
+    }
     if (isTestFile(context.filename) || BENCHMARK_PATH_RE2.test(context.filename.replaceAll("\\", "/")) || isGeneratedFile(context.filename, context.sourceCode.text)) {
       return {};
     }
@@ -23364,7 +23457,7 @@ var RULES = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "16.0.0"
+  version: "16.1.0"
 };
 var APPLICATION_ONLY_RULES = [];
 var LIBRARY_IMPORT_POLICY = ["error", {