@sarj/eslint-plugin 2.6.0 → 2.7.0

package/dist/index.cjs

@@ -2774,13 +2774,292 @@ var no_cors_wildcard_with_credentials_default = import_utils23.ESLintUtils.RuleC
   }
 });
 
-// src/rules/no-fat-try-blocks.ts
+// src/rules/no-silent-promise-catch.ts
 var import_utils24 = require("@typescript-eslint/utils");
+
+// src/rules/_paths.ts
+var TEST_FILE_RE = /(\.(test|spec)\.)|([\\/]__tests__[\\/])/;
+var SCRIPT_FILE_RE = /([\\/]scripts[\\/])|(\.mjs$)/;
+function isTestFile(filename) {
+  return TEST_FILE_RE.test(filename);
+}
+function isScriptFile(filename) {
+  return SCRIPT_FILE_RE.test(filename);
+}
+
+// src/rules/no-silent-promise-catch.ts
+function isBodyParseCall(node) {
+  return node.type === import_utils24.AST_NODE_TYPES.CallExpression && node.arguments.length === 0 && node.callee.type === import_utils24.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils24.AST_NODE_TYPES.Identifier && (node.callee.property.name === "json" || node.callee.property.name === "text");
+}
+function isSilentExpression(node) {
+  switch (node.type) {
+    case import_utils24.AST_NODE_TYPES.Literal:
+      return !("regex" in node);
+    case import_utils24.AST_NODE_TYPES.Identifier:
+      return node.name === "undefined";
+    case import_utils24.AST_NODE_TYPES.UnaryExpression:
+      return node.operator === "void" && node.argument.type === import_utils24.AST_NODE_TYPES.Literal;
+    case import_utils24.AST_NODE_TYPES.ObjectExpression:
+      return node.properties.length === 0;
+    case import_utils24.AST_NODE_TYPES.ArrayExpression:
+      return node.elements.length === 0;
+    case import_utils24.AST_NODE_TYPES.TSAsExpression:
+      return isSilentExpression(node.expression);
+    default:
+      return false;
+  }
+}
+function isSilentHandler(handler) {
+  const body = handler.body;
+  if (body.type !== import_utils24.AST_NODE_TYPES.BlockStatement) {
+    return isSilentExpression(body);
+  }
+  if (body.body.length === 0) {
+    return true;
+  }
+  if (body.body.length === 1) {
+    const only = body.body[0];
+    if (only !== void 0 && only.type === import_utils24.AST_NODE_TYPES.ReturnStatement) {
+      return only.argument === null || isSilentExpression(only.argument);
+    }
+  }
+  return false;
+}
+var no_silent_promise_catch_default = import_utils24.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "no-silent-promise-catch",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow `.catch()` handlers that silently swallow the rejection (e.g. `.catch(() => null)`); log, rethrow, or handle the error."
+    },
+    schema: [],
+    messages: {
+      silentCatch: "This `.catch()` swallows the rejection without logging, rethrowing, or handling it \u2014 failures become invisible and callers get an indistinguishable sentinel. Log the error (and only then map to a fallback), or let it propagate."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    if (isTestFile(context.filename)) {
+      return {};
+    }
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== import_utils24.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.property.type !== import_utils24.AST_NODE_TYPES.Identifier || node.callee.property.name !== "catch") {
+          return;
+        }
+        if (isBodyParseCall(node.callee.object)) {
+          return;
+        }
+        if (node.arguments.length !== 1) {
+          return;
+        }
+        const handler = node.arguments[0];
+        if (handler === void 0 || handler.type !== import_utils24.AST_NODE_TYPES.ArrowFunctionExpression && handler.type !== import_utils24.AST_NODE_TYPES.FunctionExpression) {
+          return;
+        }
+        if (isSilentHandler(handler)) {
+          context.report({ node, messageId: "silentCatch" });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/require-fetch-timeout.ts
+var import_utils25 = require("@typescript-eslint/utils");
+var GLOBAL_OBJECTS = /* @__PURE__ */ new Set([
+  "globalThis",
+  "window",
+  "self"
+]);
+function matchesAnyPattern2(filename, patterns) {
+  for (const pattern of patterns) {
+    const regexSource = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "::DOUBLESTAR::").replace(/\*/g, "[^/\\\\]*").replace(/::DOUBLESTAR::/g, ".*");
+    if (new RegExp(`^${regexSource}$`).test(filename)) {
+      return true;
+    }
+  }
+  return false;
+}
+function initProvablyLacksSignal(init) {
+  if (init.type !== import_utils25.AST_NODE_TYPES.ObjectExpression) {
+    return false;
+  }
+  for (const prop of init.properties) {
+    if (prop.type === import_utils25.AST_NODE_TYPES.SpreadElement) {
+      return false;
+    }
+    if (prop.key.type === import_utils25.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils25.AST_NODE_TYPES.Literal && prop.key.value === "signal") {
+      return false;
+    }
+    if (prop.computed) {
+      return false;
+    }
+  }
+  return true;
+}
+function isStringish(node) {
+  return node.type === import_utils25.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils25.AST_NODE_TYPES.TemplateLiteral;
+}
+var require_fetch_timeout_default = import_utils25.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "require-fetch-timeout",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require an abort `signal` (e.g. `AbortSignal.timeout(ms)`) on global `fetch()` calls so stalled upstreams cannot hang the caller forever."
+    },
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          allowIn: {
+            description: "Glob patterns for wrapper modules exempt from the rule. Matched against the ABSOLUTE file path, so anchor with a `**/` prefix (e.g. `**/http-client.ts`).",
+            type: "array",
+            items: { type: "string" }
+          }
+        }
+      }
+    ],
+    messages: {
+      missingSignal: "This `fetch()` has no abort `signal` \u2014 a stalled upstream will hang it forever. Pass `{ signal: AbortSignal.timeout(ms) }` or a signal from an AbortController."
+    }
+  },
+  defaultOptions: [{}],
+  create(context, [optionsArg]) {
+    if (isTestFile(context.filename) || isScriptFile(context.filename)) {
+      return {};
+    }
+    const allowIn = optionsArg?.allowIn ?? [];
+    if (allowIn.length > 0 && matchesAnyPattern2(context.filename, allowIn)) {
+      return {};
+    }
+    function resolvesToGlobal(identifier) {
+      const scope = context.sourceCode.getScope(identifier);
+      const variable = import_utils25.ASTUtils.findVariable(scope, identifier.name);
+      return variable === null || variable.defs.length === 0;
+    }
+    function isGlobalFetchCall(callee) {
+      if (callee.type === import_utils25.AST_NODE_TYPES.Identifier) {
+        return callee.name === "fetch" && resolvesToGlobal(callee);
+      }
+      return callee.type === import_utils25.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils25.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils25.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS.has(callee.object.name) && resolvesToGlobal(callee.object);
+    }
+    return {
+      CallExpression(node) {
+        if (!isGlobalFetchCall(node.callee)) {
+          return;
+        }
+        const [first, init] = node.arguments;
+        if (node.arguments.length === 1 && first !== void 0 && !isStringish(first)) {
+          return;
+        }
+        if (init === void 0 || initProvablyLacksSignal(init)) {
+          context.report({ node, messageId: "missingSignal" });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/require-schema-validate-search.ts
+var import_utils26 = require("@typescript-eslint/utils");
+var VALIDATOR_METHODS = /* @__PURE__ */ new Set([
+  "parse",
+  "safeParse",
+  "decode"
+]);
+function isConstTypeAnnotation(typeAnnotation) {
+  return typeAnnotation.type === import_utils26.AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeName.type === import_utils26.AST_NODE_TYPES.Identifier && typeAnnotation.typeName.name === "const";
+}
+function isValidatorCall(node) {
+  return node.callee.type === import_utils26.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils26.AST_NODE_TYPES.Identifier && VALIDATOR_METHODS.has(node.callee.property.name);
+}
+function findCastExpression(node, insideValidatorArg) {
+  if ((node.type === import_utils26.AST_NODE_TYPES.TSAsExpression || node.type === import_utils26.AST_NODE_TYPES.TSTypeAssertion) && !isConstTypeAnnotation(node.typeAnnotation) && !insideValidatorArg) {
+    return node;
+  }
+  if (node.type === import_utils26.AST_NODE_TYPES.CallExpression && isValidatorCall(node)) {
+    const inCallee = findCastExpression(node.callee, insideValidatorArg);
+    if (inCallee !== null) {
+      return inCallee;
+    }
+    for (const arg of node.arguments) {
+      const found = findCastExpression(arg, true);
+      if (found !== null) {
+        return found;
+      }
+    }
+    return null;
+  }
+  for (const key of Object.keys(node)) {
+    if (key === "parent") {
+      continue;
+    }
+    const value = node[key];
+    const children = Array.isArray(value) ? value : [value];
+    for (const child of children) {
+      if (child !== null && typeof child === "object" && "type" in child && typeof child.type === "string") {
+        const found = findCastExpression(
+          child,
+          insideValidatorArg
+        );
+        if (found !== null) {
+          return found;
+        }
+      }
+    }
+  }
+  return null;
+}
+var require_schema_validate_search_default = import_utils26.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "require-schema-validate-search",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow `as` casts inside hand-rolled `validateSearch` functions; use a schema validator (e.g. zodValidator) so search params are validated at runtime."
+    },
+    schema: [],
+    messages: {
+      castInValidateSearch: "This `validateSearch` asserts the search-param shape with `as` instead of validating it \u2014 malformed query params flow through typed as clean data. Use a schema validator (e.g. `zodValidator(searchSchema)` or `searchSchema.parse`) instead of casting."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    if (isTestFile(context.filename)) {
+      return {};
+    }
+    return {
+      Property(node) {
+        const isValidateSearchKey = !node.computed && node.key.type === import_utils26.AST_NODE_TYPES.Identifier && node.key.name === "validateSearch" || node.key.type === import_utils26.AST_NODE_TYPES.Literal && node.key.value === "validateSearch";
+        if (!isValidateSearchKey) {
+          return;
+        }
+        if (node.value.type !== import_utils26.AST_NODE_TYPES.ArrowFunctionExpression && node.value.type !== import_utils26.AST_NODE_TYPES.FunctionExpression) {
+          return;
+        }
+        const cast = findCastExpression(node.value.body, false);
+        if (cast !== null) {
+          context.report({ node: cast, messageId: "castInValidateSearch" });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-fat-try-blocks.ts
+var import_utils27 = require("@typescript-eslint/utils");
 var MAX_TRY_BODY_STATEMENTS = 3;
 var NESTED_FUNCTION_TYPES = /* @__PURE__ */ new Set([
-  import_utils24.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils24.AST_NODE_TYPES.FunctionExpression,
-  import_utils24.AST_NODE_TYPES.ArrowFunctionExpression
+  import_utils27.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils27.AST_NODE_TYPES.FunctionExpression,
+  import_utils27.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 var PURE_METHODS = /* @__PURE__ */ new Set([
   "map",
@@ -2878,20 +3157,20 @@ function isNode4(value) {
 }
 function isPureCall(node) {
   const callee = node.callee;
-  if (callee.type !== import_utils24.AST_NODE_TYPES.MemberExpression) {
+  if (callee.type !== import_utils27.AST_NODE_TYPES.MemberExpression) {
     return false;
   }
   const property = callee.property;
-  if (property.type !== import_utils24.AST_NODE_TYPES.Identifier) {
+  if (property.type !== import_utils27.AST_NODE_TYPES.Identifier) {
     return false;
   }
-  if (callee.object.type === import_utils24.AST_NODE_TYPES.Identifier && PURE_NAMESPACES.has(callee.object.name)) {
+  if (callee.object.type === import_utils27.AST_NODE_TYPES.Identifier && PURE_NAMESPACES.has(callee.object.name)) {
     return true;
   }
   return PURE_METHODS.has(property.name);
 }
 function isPureNew(node) {
-  return node.callee.type === import_utils24.AST_NODE_TYPES.Identifier && PURE_CONSTRUCTORS.has(node.callee.name);
+  return node.callee.type === import_utils27.AST_NODE_TYPES.Identifier && PURE_CONSTRUCTORS.has(node.callee.name);
 }
 function subtreeMatches(stmt, predicate) {
   let found = false;
@@ -2928,14 +3207,14 @@ function subtreeMatches(stmt, predicate) {
   visit(stmt);
   return found;
 }
-var hasAwait = (stmt) => subtreeMatches(stmt, (n) => n.type === import_utils24.AST_NODE_TYPES.AwaitExpression);
+var hasAwait = (stmt) => subtreeMatches(stmt, (n) => n.type === import_utils27.AST_NODE_TYPES.AwaitExpression);
 var hasThrowingCallOrNew = (stmt) => subtreeMatches(
   stmt,
-  (n) => n.type === import_utils24.AST_NODE_TYPES.CallExpression && !isPureCall(n) || n.type === import_utils24.AST_NODE_TYPES.NewExpression && !isPureNew(n)
+  (n) => n.type === import_utils27.AST_NODE_TYPES.CallExpression && !isPureCall(n) || n.type === import_utils27.AST_NODE_TYPES.NewExpression && !isPureNew(n)
 );
 function unwrap2(expr) {
   let current = expr;
-  while (current.type === import_utils24.AST_NODE_TYPES.ChainExpression || current.type === import_utils24.AST_NODE_TYPES.TSNonNullExpression) {
+  while (current.type === import_utils27.AST_NODE_TYPES.ChainExpression || current.type === import_utils27.AST_NODE_TYPES.TSNonNullExpression) {
     current = current.expression;
   }
   return current;
@@ -2944,7 +3223,7 @@ function canThrow(stmt) {
   if (hasAwait(stmt)) {
     return true;
   }
-  if (stmt.type === import_utils24.AST_NODE_TYPES.ExpressionStatement && unwrap2(stmt.expression).type === import_utils24.AST_NODE_TYPES.CallExpression) {
+  if (stmt.type === import_utils27.AST_NODE_TYPES.ExpressionStatement && unwrap2(stmt.expression).type === import_utils27.AST_NODE_TYPES.CallExpression) {
     return false;
   }
   return hasThrowingCallOrNew(stmt);
@@ -2955,9 +3234,9 @@ function handlerRethrows(handler) {
   }
   const body = handler.body.body;
   const last = body[body.length - 1];
-  return last !== void 0 && last.type === import_utils24.AST_NODE_TYPES.ThrowStatement;
+  return last !== void 0 && last.type === import_utils27.AST_NODE_TYPES.ThrowStatement;
 }
-var no_fat_try_blocks_default = import_utils24.ESLintUtils.RuleCreator(
+var no_fat_try_blocks_default = import_utils27.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-fat-try-blocks",
@@ -2998,7 +3277,7 @@ var no_fat_try_blocks_default = import_utils24.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-secret-in-log.ts
-var import_utils25 = require("@typescript-eslint/utils");
+var import_utils28 = require("@typescript-eslint/utils");
 var LOG_METHODS2 = /* @__PURE__ */ new Set([
   "debug",
   "info",
@@ -3196,7 +3475,7 @@ function propertyKeyName2(prop) {
   }
   return null;
 }
-var no_secret_in_log_default = import_utils25.ESLintUtils.RuleCreator(
+var no_secret_in_log_default = import_utils28.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-secret-in-log",
@@ -3264,15 +3543,15 @@ var no_secret_in_log_default = import_utils25.ESLintUtils.RuleCreator(
 });
 
 // src/rules/no-unsafe-cast.ts
-var import_utils26 = require("@typescript-eslint/utils");
-var import_utils27 = require("@typescript-eslint/utils");
+var import_utils29 = require("@typescript-eslint/utils");
+var import_utils30 = require("@typescript-eslint/utils");
 function isAnyAnnotation(node) {
-  return node.type === import_utils27.AST_NODE_TYPES.TSAnyKeyword;
+  return node.type === import_utils30.AST_NODE_TYPES.TSAnyKeyword;
 }
 function isConstAssertion(typeAnnotation) {
-  return typeAnnotation.type === import_utils27.AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeName.type === import_utils27.AST_NODE_TYPES.Identifier && typeAnnotation.typeName.name === "const";
+  return typeAnnotation.type === import_utils30.AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeName.type === import_utils30.AST_NODE_TYPES.Identifier && typeAnnotation.typeName.name === "const";
 }
-var no_unsafe_cast_default = import_utils26.ESLintUtils.RuleCreator(
+var no_unsafe_cast_default = import_utils29.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "no-unsafe-cast",
@@ -3298,7 +3577,7 @@ var no_unsafe_cast_default = import_utils26.ESLintUtils.RuleCreator(
         return;
       }
       const inner = node.expression;
-      if (inner.type === import_utils27.AST_NODE_TYPES.TSAsExpression || inner.type === import_utils27.AST_NODE_TYPES.TSTypeAssertion) {
+      if (inner.type === import_utils30.AST_NODE_TYPES.TSAsExpression || inner.type === import_utils30.AST_NODE_TYPES.TSTypeAssertion) {
         context.report({ node, messageId: "doubleCast" });
       }
     }
@@ -3310,7 +3589,7 @@ var no_unsafe_cast_default = import_utils26.ESLintUtils.RuleCreator(
 });
 
 // src/rules/prefer-string-literal-union.ts
-var import_utils28 = require("@typescript-eslint/utils");
+var import_utils31 = require("@typescript-eslint/utils");
 var ts = __toESM(require("typescript"), 1);
 var CHOICE_TOKENS = /* @__PURE__ */ new Set([
   "status",
@@ -3353,19 +3632,19 @@ function isChoiceLikeName(name) {
   return CHOICE_TOKENS.has(lastWord(name));
 }
 function keyName(key) {
-  if (key.type === import_utils28.AST_NODE_TYPES.Identifier) {
+  if (key.type === import_utils31.AST_NODE_TYPES.Identifier) {
     return key.name;
   }
-  if (key.type === import_utils28.AST_NODE_TYPES.Literal && typeof key.value === "string") {
+  if (key.type === import_utils31.AST_NODE_TYPES.Literal && typeof key.value === "string") {
     return key.value;
   }
   return null;
 }
 function isStringLiteralMember(t) {
-  return t.type === import_utils28.AST_NODE_TYPES.TSLiteralType && t.literal.type === import_utils28.AST_NODE_TYPES.Literal && typeof t.literal.value === "string";
+  return t.type === import_utils31.AST_NODE_TYPES.TSLiteralType && t.literal.type === import_utils31.AST_NODE_TYPES.Literal && typeof t.literal.value === "string";
 }
 function isStringLiteralUnion(node) {
-  if (node?.type !== import_utils28.AST_NODE_TYPES.TSUnionType) {
+  if (node?.type !== import_utils31.AST_NODE_TYPES.TSUnionType) {
     return false;
   }
   return node.types.filter(isStringLiteralMember).length >= MIN_CLUSTER_SIZE;
@@ -3394,12 +3673,12 @@ function bindingSourceExpression(decl) {
   return ts.isForOfStatement(node) ? node.expression : node.initializer;
 }
 function refKey(node) {
-  if (node.type === import_utils28.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils31.AST_NODE_TYPES.Identifier) {
     return node.name;
   }
-  if (node.type === import_utils28.AST_NODE_TYPES.MemberExpression && !node.computed) {
+  if (node.type === import_utils31.AST_NODE_TYPES.MemberExpression && !node.computed) {
     const inner = refKey(node.object);
-    if (inner === null || node.property.type !== import_utils28.AST_NODE_TYPES.Identifier) {
+    if (inner === null || node.property.type !== import_utils31.AST_NODE_TYPES.Identifier) {
       return null;
     }
     return `${inner}.${node.property.name}`;
@@ -3407,12 +3686,12 @@ function refKey(node) {
   return null;
 }
 function strLiteral(node) {
-  if (node.type === import_utils28.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+  if (node.type === import_utils31.AST_NODE_TYPES.Literal && typeof node.value === "string") {
     return node.value;
   }
   return null;
 }
-var prefer_string_literal_union_default = import_utils28.ESLintUtils.RuleCreator(
+var prefer_string_literal_union_default = import_utils31.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "prefer-string-literal-union",
@@ -3436,7 +3715,7 @@ var prefer_string_literal_union_default = import_utils28.ESLintUtils.RuleCreator
     }
     let services;
     try {
-      services = import_utils28.ESLintUtils.getParserServices(context);
+      services = import_utils31.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
@@ -3520,7 +3799,7 @@ var prefer_string_literal_union_default = import_utils28.ESLintUtils.RuleCreator
         containersWithUnion.add(container);
         return;
       }
-      if (typeNode?.type !== import_utils28.AST_NODE_TYPES.TSStringKeyword) {
+      if (typeNode?.type !== import_utils31.AST_NODE_TYPES.TSStringKeyword) {
         return;
       }
       const name = keyName(key);
@@ -3608,10 +3887,10 @@ var prefer_string_literal_union_default = import_utils28.ESLintUtils.RuleCreator
       }
     };
     function refKeyText(node) {
-      if (node.type === import_utils28.AST_NODE_TYPES.BinaryExpression) {
+      if (node.type === import_utils31.AST_NODE_TYPES.BinaryExpression) {
         return refKey(node.left) ?? refKey(node.right) ?? "value";
       }
-      if (node.type === import_utils28.AST_NODE_TYPES.SwitchStatement) {
+      if (node.type === import_utils31.AST_NODE_TYPES.SwitchStatement) {
         return refKey(node.discriminant) ?? "value";
       }
       return "value";
@@ -3620,7 +3899,7 @@ var prefer_string_literal_union_default = import_utils28.ESLintUtils.RuleCreator
 });
 
 // src/rules/single-public-export.ts
-var import_utils29 = require("@typescript-eslint/utils");
+var import_utils32 = require("@typescript-eslint/utils");
 var JUNK_DRAWER_STEMS = /* @__PURE__ */ new Set([
   "util",
   "utils",
@@ -3643,7 +3922,7 @@ var ACRONYM_OVERRIDES = [
   [/gRPC/g, "Grpc"]
 ];
 var CAMEL_BOUNDARY_RE = /(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/g;
-var TEST_FILE_RE = /\.(test|spec)\.[cm]?[jt]sx?$/i;
+var TEST_FILE_RE2 = /\.(test|spec)\.[cm]?[jt]sx?$/i;
 var SCRIPT_EXT_RE = /\.[cm]?[jt]sx?$/i;
 var basename = (filename) => filename.split(/[/\\]/).pop() ?? filename;
 var stemOf = (base) => base.replace(SCRIPT_EXT_RE, "");
@@ -3654,12 +3933,12 @@ var kebabCase2 = (name) => {
   }
   return normalized.replace(CAMEL_BOUNDARY_RE, "-").toLowerCase();
 };
-var isFunctionExpression = (node) => node !== null && (node.type === import_utils29.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils29.AST_NODE_TYPES.FunctionExpression);
+var isFunctionExpression = (node) => node !== null && (node.type === import_utils32.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils32.AST_NODE_TYPES.FunctionExpression);
 var functionConstName = (decl) => {
   if (decl.declarations.length !== 1) return null;
   const [declarator] = decl.declarations;
   if (declarator === void 0) return null;
-  if (declarator.id.type !== import_utils29.AST_NODE_TYPES.Identifier) return null;
+  if (declarator.id.type !== import_utils32.AST_NODE_TYPES.Identifier) return null;
   if (!isFunctionExpression(declarator.init)) return null;
   return declarator.id.name;
 };
@@ -3673,20 +3952,20 @@ var summarizeExports = (body) => {
   };
   for (const statement of body) {
     switch (statement.type) {
-      case import_utils29.AST_NODE_TYPES.ExportAllDeclaration:
+      case import_utils32.AST_NODE_TYPES.ExportAllDeclaration:
         hasReExport = true;
         break;
-      case import_utils29.AST_NODE_TYPES.ExportDefaultDeclaration: {
+      case import_utils32.AST_NODE_TYPES.ExportDefaultDeclaration: {
         names += 1;
         const decl = statement.declaration;
-        if (decl.type === import_utils29.AST_NODE_TYPES.FunctionDeclaration && decl.id !== null) {
+        if (decl.type === import_utils32.AST_NODE_TYPES.FunctionDeclaration && decl.id !== null) {
           candidate = { name: decl.id.name, node: statement };
-        } else if (decl.type === import_utils29.AST_NODE_TYPES.ClassDeclaration && decl.id !== null) {
+        } else if (decl.type === import_utils32.AST_NODE_TYPES.ClassDeclaration && decl.id !== null) {
           candidate = { name: decl.id.name, node: statement };
         }
         break;
       }
-      case import_utils29.AST_NODE_TYPES.ExportNamedDeclaration: {
+      case import_utils32.AST_NODE_TYPES.ExportNamedDeclaration: {
         if (statement.source !== null) {
           hasReExport = true;
           break;
@@ -3697,15 +3976,15 @@ var summarizeExports = (body) => {
           break;
         }
         switch (decl.type) {
-          case import_utils29.AST_NODE_TYPES.FunctionDeclaration:
+          case import_utils32.AST_NODE_TYPES.FunctionDeclaration:
             if (decl.id !== null) addCandidate(decl.id.name, statement);
             else names += 1;
             break;
-          case import_utils29.AST_NODE_TYPES.ClassDeclaration:
+          case import_utils32.AST_NODE_TYPES.ClassDeclaration:
             if (decl.id !== null) addCandidate(decl.id.name, statement);
             else names += 1;
             break;
-          case import_utils29.AST_NODE_TYPES.VariableDeclaration: {
+          case import_utils32.AST_NODE_TYPES.VariableDeclaration: {
             const fnName = functionConstName(decl);
             if (fnName !== null && decl.declarations.length === 1) {
               addCandidate(fnName, statement);
@@ -3725,7 +4004,7 @@ var summarizeExports = (body) => {
   }
   return { names, hasReExport, candidate };
 };
-var single_public_export_default = import_utils29.ESLintUtils.RuleCreator(
+var single_public_export_default = import_utils32.ESLintUtils.RuleCreator(
   (name) => `https://github.com/sarj-ai/standards/blob/main/packages/typescript/src/rules/${name}.ts`
 )({
   name: "single-public-export",
@@ -3743,7 +4022,7 @@ var single_public_export_default = import_utils29.ESLintUtils.RuleCreator(
   create(context) {
     const base = basename(context.filename);
     if (base.endsWith(".d.ts")) return {};
-    if (TEST_FILE_RE.test(base)) return {};
+    if (TEST_FILE_RE2.test(base)) return {};
     const stem = stemOf(base);
     if (!JUNK_DRAWER_STEMS.has(stem.toLowerCase())) return {};
     return {
@@ -3791,12 +4070,15 @@ var rules = {
   "no-secret-in-log": no_secret_in_log_default,
   "no-unsafe-cast": no_unsafe_cast_default,
   "prefer-string-literal-union": prefer_string_literal_union_default,
-  "single-public-export": single_public_export_default
+  "single-public-export": single_public_export_default,
+  "no-silent-promise-catch": no_silent_promise_catch_default,
+  "require-fetch-timeout": require_fetch_timeout_default,
+  "require-schema-validate-search": require_schema_validate_search_default
 };
 var plugin = {
   meta: {
     name: "@sarj/eslint-plugin",
-    version: "2.6.0"
+    version: "2.7.0"
   },
   rules,
   configs: {
@@ -3828,7 +4110,11 @@ var plugin = {
         "@sarj/no-secret-in-log": "warn",
         "@sarj/no-unsafe-cast": "warn",
         "@sarj/single-public-export": "warn",
-        "@sarj/prefer-string-literal-union": "warn"
+        "@sarj/prefer-string-literal-union": "warn",
+        // Mined from 2y of PR review feedback + 5-repo code-smell audit (2026-07).
+        "@sarj/require-fetch-timeout": "warn",
+        "@sarj/no-silent-promise-catch": "warn",
+        "@sarj/require-schema-validate-search": "warn"
       }
     },
     strict: {
@@ -3864,7 +4150,11 @@ var plugin = {
         "@sarj/no-unsafe-cast": "warn",
         "@sarj/single-public-export": "error",
         // High-volume/stylistic — warn until rollout proves FP rate.
-        "@sarj/prefer-string-literal-union": "warn"
+        "@sarj/prefer-string-literal-union": "warn",
+        // Mined from 2y of PR review feedback + 5-repo code-smell audit (2026-07).
+        "@sarj/require-fetch-timeout": "error",
+        "@sarj/no-silent-promise-catch": "error",
+        "@sarj/require-schema-validate-search": "error"
       }
     }
   }